Merge from master

17 files changed, 170 insertions, 182 deletions

diff --git a/toolsrc/src/BinaryParagraph.cpp b/toolsrc/src/BinaryParagraph.cpp
index 42ef0a77a..499ef54f7 100644
--- a/toolsrc/src/BinaryParagraph.cpp
+++ b/toolsrc/src/BinaryParagraph.cpp
@@ -29,9 +29,9 @@ namespace vcpkg
     {
         const std::string name = details::remove_required_field(&fields, BinaryParagraphRequiredField::PACKAGE);
         const std::string architecture = details::remove_required_field(&fields, BinaryParagraphRequiredField::ARCHITECTURE);
-        const Triplet target_triplet = Triplet::from_canonical_name(architecture);
+        const Triplet triplet = Triplet::from_canonical_name(architecture);
 
-        this->spec = PackageSpec::from_name_and_triplet(name, target_triplet).value_or_exit(VCPKG_LINE_INFO);
+        this->spec = PackageSpec::from_name_and_triplet(name, triplet).value_or_exit(VCPKG_LINE_INFO);
         this->version = details::remove_required_field(&fields, BinaryParagraphRequiredField::VERSION);
 
         this->description = details::remove_optional_field(&fields, BinaryParagraphOptionalField::DESCRIPTION);
@@ -44,18 +44,18 @@ namespace vcpkg
         this->depends = parse_depends(deps);
     }
 
-    BinaryParagraph::BinaryParagraph(const SourceParagraph& spgh, const Triplet& target_triplet)
+    BinaryParagraph::BinaryParagraph(const SourceParagraph& spgh, const Triplet& triplet)
     {
-        this->spec = PackageSpec::from_name_and_triplet(spgh.name, target_triplet).value_or_exit(VCPKG_LINE_INFO);
+        this->spec = PackageSpec::from_name_and_triplet(spgh.name, triplet).value_or_exit(VCPKG_LINE_INFO);
         this->version = spgh.version;
         this->description = spgh.description;
         this->maintainer = spgh.maintainer;
-        this->depends = filter_dependencies(spgh.depends, target_triplet);
+        this->depends = filter_dependencies(spgh.depends, triplet);
     }
 
     std::string BinaryParagraph::displayname() const
     {
-        return this->spec.display_name();
+        return this->spec.to_string();
     }
 
     std::string BinaryParagraph::dir() const
@@ -65,7 +65,7 @@ namespace vcpkg
 
     std::string BinaryParagraph::fullstem() const
     {
-        return Strings::format("%s_%s_%s", this->spec.name(), this->version, this->spec.target_triplet());
+        return Strings::format("%s_%s_%s", this->spec.name(), this->version, this->spec.triplet());
     }
 
     std::ostream& operator<<(std::ostream& os, const BinaryParagraph& p)
@@ -85,7 +85,7 @@ namespace vcpkg
 
             os << "\n";
         }
-        os << "Architecture: " << p.spec.target_triplet() << "\n";
+        os << "Architecture: " << p.spec.triplet().to_string() << "\n";
         os << "Multi-Arch: same\n";
         if (!p.maintainer.empty())
             os << "Maintainer: " << p.maintainer << "\n";
diff --git a/toolsrc/src/PackageSpec.cpp b/toolsrc/src/PackageSpec.cpp
index fab0cc8b6..bf1c7380c 100644
--- a/toolsrc/src/PackageSpec.cpp
+++ b/toolsrc/src/PackageSpec.cpp
@@ -8,12 +8,12 @@ namespace vcpkg
         return (c == '-') || isdigit(c) || (isalpha(c) && islower(c));
     }
 
-    Expected<PackageSpec> PackageSpec::from_string(const std::string& spec_as_string, const Triplet& default_target_triplet)
+    Expected<PackageSpec> PackageSpec::from_string(const std::string& spec_as_string, const Triplet& default_triplet)
     {
         auto pos = spec_as_string.find(':');
         if (pos == std::string::npos)
         {
-            return from_name_and_triplet(spec_as_string, default_target_triplet);
+            return from_name_and_triplet(spec_as_string, default_triplet);
         }
 
         auto pos2 = spec_as_string.find(':', pos + 1);
@@ -23,11 +23,11 @@ namespace vcpkg
         }
 
         const std::string name = spec_as_string.substr(0, pos);
-        const Triplet target_triplet = Triplet::from_canonical_name(spec_as_string.substr(pos + 1));
-        return from_name_and_triplet(name, target_triplet);
+        const Triplet triplet = Triplet::from_canonical_name(spec_as_string.substr(pos + 1));
+        return from_name_and_triplet(name, triplet);
     }
 
-    Expected<PackageSpec> PackageSpec::from_name_and_triplet(const std::string& name, const Triplet& target_triplet)
+    Expected<PackageSpec> PackageSpec::from_name_and_triplet(const std::string& name, const Triplet& triplet)
     {
         if (std::find_if_not(name.cbegin(), name.cend(), is_valid_package_spec_char) != name.end())
         {
@@ -36,7 +36,7 @@ namespace vcpkg
 
         PackageSpec p;
         p.m_name = name;
-        p.m_target_triplet = target_triplet;
+        p.m_triplet = triplet;
         return p;
     }
 
@@ -45,38 +45,23 @@ namespace vcpkg
         return this->m_name;
     }
 
-    const Triplet& PackageSpec::target_triplet() const
+    const Triplet& PackageSpec::triplet() const
     {
-        return this->m_target_triplet;
-    }
-
-    std::string PackageSpec::display_name() const
-    {
-        return Strings::format("%s:%s", this->name(), this->target_triplet());
+        return this->m_triplet;
     }
 
     std::string PackageSpec::dir() const
     {
-        return Strings::format("%s_%s", this->m_name, this->m_target_triplet);
+        return Strings::format("%s_%s", this->m_name, this->m_triplet);
     }
 
     std::string PackageSpec::to_string() const
     {
-        return this->display_name();
-    }
-
-    std::string to_printf_arg(const PackageSpec& spec)
-    {
-        return spec.to_string();
+        return Strings::format("%s:%s", this->name(), this->triplet());
     }
 
     bool operator==(const PackageSpec& left, const PackageSpec& right)
     {
-        return left.name() == right.name() && left.target_triplet() == right.target_triplet();
-    }
-
-    std::ostream& operator<<(std::ostream& os, const PackageSpec& spec)
-    {
-        return os << spec.to_string();
+        return left.name() == right.name() && left.triplet() == right.triplet();
     }
 }
