[Concurrency] Simplify the logic in computeDefaultInferredActorIsolation.

Author: hborla

include/swift/AST/SourceFile.h

@@ -20,6 +20,7 @@
 #include "swift/AST/Import.h"
 #include "swift/AST/SynthesizedFileUnit.h"
 #include "swift/Basic/Debug.h"
+#include "swift/Basic/LangOptions.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetVector.h"
@@ -57,9 +58,9 @@ using ImportAccessLevel = std::optional<AttributedImport<ImportedModule>>;
 ///
 /// 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;
+  /// The default actor isolation to infer on declarations
+  /// within the source file.
+  std::optional<DefaultIsolation> defaultIsolation;
 };
 
 /// A file containing Swift source code.

lib/AST/Module.cpp

@@ -4218,12 +4218,11 @@ struct SwiftSettingsWalker : ASTWalker {
   }
 
   /// Given a specific CallExpr, pattern matches the CallExpr's first argument
-  /// to validate it is MainActor.self. Returns CanType() if the CallExpr has
-  /// multiple parameters or if its first parameter is not a MainActor.self.
+  /// to validate it is MainActor.self.
   ///
-  /// This is used when pattern matching against
-  /// .defaultIsolation(MainActor.self).
-  CanType patternMatchDefaultIsolationMainActor(CallExpr *callExpr);
+  /// \returns \c true if the call has one argument that matches
+  /// \c MainActor.self, and \c false otherwise.
+  bool patternMatchDefaultIsolationMainActor(CallExpr *callExpr);
 
   /// Validates that macroExpr is a well formed "SwiftSettings" macro. Returns
   /// true if we can process it and false otherwise.
@@ -4289,16 +4288,16 @@ struct SwiftSettingsWalker : ASTWalker {
         }
 
         // Otherwise, set things up appropriately.
-        if (auto actor = patternMatchDefaultIsolationMainActor(callExpr)) {
+        if (patternMatchDefaultIsolationMainActor(callExpr)) {
           expr = callExpr;
-          result.defaultIsolation = actor;
+          result.defaultIsolation = DefaultIsolation::MainActor;
           foundValidArg = true;
           continue;
         }
 
         if (isa<NilLiteralExpr>(callExpr->getArgs()->getExpr(0))) {
           expr = callExpr;
-          result.defaultIsolation = {Type()};
+          result.defaultIsolation = DefaultIsolation::Nonisolated;
           foundValidArg = true;
           continue;
         }
@@ -4400,18 +4399,18 @@ SwiftSettingsWalker::getSwiftSettingArgDecl(Argument arg) {
   return {{callExpr, f}};
 }
 
-CanType
+bool
 SwiftSettingsWalker::patternMatchDefaultIsolationMainActor(CallExpr *callExpr) {
   // Grab the dot self expr.
   auto *selfExpr = dyn_cast<DotSelfExpr>(callExpr->getArgs()->getExpr(0));
   if (!selfExpr)
-    return CanType();
+    return false;
 
   // Then validate we have something that is MainActor.
   auto *declRefExpr = dyn_cast<UnresolvedDeclRefExpr>(selfExpr->getSubExpr());
   if (!declRefExpr ||
       !declRefExpr->getName().getBaseName().getIdentifier().is("MainActor"))
-    return CanType();
+    return false;
 
   // Then use unqualified lookup descriptor to find our MainActor.
   UnqualifiedLookupDescriptor lookupDesc{
@@ -4420,20 +4419,20 @@ SwiftSettingsWalker::patternMatchDefaultIsolationMainActor(CallExpr *callExpr) {
   auto lookup = evaluateOrDefault(ctx.evaluator,
                                   UnqualifiedLookupRequest{lookupDesc}, {});
   if (lookup.allResults().empty())
-    return CanType();
+    return false;
 
   // Then grab our nominal type decl and make sure it is from the concurrency
   // module.
   auto *nomDecl =
       dyn_cast<NominalTypeDecl>(lookup.allResults().front().getValueDecl());
   if (!nomDecl)
-    return CanType();
+    return false;
   auto *nomDeclDC = nomDecl->getDeclContext();
   auto *nomDeclModule = nomDecl->getParentModule();
   if (!nomDeclDC->isModuleScopeContext() || !nomDeclModule->isConcurrencyModule())
-    return CanType();
+    return false;
 
-  return nomDecl->getDeclaredType()->getCanonicalType();
+  return true;
 }
 
 SourceFileLangOptions

lib/Sema/TypeCheckConcurrency.cpp

@@ -5753,12 +5753,21 @@ static std::tuple<InferredActorIsolation, ValueDecl *,
 computeDefaultInferredActorIsolation(ValueDecl *value) {
   auto &ctx = value->getASTContext();
 
-  // If we are supposed to infer main actor isolation by default for entities
-  // within our module, make our default isolation main actor.
+  // Determine whether default isolation is set to MainActor, either for
+  // the entire module or in this specific file.
   if (value->getModuleContext() == ctx.MainModule) {
-    auto globalActorHelper = [&](Type globalActor)
-        -> std::optional<std::tuple<InferredActorIsolation, ValueDecl *,
-                                    std::optional<ActorIsolation>>> {
+    // 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;
+        }
+      }
+    }
+
+    if (defaultIsolation == DefaultIsolation::MainActor) {
       // Default global actor isolation does not apply to any declarations
       // within actors and distributed actors.
       bool inActorContext = false;
@@ -5770,44 +5779,18 @@ 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) ||
             isa<AbstractStorageDecl>(value) || isa<FuncDecl>(value) ||
             isa<ConstructorDecl>(value)) {
-          return {
-              {{ActorIsolation::forGlobalActor(globalActor), {}}, 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;
-          }
+          auto mainActorIsolation =
+              ActorIsolation::forGlobalActor(mainActorType);
+          return {{mainActorIsolation, {}}, nullptr, {}};
         }
       }
     }
-
-    // If we are required to use main actor... just use that.
-    if (!ignoreUnspecifiedMeansMainActorIsolated &&
-        ctx.LangOpts.DefaultIsolationBehavior == DefaultIsolation::MainActor)
-      if (auto result =
-              globalActorHelper(ctx.getMainActorType()->mapTypeOutOfContext()))
-        return *result;
   }
 
   // If we have an async function... by default we inherit isolation.