Add driver flags for C++ interop.

The flags (-enable-experimental-cxx-interop and -experimental-cxx-stdlib) carry
"experimental" in the name to emphasize that C++ interop is still an
experimental feature.

Author: martinboehme

include/swift/AST/DiagnosticsDriver.def

@@ -207,6 +207,10 @@ ERROR(cannot_find_migration_script, none,
 ERROR(error_darwin_static_stdlib_not_supported, none,
       "-static-stdlib is no longer supported on Apple platforms", ())
 
+ERROR(error_darwin_only_supports_libcxx, none,
+      "The only C++ standard library supported on Apple platforms is libc++",
+      ())
+
 WARNING(warn_drv_darwin_sdk_invalid_settings, none,
     "SDK settings were ignored because 'SDKSettings.json' could not be parsed",
     ())

include/swift/Driver/ToolChain.h

@@ -105,8 +105,6 @@ class ToolChain {
 
     const char *computeFrontendModeForCompile() const;
 
-    bool cxxInteropEnabled() const;
-
     void addFrontendInputAndOutputArguments(
         llvm::opt::ArgStringList &Arguments,
         std::vector<FilelistInfo> &FilelistInfos) const;

include/swift/Option/Options.td

@@ -516,6 +516,14 @@ def enable_experimental_concise_pound_file : Flag<["-"],
   Flags<[FrontendOption]>,
   HelpText<"Enable experimental concise '#file' identifier">;
 
+def enable_experimental_cxx_interop :
+  Flag<["-"], "enable-experimental-cxx-interop">,
+  HelpText<"Enable C++ interop code generation and config directives">;
+
+def experimental_cxx_stdlib :
+  Separate<["-"], "experimental-cxx-stdlib">,
+  HelpText<"C++ standard library to use; forwarded to Clang's -stdlib flag">;
+
 // Diagnostic control options
 def suppress_warnings : Flag<["-"], "suppress-warnings">,
   Flags<[FrontendOption]>,

lib/Driver/DarwinToolChains.cpp

@@ -712,8 +712,8 @@ toolchains::Darwin::constructInvocation(const DynamicLinkJobAction &job,
   Arguments.push_back("-arch");
   Arguments.push_back(context.Args.MakeArgString(getTriple().getArchName()));
 
-  if (context.cxxInteropEnabled()) {
-    // On Darwin, we only support libc++.
+  // On Darwin, we only support libc++.
+  if (context.Args.hasArg(options::OPT_enable_experimental_cxx_interop)) {
     Arguments.push_back("-lc++");
   }
 
@@ -860,6 +860,13 @@ toolchains::Darwin::validateArguments(DiagnosticEngine &diags,
   if (args.hasArg(options::OPT_static_stdlib)) {
     diags.diagnose(SourceLoc(), diag::error_darwin_static_stdlib_not_supported);
   }
+
+  // If a C++ standard library is specified, it has to be libc++.
+  if (auto arg = args.getLastArg(options::OPT_experimental_cxx_stdlib)) {
+    if (StringRef(arg->getValue()) != "libc++") {
+      diags.diagnose(SourceLoc(), diag::error_darwin_only_supports_libcxx); 
+    }
+  }
 }
 
 void

lib/Driver/ToolChain.cpp

@@ -67,19 +67,6 @@ ToolChain::JobContext::getTemporaryFilePath(const llvm::Twine &name,
   return C.getArgs().MakeArgString(buffer.str());
 }
 
-bool
-ToolChain::JobContext::cxxInteropEnabled() const {
-  // TODO: Eventually, we'll want to have a driver flag to control C++ interop,
-  // but for the time being, we just query the frontend flag.
-  for (const Arg *A : Args.filtered(options::OPT_Xfrontend)) {
-    if (A->containsValue("-enable-cxx-interop")) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
 Optional<Job::ResponseFileInfo>
 ToolChain::getResponseFileInfo(const Compilation &C, const char *executablePath,
                                const ToolChain::InvocationInfo &invocationInfo,

lib/Driver/ToolChains.cpp

@@ -170,6 +170,17 @@ static void addCommonFrontendArgs(const ToolChain &TC, const OutputInfo &OI,
     arguments.push_back("-disable-objc-interop");
   }
 
+  // Add flags for C++ interop.
+  if (inputArgs.hasArg(options::OPT_enable_experimental_cxx_interop)) {
+    arguments.push_back("-enable-cxx-interop");
+  }
+  if (const Arg *arg =
+      inputArgs.getLastArg(options::OPT_experimental_cxx_stdlib)) {
+    arguments.push_back("-Xcc");
+    arguments.push_back(inputArgs.MakeArgString(
+        Twine("-stdlib=") + arg->getValue()));
+  }
+
   // Handle the CPU and its preferences.
   inputArgs.AddLastArg(arguments, options::OPT_target_cpu);
 

lib/Driver/UnixToolChains.cpp

@@ -186,19 +186,9 @@ toolchains::GenericUnix::constructInvocation(const DynamicLinkJobAction &job,
   // a C++ standard library if it's not needed, in particular because the
   // standard library that `clang++` selects by default may not be the one that
   // is desired.
-  //
-  // TODO: In principle, it should be possible to use a different C++ standard
-  // library than the one configured by default by passing a `-stdlib` option
-  // to `-Xcc` and `-Xclang-linker`, e.g.
-  // `-Xcc -stdlib=libc++ -Xclang-linker -stdlib=libc++`.
-  // Once there is a driver flag for C++ interop, we will probably also want to
-  // add a driver flag for selecting the C++ standard library.
-  //
-  // In practice, using libc++ on Linux, for example, does not work because the
-  // SwiftGlibc module definition is incompatible with libc++'s header layout.
-  // We probably need to ensure that we use libc++'s own module map instead of 
-  // the SwiftGlibc module map.
-  const char *Clang = context.cxxInteropEnabled()? "clang++" : "clang";
+  const char *Clang =
+      context.Args.hasArg(options::OPT_enable_experimental_cxx_interop) ?
+      "clang++" : "clang";
   if (const Arg *A = context.Args.getLastArg(options::OPT_tools_directory)) {
     StringRef toolchainPath(A->getValue());
 
@@ -306,6 +296,13 @@ toolchains::GenericUnix::constructInvocation(const DynamicLinkJobAction &job,
     }
   }
 
+  // Link against the desired C++ standard library.
+  if (const Arg *A =
+      context.Args.getLastArg(options::OPT_experimental_cxx_stdlib)) {
+    Arguments.push_back(context.Args.MakeArgString(
+        Twine("-stdlib=") + A->getValue()));
+  }
+
   // Explicitly pass the target to the linker
   Arguments.push_back(
       context.Args.MakeArgString("--target=" + getTriple().str()));

lib/Driver/WindowsToolChains.cpp

@@ -85,7 +85,9 @@ toolchains::Windows::constructInvocation(const DynamicLinkJobAction &job,
   }
 
   // Configure the toolchain.
-  const char *Clang = context.cxxInteropEnabled()? "clang++" : "clang";
+  const char *Clang =
+      context.Args.hasArg(options::OPT_enable_experimental_cxx_interop) ?
+      "clang++" : "clang";
   if (const Arg *A = context.Args.getLastArg(options::OPT_tools_directory)) {
     StringRef toolchainPath(A->getValue());
 
@@ -143,6 +145,13 @@ toolchains::Windows::constructInvocation(const DynamicLinkJobAction &job,
     Arguments.push_back(context.Args.MakeArgString(context.OI.SDKPath));
   }
 
+  // Link against the desired C++ standard library.
+  if (const Arg *A =
+      context.Args.getLastArg(options::OPT_experimental_cxx_stdlib)) {
+    Arguments.push_back(context.Args.MakeArgString(
+        Twine("-stdlib=") + A->getValue()));
+  }
+
   if (job.getKind() == LinkKind::Executable) {
     if (context.OI.SelectedSanitizers & SanitizerKind::Address)
       addLinkRuntimeLib(context.Args, Arguments,

test/Driver/cxx_interop.swift

@@ -0,0 +1,10 @@
+// RUN: %swiftc_driver -driver-print-jobs -target x86_64-apple-macosx10.9 %s -enable-experimental-cxx-interop 2>^1 | %FileCheck -check-prefix ENABLE %s
+
+// RUN: %swiftc_driver -driver-print-jobs -target x86_64-apple-macosx10.9 %s -enable-experimental-cxx-interop -experimental-cxx-stdlib libc++ 2>^1 | %FileCheck -check-prefix STDLIB %s
+
+// ENABLE: swift
+// ENABLE: -enable-cxx-interop
+
+// STDLIB: swift
+// STDLIB-DAG: -enable-cxx-interop
+// STDLIB-DAG: -Xcc -stdlib=libc++

test/Driver/linker.swift

@@ -101,11 +101,12 @@
 // INFERRED_NAMED_DARWIN tests above: 'libLINKER.dylib'.
 // RUN: %swiftc_driver -driver-print-jobs -target x86_64-apple-macosx10.9 -emit-library %s -o libLINKER.dylib | %FileCheck -check-prefix INFERRED_NAME_DARWIN %s
 
-// RUN: %swiftc_driver -driver-print-jobs -target x86_64-apple-ios7.1 -Xfrontend -enable-cxx-interop %s 2>&1 | %FileCheck -check-prefix IOS-cxx-interop %s
+// RUN: %swiftc_driver -driver-print-jobs -target x86_64-apple-ios7.1 -enable-experimental-cxx-interop -experimental-cxx-stdlib libc++ %s 2>&1 | %FileCheck -check-prefix IOS-cxx-interop %s
+// RUN: not %swiftc_driver -driver-print-jobs -target x86_64-apple-ios7.1 -enable-experimental-cxx-interop -experimental-cxx-stdlib libstdc++ %s 2>&1 | %FileCheck -check-prefix IOS-cxx-interop-libstdcxx %s
 
-// RUN: %swiftc_driver -driver-print-jobs -target x86_64-unknown-linux-gnu -Xfrontend -enable-cxx-interop %s 2>&1 | %FileCheck -check-prefix LINUX-cxx-interop %s
+// RUN: %swiftc_driver -driver-print-jobs -target x86_64-unknown-linux-gnu -enable-experimental-cxx-interop -experimental-cxx-stdlib libc++ %s 2>&1 | %FileCheck -check-prefix LINUX-cxx-interop %s
 
-// RUN: %swiftc_driver -driver-print-jobs -target x86_64-unknown-windows-msvc -Xfrontend -enable-cxx-interop %s 2>&1 | %FileCheck -check-prefix WINDOWS-cxx-interop %s
+// RUN: %swiftc_driver -driver-print-jobs -target x86_64-unknown-windows-msvc -enable-experimental-cxx-interop -experimental-cxx-stdlib libc++ %s 2>&1 | %FileCheck -check-prefix WINDOWS-cxx-interop %s
 
 // Check reading the SDKSettings.json from an SDK
 // RUN: %swiftc_driver -driver-print-jobs -target x86_64-apple-macosx10.9 -sdk %S/Inputs/MacOSX10.15.versioned.sdk %s 2>&1 | %FileCheck -check-prefix MACOS_10_15 %s
@@ -423,20 +424,24 @@
 // IOS-cxx-interop-DAG: -lc++
 // IOS-cxx-interop: -o linker
 
+// IOS-cxx-interop-libstdcxx: error: The only C++ standard library supported on Apple platforms is libc++
+
 // LINUX-cxx-interop: swift
 // LINUX-cxx-interop-DAG: -enable-cxx-interop
 // LINUX-cxx-interop-DAG: -o [[OBJECTFILE:.*]]
 
 // LINUX-cxx-interop: clang++{{(\.exe)?"? }}
-// LINUX-cxx-interop: [[OBJECTFILE]]
+// LINUX-cxx-interop-DAG: [[OBJECTFILE]]
+// LINUX-cxx-interop-DAG: -stdlib=libc++
 // LINUX-cxx-interop: -o linker
 
 // WINDOWS-cxx-interop: swift
 // WINDOWS-cxx-interop-DAG: -enable-cxx-interop
 // WINDOWS-cxx-interop-DAG: -o [[OBJECTFILE:.*]]
 
 // WINDOWS-cxx-interop: clang++{{(\.exe)?"? }}
-// WINDOWS-cxx-interop: [[OBJECTFILE]]
+// WINDOWS-cxx-interop-DAG: [[OBJECTFILE]]
+// WINDOWS-cxx-interop-DAG: -stdlib=libc++
 // WINDOWS-cxx-interop: -o linker
 
 // Test ld detection. We use hard links to make sure