Updating tests to use actor

This patch updates the `actor class` spelling to `actor` in almost all
of the tests. There are places where I verify that we sanely handle
`actor` as an attribute though. These include:

 - test/decl/class/actor/basic.swift
 - test/decl/protocol/special/Actor.swift
 - test/SourceKit/CursorInfo/cursor_info_concurrency.swift
 - test/attr/attr_objc_async.swift
 - test/ModuleInterface/actor_protocol.swift

Author: etcwilde

test/ClangImporter/objc_async.swift

@@ -71,7 +71,7 @@ func testSlowServerOldSchool(slowServer: SlowServer) {
 // Check import of attributes
 func globalAsync() async { }
 
-actor class MySubclassCheckingSwiftAttributes : ProtocolWithSwiftAttributes {
+actor MySubclassCheckingSwiftAttributes : ProtocolWithSwiftAttributes {
   func syncMethod() { } // expected-note 2{{calls to instance method 'syncMethod()' from outside of its actor context are implicitly asynchronous}}
 
   func independentMethod() {

test/Concurrency/Runtime/actor_counters.swift

@@ -13,7 +13,7 @@ import Darwin
 import Glibc
 #endif
 
-actor class Counter {
+actor Counter {
   private var value = 0
   private let scratchBuffer: UnsafeMutableBufferPointer<Int>
 

test/Concurrency/Runtime/mainactor.swift

@@ -26,7 +26,7 @@ func checkIfMainQueue(expectedAnswer expected: Bool) -> Bool {
   return true
 }
 
-actor class A {
+actor A {
   func onCorrectQueue(_ count : Int) -> Int {
     if checkIfMainQueue(expectedAnswer: false) {
       print("on actor instance's queue")

test/Concurrency/actor_call_implicitly_async.swift

@@ -1,7 +1,7 @@
 // RUN: %target-typecheck-verify-swift -enable-experimental-concurrency
 // REQUIRES: concurrency
 
-actor class BankAccount {
+actor BankAccount {
 
   private var curBalance : Int
 
@@ -61,7 +61,7 @@ actor class BankAccount {
     _ = deposit(withdraw(deposit(withdraw(balance()))))
   }
 
-} // end actor class
+} // end actor
 
 func someAsyncFunc() async {
   let deposit1 = 120, deposit2 = 45
@@ -136,7 +136,7 @@ func regularFunc() {
 }
 
 
-actor class TestActor {}
+actor TestActor {}
 
 @globalActor
 struct BananaActor {
@@ -189,7 +189,7 @@ func blender(_ peeler : () -> Void) {
 ///////////
 // check various curried applications to ensure we mark the right expression.
 
-actor class Calculator {
+actor Calculator {
   func addCurried(_ x : Int) -> ((Int) -> Int) { 
     return { (_ y : Int) in x + y }
   }
@@ -214,4 +214,4 @@ actor class Calculator {
 
   let plusOne = await calc.addCurried(await calc.add(0, 1))
   let _ = plusOne(2)
-}
+}

test/Concurrency/actor_inout_isolation.swift

@@ -22,7 +22,7 @@ struct Point {
   }
 }
 
-actor class TestActor {
+actor TestActor {
   // expected-note@+1{{mutable state is only available within the actor instance}}
   var position = Point(x: 0, y: 0)
   var nextPosition = Point(x: 0, y: 1)
@@ -122,7 +122,7 @@ extension TestActor {
 }
 
 // Check implicit async testing
-actor class DifferentActor {
+actor DifferentActor {
   func modify(_ state: inout Int) {}
 }
 
@@ -144,7 +144,7 @@ extension TestActor {
   }
 }
 
-actor class MyActor {
+actor MyActor {
   var points: [Point] = []
   var int: Int = 0
   var maybeInt: Int?

test/Concurrency/actor_isolation.swift

@@ -17,7 +17,7 @@ func acceptEscapingAsyncClosure<T>(_: @escaping () async -> T) { }
 // ----------------------------------------------------------------------
 // Actor state isolation restrictions
 // ----------------------------------------------------------------------
-actor class MySuperActor {
+actor MySuperActor {
   var superState: Int = 25 // expected-note {{mutable state is only available within the actor instance}}
 
   func superMethod() { } // expected-note 3 {{calls to instance method 'superMethod()' from outside of its actor context are implicitly asynchronous}}
@@ -28,7 +28,7 @@ actor class MySuperActor {
   }
 }
 
-actor class MyActor: MySuperActor {
+actor MyActor: MySuperActor {
   let immutable: Int = 17
   var text: [String] = [] // expected-note 10{{mutable state is only available within the actor instance}}
 
@@ -199,7 +199,7 @@ extension MyActor {
 // ----------------------------------------------------------------------
 // Global actor isolation restrictions
 // ----------------------------------------------------------------------
-actor class SomeActor { }
+actor SomeActor { }
 
 @globalActor
 struct SomeGlobalActor {
@@ -395,7 +395,7 @@ func checkLocalFunctions() async {
 // Lazy properties with initializers referencing 'self'
 // ----------------------------------------------------------------------
 
-actor class LazyActor {
+actor LazyActor {
     var v: Int = 0
     // expected-note@-1 6 {{mutable state is only available within the actor instance}}
 
@@ -450,7 +450,7 @@ extension SomeClassInActor.ID {
 // ----------------------------------------------------------------------
 // Initializers
 // ----------------------------------------------------------------------
-actor class SomeActorWithInits {
+actor SomeActorWithInits {
   var mutableState: Int = 17
   var otherMutableState: Int
 

test/Concurrency/actor_isolation_objc.swift

@@ -6,7 +6,7 @@ import Foundation
 
 func g(_ selector: Selector) -> Int { }
 
-actor class A {
+actor A {
   func selectors() {
     _ = #selector(type(of: self).f) // expected-error{{argument of '#selector' refers to instance method 'f()' that is not exposed to Objective-C}}
     _ = #selector(type(of: self).g) // expected-error{{argument of '#selector' refers to instance method 'g()' that is not exposed to Objective-C}}

test/Concurrency/async_let_isolation.swift

@@ -1,7 +1,7 @@
 // RUN: %target-typecheck-verify-swift -enable-experimental-concurrency
 // REQUIRES: concurrency
 
-actor class MyActor {
+actor MyActor {
   let immutable: Int = 17
   var text: [String] = []
 

test/Concurrency/closure_isolation.swift

@@ -7,7 +7,7 @@ func acceptEscapingClosure<T>(_: @escaping () -> T) { }
 func acceptAsyncClosure<T>(_: () async -> T) { }
 func acceptEscapingAsyncClosure<T>(_: @escaping () async -> T) { }
 
-actor class MyActor {
+actor MyActor {
   func method() async -> String { "" }
 }
 
@@ -36,7 +36,7 @@ extension MyActor {
   }
 }
 
-actor class SomeActor { }
+actor SomeActor { }
 
 @globalActor
 struct SomeGlobalActor {

test/Concurrency/concurrent_value_checking.swift

@@ -7,13 +7,13 @@ class NotConcurrent { }
 // ConcurrentValue restriction on actor operations
 // ----------------------------------------------------------------------
 
-actor class A1 {
+actor A1 {
   let localLet: NotConcurrent = NotConcurrent()
   func synchronous() -> NotConcurrent? { nil }
   func asynchronous(_: NotConcurrent?) async { }
 }
 
-actor class A2 {
+actor A2 {
   var localVar: NotConcurrent
 
   init(value: NotConcurrent) {
@@ -46,7 +46,7 @@ extension A1 {
 // ----------------------------------------------------------------------
 // ConcurrentValue restriction on global actor operations
 // ----------------------------------------------------------------------
-actor class TestActor {}
+actor TestActor {}
 
 @globalActor
 struct SomeGlobalActor {

test/Concurrency/default_actor_definit.swift

@@ -1,15 +1,15 @@
 // RUN: %target-swift-frontend -emit-sil %s -enable-experimental-concurrency | %FileCheck %s
 // REQUIRES: concurrency
 
-actor class A {
+actor A {
   var x: String = "Hello"
   var y: String = "World"
 }
 // CHECK-LABEL: sil hidden @$s21default_actor_definit1ACACycfc
 // CHECK:         builtin "initializeDefaultActor"(%0 : $A) : $()
 // CHECK-LABEL: end sil function '$s21default_actor_definit1ACACycfc'
 
-actor class B {
+actor B {
   var x: String
   var y: String
 
@@ -22,7 +22,7 @@ actor class B {
 // CHECK:         builtin "initializeDefaultActor"(%0 : $B) : $()
 // CHECK-LABEL: end sil function '$s21default_actor_definit1BCACycfc'
 
-actor class C {
+actor C {
   var x: String
   var y: Int
 

test/Concurrency/global_actor_from_ordinary_context.swift

@@ -3,7 +3,7 @@
 
 // provides coverage for rdar://71548470
 
-actor class TestActor {}
+actor TestActor {}
 
 @globalActor
 struct SomeGlobalActor {
@@ -14,7 +14,7 @@ struct SomeGlobalActor {
 @SomeGlobalActor func syncGlobActorFn() { }
 @SomeGlobalActor func asyncGlobalActFn() async { }
 
-actor class Alex {
+actor Alex {
   @SomeGlobalActor let const_memb = 20
   @SomeGlobalActor var mut_memb = 30 // expected-note 2 {{mutable state is only available within the actor instance}}
   @SomeGlobalActor func method() {} // expected-note 2 {{calls to instance method 'method()' from outside of its actor context are implicitly asynchronous}}

test/Concurrency/global_actor_inference.swift

@@ -1,7 +1,7 @@
 // RUN: %target-typecheck-verify-swift -enable-experimental-concurrency
 // REQUIRES: concurrency
 
-actor class SomeActor { }
+actor SomeActor { }
 
 @globalActor
 struct SomeGlobalActor {
@@ -140,7 +140,7 @@ class C6: P2, P3 {
 // ----------------------------------------------------------------------
 // Global actor checking for overrides
 // ----------------------------------------------------------------------
-actor class GenericSuper<T> {
+actor GenericSuper<T> {
   @GenericGlobalActor<T> func method() { }
 
   @GenericGlobalActor<T> func method2() { } // expected-note {{overridden declaration is here}}
@@ -149,7 +149,7 @@ actor class GenericSuper<T> {
   @GenericGlobalActor<T> func method5() { }
 }
 
-actor class GenericSub<T> : GenericSuper<[T]> {
+actor GenericSub<T> : GenericSuper<[T]> {
   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}}

test/IRGen/actor_class.swift

@@ -37,7 +37,7 @@
 // CHECK-SAME: i16 1, i16 12, i32 2, i32 6,
 // CHECK-SAME: @"symbolic BD"
 
-public actor class MyClass {
+public actor MyClass {
   public var x: Int
   public init() { self.x = 0 }
 }
@@ -60,7 +60,7 @@ public actor class MyClass {
 // CHECK: swift_defaultActor_destroy
 // CHECK-LABEL: ret
 
-public actor class Exchanger<T> {
+public actor Exchanger<T> {
   public var value: T
 
   public init(value: T) { self.value = value }

test/IRGen/actor_class_forbid_objc_assoc_objects.swift

@@ -7,19 +7,19 @@ import _Concurrency
 
 // CHECK: @_METACLASS_DATA__TtC37actor_class_forbid_objc_assoc_objects5Actor = internal constant { {{.*}} } { i32 [[METAFLAGS:1153]],
 // CHECK: @_DATA__TtC37actor_class_forbid_objc_assoc_objects5Actor = internal constant { {{.*}} } { i32 [[OBJECTFLAGS:1152|1216]],
-final actor class Actor {
+final actor Actor {
 }
 
 // CHECK: @_METACLASS_DATA__TtC37actor_class_forbid_objc_assoc_objects6Actor2 = internal constant { {{.*}} } { i32 [[METAFLAGS]],
 // CHECK: @_DATA__TtC37actor_class_forbid_objc_assoc_objects6Actor2 = internal constant { {{.*}} } { i32 [[OBJECTFLAGS]],
-actor class Actor2 {
+actor Actor2 {
 }
 
 // CHECK: @_METACLASS_DATA__TtC37actor_class_forbid_objc_assoc_objects6Actor3 = internal constant { {{.*}} } { i32 [[METAFLAGS]],
 // CHECK: @_DATA__TtC37actor_class_forbid_objc_assoc_objects6Actor3 = internal constant { {{.*}} } { i32 [[OBJECTFLAGS]],
 class Actor3 : Actor2 {}
 
-actor class GenericActor<T> {
+actor GenericActor<T> {
     var state: T
     init(state: T) { self.state = state }
 }

test/IRGen/actor_class_objc.swift

@@ -32,7 +32,7 @@ import Foundation
 // CHECK-64-SAME: i64 96,
 // CHECK-32-SAME: i32 48,
 
-public actor class MyClass: NSObject {
+public actor MyClass: NSObject {
   public var x: Int
   public override init() { self.x = 0 }
 }

test/IRGen/async/hop_to_executor.sil

@@ -8,7 +8,7 @@ import Builtin
 import Swift
 import _Concurrency
 
-final actor class MyActor {
+final actor MyActor {
 }
 
 // CHECK-LABEL: define{{.*}} void @test_simple(%swift.task* %0, %swift.executor* %1, %swift.context* swiftasync %2)

test/IRGen/async/run-switch-executor.swift

@@ -16,7 +16,7 @@
 // Currently this test just checks if nothing crashes.
 // TODO: also check if the current executor is the correct one.
 
-final actor class MyActor {
+final actor MyActor {
   var p: Int
 
   @inline(never)

test/IRGen/ptrauth-actor.swift

@@ -8,11 +8,11 @@
 import Swift
 import _Concurrency
 
-public actor class A1 {
+public actor A1 {
   var x: Int = 17
 }
 
-open actor class A3<T>: Actor {
+open actor A3<T>: Actor {
   open func f() { }
 }