Add 'nonisolated' modifier as the preferred spelling for @actorIndependent

Author: DougGregor

include/swift/AST/Attr.def

@@ -620,7 +620,7 @@ SIMPLE_DECL_ATTR(reasync, Reasync,
   109)
 
 SIMPLE_DECL_ATTR(reasync, AtReasync,
-  OnProtocol |
+  OnProtocol | ConcurrencyOnly |
   ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
   110)
 
@@ -630,6 +630,13 @@ DECL_ATTR(hasAsyncAlternative, HasAsyncAlternative,
   APIStableToAdd | APIStableToRemove,
   111)
 
+CONTEXTUAL_SIMPLE_DECL_ATTR(nonisolated, Nonisolated,
+  OnFunc | OnConstructor | OnVar | OnSubscript | ConcurrencyOnly |
+  ABIStableToAdd | ABIStableToRemove |
+  APIBreakingToAdd | APIStableToRemove,
+  112)
+
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/DiagnosticsSema.def

@@ -4212,8 +4212,8 @@ NOTE(note_add_async_to_function,none,
      "add 'async' to function %0 to make it asynchronous", (DeclName))
 NOTE(note_add_asynchandler_to_function,none,
      "add '@asyncHandler' to function %0 to create an implicit asynchronous context", (DeclName))
-NOTE(note_add_actorindependent_to_decl,none,
-     "add '@actorIndependent' to %0 to make this %1 independent of the actor",
+NOTE(note_add_nonisolated_to_decl,none,
+     "add 'nonisolated' to %0 to make this %1 not isolated to the actor",
      (DeclName, DescriptiveDeclKind))
 NOTE(note_add_globalactor_to_function,none,
      "add '@%0' to make %1 %2 part of global actor %3", 
@@ -4407,9 +4407,20 @@ ERROR(actorindependent_local_var,none,
       "'@actorIndependent' can not be applied to local variables",
       ())
 
+ERROR(nonisolated_let,none,
+      "'nonisolated' is meaningless on 'let' declarations because "
+      "they are immutable",
+      ())
+ERROR(nonisolated_mutable_storage,none,
+      "nonisolated' can not be applied to stored properties",
+      ())
+ERROR(nonisolated_local_var,none,
+      "'nonisolated' can not be applied to local variables",
+      ())
+
 ERROR(actor_instance_property_wrapper,none,
       "%0 property in property wrapper type %1 cannot be isolated to "
-      "the actor instance; consider @actorIndependent",
+      "the actor instance; consider 'nonisolated'",
       (Identifier, Identifier))
 
 ERROR(concurrency_lib_missing,none,

lib/Sema/TypeCheckAttr.cpp

@@ -281,6 +281,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   void visitMarkerAttr(MarkerAttr *attr);
 
   void visitReasyncAttr(ReasyncAttr *attr);
+  void visitNonisolatedAttr(NonisolatedAttr *attr);
 };
 } // end anonymous namespace
 
@@ -5476,6 +5477,41 @@ void AttributeChecker::visitActorIndependentAttr(ActorIndependentAttr *attr) {
   }
 }
 
