Stop inferring actor isolation from property wrappers in Swift 6.

In Swift 5, isolation will continue, but will now produce a warning
and a fix-it suggesting that the user add explicit isolation

(cherry picked from commit 982e14b)

Author: bjhomer

include/swift/AST/DiagnosticsSema.def

@@ -5364,6 +5364,12 @@ ERROR(async_unavailable_decl,none,
       "%0 %1 is unavailable from asynchronous contexts%select{|; %2}2",
       (DescriptiveDeclKind, DeclBaseName, StringRef))
 
+WARNING(actor_isolation_inferred_from_property_wrapper,none,
+        "%0 is implicitly %1 because it uses %2. This implicit isolation "
+        "will no longer happen in Swift 6.",
+        (DeclName, ActorIsolation, StringRef))
+
+
 //------------------------------------------------------------------------------
 // MARK: String Processing
 //------------------------------------------------------------------------------

lib/Sema/TypeCheckConcurrency.cpp

@@ -3622,8 +3622,16 @@ static Optional<ActorIsolation> getIsolationFromWrappers(
 
   if (!nominal->getParentSourceFile())
     return None;
-  
-  Optional<ActorIsolation> foundIsolation;
+
+  ASTContext &ctx = nominal->getASTContext();
+  if (ctx.isSwiftVersionAtLeast(6)) {
+    // In Swift 6, we no longer infer isolation of a nominal type based
+    // on property wrappers used in its stored properties
+    return None;
+  }
+
+  Optional<std::pair<ActorIsolation, Type>> foundIsolationAndType;
+
   for (auto member : nominal->getMembers()) {
     auto var = dyn_cast<VarDecl>(member);
     if (!var || !var->isInstanceMember())
@@ -3648,19 +3656,36 @@ static Optional<ActorIsolation> getIsolationFromWrappers(
 
     case ActorIsolation::GlobalActor:
     case ActorIsolation::GlobalActorUnsafe:
-      if (!foundIsolation) {
-        foundIsolation = isolation;
-        continue;
+      if (!foundIsolationAndType) {
+        if (auto propertyWrapperType = var->getAttachedPropertyWrapperType(0)) {
+          foundIsolationAndType = { isolation, propertyWrapperType };
+          continue;
+        }
       }
 
-      if (*foundIsolation != isolation)
+      if (foundIsolationAndType->first != isolation)
         return None;
 
       break;
     }
   }
 
-  return foundIsolation;
+  if (foundIsolationAndType) {
+    // We are inferring isolation for the type because
+    // it contains an actor-isolated property wrapper.
+    // Warn that this inferrence will be going away in
+    // Swift 6
+    const ActorIsolation isolation = foundIsolationAndType->first;
+    const Type type = foundIsolationAndType->second;
+
+    nominal->diagnose(diag::actor_isolation_inferred_from_property_wrapper,
+                      nominal->getName(), isolation, "'@"+type->getString()+"'")
+      .fixItInsert(nominal->getAttributeInsertionLoc(false), "@" + isolation.getGlobalActor().getString());
+    return isolation;
+  }
+  else {
+    return None;
+  }
 }
 
 namespace {
@@ -4236,8 +4261,8 @@ ActorIsolation ActorIsolationRequest::evaluate(
         if (auto inferred = inferredIsolation(*conformanceIsolation))
           return inferred;
 
-      // If the declaration is a nominal type and any property wrappers on
-      // its stored properties require isolation, use that.
+      // Before Swift 6: If the declaration is a nominal type and any property
+      // wrappers on its stored properties require isolation, use that.
       if (auto wrapperIsolation = getIsolationFromWrappers(nominal)) {
         if (auto inferred = inferredIsolation(*wrapperIsolation))
           return inferred;