VS: Add Visual Studio 16 2019 generator

Add this generator *without* support for specifying the target
architecture in the generator name.  cmake-gui will be taught
to provide a field for this, and command-line builds can use -A.

Also, teach this generator to select a default target architecture
based on the host architecture.

Fixes: #18689
Inspired-by: Egor Pugin <egor.pugin@gmail.com>

8 files changed, 160 insertions, 8 deletions

diff --git a/Source/cmCMakeHostSystemInformationCommand.cxx b/Source/cmCMakeHostSystemInformationCommand.cxx
index ddc32c0..54f08bb 100644
--- a/Source/cmCMakeHostSystemInformationCommand.cxx
+++ b/Source/cmCMakeHostSystemInformationCommand.cxx
@@ -145,6 +145,22 @@ bool cmCMakeHostSystemInformationCommand::GetValue(
     if (vsSetupAPIHelper.GetVSInstanceInfo(value)) {
       cmSystemTools::ConvertToUnixSlashes(value);
     }
+  } else if (key == "VS_16_DIR") {
+    // If generating for the VS 16 IDE, use the same instance.
+    cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();
+    if (cmHasLiteralPrefix(gg->GetName(), "Visual Studio 16 ")) {
+      cmGlobalVisualStudioVersionedGenerator* vs16gen =
+        static_cast<cmGlobalVisualStudioVersionedGenerator*>(gg);
+      if (vs16gen->GetVSInstance(value)) {
+        return true;
+      }
+    }
+
+    // Otherwise, find a VS 16 instance ourselves.
+    cmVSSetupAPIHelper vsSetupAPIHelper(16);
+    if (vsSetupAPIHelper.GetVSInstanceInfo(value)) {
+      cmSystemTools::ConvertToUnixSlashes(value);
+    }
 #endif
   } else {
     std::string e = "does not recognize <key> " + key;
diff --git a/Source/cmGlobalVisualStudio10Generator.cxx b/Source/cmGlobalVisualStudio10Generator.cxx
index a6bec4b..2932970 100644
--- a/Source/cmGlobalVisualStudio10Generator.cxx
+++ b/Source/cmGlobalVisualStudio10Generator.cxx
@@ -1032,6 +1032,8 @@ const char* cmGlobalVisualStudio10Generator::GetToolsVersion() const
       return "14.0";
     case cmGlobalVisualStudioGenerator::VS15:
       return "15.0";
+    case cmGlobalVisualStudioGenerator::VS16:
+      return "16.0";
   }
   return "";
 }
diff --git a/Source/cmGlobalVisualStudioGenerator.cxx b/Source/cmGlobalVisualStudioGenerator.cxx
index dc8de03..57510df 100644
--- a/Source/cmGlobalVisualStudioGenerator.cxx
+++ b/Source/cmGlobalVisualStudioGenerator.cxx
@@ -86,6 +86,8 @@ const char* cmGlobalVisualStudioGenerator::GetIDEVersion() const
       return "14.0";
     case cmGlobalVisualStudioGenerator::VS15:
       return "15.0";
+    case cmGlobalVisualStudioGenerator::VS16:
+      return "16.0";
   }
   return "";
 }
@@ -139,6 +141,15 @@ void cmGlobalVisualStudioGenerator::WriteSLNHeader(std::ostream& fout)
         fout << "# Visual Studio 15\n";
       }
       break;
+    case cmGlobalVisualStudioGenerator::VS16:
+      // Visual Studio 16 writes .sln format 12.00
+      fout << "Microsoft Visual Studio Solution File, Format Version 12.00\n";
+      if (this->ExpressEdition) {
+        fout << "# Visual Studio Express 16 for Windows Desktop\n";
+      } else {
+        fout << "# Visual Studio 16\n";
+      }
+      break;
   }
 }
 
diff --git a/Source/cmGlobalVisualStudioGenerator.h b/Source/cmGlobalVisualStudioGenerator.h
index d44f5a5..039191c 100644
--- a/Source/cmGlobalVisualStudioGenerator.h
+++ b/Source/cmGlobalVisualStudioGenerator.h
@@ -38,7 +38,8 @@ public:
     VS12 = 120,
     /* VS13 = 130 was skipped */
     VS14 = 140,
-    VS15 = 150
+    VS15 = 150,
+    VS16 = 160
   };
 
   virtual ~cmGlobalVisualStudioGenerator();
diff --git a/Source/cmGlobalVisualStudioVersionedGenerator.cxx b/Source/cmGlobalVisualStudioVersionedGenerator.cxx
index 7d04be2..f06c019 100644
--- a/Source/cmGlobalVisualStudioVersionedGenerator.cxx
+++ b/Source/cmGlobalVisualStudioVersionedGenerator.cxx
@@ -8,6 +8,16 @@
 #include "cmMakefile.h"
 #include "cmVSSetupHelper.h"
 
