[Concurrency] When isolated default values are enabled, synthesized initializers

should be nonisolated if all initialized properties are Sendable with nonisolated
default values.

(cherry picked from commit d6fce01)

Author: hborla

include/swift/AST/DiagnosticsSema.def

@@ -5200,6 +5200,12 @@ ERROR(distributed_actor_isolated_non_self_reference,none,
       "distributed actor-isolated %kind0 can not be accessed from a "
       "non-isolated context",
       (const ValueDecl *))
+ERROR(conflicting_stored_property_isolation,none,
+      "%select{default|memberwise}0 initializer for %1 cannot be both %2 and %3",
+      (bool, Type, ActorIsolation, ActorIsolation))
+NOTE(property_requires_actor,none,
+      "initializer for %0 %1 is %2",
+      (DescriptiveDeclKind, Identifier, ActorIsolation))
 ERROR(isolated_default_argument_context,none,
       "%0 default value in a %1 context", 
       (ActorIsolation, ActorIsolation))

lib/Sema/CodeSynthesis.cpp

@@ -336,13 +336,64 @@ static ConstructorDecl *createImplicitConstructor(NominalTypeDecl *decl,
   ctor->setSynthesized();
   ctor->setAccess(accessLevel);
 
+  if (ctx.LangOpts.hasFeature(Feature::IsolatedDefaultValues)) {
+    // If any of the type's actor-isolated properties:
+    //   1. Have non-Sendable type, or
+    //   2. Have an isolated initial value
+    // then the initializer must also be actor-isolated. If all
+    // isolated properties have Sendable type and a nonisolated
+    // default value, then the initializer can be nonisolated.
+    //
+    // These rules only apply for global actor isolation, because actor
+    // initializers apply Sendable checking to arguments at the call-site,
+    // and actor initializers do not run on the actor, so initial values
+    // cannot be actor-instance-isolated.
+    bool shouldAddNonisolated = true;
+    llvm::Optional<ActorIsolation> existingIsolation = llvm::None;
+    VarDecl *previousVar = nullptr;
+
+    // The memberwise init properties are also effectively what the
+    // default init uses, e.g. default initializers initialize via
+    // properties wrapped and init accessors.
+    for (auto var : decl->getMemberwiseInitProperties()) {
+      auto type = var->getTypeInContext();
+      auto isolation = getActorIsolation(var);
+      if (isolation.isGlobalActor()) {
+        if (!isSendableType(decl->getModuleContext(), type) ||
+            var->getInitializerIsolation().isGlobalActor()) {
+          // If different isolated stored properties require different
+          // global actors, it is impossible to initialize this type.
+          if (existingIsolation &&
+              *existingIsolation != isolation) {
+            ctx.Diags.diagnose(decl->getLoc(),
+                diag::conflicting_stored_property_isolation,
+                ICK == ImplicitConstructorKind::Memberwise,
+                decl->getDeclaredType(), *existingIsolation, isolation);
+            previousVar->diagnose(
+                diag::property_requires_actor,
+                previousVar->getDescriptiveKind(),
+                previousVar->getName(), *existingIsolation);
+            var->diagnose(
+                diag::property_requires_actor,
+                var->getDescriptiveKind(),
+                var->getName(), isolation);
+          }
+
+          existingIsolation = isolation;
+          previousVar = var;
+          shouldAddNonisolated = false;
+        }
+      }
+    }
+
+    if (shouldAddNonisolated) {
+      addNonIsolatedToSynthesized(decl, ctor);
+    }
+  }
+
   if (ICK == ImplicitConstructorKind::Memberwise) {
     ctor->setIsMemberwiseInitializer();
 
-    // FIXME: If 'IsolatedDefaultValues' is enabled, the memberwise init
-    // should be 'nonisolated' if none of the memberwise-initialized properties
-    // are global actor isolated and have non-Sendable type, and none of the
-    // initial values require global actor isolation.
     if (!ctx.LangOpts.hasFeature(Feature::IsolatedDefaultValues)) {
       addNonIsolatedToSynthesized(decl, ctor);
     }

lib/Sema/TypeCheckConcurrency.cpp

@@ -4818,8 +4818,11 @@ DefaultInitializerIsolation::evaluate(Evaluator &evaluator,
       return ActorIsolation::forUnspecified();
 
     auto i = pbd->getPatternEntryIndexForVarDecl(var);
+    if (!pbd->isInitializerChecked(i))
+      TypeChecker::typeCheckPatternBinding(pbd, i);
+
     dc = cast<Initializer>(pbd->getInitContext(i));
-    initExpr = var->getParentInitializer();
+    initExpr = pbd->getInit(i);
     enclosingIsolation = getActorIsolation(var);
   } else if (auto *param = dyn_cast<ParamDecl>(var)) {
     // If this parameter corresponds to a stored property for a

test/Concurrency/isolated_default_arguments.swift

@@ -195,3 +195,37 @@ extension A {
     _ = S2(required: 10)
   }
 }
+
+// expected-error@+1 {{default initializer for 'C1' cannot be both main actor-isolated and global actor 'SomeGlobalActor'-isolated}}
+class C1 {
+  // expected-note@+1 {{initializer for property 'x' is main actor-isolated}}
+  @MainActor var x = requiresMainActor()
+  // expected-note@+1 {{initializer for property 'y' is global actor 'SomeGlobalActor'-isolated}}
+  @SomeGlobalActor var y = requiresSomeGlobalActor()
+}
+
+class NonSendable {}
+
+// expected-error@+1 {{default initializer for 'C2' cannot be both main actor-isolated and global actor 'SomeGlobalActor'-isolated}}
+class C2 {
+  // expected-note@+1 {{initializer for property 'x' is main actor-isolated}}
+  @MainActor var x = NonSendable()
+  // expected-note@+1 {{initializer for property 'y' is global actor 'SomeGlobalActor'-isolated}}
+  @SomeGlobalActor var y = NonSendable()
+}
+
+class C3 {
+  @MainActor var x = 1
+  @SomeGlobalActor var y = 2
+}
+
+@MainActor struct NonIsolatedInit {
+  var x = 0
+  var y = 0
+}
+
+func callDefaultInit() async {
+  _ = C2()
+  _ = NonIsolatedInit()
+  _ = NonIsolatedInit(x: 10)
+}