Completely rework Visual Studio detection

- Now using vswhere.exe to detect all VS instance (2015 + 2017)
- Default version preference order is now: stable, prerelease, legacy
- Within each preference weight, the latest one is chosen
- findVisualStudioInstallationInstances.ps1 now has a parameter to choose VS instance

4 files changed, 172 insertions, 272 deletions

diff --git a/scripts/findAnyMSBuildWithCppPlatformToolset.ps1 b/scripts/findAnyMSBuildWithCppPlatformToolset.ps1
index f72491e5d..632cc2cdf 100644
--- a/scripts/findAnyMSBuildWithCppPlatformToolset.ps1
+++ b/scripts/findAnyMSBuildWithCppPlatformToolset.ps1
@@ -1,164 +1,50 @@
 [CmdletBinding()]
 param(
     [Parameter(Mandatory=$False)]
-    [switch]$DisableVS2017 = $False,
-
-    [Parameter(Mandatory=$False)]
-    [switch]$DisableVS2015 = $False
+    [string]$explicitlyRequestedVSPath = ""
 )
 
-if ($DisableVS2017 -and $DisableVS2015)
-{
-    throw "Both VS2015 and VS2017 were disabled."
-}
-
-function New-MSBuildInstance()
-{
-    param ($msbuildExePath, $toolsetVersion)
-
-    $instance = new-object PSObject
-    $instance | add-member -type NoteProperty -Name msbuildExePath -Value $msbuildExePath
-    $instance | add-member -type NoteProperty -Name toolsetVersion -Value $toolsetVersion
+$explicitlyRequestedVSPath = $explicitlyRequestedVSPath -replace "\\$" # Remove potential trailing backslash
 
-    return $instance
-}
-
-Write-Verbose "Executing $($MyInvocation.MyCommand.Name) with DisableVS2017=$DisableVS2017, DisableVS2015=$DisableVS2015"
 $scriptsDir = split-path -parent $MyInvocation.MyCommand.Definition