+void AttributeChecker::visitNonisolatedAttr(NonisolatedAttr *attr) {
+  // 'nonisolated' can be applied to global and static/class variables
+  // that do not have storage.
+  auto dc = D->getDeclContext();
+  if (auto var = dyn_cast<VarDecl>(D)) {
+    // 'nonisolated' is meaningless on a `let`.
+    if (var->isLet()) {
+      diagnoseAndRemoveAttr(attr, diag::nonisolated_let);
+      return;
+    }
+
+    // 'nonisolated' can not be applied to stored properties.
+    if (var->hasStorage()) {
+      diagnoseAndRemoveAttr(attr, diag::nonisolated_mutable_storage);
+      return;
+    }
+
+    // @actorIndependent can not be applied to local properties.
+    if (dc->isLocalContext()) {
+      diagnoseAndRemoveAttr(attr, diag::nonisolated_local_var);
+      return;
+    }
+
+    // If this is a static or global variable, we're all set.
+    if (dc->isModuleScopeContext() ||
+        (dc->isTypeContext() && var->isStatic())) {
+      return;
+    }
+  }
+
+  if (auto VD = dyn_cast<ValueDecl>(D)) {
+    (void)getActorIsolation(VD);
+  }
+}
+
 void AttributeChecker::visitGlobalActorAttr(GlobalActorAttr *attr) {
   auto nominal = dyn_cast<NominalTypeDecl>(D);
   if (!nominal)

lib/Sema/TypeCheckConcurrency.cpp

@@ -2241,13 +2241,16 @@ static Optional<ActorIsolation> getIsolationFromAttributes(
   // Look up attributes on the declaration that can affect its actor isolation.
   // If any of them are present, use that attribute.
   auto independentAttr = decl->getAttrs().getAttribute<ActorIndependentAttr>();
+  auto nonisolatedAttr = decl->getAttrs().getAttribute<NonisolatedAttr>();
   auto globalActorAttr = decl->getGlobalActorAttr();
   unsigned numIsolationAttrs =
-    (independentAttr ? 1 : 0) + (globalActorAttr ? 1 : 0);
+    (nonisolatedAttr ? 1 : 0) + (independentAttr ? 1 : 0) +
+    (globalActorAttr ? 1 : 0);
   if (numIsolationAttrs == 0)
     return None;
 
-  // Only one such attribute is valid.
+  // Only one such attribute is valid, but we only actually care of one of
+  // them is a global actor.
   if (numIsolationAttrs > 1) {
     DeclName name;
     if (auto value = dyn_cast<ValueDecl>(decl)) {
@@ -2257,16 +2260,34 @@ static Optional<ActorIsolation> getIsolationFromAttributes(
         name = selfTypeDecl->getName();
     }
 
-    if (shouldDiagnose) {
-      decl->diagnose(
-          diag::actor_isolation_multiple_attr, decl->getDescriptiveKind(),
-          name, independentAttr->getAttrName(),
-          globalActorAttr->second->getName().str())
-        .highlight(independentAttr->getRangeWithAt())
-        .highlight(globalActorAttr->first->getRangeWithAt());
+    if (globalActorAttr) {
+      StringRef nonisolatedAttrName;
+      SourceRange nonisolatedRange;
+      if (independentAttr) {
+        nonisolatedAttrName = independentAttr->getAttrName();
+        nonisolatedRange = independentAttr->getRangeWithAt();
+      } else {
+        nonisolatedAttrName = nonisolatedAttr->getAttrName();
+        nonisolatedRange = nonisolatedAttr->getRangeWithAt();
+      }
+
+      if (shouldDiagnose) {
+        decl->diagnose(
+            diag::actor_isolation_multiple_attr, decl->getDescriptiveKind(),
+            name, nonisolatedAttrName,
+            globalActorAttr->second->getName().str())
+          .highlight(nonisolatedRange)
+          .highlight(globalActorAttr->first->getRangeWithAt());
+      }
     }
   }
 
+    // If the declaration is explicitly marked 'nonisolated', report it as
+    // independent.
+    if (nonisolatedAttr) {
+      return ActorIsolation::forIndependent(ActorIndependentKind::Safe);
+    }
+
   // If the declaration is explicitly marked @actorIndependent, report it as
   // independent.
   if (independentAttr) {

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1540,6 +1540,7 @@ namespace  {
     UNINTERESTING_ATTR(Marker)
 
     UNINTERESTING_ATTR(AtReasync)
+    UNINTERESTING_ATTR(Nonisolated)
 
 #undef UNINTERESTING_ATTR
 

lib/Sema/TypeCheckProtocol.cpp

@@ -2748,10 +2748,10 @@ bool ConformanceChecker::checkActorIsolation(
       auto witnessVar = dyn_cast<VarDecl>(witness);
       if ((witnessVar && !witnessVar->hasStorage()) || !witnessVar) {
         auto independentNote = witness->diagnose(
-            diag::note_add_actorindependent_to_decl,
+            diag::note_add_nonisolated_to_decl,
             witness->getName(), witness->getDescriptiveKind());
-        independentNote.fixItInsert(witness->getAttributeInsertionLoc(false),
-            "@actorIndependent ");
+        independentNote.fixItInsert(witness->getAttributeInsertionLoc(true),
+            "nonisolated ");
       }
     }
 

test/Concurrency/global_actor_inference.swift

@@ -243,7 +243,7 @@ func barSync() {
 struct WrapperOnActor<Wrapped> {
   @actorIndependent(unsafe) private var stored: Wrapped
 
-  @actorIndependent init(wrappedValue: Wrapped) {
+  nonisolated init(wrappedValue: Wrapped) {
     stored = wrappedValue
   }
 
@@ -266,12 +266,12 @@ actor WrapperActor<Wrapped> {
     storage = wrappedValue
   }
 
-  @actorIndependent var wrappedValue: Wrapped {
+  nonisolated var wrappedValue: Wrapped {
     get { storage }
     set { storage = newValue }
   }
 
-  @actorIndependent var projectedValue: Wrapped {
+  nonisolated var projectedValue: Wrapped {
     get { storage }
     set { storage = newValue }
   }
@@ -311,7 +311,7 @@ actor WrapperActorBad1<Wrapped> {
     storage = wrappedValue
   }
 
-  var wrappedValue: Wrapped { // expected-error{{'wrappedValue' property in property wrapper type 'WrapperActorBad1' cannot be isolated to the actor instance; consider @actorIndependent}}}}
+  var wrappedValue: Wrapped { // expected-error{{'wrappedValue' property in property wrapper type 'WrapperActorBad1' cannot be isolated to the actor instance; consider 'nonisolated'}}}}
     get { storage }
     set { storage = newValue }
   }
@@ -325,12 +325,12 @@ actor WrapperActorBad2<Wrapped> {
     storage = wrappedValue
   }
 
-  @actorIndependent var wrappedValue: Wrapped {
+  nonisolated var wrappedValue: Wrapped {
     get { storage }
     set { storage = newValue }
   }
 
-  var projectedValue: Wrapped { // expected-error{{'projectedValue' property in property wrapper type 'WrapperActorBad2' cannot be isolated to the actor instance; consider @actorIndependent}}
+  var projectedValue: Wrapped { // expected-error{{'projectedValue' property in property wrapper type 'WrapperActorBad2' cannot be isolated to the actor instance; consider 'nonisolated'}}
     get { storage }
     set { storage = newValue }
   }
@@ -358,7 +358,7 @@ struct StructUGA1: UGA {
 }
 
 struct StructUGA2: UGA {
-  @actorIndependent func req() { }
+  nonisolated func req() { }
 }
 
 @GenericGlobalActor<String>
@@ -408,7 +408,7 @@ struct HasWrapperOnUnsafeActor {
     _ = _synced
   }
 
-  @actorIndependent func testErrors() {
+  nonisolated func testErrors() {
     _ = synced // expected-error{{property 'synced' isolated to global actor 'MainActor' can not be referenced from}}
     _ = $synced // expected-error{{property '$synced' isolated to global actor 'SomeGlobalActor' can not be referenced from}}
     _ = _synced // expected-error{{property '_synced' isolated to global actor 'OtherGlobalActor' can not be referenced from}}

test/IDE/complete_decl_attribute.swift

@@ -242,7 +242,6 @@ struct _S {
 // ON_MEMBER_LAST-DAG: Keyword/None:                       objcMembers[#Declaration Attribute#]; name=objcMembers
 // ON_MEMBER_LAST-DAG: Keyword/None:                       NSApplicationMain[#Declaration Attribute#]; name=NSApplicationMain
 // ON_MEMBER_LAST-DAG: Keyword/None:                       rethrows[#Declaration Attribute#]; name=rethrows
-// ON_MEMBER_LAST-DAG: Keyword/None:                       reasync[#Declaration Attribute#]; name=reasync
 // ON_MEMBER_LAST-DAG: Keyword/None:                       warn_unqualified_access[#Declaration Attribute#]; name=warn_unqualified_access
 // ON_MEMBER_LAST-DAG: Keyword/None:                       usableFromInline[#Declaration Attribute#]; name=usableFromInline
 // ON_MEMBER_LAST-DAG: Keyword/None:                       discardableResult[#Declaration Attribute#]; name=discardableResult
@@ -291,7 +290,6 @@ func dummy2() {}
 // KEYWORD_LAST-DAG: Keyword/None:                       inlinable[#Declaration Attribute#]; name=inlinable{{$}}
 // KEYWORD_LAST-DAG: Keyword/None:                       objcMembers[#Declaration Attribute#]; name=objcMembers{{$}}
 // KEYWORD_LAST-DAG: Keyword/None:                       NSApplicationMain[#Declaration Attribute#]; name=NSApplicationMain{{$}}
-// KEYWORD_LAST-DAG: Keyword/None:                       reasync[#Declaration Attribute#]; name=reasync{{$}}
 // KEYWORD_LAST-DAG: Keyword/None:                       rethrows[#Declaration Attribute#]; name=rethrows{{$}}
 // KEYWORD_LAST-DAG: Keyword/None:                       warn_unqualified_access[#Declaration Attribute#]; name=warn_unqualified_access
 // KEYWORD_LAST-DAG: Keyword/None:                       usableFromInline[#Declaration Attribute#]; name=usableFromInline{{$}}

test/decl/class/actor/conformance.swift

@@ -37,11 +37,11 @@ actor OtherActor: SyncProtocol {
 
   var propertyA: Int { 17 }
   // expected-error@-1{{actor-isolated property 'propertyA' cannot be used to satisfy a protocol requirement}}
-  // expected-note@-2{{add '@actorIndependent' to 'propertyA' to make this property independent of the actor}}{{3-3=@actorIndependent }}
+  // expected-note@-2{{add 'nonisolated' to 'propertyA' to make this property not isolated to the actor}}{{3-3=nonisolated }}
 
   func syncMethodA() { }
   // expected-error@-1{{actor-isolated instance method 'syncMethodA()' cannot be used to satisfy a protocol requirement}}
-  // expected-note@-2{{add '@actorIndependent' to 'syncMethodA()' to make this instance method independent of the actor}}{{3-3=@actorIndependent }}
+  // expected-note@-2{{add 'nonisolated' to 'syncMethodA()' to make this instance method not isolated to the actor}}{{3-3=nonisolated }}
   // expected-note@-3{{add '@asyncHandler' to function 'syncMethodA()' to create an implicit asynchronous context}}{{3-3=@asyncHandler }}
 
   // Async handlers are okay.
@@ -54,7 +54,7 @@ actor OtherActor: SyncProtocol {
 
   subscript (index: Int) -> String { "\(index)" }
   // expected-error@-1{{actor-isolated subscript 'subscript(_:)' cannot be used to satisfy a protocol requirement}}
-  // expected-note@-2{{add '@actorIndependent' to 'subscript(_:)' to make this subscript independent of the actor}}{{3-3=@actorIndependent }}
+  // expected-note@-2{{add 'nonisolated' to 'subscript(_:)' to make this subscript not isolated to the actor}}{{3-3=nonisolated }}
 
   // Static methods and properties are okay.
   static func staticMethod() { }