Merge pull request #2328 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

lib/Frontend/CompilerInvocation.cpp

@@ -81,6 +81,26 @@ void CompilerInvocation::setMainExecutablePath(StringRef Path) {
   DiagnosticOpts.LocalizationPath = std::string(DiagnosticMessagesDir.str());
 }
 
+static std::string
+getVersionedPrebuiltModulePath(Optional<llvm::VersionTuple> sdkVer,
+                               StringRef defaultPrebuiltPath) {
+  if (!sdkVer.hasValue())
+    return defaultPrebuiltPath.str();
+  std::string versionStr = sdkVer->getAsString();
+  StringRef vs = versionStr;
+  do {
+    SmallString<64> pathWithSDKVer = defaultPrebuiltPath;
+    llvm::sys::path::append(pathWithSDKVer, vs);
+    if (llvm::sys::fs::exists(pathWithSDKVer)) {
+      return pathWithSDKVer.str().str();
+    } else if (vs.endswith(".0")) {
+      vs = vs.substr(0, vs.size() - 2);
+    } else {
+      return defaultPrebuiltPath.str();
+    }
+  } while(true);
+}
+
 void CompilerInvocation::setDefaultPrebuiltCacheIfNecessary() {
 
   if (!FrontendOpts.PrebuiltModuleCachePath.empty())
@@ -101,18 +121,8 @@ void CompilerInvocation::setDefaultPrebuiltCacheIfNecessary() {
 
   // If the SDK version is given, we should check if SDK-versioned prebuilt
   // module cache is available and use it if so.
-  if (auto ver = LangOpts.SDKVersion) {
-    // "../macosx/prebuilt-modules"
-    SmallString<64> defaultPrebuiltPathWithSDKVer = defaultPrebuiltPath;
-    // "../macosx/prebuilt-modules/10.15"
-    llvm::sys::path::append(defaultPrebuiltPathWithSDKVer, ver->getAsString());
-    // If the versioned prebuilt module cache exists in the disk, use it.
-    if (llvm::sys::fs::exists(defaultPrebuiltPathWithSDKVer)) {
-      FrontendOpts.PrebuiltModuleCachePath = std::string(defaultPrebuiltPathWithSDKVer.str());
-      return;
-    }
-  }
-  FrontendOpts.PrebuiltModuleCachePath = std::string(defaultPrebuiltPath.str());
+  FrontendOpts.PrebuiltModuleCachePath =
+    getVersionedPrebuiltModulePath(LangOpts.SDKVersion, defaultPrebuiltPath);
 }
 
 static void updateRuntimeLibraryPaths(SearchPathOptions &SearchPathOpts,

lib/Parse/ParseType.cpp

@@ -368,7 +368,8 @@ ParserResult<TypeRepr> Parser::parseType(Diag<> MessageID,
   // Parse an async specifier.
   SourceLoc asyncLoc;
   if (shouldParseExperimentalConcurrency() &&
-      Tok.isContextualKeyword("async")) {
+      Tok.isContextualKeyword("async") &&
+      peekToken().isAny(tok::arrow, tok::kw_throws)) {
     asyncLoc = consumeToken();
   }
 

lib/SILGen/SwitchEnumBuilder.cpp

@@ -67,8 +67,9 @@ void SwitchCaseFullExpr::unreachableExit() {
 //===----------------------------------------------------------------------===//
 
 void SwitchEnumBuilder::emit() && {
-  bool isAddressOnly = optional.getType().isAddressOnly(builder.getFunction()) &&
-                       getSGF().silConv.useLoweredAddresses();
+  bool isAddressOnly =
+      subjectExprOperand.getType().isAddressOnly(builder.getFunction()) &&
+      getSGF().silConv.useLoweredAddresses();
   using DeclBlockPair = std::pair<EnumElementDecl *, SILBasicBlock *>;
   {
     // TODO: We could store the data in CaseBB form and not have to do this.
@@ -90,20 +91,20 @@ void SwitchEnumBuilder::emit() && {
         defaultBlockData ? defaultBlockData->count : ProfileCounter();
     ArrayRef<ProfileCounter> caseBlockCountsRef = caseBlockCounts;
     if (isAddressOnly) {
-      builder.createSwitchEnumAddr(loc, optional.getValue(), defaultBlock,
-                                   caseBlocks, caseBlockCountsRef,
+      builder.createSwitchEnumAddr(loc, subjectExprOperand.getValue(),
+                                   defaultBlock, caseBlocks, caseBlockCountsRef,
                                    defaultBlockCount);
     } else {
-      if (optional.getType().isAddress()) {
+      if (subjectExprOperand.getType().isAddress()) {
         // TODO: Refactor this into a maybe load.
-        if (optional.hasCleanup()) {
-          optional = builder.createLoadTake(loc, optional);
+        if (subjectExprOperand.hasCleanup()) {
+          subjectExprOperand = builder.createLoadTake(loc, subjectExprOperand);
         } else {
-          optional = builder.createLoadCopy(loc, optional);
+          subjectExprOperand = builder.createLoadCopy(loc, subjectExprOperand);
         }
       }
-      builder.createSwitchEnum(loc, optional.forward(getSGF()), defaultBlock,
-                               caseBlocks, caseBlockCountsRef,
+      builder.createSwitchEnum(loc, subjectExprOperand.forward(getSGF()),
+                               defaultBlock, caseBlocks, caseBlockCountsRef,
                                defaultBlockCount);
     }
   }
@@ -121,9 +122,9 @@ void SwitchEnumBuilder::emit() && {
     SwitchCaseFullExpr presentScope(builder.getSILGenFunction(),
                                     CleanupLocation::get(loc), branchDest);
     builder.emitBlock(defaultBlock);
-    ManagedValue input = optional;
+    ManagedValue input = subjectExprOperand;
     if (!isAddressOnly) {
-      input = builder.createOwnedPhiArgument(optional.getType());
+      input = builder.createOwnedPhiArgument(subjectExprOperand.getType());
     }
     handler(input, std::move(presentScope));
     builder.clearInsertionPoint();
@@ -144,9 +145,9 @@ void SwitchEnumBuilder::emit() && {
     ManagedValue input;
     if (decl->hasAssociatedValues()) {
       // Pull the payload out if we have one.
-      SILType inputType = optional.getType().getEnumElementType(
+      SILType inputType = subjectExprOperand.getType().getEnumElementType(
           decl, builder.getModule(), builder.getFunction());
-      input = optional;
+      input = subjectExprOperand;
       if (!isAddressOnly) {
         input = builder.createOwnedPhiArgument(inputType);
       }
@@ -167,9 +168,9 @@ void SwitchEnumBuilder::emit() && {
     SwitchCaseFullExpr presentScope(builder.getSILGenFunction(),
                                     CleanupLocation::get(loc), branchDest);
     builder.emitBlock(defaultBlock);
-    ManagedValue input = optional;
+    ManagedValue input = subjectExprOperand;
     if (!isAddressOnly) {
-      input = builder.createOwnedPhiArgument(optional.getType());
+      input = builder.createOwnedPhiArgument(subjectExprOperand.getType());
     }
     handler(input, std::move(presentScope));
     builder.clearInsertionPoint();

lib/SILGen/SwitchEnumBuilder.h

@@ -133,14 +133,14 @@ class SwitchEnumBuilder {
 
   SILGenBuilder &builder;
   SILLocation loc;
-  ManagedValue optional;
+  ManagedValue subjectExprOperand;
   llvm::Optional<DefaultCaseData> defaultBlockData;
   llvm::SmallVector<NormalCaseData, 8> caseDataArray;
 
 public:
   SwitchEnumBuilder(SILGenBuilder &builder, SILLocation loc,
-                    ManagedValue optional)
-      : builder(builder), loc(loc), optional(optional) {}
+                    ManagedValue subjectExprOperand)
+      : builder(builder), loc(loc), subjectExprOperand(subjectExprOperand) {}
 
   void addDefaultCase(
       SILBasicBlock *defaultBlock, SwitchCaseBranchDest branchDest,

lib/SILOptimizer/Mandatory/MandatoryInlining.cpp

@@ -822,12 +822,12 @@ static SILInstruction *tryDevirtualizeApplyHelper(FullApplySite InnerAI,
 ///
 /// \returns true if successful, false if failed due to circular inlining.
 static bool
-runOnFunctionRecursively(SILOptFunctionBuilder &FuncBuilder,
-			 SILFunction *F, FullApplySite AI,
-                         DenseFunctionSet &FullyInlinedSet,
+runOnFunctionRecursively(SILOptFunctionBuilder &FuncBuilder, SILFunction *F,
+                         FullApplySite AI, DenseFunctionSet &FullyInlinedSet,
                          ImmutableFunctionSet::Factory &SetFactory,
                          ImmutableFunctionSet CurrentInliningSet,
-                         ClassHierarchyAnalysis *CHA) {
+                         ClassHierarchyAnalysis *CHA,
+                         DenseFunctionSet &changedFunctions) {
   // Avoid reprocessing functions needlessly.
   if (FullyInlinedSet.count(F))
     return true;
@@ -874,6 +874,10 @@ runOnFunctionRecursively(SILOptFunctionBuilder &FuncBuilder,
       // but a casted result of InnerAI or even a block argument due to
       // abstraction changes when calling the witness or class method.
       auto *devirtInst = tryDevirtualizeApplyHelper(InnerAI, CHA);
+      // If devirtualization succeeds, make sure we record that this function
+      // changed.
+      if (devirtInst != InnerAI.getInstruction())
+        changedFunctions.insert(F);
       // Restore II to the current apply site.
       II = devirtInst->getReverseIterator();
       // If the devirtualized call result is no longer a invalid FullApplySite,
@@ -892,9 +896,9 @@ runOnFunctionRecursively(SILOptFunctionBuilder &FuncBuilder,
         continue;
 
       // Then recursively process it first before trying to inline it.
-      if (!runOnFunctionRecursively(FuncBuilder, CalleeFunction, InnerAI,
-                                    FullyInlinedSet, SetFactory,
-                                    CurrentInliningSet, CHA)) {
+      if (!runOnFunctionRecursively(
+              FuncBuilder, CalleeFunction, InnerAI, FullyInlinedSet, SetFactory,
+              CurrentInliningSet, CHA, changedFunctions)) {
         // If we failed due to circular inlining, then emit some notes to
         // trace back the failure if we have more information.
         // FIXME: possibly it could be worth recovering and attempting other
@@ -984,6 +988,10 @@ runOnFunctionRecursively(SILOptFunctionBuilder &FuncBuilder,
       closureCleanup.cleanupDeadClosures(F);
       invalidatedStackNesting |= closureCleanup.invalidatedStackNesting;
 
+      // Record that we inlined into this function so that we can invalidate it
+      // later.
+      changedFunctions.insert(F);
+
       // Resume inlining within nextBB, which contains only the inlined
       // instructions and possibly instructions in the original call block that
       // have not yet been visited.
@@ -993,6 +1001,7 @@ runOnFunctionRecursively(SILOptFunctionBuilder &FuncBuilder,
 
   if (invalidatedStackNesting) {
     StackNesting().correctStackNesting(F);
+    changedFunctions.insert(F);
   }
 
   // Keep track of full inlined functions so we don't waste time recursively
@@ -1012,10 +1021,10 @@ class MandatoryInlining : public SILModuleTransform {
   void run() override {
     ClassHierarchyAnalysis *CHA = getAnalysis<ClassHierarchyAnalysis>();
     SILModule *M = getModule();
-    bool ShouldCleanup = !getOptions().DebugSerialization;
     bool SILVerifyAll = getOptions().VerifyAll;
     DenseFunctionSet FullyInlinedSet;
     ImmutableFunctionSet::Factory SetFactory;
+    DenseFunctionSet changedFunctions;
 
     SILOptFunctionBuilder FuncBuilder(*this);
     for (auto &F : *M) {
@@ -1027,13 +1036,15 @@ class MandatoryInlining : public SILModuleTransform {
       if (F.wasDeserializedCanonical())
         continue;
 
-      runOnFunctionRecursively(FuncBuilder, &F,
-                               FullApplySite(), FullyInlinedSet, SetFactory,
-                               SetFactory.getEmptySet(), CHA);
+      runOnFunctionRecursively(FuncBuilder, &F, FullApplySite(),
+                               FullyInlinedSet, SetFactory,
+                               SetFactory.getEmptySet(), CHA, changedFunctions);
 
       // The inliner splits blocks at call sites. Re-merge trivial branches
       // to reestablish a canonical CFG.
-      mergeBasicBlocks(&F);
+      if (mergeBasicBlocks(&F)) {
+        changedFunctions.insert(&F);
+      }
 
       // If we are asked to perform SIL verify all, perform that now so that we
       // can discover the immediate inlining trigger of the problematic
@@ -1043,38 +1054,10 @@ class MandatoryInlining : public SILModuleTransform {
       }
     }
 
-    if (!ShouldCleanup)
+    if (getOptions().DebugSerialization)
       return;
-
-    // Now that we've inlined some functions, clean up.  If there are any
-    // transparent functions that are deserialized from another module that are
-    // now unused, just remove them from the module.
-    //
-    // We do this with a simple linear scan, because transparent functions that
-    // reference each other have already been flattened.
-    for (auto FI = M->begin(), E = M->end(); FI != E; ) {
-      SILFunction &F = *FI++;
-
-      invalidateAnalysis(&F, SILAnalysis::InvalidationKind::Everything);
-
-      if (F.getRefCount() != 0) continue;
-
-      // Leave non-transparent functions alone.
-      if (!F.isTransparent())
-        continue;
-
-      // We discard functions that don't have external linkage,
-      // e.g. deserialized functions, internal functions, and thunks.
-      // Being marked transparent controls this.
-      if (F.isPossiblyUsedExternally()) continue;
-
-      // ObjC functions are called through the runtime and are therefore alive
-      // even if not referenced inside SIL.
-      if (F.getRepresentation() == SILFunctionTypeRepresentation::ObjCMethod)
-        continue;
-
-      // Okay, just erase the function from the module.
-      FuncBuilder.eraseFunction(&F);
+    for (auto *F : changedFunctions) {
+      invalidateAnalysis(F, SILAnalysis::InvalidationKind::Everything);
     }
   }
 

lib/SymbolGraphGen/FormatVersion.h

@@ -15,6 +15,6 @@
 
 #define SWIFT_SYMBOLGRAPH_FORMAT_MAJOR 0
 #define SWIFT_SYMBOLGRAPH_FORMAT_MINOR 5
-#define SWIFT_SYMBOLGRAPH_FORMAT_PATCH 0
+#define SWIFT_SYMBOLGRAPH_FORMAT_PATCH 1
 
 #endif // SWIFT_SYMBOLGRAPHGEN_FORMATVERSION_H

lib/SymbolGraphGen/SymbolGraph.cpp

@@ -39,7 +39,15 @@ SymbolGraph::SymbolGraph(SymbolGraphASTWalker &Walker,
   M(M),
   ExtendedModule(ExtendedModule),
   Ctx(Ctx),
-  ModuleVersion(ModuleVersion) {}
+  ModuleVersion(ModuleVersion) {
+    if (auto *DM = M.getDeclaringModuleIfCrossImportOverlay()) {
+      DeclaringModule = DM;
+      SmallVector<Identifier, 1> Bystanders;
+      if (M.getRequiredBystandersIfCrossImportOverlay(DM, Bystanders)) {
+        BystanderModules = Bystanders;
+      }
+    }
+  }
 
 // MARK: - Utilities
 
@@ -499,7 +507,17 @@ void SymbolGraph::serialize(llvm::json::OStream &OS) {
     }); // end metadata:
 
     OS.attributeObject("module", [&](){
-      OS.attribute("name", M.getNameStr());
+      if (DeclaringModule) {
+        // A cross-import overlay can be considered part of its declaring module
+        OS.attribute("name", (*DeclaringModule)->getNameStr());
+        std::vector<StringRef> B;
+        for (auto BModule : BystanderModules) {
+          B.push_back(BModule.str());
+        }
+        OS.attribute("bystanders", B);
+      } else {
+        OS.attribute("name", M.getNameStr());
+      }
       AttributeRAII Platform("platform", OS);
 
       auto *MainFile = M.getFiles().front();

lib/SymbolGraphGen/SymbolGraph.h

@@ -42,6 +42,16 @@ struct SymbolGraph {
    The module whose types were extended in `M`.
    */
   Optional<ModuleDecl *> ExtendedModule;
+  
+  /**
+   The module declaring `M`, if `M` is a cross-import overlay.
+   */
+  Optional<ModuleDecl *> DeclaringModule;
+  
+  /**
+   The modules that must be imported alongside `DeclaringModule` for `M` to be imported, if `M` is a cross-import overlay.
+   */
+  SmallVector<Identifier, 1> BystanderModules;
 
   /**
    A context for allocations.

lib/SymbolGraphGen/SymbolGraphGen.cpp

@@ -22,10 +22,27 @@ using namespace symbolgraphgen;
 namespace {
 int serializeSymbolGraph(SymbolGraph &SG,
                          const SymbolGraphOptions &Options) {
-  SmallString<256> FileName(SG.M.getNameStr());
-  if (SG.ExtendedModule.hasValue()) {
+  SmallString<256> FileName;
+  if (SG.DeclaringModule.hasValue()) {
+    // Save a cross-import overlay symbol graph as `MainModule@BystandingModule[@BystandingModule...]@OverlayModule.symbols.json`
+    //
+    // The overlay module's name is added as a disambiguator in case an overlay
+    // declares multiple modules for the same set of imports.
+    FileName.append(SG.DeclaringModule.getValue()->getNameStr());
+    for (auto BystanderModule : SG.BystanderModules) {
+      FileName.push_back('@');
+      FileName.append(BystanderModule.str());
+    }
+    
     FileName.push_back('@');
-    FileName.append(SG.ExtendedModule.getValue()->getNameStr());
+    FileName.append(SG.M.getNameStr());
+  } else {
+    FileName.append(SG.M.getNameStr());
+    
+    if (SG.ExtendedModule.hasValue()) {
+      FileName.push_back('@');
+      FileName.append(SG.ExtendedModule.getValue()->getNameStr());
+    }
   }
   FileName.append(".symbols.json");
 

stdlib/public/Concurrency/PartialAsyncTask.swift

@@ -79,7 +79,9 @@ internal func _resumeUnsafeThrowingContinuationWithError<T>(
 
 #endif
 
-// Wrappers around unsafe continuation builtins
+/// The operation functions must resume the continuation *exactly once*.
+///
+/// The continuation will not begin executing until the operation function returns.
 @_alwaysEmitIntoClient
 public func withUnsafeContinuation<T>(
   _ fn: (UnsafeContinuation<T>) -> Void
@@ -89,6 +91,9 @@ public func withUnsafeContinuation<T>(
   }
 }
 
+/// The operation functions must resume the continuation *exactly once*.
+///
+/// The continuation will not begin executing until the operation function returns.
 @_alwaysEmitIntoClient
 public func withUnsafeThrowingContinuation<T>(
   _ fn: (UnsafeThrowingContinuation<T>) -> Void