+#if defined(_M_ARM64)
+#  define HOST_PLATFORM_NAME "ARM64";
+#elif defined(_M_ARM)
+#  define HOST_PLATFORM_NAME "ARM";
+#elif defined(_M_IA64)
+#  define HOST_PLATFORM_NAME "Itanium";
+#else
+#  include "cmsys/SystemInformation.hxx"
+#endif
+
 static unsigned int VSVersionToMajor(
   cmGlobalVisualStudioGenerator::VSVersion v)
 {
@@ -24,10 +34,35 @@ static unsigned int VSVersionToMajor(
       return 14;
     case cmGlobalVisualStudioGenerator::VS15:
       return 15;
+    case cmGlobalVisualStudioGenerator::VS16:
+      return 16;
   }
   return 0;
 }
 
+static const char* VSVersionToToolset(
+  cmGlobalVisualStudioGenerator::VSVersion v)
+{
+  switch (v) {
+    case cmGlobalVisualStudioGenerator::VS9:
+      return "v90";
+    case cmGlobalVisualStudioGenerator::VS10:
+      return "v100";
+    case cmGlobalVisualStudioGenerator::VS11:
+      return "v110";
+    case cmGlobalVisualStudioGenerator::VS12:
+      return "v120";
+    case cmGlobalVisualStudioGenerator::VS14:
+      return "v140";
+    case cmGlobalVisualStudioGenerator::VS15:
+      return "v141";
+    case cmGlobalVisualStudioGenerator::VS16:
+      // FIXME: VS 2019 Preview 1.1 uses v141 but preview 2 will use v142.
+      return "v141";
+  }
+  return "";
+}
+
 static const char vs15generatorName[] = "Visual Studio 15 2017";
 
 // Map generator name without year to name with year.
@@ -99,18 +134,88 @@ cmGlobalVisualStudioVersionedGenerator::NewFactory15()
   return new Factory15;
 }
 
+static const char vs16generatorName[] = "Visual Studio 16 2019";
+
+// Map generator name without year to name with year.
+static const char* cmVS16GenName(const std::string& name, std::string& genName)
+{
+  if (strncmp(name.c_str(), vs16generatorName,
+              sizeof(vs16generatorName) - 6) != 0) {
+    return 0;
+  }
+  const char* p = name.c_str() + sizeof(vs16generatorName) - 6;
+  if (cmHasLiteralPrefix(p, " 2019")) {
+    p += 5;
+  }
+  genName = std::string(vs16generatorName) + p;
+  return p;
+}
+
+class cmGlobalVisualStudioVersionedGenerator::Factory16
+  : public cmGlobalGeneratorFactory
+{
+public:
+  virtual cmGlobalGenerator* CreateGlobalGenerator(const std::string& name,
+                                                   cmake* cm) const
+  {
+    std::string genName;
+    const char* p = cmVS16GenName(name, genName);
+    if (!p) {
+      return 0;
+    }
+    if (!*p) {
+      return new cmGlobalVisualStudioVersionedGenerator(
+        cmGlobalVisualStudioGenerator::VS16, cm, genName, "");
+    }
+    return 0;
+  }
+
+  virtual void GetDocumentation(cmDocumentationEntry& entry) const
+  {
+    entry.Name = std::string(vs16generatorName);
+    entry.Brief = "Generates Visual Studio 2019 project files.  "
+                  "Use -A option to specify architecture.";
+  }
+
+  virtual void GetGenerators(std::vector<std::string>& names) const
+  {
+    names.push_back(vs16generatorName);
+  }
+
+  bool SupportsToolset() const override { return true; }
+  bool SupportsPlatform() const override { return true; }
+};
+
+cmGlobalGeneratorFactory*
+cmGlobalVisualStudioVersionedGenerator::NewFactory16()
+{
+  return new Factory16;
+}
+
 cmGlobalVisualStudioVersionedGenerator::cmGlobalVisualStudioVersionedGenerator(
   VSVersion version, cmake* cm, const std::string& name,
   std::string const& platformInGeneratorName)
   : cmGlobalVisualStudio14Generator(cm, name, platformInGeneratorName)
   , vsSetupAPIHelper(VSVersionToMajor(version))
 {
-  this->ExpressEdition = false;
-  this->DefaultPlatformToolset = "v141";
-  this->DefaultCLFlagTableName = "v141";
-  this->DefaultCSharpFlagTableName = "v141";
-  this->DefaultLinkFlagTableName = "v141";
   this->Version = version;
+  this->ExpressEdition = false;
+  this->DefaultPlatformToolset = VSVersionToToolset(this->Version);
+  this->DefaultCLFlagTableName = VSVersionToToolset(this->Version);
+  this->DefaultCSharpFlagTableName = VSVersionToToolset(this->Version);
+  this->DefaultLinkFlagTableName = VSVersionToToolset(this->Version);
+  if (this->Version >= cmGlobalVisualStudioGenerator::VS16) {
+#ifdef HOST_PLATFORM_NAME
+    this->DefaultPlatformName = HOST_PLATFORM_NAME;
+#else
+    cmsys::SystemInformation info;
+    if (info.Is64Bits()) {
+      this->DefaultPlatformName = "x64";
+    } else {
+      this->DefaultPlatformName = "Win32";
+    }
+#endif
+  }
 }
 
 bool cmGlobalVisualStudioVersionedGenerator::MatchesGeneratorName(
@@ -129,6 +234,11 @@ bool cmGlobalVisualStudioVersionedGenerator::MatchesGeneratorName(
         return genName == this->GetName();
       }
       break;
+    case cmGlobalVisualStudioGenerator::VS16:
+      if (cmVS16GenName(name, genName)) {
+        return genName == this->GetName();
+      }
+      break;
   }
   return false;
 }
