Pass all the tests!

There were some tests that relied on the top-level code not being an
asynchronous context to emit certain error messages. Now that it is,
those tests weren't emitting the expected error message.

In other cases, the issue was that they were trying to initialize a
global variable and weren't really using top-level code as top-level
code, so adding `-parse-as-library` was sufficient for the testing
purposes.

To fix the objc_async test, parsing as a library was nearly sufficient.
Unfortunately, the little `if #available` trick that I was using stopped
working since it relied on being in top-level code. So that we emit the
unavailableFromAsync error message, I had to set the availability on
everything correctly because we can't just disable availability
checking.

Author: etcwilde

test/ClangImporter/objc_async.swift

@@ -1,15 +1,15 @@
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -I %S/Inputs/custom-modules %s -verify -verify-additional-file %swift_src_root/test/Inputs/clang-importer-sdk/usr/include/ObjCConcurrency.h -warn-concurrency
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -I %S/Inputs/custom-modules %s -verify -verify-additional-file %swift_src_root/test/Inputs/clang-importer-sdk/usr/include/ObjCConcurrency.h -warn-concurrency -parse-as-library
 
 // REQUIRES: objc_interop
 // REQUIRES: concurrency
 import Foundation
 import ObjCConcurrency
 // expected-remark@-1{{add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'ObjCConcurrency'}}
 
-if #available(SwiftStdlib 5.5, *) {
-
+@available(SwiftStdlib 5.5, *)
 @MainActor func onlyOnMainActor() { }
 