-
-$validInstances = New-Object System.Collections.ArrayList
-
-# VS2017
-Write-Verbose "`n`n"
-Write-Verbose "Checking for MSBuild from VS2017 instances..."
-$VisualStudio2017InstallationInstances = & $scriptsDir\findVisualStudioInstallationInstances.ps1
-Write-Verbose "VS2017 Candidates: $([system.String]::Join(',', $VisualStudio2017InstallationInstances))"
-foreach ($instanceCandidate in $VisualStudio2017InstallationInstances)
-{
-    $VCFolder= "$instanceCandidate\VC\Tools\MSVC\"
-
-    if (Test-Path $VCFolder)
-    {
-        $instance = New-MSBuildInstance "$instanceCandidate\MSBuild\15.0\Bin\MSBuild.exe" "v141"
-        Write-Verbose "Found $instance"
-        $validInstances.Add($instance) > $null
-    }
-}
-
-# VS2015 - in Program Files
-Write-Verbose "`n`n"
-Write-Verbose "Checking for MSBuild from VS2015 in Program Files..."
-$CandidateProgramFiles = $(& $scriptsDir\getProgramFiles32bit.ps1), $(& $scriptsDir\getProgramFilesPlatformBitness.ps1)
-Write-Verbose "Program Files Candidate locations: $([system.String]::Join(',', $CandidateProgramFiles))"
-foreach ($ProgramFiles in $CandidateProgramFiles)
-{
-    $clExe= "$ProgramFiles\Microsoft Visual Studio 14.0\VC\bin\cl.exe"
-
-    if (!(Test-Path $clExe))
-    {
-        Write-Verbose "$clExe - Not Found"
-        continue
-    }
-
-    Write-Verbose "$clExe - Found"
-    $instance = New-MSBuildInstance "$ProgramFiles\MSBuild\14.0\Bin\MSBuild.exe" "v140"
-    Write-Verbose "Found $instance"
-    $validInstances.Add($instance) > $null
-}
-
-# VS2015 - through the registry
-function NewCppRegistryPair()
-{
-    param ($visualStudioEntry, $msBuildEntry)
-
-    $instance = new-object PSObject
-    $instance | add-member -type NoteProperty -Name visualStudioEntry -Value $visualStudioEntry
-    $instance | add-member -type NoteProperty -Name msBuildEntry -Value $msBuildEntry
-
-    return $instance
-}
-
-Write-Verbose "`n`n"
-Write-Verbose "Checking for MSBuild from VS2015 through the registry..."
-
-$registryPairs =
-$(NewCppRegistryPair "Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\visualstudio\14.0" "Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\msbuild\toolsversions\14.0"),
-$(NewCppRegistryPair "Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\visualstudio\14.0" "Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\msbuild\toolsversions\14.0")
-
-foreach ($pair in $registryPairs)
+$VisualStudioInstallationInstances = & $scriptsDir\findVisualStudioInstallationInstances.ps1
+Write-Verbose "VS Candidates:`n`r$([system.String]::Join([Environment]::NewLine, $VisualStudioInstallationInstances))"
+foreach ($instanceCandidate in $VisualStudioInstallationInstances)
 {
-    $vsEntry = $pair.visualStudioEntry
-    try
-    {
-        $VS14InstallDir = $(gp $vsEntry InstallDir -erroraction Stop | % { $_.InstallDir })
-        Write-Verbose "$vsEntry\InstallDir - Found"
-    }
-    catch
-    {
-        Write-Verbose "$vsEntry\InstallDir - Not Found"
-        continue
-    }
-
-    Write-Verbose "$VS14InstallDir - Obtained from registry"
-    # We want "${VS14InstallDir}..\..\VC\bin\cl.exe"
-    # Doing Split-path to avoid the ..\.. from appearing in the output
-    $clExePath = Split-path $VS14InstallDir -Parent
-    $clExePath = Split-path $clExePath -Parent
-    $clExePath = "$clExePath\VC\bin\cl.exe"
-
-    if (!(Test-Path $clExePath))
-    {
-        Write-Verbose "$clExePath - Not Found"
-        continue
-    }
+    Write-Verbose "Inspecting: $instanceCandidate"
+    $split = $instanceCandidate -split "::"
+    # $preferenceWeight = $split[0]
+    # $releaseType = $split[1]
+    $version = $split[2]
+    $path = $split[3]
 
-    Write-Verbose "$clExePath - Found"
-
-    $msbuildEntry = $pair.msBuildEntry
-    try
-    {
-        $MSBuild14 = $(gp $msbuildEntry MSBuildToolsPath -erroraction Stop | % { $_.MSBuildToolsPath })
-        Write-Verbose "$msbuildEntry\MSBuildToolsPath - Found"
-    }
-    catch
-    {
-        Write-Verbose "$msbuildEntry\MSBuildToolsPath - Not Found"
-        continue
-    }
-
-    Write-Verbose "${MSBuild14} - Obtained from registry"
-    $msbuildPath = "${MSBuild14}MSBuild.exe"
-    if (!(Test-Path $msbuildPath))
+    if ($explicitlyRequestedVSPath -ne "" -and $explicitlyRequestedVSPath -ne $path)
     {
-        Write-Verbose "$msbuildPath - Not Found"
+        Write-Verbose "Skipping: $instanceCandidate"
         continue
     }
 
-    $instance = New-MSBuildInstance $msbuildPath "v140"
-    Write-Verbose "Found $instance"
-    $validInstances.Add($instance) > $null
-}
-
-Write-Verbose "`n`n`n"
-Write-Verbose "The following MSBuild instances were found:"
-foreach ($instance in $validInstances)
-{
-    Write-Verbose $instance
-}
-
-# Selecting
-foreach ($instance in $validInstances)
-{
-    if (!$DisableVS2017 -and $instance.toolsetVersion -eq "v141")
+    $majorVersion = $version.Substring(0,2);
+    if ($majorVersion -eq "15")
     {
-        return $instance.msbuildExePath, $instance.toolsetVersion
+        $VCFolder= "$path\VC\Tools\MSVC\"
+        if (Test-Path $VCFolder)
+        {
+            Write-Verbose "Picking: $instanceCandidate"
+            return "$path\MSBuild\15.0\Bin\MSBuild.exe", "v141"
+        }
     }
 
-    if (!$DisableVS2015 -and $instance.toolsetVersion -eq "v140")
+    if ($majorVersion -eq "14")
     {
-        return $instance.msbuildExePath, $instance.toolsetVersion
+        $clExe= "$path\VC\bin\cl.exe"
+        if (Test-Path $clExe)
+        {
+            Write-Verbose "Picking: $instanceCandidate"
+            $programFilesPath = split-path -parent $path
+            return "$programFilesPath\MSBuild\14.0\Bin\MSBuild.exe", "v140"
+        }
     }
 }
 
