packages/flutter_tools/lib/src/windows/visual_studio.dart - external/github.com/flutter/flutter - Git at Google

 // Copyright 2014 The Flutter Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 import 'package:process/process.dart';

 import '../base/common.dart';
 import '../base/file_system.dart';
 import '../base/io.dart';
 import '../base/logger.dart';
 import '../base/platform.dart';
 import '../base/process.dart';
 import '../base/version.dart';
 import '../convert.dart';

 /// Encapsulates information about the installed copy of Visual Studio, if any.
 class VisualStudio {
   VisualStudio({
     required FileSystem fileSystem,
     required ProcessManager processManager,
     required Platform platform,
     required Logger logger,
   }) : _platform = platform,
        _fileSystem = fileSystem,
        _processUtils = ProcessUtils(processManager: processManager, logger: logger);

   final FileSystem _fileSystem;
   final Platform _platform;
   final ProcessUtils _processUtils;

   /// True if Visual Studio installation was found.
   ///
   /// Versions older than 2017 Update 2 won't be detected, so error messages to
   /// users should take into account that [false] may mean that the user may
   /// have an old version rather than no installation at all.
   bool get isInstalled => _bestVisualStudioDetails.isNotEmpty;

   bool get isAtLeastMinimumVersion {
     final int? installedMajorVersion = _majorVersion;
     return installedMajorVersion != null && installedMajorVersion >= _minimumSupportedVersion;
   }

   /// True if there is a version of Visual Studio with all the components
   /// necessary to build the project.
   bool get hasNecessaryComponents => _usableVisualStudioDetails.isNotEmpty;

   /// The name of the Visual Studio install.
   ///
   /// For instance: "Visual Studio Community 2019".
   String? get displayName => _bestVisualStudioDetails[_displayNameKey] as String?;

   /// The user-friendly version number of the Visual Studio install.
   ///
   /// For instance: "15.4.0".
   String? get displayVersion {
     if (_bestVisualStudioDetails[_catalogKey] == null) {
       return null;
     }
     return (_bestVisualStudioDetails[_catalogKey] as Map<String, dynamic>)[_catalogDisplayVersionKey] as String?;
   }

   /// The directory where Visual Studio is installed.
   String? get installLocation => _bestVisualStudioDetails[_installationPathKey] as String?;

   /// The full version of the Visual Studio install.
   ///
   /// For instance: "15.4.27004.2002".
   String? get fullVersion => _bestVisualStudioDetails[_fullVersionKey] as String?;

   // Properties that determine the status of the installation. There might be
   // Visual Studio versions that don't include them, so default to a "valid" value to
   // avoid false negatives.

   /// True if there is a complete installation of Visual Studio.
   ///
   /// False if installation is not found.
   bool get isComplete {
     if (_bestVisualStudioDetails.isEmpty) {
       return false;
     }
     return _bestVisualStudioDetails[_isCompleteKey] as bool? ?? true;
   }

   /// True if Visual Studio is launchable.
   ///
   /// False if installation is not found.
   bool get isLaunchable {
     if (_bestVisualStudioDetails.isEmpty) {
       return false;
     }
     return _bestVisualStudioDetails[_isLaunchableKey] as bool? ?? true;
   }

   /// True if the Visual Studio installation is as pre-release version.
   bool get isPrerelease => _bestVisualStudioDetails[_isPrereleaseKey] as bool? ?? false;

   /// True if a reboot is required to complete the Visual Studio installation.
   bool get isRebootRequired => _bestVisualStudioDetails[_isRebootRequiredKey] as bool? ?? false;

   /// The name of the recommended Visual Studio installer workload.
   String get workloadDescription => 'Desktop development with C++';

   /// Returns the highest installed Windows 10 SDK version, or null if none is
   /// found.
   ///
   /// For instance: 10.0.18362.0.
   String? getWindows10SDKVersion() {
     final String? sdkLocation = _getWindows10SdkLocation();
     if (sdkLocation == null) {
       return null;
     }
     final Directory sdkIncludeDirectory = _fileSystem.directory(sdkLocation).childDirectory('Include');
     if (!sdkIncludeDirectory.existsSync()) {
       return null;
     }
     // The directories in this folder are named by the SDK version.
     Version? highestVersion;
     for (final FileSystemEntity versionEntry in sdkIncludeDirectory.listSync()) {
       if (versionEntry.basename.startsWith('10.')) {
         // Version only handles 3 components; strip off the '10.' to leave three
         // components, since they all start with that.
         final Version? version = Version.parse(versionEntry.basename.substring(3));
         if (highestVersion == null || (version != null && version > highestVersion)) {
           highestVersion = version;
         }
       }
     }
     if (highestVersion == null) {
       return null;
     }
     return '10.$highestVersion';
   }

   /// The names of the components within the workload that must be installed.
   ///
   /// The descriptions of some components differ from version to version. When
   /// a supported version is present, the descriptions used will be for that
   /// version.
   List<String> necessaryComponentDescriptions() {
     return _requiredComponents().values.toList();
   }

   /// The consumer-facing version name of the minimum supported version.
   ///
   /// E.g., for Visual Studio 2019 this returns "2019" rather than "16".
   String get minimumVersionDescription {
     return '2019';
   }

   /// The path to CMake, or null if no Visual Studio installation has
   /// the components necessary to build.
   String? get cmakePath {
     final Map<String, dynamic> details = _usableVisualStudioDetails;
     if (details.isEmpty || _usableVisualStudioDetails[_installationPathKey] == null) {
       return null;
     }
     return _fileSystem.path.joinAll(<String>[
       _usableVisualStudioDetails[_installationPathKey] as String,
       'Common7',
       'IDE',
       'CommonExtensions',
       'Microsoft',
       'CMake',
       'CMake',
       'bin',
       'cmake.exe',
     ]);
   }

   /// The generator string to pass to CMake to select this Visual Studio
   /// version.
   String? get cmakeGenerator {
     // From https://cmake.org/cmake/help/v3.22/manual/cmake-generators.7.html#visual-studio-generators
     switch (_majorVersion) {
       case 17:
         return 'Visual Studio 17 2022';
       case 16:
       default:
         return 'Visual Studio 16 2019';
     }
   }

   /// The major version of the Visual Studio install, as an integer.
   int? get _majorVersion => fullVersion != null ? int.tryParse(fullVersion!.split('.')[0]) : null;

   /// The path to vswhere.exe.
   ///
   /// vswhere should be installed for VS 2017 Update 2 and later; if it's not
   /// present then there isn't a new enough installation of VS. This path is
   /// not user-controllable, unlike the install location of Visual Studio
   /// itself.
   String get _vswherePath {
     const String programFilesEnv = 'PROGRAMFILES(X86)';
     if (!_platform.environment.containsKey(programFilesEnv)) {
       throwToolExit('%$programFilesEnv% environment variable not found.');
     }
     return _fileSystem.path.join(
       _platform.environment[programFilesEnv]!,
       'Microsoft Visual Studio',
       'Installer',
       'vswhere.exe',
     );
   }

   /// Workload ID for use with vswhere requirements.
   ///
   /// Workload ID is different between Visual Studio IDE and Build Tools.
   /// See https://docs.microsoft.com/en-us/visualstudio/install/workload-and-component-ids
   static const List<String> _requiredWorkloads = <String>[
     'Microsoft.VisualStudio.Workload.NativeDesktop',
     'Microsoft.VisualStudio.Workload.VCTools'
   ];

   /// Components for use with vswhere requirements.
   ///
   /// Maps from component IDs to description in the installer UI.
   /// See https://docs.microsoft.com/en-us/visualstudio/install/workload-and-component-ids
   Map<String, String> _requiredComponents([int? majorVersion]) {
     // The description of the C++ toolchain required by the template. The
     // component name is significantly different in different versions.
     // When a new major version of VS is supported, its toolchain description
     // should be added below. It should also be made the default, so that when
     // there is no installation, the message shows the string that will be
     // relevant for the most likely fresh install case).
     String cppToolchainDescription;
     switch (majorVersion ?? _majorVersion) {
       case 16:
       default:
         cppToolchainDescription = 'MSVC v142 - VS 2019 C++ x64/x86 build tools';
     }
     // The 'Microsoft.VisualStudio.Component.VC.Tools.x86.x64' ID is assigned to the latest
     // release of the toolchain, and there can be minor updates within a given version of
     // Visual Studio. Since it changes over time, listing a precise version would become
     // wrong after each VC++ toolchain update, so just instruct people to install the
     // latest version.
     cppToolchainDescription += '\n   - If there are multiple build tool versions available, install the latest';
     // Things which are required by the workload (e.g., MSBuild) don't need to
     // be included here.
     return <String, String>{
       // The C++ toolchain required by the template.
       'Microsoft.VisualStudio.Component.VC.Tools.x86.x64': cppToolchainDescription,
       // CMake
       'Microsoft.VisualStudio.Component.VC.CMake.Project': 'C++ CMake tools for Windows',
     };
   }

   /// The minimum supported major version.
   static const int _minimumSupportedVersion = 16;  // '16' is VS 2019.

   /// vswhere argument to specify the minimum version.
   static const String _vswhereMinVersionArgument = '-version';

   /// vswhere argument to allow prerelease versions.
   static const String _vswherePrereleaseArgument = '-prerelease';

   // Keys in a VS details dictionary returned from vswhere.

   /// The root directory of the Visual Studio installation.
   static const String _installationPathKey = 'installationPath';

   /// The user-friendly name of the installation.
   static const String _displayNameKey = 'displayName';

   /// The complete version.
   static const String _fullVersionKey = 'installationVersion';

   /// Keys for the status of the installation.
   static const String _isCompleteKey = 'isComplete';
   static const String _isLaunchableKey = 'isLaunchable';
   static const String _isRebootRequiredKey = 'isRebootRequired';

   /// The 'catalog' entry containing more details.
   static const String _catalogKey = 'catalog';

   /// The key for a pre-release version.
   static const String _isPrereleaseKey = 'isPrerelease';

   /// The user-friendly version.
   ///
   /// This key is under the 'catalog' entry.
   static const String _catalogDisplayVersionKey = 'productDisplayVersion';

   /// The registry path for Windows 10 SDK installation details.
   static const String _windows10SdkRegistryPath = r'HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Microsoft SDKs\Windows\v10.0';

   /// The registry key in _windows10SdkRegistryPath for the folder where the
   /// SDKs are installed.
   static const String _windows10SdkRegistryKey = 'InstallationFolder';

   /// Returns the details dictionary for the newest version of Visual Studio.
   /// If [validateRequirements] is set, the search will be limited to versions
   /// that have all of the required workloads and components.
   Map<String, dynamic>? _visualStudioDetails({
       bool validateRequirements = false,
       List<String>? additionalArguments,
       String? requiredWorkload
     }) {
     final List<String> requirementArguments = validateRequirements
         ? <String>[
             if (requiredWorkload != null) ...<String>[
               '-requires',
               requiredWorkload,
             ],
             ..._requiredComponents(_minimumSupportedVersion).keys
           ]
         : <String>[];
     try {
       final List<String> defaultArguments = <String>[
         '-format', 'json',
         '-products', '*',
         '-utf8',
         '-latest',
       ];
       final RunResult whereResult = _processUtils.runSync(<String>[
         _vswherePath,
         ...defaultArguments,
         ...?additionalArguments,
         ...requirementArguments,
       ], encoding: utf8);
       if (whereResult.exitCode == 0) {
         final List<Map<String, dynamic>> installations =
             (json.decode(whereResult.stdout) as List<dynamic>).cast<Map<String, dynamic>>();
         if (installations.isNotEmpty) {
           return installations[0];
         }
       }
     } on ArgumentError {
       // Thrown if vswhere doesn't exist; ignore and return null below.
     } on ProcessException {
       // Ignored, return null below.
     } on FormatException {
       // may be thrown if invalid JSON is returned.
     }
     return null;
   }

   /// Checks if the given installation has issues that the user must resolve.
   ///
   /// Returns false if the required information is missing since older versions
   /// of Visual Studio might not include them.
   bool installationHasIssues(Map<String, dynamic>installationDetails) {
     assert(installationDetails != null);
     if (installationDetails[_isCompleteKey] != null && !(installationDetails[_isCompleteKey] as bool)) {
       return true;
     }

     if (installationDetails[_isLaunchableKey] != null && !(installationDetails[_isLaunchableKey] as bool)) {
       return true;
     }

     if (installationDetails[_isRebootRequiredKey] != null && installationDetails[_isRebootRequiredKey] as bool) {
       return true;
     }

     return false;
   }

   /// Returns the details dictionary for the latest version of Visual Studio
   /// that has all required components and is a supported version, or {} if
   /// there is no such installation.
   ///
   /// If no installation is found, the cached VS details are set to an empty map
   /// to avoid repeating vswhere queries that have already not found an installation.
   late final Map<String, dynamic> _usableVisualStudioDetails = (){
     final List<String> minimumVersionArguments = <String>[
       _vswhereMinVersionArgument,
       _minimumSupportedVersion.toString(),
     ];
     Map<String, dynamic>? visualStudioDetails;
     // Check in the order of stable VS, stable BT, pre-release VS, pre-release BT
     for (final bool checkForPrerelease in <bool>[false, true]) {
       for (final String requiredWorkload in _requiredWorkloads) {
         visualStudioDetails ??= _visualStudioDetails(
           validateRequirements: true,
           additionalArguments: checkForPrerelease
               ? <String>[...minimumVersionArguments, _vswherePrereleaseArgument]
               : minimumVersionArguments,
           requiredWorkload: requiredWorkload);
       }
     }

     Map<String, dynamic>? usableVisualStudioDetails;
     if (visualStudioDetails != null) {
       if (installationHasIssues(visualStudioDetails)) {
         _cachedAnyVisualStudioDetails = visualStudioDetails;
       } else {
         usableVisualStudioDetails = visualStudioDetails;
       }
     }
     return usableVisualStudioDetails ?? <String, dynamic>{};
   }();

   /// Returns the details dictionary of the latest version of Visual Studio,
   /// regardless of components and version, or {} if no such installation is
   /// found.
   ///
   /// If no installation is found, the cached VS details are set to an empty map
   /// to avoid repeating vswhere queries that have already not found an
   /// installation.
   Map<String, dynamic>? _cachedAnyVisualStudioDetails;
   Map<String, dynamic> get _anyVisualStudioDetails {
     // Search for all types of installations.
     _cachedAnyVisualStudioDetails ??= _visualStudioDetails(
         additionalArguments: <String>[_vswherePrereleaseArgument, '-all']);
     // Add a sentinel empty value to avoid querying vswhere again.
     _cachedAnyVisualStudioDetails ??= <String, dynamic>{};
     return _cachedAnyVisualStudioDetails!;
   }

   /// Returns the details dictionary of the best available version of Visual
   /// Studio.
   ///
   /// If there's a version that has all the required components, that
   /// will be returned, otherwise returns the latest installed version (if any).
   Map<String, dynamic> get _bestVisualStudioDetails {
     if (_usableVisualStudioDetails.isNotEmpty) {
       return _usableVisualStudioDetails;
     }
     return _anyVisualStudioDetails;
   }

   /// Returns the installation location of the Windows 10 SDKs, or null if the
   /// registry doesn't contain that information.
   String? _getWindows10SdkLocation() {
     try {
       final RunResult result = _processUtils.runSync(<String>[
         'reg',
         'query',
         _windows10SdkRegistryPath,
         '/v',
         _windows10SdkRegistryKey,
       ]);
       if (result.exitCode == 0) {
         final RegExp pattern = RegExp(r'InstallationFolder\s+REG_SZ\s+(.+)');
         final RegExpMatch? match = pattern.firstMatch(result.stdout);
         if (match != null) {
           return match.group(1)!.trim();
         }
       }
     } on ArgumentError {
       // Thrown if reg somehow doesn't exist; ignore and return null below.
     } on ProcessException {
       // Ignored, return null below.
     }
     return null;
   }

   /// Returns the highest-numbered SDK version in [dir], which should be the
   /// Windows 10 SDK installation directory.
   ///
   /// Returns null if no Windows 10 SDKs are found.
   String? findHighestVersionInSdkDirectory(Directory dir) {
     // This contains subfolders that are named by the SDK version.
     final Directory includeDir = dir.childDirectory('Includes');
     if (!includeDir.existsSync()) {
       return null;
     }
     Version? highestVersion;
     for (final FileSystemEntity versionEntry in includeDir.listSync()) {
       if (!versionEntry.basename.startsWith('10.')) {
         continue;
       }
       // Version only handles 3 components; strip off the '10.' to leave three
       // components, since they all start with that.
       final Version? version = Version.parse(versionEntry.basename.substring(3));
       if (highestVersion == null || (version != null && version > highestVersion)) {
         highestVersion = version;
       }
     }
     // Re-add the leading '10.' that was removed for comparison.
     return highestVersion == null ? null : '10.$highestVersion';
   }
 }
	// Copyright 2014 The Flutter Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	import 'package:process/process.dart';

	import '../base/common.dart';
	import '../base/file_system.dart';
	import '../base/io.dart';
	import '../base/logger.dart';
	import '../base/platform.dart';
	import '../base/process.dart';
	import '../base/version.dart';
	import '../convert.dart';

	/// Encapsulates information about the installed copy of Visual Studio, if any.
	class VisualStudio {
	VisualStudio({
	required FileSystem fileSystem,
	required ProcessManager processManager,
	required Platform platform,
	required Logger logger,
	}) : _platform = platform,
	_fileSystem = fileSystem,
	_processUtils = ProcessUtils(processManager: processManager, logger: logger);

	final FileSystem _fileSystem;
	final Platform _platform;
	final ProcessUtils _processUtils;

	/// True if Visual Studio installation was found.
	///
	/// Versions older than 2017 Update 2 won't be detected, so error messages to
	/// users should take into account that [false] may mean that the user may
	/// have an old version rather than no installation at all.
	bool get isInstalled => _bestVisualStudioDetails.isNotEmpty;

	bool get isAtLeastMinimumVersion {
	final int? installedMajorVersion = _majorVersion;
	return installedMajorVersion != null && installedMajorVersion >= _minimumSupportedVersion;
	}

	/// True if there is a version of Visual Studio with all the components
	/// necessary to build the project.
	bool get hasNecessaryComponents => _usableVisualStudioDetails.isNotEmpty;

	/// The name of the Visual Studio install.
	///
	/// For instance: "Visual Studio Community 2019".
	String? get displayName => _bestVisualStudioDetails[_displayNameKey] as String?;

	/// The user-friendly version number of the Visual Studio install.
	///
	/// For instance: "15.4.0".
	String? get displayVersion {
	if (_bestVisualStudioDetails[_catalogKey] == null) {
	return null;
	}
	return (_bestVisualStudioDetails[_catalogKey] as Map<String, dynamic>)[_catalogDisplayVersionKey] as String?;
	}

	/// The directory where Visual Studio is installed.
	String? get installLocation => _bestVisualStudioDetails[_installationPathKey] as String?;

	/// The full version of the Visual Studio install.
	///
	/// For instance: "15.4.27004.2002".
	String? get fullVersion => _bestVisualStudioDetails[_fullVersionKey] as String?;

	// Properties that determine the status of the installation. There might be
	// Visual Studio versions that don't include them, so default to a "valid" value to
	// avoid false negatives.

	/// True if there is a complete installation of Visual Studio.
	///
	/// False if installation is not found.
	bool get isComplete {
	if (_bestVisualStudioDetails.isEmpty) {
	return false;
	}
	return _bestVisualStudioDetails[_isCompleteKey] as bool? ?? true;
	}

	/// True if Visual Studio is launchable.
	///
	/// False if installation is not found.
	bool get isLaunchable {
	if (_bestVisualStudioDetails.isEmpty) {
	return false;
	}
	return _bestVisualStudioDetails[_isLaunchableKey] as bool? ?? true;
	}

	/// True if the Visual Studio installation is as pre-release version.
	bool get isPrerelease => _bestVisualStudioDetails[_isPrereleaseKey] as bool? ?? false;

	/// True if a reboot is required to complete the Visual Studio installation.
	bool get isRebootRequired => _bestVisualStudioDetails[_isRebootRequiredKey] as bool? ?? false;

	/// The name of the recommended Visual Studio installer workload.
	String get workloadDescription => 'Desktop development with C++';

	/// Returns the highest installed Windows 10 SDK version, or null if none is
	/// found.
	///
	/// For instance: 10.0.18362.0.
	String? getWindows10SDKVersion() {
	final String? sdkLocation = _getWindows10SdkLocation();
	if (sdkLocation == null) {
	return null;
	}
	final Directory sdkIncludeDirectory = _fileSystem.directory(sdkLocation).childDirectory('Include');
	if (!sdkIncludeDirectory.existsSync()) {
	return null;
	}
	// The directories in this folder are named by the SDK version.
	Version? highestVersion;
	for (final FileSystemEntity versionEntry in sdkIncludeDirectory.listSync()) {
	if (versionEntry.basename.startsWith('10.')) {
	// Version only handles 3 components; strip off the '10.' to leave three
	// components, since they all start with that.
	final Version? version = Version.parse(versionEntry.basename.substring(3));
	if (highestVersion == null \|\| (version != null && version > highestVersion)) {
	highestVersion = version;
	}
	}
	}
	if (highestVersion == null) {
	return null;
	}
	return '10.$highestVersion';
	}

	/// The names of the components within the workload that must be installed.
	///
	/// The descriptions of some components differ from version to version. When
	/// a supported version is present, the descriptions used will be for that
	/// version.
	List<String> necessaryComponentDescriptions() {
	return _requiredComponents().values.toList();
	}

	/// The consumer-facing version name of the minimum supported version.
	///
	/// E.g., for Visual Studio 2019 this returns "2019" rather than "16".
	String get minimumVersionDescription {
	return '2019';
	}

	/// The path to CMake, or null if no Visual Studio installation has
	/// the components necessary to build.
	String? get cmakePath {
	final Map<String, dynamic> details = _usableVisualStudioDetails;
	if (details.isEmpty \|\| _usableVisualStudioDetails[_installationPathKey] == null) {
	return null;
	}
	return _fileSystem.path.joinAll(<String>[
	_usableVisualStudioDetails[_installationPathKey] as String,
	'Common7',
	'IDE',
	'CommonExtensions',
	'Microsoft',
	'CMake',
	'CMake',
	'bin',
	'cmake.exe',
	]);
	}

	/// The generator string to pass to CMake to select this Visual Studio
	/// version.
	String? get cmakeGenerator {
	// From https://cmake.org/cmake/help/v3.22/manual/cmake-generators.7.html#visual-studio-generators
	switch (_majorVersion) {
	case 17:
	return 'Visual Studio 17 2022';
	case 16:
	default:
	return 'Visual Studio 16 2019';
	}
	}

	/// The major version of the Visual Studio install, as an integer.
	int? get _majorVersion => fullVersion != null ? int.tryParse(fullVersion!.split('.')[0]) : null;

	/// The path to vswhere.exe.
	///
	/// vswhere should be installed for VS 2017 Update 2 and later; if it's not
	/// present then there isn't a new enough installation of VS. This path is
	/// not user-controllable, unlike the install location of Visual Studio
	/// itself.
	String get _vswherePath {
	const String programFilesEnv = 'PROGRAMFILES(X86)';
	if (!_platform.environment.containsKey(programFilesEnv)) {
	throwToolExit('%$programFilesEnv% environment variable not found.');
	}
	return _fileSystem.path.join(
	_platform.environment[programFilesEnv]!,
	'Microsoft Visual Studio',
	'Installer',
	'vswhere.exe',
	);
	}

	/// Workload ID for use with vswhere requirements.
	///
	/// Workload ID is different between Visual Studio IDE and Build Tools.
	/// See https://docs.microsoft.com/en-us/visualstudio/install/workload-and-component-ids
	static const List<String> _requiredWorkloads = <String>[
	'Microsoft.VisualStudio.Workload.NativeDesktop',
	'Microsoft.VisualStudio.Workload.VCTools'
	];

	/// Components for use with vswhere requirements.
	///
	/// Maps from component IDs to description in the installer UI.
	/// See https://docs.microsoft.com/en-us/visualstudio/install/workload-and-component-ids
	Map<String, String> _requiredComponents([int? majorVersion]) {
	// The description of the C++ toolchain required by the template. The
	// component name is significantly different in different versions.
	// When a new major version of VS is supported, its toolchain description
	// should be added below. It should also be made the default, so that when
	// there is no installation, the message shows the string that will be
	// relevant for the most likely fresh install case).
	String cppToolchainDescription;
	switch (majorVersion ?? _majorVersion) {
	case 16:
	default:
	cppToolchainDescription = 'MSVC v142 - VS 2019 C++ x64/x86 build tools';
	}
	// The 'Microsoft.VisualStudio.Component.VC.Tools.x86.x64' ID is assigned to the latest
	// release of the toolchain, and there can be minor updates within a given version of
	// Visual Studio. Since it changes over time, listing a precise version would become
	// wrong after each VC++ toolchain update, so just instruct people to install the
	// latest version.
	cppToolchainDescription += '\n - If there are multiple build tool versions available, install the latest';
	// Things which are required by the workload (e.g., MSBuild) don't need to
	// be included here.
	return <String, String>{
	// The C++ toolchain required by the template.
	'Microsoft.VisualStudio.Component.VC.Tools.x86.x64': cppToolchainDescription,
	// CMake
	'Microsoft.VisualStudio.Component.VC.CMake.Project': 'C++ CMake tools for Windows',
	};
	}

	/// The minimum supported major version.
	static const int _minimumSupportedVersion = 16; // '16' is VS 2019.

	/// vswhere argument to specify the minimum version.
	static const String _vswhereMinVersionArgument = '-version';

	/// vswhere argument to allow prerelease versions.
	static const String _vswherePrereleaseArgument = '-prerelease';

	// Keys in a VS details dictionary returned from vswhere.

	/// The root directory of the Visual Studio installation.
	static const String _installationPathKey = 'installationPath';

	/// The user-friendly name of the installation.
	static const String _displayNameKey = 'displayName';

	/// The complete version.
	static const String _fullVersionKey = 'installationVersion';

	/// Keys for the status of the installation.
	static const String _isCompleteKey = 'isComplete';
	static const String _isLaunchableKey = 'isLaunchable';
	static const String _isRebootRequiredKey = 'isRebootRequired';

	/// The 'catalog' entry containing more details.
	static const String _catalogKey = 'catalog';

	/// The key for a pre-release version.
	static const String _isPrereleaseKey = 'isPrerelease';

	/// The user-friendly version.
	///
	/// This key is under the 'catalog' entry.
	static const String _catalogDisplayVersionKey = 'productDisplayVersion';

	/// The registry path for Windows 10 SDK installation details.
	static const String _windows10SdkRegistryPath = r'HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Microsoft SDKs\Windows\v10.0';

	/// The registry key in _windows10SdkRegistryPath for the folder where the
	/// SDKs are installed.
	static const String _windows10SdkRegistryKey = 'InstallationFolder';

	/// Returns the details dictionary for the newest version of Visual Studio.
	/// If [validateRequirements] is set, the search will be limited to versions
	/// that have all of the required workloads and components.
	Map<String, dynamic>? _visualStudioDetails({
	bool validateRequirements = false,
	List<String>? additionalArguments,
	String? requiredWorkload
	}) {
	final List<String> requirementArguments = validateRequirements
	? <String>[
	if (requiredWorkload != null) ...<String>[
	'-requires',
	requiredWorkload,
	],
	..._requiredComponents(_minimumSupportedVersion).keys
	]
	: <String>[];
	try {
	final List<String> defaultArguments = <String>[
	'-format', 'json',
	'-products', '*',
	'-utf8',
	'-latest',
	];
	final RunResult whereResult = _processUtils.runSync(<String>[
	_vswherePath,
	...defaultArguments,
	...?additionalArguments,
	...requirementArguments,
	], encoding: utf8);
	if (whereResult.exitCode == 0) {
	final List<Map<String, dynamic>> installations =
	(json.decode(whereResult.stdout) as List<dynamic>).cast<Map<String, dynamic>>();
	if (installations.isNotEmpty) {
	return installations[0];
	}
	}
	} on ArgumentError {
	// Thrown if vswhere doesn't exist; ignore and return null below.
	} on ProcessException {
	// Ignored, return null below.
	} on FormatException {
	// may be thrown if invalid JSON is returned.
	}
	return null;
	}

	/// Checks if the given installation has issues that the user must resolve.
	///
	/// Returns false if the required information is missing since older versions
	/// of Visual Studio might not include them.
	bool installationHasIssues(Map<String, dynamic>installationDetails) {
	assert(installationDetails != null);
	if (installationDetails[_isCompleteKey] != null && !(installationDetails[_isCompleteKey] as bool)) {
	return true;
	}

	if (installationDetails[_isLaunchableKey] != null && !(installationDetails[_isLaunchableKey] as bool)) {
	return true;
	}

	if (installationDetails[_isRebootRequiredKey] != null && installationDetails[_isRebootRequiredKey] as bool) {
	return true;
	}

	return false;
	}

	/// Returns the details dictionary for the latest version of Visual Studio
	/// that has all required components and is a supported version, or {} if
	/// there is no such installation.
	///
	/// If no installation is found, the cached VS details are set to an empty map
	/// to avoid repeating vswhere queries that have already not found an installation.
	late final Map<String, dynamic> _usableVisualStudioDetails = (){
	final List<String> minimumVersionArguments = <String>[
	_vswhereMinVersionArgument,
	_minimumSupportedVersion.toString(),
	];
	Map<String, dynamic>? visualStudioDetails;
	// Check in the order of stable VS, stable BT, pre-release VS, pre-release BT
	for (final bool checkForPrerelease in <bool>[false, true]) {
	for (final String requiredWorkload in _requiredWorkloads) {
	visualStudioDetails ??= _visualStudioDetails(
	validateRequirements: true,
	additionalArguments: checkForPrerelease
	? <String>[...minimumVersionArguments, _vswherePrereleaseArgument]
	: minimumVersionArguments,
	requiredWorkload: requiredWorkload);
	}
	}

	Map<String, dynamic>? usableVisualStudioDetails;
	if (visualStudioDetails != null) {
	if (installationHasIssues(visualStudioDetails)) {
	_cachedAnyVisualStudioDetails = visualStudioDetails;
	} else {
	usableVisualStudioDetails = visualStudioDetails;
	}
	}
	return usableVisualStudioDetails ?? <String, dynamic>{};
	}();

	/// Returns the details dictionary of the latest version of Visual Studio,
	/// regardless of components and version, or {} if no such installation is
	/// found.
	///
	/// If no installation is found, the cached VS details are set to an empty map
	/// to avoid repeating vswhere queries that have already not found an
	/// installation.
	Map<String, dynamic>? _cachedAnyVisualStudioDetails;
	Map<String, dynamic> get _anyVisualStudioDetails {
	// Search for all types of installations.
	_cachedAnyVisualStudioDetails ??= _visualStudioDetails(
	additionalArguments: <String>[_vswherePrereleaseArgument, '-all']);
	// Add a sentinel empty value to avoid querying vswhere again.
	_cachedAnyVisualStudioDetails ??= <String, dynamic>{};
	return _cachedAnyVisualStudioDetails!;
	}

	/// Returns the details dictionary of the best available version of Visual
	/// Studio.
	///
	/// If there's a version that has all the required components, that
	/// will be returned, otherwise returns the latest installed version (if any).
	Map<String, dynamic> get _bestVisualStudioDetails {
	if (_usableVisualStudioDetails.isNotEmpty) {
	return _usableVisualStudioDetails;
	}
	return _anyVisualStudioDetails;
	}

	/// Returns the installation location of the Windows 10 SDKs, or null if the
	/// registry doesn't contain that information.
	String? _getWindows10SdkLocation() {
	try {
	final RunResult result = _processUtils.runSync(<String>[
	'reg',
	'query',
	_windows10SdkRegistryPath,
	'/v',
	_windows10SdkRegistryKey,
	]);
	if (result.exitCode == 0) {
	final RegExp pattern = RegExp(r'InstallationFolder\s+REG_SZ\s+(.+)');
	final RegExpMatch? match = pattern.firstMatch(result.stdout);
	if (match != null) {
	return match.group(1)!.trim();
	}
	}
	} on ArgumentError {
	// Thrown if reg somehow doesn't exist; ignore and return null below.
	} on ProcessException {
	// Ignored, return null below.
	}
	return null;
	}

	/// Returns the highest-numbered SDK version in [dir], which should be the
	/// Windows 10 SDK installation directory.
	///
	/// Returns null if no Windows 10 SDKs are found.
	String? findHighestVersionInSdkDirectory(Directory dir) {
	// This contains subfolders that are named by the SDK version.
	final Directory includeDir = dir.childDirectory('Includes');
	if (!includeDir.existsSync()) {
	return null;
	}
	Version? highestVersion;
	for (final FileSystemEntity versionEntry in includeDir.listSync()) {
	if (!versionEntry.basename.startsWith('10.')) {
	continue;
	}
	// Version only handles 3 components; strip off the '10.' to leave three
	// components, since they all start with that.
	final Version? version = Version.parse(versionEntry.basename.substring(3));
	if (highestVersion == null \|\| (version != null && version > highestVersion)) {
	highestVersion = version;
	}
	}
	// Re-add the leading '10.' that was removed for comparison.
	return highestVersion == null ? null : '10.$highestVersion';
	}
	}