adjust tests

not even close to complete

Author: hamishknight

test/Concurrency/Runtime/isolated_conformance.swift

@@ -147,8 +147,8 @@ func tryCastToQ(_ value: any Sendable) -> Bool {
 // CHECK-NEXT: MyClass.f()
 // CHECK-NEXT: Wrapper for MyClass.f()
 print("Testing on the main actor")
-nonisolated let mc = MyClass()
-nonisolated let wrappedMC = Wrapper(wrapped: mc)
+let mc = MyClass()
+let wrappedMC = Wrapper(wrapped: mc)
 precondition(tryCastToP(mc))
 precondition(tryCastToP(wrappedMC))
 

test/Concurrency/Runtime/isolated_deinit_main_sync.swift

@@ -5,7 +5,7 @@
 // REQUIRES: concurrency_runtime
 // UNSUPPORTED: back_deployment_runtime
 
-var isDead: Bool = false
+internal var isDead: Bool = false
 
 public class Foo {
   @MainActor

test/Concurrency/Runtime/startImmediately.swift

@@ -454,7 +454,7 @@ print("\n\n==== ----------------------------------------------------------------
 print("call_taskImmediate_taskExecutor()")
 
 @TaskLocal
-nonisolated(unsafe) var niceTaskLocalValueYouGotThere: String = ""
+nonisolated(unsafe) internal var niceTaskLocalValueYouGotThere: String = ""
 
 // FIXME: rdar://155596073 Task executors execution may not always hop as expected
 func call_taskImmediate_taskExecutor(taskExecutor: NaiveQueueExecutor) async {

test/Concurrency/Runtime/startImmediately_order.swift

@@ -14,7 +14,7 @@
 
 import _Concurrency
 
-let max = 1000
+internal nonisolated let max = 1000
 
 func bar(x: Int, cc: CheckedContinuation<Void, Never>) {
   Task.immediate {

test/Concurrency/actor_existentials.swift

@@ -51,7 +51,7 @@ func from_isolated_concrete(_ x: isolated A) async {
 actor Act {
     var i = 0 // expected-note {{mutation of this property is only permitted within the actor}}
 }
-nonisolated let act = Act()
+nonisolated internal let act = Act()
 
 func bad() async {
     // expected-warning@+3 {{no 'async' operations occur within 'await' expression}}{{5-11=}}

test/Concurrency/actor_inout_isolation.swift

@@ -208,26 +208,25 @@ struct MyGlobalActor {
   static let shared = TestActor()
 }
 
-@MyGlobalActor var number: Int = 0
-// expected-note @-1 {{var declared here}}
-// expected-note @-2 {{var declared here}}
-// expected-note @-3 {{mutation of this var is only permitted within the actor}}
-// expected-complete-error @-4 {{top-level code variables cannot have a global actor}}
-// expected-complete-note @-5 4{{mutation of this var is only permitted within the actor}}
+internal var number: Int = 0
+// expected-complete-note@-1 2{{var declared here}}
+// expected-complete-note@-2 {{mutation of this var is only permitted within the actor}}
+// expected-complete-note@-3 4{{mutation of this var is only permitted within the actor}}
 
+@MyGlobalActor var anotherNumber: Int = 0
+// expected-error @-1 {{local variable 'anotherNumber' cannot have a global actor}}
 
 if #available(SwiftStdlib 5.1, *) {
   let _ = Task.detached { await { (_ foo: inout Int) async in foo += 1 }(&number) }
-  // expected-error @-1 {{actor-isolated var 'number' cannot be passed 'inout' to 'async' function call}}
-  // expected-minimal-error @-2 {{global actor 'MyGlobalActor'-isolated var 'number' can not be used 'inout' from a nonisolated context}}
-  // expected-complete-warning @-3 {{main actor-isolated var 'number' can not be used 'inout' from a nonisolated context}}
+  // expected-complete-error@-1 {{actor-isolated var 'number' cannot be passed 'inout' to 'async' function call}}
+  // expected-complete-warning@-2 {{main actor-isolated var 'number' can not be used 'inout' from a nonisolated context}}
 }
 
 // attempt to pass global state owned by the global actor to another async function
 @available(SwiftStdlib 5.1, *)
 @MyGlobalActor func sneaky() async { await modifyAsynchronously(&number) }
-// expected-error @-1 {{actor-isolated var 'number' cannot be passed 'inout' to 'async' function call}}
-// expected-complete-error @-2 {{main actor-isolated var 'number' can not be used 'inout' from global actor 'MyGlobalActor'}}
+// expected-complete-error@-1 {{actor-isolated var 'number' cannot be passed 'inout' to 'async' function call}}
+// expected-complete-error@-2 {{main actor-isolated var 'number' can not be used 'inout' from global actor 'MyGlobalActor'}}
 
 
 // It's okay to pass actor state inout to synchronous functions!

test/Concurrency/assume_mainactor.swift

@@ -256,7 +256,7 @@ class CustomActorIsolated {
   }
 }
 
-var global = 0
+internal var global = 0
 
 func onMain() async {
   await withTaskGroup { group in

test/Concurrency/freestanding_top_level.swift

@@ -4,8 +4,8 @@
 // expected-complete-warning@+4 {{var 'global' is not concurrency-safe because it is nonisolated global shared mutable state; this is an error in the Swift 6 language mode}}
 // expected-complete-note@+3 {{add '@MainActor' to make var 'global' part of global actor 'MainActor'}}{{1-1=@MainActor }}
 // expected-complete-note@+2 {{disable concurrency-safety checks if accesses are protected by an external synchronization mechanism}}{{1-1=nonisolated(unsafe) }}
-// expected-complete-note@+1 {{convert 'global' to a 'let' constant to make 'Sendable' shared state immutable}}{{1-4=let}}
-var global = 10
+// expected-complete-note@+1 {{convert 'global' to a 'let' constant to make 'Sendable' shared state immutable}}{{10-13=let}}
+internal var global = 10
 
 // No warning because we're in the same module.
 print(global)

test/Concurrency/global_actor_from_ordinary_context.swift

@@ -130,13 +130,16 @@ func fromAsync() async {
   a[0] = 1  // expected-error{{global actor 'SomeGlobalActor'-isolated subscript 'subscript(_:)' can not be mutated from a nonisolated context}}
 }
 
-// expected-minimal-and-targeted-note @+2 {{mutation of this var is only permitted within the actor}}
-// expected-complete-error @+1 {{top-level code variables cannot have a global actor}}
-@SomeGlobalActor var value: Int = 42
+@SomeGlobalActor internal var value: Int = 42
+// expected-note@-1 {{mutation of this var is only permitted within the actor}}
+
+@SomeGlobalActor var anotherValue: Int = 42
+// expected-error@-1 {{local variable 'anotherValue' cannot have a global actor}}
 
 func topLevelSyncFunction(_ number: inout Int) { }
-// expected-minimal-and-targeted-error @+1 {{global actor 'SomeGlobalActor'-isolated var 'value' can not be used 'inout' from a nonisolated context}}
 topLevelSyncFunction(&value)
+// expected-minimal-and-targeted-error@-1 {{global actor 'SomeGlobalActor'-isolated var 'value' can not be used 'inout' from a nonisolated context}}
+// expected-complete-warning@-2 {{global actor 'SomeGlobalActor'-isolated var 'value' can not be used 'inout' from the main actor}}
 
 // Strict checking based on inferred Sendable/async/etc.
 @preconcurrency @SomeGlobalActor class Super { }

test/Concurrency/global_actor_inference.swift

@@ -660,8 +660,7 @@ func acceptAsyncSendableClosureInheriting<T>(@_inheritActorContext _: @Sendable
 
 // defer bodies inherit global actor-ness
 @MainActor
-var statefulThingy: Bool = false // expected-minimal-targeted-note {{var declared here}}
-// expected-complete-error @-1 {{top-level code variables cannot have a global actor}}
+internal var statefulThingy: Bool = false // expected-minimal-targeted-note {{var declared here}}
 
 @MainActor
 func useFooInADefer() -> String { // expected-minimal-targeted-note {{calls to global function 'useFooInADefer()' from outside of its actor context are implicitly asynchronous}}