+@available(SwiftStdlib 5.5, *)
 func testSlowServer(slowServer: SlowServer) async throws {
   let _: Int = await slowServer.doSomethingSlow("mail")
   let _: Bool = await slowServer.checkAvailability()
@@ -62,6 +62,7 @@ func testSlowServer(slowServer: SlowServer) async throws {
   _ = await slowServer.runOnMainThread()
 }
 
+@available(SwiftStdlib 5.5, *)
 func testSlowServerSynchronous(slowServer: SlowServer) {
   // synchronous version
   let _: Int = slowServer.doSomethingConflicted("thinking")
@@ -88,6 +89,7 @@ func testSlowServerSynchronous(slowServer: SlowServer) {
   let _: Int = slowServer.overridableButRunsOnMainThread // expected-error{{cannot convert value of type '(((String) -> Void)?) -> Void' to specified type 'Int'}}
 }
 
+@available(SwiftStdlib 5.5, *)
 func testSlowServerOldSchool(slowServer: SlowServer) {
   slowServer.doSomethingSlow("mail") { i in
     _ = i
@@ -96,6 +98,7 @@ func testSlowServerOldSchool(slowServer: SlowServer) {
   _ = slowServer.allOperations
 }
 
+@available(SwiftStdlib 5.5, *)
 func testSendable(fn: () -> Void) {
   doSomethingConcurrently(fn) // okay, due to implicit @preconcurrency
   doSomethingConcurrentlyButUnsafe(fn) // okay, @Sendable not part of the type
@@ -107,6 +110,7 @@ func testSendable(fn: () -> Void) {
   }
 }
 
+@available(SwiftStdlib 5.5, *)
 func testSendableInAsync() async {
   var x = 17
   doSomethingConcurrentlyButUnsafe {
@@ -115,6 +119,7 @@ func testSendableInAsync() async {
   print(x)
 }
 
+@available(SwiftStdlib 5.5, *)
 func testSendableAttrs(
   sendableClass: SendableClass, nonSendableClass: NonSendableClass,
   sendableEnum: SendableEnum, nonSendableEnum: NonSendableEnum,
@@ -150,8 +155,10 @@ func testSendableAttrs(
 }
 
 // Check import of attributes
+@available(SwiftStdlib 5.5, *)
 func globalAsync() async { }
 
+@available(SwiftStdlib 5.5, *)
 actor MySubclassCheckingSwiftAttributes : ProtocolWithSwiftAttributes {
   func syncMethod() { } // expected-note 2{{calls to instance method 'syncMethod()' from outside of its actor context are implicitly asynchronous}}
 
@@ -177,13 +184,16 @@ func testCV(r: NSRange) {
 
 // Global actor (unsafe) isolation.
 
+@available(SwiftStdlib 5.5, *)
 actor SomeActor { }
 
+@available(SwiftStdlib 5.5, *)
 @globalActor
 struct SomeGlobalActor {
   static let shared = SomeActor()
 }
 
+@available(SwiftStdlib 5.5, *)
 class MyButton : NXButton {
   @MainActor func testMain() {
     onButtonPress() // okay
@@ -198,17 +208,19 @@ class MyButton : NXButton {
   }
 }
 
+@available(SwiftStdlib 5.5, *)
 func testButtons(mb: MyButton) {
   mb.onButtonPress()
 }
 
-
+@available(SwiftStdlib 5.5, *)
 func testMirrored(instance: ClassWithAsync) async {
   await instance.instanceAsync()
   await instance.protocolMethod()
   await instance.customAsyncName()
 }
 
+@available(SwiftStdlib 5.5, *)
 @MainActor class MyToolbarButton : NXButton {
   var count = 5
 
@@ -220,6 +232,7 @@ func testMirrored(instance: ClassWithAsync) async {
   }
 }
 
+@available(SwiftStdlib 5.5, *)
 @MainActor class MyView: NXView {
   func f() {
     Task {
@@ -231,13 +244,17 @@ func testMirrored(instance: ClassWithAsync) async {
 }
 
 
+
+@available(SwiftStdlib 5.5, *)
 @MainActor func mainActorFn() {}
+@available(SwiftStdlib 5.5, *)
 @SomeGlobalActor func sgActorFn() {}
 
 // Check inferred isolation for overridden decls from ObjC.
 // Note that even if the override is not present, it
 // can have an affect. -- rdar://87217618 / SR-15694
 @MainActor
+@available(SwiftStdlib 5.5, *)
 class FooFrame: PictureFrame {
   init() {
     super.init(size: 0)
@@ -252,6 +269,7 @@ class FooFrame: PictureFrame {
   }
 }
 
+@available(SwiftStdlib 5.5, *)
 class BarFrame: PictureFrame {
   init() {
     super.init(size: 0)
@@ -266,6 +284,7 @@ class BarFrame: PictureFrame {
   }
 }
 
+@available(SwiftStdlib 5.5, *)
 @SomeGlobalActor
 class BazFrame: NotIsolatedPictureFrame {
   init() {
@@ -285,6 +304,7 @@ class BazFrame: NotIsolatedPictureFrame {
 class BazFrameIso: PictureFrame { // expected-error {{global actor 'SomeGlobalActor'-isolated class 'BazFrameIso' has different actor isolation from main actor-isolated superclass 'PictureFrame'}}
 }
 
+@available(SwiftStdlib 5.5, *)
 func check() async {
   _ = await BarFrame()
   _ = await FooFrame()
@@ -347,5 +367,3 @@ func testSender(
   sender.sendPtr(ptr)
   sender.sendStringArray(stringArray)
 }
-
-} // SwiftStdlib 5.5

test/Concurrency/actor_call_implicitly_async.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift  -disable-availability-checking -warn-concurrency
+// RUN: %target-typecheck-verify-swift  -disable-availability-checking -warn-concurrency -parse-as-library
 // REQUIRES: concurrency
 
 

test/Concurrency/actor_isolation.swift

@@ -1,6 +1,6 @@
 // RUN: %empty-directory(%t)
 // RUN: %target-swift-frontend -emit-module -emit-module-path %t/OtherActors.swiftmodule -module-name OtherActors %S/Inputs/OtherActors.swift -disable-availability-checking
-// RUN: %target-typecheck-verify-swift -I %t  -disable-availability-checking -warn-concurrency
+// RUN: %target-typecheck-verify-swift -I %t  -disable-availability-checking -warn-concurrency -parse-as-library
 // REQUIRES: concurrency
 
 import OtherActors // expected-remark{{add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'OtherActors'}}{{1-1=@preconcurrency }}

test/Concurrency/concurrency_warnings.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift -warn-concurrency
+// RUN: %target-typecheck-verify-swift -warn-concurrency -parse-as-library
 // REQUIRES: concurrency
 
 class GlobalCounter {

test/Concurrency/concurrent_value_checking.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift  -disable-availability-checking -warn-concurrency
+// RUN: %target-typecheck-verify-swift  -disable-availability-checking -warn-concurrency -parse-as-library
 // REQUIRES: concurrency
 
 class NotConcurrent { } // expected-note 27{{class 'NotConcurrent' does not conform to the 'Sendable' protocol}}

test/Concurrency/property_initializers_swift6.swift

@@ -3,17 +3,21 @@
 
 // REQUIRES: asserts
 
-@MainActor
-func mainActorFn() -> Int { return 0 } // expected-note 2 {{calls to global function 'mainActorFn()' from outside of its actor context are implicitly asynchronous}}
+@globalActor
+actor GlobalActor {
+    static let shared = GlobalActor()
+}
+
+@GlobalActor
+func globalActorFn() -> Int { return 0 } // expected-note 2 {{calls to global function 'globalActorFn()' from outside of its actor context are implicitly asynchronous}}
 
-@MainActor
+@GlobalActor
 class C {
-  var x: Int = mainActorFn() // expected-error {{call to main actor-isolated global function 'mainActorFn()' in a synchronous nonisolated context}}
+  var x: Int = globalActorFn() // expected-error {{call to global actor 'GlobalActor'-isolated global function 'globalActorFn()' in a synchronous nonisolated context}}
 
-  lazy var y: Int = mainActorFn()
+  lazy var y: Int = globalActorFn()
 
-  static var z: Int = mainActorFn()
+  static var z: Int = globalActorFn()
 }
 
-@MainActor
-var x: Int = mainActorFn() // expected-error {{call to main actor-isolated global function 'mainActorFn()' in a synchronous nonisolated context}}
+var x: Int = globalActorFn() // expected-error {{call to global actor 'GlobalActor'-isolated global function 'globalActorFn()' in a synchronous main actor-isolated context}}

test/stmt/async.swift

@@ -2,9 +2,14 @@
 
 // REQUIRES: concurrency
 
-func f() async -> Int { 0 }
+@_silgen_name("omnomInt")
+func omnom(_ x: Int)
 
-_ = await f() // expected-error{{'async' call in a function that does not support concurrency}}
+func f() async -> Int { 0 }
 
-async let y = await f() // expected-error{{'async let' in a function that does not support concurrency}}
-// expected-error@-1{{'async' call in a function that does not support concurrency}}
+func syncContext() {        // expected-note 4 {{add 'async' to function 'syncContext()' to make it asynchronous}}
+    _ = await f()           // expected-error{{'async' call in a function that does not support concurrency}}
+    async let y = await f() // expected-error{{'async let' in a function that does not support concurrency}}
+                            // expected-error@-1{{'async' call in a function that does not support concurrency}}
+    await omnom(y)          // expected-error{{'async let' in a function that does not support concurrency}}
+}