[Concurrency] Wrap the initializer of 'async let' in an autoclosure call.

The initializer of an 'async let' is executed as a separate child task
that will run concurrently with the main body of the function. Model
the semantics of this operation by wrapping the initializer in an
async, escaping autoclosure (representing the evaluation of the child
task), and then a call to that autoclosure (to

This is useful both for actor isolation checking, which needs to treat
the initializer as executing in concurrent code, and also (eventually)
for code generation, which needs to have that code in a closure so
that it can be passed off to the task-creation functions.

There are a number of issues with this implementation producing
extraneous diagnostics due to this closure transformation, which will
be addressed in a follow-up commit.

Author: DougGregor

lib/Sema/CSApply.cpp

@@ -7881,6 +7881,49 @@ bool ConstraintSystem::applySolutionFixes(const Solution &solution) {
   return diagnosedAnyErrors;
 }
 
+/// For the initializer of an `async let`, wrap it in an autoclosure and then
+/// a call to that autoclosure, so that the code for the child task is captured
+/// entirely within the autoclosure. This captures the semantics of the
+/// operation but not the timing, e.g., the call itself will actually occur
+/// when one of the variables in the async let is referenced.
+static Expr *wrapAsyncLetInitializer(
+      ConstraintSystem &cs, Expr *initializer, DeclContext *dc) {
+  // Form the autoclosure type. It is always 'async', and will be 'throws'.
+  Type initializerType = initializer->getType();
+  bool throws = TypeChecker::canThrow(initializer);
+  auto extInfo = ASTExtInfoBuilder()
+    .withAsync()
+    .withThrows(throws)
+    .build();
+
+  // Form the autoclosure expression. The actual closure here encapsulates the
+  // child task.
+  auto closureType = FunctionType::get({ }, initializerType, extInfo);
+  ASTContext &ctx = dc->getASTContext();
+  Expr *autoclosureExpr = cs.buildAutoClosureExpr(initializer, closureType);
+
+  // Call the autoclosure so that the AST types line up. SILGen will ignore the
+  // actual calls and translate them into a different mechanism.
+  auto autoclosureCall = CallExpr::createImplicit(
+      ctx, autoclosureExpr, { }, { });
+  autoclosureCall->setType(initializerType);
+  autoclosureCall->setThrows(throws);
+
+  // For a throwing expression, wrap the call in a 'try'.
+  Expr *resultInit = autoclosureCall;
+  if (throws) {
+    resultInit = new (ctx) TryExpr(
+        SourceLoc(), resultInit, initializerType, /*implicit=*/true);
+  }
+
+  // Wrap the call in an 'await'.
+  resultInit = new (ctx) AwaitExpr(
+      SourceLoc(), resultInit, initializerType, /*implicit=*/true);
+
+  cs.cacheExprTypes(resultInit);
+  return resultInit;
+}
+
 /// Apply the given solution to the initialization target.
 ///
 /// \returns the resulting initialization expression.
@@ -7955,6 +7998,16 @@ static Optional<SolutionApplicationTarget> applySolutionToInitialization(
     return None;
   }
 
+  // For an async let, wrap the initializer appropriately to make it a child
+  // task.
+  if (auto patternBinding = target.getInitializationPatternBindingDecl()) {
+    if (patternBinding->isAsyncLet()) {
+      resultTarget.setExpr(
+          wrapAsyncLetInitializer(
+            cs, resultTarget.getAsExpr(), resultTarget.getDeclContext()));
+    }
+  }
+
   return resultTarget;
 }
 

lib/Sema/TypeCheckEffects.cpp

@@ -533,6 +533,13 @@ class ApplyClassifier {
     return result;
   }
 
+  /// Classify a single expression without considering its enclosing context.
+  ThrowingKind classifyExpr(Expr *expr) {
+    FunctionBodyClassifier classifier(*this);
+    expr->walk(classifier);
+    return classifier.Result;
+  }
+
 private:
   /// Classify a throwing function according to our local knowledge of
   /// its implementation.
@@ -2015,3 +2022,7 @@ void TypeChecker::checkPropertyWrapperEffects(
   CheckEffectsCoverage checker(ctx, Context::forPatternBinding(binding));
   expr->walk(checker);
 }
+
+bool TypeChecker::canThrow(Expr *expr) {
+  return ApplyClassifier().classifyExpr(expr) == ThrowingKind::Throws;
+}

lib/Sema/TypeChecker.h

@@ -1062,6 +1062,9 @@ void checkInitializerEffects(Initializer *I, Expr *E);
 void checkEnumElementEffects(EnumElementDecl *D, Expr *expr);
 void checkPropertyWrapperEffects(PatternBindingDecl *binding, Expr *expr);
 
+/// Whether the given expression can throw.
+bool canThrow(Expr *expr);
+
 /// If an expression references 'self.init' or 'super.init' in an
 /// initializer context, returns the implicit 'self' decl of the constructor.
 /// Otherwise, return nil.

test/Concurrency/async_let_isolation.swift

@@ -0,0 +1,31 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-concurrency
+// REQUIRES: concurrency
+
+actor class MyActor {
+  let immutable: Int = 17
+  var text: [String] = []
+
+  func synchronous() -> String { text.first ?? "nothing" } // expected-note 2 {{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+  func asynchronous() async -> String { synchronous() }
+
+  func testAsyncLetIsolation() async {
+    async let x = self.synchronous()
+    // expected-error @-1{{actor-isolated instance method 'synchronous()' is unsafe to reference in code that may execute concurrently}}
+
+    async let y = await self.asynchronous()
+
+    async let z = synchronous()
+    // expected-error @-1{{actor-isolated instance method 'synchronous()' is unsafe to reference in code that may execute concurrently}}
+    // FIXME: expected-error @-2{{call to method 'synchronous' in closure requires explicit use of 'self' to make capture semantics explicit}}
+    // FIXME: expected-note @-3{{reference 'self.' explicitly}}
+
+    var localText = text // expected-note{{var declared here}}
+    async let w = localText.removeLast()
+    // expected-warning@-1{{local var 'localText' is unsafe to reference in code that may execute concurrently}}
+
+    _ = await x
+    _ = await y
+    _ = await z
+    _ = await w
+  }
+}

test/decl/var/async_let.swift

@@ -6,6 +6,7 @@ async let x = 1 // okay
 
 struct X {
   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 {

test/expr/unary/async_await.swift

@@ -164,10 +164,11 @@ func testAsyncLet() async throws {
   }
 }
 
-// expected-note@+2 3{{add 'async' to function 'testAsyncLetOutOfAsync()' to make it asynchronous}}
-// expected-note@+1 3{{add '@asyncHandler' to function 'testAsyncLetOutOfAsync()' to create an implicit asynchronous context}}
+// expected-note@+2 4{{add 'async' to function 'testAsyncLetOutOfAsync()' to make it asynchronous}}
+// expected-note@+1 4{{add '@asyncHandler' to function 'testAsyncLetOutOfAsync()' to create an implicit asynchronous context}}
 func testAsyncLetOutOfAsync() {
   async let x = 1 // expected-error{{'async let' in a function that does not support concurrency}}
+  // FIXME: expected-error@-1{{'async' 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}}