Merge pull request #73104 from xedin/promote-dynamic-actor-isolation-to-upcoming-feature-6.0

[6.0][SE-0423] Promote `DynamicActorIsolation` to an upcoming feature and add a way to disable checks

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -5690,8 +5690,6 @@ ERROR(preconcurrency_not_inheritance_clause,none,
       "'preconcurrency' attribute only applies in inheritance clauses", ())
 ERROR(preconcurrency_not_existential,none,
       "'preconcurrency' attribute cannot apply to non-protocol type %0", (Type))
-ERROR(preconcurrency_attr_disabled,none,
-      "attribute requires '-enable-experimental-feature DynamicActorIsolation'", ())
 
 ERROR(redundant_any_in_existential,none,
        "redundant 'any' in type %0",

include/swift/Basic/Features.def

@@ -190,6 +190,7 @@ UPCOMING_FEATURE(GlobalConcurrency, 412, 6)
 UPCOMING_FEATURE(InferSendableFromCaptures, 418, 6)
 UPCOMING_FEATURE(ImplicitOpenExistentials, 352, 6)
 UPCOMING_FEATURE(RegionBasedIsolation, 414, 6)
+UPCOMING_FEATURE(DynamicActorIsolation, 423, 6)
 UPCOMING_FEATURE(MoveOnlyPartialConsumption, 429, 6)
 
 // Swift 7
@@ -353,11 +354,6 @@ EXPERIMENTAL_FEATURE(GroupActorErrors, true)
 // Allow for the 'transferring' keyword to be applied to arguments and results.
 EXPERIMENTAL_FEATURE(TransferringArgsAndResults, true)
 
-// Enable `@preconcurrency` attribute on protocol conformances and runtime checks
-// of actor isolation in @obj thunks and arguments of APIs that haven't yet adopted
-// strict concurrency checking.
-EXPERIMENTAL_FEATURE(DynamicActorIsolation, false)
-
 // Allow for `switch` of noncopyable values to be borrowing or consuming.
 EXPERIMENTAL_FEATURE(BorrowingSwitch, true)
 

include/swift/Basic/LangOptions.h

@@ -593,6 +593,9 @@ namespace swift {
     /// type-checking, SIL verification, and IR emission,
     bool BypassResilienceChecks = false;
 
+    /// Disables `DynamicActorIsolation` feature.
+    bool DisableDynamicActorIsolation = false;
+
     /// Whether or not to allow experimental features that are only available
     /// in "production".
 #ifdef NDEBUG
@@ -605,6 +608,11 @@ namespace swift {
       return ActiveConcurrencyModel == ConcurrencyModel::TaskToThread;
     }
 
+    bool isDynamicActorIsolationCheckingEnabled() const {
+      return !DisableDynamicActorIsolation &&
+             hasFeature(Feature::DynamicActorIsolation);
+    }
+
     LangOptions();
 
     /// Sets the target we are building for and updates platform conditions

include/swift/Option/Options.td

@@ -817,6 +817,11 @@ def disable_actor_data_race_checks :
   Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
   HelpText<"Disable runtime checks for actor data races">;
 
+def disable_dynamic_actor_isolation :
+  Flag<["-"], "disable-dynamic-actor-isolation">,
+  Flags<[FrontendOption, DoesNotAffectIncrementalBuild]>,
+  HelpText<"Disable dynamic actor isolation checks">;
+
 def enable_bare_slash_regex : Flag<["-"], "enable-bare-slash-regex">,
   Flags<[FrontendOption, ModuleInterfaceOption]>,
   HelpText<"Enable the use of forward slash regular-expression literal syntax">;

lib/AST/FeatureSet.cpp

@@ -643,29 +643,7 @@ static bool usesFeatureTransferringArgsAndResults(Decl *decl) {
   return false;
 }
 
-static bool usesFeatureDynamicActorIsolation(Decl *decl) {
-  auto usesPreconcurrencyConformance = [&](const InheritedTypes &inherited) {
-    return llvm::any_of(
-        inherited.getEntries(),
-        [](const InheritedEntry &entry) { return entry.isPreconcurrency(); });
-  };
-
-  if (auto *T = dyn_cast<TypeDecl>(decl))
-    return usesPreconcurrencyConformance(T->getInherited());
-
-  if (auto *E = dyn_cast<ExtensionDecl>(decl)) {
-    // If type has `@preconcurrency` conformance(s) all of its
-    // extensions have to be guarded by the flag too.
-    if (auto *T = dyn_cast<TypeDecl>(E->getExtendedNominal())) {
-      if (usesPreconcurrencyConformance(T->getInherited()))
-        return true;
-    }
-
-    return usesPreconcurrencyConformance(E->getInherited());
-  }
-
-  return false;
-}
+UNINTERESTING_FEATURE(DynamicActorIsolation)
 
 UNINTERESTING_FEATURE(BorrowingSwitch)
 

lib/Driver/ToolChains.cpp

@@ -264,6 +264,7 @@ void ToolChain::addCommonFrontendArgs(const OutputInfo &OI,
   inputArgs.AddLastArg(arguments,
                        options::OPT_enable_actor_data_race_checks,
                        options::OPT_disable_actor_data_race_checks);
+  inputArgs.AddLastArg(arguments, options::OPT_disable_dynamic_actor_isolation);
   inputArgs.AddLastArg(arguments, options::OPT_warn_concurrency);
   inputArgs.AddLastArg(arguments, options::OPT_strict_concurrency);
   inputArgs.AddAllArgs(arguments, options::OPT_enable_experimental_feature);

lib/Frontend/CompilerInvocation.cpp

@@ -1517,6 +1517,9 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   if (Opts.hasFeature(Feature::DebugDescriptionMacro))
     Opts.enableFeature(Feature::SymbolLinkageMarkers);
 
+  Opts.DisableDynamicActorIsolation |=
+      Args.hasArg(OPT_disable_dynamic_actor_isolation);
+
 #if SWIFT_ENABLE_EXPERIMENTAL_PARSER_VALIDATION
   /// Enable round trip parsing via the new swift parser unless it is disabled
   /// explicitly. The new Swift parser can have mismatches with C++ parser -

lib/SILGen/SILGenBridging.cpp

@@ -1593,14 +1593,12 @@ void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
   loc.markAutoGenerated();
   Scope scope(Cleanups, CleanupLocation(loc));
 
-  bool emitExecutorPrecondition =
-      getASTContext().LangOpts.hasFeature(Feature::DynamicActorIsolation);
-
   std::optional<ActorIsolation> isolation;
   if (F.isAsync()) {
     if (thunk.hasDecl())
       isolation = getActorIsolation(thunk.getDecl());
-  } else if (emitExecutorPrecondition) {
+  } else if (getASTContext()
+                 .LangOpts.isDynamicActorIsolationCheckingEnabled()) {
     if (thunk.hasDecl()) {
       isolation = getActorIsolation(thunk.getDecl());
     } else if (auto globalActor = nativeInfo.FormalType->getGlobalActor()) {

lib/SILGen/SILGenPoly.cpp

@@ -7021,7 +7021,10 @@ void SILGenFunction::emitProtocolWitness(
 
     if (!F.isAsync()) {
       assert(isPreconcurrency);
-      emitPreconditionCheckExpectedExecutor(loc, *enterIsolation, actorSelf);
+
+      if (getASTContext().LangOpts.isDynamicActorIsolationCheckingEnabled()) {
+        emitPreconditionCheckExpectedExecutor(loc, *enterIsolation, actorSelf);
+      }
     } else {
       emitHopToTargetActor(loc, enterIsolation, actorSelf);
     }

lib/Sema/CSApply.cpp

@@ -7462,7 +7462,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
       }
     }
 
-    if (ctx.LangOpts.hasFeature(Feature::DynamicActorIsolation)) {
+    if (ctx.LangOpts.isDynamicActorIsolationCheckingEnabled()) {
       // Passing a synchronous global actor-isolated function value and
       // parameter that expects a synchronous non-isolated function type could
       // require a runtime check to ensure that function is always called in