Revert "[concurrency] Split out the default inferred actor isolation computation into a helper from ActorIsolationRequest::evaluate."

This reverts commit 5d6131e.

Author: gottesmm

lib/Sema/TypeCheckConcurrency.cpp

@@ -5529,82 +5529,6 @@ static void addAttributesForActorIsolation(ValueDecl *value,
     }
 }
 
-/// Determine the default isolation and isolation source for this declaration,
-/// which may still be overridden by other inference rules.
-static std::tuple<InferredActorIsolation, ValueDecl *,
-                  std::optional<ActorIsolation>>
-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.
-  if (ctx.LangOpts.hasFeature(Feature::UnspecifiedMeansMainActorIsolated) &&
-      value->getModuleContext() == ctx.MainModule) {
-
-    // 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();
-    }
-
-    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, {}};
-      }
-    }
-  }
-
-  // If we have an async function... by default we inherit isolation.
-  if (ctx.LangOpts.hasFeature(
-          Feature::NonIsolatedAsyncInheritsIsolationFromContext)) {
-    if (auto *func = dyn_cast<AbstractFunctionDecl>(value);
-        func && func->hasAsync() &&
-        func->getModuleContext() == ctx.MainModule) {
-      return {{ActorIsolation::forNonisolated(false /*is unsafe*/), {}},
-              nullptr,
-              {}};
-    }
-  }
-
-  if (auto func = dyn_cast<AbstractFunctionDecl>(value)) {
-    // A @Sendable function is assumed to be actor-independent.
-    if (func->isSendable()) {
-      return {
-          {ActorIsolation::forConcurrent(/*unsafe=*/false), {}}, nullptr, {}};
-    }
-  }
-
-  // When no other isolation applies, an actor's non-async init is independent
-  if (auto nominal = value->getDeclContext()->getSelfNominalTypeDecl())
-    if (nominal->isAnyActor())
-      if (auto ctor = dyn_cast<ConstructorDecl>(value))
-        if (!ctor->hasAsync())
-          return {{ActorIsolation::forConcurrent(/*unsafe=*/false), {}},
-                  nullptr,
-                  {}};
-
-  // Look for and remember the overridden declaration's isolation.
-  if (auto *overriddenValue = value->getOverriddenDeclOrSuperDeinit()) {
-    // Use the overridden decl's iso as the default isolation for this decl.
-    auto isolation = getOverriddenIsolationFor(value);
-    return {{isolation,
-             IsolationSource(overriddenValue, IsolationSource::Override)},
-            overriddenValue,
-            isolation};
-  }
-
-  // We did not find anything special, return unspecified.
-  return {{ActorIsolation::forUnspecified(), {}}, nullptr, {}};
-}
-
 InferredActorIsolation ActorIsolationRequest::evaluate(
     Evaluator &evaluator, ValueDecl *value) const {
   // If this declaration has actor-isolated "self", it's isolated to that
@@ -5648,7 +5572,7 @@ InferredActorIsolation ActorIsolationRequest::evaluate(
     value->getAttrs().add(preconcurrency);
   }
 
-  if (auto *fd = dyn_cast<FuncDecl>(value)) {
+  if (FuncDecl *fd = dyn_cast<FuncDecl>(value)) {
     // Main.main() and Main.$main are implicitly MainActor-protected.
     // Any other isolation is an error.
     std::optional<ActorIsolation> mainIsolation =
@@ -5681,11 +5605,74 @@ InferredActorIsolation ActorIsolationRequest::evaluate(
             IsolationSource(/*source*/ nullptr, IsolationSource::Explicit)};
   }
 
-  InferredActorIsolation defaultIsolation;
-  ValueDecl *overriddenValue;
-  std::optional<ActorIsolation> overriddenIsolation;
-  std::tie(defaultIsolation, overriddenValue, overriddenIsolation) =
-      computeDefaultInferredActorIsolation(value);
+  // Determine the default isolation for this declaration, which may still be
+  // overridden by other inference rules.
+  ActorIsolation defaultIsolation = ActorIsolation::forUnspecified();
+  IsolationSource defaultIsolationSource;
+
+  // 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) {
+
+    // 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();
+    }
+
+    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)) {
+        defaultIsolation = ActorIsolation::forMainActor(ctx);
+      }
+    }
+  }
+
+  // If we have an async function... by default we inherit isolation.
+  if (ctx.LangOpts.hasFeature(
+          Feature::NonIsolatedAsyncInheritsIsolationFromContext)) {
+    if (auto *func = dyn_cast<AbstractFunctionDecl>(value);
+        func && func->hasAsync() &&
+        func->getModuleContext() == ctx.MainModule) {
+      defaultIsolation = ActorIsolation::forNonisolated(false /*is unsafe*/);
+    }
+  }
+
+  if (auto func = dyn_cast<AbstractFunctionDecl>(value)) {
+    // A @Sendable function is assumed to be actor-independent.
+    if (func->isSendable()) {
+      defaultIsolation = ActorIsolation::forConcurrent(/*unsafe=*/false);
+    }
+  }
+
+  // When no other isolation applies, an actor's non-async init is independent
+  if (auto nominal = value->getDeclContext()->getSelfNominalTypeDecl())
+    if (nominal->isAnyActor())
+      if (auto ctor = dyn_cast<ConstructorDecl>(value))
+        if (!ctor->hasAsync())
+          defaultIsolation = ActorIsolation::forConcurrent(/*unsafe=*/false);
+
+  // Look for and remember the overridden declaration's isolation.
+  std::optional<ActorIsolation> overriddenIso;
+  ValueDecl *overriddenValue = value->getOverriddenDeclOrSuperDeinit();
+  if (overriddenValue) {
+    // use the overridden decl's iso as the default isolation for this decl.
+    defaultIsolation = getOverriddenIsolationFor(value);
+    defaultIsolationSource =
+        IsolationSource(overriddenValue, IsolationSource::Override);
+    overriddenIso = defaultIsolation;
+  }
+
+  // NOTE: After this point, the default has been set. Only touch the default
+  // isolation above this point since code below assumes it is now constant.
 
   // Function used when returning an inferred isolation.
   auto inferredIsolation = [&](ActorIsolation inferred,
@@ -5696,17 +5683,16 @@ InferredActorIsolation ActorIsolationRequest::evaluate(
       // if the inferred isolation is not valid, then carry-over the overridden
       // declaration's isolation as this decl's inferred isolation.
       switch (validOverrideIsolation(value, inferred, overriddenValue,
-                                     *overriddenIsolation)) {
+                                     *overriddenIso)) {
       case OverrideIsolationResult::Allowed:
       case OverrideIsolationResult::Sendable:
         break;
 
       case OverrideIsolationResult::Disallowed:
-        if (overriddenValue->hasClangNode() &&
-            overriddenIsolation->isUnspecified()) {
-          inferred = overriddenIsolation->withPreconcurrency(true);
+        if (overriddenValue->hasClangNode() && overriddenIso->isUnspecified()) {
+          inferred = overriddenIso->withPreconcurrency(true);
         } else {
-          inferred = *overriddenIsolation;
+          inferred = *overriddenIso;
         }
         break;
       }
@@ -5965,7 +5951,7 @@ InferredActorIsolation ActorIsolationRequest::evaluate(
   }
 
   // Default isolation for this member.
-  return defaultIsolation;
+  return {defaultIsolation, defaultIsolationSource};
 }
 
 bool HasIsolatedSelfRequest::evaluate(