Merge pull request #37163 from DougGregor/spawn-let-5.5

Spawn let syntax

Author: DougGregor

include/swift/AST/Attr.def

@@ -657,6 +657,12 @@ SIMPLE_DECL_ATTR(_inheritActorContext, InheritActorContext,
   ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIBreakingToRemove,
   116)
 
+CONTEXTUAL_SIMPLE_DECL_ATTR(spawn, Spawn,
+  DeclModifier | OnVar | ConcurrencyOnly |
+  ABIBreakingToAdd | ABIBreakingToRemove |
+  APIBreakingToAdd | APIBreakingToRemove,
+  117)
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/Decl.h

@@ -1863,7 +1863,7 @@ class PatternBindingDecl final : public Decl,
   bool isComputingPatternBindingEntry(const VarDecl *vd) const;
 
   /// Is this an "async let" declaration?
-  bool isAsyncLet() const;
+  bool isSpawnLet() const;
 
   /// Gets the text of the initializer expression for the pattern entry at the
   /// given index, stripping out inactive branches of any #ifs inside the
@@ -4943,7 +4943,7 @@ class VarDecl : public AbstractStorageDecl {
   bool isLet() const { return getIntroducer() == Introducer::Let; }
 
   /// Is this an "async let" property?
-  bool isAsyncLet() const;
+  bool isSpawnLet() const;
 
   Introducer getIntroducer() const {
     return Introducer(Bits.VarDecl.Introducer);

include/swift/AST/DiagnosticsSema.def

@@ -4231,8 +4231,8 @@ ERROR(throwing_interpolation_without_try,none,
       "interpolation can throw but is not marked with 'try'", ())
 ERROR(throwing_call_without_try,none,
       "call can throw but is not marked with 'try'", ())
-ERROR(throwing_async_let_without_try,none,
-      "reading 'async let' can throw but is not marked with 'try'", ())
+ERROR(throwing_spawn_let_without_try,none,
+      "reading 'spawn let' can throw but is not marked with 'try'", ())
 ERROR(throwing_prop_access_without_try,none,
       "property access can throw but is not marked with 'try'", ())
 ERROR(throwing_subscript_access_without_try,none,
@@ -4261,8 +4261,8 @@ NOTE(async_access_without_await,none,
 
 NOTE(async_call_without_await_in_autoclosure,none,
       "call is 'async' in an autoclosure argument", ())
-NOTE(async_call_without_await_in_async_let,none,
-      "call is 'async' in an 'async let' initializer", ())
+NOTE(async_call_without_await_in_spawn_let,none,
+      "call is 'async' in an 'spawn let' initializer", ())
 
 WARNING(no_async_in_await,none,
         "no 'async' operations occur within 'await' expression", ())
@@ -4275,7 +4275,7 @@ ERROR(await_in_illegal_context,none,
       "%select{<<ERROR>>|a default argument|a property wrapper initializer|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}0",
       (unsigned))
 ERROR(async_in_nonasync_function,none,
-      "%select{'async'|'async' call|'await'|'async let'|'async' property access|'async' subscript access}0 in "
+      "%select{'async'|'async' call|'await'|'spawn let'|'async' property access|'async' subscript access}0 in "
       "%select{a function|an autoclosure}1 that does not support concurrency",
       (unsigned, bool))
 NOTE(note_add_async_to_function,none,
@@ -4302,18 +4302,21 @@ NOTE(protocol_witness_async_conflict,none,
 ERROR(async_autoclosure_nonasync_function,none,
       "'async' autoclosure parameter in a non-'async' function", ())
 
-ERROR(async_not_let,none,
-      "'async' can only be used with 'let' declarations", ())
-ERROR(async_let_not_local,none,
-      "'async let' can only be used on local declarations", ())
-ERROR(async_let_not_initialized,none,
-      "'async let' binding requires an initializer expression", ())
-ERROR(async_let_no_variables,none,
-      "'async let' requires at least one named variable", ())
-NOTE(async_let_without_await,none,
-      "reference to async let %0 is 'async'", (DeclName))
-ERROR(async_let_in_illegal_context,none,
-      "async let %0 cannot be referenced in "
+WARNING(async_let_is_spawn_let,none,
+      "'async let' is now 'spawn let'", ())
+
+ERROR(spawn_not_let,none,
+      "'spawn' can only be used with 'let' declarations", ())
+ERROR(spawn_let_not_local,none,
+      "'spawn let' can only be used on local declarations", ())
+ERROR(spawn_let_not_initialized,none,
+      "'spawn let' binding requires an initializer expression", ())
+ERROR(spawn_let_no_variables,none,
+      "'spawn let' requires at least one named variable", ())
+NOTE(spawn_let_without_await,none,
+      "reference to spawn let %0 is 'async'", (DeclName))
+ERROR(spawn_let_in_illegal_context,none,
+      "spawn let %0 cannot be referenced in "
       "%select{<<ERROR>>|a default argument|a property wrapper initializer|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}1",
       (DeclName, unsigned))
 
@@ -4403,8 +4406,8 @@ ERROR(actor_isolated_from_concurrent_closure,none,
 ERROR(actor_isolated_from_concurrent_function,none,
         "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from a concurrent function",
         (DescriptiveDeclKind, DeclName, unsigned))
-ERROR(actor_isolated_from_async_let,none,
-        "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from 'async let' initializer",
+ERROR(actor_isolated_from_spawn_let,none,
+        "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from 'spawn let' initializer",
         (DescriptiveDeclKind, DeclName, unsigned))
 ERROR(actor_isolated_keypath_component,none,
       "cannot form key path to actor-isolated %0 %1",

include/swift/Sema/ConstraintSystem.h

@@ -4433,7 +4433,7 @@ class ConstraintSystem {
   /// Given expression represents computed result of the closure.
   Expr *buildAutoClosureExpr(Expr *expr, FunctionType *closureType,
                              bool isDefaultWrappedValue = false,
-                             bool isAsyncLetWrapper = false);
+                             bool isSpawnLetWrapper = false);
 
   /// Builds a type-erased return expression that can be used in dynamic
   /// replacement.

lib/AST/Decl.cpp

@@ -1567,9 +1567,9 @@ StaticSpellingKind PatternBindingDecl::getCorrectStaticSpelling() const {
   return getCorrectStaticSpellingForDecl(this);
 }
 
-bool PatternBindingDecl::isAsyncLet() const {
+bool PatternBindingDecl::isSpawnLet() const {
   if (auto var = getAnchoringVarDecl(0))
-    return var->isAsyncLet();
+    return var->isSpawnLet();
 
   return false;
 }
@@ -5862,8 +5862,8 @@ bool VarDecl::isMemberwiseInitialized(bool preferDeclaredProperties) const {
   return true;
 }
 
-bool VarDecl::isAsyncLet() const {
-  return getAttrs().hasAttribute<AsyncAttr>();
+bool VarDecl::isSpawnLet() const {
+  return getAttrs().hasAttribute<AsyncAttr>() || getAttrs().hasAttribute<SpawnAttr>();
 }
 
 void ParamDecl::setSpecifier(Specifier specifier) {

lib/SILGen/SILGenDecl.cpp

@@ -440,7 +440,7 @@ class LetValueInitialization : public Initialization {
       // buffer.  DI will make sure it is only assigned to once.
       needsTemporaryBuffer = true;
       isUninitialized = true;
-    } else if (vd->isAsyncLet()) {
+    } else if (vd->isSpawnLet()) {
       // If this is an async let, treat it like a let-value without an
       // initializer. The initializer runs concurrently in a child task,
       // and value will be initialized at the point the variable in the
@@ -1146,7 +1146,7 @@ void SILGenFunction::emitPatternBinding(PatternBindingDecl *PBD,
 
   // If this is an async let, create a child task to compute the initializer
   // value.
-  if (PBD->isAsyncLet()) {
+  if (PBD->isSpawnLet()) {
     // Look through the implicit await (if present), try (if present), and
     // call to reach the autoclosure that computes the value.
     auto *init = PBD->getExecutableInit(idx);

lib/SILGen/SILGenLValue.cpp

@@ -2816,7 +2816,7 @@ SILGenFunction::maybeEmitValueOfLocalVarDecl(
   if (It != VarLocs.end()) {
     // If the variable is part of an async let, ensure that the child task
     // has completed first.
-    if (var->isAsyncLet() && accessKind != AccessKind::Write) {
+    if (var->isSpawnLet() && accessKind != AccessKind::Write) {
       auto patternBinding = var->getParentPatternBinding();
       unsigned index = patternBinding->getPatternEntryIndexForVarDecl(var);
       completeAsyncLetChildTask(patternBinding, index);

lib/Sema/CSApply.cpp

@@ -8297,7 +8297,7 @@ static Expr *wrapAsyncLetInitializer(
   ASTContext &ctx = dc->getASTContext();
   Expr *autoclosureExpr = cs.buildAutoClosureExpr(
       initializer, closureType, /*isDefaultWrappedValue=*/false,
-      /*isAsyncLetWrapper=*/true);
+      /*isSpawnLetWrapper=*/true);
 
   // Call the autoclosure so that the AST types line up. SILGen will ignore the
   // actual calls and translate them into a different mechanism.
@@ -8398,7 +8398,7 @@ static Optional<SolutionApplicationTarget> applySolutionToInitialization(
   // For an async let, wrap the initializer appropriately to make it a child
   // task.
   if (auto patternBinding = target.getInitializationPatternBindingDecl()) {
-    if (patternBinding->isAsyncLet()) {
+    if (patternBinding->isSpawnLet()) {
       resultTarget.setExpr(
           wrapAsyncLetInitializer(
             cs, resultTarget.getAsExpr(), resultTarget.getDeclContext()));

lib/Sema/ConstraintSystem.cpp

@@ -2517,7 +2517,7 @@ FunctionType::ExtInfo ConstraintSystem::closureEffects(ClosureExpr *expr) {
     bool walkToDeclPre(Decl *decl) override {
       // Do not walk into function or type declarations.
       if (auto *patternBinding = dyn_cast<PatternBindingDecl>(decl)) {
-        if (patternBinding->isAsyncLet())
+        if (patternBinding->isSpawnLet())
           FoundAsync = true;
 
         return true;
@@ -4987,7 +4987,7 @@ ConstraintSystem::isConversionEphemeral(ConversionRestrictionKind conversion,
 Expr *ConstraintSystem::buildAutoClosureExpr(Expr *expr,
                                              FunctionType *closureType,
                                              bool isDefaultWrappedValue,
-                                             bool isAsyncLetWrapper) {
+                                             bool isSpawnLetWrapper) {
   auto &Context = DC->getASTContext();
   bool isInDefaultArgumentContext = false;
   if (auto *init = dyn_cast<Initializer>(DC)) {
@@ -5009,7 +5009,7 @@ Expr *ConstraintSystem::buildAutoClosureExpr(Expr *expr,
 
   closure->setParameterList(ParameterList::createEmpty(Context));
 
-  if (isAsyncLetWrapper)
+  if (isSpawnLetWrapper)
     closure->setThunkKind(AutoClosureExpr::Kind::AsyncLet);
 
   Expr *result = closure;

lib/Sema/TypeCheckAttr.cpp

@@ -284,6 +284,8 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   void visitActorIndependentAttr(ActorIndependentAttr *attr);
   void visitGlobalActorAttr(GlobalActorAttr *attr);
   void visitAsyncAttr(AsyncAttr *attr);
+  void visitSpawnAttr(SpawnAttr *attr);
+  void visitAsyncOrSpawnAttr(DeclAttribute *attr);
   void visitMarkerAttr(MarkerAttr *attr);
 
   void visitReasyncAttr(ReasyncAttr *attr);
@@ -5503,6 +5505,20 @@ void AttributeChecker::visitGlobalActorAttr(GlobalActorAttr *attr) {
 }
 
 void AttributeChecker::visitAsyncAttr(AsyncAttr *attr) {
+  if (isa<VarDecl>(D)) {
+    D->getASTContext().Diags.diagnose(
+        attr->getLocation(), diag::async_let_is_spawn_let)
+      .fixItReplace(attr->getRange(), "spawn");
+
+    visitAsyncOrSpawnAttr(attr);
+  }
+}
+
+void AttributeChecker::visitSpawnAttr(SpawnAttr *attr) {
+  visitAsyncOrSpawnAttr(attr);
+}
+
+void AttributeChecker::visitAsyncOrSpawnAttr(DeclAttribute *attr) {
   auto var = dyn_cast<VarDecl>(D);
   if (!var)
     return;
@@ -5513,7 +5529,7 @@ void AttributeChecker::visitAsyncAttr(AsyncAttr *attr) {
 
   // "Async" modifier can only be applied to local declarations.
   if (!patternBinding->getDeclContext()->isLocalContext()) {
-    diagnoseAndRemoveAttr(attr, diag::async_let_not_local);
+    diagnoseAndRemoveAttr(attr, diag::spawn_let_not_local);
     return;
   }
 
@@ -5534,21 +5550,21 @@ void AttributeChecker::visitAsyncAttr(AsyncAttr *attr) {
     // Each entry must bind at least one named variable, so that there is
     // something to "await".
     if (!foundAnyVariable) {
-      diagnose(pattern->getLoc(), diag::async_let_no_variables);
+      diagnose(pattern->getLoc(), diag::spawn_let_no_variables);
       attr->setInvalid();
       return;
     }
 
     // Async can only be used on an "async let".
     if (!isLet && !diagnosedVar) {
-      diagnose(patternBinding->getLoc(), diag::async_not_let)
+      diagnose(patternBinding->getLoc(), diag::spawn_not_let)
         .fixItReplace(patternBinding->getLoc(), "let");
       diagnosedVar = true;
     }
 
     // Each pattern entry must have an initializer expression.
     if (patternBinding->getEqualLoc(index).isInvalid()) {
-      diagnose(pattern->getLoc(), diag::async_let_not_initialized);
+      diagnose(pattern->getLoc(), diag::spawn_let_not_initialized);
       attr->setInvalid();
       return;
     }

lib/Sema/TypeCheckConcurrency.cpp

@@ -1879,6 +1879,10 @@ namespace {
       // Check whether this is a local variable, in which case we can
       // determine whether it was safe to access concurrently.
       if (auto var = dyn_cast<VarDecl>(value)) {
+        // Ignore interpolation variables.
+        if (var->getBaseName() == ctx.Id_dollarInterpolation)
+          return false;
+
         auto parent = mutableLocalVarParent[declRefExpr];
 
         // If the variable is immutable, it's fine so long as it involves
@@ -2034,7 +2038,7 @@ namespace {
       if (auto autoclosure = dyn_cast<AutoClosureExpr>(dc)) {
         switch (autoclosure->getThunkKind()) {
         case AutoClosureExpr::Kind::AsyncLet:
-          return diag::actor_isolated_from_async_let;
+          return diag::actor_isolated_from_spawn_let;
 
         case AutoClosureExpr::Kind::DoubleCurryThunk:
         case AutoClosureExpr::Kind::SingleCurryThunk:

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1537,6 +1537,7 @@ namespace  {
     UNINTERESTING_ATTR(ActorIndependent)
     UNINTERESTING_ATTR(GlobalActor)
     UNINTERESTING_ATTR(Async)
+    UNINTERESTING_ATTR(Spawn)
     UNINTERESTING_ATTR(Sendable)
 
     UNINTERESTING_ATTR(AtRethrows)

lib/Sema/TypeCheckEffects.cpp

@@ -418,7 +418,7 @@ class EffectsHandlingWalker : public ASTWalker {
     if (auto ic = dyn_cast<IfConfigDecl>(D)) {
       recurse = asImpl().checkIfConfig(ic);
     } else if (auto patternBinding = dyn_cast<PatternBindingDecl>(D)) {
-      if (patternBinding->isAsyncLet())
+      if (patternBinding->isSpawnLet())
         recurse = asImpl().checkAsyncLet(patternBinding);
     } else {
       recurse = ShouldNotRecurse;
@@ -1689,7 +1689,7 @@ class Context {
     bool suggestTryFixIt = reasonKind == PotentialEffectReason::Kind::Apply;
 
     if (reasonKind == PotentialEffectReason::Kind::AsyncLet) {
-      message = diag::throwing_async_let_without_try;
+      message = diag::throwing_spawn_let_without_try;
 
     } else if (reasonKind == PotentialEffectReason::Kind::PropertyAccess) {
       message = diag::throwing_prop_access_without_try;
@@ -1922,20 +1922,20 @@ class Context {
 
       if (auto declRef = dyn_cast<DeclRefExpr>(e)) {
         if (auto var = dyn_cast<VarDecl>(declRef->getDecl())) {
-          if (var->isAsyncLet()) {
+          if (var->isSpawnLet()) {
             Diags.diagnose(
-                e->getLoc(), diag::async_let_in_illegal_context,
+                e->getLoc(), diag::spawn_let_in_illegal_context,
                 var->getName(), static_cast<unsigned>(getKind()));
             return;
           }
         }
       }
     } else if (auto patternBinding = dyn_cast_or_null<PatternBindingDecl>(
                    node.dyn_cast<Decl *>())) {
-      if (patternBinding->isAsyncLet()) {
+      if (patternBinding->isSpawnLet()) {
         auto var = patternBinding->getAnchoringVarDecl(0);
         Diags.diagnose(
-            e->getLoc(), diag::async_let_in_illegal_context,
+            e->getLoc(), diag::spawn_let_in_illegal_context,
             var->getName(), static_cast<unsigned>(getKind()));
         return;
       }
@@ -2529,7 +2529,7 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
         // "Async let" declarations are treated as an asynchronous call
         // (to the underlying task's "get"). If the initializer was throwing,
         // then the access is also treated as throwing.
-        if (var->isAsyncLet()) {
+        if (var->isSpawnLet()) {
           // If the initializer could throw, we will have a 'try' in the
           // application of its autoclosure.
           bool throws = false;
@@ -2830,9 +2830,9 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
         case PotentialEffectReason::Kind::AsyncLet:
           if (auto declR = dyn_cast<DeclRefExpr>(&diag.expr)) {
             if (auto var = dyn_cast<VarDecl>(declR->getDecl())) {
-              if (var->isAsyncLet()) {
+              if (var->isSpawnLet()) {
                 Ctx.Diags.diagnose(declR->getLoc(),
-                                   diag::async_let_without_await,
+                                   diag::spawn_let_without_await,
                                    var->getName());
                 continue;
               }
@@ -2861,7 +2861,7 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
                break;
              case AutoClosureExpr::Kind::AsyncLet:
                Ctx.Diags.diagnose(diag.expr.getStartLoc(),
-                                  diag::async_call_without_await_in_async_let);
+                                  diag::async_call_without_await_in_spawn_let);
                break;
              case AutoClosureExpr::Kind::SingleCurryThunk:
              case AutoClosureExpr::Kind::DoubleCurryThunk:

test/Concurrency/await_typo_correction.swift

@@ -21,8 +21,9 @@ func async() throws { }
     // expected-error@+1 {{found 'async' in expression; did you mean 'await'?}}{{13-18=await}}
     let _ = async anotherAsyncFunc()
 
-    // Don't emit a diagnostic here
+    // Don't emit a diagnostic here related to 'await'
     async let foo = anotherAsyncFunc()
+    // expected-warning@-1{{'async let' is now 'spawn let'}}{{5-10=spawn}}
     let _ = await foo
 
     // I question the name choice, but it's valid