[concurrency] initial declaration of MainActor

Implementation is left as a TODO for now.

Resolves rdar://72161578
Partially resolves rdar://72105129

Author: kavon

lib/Frontend/ModuleInterfaceSupport.cpp

@@ -414,6 +414,11 @@ class InheritedProtocolCollector {
     if (!printOptions.shouldPrint(nominal))
       return;
 
+    /// is this nominal specifically an 'actor class'?
+    bool actorClass = false;
+    if (auto klass = dyn_cast<ClassDecl>(nominal))
+      actorClass = klass->isActor();
+
     SmallPtrSet<ProtocolDecl *, 16> handledProtocols;
 
     // First record all protocols that have already been handled.
@@ -438,6 +443,15 @@ class InheritedProtocolCollector {
         if (!handledProtocols.insert(inherited).second)
           return TypeWalker::Action::SkipChildren;
 
+        // If 'nominal' is an 'actor class', we do not synthesize its 
+        // conformance to the Actor protocol through a dummy extension.
+        // There is a special restriction on the Actor protocol in that
+        // it is only valid to conform to Actor on an 'actor class' decl,
+        // not extensions of that 'actor class'.
+        if (actorClass &&
+            inherited->isSpecificProtocol(KnownProtocolKind::Actor))
+          return TypeWalker::Action::Continue; 
+
         if (isPublicOrUsableFromInline(inherited) &&
             conformanceDeclaredInModule(M, nominal, inherited)) {
           protocolsToPrint.push_back({inherited, protoAndAvailability.second});

stdlib/public/Concurrency/Actor.swift

@@ -38,3 +38,17 @@ public func _defaultActorDestroy(_ actor: AnyObject)
 @_silgen_name("swift_defaultActor_enqueue")
 public func _defaultActorEnqueue(partialTask: PartialAsyncTask,
                                  actor: AnyObject)
+
+/// A singleton actor whose executor is equivalent to 
+/// \c DispatchQueue.main, which is the main dispatch queue.
+@globalActor public final class MainActor {
+  public static let shared = _Impl()
+  
+  public actor class _Impl {
+    @actorIndependent
+    public func enqueue(partialTask: PartialAsyncTask) {
+      // TODO: implement this.
+      _ = (nil as String?)! + "MainActor is not implemented yet."
+    }
+  }
+}

test/Concurrency/global_actor_inference.swift

@@ -18,6 +18,16 @@ struct GenericGlobalActor<T> {
   static var shared: SomeActor { SomeActor() }
 }
 
+// ----------------------------------------------------------------------
+// Check that MainActor exists
+// ----------------------------------------------------------------------
+
+@MainActor protocol Aluminium {
+  func method()
+}
+@MainActor class Copper {}
+@MainActor func iron() {}
+
 // ----------------------------------------------------------------------
 // Global actor inference for protocols
 // ----------------------------------------------------------------------

test/ModuleInterface/actor_protocol.swift

@@ -0,0 +1,46 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -typecheck -enable-library-evolution -enable-experimental-concurrency -emit-module-interface-path %t/Library.swiftinterface -module-name Library %s
+// RUN: %FileCheck --check-prefix CHECK-EXTENSION %s <%t/Library.swiftinterface
+// RUN: %FileCheck --check-prefix CHECK %s <%t/Library.swiftinterface
+
+/// This test ensures that, when generating a swiftinterface file,
+/// the actor class decl itself is what may conform to the Actor protocol,
+/// and not via some extension. The requirement is due to the unique
+/// optimizations applied to the implementation of actors.
+
+// CHECK-EXTENSION-NOT: extension {{.+}} : _Concurrency.Actor
+
+// CHECK: actor public class PlainActorClass {
+public actor class PlainActorClass {
+  @actorIndependent public func enqueue(partialTask: PartialAsyncTask) { }
+}
+
+// CHECK: actor public class ExplicitActorClass : _Concurrency.Actor {
+public actor class ExplicitActorClass : Actor {
+  @actorIndependent public func enqueue(partialTask: PartialAsyncTask) { }
+}
+
+// CHECK: actor public class EmptyActorClass {
+public actor class EmptyActorClass {}
+
+// CHECK: public protocol Cat : _Concurrency.Actor {
+public protocol Cat : Actor {
+  func mew()
+}
+
+// CHECK: actor public class HouseCat : Library.Cat {
+public actor class HouseCat : Cat {
+  @asyncHandler public func mew() {}
+  @actorIndependent public func enqueue(partialTask: PartialAsyncTask) { }
+}
+
+// CHECK: public protocol ToothyMouth {
+public protocol ToothyMouth {
+  func chew()
+}
+
+// CHECK: actor public class Lion : Library.ToothyMouth, _Concurrency.Actor {
+public actor class Lion : ToothyMouth, Actor {
+  @asyncHandler public func chew() {}
+  @actorIndependent public func enqueue(partialTask: PartialAsyncTask) { }
+}