[Concurrency] Introduce spawn let

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

@@ -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))
 

include/swift/Sema/ConstraintSystem.h

@@ -4430,7 +4430,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;
 }
@@ -5861,8 +5861,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
@@ -1144,7 +1144,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

@@ -8283,7 +8283,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.
@@ -8384,7 +8384,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

@@ -2508,7 +2508,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;
@@ -4972,7 +4972,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)) {
@@ -4994,7 +4994,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);
@@ -5500,6 +5502,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;
@@ -5510,7 +5526,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;
   }
 
@@ -5531,21 +5547,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;
     }