[Concurrency] Make #isolation macro expansions explicit.

Macro expansions are never considered implicit. They have
valid source locations in their macro expansion buffer, they
do not cause implicit 'self' capture diagnostics, etc. This
fixes an issue where existing code that iterates over an async
sequence in an escaping closure would diagnose a use of implicit
'self' via the '#isolation' argument to 'next()'.

Author: hborla

lib/Sema/TypeCheckConcurrency.cpp

@@ -3512,6 +3512,12 @@ namespace {
       auto isolation = getActorIsolationOfContext(
           const_cast<DeclContext *>(getDeclContext()),
                                     getClosureActorIsolation);
+      auto *dc = const_cast<DeclContext *>(getDeclContext());
+
+      // Note that macro expansions are never implicit. They have
+      // valid source locations in their macro expansion buffer, they
+      // do not cause implicit 'self' capture diagnostics, etc.
+
       Expr *actorExpr = nullptr;
       Type optionalAnyActorType = isolationExpr->getType();
       switch (isolation) {
@@ -3533,7 +3539,7 @@ namespace {
         }
         actorExpr = new (ctx) DeclRefExpr(
             const_cast<VarDecl *>(var), DeclNameLoc(loc),
-            /*Implicit=*/true);
+            /*implicit=*/false);
 
         // For a distributed actor, we need to retrieve the local
         // actor.
@@ -3547,10 +3553,11 @@ namespace {
         // Form a <global actor type>.shared reference.
         Type globalActorType = getDeclContext()->mapTypeIntoContext(
             isolation.getGlobalActor());
-        auto typeExpr = TypeExpr::createImplicit(globalActorType, ctx);
+        auto typeExpr = TypeExpr::createForDecl(
+            DeclNameLoc(loc), globalActorType->getAnyNominal(), dc);
         actorExpr = new (ctx) UnresolvedDotExpr(
-            typeExpr, loc, DeclNameRef(ctx.Id_shared), DeclNameLoc(),
-            /*implicit=*/true);
+            typeExpr, loc, DeclNameRef(ctx.Id_shared), DeclNameLoc(loc),
+            /*implicit=*/false);
         break;
       }
 
@@ -3560,14 +3567,14 @@ namespace {
       case ActorIsolation::Unspecified:
       case ActorIsolation::Nonisolated:
       case ActorIsolation::NonisolatedUnsafe:
-        actorExpr = new (ctx) NilLiteralExpr(loc, /*implicit=*/true);
+        actorExpr = new (ctx) NilLiteralExpr(loc, /*implicit=*/false);
         break;
       }
 
 
       // Convert the actor argument to the appropriate type.
       (void)TypeChecker::typeCheckExpression(
-          actorExpr, const_cast<DeclContext *>(getDeclContext()),
+          actorExpr, dc,
           constraints::ContextualTypeInfo(
             optionalAnyActorType, CTP_CallArgument));
 

test/Concurrency/isolation_macro.swift

@@ -33,7 +33,7 @@ extension A {
     // CHECK: rewritten=current_context_isolation_expr
     // CHECK-NEXT: inject_into_optional
     // CHECK-NEXT: erasure_expr
-    // CHECK: declref_expr implicit type="A"{{.*}}self@
+    // CHECK: declref_expr type="A"{{.*}}self@
     _ = #isolation
   }
 }
@@ -45,7 +45,7 @@ func actorIsolationToParam(_ isolatedParam: isolated A) {
   // CHECK: rewritten=current_context_isolation_expr
   // CHECK-NEXT: inject_into_optional
   // CHECK-NEXT: erasure_expr
-  // CHECK: declref_expr implicit type="A"{{.*}}isolatedParam@
+  // CHECK: declref_expr type="A"{{.*}}isolatedParam@
   _ = #isolation
 }
 
@@ -57,8 +57,8 @@ func mainActorIsolated() {
   // CHECK: rewritten=current_context_isolation_expr
   // CHECK-NEXT: inject_into_optional
   // CHECK-NEXT: erasure_expr
-  // CHECK: member_ref_expr implicit type="MainActor" decl="_Concurrency.(file).MainActor.shared"
-  // CHECK-NEXT: type_expr implicit type="MainActor.Type"
+  // CHECK: member_ref_expr type="MainActor" location=@__swiftmacro_{{.*}} decl="_Concurrency.(file).MainActor.shared"
+  // CHECK-NEXT: type_expr type="MainActor.Type"
   _ = #isolation
 }
 
@@ -72,9 +72,24 @@ func closureIsolatedToOuterParam(_ isolatedParam: isolated A) {
   // CHECK: rewritten=current_context_isolation_expr
   // CHECK-NEXT: inject_into_optional
   // CHECK-NEXT: erasure_expr
-  // CHECK: declref_expr implicit type="A"{{.*}}isolatedParam@
+  // CHECK: declref_expr type="A"{{.*}}isolatedParam@
   acceptClosure {
     _ = #isolation
     print(isolatedParam)
   }
 }
+
+func acceptEscapingClosure(_ fn: @escaping () -> Void) { }
+
+@available(SwiftStdlib 5.1, *)
+extension A {
+  func f() {
+    // Make sure this doesn't diagnose a use of implicit 'self'
+    acceptEscapingClosure {
+      _ = #isolation
+      self.g()
+    }
+  }
+
+  func g() {}
+}

test/Distributed/isolation_macro.swift

@@ -16,7 +16,7 @@ extension DistributedActor {
     // CHECK: rewritten=current_context_isolation_expr
     // CHECK-NEXT: inject_into_optional
     // CHECK: member_ref_expr{{.*}}asLocalActor
-    // CHECK: declref_expr implicit type="Self"
+    // CHECK: declref_expr type="Self"
     _ = #isolation
   }
 }