[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

@@ -8375,6 +8375,15 @@ ERROR(invalid_function_conversion_with_non_sendable,none,
 NOTE(type_does_not_conform_to_Sendable,none,
      "type %0 does not conform to 'Sendable' protocol", (Type))
 
+//===----------------------------------------------------------------------===//
+//                            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/KnownStdlibTypes.def

@@ -101,4 +101,6 @@ KNOWN_STDLIB_TYPE_DECL(Result, NominalTypeDecl, 2)
 
 KNOWN_STDLIB_TYPE_DECL(InlineArray, NominalTypeDecl, 2)
 
+KNOWN_STDLIB_TYPE_DECL(SwiftSetting, NominalTypeDecl, 0)
+
 #undef KNOWN_STDLIB_TYPE_DECL

include/swift/AST/MacroDefinition.h

@@ -18,7 +18,10 @@
 #ifndef SWIFT_AST_MACRO_DEFINITION_H
 #define SWIFT_AST_MACRO_DEFINITION_H
 
+#include "swift/AST/Identifier.h"
 #include "swift/Basic/StringExtras.h"
+
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/PointerUnion.h"
 
 namespace swift {
@@ -69,11 +72,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

@@ -476,6 +476,9 @@ EXPERIMENTAL_FEATURE(ExtensibleEnums, true)
 /// Allow isolated conformances.
 EXPERIMENTAL_FEATURE(IsolatedConformances, true)
 
+/// Allow SwiftSettings
+EXPERIMENTAL_FEATURE(SwiftSettings, false)
+
 /// Syntax sugar features for concurrency.
 EXPERIMENTAL_FEATURE(ConcurrencySyntaxSugar, true)
 

lib/AST/ASTPrinter.cpp

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

lib/AST/FeatureSet.cpp

@@ -26,7 +26,8 @@ using namespace swift;
 
 /// Does the interface of this declaration use a type for which the
 /// given predicate returns true?
-static bool usesTypeMatching(Decl *decl, llvm::function_ref<bool(Type)> fn) {
+static bool usesTypeMatching(const Decl *decl,
+                             llvm::function_ref<bool(Type)> fn) {
   if (auto value = dyn_cast<ValueDecl>(decl)) {
     if (Type type = value->getInterfaceType()) {
       return type.findIf(fn);
@@ -390,6 +391,24 @@ UNINTERESTING_FEATURE(ImportNonPublicCxxMembers)
 UNINTERESTING_FEATURE(CoroutineAccessorsUnwindOnCallerError)
 UNINTERESTING_FEATURE(CoroutineAccessorsAllocateInCallee)
 
+static bool usesFeatureSwiftSettings(const Decl *decl) {
+  // If we cannot find the struct SwiftSetting decl, then we could not have
+  // specified #SwiftSettings.
+  if (!decl->getASTContext().getSwiftSettingDecl())
+    return false;
+
+  if (auto *nom = dyn_cast<NominalTypeDecl>(decl))
+    return nom == decl->getASTContext().getSwiftSettingDecl();
+  if (auto *ext = dyn_cast<ExtensionDecl>(decl))
+    if (auto *nominal = ext->getExtendedNominal())
+      if (usesFeatureSwiftSettings(nominal))
+        return true;
+  return usesTypeMatching(decl, [&](Type type) -> bool {
+    return type->getCanonicalType() ==
+           decl->getASTContext().getSwiftSettingType()->getCanonicalType();
+  });
+}
+
 bool swift::usesFeatureIsolatedDeinit(const Decl *decl) {
   if (auto cd = dyn_cast<ClassDecl>(decl)) {
     return cd->getFormalAccess() == AccessLevel::Open &&