-
 throw "Could not find MSBuild version with C++ support. VS2015 or VS2017 (with C++) needs to be installed."
\ No newline at end of file
diff --git a/scripts/findVisualStudioInstallationInstances.ps1 b/scripts/findVisualStudioInstallationInstances.ps1
index ca807980c..8c67ef6d6 100644
--- a/scripts/findVisualStudioInstallationInstances.ps1
+++ b/scripts/findVisualStudioInstallationInstances.ps1
@@ -4,32 +4,35 @@ param(
 )
 
 $scriptsDir = split-path -parent $MyInvocation.MyCommand.Definition
-$vcpkgRootDir = & $scriptsDir\findFileRecursivelyUp.ps1 $scriptsDir .vcpkg-root
+$vswhereExe = & $scriptsDir\fetchDependency.ps1 "vswhere"
 
-$downloadsDir = "$vcpkgRootDir\downloads"
+$output = & $vswhereExe -prerelease -legacy -format xml
+[xml]$asXml = $output
 
-$nugetexe = & $scriptsDir\fetchDependency.ps1 "nuget"
-$nugetPackageDir = "$downloadsDir\nuget-packages"
-
-$SetupAPIVersion = "1.8.24"
-Write-Verbose "Fetching Microsoft.VisualStudio.Setup.Configuration.Native@$SetupAPIVersion from NuGet."
-$nugetOutput = & $nugetexe install Microsoft.VisualStudio.Setup.Configuration.Native -Version $SetupAPIVersion -OutputDirectory $nugetPackageDir -Source "https://api.nuget.org/v3/index.json" -nocache 2>&1
-Write-Verbose "Fetching Microsoft.VisualStudio.Setup.Configuration.Native@$SetupAPIVersion from NuGet. Done."
-
-$SetupConsoleExe = "$nugetPackageDir\Microsoft.VisualStudio.Setup.Configuration.Native.$SetupAPIVersion\tools\x86\Microsoft.VisualStudio.Setup.Configuration.Console.exe"
-
-if (!(Test-Path $SetupConsoleExe))
+$results = New-Object System.Collections.ArrayList
+foreach ($instance in $asXml.instances.instance)
 {
-    throw $nugetOutput
+    $installationPath = $instance.InstallationPath -replace "\\$" # Remove potential trailing backslash
+    $installationVersion = $instance.InstallationVersion
+    $isPrerelease = $instance.IsPrerelease
+    if ($isPrerelease -eq 0)
+    {
+        $releaseType = "PreferenceWeight3::StableRelease"
+    }
+    elseif ($isPrerelease -eq 1)
+    {
+        $releaseType = "PreferenceWeight2::PreRelease"
+    }
+    else
+    {
+        $releaseType = "PreferenceWeight1::Legacy"
+    }
+
+    # Placed like that for easy sorting according to preference
+    $results.Add("${releaseType}::${installationVersion}::${installationPath}") > $null
 }
 
-$instances = & $SetupConsoleExe -nologo -value InstallationPath 2>&1
-$instanceCount = $instances.Length
-
-# The last item can be empty
-if ($instanceCount -gt 0 -and $instances[$instanceCount - 1] -eq "")
-{
-    $instances = $instances[0..($instanceCount - 2)]
-}
+$results.Sort()
+$results.Reverse()
 
