[AST/Sema] Decouple @preconcurrency conformances from DynamicActorIsolation feature flag

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -5697,8 +5697,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",

lib/AST/FeatureSet.cpp

@@ -645,29 +645,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/Sema/TypeCheckType.cpp

@@ -3317,28 +3317,21 @@ TypeResolver::resolveAttributedType(TypeRepr *repr, TypeResolutionOptions option
   }
 
   if (auto preconcurrencyAttr = claim<PreconcurrencyTypeAttr>(attrs)) {
-    auto &ctx = getASTContext();
-    if (ctx.LangOpts.hasFeature(Feature::DynamicActorIsolation)) {
-      if (ty->hasError())
-        return ty;
-
-      if (!options.is(TypeResolverContext::Inherited) ||
-          getDeclContext()->getSelfProtocolDecl()) {
-        diagnoseInvalid(repr, preconcurrencyAttr->getAtLoc(),
-                        diag::preconcurrency_not_inheritance_clause);
-        ty = ErrorType::get(getASTContext());
-      } else if (!ty->isConstraintType()) {
-        diagnoseInvalid(repr, preconcurrencyAttr->getAtLoc(),
-                        diag::preconcurrency_not_existential, ty);
-        ty = ErrorType::get(getASTContext());
-      }
+    if (ty->hasError())
+      return ty;
 
-      // Nothing to record in the type.
-    } else {
+    if (!options.is(TypeResolverContext::Inherited) ||
+        getDeclContext()->getSelfProtocolDecl()) {
       diagnoseInvalid(repr, preconcurrencyAttr->getAtLoc(),
-                      diag::preconcurrency_attr_disabled);
+                      diag::preconcurrency_not_inheritance_clause);
+      ty = ErrorType::get(getASTContext());
+    } else if (!ty->isConstraintType()) {
+      diagnoseInvalid(repr, preconcurrencyAttr->getAtLoc(),
+                      diag::preconcurrency_not_existential, ty);
       ty = ErrorType::get(getASTContext());
     }
+
+    // Nothing to record in the type.
   }
 
   if (auto retroactiveAttr = claim<RetroactiveTypeAttr>(attrs)) {

test/ModuleInterface/preconcurrency_conformances.swift

@@ -44,8 +44,8 @@ public protocol WithAssoc {
 //--- Client.swift
 import A
 
-// CHECK: #if {{.*}} $DynamicActorIsolation
-// CHECK-NEXT: @_Concurrency.MainActor public struct GlobalActorTest : @preconcurrency A.P
+// CHECK-NOT: #if {{.*}} $DynamicActorIsolation
+// CHECK: @_Concurrency.MainActor public struct GlobalActorTest : @preconcurrency A.P
 
 @MainActor
 public struct GlobalActorTest : @preconcurrency P {
@@ -56,37 +56,36 @@ public struct GlobalActorTest : @preconcurrency P {
 public class ExtTest {
 }
 
-// CHECK: #if {{.*}} $DynamicActorIsolation
-// CHECK-NEXT: extension Client.ExtTest : @preconcurrency A.P
+// CHECK-NOT: #if {{.*}} $DynamicActorIsolation
+// CHECK: extension Client.ExtTest : @preconcurrency A.P
 extension ExtTest : @preconcurrency P {
   public func test() -> Int { 1 }
 }
 
-// CHECK: #if {{.*}} && $DynamicActorIsolation
-// CHECK-NEXT: public actor ActorTest : @preconcurrency A.P
+// CHECK-NOT: #if {{.*}} && $DynamicActorIsolation
+// CHECK: public actor ActorTest : @preconcurrency A.P
 public actor ActorTest : @preconcurrency P {
   public func test() -> Int { 2 }
 }
 
 public actor ActorExtTest {
 }
 
-// CHECK: #if {{.*}} $DynamicActorIsolation
-// CHECK-NEXT: extension Client.ActorExtTest : @preconcurrency A.Q
+// CHECK-NOT: #if {{.*}} $DynamicActorIsolation
+// CHECK: extension Client.ActorExtTest : @preconcurrency A.Q
 extension ActorExtTest : @preconcurrency Q {
   public var x: Int { 42 }
 }
 
 public struct TestConditional<T> {}
 
-// CHECK: #if {{.*}} $DynamicActorIsolation
-// CHECK-NEXT: extension Client.TestConditional : @preconcurrency A.WithAssoc where T == Swift.Int {
+// CHECK-NOT: #if {{.*}} $DynamicActorIsolation
+// CHECK: extension Client.TestConditional : @preconcurrency A.WithAssoc where T == Swift.Int {
 // CHECK-NEXT:  @_Concurrency.MainActor public func test() -> T
 // CHECK-NEXT: }
 extension TestConditional : @preconcurrency WithAssoc where T == Int {
   @MainActor public func test() -> T { 42 } // Ok
 }
 
-// CHECK: #if {{.*}} $DynamicActorIsolation
-// CHECK-NEXT: extension Client.GlobalActorTest : Swift.Sendable {}
-// CHECK-NEXT: #endif
+// CHECK-NOT: #if {{.*}} $DynamicActorIsolation
+// CHECK: extension Client.GlobalActorTest : Swift.Sendable {}