[Concurrency] Add inferred actor-isolation attributes.

When we infer an actor-isolation attribute on a declaration, add an
implicit attribute that will show up in the printed interface and get
serialized.

... and clean up the type resolution logic for global actor attributes
to make it use CustomAttrTypeRequest, so the result gets appropriately
cached in CustomAttr for serialization.

Author: DougGregor

include/swift/AST/TypeCheckRequests.h

@@ -2696,6 +2696,10 @@ enum class CustomAttrTypeKind {
   /// Property delegates have some funky rules, like allowing
   /// unbound generic types.
   PropertyDelegate,
+
+  /// Global actors are represented as custom type attributes. They don't
+  /// have any particularly interesting semantics.
+  GlobalActor,
 };
 
 void simple_display(llvm::raw_ostream &out, CustomAttrTypeKind value);

lib/AST/TypeCheckRequests.cpp

@@ -1430,6 +1430,10 @@ void swift::simple_display(llvm::raw_ostream &out, CustomAttrTypeKind value) {
   case CustomAttrTypeKind::PropertyDelegate:
     out << "property-delegate";
     return;
+
+  case CustomAttrTypeKind::GlobalActor:
+    out << "global-actor";
+    return;
   }
   llvm_unreachable("bad kind");
 }

lib/Sema/TypeCheckConcurrency.cpp

@@ -1031,15 +1031,18 @@ static Optional<ActorIsolation> getIsolationFromAttributes(Decl *decl) {
   // If the declaration is marked with a global actor, report it as being
   // part of that global actor.
   if (globalActorAttr) {
-    TypeResolutionOptions options(TypeResolverContext::None);
-    TypeResolution resolver = TypeResolution::forInterface(
-        decl->getInnermostDeclContext(), options, nullptr);
-    Type globalActorType = resolver.resolveType(
-        globalActorAttr->first->getTypeRepr(), nullptr);
+    ASTContext &ctx = decl->getASTContext();
+    auto dc = decl->getInnermostDeclContext();
+    Type globalActorType = evaluateOrDefault(
+        ctx.evaluator,
+        CustomAttrTypeRequest{
+          globalActorAttr->first, dc, CustomAttrTypeKind::GlobalActor},
+        Type());
     if (!globalActorType || globalActorType->hasError())
       return ActorIsolation::forUnspecified();
 
-    return ActorIsolation::forGlobalActor(globalActorType);
+    return ActorIsolation::forGlobalActor(
+        globalActorType->mapTypeOutOfContext());
   }
 
   llvm_unreachable("Forgot about an attribute?");
@@ -1158,6 +1161,27 @@ ActorIsolation ActorIsolationRequest::evaluate(
 
   // Function used when returning an inferred isolation.
   auto inferredIsolation = [&](ActorIsolation inferred) {
+    // Add an implicit attribute to capture the actor isolation that was
+    // inferred, so that (e.g.) it will be printed and serialized.
+    ASTContext &ctx = value->getASTContext();
+    switch (inferred) {
+    case ActorIsolation::Independent:
+      value->getAttrs().add(new (ctx) ActorIndependentAttr(true));
+      break;
+
+    case ActorIsolation::GlobalActor: {
+      auto typeExpr = TypeExpr::createImplicit(inferred.getGlobalActor(), ctx);
+      auto attr = CustomAttr::create(
+          ctx, SourceLoc(), typeExpr, /*implicit=*/true);
+      value->getAttrs().add(attr);
+      break;
+    }
+
+    case ActorIsolation::ActorInstance:
+    case ActorIsolation::Unspecified:
+      // Nothing to do.
+      break;
+    }
     return inferred;
   };
 

test/ModuleInterface/actor_isolation.swift

@@ -0,0 +1,44 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -o %t/Test.swiftmodule -emit-module-interface-path %t/Test.swiftinterface -module-name Test -enable-experimental-concurrency %s
+// RUN: %FileCheck %s --check-prefix FROMSOURCE --check-prefix CHECK < %t/Test.swiftinterface
+// RUN: %target-swift-frontend -emit-module -o /dev/null -merge-modules %t/Test.swiftmodule -disable-objc-attr-requires-foundation-module -emit-module-interface-path %t/TestFromModule.swiftinterface -module-name Test -enable-experimental-concurrency
+// RUN: %FileCheck %s --check-prefix FROMMODULE --check-prefix CHECK < %t/TestFromModule.swiftinterface
+
+// REQUIRES: concurrency
+import _Concurrency
+
+// CHECK: actor public class SomeActor
+public actor class SomeActor {
+  @actorIndependent func maine() { }
+}
+
+// CHECK: @globalActor public struct SomeGlobalActor
+@globalActor
+public struct SomeGlobalActor {
+  public static let shared = SomeActor()
+}
+
+// CHECK: @{{(Test.)?}}SomeGlobalActor public protocol P1
+// CHECK-NEXT: @{{(Test.)?}}SomeGlobalActor func method()
+@SomeGlobalActor
+public protocol P1 {
+  func method()
+}
+
+// CHECK: class C1
+// CHECK-NEXT: @{{(Test.)?}}SomeGlobalActor public func method()
+public class C1: P1 {
+  public func method() { }
+}
+
+@SomeGlobalActor
+public class C2 { }
+
+// CHECK: @{{(Test.)?}}SomeGlobalActor public class C2
+public class C3: C2 { }
+
+// CHECK: actor public class SomeSubActor
+// CHECK-NEXT: @actorIndependent public func maine()
+public actor class SomeSubActor: SomeActor {
+  override public func maine() { }
+}