Revert "[Concurrency] Resyntax 'async let' as 'spawn let'."

This reverts commit 41f42fa.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4246,8 +4246,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_spawn_let_without_try,none,
-      "reading 'spawn let' 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_prop_access_without_try,none,
       "property access can throw but is not marked with 'try'", ())
 ERROR(throwing_subscript_access_without_try,none,
@@ -4276,8 +4276,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_spawn_let,none,
-      "call is 'async' in an 'spawn let' initializer", ())
+NOTE(async_call_without_await_in_async_let,none,
+      "call is 'async' in an 'async let' initializer", ())
 
 WARNING(no_async_in_await,none,
         "no 'async' operations occur within 'await' expression", ())
@@ -4290,7 +4290,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'|'spawn let'|'async' property access|'async' subscript access}0 in "
+      "%select{'async'|'async' call|'await'|'async 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,
@@ -4428,8 +4428,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_spawn_let,none,
-        "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from 'spawn let' initializer",
+ERROR(actor_isolated_from_async_let,none,
+        "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from 'async let' initializer",
         (DescriptiveDeclKind, DeclName, unsigned))
 ERROR(actor_isolated_keypath_component,none,
       "cannot form key path to actor-isolated %0 %1",

lib/Sema/TypeCheckConcurrency.cpp

@@ -2044,7 +2044,7 @@ namespace {
       if (auto autoclosure = dyn_cast<AutoClosureExpr>(dc)) {
         switch (autoclosure->getThunkKind()) {
         case AutoClosureExpr::Kind::AsyncLet:
-          return diag::actor_isolated_from_spawn_let;
+          return diag::actor_isolated_from_async_let;
 
         case AutoClosureExpr::Kind::DoubleCurryThunk:
         case AutoClosureExpr::Kind::SingleCurryThunk:

lib/Sema/TypeCheckEffects.cpp

@@ -1689,7 +1689,7 @@ class Context {
     bool suggestTryFixIt = reasonKind == PotentialEffectReason::Kind::Apply;
 
     if (reasonKind == PotentialEffectReason::Kind::AsyncLet) {
-      message = diag::throwing_spawn_let_without_try;
+      message = diag::throwing_async_let_without_try;
 
     } else if (reasonKind == PotentialEffectReason::Kind::PropertyAccess) {
       message = diag::throwing_prop_access_without_try;
@@ -1924,7 +1924,7 @@ class Context {
         if (auto var = dyn_cast<VarDecl>(declRef->getDecl())) {
           if (var->isSpawnLet()) {
             Diags.diagnose(
-                e->getLoc(), diag::spawn_let_in_illegal_context,
+                e->getLoc(), diag::async_let_in_illegal_context,
                 var->getName(), static_cast<unsigned>(getKind()));
             return;
           }
@@ -1935,7 +1935,7 @@ class Context {
       if (patternBinding->isSpawnLet()) {
         auto var = patternBinding->getAnchoringVarDecl(0);
         Diags.diagnose(
-            e->getLoc(), diag::spawn_let_in_illegal_context,
+            e->getLoc(), diag::async_let_in_illegal_context,
             var->getName(), static_cast<unsigned>(getKind()));
         return;
       }
@@ -2833,7 +2833,7 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
             if (auto var = dyn_cast<VarDecl>(declR->getDecl())) {
               if (var->isSpawnLet()) {
                 Ctx.Diags.diagnose(declR->getLoc(),
-                                   diag::spawn_let_without_await,
+                                   diag::async_let_without_await,
                                    var->getName());
                 continue;
               }
@@ -2862,7 +2862,7 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
                break;
              case AutoClosureExpr::Kind::AsyncLet:
                Ctx.Diags.diagnose(diag.expr.getStartLoc(),
-                                  diag::async_call_without_await_in_spawn_let);
+                                  diag::async_call_without_await_in_async_let);
                break;
              case AutoClosureExpr::Kind::SingleCurryThunk:
              case AutoClosureExpr::Kind::DoubleCurryThunk:

…st/Concurrency/spawn_let_isolation.swift …st/Concurrency/async_let_isolation.swifttest/Concurrency/spawn_let_isolation.swift renamed to test/Concurrency/async_let_isolation.swift test/Concurrency/spawn_let_isolation.swift renamed to test/Concurrency/async_let_isolation.swift

@@ -9,14 +9,14 @@ actor MyActor {
   func asynchronous() async -> String { synchronous() }
 
   func testAsyncLetIsolation() async {
-    spawn let x = self.synchronous()
+    async let x = self.synchronous()
 
-    spawn let y = await self.asynchronous()
+    async let y = await self.asynchronous()
 
-    spawn let z = synchronous()
+    async let z = synchronous()
 
     var localText = text
-    spawn let w = localText.removeLast() // expected-error{{mutation of captured var 'localText' in concurrently-executing code}}
+    async let w = localText.removeLast() // expected-error{{mutation of captured var 'localText' in concurrently-executing code}}
 
     _ = await x
     _ = await y
@@ -27,8 +27,8 @@ actor MyActor {
 
 func outside() async {
   let a = MyActor()
-  spawn let x = a.synchronous() // okay, await is implicit
-  spawn let y = await a.synchronous()
+  async let x = a.synchronous() // okay, await is implicit
+  async let y = await a.synchronous()
   _ = await x
   _ = await y
 }

test/Concurrency/await_typo_correction.swift

@@ -21,9 +21,8 @@ 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 related to 'await'
+    // Don't emit a diagnostic here
     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

test/Concurrency/reasync.swift

@@ -149,11 +149,11 @@ func callReasyncWithAutoclosure3() {
   reasyncWithAutoclosure2("Hello \(world)")
 }
 
-//// spawn let
+//// async let
 
 func callReasyncWithAutoclosure4(_: () async -> ()) reasync {
   await reasyncFunction {
-    spawn let x = 123
+    async let x = 123
 
     _ = await x
   }

test/Parse/async.swift

@@ -75,7 +75,7 @@ func testAwaitExpr() async {
 func getIntSomeday() async -> Int { 5 }
 
 func testAsyncLet() async {
-  spawn let x = await getIntSomeday()
+  async let x = await getIntSomeday()
   _ = await x
 }
 

test/decl/var/spawn_let.swift test/decl/var/async_let.swifttest/decl/var/spawn_let.swift renamed to test/decl/var/async_let.swift

@@ -3,23 +3,23 @@
 // REQUIRES: concurrency
 
 func test() async {
-  spawn let x = 1 // okay
+  async let x = 1 // okay
   _ = await x
 }
 
 struct X {
-  spawn let x = 1 // expected-error{{'spawn let' can only be used on local declarations}}
+  async let x = 1 // expected-error{{'async let' can only be used on local declarations}}
   // FIXME: expected-error@-1{{'async' call cannot occur in a property initializer}}
 }
 
 func testAsyncFunc() async {
-  spawn let (z1, z2) = (2, 3)
-  spawn let (_, _) = (2, 3)
-  spawn let x2 = 1
+  async let (z1, z2) = (2, 3)
+  async let (_, _) = (2, 3)
+  async let x2 = 1
 
-  spawn var x = 17 // expected-error{{'spawn' can only be used with 'let' declarations}}{{9-12=let}}
-  spawn let (_, _) = (1, 2), y2 = 7 // expected-error{{'spawn let' requires at least one named variable}}
-  spawn let y: Int // expected-error{{'spawn let' binding requires an initializer expression}}
+  async var x = 17 // expected-error{{'async' can only be used with 'let' declarations}}{{9-12=let}}
+  async let (_, _) = (1, 2), y2 = 7 // expected-error{{'async let' requires at least one named variable}}
+  async let y: Int // expected-error{{'async let' binding requires an initializer expression}}
   _ = await x
   _ = y
   _ = await z1
@@ -34,7 +34,7 @@ func chopVegetables() async throws -> [String] { [] }
 func marinateMeat() async -> String { "MEAT" }
 
 func cook() async throws {
-  spawn let veggies = try await chopVegetables(), meat = await marinateMeat()
+  async let veggies = try await chopVegetables(), meat = await marinateMeat()
   _ = try await veggies
   _ = await meat
 }

test/expr/unary/async_await.swift

@@ -158,7 +158,7 @@ func validAsyncFunction() async throws {
   _ = try await throwingAndAsync()
 }
 
-// spawn let checking
+// Async let checking
 func mightThrow() throws { }
 
 func getIntUnsafely() throws -> Int { 0 }
@@ -169,27 +169,27 @@ extension Error {
 }
 
 func testAsyncLet() async throws {
-  spawn let x = await getInt()
+  async let x = await getInt()
   print(x) // expected-error{{expression is 'async' but is not marked with 'await'}}
-  // expected-note@-1:9{{reference to spawn let 'x' is 'async'}}
+  // expected-note@-1:9{{reference to async let 'x' is 'async'}}
 
   print(await x)
 
   do {
     try mightThrow()
-  } catch let e where e.number == x { // expected-error{{spawn let 'x' cannot be referenced in a catch guard expression}}
+  } catch let e where e.number == x { // expected-error{{async let 'x' cannot be referenced in a catch guard expression}}
   } catch {
   }
 
-  spawn let x1 = getIntUnsafely() // okay, try is implicit here
+  async let x1 = getIntUnsafely() // okay, try is implicit here
 
-  spawn let x2 = getInt() // okay, await is implicit here
+  async let x2 = getInt() // okay, await is implicit here
 
-  spawn let x3 = try getIntUnsafely()
-  spawn let x4 = try! getIntUnsafely()
-  spawn let x5 = try? getIntUnsafely()
+  async let x3 = try getIntUnsafely()
+  async let x4 = try! getIntUnsafely()
+  async let x5 = try? getIntUnsafely()
 
-  _ = await x1 // expected-error{{reading 'spawn let' can throw but is not marked with 'try'}}
+  _ = await x1 // expected-error{{reading 'async let' can throw but is not marked with 'try'}}
   _ = await x2
   _ = try await x3
   _ = await x4
@@ -198,9 +198,9 @@ func testAsyncLet() async throws {
 
 // expected-note@+1 4{{add 'async' to function 'testAsyncLetOutOfAsync()' to make it asynchronous}} {{30-30= async}}
 func testAsyncLetOutOfAsync() {
-  spawn let x = 1 // expected-error{{'spawn let' in a function that does not support concurrency}}
+  async let x = 1 // expected-error{{'async let' in a function that does not support concurrency}}
   // FIXME: expected-error@-1{{'async' call in a function that does not support concurrency}}
 
-  _ = await x  // expected-error{{'spawn let' in a function that does not support concurrency}}
-  _ = x // expected-error{{'spawn let' in a function that does not support concurrency}}
+  _ = await x  // expected-error{{'async let' in a function that does not support concurrency}}
+  _ = x // expected-error{{'async let' in a function that does not support concurrency}}
 }

test/stmt/async.swift

@@ -6,5 +6,5 @@ func f() async -> Int { 0 }
 
 _ = await f() // expected-error{{'async' call in a function that does not support concurrency}}
 
-spawn let y = await f() // expected-error{{'spawn let' in a function that does not support concurrency}}
+async let y = await f() // expected-error{{'async let' in a function that does not support concurrency}}
 // expected-error@-1{{'async' call in a function that does not support concurrency}}