[Concurrency] Serialize default argument isolation.

hborla · Holly Borla · commit 3cb9bb89bc2b · 2023-10-04T13:12:11.000-07:00
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -1973,15 +1973,6 @@ class PatternBindingEntry {
   SourceRange getOriginalInitRange() const;
   void setInit(Expr *E);
 
-  /// Get the required actor isolation for evaluating the initializer
-  /// expression synchronously (if there is one). 
-  ///
-  /// If this pattern binding entry is for a stored instance property, the
-  /// initializer can only be used in an `init` that meets the required
-  /// isolation; otherwise, the property must be explicitly initialized in
-  /// the `init`.
-  ActorIsolation getInitializerIsolation() const;
-
   /// Gets the text of the initializer expression, stripping out inactive
   /// branches of any #ifs inside the expression.
   StringRef getInitStringRepresentation(SmallVectorImpl<char> &scratch) const;
@@ -2235,10 +2226,6 @@ class PatternBindingDecl final : public Decl,
     getMutablePatternList()[i].setOriginalInit(E);
   }
 
-  ActorIsolation getInitializerIsolation(unsigned i) const {
-    return getPatternList()[i].getInitializerIsolation();
-  }
-
   Pattern *getPattern(unsigned i) const {
     return getPatternList()[i].getPattern();
   }
@@ -5986,6 +5973,19 @@ class VarDecl : public AbstractStorageDecl {
     return getParentExecutableInitializer() != nullptr;
   }
 
+  /// Get the required actor isolation for evaluating the initializer
+  /// expression synchronously (if there is one).
+  ///
+  /// If this VarDecl is a stored instance property, the initializer
+  /// can only be used in an `init` that meets the required isolation.
+  /// Otherwise, the property must be explicitly initialized in the `init`.
+  ///
+  /// If this is a ParamDecl, the initializer isolation is required at
+  /// the call-site in order to use the default argument for this parameter.
+  /// If the required isolation is not met, an argument must be written
+  /// explicitly at the call-site.
+  ActorIsolation getInitializerIsolation() const;
+
   // Return whether this VarDecl has an initial value, either by checking
   // if it has an initializer in its parent pattern binding or if it has
   // the @_hasInitialValue attribute.
@@ -6428,11 +6428,6 @@ class ParamDecl : public VarDecl {
   /// at the call site in order to have the correct context information.
   Expr *getTypeCheckedDefaultExpr() const;
 
-  /// The actor isolation required of the caller in order to use the
-  /// default argument for this parameter. If the required isolation is
-  /// not met, an argument must be written explicitly at the call-site.
-  ActorIsolation getDefaultArgumentIsolation() const;
-
   /// Retrieve the potentially un-type-checked default argument expression for
   /// this parameter, which can be queried for information such as its source
   /// range and textual representation. Returns \c nullptr if there is no
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -2938,7 +2938,7 @@ class DefaultArgumentTypeRequest
 /// default initializer expression.
 class DefaultInitializerIsolation
     : public SimpleRequest<DefaultInitializerIsolation,
-                           ActorIsolation(Initializer *, Expr *),
+                           ActorIsolation(VarDecl *),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -2947,8 +2947,7 @@ class DefaultInitializerIsolation
   friend SimpleRequest;
 
   ActorIsolation evaluate(Evaluator &evaluator, 
-                          Initializer *init,
-                          Expr *initExpr) const;
+                          VarDecl *) const;
 
 public:
   bool isCached() const { return true; }
