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 {