[Concurrency] Implement an experimental feature for setting default

actor isolation per file using a typealias.

This feature is gated behind the `DefaultIsolationTypealias` experimental
feature flag.

Author: hborla

include/swift/AST/DiagnosticsSema.def

@@ -6029,6 +6029,13 @@ ERROR(global_actor_not_usable_from_inline,none,
 NOTE(move_global_actor_attr_to_storage_decl,none,
      "move global actor attribute to %kind0", (const ValueDecl *))
 
+ERROR(default_isolation_internal,none,
+      "default isolation can only be set per file",
+      ())
+ERROR(default_isolation_custom,none,
+      "default isolation can only be set to 'MainActor' or 'nonisolated'",
+      ())
+
 ERROR(actor_isolation_multiple_attr_2,none,
       "%kind0 has multiple actor-isolation attributes (%1 and %2)",
       (const Decl *, DeclAttribute, DeclAttribute))

include/swift/AST/KnownIdentifiers.def

@@ -74,6 +74,7 @@ IDENTIFIER(decodeIfPresent)
 IDENTIFIER(Decoder)
 IDENTIFIER(decoder)
 IDENTIFIER(DefaultDistributedActorSystem)
+IDENTIFIER(DefaultIsolation)
 IDENTIFIER_(Differentiation)
 IDENTIFIER_WITH_NAME(PatternMatchVar, "$match")
 IDENTIFIER(dynamicallyCall)

include/swift/AST/KnownSDKTypes.def

@@ -40,6 +40,7 @@ KNOWN_SDK_TYPE_DECL(ObjectiveC, ObjCBool, StructDecl, 0)
 KNOWN_SDK_TYPE_DECL(Concurrency, CheckedContinuation, NominalTypeDecl, 2)
 KNOWN_SDK_TYPE_DECL(Concurrency, UnsafeContinuation, NominalTypeDecl, 2)
 KNOWN_SDK_TYPE_DECL(Concurrency, MainActor, NominalTypeDecl, 0)
+KNOWN_SDK_TYPE_DECL(Concurrency, nonisolated, NominalTypeDecl, 0)
 KNOWN_SDK_TYPE_DECL(Concurrency, Job, StructDecl, 0) // legacy type; prefer ExecutorJob
 KNOWN_SDK_TYPE_DECL(Concurrency, ExecutorJob, StructDecl, 0)
 KNOWN_SDK_TYPE_DECL(Concurrency, UnownedJob, StructDecl, 0)

include/swift/AST/TypeCheckRequests.h

@@ -33,6 +33,7 @@
 #include "swift/AST/SourceFile.h"
 #include "swift/AST/Type.h"
 #include "swift/AST/TypeResolutionStage.h"
+#include "swift/Basic/LangOptions.h"
 #include "swift/Basic/Statistic.h"
 #include "swift/Basic/TaggedUnion.h"
 #include "swift/Basic/TypeID.h"
@@ -1621,6 +1622,25 @@ class ActorIsolationRequest :
   bool isCached() const { return true; }
 };
 