diff --git a/include/swift/AST/TypeCheckerTypeIDZone.def b/include/swift/AST/TypeCheckerTypeIDZone.def
@@ -63,7 +63,7 @@ SWIFT_REQUEST(TypeChecker, DefaultArgumentExprRequest,
 SWIFT_REQUEST(TypeChecker, DefaultArgumentTypeRequest,
               Type(ParamDecl *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DefaultInitializerIsolation,
-              ActorIsolation(Initializer *, Expr *),
+              ActorIsolation(VarDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DefaultArgumentInitContextRequest,
               Initializer *(ParamDecl *), SeparatelyCached, NoLocationInfo)
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -1976,20 +1976,6 @@ void PatternBindingEntry::setInit(Expr *E) {
                              PatternFlags::IsText);
 }
 
-ActorIsolation PatternBindingEntry::getInitializerIsolation() const {
-  if (!isInitialized())
-    return ActorIsolation::forUnspecified();
-
-  auto *dc = cast<Initializer>(getInitContext());
-  auto &ctx = dc->getASTContext();
-  auto *initExpr = getExecutableInit();
-
-  return evaluateOrDefault(
-      ctx.evaluator,
-      DefaultInitializerIsolation{dc, initExpr},
-      ActorIsolation::forNonisolated());
-}
-
 VarDecl *PatternBindingEntry::getAnchoringVarDecl() const {
   SmallVector<VarDecl *, 8> variables;
   getPattern()->collectVariables(variables);
@@ -7141,6 +7127,14 @@ Expr *VarDecl::getParentExecutableInitializer() const {
   return nullptr;
 }
 
+ActorIsolation VarDecl::getInitializerIsolation() const {
+  auto *mutableThis = const_cast<VarDecl *>(this);
+  return evaluateOrDefault(
+      getASTContext().evaluator,
+      DefaultInitializerIsolation{mutableThis},
+      ActorIsolation::forUnspecified());
+}
+
 SourceRange VarDecl::getSourceRange() const {
   if (auto Param = dyn_cast<ParamDecl>(this))
     return Param->getSourceRange();
@@ -8277,34 +8271,6 @@ Type ParamDecl::getTypeOfDefaultExpr() const {
   return Type();
 }
 
-ActorIsolation ParamDecl::getDefaultArgumentIsolation() const {
-  // If this parameter corresponds to a stored property for a
-  // memberwise initializer, the default argument is the default
-  // initializer expression.
-  auto *var = getStoredProperty();
-  if (var && !var->isInvalid()) {
-    // FIXME: Force computation of property wrapper initializers.
-    if (auto *wrapped = var->getOriginalWrappedProperty())
-      (void)wrapped->getPropertyWrapperInitializerInfo();
-
-    auto *pbd = var->getParentPatternBinding();
-    auto i = pbd->getPatternEntryIndexForVarDecl(var);
-    return var->getParentPatternBinding()->getInitializerIsolation(i);
-  }
-
-  if (!hasDefaultExpr())
-    return ActorIsolation::forUnspecified();
-
-  auto &ctx = getASTContext();
-  auto *dc = getDefaultArgumentInitContext();
-  auto *initExpr = getTypeCheckedDefaultExpr();
-
-  return evaluateOrDefault(
-      ctx.evaluator,
-      DefaultInitializerIsolation{dc, initExpr},
-      ActorIsolation::forNonisolated());
-}
-
 void ParamDecl::setDefaultExpr(Expr *E, bool isTypeChecked) {
   if (!DefaultValueAndFlags.getPointer()) {
     if (!E) return;
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
@@ -1608,8 +1608,7 @@ Expr *DefaultArgumentExpr::getCallerSideDefaultExpr() const {
 
 ActorIsolation
 DefaultArgumentExpr::getRequiredIsolation() const {
-  auto *param = getParamDecl();
-  return param->getDefaultArgumentIsolation();
+  return getParamDecl()->getInitializerIsolation();
 }
 
 ValueDecl *ApplyExpr::getCalledValue(bool skipFunctionConversions) const {
diff --git a/lib/SILGen/SILGenConstructor.cpp b/lib/SILGen/SILGenConstructor.cpp
@@ -1547,7 +1547,8 @@ void SILGenFunction::emitMemberInitializer(DeclContext *dc, VarDecl *selfDecl,
     // initializer from being evaluated synchronously (or propagating required
     // isolation through closure bodies), then the default value cannot be used
     // and the member must be explicitly initialized in the constructor.
-    auto requiredIsolation = field->getInitializerIsolation(i);
+    auto *var = field->getAnchoringVarDecl(i);
+    auto requiredIsolation = var->getInitializerIsolation();
     auto contextIsolation = getActorIsolationOfContext(dc);
     switch (requiredIsolation) {
     // 'nonisolated' expressions can be evaluated from anywhere
diff --git a/lib/Sema/TypeCheckDeclPrimary.cpp b/lib/Sema/TypeCheckDeclPrimary.cpp
@@ -1069,7 +1069,7 @@ static void checkDefaultArguments(ParameterList *params) {
   for (auto *param : *params) {
     auto ifacety = param->getInterfaceType();
     auto *expr = param->getTypeCheckedDefaultExpr();
-    (void)param->getDefaultArgumentIsolation();
+    (void)param->getInitializerIsolation();
 
     if (!ifacety->hasPlaceholder()) {
       continue;
@@ -1158,12 +1158,43 @@ Expr *DefaultArgumentExprRequest::evaluate(Evaluator &evaluator,
 
 ActorIsolation 
 DefaultInitializerIsolation::evaluate(Evaluator &evaluator,
-                                      Initializer *init,
-                                      Expr *initExpr) const {
-  if (!init || !initExpr)
+                                      VarDecl *var) const {
+  if (var->isInvalid())
     return ActorIsolation::forUnspecified();
 
-  return computeRequiredIsolation(init, initExpr);
+  Initializer *dc = nullptr;
+  Expr *initExpr = nullptr;
+
+  if (auto *pbd = var->getParentPatternBinding()) {
+    if (!var->isParentInitialized())
+      return ActorIsolation::forUnspecified();
+
+    auto i = pbd->getPatternEntryIndexForVarDecl(var);
+    dc = cast<Initializer>(pbd->getInitContext(i));
+    initExpr = var->getParentInitializer();
+  } else if (auto *param = dyn_cast<ParamDecl>(var)) {
+    // If this parameter corresponds to a stored property for a
+    // memberwise initializer, the default argument is the default
+    // initializer expression.
+    if (auto *property = param->getStoredProperty()) {
+      // FIXME: Force computation of property wrapper initializers.
+      if (auto *wrapped = property->getOriginalWrappedProperty())
+        (void)property->getPropertyWrapperInitializerInfo();
+
+      return property->getInitializerIsolation();
+    }
+
+    if (!param->hasDefaultExpr())
+      return ActorIsolation::forUnspecified();
+
+    dc = param->getDefaultArgumentInitContext();
+    initExpr = param->getTypeCheckedDefaultExpr();
+  }
+
+  if (!dc || !initExpr)
+    return ActorIsolation::forUnspecified();
+
+  return computeRequiredIsolation(dc, initExpr);
 }
 
 Type DefaultArgumentTypeRequest::evaluate(Evaluator &evaluator,
@@ -2476,7 +2507,11 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
               PBD->getInitContext(i));
           if (initContext) {
             TypeChecker::contextualizeInitializer(initContext, init);
-            (void)PBD->getInitializerIsolation(i);
+            if (auto *singleVar = PBD->getSingleVar()) {
+              (void)singleVar->getInitializerIsolation();
+            } else {
+              computeRequiredIsolation(initContext, init);
+            }
             TypeChecker::checkInitializerEffects(initContext, init);
           }
         }
diff --git a/lib/Sema/TypeCheckStorage.cpp b/lib/Sema/TypeCheckStorage.cpp
@@ -3226,7 +3226,7 @@ PropertyWrapperInitializerInfoRequest::evaluate(Evaluator &evaluator,
   // synthesize a computed property for '$foo'.
   Expr *projectedValueInit = nullptr;
   if (auto *projection = var->getPropertyWrapperProjectionVar()) {
-    auto *pbd = createPBD(projection);
+    createPBD(projection);
 
     if (var->hasExternalPropertyWrapper()) {
       // Projected-value initialization is currently only supported for parameters.
@@ -3240,7 +3240,7 @@ PropertyWrapperInitializerInfoRequest::evaluate(Evaluator &evaluator,
       // Check initializer effects.
       auto *initContext = new (ctx) PropertyWrapperInitializer(
           dc, param, PropertyWrapperInitializer::Kind::ProjectedValue);
-      (void)pbd->getInitializerIsolation(0);
+      (void)projection->getInitializerIsolation();
       TypeChecker::checkInitializerEffects(initContext, projectedValueInit);
     }
   }
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
@@ -455,6 +455,22 @@ getActualDefaultArgKind(uint8_t raw) {
   return llvm::None;
 }
 
+static llvm::Optional<swift::ActorIsolation::Kind>
+getActualActorIsolationKind(uint8_t raw) {
+  switch (static_cast<serialization::ActorIsolation>(raw)) {
+#define CASE(X) \
+  case serialization::ActorIsolation::X: \
+    return swift::ActorIsolation::Kind::X;
+  CASE(Unspecified)
+  CASE(ActorInstance)
+  CASE(Nonisolated)
+  CASE(GlobalActor)
+  CASE(GlobalActorUnsafe)
+#undef CASE
+  }
+  return llvm::None;
+}
+
 static llvm::Optional<StableSerializationPath::ExternalPath::ComponentKind>
 getActualClangDeclPathComponentKind(uint64_t raw) {
   switch (static_cast<serialization::ClangDeclPathComponentKind>(raw)) {
@@ -3764,14 +3780,18 @@ class DeclDeserializer {
     bool isCompileTimeConst;
     uint8_t rawDefaultArg;
     TypeID defaultExprType;
+    uint8_t rawDefaultArgIsolation;
+    TypeID globalActorTypeID;
 
     decls_block::ParamLayout::readRecord(scratch, argNameID, paramNameID,
                                          contextID, rawSpecifier,
                                          interfaceTypeID, isIUO, isVariadic,
                                          isAutoClosure, isIsolated,
                                          isCompileTimeConst,
                                          rawDefaultArg,
-                                         defaultExprType);
+                                         defaultExprType,
+                                         rawDefaultArgIsolation,
+                                         globalActorTypeID);
 
     auto argName = MF.getIdentifier(argNameID);
     auto paramName = MF.getIdentifier(paramNameID);
@@ -3816,6 +3836,29 @@ class DeclDeserializer {
       if (auto exprType = MF.getType(defaultExprType))
         param->setDefaultExprType(exprType);
 
+      auto isoKind = *getActualActorIsolationKind(rawDefaultArgIsolation);
+      auto globalActor = MF.getType(globalActorTypeID);
+      ActorIsolation isolation;
+      switch (isoKind) {
+      case ActorIsolation::Unspecified:
+      case ActorIsolation::Nonisolated:
+        isolation = ActorIsolation::forUnspecified();
+        break;
+
+      case ActorIsolation::GlobalActor:
+      case ActorIsolation::GlobalActorUnsafe:
+        isolation = ActorIsolation::forGlobalActor(
+            globalActor, isoKind == ActorIsolation::GlobalActorUnsafe);
+        break;
+
+      case ActorIsolation::ActorInstance:
+        llvm_unreachable("default arg cannot be actor instance isolated");
+      }
+
+      ctx.evaluator.cacheOutput(
+          DefaultInitializerIsolation{param},
+          std::move(isolation));
+
       if (!blobData.empty())
         param->setDefaultValueStringRepresentation(blobData);
     }
diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h
@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 810; // access enforcement
+const uint16_t SWIFTMODULE_VERSION_MINOR = 811; // default argument isolation
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -526,6 +526,17 @@ enum class DefaultArgumentKind : uint8_t {
 };
 using DefaultArgumentField = BCFixed<4>;
 
+/// These IDs must \em not be renumbered or reordered without incrementing
+/// the module version.
+enum class ActorIsolation : uint8_t {
+  Unspecified = 0,
+  ActorInstance,
+  Nonisolated,
+  GlobalActor,
+  GlobalActorUnsafe
+};
+using ActorIsolationField = BCFixed<3>;
+
 // These IDs must \em not be renumbered or reordered without incrementing
 // the module version.
 enum LibraryKind : uint8_t {
@@ -1568,6 +1579,8 @@ namespace decls_block {
     BCFixed<1>,              // isCompileTimeConst?
     DefaultArgumentField,    // default argument kind
     TypeIDField,             // default argument type
+    ActorIsolationField,     // default argument isolation
+    TypeIDField,             // global actor isolation
     BCBlob                   // default argument text
   >;
 
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
diff --git a/test/Concurrency/Inputs/serialized_default_arguments.swift b/test/Concurrency/Inputs/serialized_default_arguments.swift
diff --git a/test/Concurrency/isolated_default_arguments_serialized.swift b/test/Concurrency/isolated_default_arguments_serialized.swift

Original file line number	Diff line number	Diff line change
`@@ -1608,8 +1608,7 @@ Expr *DefaultArgumentExpr::getCallerSideDefaultExpr() const {`
`1608`	`1608`
`1609`	`1609`	`ActorIsolation`
`1610`	`1610`	`DefaultArgumentExpr::getRequiredIsolation() const {`
`1611`		`- auto *param = getParamDecl();`
`1612`		`- return param->getDefaultArgumentIsolation();`
	`1611`	`+ return getParamDecl()->getInitializerIsolation();`
`1613`	`1612`	`}`
`1614`	`1613`
`1615`	`1614`	`ValueDecl *ApplyExpr::getCalledValue(bool skipFunctionConversions) const {`