Merge pull request #4851 from swiftwasm/release/5.7

kateinoigakukun · web-flow · commit a74790656977 · 2022-09-09T10:55:45.000+09:00
[pull] swiftwasm-release/5.7 from release/5.7
diff --git a/include/swift/IDE/CodeCompletionCache.h b/include/swift/IDE/CodeCompletionCache.h
@@ -45,6 +45,8 @@ class CodeCompletionCache {
     bool ResultsHaveLeadingDot;
     bool ForTestableLookup;
     bool ForPrivateImportLookup;
+    /// Must be sorted alphabetically for stable identity.
+    llvm::SmallVector<std::string, 2> SpiGroups;
     bool AddInitsInToplevel;
     bool AddCallWithNoDefaultArgs;
     bool Annotated;
@@ -56,6 +58,7 @@ class CodeCompletionCache {
              LHS.ResultsHaveLeadingDot == RHS.ResultsHaveLeadingDot &&
              LHS.ForTestableLookup == RHS.ForTestableLookup &&
              LHS.ForPrivateImportLookup == RHS.ForPrivateImportLookup &&
+             LHS.SpiGroups == RHS.SpiGroups &&
              LHS.AddInitsInToplevel == RHS.AddInitsInToplevel &&
              LHS.AddCallWithNoDefaultArgs == RHS.AddCallWithNoDefaultArgs &&
              LHS.Annotated == RHS.Annotated;
@@ -125,16 +128,35 @@ template<>
 struct DenseMapInfo<swift::ide::CodeCompletionCache::Key> {
   using KeyTy = swift::ide::CodeCompletionCache::Key;
   static inline KeyTy getEmptyKey() {
-    return KeyTy{"", "", {}, false, false, false, false, false, false};
+    return KeyTy{/*ModuleFilename=*/"",
+                 /*ModuleName=*/"",
+                 /*AccessPath=*/{},
+                 /*ResultsHaveLeadingDot=*/false,
+                 /*ForTestableLookup=*/false,
+                 /*ForPrivateImportLookup=*/false,
+                 /*SpiGroups=*/{},
+                 /*AddInitsInToplevel=*/false,
+                 /*AddCallWithNoDefaultArgs=*/false,
+                 /*Annotated=*/false};
   }
   static inline KeyTy getTombstoneKey() {
-    return KeyTy{"", "", {}, true, false, false, false, false, false};
+    return KeyTy{/*ModuleFilename=*/"",
+                 /*ModuleName=*/"",
+                 /*AccessPath=*/{},
+                 /*ResultsHaveLeadingDot=*/true,
+                 /*ForTestableLookup=*/false,
+                 /*ForPrivateImportLookup=*/false,
+                 /*SpiGroups=*/{},
+                 /*AddInitsInToplevel=*/false,
+                 /*AddCallWithNoDefaultArgs=*/false,
+                 /*Annotated=*/false};
   }
   static unsigned getHashValue(const KeyTy &Val) {
     return llvm::hash_combine(
         Val.ModuleFilename, Val.ModuleName,
         llvm::hash_combine_range(Val.AccessPath.begin(), Val.AccessPath.end()),
         Val.ResultsHaveLeadingDot, Val.ForTestableLookup,
+        llvm::hash_combine_range(Val.SpiGroups.begin(), Val.SpiGroups.end()),
         Val.ForPrivateImportLookup, Val.AddInitsInToplevel,
         Val.AddCallWithNoDefaultArgs, Val.Annotated);
   }
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -9140,14 +9140,20 @@ ActorIsolation swift::getActorIsolation(ValueDecl *value) {
 }
 
 ActorIsolation swift::getActorIsolationOfContext(DeclContext *dc) {
-  if (auto *vd = dyn_cast_or_null<ValueDecl>(dc->getAsDecl()))
+  auto dcToUse = dc;
+  // Defer bodies share actor isolation of their enclosing context.
+  if (auto FD = dyn_cast<FuncDecl>(dcToUse)) {
+    if (FD->isDeferBody()) {
+      dcToUse = FD->getDeclContext();
+    }
+  }
+  if (auto *vd = dyn_cast_or_null<ValueDecl>(dcToUse->getAsDecl()))
     return getActorIsolation(vd);
 
-  if (auto *var = dc->getNonLocalVarDecl())
-     return getActorIsolation(var);
-
+  if (auto *var = dcToUse->getNonLocalVarDecl())
+    return getActorIsolation(var);
 
-  if (auto *closure = dyn_cast<AbstractClosureExpr>(dc)) {
+  if (auto *closure = dyn_cast<AbstractClosureExpr>(dcToUse)) {
     switch (auto isolation = closure->getActorIsolation()) {
     case ClosureActorIsolation::Independent:
       return ActorIsolation::forIndependent()
@@ -9170,14 +9176,14 @@ ActorIsolation swift::getActorIsolationOfContext(DeclContext *dc) {
     }
   }
 
-  if (auto *tld = dyn_cast<TopLevelCodeDecl>(dc)) {
-    if (dc->isAsyncContext() ||
-        dc->getASTContext().LangOpts.StrictConcurrencyLevel
-            >= StrictConcurrency::Complete) {
-      if (Type mainActor = dc->getASTContext().getMainActorType())
+  if (auto *tld = dyn_cast<TopLevelCodeDecl>(dcToUse)) {
+    if (dcToUse->isAsyncContext() ||
+        dcToUse->getASTContext().LangOpts.StrictConcurrencyLevel >=
+            StrictConcurrency::Complete) {
+      if (Type mainActor = dcToUse->getASTContext().getMainActorType())
         return ActorIsolation::forGlobalActor(
             mainActor,
-            /*unsafe=*/!dc->getASTContext().isSwiftVersionAtLeast(6));
+            /*unsafe=*/!dcToUse->getASTContext().isSwiftVersionAtLeast(6));
     }
   }
 
diff --git a/lib/IDE/CodeCompletion.cpp b/lib/IDE/CodeCompletion.cpp
@@ -1291,6 +1291,16 @@ void swift::ide::deliverCompletionResults(
       // ModuleFilename can be empty if something strange happened during
       // module loading, for example, the module file is corrupted.
       if (!ModuleFilename.empty()) {
+        llvm::SmallVector<std::string, 2> spiGroups;
+        for (auto Import : SF.getImports()) {
+          if (Import.module.importedModule == TheModule) {
+            for (auto SpiGroup : Import.spiGroups) {
+              spiGroups.push_back(SpiGroup.str().str());
+            }
+            break;
+          }
+        }
+        llvm::sort(spiGroups);
         CodeCompletionCache::Key K{
             ModuleFilename.str(),
             std::string(TheModule->getName()),
@@ -1302,6 +1312,7 @@ void swift::ide::deliverCompletionResults(
             SF.hasTestableOrPrivateImport(
                 AccessLevel::Internal, TheModule,
                 SourceFile::ImportQueryKind::PrivateOnly),
+            spiGroups,
             CompletionContext.getAddInitsToTopLevel(),
             CompletionContext.addCallWithNoDefaultArgs(),
             CompletionContext.getAnnotateResult()};
@@ -1341,9 +1352,12 @@ void swift::ide::deliverCompletionResults(
       // Add results for all imported modules.
       SmallVector<ImportedModule, 4> Imports;
       SF.getImportedModules(
-          Imports, {ModuleDecl::ImportFilterKind::Exported,
-                    ModuleDecl::ImportFilterKind::Default,
-                    ModuleDecl::ImportFilterKind::ImplementationOnly});
+          Imports, {
+                       ModuleDecl::ImportFilterKind::Exported,
+                       ModuleDecl::ImportFilterKind::Default,
+                       ModuleDecl::ImportFilterKind::ImplementationOnly,
+                       ModuleDecl::ImportFilterKind::SPIAccessControl,
+                   });
 
       for (auto Imported : Imports) {
         for (auto Import : namelookup::getAllImports(Imported.importedModule))
diff --git a/lib/IDE/CodeCompletionCache.cpp b/lib/IDE/CodeCompletionCache.cpp
@@ -475,6 +475,12 @@ static std::string getName(StringRef cacheDirectory,
       << (K.AddInitsInToplevel ? "-inits" : "")
       << (K.AddCallWithNoDefaultArgs ? "-nodefaults" : "")
       << (K.Annotated ? "-annotated" : "");
+  if (K.SpiGroups.size() > 0) {
+    OSS << "-spi";
+    for (auto SpiGroup : K.SpiGroups) {
+      OSS << "-" << SpiGroup;
+    }
+  }
 
   // name[-access-path-components]
   for (StringRef component : K.AccessPath)
@@ -539,9 +545,16 @@ OnDiskCodeCompletionCache::getFromFile(StringRef filename) {
     return None;
 
   // Make up a key for readCachedModule.
-  CodeCompletionCache::Key K{filename.str(), "<module-name>", {},
-                             false,          false,           false,
-                             false,          false,           false};
+  CodeCompletionCache::Key K{/*ModuleFilename=*/filename.str(),
+                             /*ModuleName=*/"<module-name>",
+                             /*AccessPath=*/{},
+                             /*ResultsHaveLeadingDot=*/false,
+                             /*ForTestableLookup=*/false,
+                             /*ForPrivateImportLookup=*/false,
+                             /*SpiGroups=*/{},
+                             /*AddInitsInToplevel=*/false,
+                             /*AddCallWithNoDefaultArgs=*/false,
+                             /*Annotated=*/false};
 
   // Read the cached results.
   auto V = CodeCompletionCache::createValue();
diff --git a/lib/SILGen/SILGenProlog.cpp b/lib/SILGen/SILGenProlog.cpp
@@ -733,7 +733,7 @@ void SILGenFunction::emitPrologGlobalActorHop(SILLocation loc,
 }
 
 SILValue SILGenFunction::emitLoadGlobalActorExecutor(Type globalActor) {
-  CanType actorType = CanType(globalActor);
+  CanType actorType = globalActor->getCanonicalType();
   NominalTypeDecl *nominal = actorType->getNominalOrBoundGenericNominal();
   VarDecl *sharedInstanceDecl = nominal->getGlobalActorInstance();
   assert(sharedInstanceDecl && "no shared actor field in global actor");
diff --git a/lib/Sema/TypeCheckConcurrency.cpp b/lib/Sema/TypeCheckConcurrency.cpp
@@ -124,10 +124,13 @@ bool swift::usesFlowSensitiveIsolation(AbstractFunctionDecl const *fn) {
   }
 
   auto *dc = fn->getDeclContext();
+  if (!dc)
+    return false;
 
   // Must be part of a nominal type.
   auto *nominal = dc->getSelfNominalTypeDecl();
-  assert(nominal && "init/deinit not part of a nominal?");
+  if (!nominal)
+    return false;
 
   // If it's part of an actor type, then its deinit and some of its inits use
   // flow-isolation.
@@ -1489,6 +1492,7 @@ static FuncDecl *findAnnotatableFunction(DeclContext *dc) {
 }
 
 /// Note when the enclosing context could be put on a global actor.
+// FIXME: This should handle closures too.
 static void noteGlobalActorOnContext(DeclContext *dc, Type globalActor) {
   // If we are in a synchronous function on the global actor,
   // suggest annotating with the global actor itself.
@@ -3755,14 +3759,6 @@ ActorIsolation ActorIsolationRequest::evaluate(
   // If this is a local function, inherit the actor isolation from its
   // context if it global or was captured.
   if (auto func = dyn_cast<FuncDecl>(value)) {
-    // If this is a defer body, inherit unconditionally; we don't
-    // care if the enclosing function captures the isolated parameter.
-    if (func->isDeferBody()) {
-      auto enclosingIsolation =
-                        getActorIsolationOfContext(func->getDeclContext());
-      return inferredIsolation(enclosingIsolation);
-    }
-
     if (func->isLocalCapture() && !func->isSendable()) {
       switch (auto enclosingIsolation =
                   getActorIsolationOfContext(func->getDeclContext())) {
diff --git a/stdlib/public/core/StringGutsRangeReplaceable.swift b/stdlib/public/core/StringGutsRangeReplaceable.swift
@@ -483,9 +483,13 @@ extension _StringGuts {
       let newUTF8Count =
         oldUTF8Count + newUTF8Subrange.count - oldUTF8SubrangeCount
 
-      // Get the character stride in the entire string, not just the substring.
-      // (Characters in a substring may end beyond the bounds of it.)
-      let newStride = _opaqueCharacterStride(startingAt: utf8StartOffset)
+      var newStride = 0
+
+      if !newUTF8Subrange.isEmpty {
+        // Get the character stride in the entire string, not just the substring.
+        // (Characters in a substring may end beyond the bounds of it.)
+        newStride = _opaqueCharacterStride(startingAt: utf8StartOffset)
+      }
 
       startIndex = String.Index(
         encodedOffset: utf8StartOffset,
@@ -522,9 +526,14 @@ extension _StringGuts {
     // needs to look ahead by more than one Unicode scalar.)
     let oldStride = startIndex.characterStride ?? 0
     if oldRange.lowerBound <= oldBounds.lowerBound &+ oldStride {
-      // Get the character stride in the entire string, not just the substring.
-      // (Characters in a substring may end beyond the bounds of it.)
-      let newStride = _opaqueCharacterStride(startingAt: newBounds.lowerBound)
+      var newStride = 0
+
+      if !newBounds.isEmpty {
+        // Get the character stride in the entire string, not just the substring.
+        // (Characters in a substring may end beyond the bounds of it.)
+        newStride = _opaqueCharacterStride(startingAt: newBounds.lowerBound)
+      }
+
       var newStart = String.Index(
         encodedOffset: newBounds.lowerBound,
         characterStride: newStride
diff --git a/test/Concurrency/actor_defer.swift b/test/Concurrency/actor_defer.swift
@@ -5,7 +5,7 @@
 
 func doSomething() {}
 
-// expected-note @+1 4 {{calls to global function 'requiresMainActor()' from outside of its actor context are implicitly asynchronous}}
+// expected-note @+1 6 {{calls to global function 'requiresMainActor()' from outside of its actor context are implicitly asynchronous}}
 @MainActor func requiresMainActor() {}
 
 @MainActor func testNonDefer_positive() {
@@ -66,7 +66,7 @@ func testGlobalActorAsync_negative() async {
 
 @available(SwiftStdlib 5.1, *)
 actor Actor {
-  // expected-note @+1 3 {{mutation of this property is only permitted within the actor}}
+  // expected-note @+1 6 {{mutation of this property is only permitted within the actor}}
   var actorProperty = 0
 
   func testActor_positive() {
@@ -76,6 +76,13 @@ actor Actor {
     doSomething()
   }
 
+  func testActor_task_positive() {
+    Task {
+      defer { actorProperty += 1 }
+      doSomething()
+    }
+  }
+
 #if NEGATIVES
   nonisolated func testActor_negative() {
     defer {
@@ -84,13 +91,30 @@ actor Actor {
     }
     doSomething()
   }
+
+  nonisolated func testActor_task_negative() {
+    Task {
+      // expected-error @+1 {{actor-isolated property 'actorProperty' can not be mutated from a non-isolated context}}
+      defer { actorProperty += 1 }
+      doSomething()
+    }
+  }
+
   @MainActor func testActor_negative_globalActor() {
     defer {
       // expected-error @+1 {{actor-isolated property 'actorProperty' can not be mutated from the main actor}}
       actorProperty += 1
     }
     doSomething()
   }
+
+  func testActor_task_negative_globalActor() {
+    Task { @MainActor in
+      // expected-error @+1 {{actor-isolated property 'actorProperty' can not be mutated from the main actor}}
+      defer { actorProperty += 1 }
+      doSomething()
+    }
+  }
 #endif
 
   @MainActor func testGlobalActor_positive() {
@@ -99,6 +123,13 @@ actor Actor {
     }
     doSomething()
   }
+  
+  func testGlobalActor_task_positive() {
+    Task { @MainActor in
+      defer { requiresMainActor() }
+      doSomething()
+    }
+  }
 
 #if NEGATIVES
   func testGlobalActor_negative() {
@@ -108,6 +139,14 @@ actor Actor {
     }
     doSomething()
   }
+
+  func testGlobalActor_task_negative() {
+    Task {
+      // expected-error @+1 {{call to main actor-isolated global function 'requiresMainActor()' in a synchronous nonisolated context}}
+      defer { requiresMainActor() }
+      doSomething()
+    }
+  }
 #endif
 }
 
@@ -130,3 +169,48 @@ func testIsolatedActor_negative(actor: Actor) {
   doSomething()
 }
 #endif
+
+@available(SwiftStdlib 5.1, *)
+func testGlobalActor_inTask_positive() {
+  Task { @MainActor in
+    defer { requiresMainActor() }
+    doSomething()
+  }
+}
+
+#if NEGATIVES
+@available(SwiftStdlib 5.1, *)
+func testGlobalActor_inTask_negative() {
+  Task {
+    // expected-error @+1 {{call to main actor-isolated global function 'requiresMainActor()' in a synchronous nonisolated context}}
+    defer { requiresMainActor() }
+    doSomething()
+  }
+}
+#endif
+
+@available(SwiftStdlib 5.1, *)
+func takeClosureWithIsolatedParam(body: (isolated Actor) -> Void) {}
+
+@available(SwiftStdlib 5.1, *)
+func takeClosureWithNotIsolatedParam(body: (Actor) -> Void) {}
+
+@available(SwiftStdlib 5.1, *)
+func testIsolatedActor_closure_positive() {
+  takeClosureWithIsolatedParam { actor in
+    actor.actorProperty += 1
+    defer { actor.actorProperty += 1 }
+    doSomething()
+  }
+}
+
+#if NEGATIVES
+@available(SwiftStdlib 5.1, *)
+func testIsolatedActor_closure_negative() {
+  takeClosureWithNotIsolatedParam { actor in
+    // expected-error @+1 {{actor-isolated property 'actorProperty' can not be mutated from a non-isolated context}}
+    defer { actor.actorProperty += 1 }
+    doSomething()
+  }
+}
+#endif
diff --git a/test/IDE/complete_from_swift_module_spi.swift b/test/IDE/complete_from_swift_module_spi.swift
diff --git a/test/SILGen/hop_to_executor_async_prop.swift b/test/SILGen/hop_to_executor_async_prop.swift

Original file line number	Diff line number	Diff line change
`@@ -733,7 +733,7 @@ void SILGenFunction::emitPrologGlobalActorHop(SILLocation loc,`
`733`	`733`	`}`
`734`	`734`
`735`	`735`	`SILValue SILGenFunction::emitLoadGlobalActorExecutor(Type globalActor) {`
`736`		`- CanType actorType = CanType(globalActor);`
	`736`	`+ CanType actorType = globalActor->getCanonicalType();`
`737`	`737`	`NominalTypeDecl *nominal = actorType->getNominalOrBoundGenericNominal();`
`738`	`738`	`VarDecl *sharedInstanceDecl = nominal->getGlobalActorInstance();`
`739`	`739`	`assert(sharedInstanceDecl && "no shared actor field in global actor");`