[Concurrency] Replace ClosureActorIsolation with ActorIsolation throughout

the isolation query APIs.

Author: hborla

include/swift/AST/ActorIsolation.h

@@ -31,18 +31,6 @@ class NominalTypeDecl;
 class SubstitutionMap;
 class AbstractFunctionDecl;
 class AbstractClosureExpr;
-class ClosureActorIsolation;
-
-/// Trampoline for AbstractClosureExpr::getActorIsolation.
-ClosureActorIsolation
-__AbstractClosureExpr_getActorIsolation(AbstractClosureExpr *CE);
-
-/// Returns a function reference to \c __AbstractClosureExpr_getActorIsolation.
-/// This is needed so we can use it as a default argument for
-/// \c getActorIsolationOfContext without knowing the layout of
-/// \c ClosureActorIsolation.
-llvm::function_ref<ClosureActorIsolation(AbstractClosureExpr *)>
-_getRef__AbstractClosureExpr_getActorIsolation();
 
 /// Determine whether the given types are (canonically) equal, declared here
 /// to avoid having to include Types.h.
@@ -100,6 +88,11 @@ class ActorIsolation {
         parameterIndex(0) { }
 
 public:
+  // No-argument constructor needed for DenseMap use in PostfixCompletion.cpp
+  explicit ActorIsolation(Kind kind = Unspecified)
+      : pointer(nullptr), kind(kind), isolatedByPreconcurrency(false),
+        parameterIndex(0) { }
+
   static ActorIsolation forUnspecified() {
     return ActorIsolation(Unspecified, nullptr);
   }
@@ -157,7 +150,7 @@ class ActorIsolation {
 
   NominalTypeDecl *getActor() const;
 
-  VarDecl *getCapturedActor() const;
+  VarDecl *getActorInstance() const;
 
   bool isGlobalActor() const {
     return getKind() == GlobalActor || getKind() == GlobalActorUnsafe;
@@ -227,16 +220,19 @@ class ActorIsolation {
 /// Determine how the given value declaration is isolated.
 ActorIsolation getActorIsolation(ValueDecl *value);
 
+/// Trampoline for AbstractClosureExpr::getActorIsolation.
+ActorIsolation
+__AbstractClosureExpr_getActorIsolation(AbstractClosureExpr *CE);
+
 /// Determine how the given declaration context is isolated.
 /// \p getClosureActorIsolation allows the specification of actor isolation for
 /// closures that haven't been saved been saved to the AST yet. This is useful
 /// for solver-based code completion which doesn't modify the AST but stores the
 /// actor isolation of closures in the constraint system solution.
 ActorIsolation getActorIsolationOfContext(
     DeclContext *dc,
-    llvm::function_ref<ClosureActorIsolation(AbstractClosureExpr *)>
-        getClosureActorIsolation =
-            _getRef__AbstractClosureExpr_getActorIsolation());
+    llvm::function_ref<ActorIsolation(AbstractClosureExpr *)>
+        getClosureActorIsolation = __AbstractClosureExpr_getActorIsolation);
 
 /// Check if both the value, and context are isolated to the same actor.
 bool isSameActorIsolated(ValueDecl *value, DeclContext *dc);
@@ -260,9 +256,9 @@ bool usesFlowSensitiveIsolation(AbstractFunctionDecl const *fn);
 /// \return true if it is safe to drop the global-actor qualifier.
 bool safeToDropGlobalActor(
                 DeclContext *dc, Type globalActor, Type ty,
-                llvm::function_ref<ClosureActorIsolation(AbstractClosureExpr *)>
+                llvm::function_ref<ActorIsolation(AbstractClosureExpr *)>
                     getClosureActorIsolation =
-                        _getRef__AbstractClosureExpr_getActorIsolation());
+                        __AbstractClosureExpr_getActorIsolation);
 
 void simple_display(llvm::raw_ostream &out, const ActorIsolation &state);
 

include/swift/AST/Expr.h

@@ -3970,7 +3970,7 @@ class AbstractClosureExpr : public DeclContext, public Expr {
 
     case ActorIsolation::ActorInstance:
       return ClosureActorIsolation::forActorInstance(
-          actorIsolation.getCapturedActor(), preconcurrency);
+          actorIsolation.getActorInstance(), preconcurrency);
 
     case ActorIsolation::GlobalActor:
     case ActorIsolation::GlobalActorUnsafe:

include/swift/IDE/CompletionLookup.h

@@ -131,7 +131,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
   bool CanCurrDeclContextHandleAsync = false;
   /// Actor isolations that were determined during constraint solving but that
   /// haven't been saved to the AST.
-  llvm::DenseMap<AbstractClosureExpr *, ClosureActorIsolation>
+  llvm::DenseMap<AbstractClosureExpr *, ActorIsolation>
       ClosureActorIsolations;
   bool HaveDot = false;
   bool IsUnwrappedOptional = false;
@@ -253,7 +253,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
   }
 
   void setClosureActorIsolations(
-      llvm::DenseMap<AbstractClosureExpr *, ClosureActorIsolation>
+      llvm::DenseMap<AbstractClosureExpr *, ActorIsolation>
           ClosureActorIsolations) {
     this->ClosureActorIsolations = ClosureActorIsolations;
   }

include/swift/IDE/PostfixCompletion.h

@@ -63,7 +63,7 @@ class PostfixCompletionCallback : public TypeCheckCompletionCallback {
 
     /// Actor isolations that were determined during constraint solving but that
     /// haven't been saved to the AST.
-    llvm::DenseMap<AbstractClosureExpr *, ClosureActorIsolation>
+    llvm::DenseMap<AbstractClosureExpr *, ActorIsolation>
         ClosureActorIsolations;
 
     /// Checks whether this result has the same \c BaseTy and \c BaseDecl as

include/swift/Sema/IDETypeChecking.h

@@ -318,9 +318,9 @@ namespace swift {
   bool completionContextUsesConcurrencyFeatures(const DeclContext *dc);
 
   /// Determine the isolation of a particular closure.
-  ClosureActorIsolation determineClosureActorIsolation(
+  ActorIsolation determineClosureActorIsolation(
       AbstractClosureExpr *closure, llvm::function_ref<Type(Expr *)> getType,
-      llvm::function_ref<ClosureActorIsolation(AbstractClosureExpr *)>
+      llvm::function_ref<ActorIsolation(AbstractClosureExpr *)>
           getClosureActorIsolation);
 
   /// If the capture list shadows any declarations using shorthand syntax, i.e.

lib/AST/Decl.cpp

@@ -10333,7 +10333,7 @@ ActorIsolation swift::getActorIsolation(ValueDecl *value) {
 
 ActorIsolation swift::getActorIsolationOfContext(
     DeclContext *dc,
-    llvm::function_ref<ClosureActorIsolation(AbstractClosureExpr *)>
+    llvm::function_ref<ActorIsolation(AbstractClosureExpr *)>
         getClosureActorIsolation) {
   auto dcToUse = dc;
   // Defer bodies share actor isolation of their enclosing context.
@@ -10349,7 +10349,7 @@ ActorIsolation swift::getActorIsolationOfContext(
     return getActorIsolation(var);
 
   if (auto *closure = dyn_cast<AbstractClosureExpr>(dcToUse)) {
-    return getClosureActorIsolation(closure).getActorIsolation();
+    return getClosureActorIsolation(closure);
   }
 
   if (auto *tld = dyn_cast<TopLevelCodeDecl>(dcToUse)) {
@@ -10619,7 +10619,7 @@ NominalTypeDecl *ActorIsolation::getActor() const {
   return actorInstance.get<NominalTypeDecl *>();
 }
 
-VarDecl *ActorIsolation::getCapturedActor() const {
+VarDecl *ActorIsolation::getActorInstance() const {
   assert(getKind() == ActorInstance);
   return actorInstance.dyn_cast<VarDecl *>();
 }

lib/AST/Expr.cpp

@@ -2017,14 +2017,9 @@ Expr *AbstractClosureExpr::getSingleExpressionBody() const {
   return nullptr;
 }
 
-ClosureActorIsolation
+ActorIsolation
 swift::__AbstractClosureExpr_getActorIsolation(AbstractClosureExpr *CE) {
-  return CE->getClosureActorIsolation();
-}
-
-llvm::function_ref<ClosureActorIsolation(AbstractClosureExpr *)>
-swift::_getRef__AbstractClosureExpr_getActorIsolation() {
-  return __AbstractClosureExpr_getActorIsolation;
+  return CE->getActorIsolation();
 }
 
 #define FORWARD_SOURCE_LOCS_TO(CLASS, NODE) \

lib/IDE/CompletionLookup.cpp

@@ -777,7 +777,7 @@ void CompletionLookup::analyzeActorIsolation(
       if (isolation != ClosureActorIsolations.end()) {
         return isolation->second;
       } else {
-        return CE->getClosureActorIsolation();
+        return CE->getActorIsolation();
       }
     };
     auto contextIsolation = getActorIsolationOfContext(

lib/IDE/PostfixCompletion.cpp

@@ -111,7 +111,7 @@ void PostfixCompletionCallback::fallbackTypeCheck(DeclContext *DC) {
                              [&](const Solution &S) { sawSolution(S); });
 }
 
-static ClosureActorIsolation
+static ActorIsolation
 getClosureActorIsolation(const Solution &S, AbstractClosureExpr *ACE) {
   auto getType = [&S](Expr *E) -> Type {
     // Prefer the contextual type of the closure because it might be 'weaker'
@@ -213,7 +213,7 @@ void PostfixCompletionCallback::sawSolutionImpl(
       isImplicitSingleExpressionReturn(CS, CompletionExpr);
 
   bool IsInAsyncContext = isContextAsync(S, DC);
-  llvm::DenseMap<AbstractClosureExpr *, ClosureActorIsolation>
+  llvm::DenseMap<AbstractClosureExpr *, ActorIsolation>
       ClosureActorIsolations;
   for (auto SAT : S.targets) {
     if (auto ACE = getAsExpr<AbstractClosureExpr>(SAT.second.getAsASTNode())) {

lib/SILGen/SILGenProlog.cpp

@@ -1593,7 +1593,7 @@ void SILGenFunction::emitHopToActorValue(SILLocation loc, ManagedValue actor) {
   }
   auto isolation =
       getActorIsolationOfContext(FunctionDC, [](AbstractClosureExpr *CE) {
-        return CE->getClosureActorIsolation();
+        return CE->getActorIsolation();
       });
   if (isolation != ActorIsolation::Nonisolated
       && isolation != ActorIsolation::Unspecified) {

lib/Sema/CSSimplify.cpp

@@ -2960,16 +2960,16 @@ static bool isPreconcurrency(ConstraintSystem &cs, DeclContext *dc) {
 static bool okToRemoveGlobalActor(ConstraintSystem &cs,
                                   DeclContext *dc,
                                   Type globalActor, Type ty) {
-  auto findGlobalActorForClosure = [&](AbstractClosureExpr *ace) -> ClosureActorIsolation {
+  auto findGlobalActorForClosure = [&](AbstractClosureExpr *ace) -> ActorIsolation {
     // FIXME: Because the actor isolation checking happens after constraint
     // solving, the closure expression does not yet have its actor isolation
     // set, i.e., the code that would call
     // `AbstractClosureExpr::setActorIsolation` hasn't run yet.
     // So, I expect the existing isolation to always be set to the default.
     // If the assertion below starts tripping, then this ad-hoc inference
     // is no longer needed!
-    auto existingIso = ace->getClosureActorIsolation();
-    if (existingIso != ClosureActorIsolation()) {
+    auto existingIso = ace->getActorIsolation();
+    if (existingIso != ActorIsolation::forUnspecified()) {
       assert(false && "somebody set the closure's isolation already?");
       return existingIso;
     }
@@ -2980,17 +2980,17 @@ static bool okToRemoveGlobalActor(ConstraintSystem &cs,
     if (auto closType = GetClosureType{cs}(ace)) {
       if (auto fnTy = closType->getAs<AnyFunctionType>()) {
         if (auto globActor = fnTy->getGlobalActor()) {
-          return ClosureActorIsolation::forGlobalActor(globActor,
-                                                       isPreconcurrency(cs, ace));
+          return ActorIsolation::forGlobalActor(globActor, /*unsafe=*/false)
+              .withPreconcurrency(isPreconcurrency(cs, ace));
         }
       }
     }
 
     // otherwise, check for an explicit annotation
     if (auto *ce = dyn_cast<ClosureExpr>(ace)) {
       if (auto globActor = getExplicitGlobalActor(ce)) {
-        return ClosureActorIsolation::forGlobalActor(globActor,
-                                                     isPreconcurrency(cs, ce));
+        return ActorIsolation::forGlobalActor(globActor, /*unsafe=*/false)
+            .withPreconcurrency(isPreconcurrency(cs, ace));
       }
     }