Merge pull request #4948 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

include/swift/AST/DiagnosticsFrontend.def

@@ -106,6 +106,8 @@ WARNING(warning_cannot_multithread_batch_mode,none,
       "ignoring -num-threads argument; cannot multithread batch mode", ())
 ERROR(error_cannot_explicit_interface_build_in_mode,none,
       "'-explicit-interface-module-build' only supported when building a module from interface ('-compile-module-from-interface')'", ())
+ERROR(error_cannot_direct_cc1_pcm_build_in_mode,none,
+      "'-direct-clang-cc1-module-build' only supported when building a PCM ('-emit-pcm')'", ())
 ERROR(error_unsupported_option_argument,none,
       "unsupported argument '%1' to option '%0'", (StringRef, StringRef))
 ERROR(error_immediate_mode_missing_stdlib,none,

include/swift/Basic/LangOptions.h

@@ -808,6 +808,11 @@ namespace swift {
     /// contains the full option set.
     bool ExtraArgsOnly = false;
 
+    /// When building a PCM, rely on the Swift frontend's command-line -Xcc flags
+    /// to build the Clang module via Clang frontend directly,
+    /// and completly bypass the Clang driver.
+    bool DirectClangCC1ModuleBuild = false;
+
     /// Return a hash code of any components from these options that should
     /// contribute to a Swift Bridging PCH hash.
     llvm::hash_code getPCHHashComponents() const {

include/swift/Frontend/FrontendOptions.h

@@ -392,6 +392,10 @@ class FrontendOptions {
   /// header.
   bool ExposePublicDeclsInClangHeader = false;
 
+  /// Emit C++ bindings for the exposed Swift declarations in the generated
+  /// clang header.
+  bool EnableExperimentalCxxInteropInClangHeader = false;
+
   /// \return true if the given action only parses without doing other compilation steps.
   static bool shouldActionOnlyParse(ActionType);
 

include/swift/Option/FrontendOptions.td

@@ -889,6 +889,10 @@ def explicit_interface_module_build :
   Flag<["-"], "explicit-interface-module-build">,
   HelpText<"Use the specified command-line to build the module from interface, instead of flags specified in the interface">;
 
+def direct_clang_cc1_module_build :
+  Flag<["-"], "direct-clang-cc1-module-build">,
+  HelpText<"Use the specified -Xcc options to build a PCM by using Clang frontend directly, bypassing the Clang driver">;
+
 def build_module_from_parseable_interface :
   Flag<["-"], "build-module-from-parseable-interface">,
   Alias<compile_module_from_interface>,

include/swift/Option/Options.td

@@ -630,6 +630,11 @@ def enable_experimental_cxx_interop :
   Flags<[FrontendOption, HelpHidden, ModuleInterfaceOption]>,
   HelpText<"Enable experimental C++ interop code generation and config directives">;
 
+def enable_experimental_cxx_interop_in_clang_header :
+  Flag<["-"], "enable-experimental-cxx-interop-in-clang-header">,
+  Flags<[FrontendOption, NoDriverOption, HelpHidden]>,
+  HelpText<"Enable experimental Swift to C++ interop code generation in generated Clang header">;
+
 def experimental_cxx_stdlib :
   Separate<["-"], "experimental-cxx-stdlib">,
   Flags<[HelpHidden]>,

include/swift/PrintAsClang/PrintAsClang.h

@@ -18,6 +18,7 @@
 #include "swift/AST/Identifier.h"
 
 namespace swift {
+class FrontendOptions;
 class IRGenOptions;
 class ModuleDecl;
 class ValueDecl;
@@ -34,7 +35,7 @@ class ValueDecl;
 /// Returns true on error.
 bool printAsClangHeader(raw_ostream &out, ModuleDecl *M,
                         StringRef bridgingHeader,
-                        bool ExposePublicDeclsInClangHeader,
+                        const FrontendOptions &frontendOpts,
                         const IRGenOptions &irGenOpts);
 }
 

lib/ClangImporter/ClangImporter.cpp

@@ -1040,27 +1040,51 @@ std::unique_ptr<clang::CompilerInvocation> ClangImporter::createClangInvocation(
   invocationArgs.reserve(invocationArgStrs.size());
   for (auto &argStr : invocationArgStrs)
     invocationArgs.push_back(argStr.c_str());
-  // Set up a temporary diagnostic client to report errors from parsing the
-  // command line, which may be important for Swift clients if, for example,
-  // they're using -Xcc options. Unfortunately this diagnostic engine has to
-  // use the default options because the /actual/ options haven't been parsed
-  // yet.
-  //
-  // The long-term client for Clang diagnostics is set up below, after the
-  // clang::CompilerInstance is created.
-  llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> tempDiagOpts{
-    new clang::DiagnosticOptions
-  };
 
-  ClangDiagnosticConsumer tempDiagClient{importer->Impl, *tempDiagOpts,
-                                         importerOpts.DumpClangDiagnostics};
-  llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> tempClangDiags =
-      clang::CompilerInstance::createDiagnostics(tempDiagOpts.get(),
-                                                 &tempDiagClient,
-                                                 /*owned*/false);
+  llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> clangDiags;
+  std::unique_ptr<clang::CompilerInvocation> CI;
+  if (importerOpts.DirectClangCC1ModuleBuild) {
+    // In this mode, we bypass createInvocationFromCommandLine, which goes
+    // through the Clang driver, and use strictly cc1 arguments to instantiate a
+    // clang Instance directly, assuming that the set of '-Xcc <X>' frontend flags is
+    // fully sufficient to do so.
+
+    // Because we are bypassing the Clang driver, we must populate
+    // the diagnostic options here explicitly.
+    std::unique_ptr<clang::DiagnosticOptions> clangDiagOpts =
+        clang::CreateAndPopulateDiagOpts(invocationArgs);
+    ClangDiagnosticConsumer diagClient{importer->Impl, *clangDiagOpts,
+                                       importerOpts.DumpClangDiagnostics};
+    clangDiags = clang::CompilerInstance::createDiagnostics(
+        clangDiagOpts.release(), &diagClient,
+        /*owned*/ false);
+
+    // Finally, use the CC1 command-line and the diagnostic engine
+    // to instantiate our Invocation.
+    CI = std::make_unique<clang::CompilerInvocation>();
+    if (!clang::CompilerInvocation::CreateFromArgs(
+        *CI, invocationArgs, *clangDiags, invocationArgs[0]))
+      return nullptr;
+  } else {
+    // Set up a temporary diagnostic client to report errors from parsing the
+    // command line, which may be important for Swift clients if, for example,
+    // they're using -Xcc options. Unfortunately this diagnostic engine has to
+    // use the default options because the /actual/ options haven't been parsed
+    // yet.
+    //
+    // The long-term client for Clang diagnostics is set up below, after the
+    // clang::CompilerInstance is created.
+    llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> tempDiagOpts{
+        new clang::DiagnosticOptions};
 
-  auto CI = clang::createInvocationFromCommandLine(
-      invocationArgs, tempClangDiags, VFS, false, CC1Args);
+    ClangDiagnosticConsumer tempDiagClient{importer->Impl, *tempDiagOpts,
+                                           importerOpts.DumpClangDiagnostics};
+    clangDiags = clang::CompilerInstance::createDiagnostics(tempDiagOpts.get(),
+                                                            &tempDiagClient,
+                                                            /*owned*/ false);
+    CI = clang::createInvocationFromCommandLine(invocationArgs, clangDiags, VFS,
+                                                false, CC1Args);
+  }
 
   if (!CI) {
     return CI;
@@ -1077,8 +1101,9 @@ std::unique_ptr<clang::CompilerInvocation> ClangImporter::createClangInvocation(
   // rdar://77516546 is tracking that the clang importer should be more
   // resilient and provide a module even if there were building it.
   auto TempVFS = clang::createVFSFromCompilerInvocation(
-      *CI, *tempClangDiags,
+      *CI, *clangDiags,
       VFS ? VFS : importer->Impl.SwiftContext.SourceMgr.getFileSystem());
+
   std::vector<std::string> FilteredModuleMapFiles;
   for (auto ModuleMapFile : CI->getFrontendOpts().ModuleMapFiles) {
     if (TempVFS->exists(ModuleMapFile)) {
@@ -1105,13 +1130,11 @@ ClangImporter::create(ASTContext &ctx,
   if (importerOpts.DumpClangDiagnostics) {
     llvm::errs() << "'";
     llvm::interleave(
-        invocationArgStrs, [](StringRef arg) { llvm::errs() << arg; },
-        [] { llvm::errs() << "' '"; });
+                     invocationArgStrs, [](StringRef arg) { llvm::errs() << arg; },
+                     [] { llvm::errs() << "' '"; });
     llvm::errs() << "'\n";
   }
 
-
-
   if (isPCHFilenameExtension(importerOpts.BridgingHeader)) {
     importer->Impl.setSinglePCHImport(importerOpts.BridgingHeader);
     importer->Impl.IsReadingBridgingPCH = true;

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -981,6 +981,7 @@ std::pair<FuncDecl *, FuncDecl *> SwiftDeclSynthesizer::makeBitFieldAccessors(
       Ctx, structDecl->getDeclContext(), clang::SourceLocation(),
       clang::SourceLocation(), cGetterName, cGetterType, cGetterTypeInfo,
       clang::SC_Static);
+  cGetterDecl->setImplicit();
   cGetterDecl->setImplicitlyInline();
   assert(!cGetterDecl->isExternallyVisible());
 
@@ -1002,6 +1003,7 @@ std::pair<FuncDecl *, FuncDecl *> SwiftDeclSynthesizer::makeBitFieldAccessors(
       Ctx, structDecl->getDeclContext(), clang::SourceLocation(),
       clang::SourceLocation(), cSetterName, cSetterType, cSetterTypeInfo,
       clang::SC_Static);
+  cSetterDecl->setImplicit();
   cSetterDecl->setImplicitlyInline();
   assert(!cSetterDecl->isExternallyVisible());
 
@@ -1017,6 +1019,7 @@ std::pair<FuncDecl *, FuncDecl *> SwiftDeclSynthesizer::makeBitFieldAccessors(
     auto cGetterSelf = clang::ParmVarDecl::Create(
         Ctx, cGetterDecl, clang::SourceLocation(), clang::SourceLocation(),
         cGetterSelfId, recordType, recordTypeInfo, clang::SC_None, nullptr);
+    cGetterSelf->setImplicit();
     cGetterDecl->setParams(cGetterSelf);
 
     auto cGetterSelfExpr = new (Ctx)
@@ -1040,13 +1043,15 @@ std::pair<FuncDecl *, FuncDecl *> SwiftDeclSynthesizer::makeBitFieldAccessors(
         Ctx, cSetterDecl, clang::SourceLocation(), clang::SourceLocation(),
         /* nameID? */ nullptr, fieldType, fieldTypeInfo, clang::SC_None,
         nullptr);
+    cSetterValue->setImplicit();
     cSetterParams.push_back(cSetterValue);
     auto recordPointerTypeInfo =
         Ctx.getTrivialTypeSourceInfo(recordPointerType);
     auto cSetterSelf = clang::ParmVarDecl::Create(
         Ctx, cSetterDecl, clang::SourceLocation(), clang::SourceLocation(),
         /* nameID? */ nullptr, recordPointerType, recordPointerTypeInfo,
         clang::SC_None, nullptr);
+    cSetterSelf->setImplicit();
     cSetterParams.push_back(cSetterSelf);
     cSetterDecl->setParams(cSetterParams);
 

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -286,6 +286,8 @@ bool ArgsToFrontendOptionsConverter::convert(
   Opts.DisableBuildingInterface = Args.hasArg(OPT_disable_building_interface);
   Opts.ExposePublicDeclsInClangHeader =
       Args.hasArg(OPT_clang_header_expose_public_decls);
+  Opts.EnableExperimentalCxxInteropInClangHeader =
+      Args.hasArg(OPT_enable_experimental_cxx_interop_in_clang_header);
 
   computeImportObjCHeaderOptions();
   computeImplicitImportModuleNames(OPT_import_module, /*isTestable=*/false);

lib/Frontend/CompilerInvocation.cpp

@@ -1273,6 +1273,7 @@ static bool ParseClangImporterArgs(ClangImporterOptions &Opts,
   }
 
   Opts.ExtraArgsOnly |= Args.hasArg(OPT_extra_clang_options_only);
+  Opts.DirectClangCC1ModuleBuild |= Args.hasArg(OPT_direct_clang_cc1_module_build);
 
   if (const Arg *A = Args.getLastArg(OPT_pch_output_dir)) {
     Opts.PrecompiledHeaderOutputDir = A->getValue();