[Concurrency] Make 'await' and 'try' implicit in async let initializer

Author: DougGregor

lib/Sema/TypeCheckEffects.cpp

@@ -1535,12 +1535,17 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
       Self.Flags.set(ContextFlags::IsTryCovered);
       Self.Flags.clear(ContextFlags::HasTryThrowSite);
     }
-    
+
     void enterAwait() {
       Self.Flags.set(ContextFlags::IsAsyncCovered);
       Self.Flags.clear(ContextFlags::HasAnyAsyncSite);
     }
 
+    void enterAsyncLet() {
+      Self.Flags.set(ContextFlags::IsTryCovered);
+      Self.Flags.set(ContextFlags::IsAsyncCovered);
+    }
+
     void refineLocalContext(Context newContext) {
       Self.CurContext = newContext;
     }
@@ -1605,7 +1610,7 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
       OldFlags.mergeFrom(ContextFlags::HasAnyAwait, Self.Flags);
       OldMaxThrowingKind = std::max(OldMaxThrowingKind, Self.MaxThrowingKind);
     }
-    
+
     bool wasTopLevelDebuggerFunction() const {
       return OldFlags.has(ContextFlags::IsTopLevelDebuggerFunction);
     }
@@ -1681,6 +1686,7 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
 
     case AutoClosureExpr::Kind::AsyncLet:
       scope.resetCoverage();
+      scope.enterAsyncLet();
       shouldPreserveCoverage = false;
       break;
     }
@@ -1820,10 +1826,11 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
   }
 
   ShouldRecurse_t checkAsyncLet(PatternBindingDecl *patternBinding) {
-      // Diagnose async calls in a context that doesn't handle async.
-      if (!CurContext.handlesAsync()) {
-        CurContext.diagnoseUnhandledAsyncSite(Ctx.Diags, patternBinding);
-      }
+    // Diagnose async let in a context that doesn't handle async.
+    if (!CurContext.handlesAsync()) {
+      CurContext.diagnoseUnhandledAsyncSite(Ctx.Diags, patternBinding);
+    }
+
     return ShouldRecurse;
   }
 

test/Concurrency/async_let_isolation.swift

@@ -30,7 +30,7 @@ actor class MyActor {
 
 func outside() async {
   let a = MyActor()
-  async let x = a.synchronous() // expected-error {{call is 'async' in an 'async let' initializer that is not marked with 'await'}}
+  async let x = a.synchronous() // okay, await is implicit
   async let y = await a.synchronous()
   _ = await x
   _ = await y

test/expr/unary/async_await.swift

@@ -165,12 +165,9 @@ func testAsyncLet() async throws {
   } catch {
   }
 
-  async let x1 = getIntUnsafely() // expected-error{{call can throw but is not marked with 'try'}}
-  // expected-note@-1{{did you mean to use 'try'}}
-  // expected-note@-2{{did you mean to handle error as optional value?}}
-  // expected-note@-3{{did you mean to disable error propagation?}}
+  async let x1 = getIntUnsafely() // okay, try is implicit here
 
-  async let x2 = getInt() // expected-error{{call is 'async' in an 'async let' initializer that is not marked with 'await'}}
+  async let x2 = getInt() // okay, await is implicit here
 
   async let x3 = try getIntUnsafely()
   async let x4 = try! getIntUnsafely()