[Frontend] Add experimental flag for @preconcurrency conformances feature

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -5630,6 +5630,8 @@ 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 PreconcurrencyConformances'", ())
 
 ERROR(redundant_any_in_existential,none,
        "redundant 'any' in type %0",

include/swift/Basic/Features.def

@@ -270,6 +270,9 @@ 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.
+EXPERIMENTAL_FEATURE(PreconcurrencyConformances, false)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

lib/AST/ASTPrinter.cpp

@@ -3908,6 +3908,30 @@ static bool usesFeatureBitwiseCopyable(Decl *decl) { return false; }
 
 static bool usesFeatureTransferringArgsAndResults(Decl *decl) { return false; }
 
+static bool usesFeaturePreconcurrencyConformances(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;
+}
+
 /// Suppress the printing of a particular feature.
 static void suppressingFeature(PrintOptions &options, Feature feature,
                                llvm::function_ref<void()> action) {

lib/Sema/TypeCheckType.cpp

@@ -3251,22 +3251,30 @@ TypeResolver::resolveAttributedType(TypeAttributes &attrs, TypeRepr *repr,
   }
 
   if (attrs.has(TAK_preconcurrency)) {
-    ty = resolveType(repr, options);
-    if (!ty || ty->hasError()) return ty;
+    auto &ctx = getASTContext();
+    if (ctx.LangOpts.hasFeature(Feature::PreconcurrencyConformances)) {
+      ty = resolveType(repr, options);
+      if (!ty || ty->hasError())
+        return ty;
 
-    if (!options.is(TypeResolverContext::Inherited) ||
-        getDeclContext()->getSelfProtocolDecl()) {
-      diagnoseInvalid(repr, attrs.getLoc(TAK_preconcurrency),
-                      diag::preconcurrency_not_inheritance_clause);
-      ty = ErrorType::get(getASTContext());
-    } else if (!ty->isConstraintType()) {
+      if (!options.is(TypeResolverContext::Inherited) ||
+          getDeclContext()->getSelfProtocolDecl()) {
+        diagnoseInvalid(repr, attrs.getLoc(TAK_preconcurrency),
+                        diag::preconcurrency_not_inheritance_clause);
+        ty = ErrorType::get(getASTContext());
+      } else if (!ty->isConstraintType()) {
+        diagnoseInvalid(repr, attrs.getLoc(TAK_preconcurrency),
+                        diag::preconcurrency_not_existential, ty);
+        ty = ErrorType::get(getASTContext());
+      }
+
+      // Nothing to record in the type. Just clear the attribute.
+      attrs.clearAttribute(TAK_preconcurrency);
+    } else {
       diagnoseInvalid(repr, attrs.getLoc(TAK_preconcurrency),
-                      diag::preconcurrency_not_existential, ty);
+                      diag::preconcurrency_attr_disabled);
       ty = ErrorType::get(getASTContext());
     }
-
-    // Nothing to record in the type. Just clear the attribute.
-    attrs.clearAttribute(TAK_preconcurrency);
   }
 
   if (attrs.has(TAK_retroactive)) {

test/Concurrency/preconcurrency_conformances.swift

@@ -0,0 +1,34 @@
+// RUN: %target-swift-frontend -disable-availability-checking %s -emit-sil -o /dev/null -verify -enable-experimental-feature PreconcurrencyConformances -verify-additional-prefix minimal-targeted-
+// RUN: %target-swift-frontend -disable-availability-checking %s -emit-sil -o /dev/null -verify -enable-experimental-feature PreconcurrencyConformances -strict-concurrency=targeted -verify-additional-prefix minimal-targeted-
+// RUN: %target-swift-frontend -disable-availability-checking %s -emit-sil -o /dev/null -verify -enable-experimental-feature PreconcurrencyConformances -strict-concurrency=complete -verify-additional-prefix complete-tns-
+
+// REQUIRES: concurrency
+// REQUIRES: asserts
+
+protocol Q {
+}
+
+do {
+  class K {}
+
+  struct A : @preconcurrency Q {} // Ok
+  struct B : @preconcurrency K {
+    // expected-error@-1 {{'preconcurrency' attribute cannot apply to non-protocol type 'K'}}
+    var x: @preconcurrency Int
+    // expected-error@-1 {{'preconcurrency' attribute only applies in inheritance clauses}}
+  }
+
+  typealias T = @preconcurrency Q
+  // expected-error@-1 {{'preconcurrency' attribute only applies in inheritance clauses}}
+
+  func test(_: @preconcurrency K) {}
+  // expected-error@-1 {{'preconcurrency' attribute only applies in inheritance clauses}}
+}
+
+protocol InvalidUseOfPreconcurrencyAttr : @preconcurrency Q {
+  // expected-error@-1 {{'preconcurrency' attribute only applies in inheritance clauses}}
+}
+
+struct TestPreconcurrencyAttr {}
+extension TestPreconcurrencyAttr : @preconcurrency Q { // Ok
+}

test/Concurrency/predates_concurrency.swift

@@ -249,28 +249,3 @@ extension MainActorPreconcurrency: NotIsolated {
     }
   }
 }
-
-do {
-  class K {}
-
-  struct A : @preconcurrency Q {} // Ok
-  struct B : @preconcurrency K {
-    // expected-error@-1 {{'preconcurrency' attribute cannot apply to non-protocol type 'K'}}
-    var x: @preconcurrency Int
-    // expected-error@-1 {{'preconcurrency' attribute only applies in inheritance clauses}}
-  }
-
-  typealias T = @preconcurrency Q
-  // expected-error@-1 {{'preconcurrency' attribute only applies in inheritance clauses}}
-
-  func test(_: @preconcurrency K) {}
-  // expected-error@-1 {{'preconcurrency' attribute only applies in inheritance clauses}}
-}
-
-protocol InvalidUseOfPreconcurrencyAttr : @preconcurrency Q {
-  // expected-error@-1 {{'preconcurrency' attribute only applies in inheritance clauses}}
-}
-
-struct TestPreconcurrencyAttr {}
-extension TestPreconcurrencyAttr : @preconcurrency Q { // Ok
-}

test/ModuleInterface/preconcurrency_conformances.swift

@@ -11,12 +11,19 @@
 // RUN: %target-swift-frontend -emit-module %t/src/Client.swift \
 // RUN:   -module-name Client -I %t -swift-version 5 -enable-library-evolution \
 // RUN:   -emit-module-path %t/Client.swiftmodule \
-// RUN:   -emit-module-interface-path %t/Client.swiftinterface
+// RUN:   -emit-module-interface-path %t/Client.swiftinterface \
+// RUN:   -enable-experimental-feature PreconcurrencyConformances
 
 // RUN: %FileCheck %s < %t/Client.swiftinterface
 
-// RUN: %target-swift-emit-module-interface(%t/Client.swiftinterface) -I %t %s -module-name Client
-// RUN: %target-swift-typecheck-module-from-interface(%t/Client.swiftinterface) -I %t -module-name Client
+// RUN: %target-swift-emit-module-interface(%t/Client.swiftinterface) -I %t %s -module-name Client \
+// RUN:   -enable-experimental-feature PreconcurrencyConformances
+
+// RUN: %target-swift-typecheck-module-from-interface(%t/Client.swiftinterface) -I %t -module-name Client \
+// RUN:   -enable-experimental-feature PreconcurrencyConformances
+
+// REQUIRES: asserts
+// REQUIRES: concurrency
 
 //--- PublicModule.swift
 public protocol P {
@@ -26,7 +33,8 @@ public protocol P {
 //--- Client.swift
 import PublicModule
 
-// CHECK: @_Concurrency.MainActor public struct GlobalActorTest : @preconcurrency PublicModule.P
+// CHECK: #if compiler(>=5.3) && $PreconcurrencyConformances
+// CHECK-NEXT: @_Concurrency.MainActor public struct GlobalActorTest : @preconcurrency PublicModule.P
 @MainActor
 public struct GlobalActorTest : @preconcurrency P {
   public func test() -> Int { 0 }
@@ -36,9 +44,14 @@ public struct GlobalActorTest : @preconcurrency P {
 public class ExtTest {
 }
 
-// CHECK: extension Client.ExtTest : @preconcurrency PublicModule.P
+// CHECK: #if compiler(>=5.3) && $PreconcurrencyConformances
+// CHECK-NEXT: extension Client.ExtTest : @preconcurrency PublicModule.P
 extension ExtTest : @preconcurrency P {
   public func test() -> Int { 1 }
 }
 
+// CHECK: #if compiler(>=5.3) && $PreconcurrencyConformances
+// CHECK-NEXT: extension Client.GlobalActorTest : Swift.Sendable {}
+// CHECK-NEXT: #endif
+
 // TODO: 'actor' cannot be tested until @preconcurrency conformances are implemented.