+/// Determine the default actor isolation for the given source file.
+class DefaultActorIsolationRequest :
+    public SimpleRequest<DefaultActorIsolationRequest,
+                         std::optional<DefaultIsolation>(SourceFile *),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  std::optional<DefaultIsolation>
+  evaluate(Evaluator &evaluator, SourceFile *file) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+};
+
 /// Determine whether the given function should have an isolated 'self'.
 class HasIsolatedSelfRequest :
     public SimpleRequest<HasIsolatedSelfRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -182,6 +182,9 @@ SWIFT_REQUEST(TypeChecker, GlobalActorAttributeRequest,
 SWIFT_REQUEST(TypeChecker, ActorIsolationRequest,
               ActorIsolationState(ValueDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, DefaultActorIsolationRequest,
+              std::optional<DefaultIsolation>(SourceFile *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, HasIsolatedSelfRequest,
               bool(ValueDecl *),
               Uncached, NoLocationInfo)

include/swift/Basic/Features.def

@@ -501,6 +501,9 @@ EXPERIMENTAL_FEATURE(InferIsolatedConformances, true)
 /// Allow SwiftSettings
 EXPERIMENTAL_FEATURE(SwiftSettings, false)
 
+/// Enable setting default isolation per file via typealias.
+EXPERIMENTAL_FEATURE(DefaultIsolationTypealias, true)
+
 /// Syntax sugar features for concurrency.
 EXPERIMENTAL_FEATURE(ConcurrencySyntaxSugar, true)
 

lib/AST/FeatureSet.cpp

@@ -405,6 +405,7 @@ UNINTERESTING_FEATURE(ImportNonPublicCxxMembers)
 UNINTERESTING_FEATURE(CXXForeignReferenceTypeInitializers)
 UNINTERESTING_FEATURE(CoroutineAccessorsUnwindOnCallerError)
 UNINTERESTING_FEATURE(AllowRuntimeSymbolDeclarations)
+UNINTERESTING_FEATURE(DefaultIsolationTypealias)
 
 static bool usesFeatureSwiftSettings(const Decl *decl) {
   // We just need to guard `#SwiftSettings`.

lib/Sema/TypeCheckConcurrency.cpp

@@ -5732,6 +5732,73 @@ static void addAttributesForActorIsolation(ValueDecl *value,
     }
 }
 
+std::optional<DefaultIsolation>
+DefaultActorIsolationRequest::evaluate(Evaluator &evaluator,
+                                       SourceFile *sourceFile) const {
+  auto &ctx = sourceFile->getASTContext();
+
+  auto defaultModuleIsolaton = ctx.LangOpts.DefaultIsolationBehavior;
+  auto mainActorType = ctx.getMainActorType();
+  if (!mainActorType)
+    return defaultModuleIsolaton;
+
+  if (ctx.LangOpts.hasFeature(Feature::SwiftSettings)) {
+    auto options = sourceFile->getLanguageOptions();
+    if (auto isolation = options.defaultIsolation) {
+      return *isolation;
+    }
+  }
+
+  if (ctx.LangOpts.hasFeature(Feature::DefaultIsolationTypealias)) {
+    auto nonisolatedType = ctx.getnonisolatedType();
+
+    auto decls = sourceFile->getTopLevelDecls();
+    if (decls.empty())
+      return defaultModuleIsolaton;
+
+    auto locInFile = decls.front()->getStartLoc();
+    auto defaultIsolationResult = TypeChecker::lookupUnqualified(
+      sourceFile->getModuleScopeContext(),
+      DeclNameRef(ctx.Id_DefaultIsolation),
+      locInFile);
+    for (auto found : defaultIsolationResult) {
+      auto *decl = found.getValueDecl();
+      if (!decl)
+        continue;
+
+      auto *typealias = dyn_cast<TypeAliasDecl>(decl);
+      if (!typealias ||
+          !typealias->getDeclContext()->isModuleScopeContext())
+        continue;
+
+      // We have a top-level 'DefaultIsolation' typealias. We can assume
+      // it's the only one, because multiple top-level typealiases with
+      // the same name is a redeclaration error, and default isolation
+      // cannot be set by an imported library.
+
+      // The typealias can only be used to set default isolation per file.
+      if (typealias->getFormalAccess() >= AccessLevel::Internal) {
+        typealias->diagnose(diag::default_isolation_internal);
+        break;
+      }
+
+      auto type = typealias->getUnderlyingType();
+      if (type->isEqual(mainActorType))
+        return DefaultIsolation::MainActor;
+
+      if (type->isEqual(nonisolatedType))
+        return DefaultIsolation::Nonisolated;
+
+      // The underlying type of the typealias must either be 'MainActor'
+      // or 'nonisolated'.
+      typealias->diagnose(diag::default_isolation_custom);
+      break;
+    }
+  }
+
+  return defaultModuleIsolaton;
+}
+
 /// Determine the default isolation and isolation source for this declaration,
 /// which may still be overridden by other inference rules.
 static std::tuple<InferredActorIsolation, ValueDecl *,
@@ -5741,17 +5808,13 @@ computeDefaultInferredActorIsolation(ValueDecl *value) {
 
   // Determine whether default isolation is set to MainActor, either for
   // the entire module or in this specific file.
-  if (value->getModuleContext() == ctx.MainModule) {
+  auto mainActorType = ctx.getMainActorType();
+  if (mainActorType && value->getModuleContext() == ctx.MainModule) {
     // See if we have one specified by our file unit.
-    auto defaultIsolation = ctx.LangOpts.DefaultIsolationBehavior;
-    if (ctx.LangOpts.hasFeature(Feature::SwiftSettings)) {
-      if (auto *sourceFile = value->getDeclContext()->getParentSourceFile()) {
-        auto options = sourceFile->getLanguageOptions();
-        if (auto isolation = options.defaultIsolation) {
-          defaultIsolation = *isolation;
-        }
-      }
-    }
+    auto *sourceFile = value->getDeclContext()->getParentSourceFile();
+    auto defaultIsolation = evaluateOrDefault(
+        ctx.evaluator, DefaultActorIsolationRequest{sourceFile},
+        ctx.LangOpts.DefaultIsolationBehavior);
 
     if (defaultIsolation == DefaultIsolation::MainActor) {
       // Default global actor isolation does not apply to any declarations
@@ -5765,7 +5828,6 @@ computeDefaultInferredActorIsolation(ValueDecl *value) {
         dc = dc->getParent();
       }
 
-      auto mainActorType = ctx.getMainActorType()->mapTypeOutOfContext();
       if (!inActorContext) {
         // FIXME: deinit should be implicitly MainActor too.
         if (isa<TypeDecl>(value) || isa<ExtensionDecl>(value) ||

stdlib/public/Concurrency/Actor.swift

@@ -140,3 +140,6 @@ public func extractIsolation<each Arg, Result>(
   return Builtin.extractFunctionIsolation(fn)
 }
 #endif
+
+@available(SwiftStdlib 6.2, *)
+public struct nonisolated {}

test/Concurrency/default_isolation.swift

@@ -0,0 +1,44 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+// REQUIRES: concurrency
+// REQUIRES: swift_feature_DefaultIsolationTypealias
+
+// RUN: %target-swift-frontend -enable-experimental-feature DefaultIsolationTypealias -emit-sil -swift-version 6 -disable-availability-checking %t/main.swift %t/concurrent.swift | %FileCheck %s
+
+//--- main.swift
+
+private typealias DefaultIsolation = MainActor
+
+class C {
+  // CHECK: // static C.shared.getter
+  // CHECK-NEXT: // Isolation: global_actor. type: MainActor
+  static let shared = C()
+
+  // CHECK: // C.init()
+  // CHECK-NEXT: // Isolation: global_actor. type: MainActor
+  init() {}
+}
+
+// CHECK: // test()
+// CHECK-NEXT: // Isolation: global_actor. type: MainActor
+func test() {
+  // CHECK: // closure #1 in test()
+  // CHECK-NEXT: // Isolation: nonisolated
+  Task.detached {
+    let s = S(value: 0)
+  }
+}
+
+
+//--- concurrent.swift
+
+private typealias DefaultIsolation = nonisolated
+
+// CHECK: // S.init(value:)
+// CHECK-NEXT: // Isolation: unspecified
+struct S {
+  // CHECK: // S.value.getter
+  // CHECK-NEXT: // Isolation: unspecified
+  var value: Int
+}