-return $instances
+return $results
\ No newline at end of file
diff --git a/toolsrc/include/vcpkg_Util.h b/toolsrc/include/vcpkg_Util.h
index a87045d73..facb7dd26 100644
--- a/toolsrc/include/vcpkg_Util.h
+++ b/toolsrc/include/vcpkg_Util.h
@@ -68,18 +68,12 @@ namespace vcpkg::Util
     }
 
     template<class Container>
-    using ToVectorOfConstPointersT = std::decay_t<decltype(*std::begin(std::declval<Container>()))>;
+    using ElementT = std::remove_reference_t<decltype(*begin(std::declval<Container>()))>;
 
-    template<class Container, class T = ToVectorOfConstPointersT<Container>>
-    std::vector<const T*> to_vector_of_const_pointers(const Container& cont)
+    template<class Container, class T = ElementT<Container>>
+    std::vector<T*> element_pointers(Container&& cont)
     {
-        std::vector<const T*> output;
-        for (auto i = cont.cbegin(), cend = cont.end(); i != cend; ++i)
-        {
-            output.push_back(&(*i));
-        }
-
-        return output;
+        return fmap(cont, [](auto&& x) { return &x; });
     }
 
     template<class Container, class Pred>
diff --git a/toolsrc/src/VcpkgPaths.cpp b/toolsrc/src/VcpkgPaths.cpp
index f080783c4..8264ec293 100644
--- a/toolsrc/src/VcpkgPaths.cpp
+++ b/toolsrc/src/VcpkgPaths.cpp
@@ -302,26 +302,33 @@ namespace vcpkg
             [this]() { return get_ifw_installerbase_exe().parent_path() / "repogen.exe"; });
     }
 
-    static std::vector<std::string> get_vs2017_installation_instances(const VcpkgPaths& paths)
+    struct VisualStudioInstance
+    {
+        fs::path root_path;
+        std::string version;
+        std::string release_type;
+        std::string preference_weight; // Mostly unused, just for verification that order is as intended
+
+        std::string major_version() const { return version.substr(0, 2); }
+    };
+
+    static std::vector<VisualStudioInstance> get_visual_studio_instances(const VcpkgPaths& paths)
     {
         const fs::path script = paths.scripts / "findVisualStudioInstallationInstances.ps1";
         const std::wstring cmd = System::create_powershell_script_cmd(script);
         const System::ExitCodeAndOutput ec_data = System::cmd_execute_and_capture_output(cmd);
-        Checks::check_exit(VCPKG_LINE_INFO, ec_data.exit_code == 0, "Could not run script to detect VS 2017 instances");
-        return Strings::split(ec_data.output, "\n");
-    }
+        Checks::check_exit(
+            VCPKG_LINE_INFO, ec_data.exit_code == 0, "Could not run script to detect Visual Studio instances");
 
-    static Optional<fs::path> get_vs2015_installation_instance()
-    {
-        const Optional<std::wstring> vs2015_cmntools_optional = System::get_environment_variable(L"VS140COMNTOOLS");
-        if (const auto v = vs2015_cmntools_optional.get())
+        const std::vector<std::string> instances_as_strings = Strings::split(ec_data.output, "\n");
+        std::vector<VisualStudioInstance> output;
+        for (const std::string& instance_as_string : instances_as_strings)
         {
-            const fs::path vs2015_cmntools = fs::path(*v).parent_path(); // The call to parent_path() is needed because
-                                                                         // the env variable has a trailing backslash
-            return vs2015_cmntools.parent_path().parent_path();
+            const std::vector<std::string> split = Strings::split(instance_as_string, "::");
+            output.push_back({split.at(3), split.at(2), split.at(1), split.at(0)});
         }
 
-        return nullopt;
+        return output;
     }
 
     static std::vector<Toolset> find_toolset_instances(const VcpkgPaths& paths)
@@ -335,108 +342,118 @@ namespace vcpkg
 
         std::vector<Toolset> found_toolsets;
 
