[Concurrency] Don't produce notes about invalid calls for partial applies

If invalid actor reference is a partial application, let's not
produce a note that talks about invalid "call".

Author: xedin

lib/Sema/TypeCheckConcurrency.cpp

@@ -1082,7 +1082,7 @@ namespace {
       if (auto lookup = dyn_cast<LookupExpr>(expr)) {
         checkMemberReference(lookup->getBase(), lookup->getMember(),
                              lookup->getLoc(),
-                             /*isEscapingPartialApply*/false,
+                             /*partialApply*/None,
                              lookup);
         return { true, expr };
       }
@@ -1108,7 +1108,7 @@ namespace {
             // implicitly async, regardless of whether they are escaping.
             checkMemberReference(
                 partialApply->base, memberRef->first, memberRef->second,
-                partialApply->isEscaping);
+                partialApply);
 
             partialApply->base->walk(*this);
 
@@ -1127,7 +1127,7 @@ namespace {
         if (auto memberRef = findMemberReference(fn)) {
           checkMemberReference(
               call->getArg(), memberRef->first, memberRef->second,
-              /*isEscapingPartialApply=*/false, call);
+              /*partialApply=*/None, call);
 
           call->getArg()->walk(*this);
 
@@ -1951,7 +1951,7 @@ namespace {
     /// in an invalid or unsafe way such that a diagnostic was emitted.
     bool checkMemberReference(
         Expr *base, ConcreteDeclRef memberRef, SourceLoc memberLoc,
-        bool isEscapingPartialApply = false, 
+        Optional<PartialApplyThunkInfo> partialApply = None,
         Expr *context = nullptr) {
       if (!base || !memberRef)
         return false;
@@ -1999,7 +1999,9 @@ namespace {
                 getNearestEnclosingActorContext(getDeclContext()),
               useKind
               );
-          noteIsolatedActorMember(member, context);
+
+          if (!partialApply)
+            noteIsolatedActorMember(member, context);
           return true;
         }
 
@@ -2009,12 +2011,11 @@ namespace {
           case ActorIsolation::ActorInstance:
             // An escaping partial application of something that is part of
             // the actor's isolated state is never permitted.
-            if (isEscapingPartialApply) {
+            if (partialApply && partialApply->isEscaping) {
               ctx.Diags.diagnose(
                   memberLoc, diag::actor_isolated_partial_apply,
                   member->getDescriptiveKind(),
                   member->getName());
-              noteIsolatedActorMember(member, context);
               return true;
             }
 
@@ -2037,7 +2038,9 @@ namespace {
             auto diag = findActorIndependentReason(curDC);
             ctx.Diags.diagnose(memberLoc, diag, member->getDescriptiveKind(),
                                member->getName(), useKind);
-            noteIsolatedActorMember(member, context);
+
+            if (!partialApply)
+              noteIsolatedActorMember(member, context);
             return true;
           }
 
@@ -2059,7 +2062,9 @@ namespace {
                                contextIsolation.getGlobalActor(), useKind,
                                result == AsyncMarkingResult::SyncContext
                                );
-            noteIsolatedActorMember(member, context);
+
+            if (!partialApply)
+              noteIsolatedActorMember(member, context);
             return true;
           }
         }

test/Concurrency/actor_call_implicitly_async.swift

@@ -33,11 +33,9 @@ actor BankAccount {
     curBalance = initialDeposit
   }
 
-  // NOTE: this func is accessed through both async and sync calls.
-  // expected-note@+1 {{calls to instance method 'balance()' from outside of its actor context are implicitly asynchronous}}
   func balance() -> Int { return curBalance }
 
-  // expected-note@+1 2{{calls to instance method 'deposit' from outside of its actor context are implicitly asynchronous}}
+  // expected-note@+1 {{calls to instance method 'deposit' from outside of its actor context are implicitly asynchronous}}
   func deposit(_ amount : Int) -> Int {
     guard amount >= 0 else { return 0 }
 

test/Concurrency/actor_isolation.swift

@@ -70,7 +70,7 @@ actor MyActor: MySuperActor { // expected-error{{actor types do not support inhe
   class func synchronousClass() { }
   static func synchronousStatic() { }
 
-  func synchronous() -> String { text.first ?? "nothing" } // expected-note 19{{calls to instance method 'synchronous()' from outside of its actor context are implicitly asynchronous}}
+  func synchronous() -> String { text.first ?? "nothing" } // expected-note 5{{calls to instance method 'synchronous()' from outside of its actor context are implicitly asynchronous}}
   func asynchronous() async -> String {
     super.superState += 4
     return synchronous()
@@ -820,3 +820,17 @@ func test_conforming_actor_to_global_actor_protocol() {
   actor MyValue : GloballyIsolatedProto {}
   // expected-error@-1 {{actor 'MyValue' cannot conform to global actor isolated protocol 'GloballyIsolatedProto'}}
 }
+
+func test_invalid_reference_to_actor_member_without_a_call_note() {
+  actor A {
+    func partial() { }
+  }
+
+  actor Test {
+    func returnPartial(other: A) async -> () async -> () {
+      let a = other.partial
+      // expected-error@-1 {{actor-isolated instance method 'partial()' can only be referenced from inside the actor}}
+      return a
+    }
+  }
+}