[Concurrency] Don't diagnose missing "self." in async let autoclosures.

Author: DougGregor

include/swift/AST/Expr.h

@@ -3903,7 +3903,10 @@ class AutoClosureExpr : public AbstractClosureExpr {
 
     // An autoclosure with type (Self) -> (Args...) -> Result. Formed from type
     // checking a partial application.
-    DoubleCurryThunk = 2
+    DoubleCurryThunk = 2,
+
+    // An autoclosure with type () -> Result that was formed for an async let.
+    AsyncLet = 3,
   };
 
   AutoClosureExpr(Expr *Body, Type ResultTy, unsigned Discriminator,

include/swift/Sema/ConstraintSystem.h

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

lib/AST/Expr.cpp

@@ -2031,6 +2031,7 @@ Expr *AutoClosureExpr::getUnwrappedCurryThunkExpr() const {
 
   switch (getThunkKind()) {
   case AutoClosureExpr::Kind::None:
+  case AutoClosureExpr::Kind::AsyncLet:
     break;
 
   case AutoClosureExpr::Kind::SingleCurryThunk: {

lib/SIL/IR/SILDeclRef.cpp

@@ -447,8 +447,15 @@ bool SILDeclRef::isTransparent() const {
 
   if (hasAutoClosureExpr()) {
     auto *ace = getAutoClosureExpr();
-    if (ace->getThunkKind() == AutoClosureExpr::Kind::None)
+    switch (ace->getThunkKind()) {
+    case AutoClosureExpr::Kind::None:
       return true;
+
+    case AutoClosureExpr::Kind::AsyncLet:
+    case AutoClosureExpr::Kind::DoubleCurryThunk:
+    case AutoClosureExpr::Kind::SingleCurryThunk:
+      break;
+    }
   }
 
   if (hasDecl()) {

lib/Sema/CSApply.cpp

@@ -7900,7 +7900,9 @@ static Expr *wrapAsyncLetInitializer(
   // child task.
   auto closureType = FunctionType::get({ }, initializerType, extInfo);
   ASTContext &ctx = dc->getASTContext();
-  Expr *autoclosureExpr = cs.buildAutoClosureExpr(initializer, closureType);
+  Expr *autoclosureExpr = cs.buildAutoClosureExpr(
+      initializer, closureType, /*isDefaultWrappedValue=*/false,
+      /*isAsyncLetWrapper=*/true);
 
   // Call the autoclosure so that the AST types line up. SILGen will ignore the
   // actual calls and translate them into a different mechanism.

lib/Sema/ConstraintSystem.cpp

@@ -4662,7 +4662,8 @@ ConstraintSystem::isConversionEphemeral(ConversionRestrictionKind conversion,
 
 Expr *ConstraintSystem::buildAutoClosureExpr(Expr *expr,
                                              FunctionType *closureType,
-                                             bool isDefaultWrappedValue) {
+                                             bool isDefaultWrappedValue,
+                                             bool isAsyncLetWrapper) {
   auto &Context = DC->getASTContext();
   bool isInDefaultArgumentContext = false;
   if (auto *init = dyn_cast<Initializer>(DC)) {
@@ -4684,6 +4685,9 @@ Expr *ConstraintSystem::buildAutoClosureExpr(Expr *expr,
 
   closure->setParameterList(ParameterList::createEmpty(Context));
 
+  if (isAsyncLetWrapper)
+    closure->setThunkKind(AutoClosureExpr::Kind::AsyncLet);
+
   Expr *result = closure;
 
   if (!newClosureType->isEqual(closureType)) {

lib/Sema/MiscDiagnostics.cpp

@@ -1495,8 +1495,16 @@ static void diagnoseImplicitSelfUseInClosure(const Expr *E,
                   const AbstractClosureExpr *CE) {
       // If the closure's type was inferred to be noescape, then it doesn't
       // need qualification.
-      return !AnyFunctionRef(const_cast<AbstractClosureExpr *>(CE))
-               .isKnownNoEscape();
+      if (AnyFunctionRef(const_cast<AbstractClosureExpr *>(CE))
+               .isKnownNoEscape())
+        return false;
+
+      if (auto autoclosure = dyn_cast<AutoClosureExpr>(CE)) {
+        if (autoclosure->getThunkKind() == AutoClosureExpr::Kind::AsyncLet)
+          return false;
+      }
+
+      return true;
     }
 
 

lib/Sema/TypeCheckEffects.cpp

@@ -1638,15 +1638,16 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
     scope.enterSubFunction();
     scope.resetCoverageForAutoclosureBody();
 
-    // Curry thunks aren't actually a call to the asynchronous function.
-    // Assume that async is covered in such contexts.
     switch (E->getThunkKind()) {
     case AutoClosureExpr::Kind::DoubleCurryThunk:
     case AutoClosureExpr::Kind::SingleCurryThunk:
+      // Curry thunks aren't actually a call to the asynchronous function.
+      // Assume that async is covered in such contexts.
       Flags.set(ContextFlags::IsAsyncCovered);
       break;
 
     case AutoClosureExpr::Kind::None:
+    case AutoClosureExpr::Kind::AsyncLet:
       break;
     }
 

test/Concurrency/async_let_isolation.swift

@@ -16,8 +16,6 @@ actor class MyActor {
 
     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()