diff --git a/toolsrc/src/PostBuildLint.cpp b/toolsrc/src/PostBuildLint.cpp
index 805fc8915..c703e1fcb 100644
--- a/toolsrc/src/PostBuildLint.cpp
+++ b/toolsrc/src/PostBuildLint.cpp
@@ -686,7 +686,7 @@ namespace vcpkg::PostBuildLint
             libs.insert(libs.cend(), debug_libs.cbegin(), debug_libs.cend());
             libs.insert(libs.cend(), release_libs.cbegin(), release_libs.cend());
 
-            error_count += check_lib_architecture(spec.target_triplet().architecture(), libs);
+            error_count += check_lib_architecture(spec.triplet().architecture(), libs);
         }
 
         switch (build_info.library_linkage)
@@ -708,8 +708,8 @@ namespace vcpkg::PostBuildLint
                     dlls.insert(dlls.cend(), release_dlls.cbegin(), release_dlls.cend());
 
                     error_count += check_exports_of_dlls(dlls, toolset.dumpbin);
-                    error_count += check_uwp_bit_of_dlls(spec.target_triplet().system(), dlls, toolset.dumpbin);
-                    error_count += check_dll_architecture(spec.target_triplet().architecture(), dlls);
+                    error_count += check_uwp_bit_of_dlls(spec.triplet().system(), dlls, toolset.dumpbin);
+                    error_count += check_dll_architecture(spec.triplet().architecture(), dlls);
 
                     error_count += check_outdated_crt_linkage_of_dlls(dlls, toolset.dumpbin);
                     break;
diff --git a/toolsrc/src/StatusParagraphs.cpp b/toolsrc/src/StatusParagraphs.cpp
index ecaf7b745..59e6ee331 100644
--- a/toolsrc/src/StatusParagraphs.cpp
+++ b/toolsrc/src/StatusParagraphs.cpp
@@ -1,6 +1,9 @@
 #include "pch.h"
 #include "StatusParagraphs.h"
 #include "vcpkg_Checks.h"
