update existing tests for new implicitly-async calls.

Author: kavon

test/Concurrency/actor_isolation.swift

@@ -34,7 +34,7 @@ actor class MyActor: MySuperActor {
   class func synchronousClass() { }
   static func synchronousStatic() { }
 
-  func synchronous() -> String { text.first ?? "nothing" } // expected-note 21{{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{{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
   func asynchronous() async -> String { synchronous() }
 }
 
@@ -44,6 +44,7 @@ extension MyActor {
     set { }
   }
 
+  // expected-note@+1 {{add 'async' to function 'actorIndependentFunc(otherActor:)' to make it asynchronous}}
   @actorIndependent func actorIndependentFunc(otherActor: MyActor) -> Int {
     _ = immutable
     _ = text[0] // expected-error{{actor-isolated property 'text' can not be referenced from an '@actorIndependent' context}}
@@ -64,7 +65,8 @@ extension MyActor {
     otherActor.actorIndependentVar = 17
 
     // Global actors
-    syncGlobalActorFunc() /// expected-error{{global function 'syncGlobalActorFunc()' isolated to global actor 'SomeGlobalActor' can not be referenced from an '@actorIndependent' context}}
+    syncGlobalActorFunc() /// expected-error{{'async' in a function that does not support concurrency}}
+    _ = syncGlobalActorFunc // expected-error{{global function 'syncGlobalActorFunc()' isolated to global actor 'SomeGlobalActor' can not be referenced from an '@actorIndependent' context}}
 
     // Global data is okay if it is immutable.
     _ = immutableGlobal
@@ -102,9 +104,9 @@ extension MyActor {
     _ = super[0]
 
     // Accesses on other actors can only reference immutable data or
-    // call asychronous methods
+    // call methods
     _ = otherActor.immutable // okay
-    _ = otherActor.synchronous() // expected-error{{actor-isolated instance method 'synchronous()' can only be referenced on 'self'}}
+    _ = otherActor.synchronous() // expected-error{{call is 'async' but is not marked with 'await'}}
     _ = await otherActor.asynchronous()
     _ = otherActor.text[0] // expected-error{{actor-isolated property 'text' can only be referenced on 'self'}}
 
@@ -120,7 +122,7 @@ extension MyActor {
     Self.synchronousStatic()
 
     // Global actors
-    syncGlobalActorFunc() // expected-error{{global function 'syncGlobalActorFunc()' isolated to global actor 'SomeGlobalActor' can not be referenced from actor 'MyActor'}}
+    syncGlobalActorFunc() // expected-error{{call is 'async' but is not marked with 'await'}}
     await asyncGlobalActorFunc()
 
     // Closures.
@@ -197,24 +199,31 @@ struct GenericGlobalActor<T> {
   static var shared: SomeActor { SomeActor() }
 }
 
-@SomeGlobalActor func syncGlobalActorFunc() { } // expected-note 3{{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
-@SomeGlobalActor func asyncGlobalActorFunc() async { }
+@SomeGlobalActor func syncGlobalActorFunc() { syncGlobalActorFunc() } // expected-note{{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+@SomeGlobalActor func asyncGlobalActorFunc() async { await asyncGlobalActorFunc() }
 
-@SomeOtherGlobalActor func syncOtherGlobalActorFunc() { } // expected-note {{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
+@SomeOtherGlobalActor func syncOtherGlobalActorFunc() { }
 
 @SomeOtherGlobalActor func asyncOtherGlobalActorFunc() async {
-  syncGlobalActorFunc() // expected-error{{global function 'syncGlobalActorFunc()' isolated to global actor 'SomeGlobalActor' can not be referenced from different global actor 'SomeOtherGlobalActor'}}
+  await syncGlobalActorFunc()
   await asyncGlobalActorFunc()
 }
 
+// test global actor funcs that are marked asyncHandler
+@SomeGlobalActor func goo1() async {
+  let _ = goo2
+  goo2()
+}
+@asyncHandler @SomeOtherGlobalActor func goo2() { await goo1() }
+
 extension MyActor {
   @SomeGlobalActor func onGlobalActor(otherActor: MyActor) async {
     // Access to other functions in this actor are okay.
     syncGlobalActorFunc()
     await asyncGlobalActorFunc()
 
-    // Other global actors are not okay
-    syncOtherGlobalActorFunc() // expected-error{{global function 'syncOtherGlobalActorFunc()' isolated to global actor 'SomeOtherGlobalActor' can not be referenced from different global actor 'SomeGlobalActor'}}
+    // Other global actors are ok if marked with 'await'
+    await syncOtherGlobalActorFunc()
     await asyncOtherGlobalActorFunc()
 
     _ = immutable
@@ -238,7 +247,8 @@ extension MyActor {
     // Accesses on other actors can only reference immutable data or
     // call asychronous methods
     _ = otherActor.immutable // okay
-    _ = otherActor.synchronous() // expected-error{{actor-isolated instance method 'synchronous()' can only be referenced on 'self'}}
+    _ = otherActor.synchronous() // expected-error{{call is 'async' but is not marked with 'await'}}
+    _ = otherActor.synchronous  // expected-error{{actor-isolated instance method 'synchronous()' can only be referenced on 'self'}}
     _ = await otherActor.asynchronous()
     _ = otherActor.text[0] // expected-error{{actor-isolated property 'text' can only be referenced on 'self'}}
   }
@@ -251,8 +261,11 @@ struct GenericStruct<T> {
     f() // okay
   }
 
+  // expected-note@+2 {{add '@asyncHandler' to function 'h()' to create an implicit asynchronous context}}
+  // expected-note@+1 {{add 'async' to function 'h()' to make it asynchronous}}
   @GenericGlobalActor<String> func h() {
-    f() // expected-error{{instance method 'f()' isolated to global actor 'GenericGlobalActor<T>' can not be referenced from different global actor 'GenericGlobalActor<String>'}}
+    f() // expected-error{{'async' in a function that does not support concurrency}}
+    _ = f // expected-error{{instance method 'f()' isolated to global actor 'GenericGlobalActor<T>' can not be referenced from different global actor 'GenericGlobalActor<String>'}}
   }
 }
 
@@ -276,8 +289,9 @@ func testGlobalRestrictions(actor: MyActor) async {
   _ = await actor.asynchronous()
   _ = actor.immutable
 
-  // Synchronous operations and mutable state references are not.
-  _ = actor.synchronous() // expected-error{{actor-isolated instance method 'synchronous()' can only be referenced inside the actor}}
+  // Synchronous operations are ok, mutable state references are not.
+  _ = actor.synchronous // expected-error{{actor-isolated instance method 'synchronous()' can only be referenced inside the actor}}
+  _ = actor.synchronous() // expected-error{{call is 'async' but is not marked with 'await'}}
   _ = actor.text[0] // expected-error{{actor-isolated property 'text' can only be referenced inside the actor}}
   _ = actor[0] // expected-error{{actor-isolated subscript 'subscript(_:)' can only be referenced inside the actor}}
 

test/Concurrency/global_actor_inference.swift

@@ -33,19 +33,25 @@ protocol P2 {
 }
 
 class C1: P1 {
-  func method() { } // expected-note{{only asynchronous methods can be used outside the actor instance}}
+  func method() { } // expected-note {{only asynchronous methods can be used outside the actor instance}}
 
+  // 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}}
   @OtherGlobalActor func testMethod() {
-    method() // expected-error{{instance method 'method()' isolated to global actor 'SomeGlobalActor' can not be referenced from different global actor 'OtherGlobalActor'}}
+    method() // expected-error {{'async' in a function that does not support concurrency}}
+    _ = method  // expected-error {{instance method 'method()' isolated to global actor 'SomeGlobalActor' can not be referenced from different global actor 'OtherGlobalActor'}}
   }
 }
 
 class C2: P2 {
-  func method1() { } // expected-note{{only asynchronous methods can be used outside the actor instance}}
+  func method1() { }  // expected-note{{only asynchronous methods can be used outside the actor instance}}
   func method2() { }
 
+  // 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}}
   @OtherGlobalActor func testMethod() {
-    method1() // expected-error{{instance method 'method1()' isolated to global actor 'SomeGlobalActor' can not be referenced from different global actor 'OtherGlobalActor'}}
+    method1() // expected-error{{'async' in a function that does not support concurrency}}
+    _ = method1 // expected-error{{instance method 'method1()' isolated to global actor 'SomeGlobalActor' can not be referenced from different global actor 'OtherGlobalActor'}}
     method2() // okay
   }
 }
@@ -54,41 +60,52 @@ 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}}
+  func method1() { }  // expected-note {{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
 }
 
 extension C3 {
-  func method2() { } // expected-note{{only asynchronous methods can be used outside the actor instance}}
+  func method2() { }  // expected-note {{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
 }
 
 class C4: C3 {
-  func method3() { } // expected-note{{only asynchronous methods can be used outside the actor instance}}
+  func method3() { }  // expected-note {{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
 }
 
 extension C4 {
-  func method4() { } // expected-note{{only asynchronous methods can be used outside the actor instance}}
+  func method4() { }  // expected-note {{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
 }
 
 class C5 {
   func method1() { }
 }
 
 @SomeGlobalActor extension C5 {
-  func method2() { } // expected-note{{only asynchronous methods can be used outside the actor instance}}
+  func method2() { }  // expected-note {{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
 }
 
+// expected-note@+2 5 {{add '@asyncHandler' to function 'testGlobalActorInference(c3:c4:c5:)' to create an implicit asynchronous context}}
+// expected-note@+1 5 {{add 'async' to function 'testGlobalActorInference(c3:c4:c5:)' to make it asynchronous}}
 @OtherGlobalActor func testGlobalActorInference(c3: C3, c4: C4, c5: C5) {
   // Propagation via class annotation
-  c3.method1() // expected-error{{instance method 'method1()' isolated to global actor 'SomeGlobalActor' can not be referenced from different global actor 'OtherGlobalActor'}}
-  c3.method2() // expected-error{{instance method 'method2()' isolated to global actor 'SomeGlobalActor' can not be referenced from different global actor 'OtherGlobalActor'}}
+  c3.method1() // expected-error{{'async' in a function that does not support concurrency}}
+  c3.method2() // expected-error{{'async' in a function that does not support concurrency}}
+  
+  _ = c3.method1  // expected-error{{instance method 'method1()' isolated to global actor 'SomeGlobalActor' can not be referenced from different global actor 'OtherGlobalActor'}}
+  _ = c3.method2  // expected-error{{instance method 'method2()' isolated to global actor 'SomeGlobalActor' can not be referenced from different global actor 'OtherGlobalActor'}}
 
   // Propagation via subclassing
-  c4.method3() // expected-error{{instance method 'method3()' isolated to global actor 'SomeGlobalActor' can not be referenced from different global actor 'OtherGlobalActor'}}
-  c4.method4() // expected-error{{instance method 'method4()' isolated to global actor 'SomeGlobalActor' can not be referenced from different global actor 'OtherGlobalActor'}}
+  c4.method3() // expected-error{{'async' in a function that does not support concurrency}}
+  c4.method4() // expected-error{{'async' in a function that does not support concurrency}}
+
+  _ = c4.method3  // expected-error{{instance method 'method3()' isolated to global actor 'SomeGlobalActor' can not be referenced from different global actor 'OtherGlobalActor'}}
+  _ = c4.method4  // expected-error{{instance method 'method4()' isolated to global actor 'SomeGlobalActor' can not be referenced from different global actor 'OtherGlobalActor'}}
 
   // Propagation in an extension.
   c5.method1() // OK: no propagation
-  c5.method2() // expected-error{{instance method 'method2()' isolated to global actor 'SomeGlobalActor' can not be referenced from different global actor 'OtherGlobalActor'}}
+  c5.method2() // expected-error{{'async' in a function that does not support concurrency}}
+
+  _ = c5.method1  // OK
+  _ = c5.method2 // expected-error{{instance method 'method2()' isolated to global actor 'SomeGlobalActor' can not be referenced from different global actor 'OtherGlobalActor'}}
 }
 
 protocol P3 {
@@ -105,6 +122,8 @@ class C6: P2, P3 {
   func testMethod() {
     method1() // okay: no inference
     method2() // okay: no inference
+    let _ = method1 // okay: no inference
+    let _ = method2 // okay: no inference
   }
 }
 
@@ -121,13 +140,16 @@ 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{{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
 
   @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}}
 
+  // 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}}
   @OtherGlobalActor func testMethod() {
-    method() // expected-error{{instance method 'method()' isolated to global actor 'GenericGlobalActor<[T]>' can not be referenced from different global actor 'OtherGlobalActor'}}
+    method() // expected-error{{'async' in a function that does not support concurrency}}
+    _ = method  // expected-error{{instance method 'method()' isolated to global actor 'GenericGlobalActor<[T]>' can not be referenced from different global actor 'OtherGlobalActor'}}
   }
 }
 
@@ -146,10 +168,29 @@ 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}}
+    func method() { } // expected-note{{only asynchronous methods can be used outside the actor instance; do you want to add 'async'?}}
 
-    @OtherGlobalActor func testMethod() {
-      method() // expected-error{{instance method 'method()' isolated to global actor 'GenericGlobalActor<[(U, V)]>' can not be referenced from different global actor 'OtherGlobalActor'}}
+    @OtherGlobalActor func testMethod() async {
+      await method()
+      let _ = method  // expected-error{{instance method 'method()' isolated to global actor 'GenericGlobalActor<[(U, V)]>' can not be referenced from different global actor 'OtherGlobalActor'}}
     }
   }
 }
+
+// ----------------------------------------------------------------------
+// Global actor inference for unspecified contexts
+// ----------------------------------------------------------------------
+
+@SomeGlobalActor func foo() { sibling() }
+
+@SomeGlobalActor func sibling() { foo() }
+
+func bar() async {
+  foo() // expected-error{{call is 'async' but is not marked with 'await'}}
+}
+
+// expected-note@+2 {{add '@asyncHandler' to function 'barSync()' to create an implicit asynchronous context}}
+// expected-note@+1 {{add 'async' to function 'barSync()' to make it asynchronous}}
+func barSync() {
+  foo() // expected-error{{'async' in a function that does not support concurrency}}
+}