-        // VS2015
-        const Optional<fs::path> vs_2015_installation_instance = get_vs2015_installation_instance();
-        if (const auto vs_2015_root_path = vs_2015_installation_instance.get())
-        {
-            const fs::path vs2015_vcvarsall_bat = *vs_2015_root_path / "VC" / "vcvarsall.bat";
+        const std::vector<VisualStudioInstance> vs_instances = get_visual_studio_instances(paths);
+        const bool v140_is_available = Util::find_if(vs_instances, [&](const VisualStudioInstance& vs_instance) {
+                                           return vs_instance.major_version() == "14";
+                                       }) != vs_instances.cend();
 
-            paths_examined.push_back(vs2015_vcvarsall_bat);
-            if (fs.exists(vs2015_vcvarsall_bat))
+        // VS2017
+        for (const VisualStudioInstance& vs_instance : vs_instances)
+        {
+            const std::string major_version = vs_instance.major_version();
+            if (major_version == "15")
             {
-                const fs::path vs2015_dumpbin_exe = *vs_2015_root_path / "VC" / "bin" / "dumpbin.exe";
-                paths_examined.push_back(vs2015_dumpbin_exe);
+                const fs::path vc_dir = vs_instance.root_path / "VC";
+
+                // Skip any instances that do not have vcvarsall.
+                const fs::path vcvarsall_dir = vc_dir / "Auxiliary" / "Build";
+                const fs::path vcvarsall_bat = vcvarsall_dir / "vcvarsall.bat";
+                paths_examined.push_back(vcvarsall_bat);
+                if (!fs.exists(vcvarsall_bat)) continue;
 
-                const fs::path vs2015_bin_dir = vs2015_vcvarsall_bat.parent_path() / "bin";
+                // Get all supported architectures
                 std::vector<ToolsetArchOption> supported_architectures;
-                if (fs.exists(vs2015_bin_dir / "vcvars32.bat"))
+                if (fs.exists(vcvarsall_dir / "vcvars32.bat"))
                     supported_architectures.push_back({L"x86", CPU::X86, CPU::X86});
-                if (fs.exists(vs2015_bin_dir / "amd64\\vcvars64.bat"))
-                    supported_architectures.push_back({L"x64", CPU::X64, CPU::X64});
-                if (fs.exists(vs2015_bin_dir / "x86_amd64\\vcvarsx86_amd64.bat"))
+                if (fs.exists(vcvarsall_dir / "vcvars64.bat"))
+                    supported_architectures.push_back({L"amd64", CPU::X64, CPU::X64});
+                if (fs.exists(vcvarsall_dir / "vcvarsx86_amd64.bat"))
                     supported_architectures.push_back({L"x86_amd64", CPU::X86, CPU::X64});
-                if (fs.exists(vs2015_bin_dir / "x86_arm\\vcvarsx86_arm.bat"))
+                if (fs.exists(vcvarsall_dir / "vcvarsx86_arm.bat"))
                     supported_architectures.push_back({L"x86_arm", CPU::X86, CPU::ARM});
-                if (fs.exists(vs2015_bin_dir / "amd64_x86\\vcvarsamd64_x86.bat"))
+                if (fs.exists(vcvarsall_dir / "vcvarsamd64_x86.bat"))
                     supported_architectures.push_back({L"amd64_x86", CPU::X64, CPU::X86});
-                if (fs.exists(vs2015_bin_dir / "amd64_arm\\vcvarsamd64_arm.bat"))
+                if (fs.exists(vcvarsall_dir / "vcvarsamd64_arm.bat"))
                     supported_architectures.push_back({L"amd64_arm", CPU::X64, CPU::ARM});
 
-                if (fs.exists(vs2015_dumpbin_exe))
+                // Locate the "best" MSVC toolchain version
+                const fs::path msvc_path = vc_dir / "Tools" / "MSVC";
+                std::vector<fs::path> msvc_subdirectories = fs.get_files_non_recursive(msvc_path);
+                Util::unstable_keep_if(msvc_subdirectories,
+                                       [&fs](const fs::path& path) { return fs.is_directory(path); });
+
+                // Sort them so that latest comes first
+                std::sort(
+                    msvc_subdirectories.begin(),
+                    msvc_subdirectories.end(),
+                    [](const fs::path& left, const fs::path& right) { return left.filename() > right.filename(); });
+
+                for (const fs::path& subdir : msvc_subdirectories)
                 {
-                    found_toolsets.push_back({*vs_2015_root_path,
-                                              vs2015_dumpbin_exe,
-                                              vs2015_vcvarsall_bat,
-                                              {},
-                                              V_140,
-                                              supported_architectures});
+                    const fs::path dumpbin_path = subdir / "bin" / "HostX86" / "x86" / "dumpbin.exe";
+                    paths_examined.push_back(dumpbin_path);
+                    if (fs.exists(dumpbin_path))
+                    {
+                        found_toolsets.push_back(Toolset{
+                            vs_instance.root_path, dumpbin_path, vcvarsall_bat, {}, V_141, supported_architectures});
+
+                        if (v140_is_available)
+                        {
+                            found_toolsets.push_back(Toolset{vs_instance.root_path,
+                                                             dumpbin_path,
+                                                             vcvarsall_bat,
+                                                             {L"-vcvars_ver=14.0"},
+                                                             V_140,
+                                                             supported_architectures});
+                        }
+
+                        break;
+                    }
                 }
-            }
-        }
 
-        const bool v140_is_available = !found_toolsets.empty();
-
-        const std::vector<std::string> vs2017_installation_instances = get_vs2017_installation_instances(paths);
+                continue;
+            }
 