+#include <algorithm>
+#include <algorithm>
+#include <algorithm>
 
 namespace vcpkg
 {
@@ -11,27 +14,27 @@ namespace vcpkg
     {
     };
 
-    StatusParagraphs::const_iterator StatusParagraphs::find(const std::string& name, const Triplet& target_triplet) const
+    StatusParagraphs::const_iterator StatusParagraphs::find(const std::string& name, const Triplet& triplet) const
     {
         return std::find_if(begin(), end(), [&](const std::unique_ptr<StatusParagraph>& pgh)
                             {
                                 const PackageSpec& spec = pgh->package.spec;
-                                return spec.name() == name && spec.target_triplet() == target_triplet;
+                                return spec.name() == name && spec.triplet() == triplet;
                             });
     }
 
-    StatusParagraphs::iterator StatusParagraphs::find(const std::string& name, const Triplet& target_triplet)
+    StatusParagraphs::iterator StatusParagraphs::find(const std::string& name, const Triplet& triplet)
     {
         return std::find_if(begin(), end(), [&](const std::unique_ptr<StatusParagraph>& pgh)
                             {
                                 const PackageSpec& spec = pgh->package.spec;
-                                return spec.name() == name && spec.target_triplet() == target_triplet;
+                                return spec.name() == name && spec.triplet() == triplet;
                             });
     }
 
-    StatusParagraphs::const_iterator StatusParagraphs::find_installed(const std::string& name, const Triplet& target_triplet) const
+    StatusParagraphs::const_iterator StatusParagraphs::find_installed(const std::string& name, const Triplet& triplet) const
     {
-        const const_iterator it = find(name, target_triplet);
+        const const_iterator it = find(name, triplet);
         if (it != end() && (*it)->want == Want::INSTALL && (*it)->state == InstallState::INSTALLED)
         {
             return it;
@@ -44,7 +47,7 @@ namespace vcpkg
     {
         Checks::check_exit(VCPKG_LINE_INFO, pgh != nullptr, "Inserted null paragraph");
         const PackageSpec& spec = pgh->package.spec;
-        auto ptr = find(spec.name(), spec.target_triplet());
+        auto ptr = find(spec.name(), spec.triplet());
         if (ptr == end())
         {
             paragraphs.push_back(std::move(pgh));
diff --git a/toolsrc/src/VcpkgCmdArguments.cpp b/toolsrc/src/VcpkgCmdArguments.cpp
index 99ca26877..b5f608840 100644
--- a/toolsrc/src/VcpkgCmdArguments.cpp
+++ b/toolsrc/src/VcpkgCmdArguments.cpp
@@ -88,7 +88,7 @@ namespace vcpkg
                 if (arg == "--triplet")
                 {
                     ++arg_begin;
-                    parse_value(arg_begin, arg_end, "--triplet", args.target_triplet);
+                    parse_value(arg_begin, arg_end, "--triplet", args.triplet);
                     continue;
                 }
                 if (arg == "--debug")
diff --git a/toolsrc/src/commands_available_commands.cpp b/toolsrc/src/commands_available_commands.cpp
index 870831599..e4c5135c7 100644
--- a/toolsrc/src/commands_available_commands.cpp
+++ b/toolsrc/src/commands_available_commands.cpp
@@ -6,12 +6,12 @@ namespace vcpkg::Commands
     const std::vector<PackageNameAndFunction<CommandTypeA>>& get_available_commands_type_a()
     {
         static std::vector<PackageNameAndFunction<CommandTypeA>> t = {
-            {"install", &Install::perform_and_exit},
+            { "install", &Install::perform_and_exit },
             { "ci", &CI::perform_and_exit },
-            {"remove", &Remove::perform_and_exit},
-            {"build", &Build::perform_and_exit},
-            {"env", &Env::perform_and_exit},
-            {"build-external", &BuildExternal::perform_and_exit}
+            { "remove", &Remove::perform_and_exit },
+            { "build", &Build::perform_and_exit },
+            { "env", &Env::perform_and_exit },
+            { "build-external", &BuildExternal::perform_and_exit }
         };
         return t;
     }
@@ -19,19 +19,19 @@ namespace vcpkg::Commands
     const std::vector<PackageNameAndFunction<CommandTypeB>>& get_available_commands_type_b()
     {
         static std::vector<PackageNameAndFunction<CommandTypeB>> t = {
-            {"/?", &Help::perform_and_exit},
-            {"help", &Help::perform_and_exit},
-            {"search", &Search::perform_and_exit},
-            {"list", &List::perform_and_exit},
-            {"integrate", &Integrate::perform_and_exit},
-            {"owns", &Owns::perform_and_exit},
-            {"update", &Update::perform_and_exit},
-            {"depend-info", &DependInfo::perform_and_exit},
-            {"edit", &Edit::perform_and_exit},
-            {"create", &Create::perform_and_exit},
-            {"import", &Import::perform_and_exit},
-            {"cache", &Cache::perform_and_exit},
-            {"portsdiff", &PortsDiff::perform_and_exit}
+            { "/?", &Help::perform_and_exit },
+            { "help", &Help::perform_and_exit },
+            { "search", &Search::perform_and_exit },
+            { "list", &List::perform_and_exit },
+            { "integrate", &Integrate::perform_and_exit },
+            { "owns", &Owns::perform_and_exit },
+            { "update", &Update::perform_and_exit },
+            { "depend-info", &DependInfo::perform_and_exit },
+            { "edit", &Edit::perform_and_exit },
+            { "create", &Create::perform_and_exit },
+            { "import", &Import::perform_and_exit },
+            { "cache", &Cache::perform_and_exit },
+            { "portsdiff", &PortsDiff::perform_and_exit }
         };
         return t;
     }
@@ -39,9 +39,9 @@ namespace vcpkg::Commands
     const std::vector<PackageNameAndFunction<CommandTypeC>>& get_available_commands_type_c()
     {
         static std::vector<PackageNameAndFunction<CommandTypeC>> t = {
-            {"version", &Version::perform_and_exit},
-            {"contact", &Contact::perform_and_exit},
-            {"hash", &Hash::perform_and_exit},
+            { "version", &Version::perform_and_exit },
+            { "contact", &Contact::perform_and_exit },
+            { "hash", &Hash::perform_and_exit },
         };
         return t;
     }
diff --git a/toolsrc/src/commands_build.cpp b/toolsrc/src/commands_build.cpp
index fe69d64bb..9af1e8e78 100644
--- a/toolsrc/src/commands_build.cpp
+++ b/toolsrc/src/commands_build.cpp
@@ -18,14 +18,14 @@ namespace vcpkg::Commands::Build
 
     static const std::string OPTION_CHECKS_ONLY = "--checks-only";
 
-    static void create_binary_control_file(const VcpkgPaths& paths, const SourceParagraph& source_paragraph, const Triplet& target_triplet)
+    static void create_binary_control_file(const VcpkgPaths& paths, const SourceParagraph& source_paragraph, const Triplet& triplet)
     {
-        const BinaryParagraph bpgh = BinaryParagraph(source_paragraph, target_triplet);
+        const BinaryParagraph bpgh = BinaryParagraph(source_paragraph, triplet);
         const fs::path binary_control_file = paths.packages / bpgh.dir() / "CONTROL";
         std::ofstream(binary_control_file) << bpgh;
     }
 
-    std::wstring make_build_env_cmd(const Triplet& target_triplet, const Toolset& toolset)
+    std::wstring make_build_env_cmd(const Triplet& triplet, const Toolset& toolset)
     {
         const wchar_t * tonull = L" >nul";
         if (g_debugging)
@@ -33,17 +33,17 @@ namespace vcpkg::Commands::Build
             tonull = L"";
         }
 
-        return Strings::wformat(LR"("%s" %s %s 2>&1)", toolset.vcvarsall.native(), Strings::utf8_to_utf16(target_triplet.architecture()), tonull);
+        return Strings::wformat(LR"("%s" %s %s 2>&1)", toolset.vcvarsall.native(), Strings::utf8_to_utf16(triplet.architecture()), tonull);
     }
 
     BuildResult build_package(const SourceParagraph& source_paragraph, const PackageSpec& spec, const VcpkgPaths& paths, const fs::path& port_dir, const StatusParagraphs& status_db)
     {
         Checks::check_exit(VCPKG_LINE_INFO, spec.name() == source_paragraph.name, "inconsistent arguments to build_package()");
 
-        const Triplet& target_triplet = spec.target_triplet();
-        for (auto&& dep : filter_dependencies(source_paragraph.depends, target_triplet))
+        const Triplet& triplet = spec.triplet();
+        for (auto&& dep : filter_dependencies(source_paragraph.depends, triplet))
         {
-            if (status_db.find_installed(dep, target_triplet) == status_db.end())
+            if (status_db.find_installed(dep, triplet) == status_db.end())
             {
                 return BuildResult::CASCADED_DUE_TO_MISSING_DEPENDENCIES;
             }
@@ -54,14 +54,14 @@ namespace vcpkg::Commands::Build
 
         const fs::path ports_cmake_script_path = paths.ports_cmake;
         const Toolset& toolset = paths.get_toolset();
-        const auto cmd_set_environment = make_build_env_cmd(target_triplet, toolset);
+        const auto cmd_set_environment = make_build_env_cmd(triplet, toolset);
 
         const std::wstring cmd_launch_cmake = make_cmake_cmd(cmake_exe_path, ports_cmake_script_path,
                                                              {
                                                                  { L"CMD", L"BUILD" },
                                                                  { L"PORT", source_paragraph.name },
                                                                  { L"CURRENT_PORT_DIR", port_dir / "/." },
-                                                                 { L"TARGET_TRIPLET", target_triplet.canonical_name() },
+                                                                 { L"TARGET_TRIPLET", triplet.canonical_name() },
                                                                  { L"VCPKG_PLATFORM_TOOLSET", toolset.version },
                                                                  { L"GIT", git_exe_path }
                                                              });
@@ -88,7 +88,7 @@ namespace vcpkg::Commands::Build
             return BuildResult::POST_BUILD_CHECKS_FAILED;
         }
 
-        create_binary_control_file(paths, source_paragraph, target_triplet);
+        create_binary_control_file(paths, source_paragraph, triplet);
 
         // const fs::path port_buildtrees_dir = paths.buildtrees / spec.name;
         // delete_directory(port_buildtrees_dir);
@@ -117,7 +117,7 @@ namespace vcpkg::Commands::Build
 
     std::string create_error_message(const BuildResult build_result, const PackageSpec& spec)
     {
-        return Strings::format("Error: Building package %s failed with: %s", spec.to_string(), Build::to_string(build_result));
+        return Strings::format("Error: Building package %s failed with: %s", spec, Build::to_string(build_result));
     }
 
     std::string create_user_troubleshooting_message(const PackageSpec& spec)
@@ -128,7 +128,7 @@ namespace vcpkg::Commands::Build
                                "  Vcpkg version: %s\n"
                                "\n"
                                "Additionally, attach any relevant sections from the log files above."
-                               , spec.to_string(), Version::version());
+                               , spec, Version::version());
     }
 
     void perform_and_exit(const PackageSpec& spec, const fs::path& port_dir, const std::unordered_set<std::string>& options, const VcpkgPaths& paths)
@@ -162,7 +162,7 @@ namespace vcpkg::Commands::Build
             System::println("");
             for (const PackageSpecWithInstallPlan& p : unmet_dependencies)
             {
-                System::println("    %s", p.spec.to_string());
+                System::println("    %s", p.spec);
             }
             System::println("");
             Checks::exit_fail(VCPKG_LINE_INFO);
@@ -178,12 +178,12 @@ namespace vcpkg::Commands::Build
         Checks::exit_success(VCPKG_LINE_INFO);
     }
 
-    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_target_triplet)
+    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_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 PackageSpec spec = Input::check_and_get_package_spec(args.command_arguments.at(0), default_target_triplet, example);
-        Input::check_triplet(spec.target_triplet(), paths);
+        const PackageSpec spec = Input::check_and_get_package_spec(args.command_arguments.at(0), default_triplet, example);
+        Input::check_triplet(spec.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);
     }
