improve and fix diagnostic for implicitly async calls

Author: kavon

include/swift/AST/DiagnosticsSema.def

@@ -4213,9 +4213,10 @@ ERROR(actor_isolated_concurrent_access,none,
         "actor-isolated %0 %1 is unsafe to reference in code "
         "that may execute concurrently",
         (DescriptiveDeclKind, DeclName))
-NOTE(actor_isolated_method,none,
-     "only asynchronous methods can be used outside the actor instance; "
-     "do you want to add 'async'?", ())
+NOTE(actor_isolated_sync_func,none,
+     "calls to %0 %1 from outside of its actor context are "
+     "implicitly asynchronous",
+     (DescriptiveDeclKind, DeclName))
 NOTE(actor_mutable_state,none,
      "mutable state is only available within the actor instance", ())
 WARNING(shared_mutable_state_access,none,

lib/Sema/TypeCheckConcurrency.cpp

@@ -720,10 +720,9 @@ namespace {
       // FIXME: Make this diagnostic more sensitive to the isolation context
       // of the declaration.
       if (auto func = dyn_cast<AbstractFunctionDecl>(decl)) {
-        // FIXME: We'd like to insert 'async' at the appropriate place, but
-        // FuncDecl/AbstractFunctionDecl doesn't have the right source-location
-        // information to do so.
-        func->diagnose(diag::actor_isolated_method);
+        func->diagnose(diag::actor_isolated_sync_func, 
+          decl->getDescriptiveKind(),
+          decl->getName());
       } else if (isa<VarDecl>(decl)) {
         decl->diagnose(diag::actor_mutable_state);
       } else {

test/Concurrency/actor_call_implicitly_async.swift

@@ -18,10 +18,10 @@ actor class BankAccount {
   }
 
   // NOTE: this func is accessed through both async and sync calls.
-  // expected-note@+1 {{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+  // 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 {{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+  // 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 }
 
@@ -86,6 +86,8 @@ func someAsyncFunc() async {
 
   _ = await a.deposit(b.withdraw(a.deposit(b.withdraw(b.balance()))))
 
+  a.testSelfBalance() // expected-error {{call is 'async' but is not marked with 'await'}}
+
   print("ok!")
 }
 
@@ -150,9 +152,9 @@ func blender(_ peeler : () -> Void) {
   peeler()
 }
 
-@BananaActor func wisk(_ something : Any) { } // expected-note 4 {{only asynchronous methods can be used outside the actor instance}}
+@BananaActor func wisk(_ something : Any) { } // expected-note 4 {{calls to global function 'wisk' from outside of its actor context are implicitly asynchronous}}
 
-@BananaActor func peelBanana() { } // expected-note 2 {{only asynchronous methods can be used outside the actor instance}}
+@BananaActor func peelBanana() { } // expected-note 2 {{calls to global function 'peelBanana()' from outside of its actor context are implicitly asynchronous}}
 
 @OrangeActor func makeSmoothie() async {
   await wisk({})
@@ -174,4 +176,12 @@ func blender(_ peeler : () -> Void) {
   // expected-warning@+2 {{no calls to 'async' functions occur within 'await' expression}}
   // expected-error@+1 {{global function 'wisk' isolated to global actor 'BananaActor' can not be referenced from different global actor 'OrangeActor'}}
   await (true ? wisk : {n in return})(1)
+}
+
+
+// want to make sure there is no note about implicitly async on this func.
+@BananaActor func rice() async {}
+
+@OrangeActor func quinoa() async {
+  rice() // expected-error {{call is 'async' but is not marked with 'await'}}
 }

test/Concurrency/actor_isolation.swift

@@ -19,7 +19,7 @@ func acceptEscapingAsyncClosure<T>(_: @escaping () async -> T) { }
 actor class MySuperActor {
   var superState: Int = 25 // expected-note {{mutable state is only available within the actor instance}}
 
-  func superMethod() { } // expected-note 3 {{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+  func superMethod() { } // expected-note 3 {{calls to instance method 'superMethod()' from outside of its actor context are implicitly asynchronous}}
   func superAsyncMethod() async { }
 
   subscript (index: Int) -> String { // expected-note 3{{subscript declared here}}
@@ -34,7 +34,7 @@ actor class MyActor: MySuperActor {
   class func synchronousClass() { }
   static func synchronousStatic() { }
 
-  func synchronous() -> String { text.first ?? "nothing" } // expected-note 20{{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+  func synchronous() -> String { text.first ?? "nothing" } // expected-note 20{{calls to instance method 'synchronous()' from outside of its actor context are implicitly asynchronous}}
   func asynchronous() async -> String { synchronous() }
 }
 
@@ -199,7 +199,7 @@ struct GenericGlobalActor<T> {
   static var shared: SomeActor { SomeActor() }
 }
 
-@SomeGlobalActor func syncGlobalActorFunc() { syncGlobalActorFunc() } // expected-note{{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+@SomeGlobalActor func syncGlobalActorFunc() { syncGlobalActorFunc() } // expected-note{{calls to global function 'syncGlobalActorFunc()' from outside of its actor context are implicitly asynchronous}}
 @SomeGlobalActor func asyncGlobalActorFunc() async { await asyncGlobalActorFunc() }
 
 @SomeOtherGlobalActor func syncOtherGlobalActorFunc() { }
@@ -255,7 +255,7 @@ extension MyActor {
 }
 
 struct GenericStruct<T> {
-  @GenericGlobalActor<T> func f() { } // expected-note{{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+  @GenericGlobalActor<T> func f() { } // expected-note{{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
 
   @GenericGlobalActor<T> func g() {
     f() // okay

test/Concurrency/global_actor_inference.swift

@@ -33,7 +33,7 @@ protocol P2 {
 }
 
 class C1: P1 {
-  func method() { } // expected-note {{only asynchronous methods can be used outside the actor instance}}
+  func method() { } // expected-note {{calls to instance method 'method()' from outside of its actor context are implicitly asynchronous}}
 
   // expected-note@+2 {{add '@asyncHandler' to function 'testMethod()' to create an implicit asynchronous context}}
   // expected-note@+1 {{add 'async' to function 'testMethod()' to make it asynchronous}}
@@ -44,7 +44,7 @@ class C1: P1 {
 }
 
 class C2: P2 {
-  func method1() { }  // expected-note{{only asynchronous methods can be used outside the actor instance}}
+  func method1() { }  // expected-note{{calls to instance method 'method1()' from outside of its actor context are implicitly asynchronous}}
   func method2() { }
 
   // expected-note@+2 {{add '@asyncHandler' to function 'testMethod()' to create an implicit asynchronous context}}
@@ -60,27 +60,27 @@ class C2: P2 {
 // Global actor inference for classes and extensions
 // ----------------------------------------------------------------------
 @SomeGlobalActor class C3 {
-  func method1() { }  // expected-note {{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+  func method1() { }  // expected-note {{calls to instance method 'method1()' from outside of its actor context are implicitly asynchronous}}
 }
 
 extension C3 {
-  func method2() { }  // expected-note {{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+  func method2() { }  // expected-note {{calls to instance method 'method2()' from outside of its actor context are implicitly asynchronous}}
 }
 
 class C4: C3 {
-  func method3() { }  // expected-note {{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+  func method3() { }  // expected-note {{calls to instance method 'method3()' from outside of its actor context are implicitly asynchronous}}
 }
 
 extension C4 {
-  func method4() { }  // expected-note {{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+  func method4() { }  // expected-note {{calls to instance method 'method4()' from outside of its actor context are implicitly asynchronous}}
 }
 
 class C5 {
   func method1() { }
 }
 
 @SomeGlobalActor extension C5 {
-  func method2() { }  // expected-note {{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+  func method2() { }  // expected-note {{calls to instance method 'method2()' from outside of its actor context are implicitly asynchronous}}
 }
 
 // expected-note@+2 5 {{add '@asyncHandler' to function 'testGlobalActorInference(c3:c4:c5:)' to create an implicit asynchronous context}}
@@ -140,7 +140,7 @@ actor class GenericSuper<T> {
 }
 
 actor class GenericSub<T> : GenericSuper<[T]> {
-  override func method() { }  // expected-note{{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+  override func method() { }  // expected-note{{calls to instance method 'method()' from outside of its actor context are implicitly asynchronous}}
 
   @GenericGlobalActor<T> override func method2() { } // expected-error{{global actor 'GenericGlobalActor<T>'-isolated instance method 'method2()' has different actor isolation from global actor 'GenericGlobalActor<[T]>'-isolated overridden declaration}}
   @actorIndependent override func method3() { } // expected-error{{actor-independent instance method 'method3()' has different actor isolation from global actor 'GenericGlobalActor<[T]>'-isolated overridden declaration}}
@@ -168,7 +168,7 @@ struct OtherContainer<U> {
 
   // Ensure that substitutions work properly when inheriting.
   class Subclass3<V> : Container<(U, V)>.Superclass2 {
-    func method() { } // expected-note{{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+    func method() { } // expected-note{{calls to instance method 'method()' from outside of its actor context are implicitly asynchronous}}
 
     @OtherGlobalActor func testMethod() async {
       await method()