-        // VS2017
-        for (const std::string& instance : vs2017_installation_instances)
-        {
-            const fs::path vs_root_path = fs::path{instance};
-            const fs::path vc_dir = vs_root_path / "VC";
-
-            // Skip any instances that do not have vcvarsall.
-            const fs::path vcvarsall_dir = vc_dir / "Auxiliary" / "Build";
-            const fs::path vcvarsall_bat = vcvarsall_dir / "vcvarsall.bat";
-            paths_examined.push_back(vcvarsall_bat);
-            if (!fs.exists(vcvarsall_bat)) continue;
-
-            // Get all supported architectures
-            std::vector<ToolsetArchOption> supported_architectures;
-            if (fs.exists(vcvarsall_dir / "vcvars32.bat"))
-                supported_architectures.push_back({L"x86", CPU::X86, CPU::X86});
-            if (fs.exists(vcvarsall_dir / "vcvars64.bat"))
-                supported_architectures.push_back({L"amd64", CPU::X64, CPU::X64});
-            if (fs.exists(vcvarsall_dir / "vcvarsx86_amd64.bat"))
-                supported_architectures.push_back({L"x86_amd64", CPU::X86, CPU::X64});
-            if (fs.exists(vcvarsall_dir / "vcvarsx86_arm.bat"))
-                supported_architectures.push_back({L"x86_arm", CPU::X86, CPU::ARM});
-            if (fs.exists(vcvarsall_dir / "vcvarsamd64_x86.bat"))
-                supported_architectures.push_back({L"amd64_x86", CPU::X64, CPU::X86});
-            if (fs.exists(vcvarsall_dir / "vcvarsamd64_arm.bat"))
-                supported_architectures.push_back({L"amd64_arm", CPU::X64, CPU::ARM});
-
-            // Locate the "best" MSVC toolchain version
-            const fs::path msvc_path = vc_dir / "Tools" / "MSVC";
-            std::vector<fs::path> msvc_subdirectories = fs.get_files_non_recursive(msvc_path);
-            Util::unstable_keep_if(msvc_subdirectories, [&fs](const fs::path& path) { return fs.is_directory(path); });
-
-            // Sort them so that latest comes first
-            std::sort(msvc_subdirectories.begin(),
-                      msvc_subdirectories.end(),
-                      [](const fs::path& left, const fs::path& right) { return left.filename() > right.filename(); });
-
-            for (const fs::path& subdir : msvc_subdirectories)
+            if (major_version == "14")
             {
-                const fs::path dumpbin_path = subdir / "bin" / "HostX86" / "x86" / "dumpbin.exe";
-                paths_examined.push_back(dumpbin_path);
-                if (fs.exists(dumpbin_path))
-                {
-                    found_toolsets.push_back(
-                        Toolset{vs_root_path, dumpbin_path, vcvarsall_bat, {}, V_141, supported_architectures});
+                const fs::path vcvarsall_bat = vs_instance.root_path / "VC" / "vcvarsall.bat";
 
-                    if (v140_is_available)
+                paths_examined.push_back(vcvarsall_bat);
+                if (fs.exists(vcvarsall_bat))
+                {
+                    const fs::path vs2015_dumpbin_exe = vs_instance.root_path / "VC" / "bin" / "dumpbin.exe";
+                    paths_examined.push_back(vs2015_dumpbin_exe);
+
+                    const fs::path vs2015_bin_dir = vcvarsall_bat.parent_path() / "bin";
+                    std::vector<ToolsetArchOption> supported_architectures;
+                    if (fs.exists(vs2015_bin_dir / "vcvars32.bat"))
+                        supported_architectures.push_back({L"x86", CPU::X86, CPU::X86});
+                    if (fs.exists(vs2015_bin_dir / "amd64\\vcvars64.bat"))
+                        supported_architectures.push_back({L"x64", CPU::X64, CPU::X64});
+                    if (fs.exists(vs2015_bin_dir / "x86_amd64\\vcvarsx86_amd64.bat"))
+                        supported_architectures.push_back({L"x86_amd64", CPU::X86, CPU::X64});
+                    if (fs.exists(vs2015_bin_dir / "x86_arm\\vcvarsx86_arm.bat"))
+                        supported_architectures.push_back({L"x86_arm", CPU::X86, CPU::ARM});
+                    if (fs.exists(vs2015_bin_dir / "amd64_x86\\vcvarsamd64_x86.bat"))
+                        supported_architectures.push_back({L"amd64_x86", CPU::X64, CPU::X86});
+                    if (fs.exists(vs2015_bin_dir / "amd64_arm\\vcvarsamd64_arm.bat"))
+                        supported_architectures.push_back({L"amd64_arm", CPU::X64, CPU::ARM});
+
+                    if (fs.exists(vs2015_dumpbin_exe))
                     {
-                        found_toolsets.push_back(Toolset{vs_root_path,
-                                                         dumpbin_path,
-                                                         vcvarsall_bat,
-                                                         {L"-vcvars_ver=14.0"},
-                                                         V_140,
-                                                         supported_architectures});
+                        found_toolsets.push_back({vs_instance.root_path,
+                                                  vs2015_dumpbin_exe,
+                                                  vcvarsall_bat,
+                                                  {},
+                                                  V_140,
+                                                  supported_architectures});
                     }
-
-                    break;
                 }
+
+                continue;
             }
+
+            Checks::exit_with_message(VCPKG_LINE_INFO, "Expected major version 14 or 15 but got: %s", major_version);
         }
 
         if (found_toolsets.empty())
@@ -460,7 +477,7 @@ namespace vcpkg
         const std::vector<Toolset>& vs_toolsets =
             this->toolsets.get_lazy([this]() { return find_toolset_instances(*this); });
 
-        std::vector<const Toolset*> candidates = Util::to_vector_of_const_pointers(vs_toolsets);
+        std::vector<const Toolset*> candidates = Util::element_pointers(vs_toolsets);
         const auto tsv = toolset_version.get();
         const auto vsp = visual_studio_path.get();
 
@@ -500,7 +517,7 @@ namespace vcpkg
                                vs_root_path.generic_string());
         }
 
-        return *candidates.back();
+        return *candidates.front();
     }
 
     Files::Filesystem& VcpkgPaths::get_filesystem() const { return Files::get_real_filesystem(); }