Merge pull request #4954 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

include/swift/Frontend/FrontendOptions.h

@@ -19,6 +19,7 @@
 #include "swift/Frontend/FrontendInputsAndOutputs.h"
 #include "swift/Frontend/InputFile.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 
 #include <string>
@@ -388,9 +389,16 @@ class FrontendOptions {
   /// '.../lib/swift', otherwise '.../lib/swift_static'.
   bool UseSharedResourceFolder = true;
 
-  /// Indicates whether to expose all public declarations in the generated clang
+  enum class ClangHeaderExposeBehavior {
+    /// Expose all public declarations in the generated header.
+    AllPublic,
+    /// Expose declarations only when they have expose attribute.
+    HasExposeAttr
+  };
+
+  /// Indicates which declarations should be exposed in the generated clang
   /// header.
-  bool ExposePublicDeclsInClangHeader = false;
+  llvm::Optional<ClangHeaderExposeBehavior> ClangHeaderExposedDecls;
 
   /// Emit C++ bindings for the exposed Swift declarations in the generated
   /// clang header.

include/swift/Option/FrontendOptions.td

@@ -1081,11 +1081,12 @@ def skip_import_in_public_interface:
   HelpText<"Skip the import statement corresponding to a module name "
            "when printing the public interface.">;
 
-def clang_header_expose_public_decls:
-  Flag<["-"], "clang-header-expose-public-decls">,
-  HelpText<"Expose all public declarations in the generated clang header">,
-  Flags<[FrontendOption, HelpHidden]>;
-  
+def clang_header_expose_decls:
+  Joined<["-"], "clang-header-expose-decls=">,
+  HelpText<"Which declarations should be exposed in the generated clang header.">,
+  Flags<[FrontendOption, HelpHidden]>,
+  MetaVarName<"all-public|has-expose-attr">;
+
 def weak_link_at_target :
   Flag<["-"], "weak-link-at-target">,
   HelpText<"Weakly link symbols for declarations that were introduced at the "

include/swift/SIL/SILDeclRef.h

@@ -556,6 +556,12 @@ struct SILDeclRef {
 
   bool isImplicit() const;
 
+  /// Whether the referenced function contains user code. This is generally true
+  /// for a non-implicit decls, but may also be true for implicit decls if
+  /// explicitly written code has been spliced into the body. This is the case
+  /// for e.g a lazy variable getter.
+  bool hasUserWrittenCode() const;
+
   /// Return the scope in which the parent class of a method (i.e. class
   /// containing this declaration) can be subclassed, returning NotApplicable if
   /// this is not a method, there is no such class, or the class cannot be

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -284,8 +284,13 @@ bool ArgsToFrontendOptionsConverter::convert(
   Opts.EnableIncrementalDependencyVerifier |= Args.hasArg(OPT_verify_incremental_dependencies);
   Opts.UseSharedResourceFolder = !Args.hasArg(OPT_use_static_resource_dir);
   Opts.DisableBuildingInterface = Args.hasArg(OPT_disable_building_interface);
-  Opts.ExposePublicDeclsInClangHeader =
-      Args.hasArg(OPT_clang_header_expose_public_decls);
+  if (const Arg *A = Args.getLastArg(options::OPT_clang_header_expose_decls)) {
+      Opts.ClangHeaderExposedDecls =
+          llvm::StringSwitch<llvm::Optional<FrontendOptions::ClangHeaderExposeBehavior>>(A->getValue())
+              .Case("all-public", FrontendOptions::ClangHeaderExposeBehavior::AllPublic)
+              .Case("has-expose-attr", FrontendOptions::ClangHeaderExposeBehavior::HasExposeAttr)
+              .Default(llvm::None);
+  }
   Opts.EnableExperimentalCxxInteropInClangHeader =
       Args.hasArg(OPT_enable_experimental_cxx_interop_in_clang_header);
 

lib/PrintAsClang/CMakeLists.txt

@@ -1,3 +1,37 @@
+set(datafiles
+    _SwiftCxxInteroperability.h
+)
+
+set(SWIFTLIB_DIR
+    "${CMAKE_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib/swift")
+set(output_dir "${SWIFTLIB_DIR}/swiftToCxx")
+
+add_custom_command(
+    OUTPUT "${output_dir}"
+    COMMAND ${CMAKE_COMMAND} "-E" "make_directory" "${output_dir}")
+
+set (outputs)
+
+foreach(input ${datafiles})
+  set(source "${CMAKE_CURRENT_SOURCE_DIR}/${input}")
+  set(dest "${output_dir}/${input}")
+  add_custom_command(OUTPUT
+                       "${output_dir}/${input}"
+                     DEPENDS
+                       "${CMAKE_CURRENT_SOURCE_DIR}/${input}"
+                     COMMAND
+                       "${CMAKE_COMMAND}" "-E" "copy" "${source}" "${dest}")
+  list(APPEND outputs "${output_dir}/${input}")
+endforeach()
+list(APPEND outputs "${output_dir}")
+
+add_custom_target("copy_swiftToCxx_shims"
+    DEPENDS "${output_dir}" "${outputs}"
+    COMMENT "Copying Swift to C++ shims to ${output_dir}")
+
+swift_install_in_component(FILES ${datafiles}
+                           DESTINATION "lib/swift/swiftToCxx"
+                           COMPONENT compiler)
 
 add_swift_host_library(swiftPrintAsClang STATIC
   ClangSyntaxPrinter.cpp
@@ -17,4 +51,7 @@ target_link_libraries(swiftPrintAsClang PRIVATE
   swiftIDE
   swiftIRGen)
 
+add_dependencies(swiftPrintAsClang
+  "copy_swiftToCxx_shims")
+
 set_swift_llvm_is_available(swiftPrintAsClang)

lib/PrintAsClang/ModuleContentsWriter.cpp

@@ -134,6 +134,7 @@ class ModuleWriter {
   llvm::raw_string_ostream outOfLineDefinitionsOS;
   DeclAndTypePrinter printer;
   OutputLanguageMode outputLangMode;
+  bool dependsOnStdlib = false;
 
 public:
   ModuleWriter(raw_ostream &os, raw_ostream &prologueOS,
@@ -149,6 +150,11 @@ class ModuleWriter {
 
   PrimitiveTypeMapping &getTypeMapping() { return typeMapping; }
 
+  /// Returns true if a Stdlib dependency was seen during the emission of this module.
+  bool isStdlibRequired() const {
+    return dependsOnStdlib;
+  }
+
   /// Returns true if we added the decl's module to the import set, false if
   /// the decl is a local decl.
   ///
@@ -159,8 +165,10 @@ class ModuleWriter {
 
     if (otherModule == &M)
       return false;
-    if (otherModule->isStdlibModule() ||
-        otherModule->isBuiltinModule())
+    if (otherModule->isStdlibModule()) {
+      dependsOnStdlib = true;
+      return true;
+    } else if (otherModule->isBuiltinModule())
       return true;
     // Don't need a module for SIMD types in C.
     if (otherModule->getName() == M.getASTContext().Id_simd)
@@ -366,7 +374,8 @@ class ModuleWriter {
           return;
 
         // Bridge, if necessary.
-        TD = printer.getObjCTypeDecl(TD);
+        if (outputLangMode != OutputLanguageMode::Cxx)
+          TD = printer.getObjCTypeDecl(TD);
 
         if (finder.needsDefinition() && isa<NominalTypeDecl>(TD)) {
           // We can delay individual members of classes; do so if necessary.
@@ -734,20 +743,22 @@ void swift::printModuleContentsAsObjC(
       .write();
 }
 
-void swift::printModuleContentsAsCxx(
-    raw_ostream &os, llvm::SmallPtrSetImpl<ImportModuleTy> &imports,
+EmittedClangHeaderDependencyInfo swift::printModuleContentsAsCxx(
+    raw_ostream &os,
     ModuleDecl &M, SwiftToClangInteropContext &interopContext,
     bool requiresExposedAttribute) {
   std::string moduleContentsBuf;
   llvm::raw_string_ostream moduleOS{moduleContentsBuf};
   std::string modulePrologueBuf;
   llvm::raw_string_ostream prologueOS{modulePrologueBuf};
+  EmittedClangHeaderDependencyInfo info;
 
   // FIXME: Use getRequiredAccess once @expose is supported.
-  ModuleWriter writer(moduleOS, prologueOS, imports, M, interopContext,
+  ModuleWriter writer(moduleOS, prologueOS, info.imports, M, interopContext,
                       AccessLevel::Public, requiresExposedAttribute,
                       OutputLanguageMode::Cxx);
   writer.write();
+  info.dependsOnStandardLibrary = writer.isStdlibRequired();
 
   os << "#ifndef SWIFT_PRINTED_CORE\n";
   os << "#define SWIFT_PRINTED_CORE\n";
@@ -778,4 +789,5 @@ void swift::printModuleContentsAsCxx(
   ClangSyntaxPrinter(os).printNamespace(
       [&](raw_ostream &os) { M.ValueDecl::getName().print(os); },
       [&](raw_ostream &os) { os << moduleOS.str(); });
+  return info;
 }

lib/PrintAsClang/ModuleContentsWriter.h

@@ -36,10 +36,17 @@ void printModuleContentsAsObjC(raw_ostream &os,
                                ModuleDecl &M,
                                SwiftToClangInteropContext &interopContext);
 
-/// Prints the declarations of \p M to \p os in C++ language mode and collects
-/// imports in \p imports along the way.
-void printModuleContentsAsCxx(raw_ostream &os,
-                              llvm::SmallPtrSetImpl<ImportModuleTy> &imports,
+struct EmittedClangHeaderDependencyInfo {
+    /// The set of imported modules used by this module.
+    SmallPtrSet<ImportModuleTy, 8> imports;
+    /// True if the printed module depends on types from the Stdlib module.
+    bool dependsOnStandardLibrary = false;
+};
+
+/// Prints the declarations of \p M to \p os in C++ language mode.
+///
+/// \returns Dependencies required by this module.
+EmittedClangHeaderDependencyInfo printModuleContentsAsCxx(raw_ostream &os,
                               ModuleDecl &M,
                               SwiftToClangInteropContext &interopContext,
                               bool requiresExposedAttribute);

lib/PrintAsClang/PrintAsClang.cpp

@@ -107,14 +107,16 @@ static void writePrologue(raw_ostream &out, ASTContext &ctx,
         out << "#include <stdlib.h>\n";
         out << "#include <new>\n";
         out << "#include <type_traits>\n";
-        // FIXME: Look for the header in the SDK.
         out << "// Look for the C++ interop support header relative to clang's resource dir:\n";
-        out << "//  '<toolchain>/usr/lib/clang/<version>/include/../../../swift/shims'.\n";
-        out << "#if __has_include(<../../../swift/shims/_SwiftCxxInteroperability.h>)\n";
-        out << "#include <../../../swift/shims/_SwiftCxxInteroperability.h>\n";
-        out << "// Alternatively, allow user to find the header using additional include path into 'swift'.\n";
-        out << "#elif __has_include(<shims/_SwiftCxxInteroperability.h>)\n";
-        out << "#include <shims/_SwiftCxxInteroperability.h>\n";
+        out << "//  '<toolchain>/usr/lib/clang/<version>/include/../../../swift/swiftToCxx'.\n";
+        out << "#if __has_include(<../../../swift/swiftToCxx/_SwiftCxxInteroperability.h>)\n";
+        out << "#include <../../../swift/swiftToCxx/_SwiftCxxInteroperability.h>\n";
+        out << "#elif __has_include(<../../../../lib/swift/swiftToCxx/_SwiftCxxInteroperability.h>)\n";
+        out << "//  '<toolchain>/usr/local/lib/clang/<version>/include/../../../../lib/swift/swiftToCxx'.\n";
+        out << "#include <../../../../lib/swift/swiftToCxx/_SwiftCxxInteroperability.h>\n";
+        out << "// Alternatively, allow user to find the header using additional include path into '<toolchain>/lib/swift'.\n";
+        out << "#elif __has_include(<swiftToCxx/_SwiftCxxInteroperability.h>)\n";
+        out << "#include <swiftToCxx/_SwiftCxxInteroperability.h>\n";
         out << "#endif\n";
       },
       [&] {
@@ -495,16 +497,6 @@ static std::string computeMacroGuard(const ModuleDecl *M) {
   return (llvm::Twine(M->getNameStr().upper()) + "_SWIFT_H").str();
 }
 
-static std::string getModuleContentsCxxString(
-    ModuleDecl &M, SmallPtrSet<ImportModuleTy, 8> &imports,
-    SwiftToClangInteropContext &interopContext, bool requiresExposedAttribute) {
-  std::string moduleContentsBuf;
-  llvm::raw_string_ostream moduleContents{moduleContentsBuf};
-  printModuleContentsAsCxx(moduleContents, imports, M, interopContext,
-                           requiresExposedAttribute);
-  return std::move(moduleContents.str());
-}
-
 bool swift::printAsClangHeader(raw_ostream &os, ModuleDecl *M,
                                StringRef bridgingHeader,
                                const FrontendOptions &frontendOpts,
@@ -524,18 +516,30 @@ bool swift::printAsClangHeader(raw_ostream &os, ModuleDecl *M,
   emitObjCConditional(os, [&] { os << objcModuleContents.str(); });
   emitCxxConditional(os, [&] {
     // FIXME: Expose Swift with @expose by default.
-    bool enableCxx = frontendOpts.ExposePublicDeclsInClangHeader ||
+    bool enableCxx = frontendOpts.ClangHeaderExposedDecls.hasValue() ||
                      frontendOpts.EnableExperimentalCxxInteropInClangHeader ||
                      M->DeclContext::getASTContext().LangOpts.EnableCXXInterop;
     if (enableCxx) {
-      SmallPtrSet<ImportModuleTy, 8> imports;
-      auto contents = getModuleContentsCxxString(
-          *M, imports, interopContext,
-          /*requiresExposedAttribute=*/
-          !frontendOpts.ExposePublicDeclsInClangHeader);
+      bool requiresExplicitExpose = !frontendOpts.ClangHeaderExposedDecls.hasValue() ||
+        *frontendOpts.ClangHeaderExposedDecls == FrontendOptions::ClangHeaderExposeBehavior::HasExposeAttr;
+      // Default dependency behavior is used when the -clang-header-expose-decls flag is not specified.
+      bool defaultDependencyBehavior = !frontendOpts.ClangHeaderExposedDecls.hasValue();
+
+      std::string moduleContentsBuf;
+      llvm::raw_string_ostream moduleContents{moduleContentsBuf};
+      auto deps = printModuleContentsAsCxx(moduleContents, *M, interopContext,
+                               /*requiresExposedAttribute=*/requiresExplicitExpose);
       // FIXME: In ObjC++ mode, we do not need to reimport duplicate modules.
-      writeImports(os, imports, *M, bridgingHeader, /*useCxxImport=*/true);
-      os << contents;
+      writeImports(os, deps.imports, *M, bridgingHeader, /*useCxxImport=*/true);
+
+      // Embed the standard library directly.
+      if (defaultDependencyBehavior && deps.dependsOnStandardLibrary) {
+        assert(!M->isStdlibModule());
+        SwiftToClangInteropContext interopContext(*M->getASTContext().getStdlibModule(), irGenOpts);
+        printModuleContentsAsCxx(os, *M->getASTContext().getStdlibModule(), interopContext, /*requiresExposedAttribute=*/true);
+      }
+
+      os << moduleContents.str();
     }
   });
   writeEpilogue(os);

stdlib/public/SwiftShims/swift/shims/_SwiftCxxInteroperability.h renamed to lib/PrintAsClang/_SwiftCxxInteroperability.h

@@ -284,6 +284,74 @@ bool SILDeclRef::isImplicit() const {
   llvm_unreachable("Unhandled case in switch");
 }
 
+bool SILDeclRef::hasUserWrittenCode() const {
+  // Non-implicit decls generally have user-written code.
+  if (!isImplicit()) {
+    switch (kind) {
+    case Kind::PropertyWrapperBackingInitializer: {
+      // Only has user-written code if any of the property wrappers have
+      // arguments to apply. Otherwise, it's just a forwarding initializer for
+      // the wrappedValue.
+      auto *var = cast<VarDecl>(getDecl());
+      return llvm::any_of(var->getAttachedPropertyWrappers(), [&](auto *attr) {
+        return attr->hasArgs();
+      });
+    }
+    case Kind::PropertyWrapperInitFromProjectedValue:
+      // Never has user-written code, is just a forwarding initializer.
+      return false;
+    default:
+      // TODO: This checking is currently conservative, we ought to
+      // exhaustively handle all the cases here, and use emitOrDelayFunction
+      // in more cases to take advantage of it.
+      return true;
+    }
+    llvm_unreachable("Unhandled case in switch!");
+  }
+
+  // Implicit decls generally don't have user-written code, but some splice
+  // user code into their body.
+  switch (kind) {
+  case Kind::Func: {
+    // Lazy getters splice in the user-written initializer expr.
+    if (auto *accessor = dyn_cast<AccessorDecl>(getFuncDecl())) {
+      auto *storage = accessor->getStorage();
+      if (accessor->isGetter() && !storage->isImplicit() &&
+          storage->getAttrs().hasAttribute<LazyAttr>()) {
+        return true;
+      }
+    }
+    return false;
+  }
+  case Kind::StoredPropertyInitializer: {
+    // Property wrapper initializers for the implicit backing storage can splice
+    // in the user-written initializer on the original property.
+    auto *var = cast<VarDecl>(getDecl());
+    if (auto *originalProperty = var->getOriginalWrappedProperty()) {
+      if (originalProperty->isPropertyMemberwiseInitializedWithWrappedType())
+        return true;
+    }
+    return false;
+  }
+  case Kind::Allocator:
+  case Kind::Initializer:
+  case Kind::EnumElement:
+  case Kind::Destroyer:
+  case Kind::Deallocator:
+  case Kind::GlobalAccessor:
+  case Kind::DefaultArgGenerator:
+  case Kind::IVarInitializer:
+  case Kind::IVarDestroyer:
+  case Kind::PropertyWrapperBackingInitializer:
+  case Kind::PropertyWrapperInitFromProjectedValue:
+  case Kind::EntryPoint:
+  case Kind::AsyncEntryPoint:
+    // Implicit decls for these don't splice in user-written code.
+    return false;
+  }
+  llvm_unreachable("Unhandled case in switch!");
+}
+
 namespace {
 enum class LinkageLimit {
   /// No limit.

lib/SIL/IR/SILDeclRef.cpp

@@ -1186,7 +1186,7 @@ static void emitOrDelayFunction(SILGenModule &SGM,
   // Implicit decls may be delayed if they can't be used externally.
   auto linkage = constant.getLinkage(ForDefinition);
   bool mayDelay = !forceEmission &&
-             (constant.isImplicit() &&
+             (!constant.hasUserWrittenCode() &&
               !constant.isDynamicallyReplaceable() &&
               !isPossiblyUsedExternally(linkage, SGM.M.isWholeModule()));
 

lib/SILGen/SILGen.cpp

@@ -714,7 +714,9 @@ Expr *swift::buildPropertyWrapperInitCall(
   ApplyExpr *innermostInit = nullptr;
 
   // Projected-value initializers don't compose, so no need to iterate
-  // over the wrapper attributes.
+  // over the wrapper attributes. NOTE: If this ever changes, you'll need to
+  // update SILDeclRef::hasUserWrittenCode to account for any spliced in
+  // user-written code.
   if (initKind == PropertyWrapperInitKind::ProjectedValue) {
     auto typeExpr = TypeExpr::createImplicit(backingStorageType, ctx);
     auto *argList = ArgumentList::forImplicitSingle(ctx, ctx.Id_projectedValue,