Merge branch 'master' into master

1 files changed, 88 insertions, 45 deletions

diff --git a/toolsrc/src/commands_build.cpp b/toolsrc/src/commands_build.cpp
index 743be216a..ec4124922 100644
--- a/toolsrc/src/commands_build.cpp
+++ b/toolsrc/src/commands_build.cpp
@@ -8,7 +8,7 @@
 #include "vcpkg_System.h"
 #include "vcpkg_Environment.h"
 #include "metrics.h"
-#include "vcpkg_info.h"
+#include "vcpkg_Enums.h"
 
 namespace vcpkg::Commands::Build
 {
@@ -24,10 +24,18 @@ namespace vcpkg::Commands::Build
         std::ofstream(binary_control_file) << bpgh;
     }
 
-    void build_package(const SourceParagraph& source_paragraph, const package_spec& spec, const vcpkg_paths& paths, const fs::path& port_dir)
+    BuildResult build_package(const SourceParagraph& source_paragraph, const package_spec& spec, const vcpkg_paths& paths, const fs::path& port_dir, const StatusParagraphs& status_db)
     {
-        Checks::check_exit(spec.name() == source_paragraph.name, "inconsistent arguments to build_internal()");
+        Checks::check_exit(spec.name() == source_paragraph.name, "inconsistent arguments to build_package()");
+
         const triplet& target_triplet = spec.target_triplet();
+        for (auto&& dep : source_paragraph.depends)
+        {
+            if (status_db.find_installed(dep.name, target_triplet) == status_db.end())
+            {
+                return BuildResult::CASCADED_DUE_TO_MISSING_DEPENDENCIES;
+            }
+        }
 
         const fs::path ports_cmake_script_path = paths.ports_cmake;
         const Environment::vcvarsall_and_platform_toolset vcvarsall_bat = Environment::get_vcvarsall_bat(paths);
@@ -48,71 +56,91 @@ namespace vcpkg::Commands::Build
 
         if (return_code != 0)
         {
-            System::println(System::color::error, "Error: building package %s failed", spec.toString());
-            System::println("Please ensure sure you're using the latest portfiles with `.\\vcpkg update`, then\n"
-                            "submit an issue at https://github.com/Microsoft/vcpkg/issues including:\n"
-                            "  Package: %s\n"
-                            "  Vcpkg version: %s\n"
-                            "\n"
-                            "Additionally, attach any relevant sections from the log files above."
-                            , spec.toString(), Info::version());
             TrackProperty("error", "build failed");
             TrackProperty("build_error", spec.toString());
-            exit(EXIT_FAILURE);
+            return BuildResult::BUILD_FAILED;
         }
 
-        PostBuildLint::perform_all_checks(spec, paths);
+        const size_t error_count = PostBuildLint::perform_all_checks(spec, paths);
+
+        if (error_count != 0)
+        {
+            return BuildResult::POST_BUILD_CHECKS_FAILED;
+        }
 
         create_binary_control_file(paths, source_paragraph, target_triplet);
 
         // const fs::path port_buildtrees_dir = paths.buildtrees / spec.name;
         // delete_directory(port_buildtrees_dir);
+
+        return BuildResult::SUCCEEDED;
     }
 
-    void perform_and_exit(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths, const triplet& default_target_triplet)
+    const std::string& to_string(const BuildResult build_result)
     {
-        static const std::string example = Commands::Help::create_example_string("build zlib:x64-windows");
+        static const std::string NULLVALUE_STRING = Enums::nullvalue_toString("vcpkg::Commands::Build::BuildResult");
+        static const std::string SUCCEEDED_STRING = "SUCCEEDED";
+        static const std::string BUILD_FAILED_STRING = "BUILD_FAILED";
+        static const std::string POST_BUILD_CHECKS_FAILED_STRING = "POST_BUILD_CHECKS_FAILED";
+        static const std::string CASCADED_DUE_TO_MISSING_DEPENDENCIES_STRING = "CASCADED_DUE_TO_MISSING_DEPENDENCIES";
 
-        // Installing multiple packages leads to unintuitive behavior if one of them depends on another.
-        // Allowing only 1 package for now.
-
-        args.check_exact_arg_count(1, example);
+        switch (build_result)
+        {
+            case BuildResult::NULLVALUE: return NULLVALUE_STRING;
+            case BuildResult::SUCCEEDED: return SUCCEEDED_STRING;
+            case BuildResult::BUILD_FAILED: return BUILD_FAILED_STRING;
+            case BuildResult::POST_BUILD_CHECKS_FAILED: return POST_BUILD_CHECKS_FAILED_STRING;
+            case BuildResult::CASCADED_DUE_TO_MISSING_DEPENDENCIES: return CASCADED_DUE_TO_MISSING_DEPENDENCIES_STRING;
+            default: Checks::unreachable();
+        }
+    }
 
-        StatusParagraphs status_db = database_load_check(paths);
+    std::string create_error_message(const BuildResult build_result, const package_spec& spec)
+    {
+        return Strings::format("Error: Building package %s failed with: %s", spec.toString(), Build::to_string(build_result));
+    }
 
