[NFC] Encapsulate the parameter index of an ActorIsolation

rjmccall · rjmccall · commit 00463df05892 · 2025-06-30T01:48:37.000-04:00
diff --git a/include/swift/AST/ActorIsolation.h b/include/swift/AST/ActorIsolation.h
@@ -88,21 +88,74 @@ class ActorIsolation {
   /// Set to true if this was parsed from SIL.
   unsigned silParsed : 1;
 
-  unsigned parameterIndex : 27;
+  /// The opaque value of an EncodedParameterIndex.
+  /// Only meaningful for ActorInstance.
+  unsigned encodedParameterIndex : 27;
+
+  class EncodedParameterIndex {
+    enum : unsigned {
+      SpecialIndex_Capture,
+      SpecialIndex_Self,
+      NumSpecialIndexes
+    };
+
+    /// Either a special index or (parameter index + NumSpecialIndexes).
+    unsigned value;
+
+    constexpr EncodedParameterIndex(unsigned value) : value(value) {}
+
+  public:
+    static constexpr EncodedParameterIndex parameter(unsigned index) {
+      return EncodedParameterIndex(NumSpecialIndexes + index);
+    }
+    static constexpr EncodedParameterIndex self() {
+      return EncodedParameterIndex(SpecialIndex_Self);
+    }
+    static constexpr EncodedParameterIndex capture() {
+      return EncodedParameterIndex(SpecialIndex_Capture);
+    }
+
+    unsigned getParameterIndex() const {
+      assert(value >= NumSpecialIndexes);
+      return value - NumSpecialIndexes;
+    }
+    bool isSelf() const {
+      return value == SpecialIndex_Self;
+    }
+    bool isCapture() const {
+      return value == SpecialIndex_Capture;
+    }
 
-  ActorIsolation(Kind kind, NominalTypeDecl *actor, unsigned parameterIndex);
+    static EncodedParameterIndex fromOpaqueValue(unsigned value) {
+      return EncodedParameterIndex(value);
+    }
+    unsigned getOpaqueValue() const {
+      return value;
+    }
+  };
 
-  ActorIsolation(Kind kind, VarDecl *actor, unsigned parameterIndex);
+  ActorIsolation(Kind kind, NominalTypeDecl *actor,
+                 EncodedParameterIndex parameterIndex);
 
-  ActorIsolation(Kind kind, Expr *actor, unsigned parameterIndex);
+  ActorIsolation(Kind kind, VarDecl *actor,
+                 EncodedParameterIndex parameterIndex);
+
+  ActorIsolation(Kind kind, Expr *actor,
+                 EncodedParameterIndex parameterIndex);
 
   ActorIsolation(Kind kind, Type globalActor);
 
+  EncodedParameterIndex getEncodedParameterIndex() const {
+    return EncodedParameterIndex::fromOpaqueValue(encodedParameterIndex);
+  }
+
 public:
   // No-argument constructor needed for DenseMap use in PostfixCompletion.cpp
   explicit ActorIsolation(Kind kind = Unspecified, bool isSILParsed = false)
       : pointer(nullptr), kind(kind), isolatedByPreconcurrency(false),
-        silParsed(isSILParsed), parameterIndex(0) {}
+        silParsed(isSILParsed), encodedParameterIndex(0) {
+    assert(kind != ActorInstance);
+  }
 
   static ActorIsolation forUnspecified() {
     return ActorIsolation(Unspecified);
@@ -125,19 +178,22 @@ class ActorIsolation {
 
   static ActorIsolation forActorInstanceParameter(NominalTypeDecl *actor,
                                                   unsigned parameterIndex) {
-    return ActorIsolation(ActorInstance, actor, parameterIndex + 1);
+    return ActorIsolation(ActorInstance, actor,
+                          EncodedParameterIndex::parameter(parameterIndex));
   }
 
   static ActorIsolation forActorInstanceParameter(VarDecl *actor,
                                                   unsigned parameterIndex) {
-    return ActorIsolation(ActorInstance, actor, parameterIndex + 1);
+    return ActorIsolation(ActorInstance, actor,
+                          EncodedParameterIndex::parameter(parameterIndex));
   }
 
   static ActorIsolation forActorInstanceParameter(Expr *actor,
                                                   unsigned parameterIndex);
 
   static ActorIsolation forActorInstanceCapture(VarDecl *capturedActor) {
-    return ActorIsolation(ActorInstance, capturedActor, 0);
+    return ActorIsolation(ActorInstance, capturedActor,
+                          EncodedParameterIndex::capture());
   }
 
   static ActorIsolation forGlobalActor(Type globalActor) {
@@ -187,17 +243,22 @@ class ActorIsolation {
   bool isNonisolatedUnsafe() const { return kind == NonisolatedUnsafe; }
 
   /// Retrieve the parameter to which actor-instance isolation applies.
-  ///
-  /// Parameter 0 is `self`.
-  unsigned getActorInstanceParameter() const {
+  unsigned getActorInstanceParameterIndex() const {
     assert(getKind() == ActorInstance);
-    return parameterIndex;
+    return getEncodedParameterIndex().getParameterIndex();
+  }
+
+  /// Given that this is actor instance isolation, is it a capture?
+  bool isActorInstanceForCapture() const {
+    assert(getKind() == ActorInstance);
+    return getEncodedParameterIndex().isCapture();
   }
 
   /// Returns true if this is an actor-instance isolation that additionally
   /// applies to the self parameter of a method.
   bool isActorInstanceForSelfParameter() const {
-    return getActorInstanceParameter() == 0;
+    assert(getKind() == ActorInstance);
+    return getEncodedParameterIndex().isSelf();
   }
 
   bool isSILParsed() const { return silParsed; }
@@ -285,13 +346,13 @@ class ActorIsolation {
     id.AddPointer(pointer);
     id.AddBoolean(isolatedByPreconcurrency);
     id.AddBoolean(silParsed);
-    id.AddInteger(parameterIndex);
+    id.AddInteger(encodedParameterIndex);
   }
 
   friend llvm::hash_code hash_value(const ActorIsolation &state) {
     return llvm::hash_combine(state.kind, state.pointer,
                               state.isolatedByPreconcurrency, state.silParsed,
-                              state.parameterIndex);
+                              state.encodedParameterIndex);
   }
 
   void print(llvm::raw_ostream &os) const;
diff --git a/lib/AST/ActorIsolation.cpp b/lib/AST/ActorIsolation.cpp
@@ -23,23 +23,27 @@ ActorIsolation ActorIsolation::forMainActor(ASTContext &ctx) {
       ctx.getMainActorType()->mapTypeOutOfContext());
 }
 
+// These constructors are defined out-of-line so that including ActorIsolation.h
+// doesn't require a bunch of other headers to be included.
+
 ActorIsolation::ActorIsolation(Kind kind, NominalTypeDecl *actor,
-                               unsigned parameterIndex)
+                               EncodedParameterIndex parameterIndex)
     : actorInstance(actor), kind(kind), isolatedByPreconcurrency(false),
-      silParsed(false), parameterIndex(parameterIndex) {}
+      silParsed(false), encodedParameterIndex(parameterIndex.getOpaqueValue()) {}
 
 ActorIsolation::ActorIsolation(Kind kind, VarDecl *actor,
-                               unsigned parameterIndex)
+                               EncodedParameterIndex parameterIndex)
     : actorInstance(actor), kind(kind), isolatedByPreconcurrency(false),
-      silParsed(false), parameterIndex(parameterIndex) {}
+      silParsed(false), encodedParameterIndex(parameterIndex.getOpaqueValue()) {}
 
-ActorIsolation::ActorIsolation(Kind kind, Expr *actor, unsigned parameterIndex)
+ActorIsolation::ActorIsolation(Kind kind, Expr *actor,
+                               EncodedParameterIndex parameterIndex)
     : actorInstance(actor), kind(kind), isolatedByPreconcurrency(false),
-      silParsed(false), parameterIndex(parameterIndex) {}
+      silParsed(false), encodedParameterIndex(parameterIndex.getOpaqueValue()) {}
 
 ActorIsolation::ActorIsolation(Kind kind, Type globalActor)
     : globalActor(globalActor), kind(kind), isolatedByPreconcurrency(false),
-      silParsed(false), parameterIndex(0) {}
+      silParsed(false), encodedParameterIndex(0) {}
 
 ActorIsolation
 ActorIsolation::forActorInstanceParameter(Expr *actor,
@@ -67,25 +71,29 @@ ActorIsolation::forActorInstanceParameter(Expr *actor,
     }
   }
 
-  return ActorIsolation(ActorInstance, actor, parameterIndex + 1);
+  return ActorIsolation(ActorInstance, actor,
+                        EncodedParameterIndex::parameter(parameterIndex));
 }
 
 ActorIsolation ActorIsolation::forActorInstanceSelf(ValueDecl *decl) {
   if (auto *fn = dyn_cast<AbstractFunctionDecl>(decl))
-    return ActorIsolation(ActorInstance, fn->getImplicitSelfDecl(), 0);
+    return ActorIsolation(ActorInstance, fn->getImplicitSelfDecl(),
+                          EncodedParameterIndex::self());
 
   if (auto *storage = dyn_cast<AbstractStorageDecl>(decl)) {
     if (auto *fn = storage->getAccessor(AccessorKind::Get)) {
-      return ActorIsolation(ActorInstance, fn->getImplicitSelfDecl(), 0);
+      return ActorIsolation(ActorInstance, fn->getImplicitSelfDecl(),
+                            EncodedParameterIndex::self());
     }
   }
 
   auto *dc = decl->getDeclContext();
-  return ActorIsolation(ActorInstance, dc->getSelfNominalTypeDecl(), 0);
+  return ActorIsolation(ActorInstance, dc->getSelfNominalTypeDecl(),
+                        EncodedParameterIndex::self());
 }
 
 ActorIsolation ActorIsolation::forActorInstanceSelf(NominalTypeDecl *selfDecl) {
-  return ActorIsolation(ActorInstance, selfDecl, 0);
+  return ActorIsolation(ActorInstance, selfDecl, EncodedParameterIndex::self());
 }
 
 NominalTypeDecl *ActorIsolation::getActor() const {
diff --git a/lib/SILGen/SILGenApply.cpp b/lib/SILGen/SILGenApply.cpp
@@ -6123,13 +6123,15 @@ RValue SILGenFunction::emitApply(
     SILValue executor;
     switch (*implicitActorHopTarget) {
     case ActorIsolation::ActorInstance:
-      if (unsigned paramIndex =
-              implicitActorHopTarget->getActorInstanceParameter()) {
+      assert(!implicitActorHopTarget->isActorInstanceForCapture());
+      if (implicitActorHopTarget->isActorInstanceForSelfParameter()) {
+        executor = emitLoadActorExecutor(loc, args.back());
+      } else {
+        unsigned paramIndex =
+          implicitActorHopTarget->getActorInstanceParameterIndex();
         auto isolatedIndex = calleeTypeInfo.origFormalType
-          ->getLoweredParamIndex(paramIndex - 1);
+          ->getLoweredParamIndex(paramIndex);
         executor = emitLoadActorExecutor(loc, args[isolatedIndex]);
-      } else {
-        executor = emitLoadActorExecutor(loc, args.back());
       }
       break;
 
diff --git a/lib/SILGen/SILGenConcurrency.cpp b/lib/SILGen/SILGenConcurrency.cpp
@@ -651,9 +651,7 @@ SILGenFunction::emitClosureIsolation(SILLocation loc, SILDeclRef constant,
              isolation.getGlobalActor()->getCanonicalType());
 
   case ActorIsolation::ActorInstance: {
-    // This should always be a capture.  That's not expressed super-cleanly
-    // in ActorIsolation, unfortunately.
-    assert(isolation.getActorInstanceParameter() == 0);
+    assert(isolation.isActorInstanceForCapture());
     auto capture = isolation.getActorInstance();
     assert(capture);
     return emitLoadOfCaptureIsolation(*this, loc, capture, constant, captures);
diff --git a/lib/SILGen/SILGenConstructor.cpp b/lib/SILGen/SILGenConstructor.cpp
@@ -595,7 +595,7 @@ static bool ctorHopsInjectedByDefiniteInit(ConstructorDecl *ctor,
   // must be self-isolated
   switch (isolation) {
   case ActorIsolation::ActorInstance:
-    return isolation.getActorInstanceParameter() == 0;
+    return isolation.isActorInstanceForSelfParameter();
 
   case ActorIsolation::Erased:
     llvm_unreachable("constructor cannot have erased isolation");
diff --git a/lib/SILGen/SILGenPoly.cpp b/lib/SILGen/SILGenPoly.cpp
@@ -7402,7 +7402,7 @@ void SILGenFunction::emitProtocolWitness(
 
     // For an instance actor, get the actor 'self'.
     if (*enterIsolation == ActorIsolation::ActorInstance) {
-      assert(enterIsolation->getActorInstanceParameter() == 0 && "Not self?");
+      assert(enterIsolation->isActorInstanceForSelfParameter() && "Not self?");
       auto actorSelfVal = origParams.back();
 
       if (actorSelfVal.getType().isAddress()) {
diff --git a/lib/Sema/TypeCheckConcurrency.cpp b/lib/Sema/TypeCheckConcurrency.cpp
@@ -3565,12 +3565,14 @@ namespace {
             if (isolation == ActorIsolation::ActorInstance) {
               VarDecl *var = isolation.getActorInstance();
               if (!var) {
+                assert(!isolation.isActorInstanceForCapture() &&
+                       "capture isolation without a variable reference?");
                 auto dc = const_cast<DeclContext *>(getDeclContext());
-                auto paramIdx = isolation.getActorInstanceParameter();
-                if (paramIdx == 0) {
+                if (isolation.isActorInstanceForSelfParameter()) {
                   var = cast<AbstractFunctionDecl>(dc)->getImplicitSelfDecl();
                 } else {
-                  var = const_cast<ParamDecl *>(getParameterAt(dc, paramIdx - 1));
+                  auto paramIdx = isolation.getActorInstanceParameterIndex();
+                  var = const_cast<ParamDecl *>(getParameterAt(dc, paramIdx));
                 }
               }
               return var;
@@ -4342,11 +4344,10 @@ namespace {
         const VarDecl *var = isolation.getActorInstance();
         if (!var) {
           auto dc = getDeclContext();
-          auto paramIdx = isolation.getActorInstanceParameter();
-          if (paramIdx == 0) {
+          if (isolation.isActorInstanceForSelfParameter()) {
             var = cast<AbstractFunctionDecl>(dc)->getImplicitSelfDecl();
           } else {
-            var = getParameterAt(dc, paramIdx - 1);
+            var = getParameterAt(dc, isolation.getActorInstanceParameterIndex());
           }
         }
         actorExpr = new (ctx) DeclRefExpr(
@@ -4656,7 +4657,7 @@ namespace {
       if (!partialApply &&
           (result.isolation.isGlobalActor() ||
            (result.isolation == ActorIsolation::ActorInstance &&
-            result.isolation.getActorInstanceParameter() > 0)) &&
+            !result.isolation.isActorInstanceForSelfParameter())) &&
           isa<AbstractFunctionDecl>(decl))
         return false;
 
@@ -8107,7 +8108,7 @@ ActorReferenceResult ActorReferenceResult::forReference(
   // The declaration we are accessing is actor-isolated. First, check whether
   // we are on the same actor already.
   if (actorInstance && declIsolation == ActorIsolation::ActorInstance &&
-      declIsolation.getActorInstanceParameter() == 0) {
+      declIsolation.isActorInstanceForSelfParameter()) {
     // If this instance is isolated, we're in the same concurrency domain.
     if (actorInstance->isIsolated())
       return forSameConcurrencyDomain(declIsolation, options);