diff --git a/toolsrc/src/commands_build_external.cpp b/toolsrc/src/commands_build_external.cpp
index 7b5a01025..d0dbf1d24 100644
--- a/toolsrc/src/commands_build_external.cpp
+++ b/toolsrc/src/commands_build_external.cpp
@@ -5,12 +5,12 @@
 
 namespace vcpkg::Commands::BuildExternal
 {
-    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_target_triplet)
+    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet)
     {
         static const std::string example = Commands::Help::create_example_string(R"(build_external zlib2 C:\path\to\dir\with\controlfile\)");
         args.check_exact_arg_count(2, example);
-        const PackageSpec spec = Input::check_and_get_package_spec(args.command_arguments.at(0), default_target_triplet, example);
-        Input::check_triplet(spec.target_triplet(), paths);
+        const PackageSpec spec = Input::check_and_get_package_spec(args.command_arguments.at(0), default_triplet, example);
+        Input::check_triplet(spec.triplet(), paths);
         const std::unordered_set<std::string> options = args.check_and_get_optional_command_arguments({});
 
         const fs::path port_dir = args.command_arguments.at(1);
diff --git a/toolsrc/src/commands_ci.cpp b/toolsrc/src/commands_ci.cpp
index e498ba574..d4b2865a6 100644
--- a/toolsrc/src/commands_ci.cpp
+++ b/toolsrc/src/commands_ci.cpp
@@ -14,26 +14,26 @@ namespace vcpkg::Commands::CI
     using Dependencies::InstallPlanType;
     using Build::BuildResult;
 
-    static std::vector<PackageSpec> load_all_package_specs(Files::Filesystem& fs, const fs::path& ports_directory, const Triplet& target_triplet)
+    static std::vector<PackageSpec> load_all_package_specs(Files::Filesystem& fs, const fs::path& ports_directory, const Triplet& triplet)
     {
         std::vector<SourceParagraph> ports = Paragraphs::load_all_ports(fs, ports_directory);
         std::vector<PackageSpec> specs;
         for (const SourceParagraph& p : ports)
         {
-            specs.push_back(PackageSpec::from_name_and_triplet(p.name, target_triplet).value_or_exit(VCPKG_LINE_INFO));
+            specs.push_back(PackageSpec::from_name_and_triplet(p.name, triplet).value_or_exit(VCPKG_LINE_INFO));
         }
 
         return specs;
     }
 
-    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_target_triplet)
+    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet)
     {
         static const std::string example = Commands::Help::create_example_string("ci x64-windows");
         args.check_max_arg_count(1, example);
-        const Triplet target_triplet = args.command_arguments.size() == 1 ? Triplet::from_canonical_name(args.command_arguments.at(0)) : default_target_triplet;
-        Input::check_triplet(target_triplet, paths);
+        const Triplet triplet = args.command_arguments.size() == 1 ? Triplet::from_canonical_name(args.command_arguments.at(0)) : default_triplet;
+        Input::check_triplet(triplet, paths);
         args.check_and_get_optional_command_arguments({});
-        const std::vector<PackageSpec> specs = load_all_package_specs(paths.get_filesystem(), paths.ports, target_triplet);
+        const std::vector<PackageSpec> specs = load_all_package_specs(paths.get_filesystem(), paths.ports, triplet);
 
         StatusParagraphs status_db = database_load_check(paths);
         const std::vector<PackageSpecWithInstallPlan> install_plan = Dependencies::create_install_plan(paths, specs, status_db);
@@ -48,44 +48,52 @@ namespace vcpkg::Commands::CI
         {
             const ElapsedTime build_timer = ElapsedTime::create_started();
             counter++;
-            System::println("Starting package %d/%d: %s", counter, package_count, action.spec.to_string());
+            const std::string display_name = action.spec.to_string();
+            System::println("Starting package %d/%d: %s", counter, package_count, display_name);
 
             timing.push_back(-1);
             results.push_back(BuildResult::NULLVALUE);
 
             try
             {
-                if (action.plan.plan_type == InstallPlanType::ALREADY_INSTALLED)
+                switch (action.plan.plan_type)
                 {
-                    results.back() = BuildResult::SUCCEEDED;
-                    System::println(System::Color::success, "Package %s is already installed", action.spec);
-                }
-                else if (action.plan.plan_type == InstallPlanType::BUILD_AND_INSTALL)
-                {
-                    const BuildResult result = Commands::Build::build_package(action.plan.source_pgh.value_or_exit(VCPKG_LINE_INFO),
-                                                                              action.spec,
-                                                                              paths,
-                                                                              paths.port_dir(action.spec),
-                                                                              status_db);
-                    timing.back() = build_timer.elapsed<std::chrono::milliseconds>().count();
-                    results.back() = result;
-                    if (result != BuildResult::SUCCEEDED)
-                    {
-                        System::println(System::Color::error, Build::create_error_message(result, action.spec));
-                        continue;
-                    }
-                    const BinaryParagraph bpgh = Paragraphs::try_load_cached_package(paths, action.spec).value_or_exit(VCPKG_LINE_INFO);
-                    Install::install_package(paths, bpgh, &status_db);
-                    System::println(System::Color::success, "Package %s is installed", action.spec);
-                }
-                else if (action.plan.plan_type == InstallPlanType::INSTALL)
-                {
-                    results.back() = BuildResult::SUCCEEDED;
-                    Install::install_package(paths, action.plan.binary_pgh.value_or_exit(VCPKG_LINE_INFO), &status_db);
-                    System::println(System::Color::success, "Package %s is installed from cache", action.spec);
+                    case InstallPlanType::ALREADY_INSTALLED:
+                        results.back() = BuildResult::SUCCEEDED;
+                        System::println(System::Color::success, "Package %s is already installed", display_name);
+                        break;
+                    case InstallPlanType::BUILD_AND_INSTALL:
+                        {
+                            System::println("Building package %s... ", display_name);
+                            const BuildResult result = Commands::Build::build_package(action.plan.source_pgh.value_or_exit(VCPKG_LINE_INFO),
+                                                                                      action.spec,
+                                                                                      paths,
+                                                                                      paths.port_dir(action.spec),
+                                                                                      status_db);
+                            timing.back() = build_timer.elapsed<std::chrono::milliseconds>().count();
+                            results.back() = result;
+                            if (result != BuildResult::SUCCEEDED)
+                            {
+                                System::println(System::Color::error, Build::create_error_message(result, action.spec));
+                                continue;
+                            }
+                            System::println(System::Color::success, "Building package %s... done", display_name);
+
+                            const BinaryParagraph bpgh = Paragraphs::try_load_cached_package(paths, action.spec).value_or_exit(VCPKG_LINE_INFO);
+                            System::println("Installing package %s... ", display_name);
+                            Install::install_package(paths, bpgh, &status_db);
+                            System::println(System::Color::success, "Installing package %s... done", display_name);
+                            break;
+                        }
+                    case InstallPlanType::INSTALL:
+                        results.back() = BuildResult::SUCCEEDED;
+                        System::println("Installing package %s... ", display_name);
+                        Install::install_package(paths, action.plan.binary_pgh.value_or_exit(VCPKG_LINE_INFO), &status_db);
+                        System::println(System::Color::success, "Installing package %s... done", display_name);
+                        break;
+                    default:
+                        Checks::unreachable(VCPKG_LINE_INFO);
                 }
-                else
-                    Checks::unreachable(VCPKG_LINE_INFO);
             }
             catch (const std::exception& e)
             {
@@ -99,7 +107,7 @@ namespace vcpkg::Commands::CI
 
         for (size_t i = 0; i < results.size(); i++)
         {
-            System::println("%s: %s: %dms", install_plan[i].spec.to_string(), Build::to_string(results[i]), timing[i]);
+            System::println("%s: %s: %dms", install_plan[i].spec, Build::to_string(results[i]), timing[i]);
         }
 
         std::map<BuildResult, int> summary;
diff --git a/toolsrc/src/commands_install.cpp b/toolsrc/src/commands_install.cpp
index 87e95e499..15aab4845 100644
--- a/toolsrc/src/commands_install.cpp
+++ b/toolsrc/src/commands_install.cpp
@@ -24,11 +24,11 @@ namespace vcpkg::Commands::Install
         const fs::path package_prefix_path = paths.package_dir(bpgh.spec);
         const size_t prefix_length = package_prefix_path.native().size();
 
-        const Triplet& target_triplet = bpgh.spec.target_triplet();
-        const std::string& target_triplet_as_string = target_triplet.canonical_name();
+        const std::string& triplet_string = bpgh.spec.triplet().canonical_name();
+        const fs::path installed_subfolder_path = paths.installed / triplet_string;
         std::error_code ec;
-        fs.create_directory(paths.installed / target_triplet_as_string, ec);
-        output.push_back(Strings::format(R"(%s/)", target_triplet_as_string));
+        fs.create_directory(installed_subfolder_path, ec);
+        output.push_back(Strings::format(R"(%s/)", triplet_string));
 
         auto files = fs.recursive_find_all_files_in_dir(package_prefix_path);
         for (auto&& file : files)
@@ -48,7 +48,7 @@ namespace vcpkg::Commands::Install
             }
 
             const std::string suffix = file.generic_u8string().substr(prefix_length + 1);
-            const fs::path target = paths.installed / target_triplet_as_string / suffix;
+            const fs::path target = installed_subfolder_path / suffix;
 
             if (fs::is_directory(status))
             {
@@ -59,7 +59,7 @@ namespace vcpkg::Commands::Install
                 }
 
                 // Trailing backslash for directories
-                output.push_back(Strings::format(R"(%s/%s/)", target_triplet_as_string, suffix));
+                output.push_back(Strings::format(R"(%s/%s/)", triplet_string, suffix));
                 continue;
             }
 
@@ -74,7 +74,7 @@ namespace vcpkg::Commands::Install
                 {
                     System::println(System::Color::error, "failed: %s: %s", target.u8string(), ec.message());
                 }
-                output.push_back(Strings::format(R"(%s/%s)", target_triplet_as_string, suffix));
+                output.push_back(Strings::format(R"(%s/%s)", triplet_string, suffix));
                 continue;
             }
 
