[Concurrency] Allow global actor annotations on declarations.

Global actor types can be used as attributes on various kinds of
declarations to indicate that those declarations are part of the
isolated state of that global actor. Allow such annotation and perform
basic correctness checks.

Author: DougGregor

include/swift/AST/Decl.h

@@ -950,6 +950,16 @@ class alignas(1 << DeclAlignInBits) Decl {
   /// If this returns true, the decl can be safely casted to ValueDecl.
   bool isPotentiallyOverridable() const;
 
+  /// Returns true if this Decl cannot be seen by any other source file
+  bool isPrivateToEnclosingFile() const;
+
+  /// Retrieve the global actor attribute that applies to this declaration,
+  /// if any.
+  ///
+  /// This is the "raw" global actor attribute as written directly on the
+  /// declaration, with any inference rules applied.
+  CustomAttr *getGlobalActorAttr() const;
+
   /// If an alternative module name is specified for this decl, e.g. using
   /// @_originalDefinedIn attribute, this function returns this module name.
   StringRef getAlternateModuleName() const;

include/swift/AST/DiagnosticsSema.def

@@ -4221,6 +4221,16 @@ NOTE(global_actor_shared_non_actor_type,none,
      "'shared' property type %0 does not conform to the 'Actor' protocol",
      (Type))
 
+ERROR(multiple_global_actors,none,
+      "declaration can not have multiple global actor attributes (%0 and %1)",
+      (Identifier, Identifier))
+ERROR(global_actor_disallowed,none,
+      "%0 cannot have a global actor", (DescriptiveDeclKind))
+ERROR(global_actor_on_actor_class,none,
+      "actor class %0 cannot have a global actor", (Identifier))
+ERROR(global_actor_on_local_variable,none,
+      "local variable %0 cannot have a global actor", (DeclName))
+
 //------------------------------------------------------------------------------
 // MARK: Type Check Types
 //------------------------------------------------------------------------------

include/swift/AST/TypeCheckRequests.h

@@ -880,6 +880,30 @@ class GlobalActorInstanceRequest :
   bool isCached() const { return true; }
 };
 