@@ -239,7 +349,7 @@ bool cmGlobalVisualStudioVersionedGenerator::SelectWindowsStoreToolset(
   if (cmHasLiteralPrefix(this->SystemVersion, "10.0")) {
     if (this->IsWindowsStoreToolsetInstalled() &&
         this->IsWindowsDesktopToolsetInstalled()) {
-      toolset = "v141"; // VS 15 uses v141 toolset
+      toolset = VSVersionToToolset(this->Version);
       return true;
     } else {
       return false;
@@ -296,6 +406,10 @@ std::string cmGlobalVisualStudioVersionedGenerator::FindMSBuildCommand()
   // Ask Visual Studio Installer tool.
   std::string vs;
   if (vsSetupAPIHelper.GetVSInstanceInfo(vs)) {
+    msbuild = vs + "/MSBuild/Current/Bin/MSBuild.exe";
+    if (cmSystemTools::FileExists(msbuild)) {
+      return msbuild;
+    }
     msbuild = vs + "/MSBuild/15.0/Bin/MSBuild.exe";
     if (cmSystemTools::FileExists(msbuild)) {
       return msbuild;
diff --git a/Source/cmGlobalVisualStudioVersionedGenerator.h b/Source/cmGlobalVisualStudioVersionedGenerator.h
index 531f5a6..466816b 100644
--- a/Source/cmGlobalVisualStudioVersionedGenerator.h
+++ b/Source/cmGlobalVisualStudioVersionedGenerator.h
@@ -20,6 +20,7 @@ class cmGlobalVisualStudioVersionedGenerator
 {
 public:
   static cmGlobalGeneratorFactory* NewFactory15();
+  static cmGlobalGeneratorFactory* NewFactory16();
 
   bool MatchesGeneratorName(const std::string& name) const override;
 
@@ -57,6 +58,8 @@ protected:
 private:
   class Factory15;
   friend class Factory15;
+  class Factory16;
+  friend class Factory16;
   mutable cmVSSetupAPIHelper vsSetupAPIHelper;
 };
 #endif
diff --git a/Source/cmVisualStudioGeneratorOptions.cxx b/Source/cmVisualStudioGeneratorOptions.cxx
index afe9230..5c3e533 100644
--- a/Source/cmVisualStudioGeneratorOptions.cxx
+++ b/Source/cmVisualStudioGeneratorOptions.cxx
@@ -70,6 +70,7 @@ void cmVisualStudioGeneratorOptions::FixExceptionHandlingDefault()
     case cmGlobalVisualStudioGenerator::VS12:
     case cmGlobalVisualStudioGenerator::VS14:
     case cmGlobalVisualStudioGenerator::VS15:
+    case cmGlobalVisualStudioGenerator::VS16:
       // by default VS puts <ExceptionHandling></ExceptionHandling> empty
       // for a project, to make our projects look the same put a new line
       // and space over for the closing </ExceptionHandling> as the default
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index 1d062f4..1541810 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -1538,7 +1538,9 @@ void cmake::CreateDefaultGlobalGenerator()
     "\\Setup\\VC;ProductDir", //
     ";InstallDir"             //
   };
-  if (cmVSSetupAPIHelper(15).IsVSInstalled()) {
+  if (cmVSSetupAPIHelper(16).IsVSInstalled()) {
+    found = "Visual Studio 16 2019";
+  } else if (cmVSSetupAPIHelper(15).IsVSInstalled()) {
     found = "Visual Studio 15 2017";
   } else {
     for (VSVersionedGenerator const* g = cm::cbegin(vsGenerators);
@@ -1793,6 +1795,8 @@ void cmake::AddDefaultGenerators()
 #if defined(_WIN32) && !defined(__CYGWIN__)
 #  if !defined(CMAKE_BOOT_MINGW)
   this->Generators.push_back(
+    cmGlobalVisualStudioVersionedGenerator::NewFactory16());
+  this->Generators.push_back(
     cmGlobalVisualStudioVersionedGenerator::NewFactory15());
   this->Generators.push_back(cmGlobalVisualStudio14Generator::NewFactory());
   this->Generators.push_back(cmGlobalVisualStudio12Generator::NewFactory());