-        const package_spec spec = Input::check_and_get_package_spec(args.command_arguments.at(0), default_target_triplet, example);
-        Input::check_triplet(spec.target_triplet(), paths);
+    std::string create_user_troubleshooting_message(const package_spec& spec)
+    {
+        return Strings::format("Please ensure sure you're using the latest portfiles with `.\\vcpkg update`, then\n"
+                               "submit an issue at https://github.com/Microsoft/vcpkg/issues including:\n"
+                               "  Package: %s\n"
+                               "  Vcpkg version: %s\n"
+                               "\n"
+                               "Additionally, attach any relevant sections from the log files above."
+                               , spec.toString(), Version::version());
+    }
 
-        const std::unordered_set<std::string> options = args.check_and_get_optional_command_arguments({OPTION_CHECKS_ONLY});
+    void perform_and_exit(const package_spec& spec, const fs::path& port_dir, const std::unordered_set<std::string>& options, const vcpkg_paths& paths)
+    {
         if (options.find(OPTION_CHECKS_ONLY) != options.end())
         {
-            PostBuildLint::perform_all_checks(spec, paths);
+            const size_t error_count = PostBuildLint::perform_all_checks(spec, paths);
+            if (error_count > 0)
+            {
+                exit(EXIT_FAILURE);
+            }
             exit(EXIT_SUCCESS);
         }
 
-        // Explicitly load and use the portfile's build dependencies when resolving the build command (instead of a cached package's dependencies).
-        const expected<SourceParagraph> maybe_spgh = try_load_port(paths, spec.name());
+        const expected<SourceParagraph> maybe_spgh = try_load_port(port_dir);
         Checks::check_exit(!maybe_spgh.error_code(), "Could not find package named %s: %s", spec, maybe_spgh.error_code().message());
         const SourceParagraph& spgh = *maybe_spgh.get();
 
-        const std::vector<std::string> first_level_deps = filter_dependencies(spgh.depends, spec.target_triplet());
-
-        std::vector<package_spec> first_level_deps_specs;
-        for (const std::string& dep : first_level_deps)
-        {
-            first_level_deps_specs.push_back(package_spec::from_name_and_triplet(dep, spec.target_triplet()).get_or_throw());
-        }
-
-        std::vector<package_spec_with_install_plan> unmet_dependencies = Dependencies::create_install_plan(paths, first_level_deps_specs, status_db);
-        unmet_dependencies.erase(
-            std::remove_if(unmet_dependencies.begin(), unmet_dependencies.end(), [](const package_spec_with_install_plan& p)
-                           {
-                               return p.plan.plan_type == install_plan_type::ALREADY_INSTALLED;
-                           }),
-            unmet_dependencies.end());
-
-        if (!unmet_dependencies.empty())
+        Environment::ensure_utilities_on_path(paths);
+        StatusParagraphs status_db = database_load_check(paths);
+        const BuildResult result = build_package(spgh, spec, paths, paths.port_dir(spec), status_db);
+        if (result == BuildResult::CASCADED_DUE_TO_MISSING_DEPENDENCIES)
         {
+            std::vector<package_spec_with_install_plan> unmet_dependencies = Dependencies::create_install_plan(paths, { spec }, status_db);
+            unmet_dependencies.erase(
+                std::remove_if(unmet_dependencies.begin(), unmet_dependencies.end(), [&spec](const package_spec_with_install_plan& p)
+                               {
+                                   return (p.spec == spec) || (p.plan.plan_type == install_plan_type::ALREADY_INSTALLED);
+                               }),
+                unmet_dependencies.end());
+
+            Checks::check_exit(!unmet_dependencies.empty());
             System::println(System::color::error, "The build command requires all dependencies to be already installed.");
             System::println("The following dependencies are missing:");
             System::println("");
@@ -124,8 +152,23 @@ namespace vcpkg::Commands::Build
             exit(EXIT_FAILURE);
         }
 
-        Environment::ensure_utilities_on_path(paths);
-        build_package(spgh, spec, paths, paths.port_dir(spec));
+        if (result != BuildResult::SUCCEEDED)
+        {
+            System::println(System::color::error, Build::create_error_message(result, spec));
+            System::println(Build::create_user_troubleshooting_message(spec));
+            exit(EXIT_FAILURE);
+        }
+
         exit(EXIT_SUCCESS);
     }
+
+    void perform_and_exit(const vcpkg_cmd_arguments& args, const vcpkg_paths& paths, const triplet& default_target_triplet)
+    {
+        static const std::string example = Commands::Help::create_example_string("build zlib:x64-windows");
+        args.check_exact_arg_count(1, example); // Build only takes a single package and all dependencies must already be installed
+        const package_spec spec = Input::check_and_get_package_spec(args.command_arguments.at(0), default_target_triplet, example);
+        Input::check_triplet(spec.target_triplet(), paths);
+        const std::unordered_set<std::string> options = args.check_and_get_optional_command_arguments({ OPTION_CHECKS_ONLY });
+        perform_and_exit(spec, paths.port_dir(spec), options, paths);
+    }
 }