+/// Request the custom attribute which denotes the global actor for the given
+/// declaration.
+///
+/// This is the "raw" global actor attribute as written directly on the
+/// declaration, with any inference rules applied.
+class GlobalActorAttributeRequest :
+    public SimpleRequest<GlobalActorAttributeRequest,
+                         CustomAttr *(Decl *),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  CustomAttr *
+  evaluate(Evaluator &evaluator, Decl *decl) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+};
+
 /// Determine the actor isolation for the given declaration.
 class ActorIsolationRequest :
     public SimpleRequest<ActorIsolationRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -90,6 +90,8 @@ SWIFT_REQUEST(TypeChecker, IsActorRequest, bool(ClassDecl *),
 SWIFT_REQUEST(TypeChecker, GlobalActorInstanceRequest,
               VarDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, GlobalActorAttributeRequest,
+              CustomAttr *(Decl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ActorIsolationRequest,
               ActorIsolationState(ValueDecl *),
               Cached, NoLocationInfo)

lib/AST/Decl.cpp

@@ -672,6 +672,14 @@ static_assert(sizeof(checkSourceLocType(&ID##Decl::getLoc)) == 2, \
   llvm_unreachable("invalid file kind");
 }
 
+CustomAttr *Decl::getGlobalActorAttr() const {
+  auto &ctx = getASTContext();
+  auto mutableThis = const_cast<Decl *>(this);
+  return evaluateOrDefault(ctx.evaluator,
+                           GlobalActorAttributeRequest{mutableThis},
+                           nullptr);
+}
+
 Expr *AbstractFunctionDecl::getSingleExpressionBody() const {
   assert(hasSingleExpressionBody() && "Not a single-expression body");
   auto braceStmt = getBody();

lib/Sema/TypeCheckAttr.cpp

@@ -3065,6 +3065,13 @@ void AttributeChecker::visitCustomAttr(CustomAttr *attr) {
     return;
   }
 
+  // If the nominal type is a global actor, let the global actor attribute
+  // retrieval request perform checking for us.
+  if (nominal->isGlobalActor()) {
+    (void)D->getGlobalActorAttr();
+    return;
+  }
+
   diagnose(attr->getLocation(), diag::nominal_type_not_attribute,
            nominal->getDescriptiveKind(), nominal->getName());
   nominal->diagnose(diag::decl_declared_here, nominal->getName());

lib/Sema/TypeCheckConcurrency.cpp

@@ -18,6 +18,7 @@
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/NameLookupRequests.h"
 #include "swift/AST/TypeCheckRequests.h"
 
 using namespace swift;
@@ -327,6 +328,77 @@ VarDecl *GlobalActorInstanceRequest::evaluate(
   return nullptr;
 }
 
+CustomAttr *GlobalActorAttributeRequest::evaluate(
+    Evaluator &evaluator, Decl *decl) const {
+  ASTContext &ctx = decl->getASTContext();
+  auto dc = decl->getDeclContext();
+  CustomAttr *globalActorAttr = nullptr;
+  NominalTypeDecl *globalActorNominal = nullptr;
+
+  for (auto attr : decl->getAttrs().getAttributes<CustomAttr>()) {
+    auto mutableAttr = const_cast<CustomAttr *>(attr);
+    // Figure out which nominal declaration this custom attribute refers to.
+    auto nominal = evaluateOrDefault(ctx.evaluator,
+                                     CustomAttrNominalRequest{mutableAttr, dc},
+                                     nullptr);
+
+    // Ignore unresolvable custom attributes.
+    if (!nominal)
+      continue;
+
+    // We are only interested in global actor types.
+    if (!nominal->isGlobalActor())
+      continue;
+
+    // Only a single global actor can be applied to a given declaration.
+    if (globalActorAttr) {
+      decl->diagnose(
+          diag::multiple_global_actors, globalActorNominal->getName(),
+          nominal->getName());
+      continue;
+    }
+
+    globalActorAttr = const_cast<CustomAttr *>(attr);
+    globalActorNominal = nominal;
+  }
+
+  if (!globalActorAttr)
+    return nullptr;
+
+  // Check that a global actor attribute makes sense on this kind of
+  // declaration.
+  if (auto nominal = dyn_cast<NominalTypeDecl>(decl)) {
+    // Nominal types are okay...
+    if (auto classDecl = dyn_cast<ClassDecl>(nominal)){
+      if (classDecl->isActor()) {
+        // ... except for actor classes.
+        nominal->diagnose(diag::global_actor_on_actor_class, nominal->getName())
+            .highlight(globalActorAttr->getRangeWithAt());
+        return nullptr;
+      }
+    }
+  } else if (auto storage = dyn_cast<AbstractStorageDecl>(decl)) {
+    // Subscripts and properties are fine...
+    if (auto var = dyn_cast<VarDecl>(storage)) {
+      if (var->getDeclContext()->isLocalContext()) {
+        var->diagnose(diag::global_actor_on_local_variable, var->getName())
+            .highlight(globalActorAttr->getRangeWithAt());
+        return nullptr;
+      }
+    }
+  } else if (isa<ExtensionDecl>(decl)) {
+    // Extensions are okay.
+  } else if (isa<ConstructorDecl>(decl) || isa<FuncDecl>(decl)) {
+    // Functions are okay.
+  } else {
+    // Everything else is disallowed.
+    decl->diagnose(diag::global_actor_disallowed, decl->getDescriptiveKind());
+    return nullptr;
+  }
+
+  return globalActorAttr;
+}
+
 namespace {
 
 /// The isolation restriction in effect for a given declaration that is

test/attr/global_actor.swift

@@ -5,6 +5,10 @@ import _Concurrency
 
 actor class SomeActor { }
 
+// -----------------------------------------------------------------------
+// @globalActor attribute itself.
+// -----------------------------------------------------------------------
+
 // Well-formed global actor.
 @globalActor
 struct GA1 {
@@ -43,3 +47,37 @@ extension GA6 where T: Equatable {
 class GA7 { // expected-error{{global actor 'GA7' requires a static property 'shared' that produces an actor instance}}
   static let shared = 5 // expected-note{{'shared' property type 'Int' does not conform to the 'Actor' protocol}}
 }
+
+// -----------------------------------------------------------------------
+// Applying global actors to entities.
+// -----------------------------------------------------------------------
+@globalActor
+struct OtherGlobalActor {
+  static let shared = SomeActor()
+}
+
+@GA1 func f() {
+  @GA1 let x = 17 // expected-error{{local variable 'x' cannot have a global actor}}
+  _ = x
+}
+
+@GA1 struct X { }
+
+struct Y {
+  @GA1 subscript(i: Int) -> Int { i }
+}
+
+@GA1 extension Y { }
+
+@GA1 func g() { }
+
+class SomeClass {
+  @GA1 init() { }
+  @GA1 deinit { } // expected-error{{deinitializer cannot have a global actor}}
+}
+
+@GA1 typealias Integer = Int // expected-error{{type alias cannot have a global actor}}
+
+@GA1 actor class ActorInTooManyPlaces { } // expected-error{{actor class 'ActorInTooManyPlaces' cannot have a global actor}}
+
+@GA1 @OtherGlobalActor func twoGlobalActors() { } // expected-error{{declaration can not have multiple global actor attributes ('OtherGlobalActor' and 'GA1')}}