@@ -105,7 +105,7 @@ namespace vcpkg::Commands::Install
         std::vector<std::string> output;
         for (const StatusParagraphAndAssociatedFiles& t : pgh_and_files)
         {
-            if (t.pgh.package.spec.target_triplet() != triplet)
+            if (t.pgh.package.spec.triplet() != triplet)
             {
                 continue;
             }
@@ -188,7 +188,7 @@ namespace vcpkg::Commands::Install
     void install_package(const VcpkgPaths& paths, const BinaryParagraph& binary_paragraph, StatusParagraphs* status_db)
     {
         const fs::path package_dir = paths.package_dir(binary_paragraph.spec);
-        const Triplet& triplet = binary_paragraph.spec.target_triplet();
+        const Triplet& triplet = binary_paragraph.spec.triplet();
         const std::vector<StatusParagraphAndAssociatedFiles> pgh_and_files = get_installed_files(paths, *status_db);
 
         const SortedVector<std::string> package_files = build_list_of_package_files(paths.get_filesystem(), package_dir);
@@ -217,7 +217,7 @@ namespace vcpkg::Commands::Install
         spgh.state = InstallState::HALF_INSTALLED;
         for (auto&& dep : spgh.package.depends)
         {
-            if (status_db->find_installed(dep, spgh.package.spec.target_triplet()) == status_db->end())
+            if (status_db->find_installed(dep, spgh.package.spec.triplet()) == status_db->end())
             {
                 Checks::unreachable(VCPKG_LINE_INFO);
             }
@@ -232,7 +232,7 @@ namespace vcpkg::Commands::Install
         status_db->insert(std::make_unique<StatusParagraph>(spgh));
     }
 
-    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_target_triplet)
+    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet)
     {
         static const std::string OPTION_DRY_RUN = "--dry-run";
 
@@ -240,12 +240,12 @@ namespace vcpkg::Commands::Install
         static const std::string example = Commands::Help::create_example_string("install zlib zlib:x64-windows curl boost");
         args.check_min_arg_count(1, example);
 
-        auto specs = Util::fmap(args.command_arguments, [&](auto&& arg)
+        const std::vector<PackageSpec> specs = Util::fmap(args.command_arguments, [&](auto&& arg)
                                 {
-                                    auto spec = Input::check_and_get_package_spec(arg, default_target_triplet, example);
-                                    Input::check_triplet(spec.target_triplet(), paths);
-                                    return spec;
+                                    return Input::check_and_get_package_spec(arg, default_triplet, example);
                                 });
+        for (auto&& spec : specs)
+            Input::check_triplet(spec.triplet(), paths);
 
         const std::unordered_set<std::string> options = args.check_and_get_optional_command_arguments({ OPTION_DRY_RUN });
         const bool dryRun = options.find(OPTION_DRY_RUN) != options.cend();
@@ -284,16 +284,18 @@ namespace vcpkg::Commands::Install
         // execute the plan
         for (const PackageSpecWithInstallPlan& action : install_plan)
         {
+            const std::string display_name = action.spec.to_string();
+
             try
             {
                 switch (action.plan.plan_type)
                 {
                     case InstallPlanType::ALREADY_INSTALLED:
-                        System::println(System::Color::success, "Package %s is already installed", action.spec);
+                        System::println(System::Color::success, "Package %s is already installed", display_name);
                         break;
                     case InstallPlanType::BUILD_AND_INSTALL:
                         {
-                            System::println("Building package %s... ", action.spec);
+                            System::println("Building package %s... ", display_name);
                             const Build::BuildResult result = Commands::Build::build_package(action.plan.source_pgh.value_or_exit(VCPKG_LINE_INFO),
                                                                                              action.spec,
                                                                                              paths,
@@ -305,18 +307,18 @@ namespace vcpkg::Commands::Install
                                 System::println(Build::create_user_troubleshooting_message(action.spec));
                                 Checks::exit_fail(VCPKG_LINE_INFO);
                             }
-                            System::println(System::Color::success, "Building package %s... done", action.spec);
+                            System::println(System::Color::success, "Building package %s... done", display_name);
 
                             const BinaryParagraph bpgh = Paragraphs::try_load_cached_package(paths, action.spec).value_or_exit(VCPKG_LINE_INFO);
-                            System::println("Installing package %s... ", action.spec);
+                            System::println("Installing package %s... ", display_name);
                             install_package(paths, bpgh, &status_db);
-                            System::println(System::Color::success, "Installing package %s... done", action.spec);
+                            System::println(System::Color::success, "Installing package %s... done", display_name);
                             break;
                         }
                     case InstallPlanType::INSTALL:
-                        System::println("Installing package %s... ", action.spec);
+                        System::println("Installing package %s... ", display_name);
                         install_package(paths, action.plan.binary_pgh.value_or_exit(VCPKG_LINE_INFO), &status_db);
-                        System::println(System::Color::success, "Installing package %s... done", action.spec);
+                        System::println(System::Color::success, "Installing package %s... done", display_name);
                         break;
                     case InstallPlanType::UNKNOWN:
                     default:
diff --git a/toolsrc/src/commands_remove.cpp b/toolsrc/src/commands_remove.cpp
index fe4aede13..9ce4adb75 100644
--- a/toolsrc/src/commands_remove.cpp
+++ b/toolsrc/src/commands_remove.cpp
@@ -30,7 +30,7 @@ namespace vcpkg::Commands::Remove
     static void remove_package(const VcpkgPaths& paths, const PackageSpec& spec, StatusParagraphs* status_db)
     {
         auto& fs = paths.get_filesystem();
-        StatusParagraph& pkg = **status_db->find(spec.name(), spec.target_triplet());
+        StatusParagraph& pkg = **status_db->find(spec.name(), spec.triplet());
 
         pkg.want = Want::PURGE;
         pkg.state = InstallState::HALF_INSTALLED;
@@ -136,7 +136,7 @@ namespace vcpkg::Commands::Remove
         }
     }
 
-    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_target_triplet)
+    void perform_and_exit(const VcpkgCmdArguments& args, const VcpkgPaths& paths, const Triplet& default_triplet)
     {
         static const std::string OPTION_PURGE = "--purge";
         static const std::string OPTION_NO_PURGE = "--no-purge";
@@ -156,9 +156,9 @@ namespace vcpkg::Commands::Remove
         else
         {
             args.check_min_arg_count(1, example);
-            specs = Util::fmap(args.command_arguments, [&](auto&& arg) { return Input::check_and_get_package_spec(arg, default_target_triplet, example); });
+            specs = Util::fmap(args.command_arguments, [&](auto&& arg) { return Input::check_and_get_package_spec(arg, default_triplet, example); });
             for (auto&& spec : specs)
-                Input::check_triplet(spec.target_triplet(), paths);
+                Input::check_triplet(spec.triplet(), paths);
         }
 
         const bool alsoRemoveFolderFromPackages = options.find(OPTION_NO_PURGE) == options.end();
@@ -200,7 +200,7 @@ namespace vcpkg::Commands::Remove
 
         for (const PackageSpecWithRemovePlan& action : remove_plan)
         {
-            const std::string display_name = action.spec.display_name();
+            const std::string display_name = action.spec.to_string();
 
             switch (action.plan.plan_type)
             {
diff --git a/toolsrc/src/commands_update.cpp b/toolsrc/src/commands_update.cpp
index 68c64ca30..6fc8b1171 100644
--- a/toolsrc/src/commands_update.cpp
+++ b/toolsrc/src/commands_update.cpp
@@ -56,7 +56,7 @@ namespace vcpkg::Commands::Update
             System::println("The following packages differ from their port versions:");
             for (auto&& package : outdated_packages)
             {
-                System::println("    %-32s %s", package.spec.display_name(), package.version_diff.to_string());
+                System::println("    %-32s %s", package.spec, package.version_diff.to_string());
             }
             System::println("\n"
                 "To update these packages, run\n"
diff --git a/toolsrc/src/tests_paragraph.cpp b/toolsrc/src/tests_paragraph.cpp
index 10a84b703..58e4121a8 100644
--- a/toolsrc/src/tests_paragraph.cpp
+++ b/toolsrc/src/tests_paragraph.cpp
@@ -111,7 +111,7 @@ namespace UnitTest1
             Assert::AreEqual("1.2.8", pgh.version.c_str());
             Assert::AreEqual("", pgh.maintainer.c_str());
             Assert::AreEqual("", pgh.description.c_str());
-            Assert::AreEqual("x86-windows", pgh.spec.target_triplet().canonical_name().c_str());
+            Assert::AreEqual("x86-windows", pgh.spec.triplet().canonical_name().c_str());
             Assert::AreEqual(size_t(0), pgh.depends.size());
         }
 
@@ -363,7 +363,7 @@ namespace UnitTest1
             vcpkg::Expected<vcpkg::PackageSpec> spec = vcpkg::PackageSpec::from_string("zlib", vcpkg::Triplet::X86_WINDOWS);
             Assert::AreEqual(vcpkg::PackageSpecParseResult::SUCCESS, vcpkg::to_package_spec_parse_result(spec.error_code()));
             Assert::AreEqual("zlib", spec.get()->name().c_str());
-            Assert::AreEqual(vcpkg::Triplet::X86_WINDOWS.canonical_name(), spec.get()->target_triplet().canonical_name());
+            Assert::AreEqual(vcpkg::Triplet::X86_WINDOWS.canonical_name(), spec.get()->triplet().canonical_name());
         }
 
         TEST_METHOD(package_spec_parse_with_arch)
@@ -371,7 +371,7 @@ namespace UnitTest1
             vcpkg::Expected<vcpkg::PackageSpec> spec = vcpkg::PackageSpec::from_string("zlib:x64-uwp", vcpkg::Triplet::X86_WINDOWS);
             Assert::AreEqual(vcpkg::PackageSpecParseResult::SUCCESS, vcpkg::to_package_spec_parse_result(spec.error_code()));
             Assert::AreEqual("zlib", spec.get()->name().c_str());
-            Assert::AreEqual(vcpkg::Triplet::X64_UWP.canonical_name(), spec.get()->target_triplet().canonical_name());
+            Assert::AreEqual(vcpkg::Triplet::X64_UWP.canonical_name(), spec.get()->triplet().canonical_name());
         }
 
         TEST_METHOD(package_spec_parse_with_multiple_colon)
diff --git a/toolsrc/src/triplet.cpp b/toolsrc/src/triplet.cpp
index 0aacec9a0..cbdafb14c 100644
--- a/toolsrc/src/triplet.cpp
+++ b/toolsrc/src/triplet.cpp
@@ -11,16 +11,6 @@ namespace vcpkg
     const Triplet Triplet::X64_UWP = from_canonical_name("x64-uwp");
     const Triplet Triplet::ARM_UWP = from_canonical_name("arm-uwp");
 
-    std::string to_string(const Triplet& t)
-    {
-        return t.canonical_name();
-    }
-
-    std::string to_printf_arg(const Triplet& t)
-    {
-        return to_string(t);
-    }
-
     bool operator==(const Triplet& left, const Triplet& right)
     {
         return left.canonical_name() == right.canonical_name();
@@ -31,11 +21,6 @@ namespace vcpkg
         return !(left == right);
     }
 
-    std::ostream& operator<<(std::ostream& os, const Triplet& t)
-    {
-        return os << to_string(t);
-    }
-
     Triplet Triplet::from_canonical_name(const std::string& triplet_as_string)
     {
         const std::string s(Strings::ascii_to_lowercase(triplet_as_string));
@@ -63,4 +48,9 @@ namespace vcpkg
         auto it = std::find(this->m_canonical_name.cbegin(), this->m_canonical_name.cend(), '-');
         return std::string(it + 1, this->m_canonical_name.cend());
     }
+
+    const std::string& Triplet::to_string() const
+    {
+        return this->m_canonical_name;
+    }
 }
diff --git a/toolsrc/src/vcpkg.cpp b/toolsrc/src/vcpkg.cpp
index 8cb2806d6..33b9fbe83 100644
--- a/toolsrc/src/vcpkg.cpp
+++ b/toolsrc/src/vcpkg.cpp
@@ -69,29 +69,29 @@ static void inner(const VcpkgCmdArguments& args)
         return command_function(args, paths);
     }
 
-    Triplet default_target_triplet;
-    if (args.target_triplet != nullptr)
+    Triplet default_triplet;
+    if (args.triplet != nullptr)
     {
-        default_target_triplet = Triplet::from_canonical_name(*args.target_triplet);
+        default_triplet = Triplet::from_canonical_name(*args.triplet);
     }
     else
     {
         const Optional<std::wstring> vcpkg_default_triplet_env = System::get_environmental_variable(L"VCPKG_DEFAULT_TRIPLET");
         if (auto v = vcpkg_default_triplet_env.get())
         {
-            default_target_triplet = Triplet::from_canonical_name(Strings::utf16_to_utf8(*v));
+            default_triplet = Triplet::from_canonical_name(Strings::utf16_to_utf8(*v));
         }
         else
         {
-            default_target_triplet = Triplet::X86_WINDOWS;
+            default_triplet = Triplet::X86_WINDOWS;
         }
     }
 
-    Input::check_triplet(default_target_triplet, paths);
+    Input::check_triplet(default_triplet, paths);
 
     if (auto command_function = Commands::find(args.command, Commands::get_available_commands_type_a()))
     {
-        return command_function(args, paths, default_target_triplet);
+        return command_function(args, paths, default_triplet);
     }
 
     return invalid_command(args.command);
diff --git a/toolsrc/src/vcpkg_Dependencies.cpp b/toolsrc/src/vcpkg_Dependencies.cpp
index 024daecfd..3e3f502b5 100644
--- a/toolsrc/src/vcpkg_Dependencies.cpp
+++ b/toolsrc/src/vcpkg_Dependencies.cpp
@@ -69,7 +69,7 @@ namespace vcpkg::Dependencies
                 {
                     for (const std::string& dep_as_string : dependencies_as_string)
                     {
-                        const PackageSpec current_dep = PackageSpec::from_name_and_triplet(dep_as_string, spec.target_triplet()).value_or_exit(VCPKG_LINE_INFO);
+                        const PackageSpec current_dep = PackageSpec::from_name_and_triplet(dep_as_string, spec.triplet()).value_or_exit(VCPKG_LINE_INFO);
                         auto it = status_db.find_installed(current_dep);
                         if (it != status_db.end())
                         {
@@ -103,7 +103,7 @@ namespace vcpkg::Dependencies
             Expected<SourceParagraph> maybe_spgh = Paragraphs::try_load_port(paths.get_filesystem(), paths.port_dir(spec));
             if (auto spgh = maybe_spgh.get())
             {
-                process_dependencies(filter_dependencies(spgh->depends, spec.target_triplet()));
+                process_dependencies(filter_dependencies(spgh->depends, spec.triplet()));
                 was_examined.emplace(spec, InstallPlanAction{ InstallPlanType::BUILD_AND_INSTALL, request_type, nullopt, std::move(*spgh) });
             }
             else
@@ -152,7 +152,7 @@ namespace vcpkg::Dependencies
             {
                 if (an_installed_package->want != Want::INSTALL)
                     continue;
-                if (an_installed_package->package.spec.target_triplet() != spec.target_triplet())
+                if (an_installed_package->package.spec.triplet() != spec.triplet())
                     continue;
 
                 const std::vector<std::string>& deps = an_installed_package->package.depends;
diff --git a/toolsrc/src/vcpkg_Input.cpp b/toolsrc/src/vcpkg_Input.cpp
index d66065cc2..1e74f2e90 100644
--- a/toolsrc/src/vcpkg_Input.cpp
+++ b/toolsrc/src/vcpkg_Input.cpp
@@ -6,10 +6,10 @@
 
 namespace vcpkg::Input
 {
-    PackageSpec check_and_get_package_spec(const std::string& package_spec_as_string, const Triplet& default_target_triplet, CStringView example_text)
+    PackageSpec check_and_get_package_spec(const std::string& package_spec_as_string, const Triplet& default_triplet, CStringView example_text)
     {
         const std::string as_lowercase = Strings::ascii_to_lowercase(package_spec_as_string);
-        Expected<PackageSpec> expected_spec = PackageSpec::from_string(as_lowercase, default_target_triplet);
+        Expected<PackageSpec> expected_spec = PackageSpec::from_string(as_lowercase, default_triplet);
         if (auto spec = expected_spec.get())
         {
             return *spec;
@@ -25,8 +25,8 @@ namespace vcpkg::Input
     {
         if (!paths.is_valid_triplet(t))
         {
-            System::println(System::Color::error, "Error: invalid triplet: %s", t.canonical_name());
-            Metrics::track_property("error", "invalid triplet: " + t.canonical_name());
+            System::println(System::Color::error, "Error: invalid triplet: %s", t);
+            Metrics::track_property("error", "invalid triplet: " + t.to_string());
             Commands::Help::help_topic_valid_triplet(paths);
             Checks::exit_fail(VCPKG_LINE_INFO);
         }