[concurrency] Add initial support for SwiftSettings to control defaultIsolation at the file level.

We introduce a new macro called #SwiftSettings that can be used in conjunction
with a new stdlib type called SwiftSetting to control the default isolation at
the file level. It overrides the current default isolation whether it is the
current nonisolated state or main actor (when -enable-experimental-feature
UnspecifiedMeansMainActorIsolated is set).

Author: gottesmm

include/swift/AST/ASTBridging.h

@@ -2882,6 +2882,8 @@ enum ENUM_EXTENSIBILITY_ATTR(open) BridgedMacroDefinitionKind : size_t {
   BridgedBuiltinExternalMacro,
   /// The builtin definition for the "isolation" macro.
   BridgedBuiltinIsolationMacro,
+  /// The builtin definition for the "SwiftSetting" macro.
+  BridgedBuiltinSwiftSettingsMacro,
 };
 
 struct BridgedASTType {

include/swift/AST/DiagnosticsSema.def

@@ -8344,6 +8344,15 @@ ERROR(attr_execution_type_attr_incompatible_with_isolated_any,none,
       "cannot use '@execution' together with @isolated(any)",
       ())
 
+//===----------------------------------------------------------------------===//
+//                            MARK: SwiftSettings
+//===----------------------------------------------------------------------===//
+
+ERROR(swift_settings_invalid_setting, none,
+      "Unrecognized setting passed to #SwiftSettings", ())
+
+ERROR(swift_settings_must_be_top_level, none,
+      "#SwiftSettings can only be invoked as a top level declaration", ())
 
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/FileUnit.h

@@ -39,7 +39,8 @@ class FileUnit : public DeclContext, public ASTAllocated<FileUnit> {
   friend class DirectOperatorLookupRequest;
   friend class DirectPrecedenceGroupLookupRequest;
 
-  // The pointer is FileUnit insted of SynthesizedFileUnit to break circularity.
+  /// The pointer is FileUnit insted of SynthesizedFileUnit to break
+  /// circularity.
   llvm::PointerIntPair<FileUnit *, 3, FileUnitKind> SynthesizedFileAndKind;
 
 protected:

include/swift/AST/MacroDefinition.h

@@ -69,11 +69,14 @@ struct ExternalMacroReference {
 };
 
 /// Describes the known kinds of builtin macros.
-enum class BuiltinMacroKind: uint8_t {
+enum class BuiltinMacroKind : uint8_t {
   /// #externalMacro, which references an external macro.
   ExternalMacro,
   /// #isolation, which produces the isolation of the current context
   IsolationMacro,
+  /// #SwiftSettings, which allows for the user to set a compiler setting at
+  /// the file level
+  SwiftSettingsMacro,
 };
 
 /// A single replacement

include/swift/AST/SourceFile.h

@@ -53,6 +53,15 @@ enum class RestrictedImportKind {
 /// Import that limits the access level of imported entities.
 using ImportAccessLevel = std::optional<AttributedImport<ImportedModule>>;
 
+/// Language options only for use with a specific SourceFile.
+///
+/// Vended by SourceFile::getLanguageOptions().
+struct SourceFileLangOptions {
+  /// If unset, no value was provided. If a Type, that type is the type of the
+  /// isolation. If set to an empty type, nil was specified explicitly.
+  std::optional<Type> defaultIsolation;
+};
+
 /// A file containing Swift source code.
 ///
 /// This is a .swift or .sil file (or a virtual file, such as the contents of
@@ -562,6 +571,9 @@ class SourceFile final : public FileUnit {
          ObjCSelector selector,
          SmallVectorImpl<AbstractFunctionDecl *> &results) const override;
 
+  /// File level language options.
+  SourceFileLangOptions getLanguageOptions() const;
+
 protected:
   virtual void
   lookupOperatorDirect(Identifier name, OperatorFixity fixity,

include/swift/AST/TypeCheckRequests.h

@@ -5228,6 +5228,25 @@ class SemanticAvailableAttrRequest
   void cacheResult(std::optional<SemanticAvailableAttr> value) const;
 };
 
+class SourceFileLangOptionsRequest
+    : public SimpleRequest<SourceFileLangOptionsRequest,
+                           SourceFileLangOptions(SourceFile *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  SourceFileLangOptions evaluate(Evaluator &evaluator,
+                                 SourceFile *sourceFile) const;
+
+public:
+  bool isCached() const { return true; }
+  std::optional<SourceFileLangOptions> getCachedResult() const;
+  void cacheResult(SourceFileLangOptions value) const;
+};
+
 #define SWIFT_TYPEID_ZONE TypeChecker
 #define SWIFT_TYPEID_HEADER "swift/AST/TypeCheckerTypeIDZone.def"
 #include "swift/Basic/DefineTypeIDZone.h"

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -616,3 +616,6 @@ SWIFT_REQUEST(TypeChecker, SemanticAvailableAttrRequest,
               std::optional<SemanticAvailableAttr>
               (const AvailableAttr *, const Decl *),
               SeparatelyCached, NoLocationInfo)
+
+SWIFT_REQUEST(TypeChecker, SourceFileLangOptionsRequest,
+              SourceFileLangOptions (SourceFile *), Cached, NoLocationInfo)

include/swift/Basic/Features.def

@@ -473,6 +473,9 @@ EXPERIMENTAL_FEATURE(ExtensibleEnums, true)
 /// Allow isolated conformances.
 EXPERIMENTAL_FEATURE(IsolatedConformances, true)
 
+/// Allow SwiftSettings
+EXPERIMENTAL_FEATURE(SwiftSettings, false)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

lib/AST/ASTPrinter.cpp

@@ -4722,6 +4722,9 @@ void PrintAST::visitMacroDecl(MacroDecl *decl) {
         case BuiltinMacroKind::IsolationMacro:
           Printer << "IsolationMacro";
           break;
+        case BuiltinMacroKind::SwiftSettingsMacro:
+          Printer << "SwiftSettingsMacro";
+          break;
         }
         break;
 

lib/AST/FeatureSet.cpp

@@ -384,6 +384,7 @@ UNINTERESTING_FEATURE(SafeInteropWrappers)
 UNINTERESTING_FEATURE(AssumeResilientCxxTypes)
 UNINTERESTING_FEATURE(CoroutineAccessorsUnwindOnCallerError)
 UNINTERESTING_FEATURE(CoroutineAccessorsAllocateInCallee)
+UNINTERESTING_FEATURE(SwiftSettings)
 
 bool swift::usesFeatureIsolatedDeinit(const Decl *decl) {
   if (auto cd = dyn_cast<ClassDecl>(decl)) {

lib/AST/Module.cpp

@@ -4167,3 +4167,121 @@ ModuleDecl::getAvailabilityDomainForIdentifier(Identifier identifier) const {
 
   return AvailabilityDomain::forCustom(iter->getSecond());
 }
+
+namespace {
+
+enum class SwiftSettingKind {
+  Unknown = 0,
+  DefaultIsolation,
+};
+
+struct SwiftSettingsWalker : ASTWalker {
+  ASTContext &ctx;
+  SourceFileLangOptions result;
+
+  SwiftSettingsWalker(ASTContext &ctx) : ctx(ctx), result() {}
+
+  CanType patternMatchDefaultIsolationMainActor(CallExpr *callExpr);
+
+  PreWalkResult<Expr *> walkToExprPre(Expr *expr) override {
+    if (auto *macroExpr = dyn_cast<MacroExpansionExpr>(expr);
+        macroExpr && macroExpr->getMacroRef()) {
+      if (auto *macro =
+              dyn_cast<MacroDecl>(macroExpr->getMacroRef().getDecl())) {
+        auto macroDef = macro->getDefinition();
+        if (macroDef.kind == MacroDefinition::Kind::Builtin &&
+            macroDef.getBuiltinKind() == BuiltinMacroKind::SwiftSettingsMacro) {
+          // Ok, we found our SwiftSettingsMacro. Lets start pattern matching.
+          for (auto arg : *macroExpr->getArgs()) {
+            // If we did not find any macro, we emit an unknown macro error.
+            bool foundMacro = false;
+
+            if (auto *callExpr = dyn_cast<CallExpr>(arg.getExpr())) {
+              if (auto *directCallee = dyn_cast<DotSyntaxCallExpr>(
+                      callExpr->getDirectCallee())) {
+                if (auto *funcDecl =
+                        dyn_cast<FuncDecl>(directCallee->getCalledValue())) {
+                  auto kind = llvm::StringSwitch<SwiftSettingKind>(
+                                  funcDecl->getBaseIdentifier().get())
+                                  .Case("defaultIsolation",
+                                        SwiftSettingKind::DefaultIsolation)
+                                  .Default(SwiftSettingKind::Unknown);
+                  switch (kind) {
+                  case SwiftSettingKind::Unknown:
+                    // Emit error.
+                    break;
+                  case SwiftSettingKind::DefaultIsolation:
+                    if (auto actor =
+                            patternMatchDefaultIsolationMainActor(callExpr)) {
+                      result.defaultIsolation = actor;
+                      foundMacro = true;
+                    }
+
+                    if (isa<NilLiteralExpr>(callExpr->getArgs()->getExpr(0))) {
+                      result.defaultIsolation = {Type()};
+                      foundMacro = true;
+                    }
+                  }
+                }
+              }
+            }
+
+            // If we did not pattern match a macro, emit an error.
+            if (!foundMacro) {
+              ctx.Diags.diagnose(arg.getStartLoc(),
+                                 diag::swift_settings_invalid_setting);
+            }
+          }
+        }
+      }
+    }
+    return Action::Continue(expr);
+  }
+};
+
+} // namespace
+
+CanType
+SwiftSettingsWalker::patternMatchDefaultIsolationMainActor(CallExpr *callExpr) {
+  auto *firstArg =
+      dyn_cast<InjectIntoOptionalExpr>(callExpr->getArgs()->getExpr(0));
+  if (!firstArg)
+    return CanType();
+
+  auto *erasureExpr = dyn_cast<ErasureExpr>(firstArg->getSubExpr());
+  if (!erasureExpr)
+    return CanType();
+
+  auto *selfExpr = dyn_cast<DotSelfExpr>(erasureExpr->getSubExpr());
+  if (!selfExpr)
+    return CanType();
+
+  auto *typeExpr = dyn_cast<TypeExpr>(selfExpr->getSubExpr());
+  if (!typeExpr)
+    return CanType();
+
+  auto instanceType = typeExpr->getInstanceType()->getCanonicalType();
+  if (instanceType != ctx.getMainActorType()->getCanonicalType())
+    return CanType();
+
+  return instanceType;
+}
+
+SourceFileLangOptions
+SourceFileLangOptionsRequest::evaluate(Evaluator &evaluator,
+                                       SourceFile *f) const {
+  SwiftSettingsWalker walker(f->getASTContext());
+
+  if (f->getASTContext().LangOpts.hasFeature(Feature::SwiftSettings)) {
+    for (auto *decl : f->getTopLevelDecls())
+      decl->walk(walker);
+  }
+
+  return walker.result;
+}
+
+SourceFileLangOptions SourceFile::getLanguageOptions() const {
+  auto &eval = getASTContext().evaluator;
+  auto *self = const_cast<SourceFile *>(this);
+  return evaluateOrDefault(eval, SourceFileLangOptionsRequest{self}, {});
+}

lib/ASTGen/Sources/MacroEvaluation/Macros.swift

@@ -244,6 +244,9 @@ func checkMacroDefinition(
         case "IsolationMacro":
           return Int(BridgedMacroDefinitionKind.builtinIsolationMacro.rawValue)
 
+        case "SwiftSettingsMacro":
+          return Int(BridgedMacroDefinitionKind.builtinSwiftSettingsMacro.rawValue)
+
         // These builtins don't exist, but are put into the standard library at
         // least for documentation purposes right now. Don't emit a warning for
         // them, but do fail operation.

lib/Sema/TypeCheckConcurrency.cpp

@@ -5585,28 +5585,59 @@ computeDefaultInferredActorIsolation(ValueDecl *value) {
 
   // If we are supposed to infer main actor isolation by default for entities
   // within our module, make our default isolation main actor.
-  if (ctx.LangOpts.hasFeature(Feature::UnspecifiedMeansMainActorIsolated) &&
-      value->getModuleContext() == ctx.MainModule) {
+  if (value->getModuleContext() == ctx.MainModule) {
+    auto globalActorHelper = [&](Type globalActor)
+        -> std::optional<std::tuple<InferredActorIsolation, ValueDecl *,
+                                    std::optional<ActorIsolation>>> {
+      // Default global actor isolation does not apply to any declarations
+      // within actors and distributed actors.
+      bool inActorContext = false;
+      auto *dc = value->getInnermostDeclContext();
+      while (dc && !inActorContext) {
+        if (auto *nominal = dc->getSelfNominalTypeDecl()) {
+          inActorContext = nominal->isAnyActor();
+        }
+        dc = dc->getParent();
+      }
 
-    // Default global actor isolation does not apply to any declarations
-    // within actors and distributed actors.
-    bool inActorContext = false;
-    auto *dc = value->getInnermostDeclContext();
-    while (dc && !inActorContext) {
-      if (auto *nominal = dc->getSelfNominalTypeDecl()) {
-        inActorContext = nominal->isAnyActor();
+      if (!inActorContext) {
+        // FIXME: deinit should be implicitly MainActor too.
+        if (isa<TypeDecl>(value) || isa<ExtensionDecl>(value) ||
+            isa<AbstractStorageDecl>(value) || isa<FuncDecl>(value) ||
+            isa<ConstructorDecl>(value)) {
+          return {
+              {{ActorIsolation::forGlobalActor(globalActor), {}}, nullptr, {}}};
+        }
       }
-      dc = dc->getParent();
-    }
 
-    if (!inActorContext) {
-      // FIXME: deinit should be implicitly MainActor too.
-      if (isa<TypeDecl>(value) || isa<ExtensionDecl>(value) ||
-          isa<AbstractStorageDecl>(value) || isa<FuncDecl>(value) ||
-          isa<ConstructorDecl>(value)) {
-        return {{ActorIsolation::forMainActor(ctx), {}}, nullptr, {}};
+      return {};
+    };
+
+    // Otherwise, see if we have one specified by our file unit.
+    bool ignoreUnspecifiedMeansMainActorIsolated = false;
+    if (ctx.LangOpts.hasFeature(Feature::SwiftSettings)) {
+      if (auto *sourceFile = value->getDeclContext()->getParentSourceFile()) {
+        auto options = sourceFile->getLanguageOptions();
+        if (auto isolation = options.defaultIsolation) {
+          if (*isolation) {
+            auto result = globalActorHelper(*options.defaultIsolation);
+            if (result)
+              return *result;
+          } else {
+            // If we found a nil type, then we know we should ignore unspecified
+            // means main actor isolated.
+            ignoreUnspecifiedMeansMainActorIsolated = true;
+          }
+        }
       }
     }
+
+    // If we are required to use main actor... just use that.
+    if (!ignoreUnspecifiedMeansMainActorIsolated &&
+        ctx.LangOpts.hasFeature(Feature::UnspecifiedMeansMainActorIsolated))
+      if (auto result =
+              globalActorHelper(ctx.getMainActorType()->mapTypeOutOfContext()))
+        return *result;
   }
 
   // If we have an async function... by default we inherit isolation.