Merge pull request #70867 from xedin/dynamic-enforcement-of-witness-isolation-with-preconcurrency

[TypeChecker/SILGen] Dynamic enforcement of witness/objc isolation with @preconcurrency attribute

Author: xedin

include/swift/AST/ASTBridging.h

@@ -1161,6 +1161,7 @@ enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedTypeAttrKind : size_t {
   BridgedTypeAttrKind_Sendable,
   BridgedTypeAttrKind_retroactive,
   BridgedTypeAttrKind_unchecked,
+  BridgedTypeAttrKind_preconcurrency,
   BridgedTypeAttrKind__local,
   BridgedTypeAttrKind__noMetadata,
   BridgedTypeAttrKind__opaqueReturnTypeOf,

include/swift/AST/ASTContext.h

@@ -1282,7 +1282,8 @@ class ASTContext final {
                        SourceLoc loc,
                        DeclContext *dc,
                        ProtocolConformanceState state,
-                       bool isUnchecked);
+                       bool isUnchecked,
+                       bool isPreconcurrency);
 
   /// Produce a self-conformance for the given protocol.
   SelfProtocolConformance *

include/swift/AST/Attr.def

@@ -57,6 +57,7 @@ TYPE_ATTR(async)
 TYPE_ATTR(Sendable)
 TYPE_ATTR(retroactive)
 TYPE_ATTR(unchecked)
+TYPE_ATTR(preconcurrency)
 TYPE_ATTR(_local)
 TYPE_ATTR(_noMetadata)
 TYPE_ATTR(_opaqueReturnTypeOf)

include/swift/AST/Decl.h

@@ -1604,11 +1604,15 @@ struct InheritedEntry : public TypeLoc {
   /// Whether there was an @retroactive attribute.
   bool isRetroactive = false;
 
+  /// Whether there was an @preconcurrency attribute.
+  bool isPreconcurrency = false;
+
   InheritedEntry(const TypeLoc &typeLoc);
 
-  InheritedEntry(const TypeLoc &typeLoc, bool isUnchecked, bool isRetroactive)
-    : TypeLoc(typeLoc), isUnchecked(isUnchecked), isRetroactive(isRetroactive) {
-    }
+  InheritedEntry(const TypeLoc &typeLoc, bool isUnchecked, bool isRetroactive,
+                 bool isPreconcurrency)
+      : TypeLoc(typeLoc), isUnchecked(isUnchecked),
+        isRetroactive(isRetroactive), isPreconcurrency(isPreconcurrency) {}
 };
 
 /// A wrapper for the collection of inherited types for either a `TypeDecl` or

include/swift/AST/DiagnosticsSema.def

@@ -5628,6 +5628,15 @@ ERROR(unchecked_not_inheritance_clause,none,
 ERROR(unchecked_not_existential,none,
       "'unchecked' attribute cannot apply to non-protocol type %0", (Type))
 
+WARNING(preconcurrency_conformance_not_used,none,
+        "@preconcurrency attribute on conformance to %0 has no effect", (Type))
+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",
        (Type))

include/swift/AST/NameLookup.h

@@ -586,12 +586,15 @@ struct InheritedNominalEntry : Located<NominalTypeDecl *> {
   /// The location of the "unchecked" attribute, if present.
   SourceLoc uncheckedLoc;
 
+  /// The location of the "preconcurrency" attribute if present.
+  SourceLoc preconcurrencyLoc;
+
   InheritedNominalEntry() { }
 
-  InheritedNominalEntry(
-    NominalTypeDecl *item, SourceLoc loc,
-    SourceLoc uncheckedLoc
-  ) : Located(item, loc), uncheckedLoc(uncheckedLoc) { }
+  InheritedNominalEntry(NominalTypeDecl *item, SourceLoc loc,
+                        SourceLoc uncheckedLoc, SourceLoc preconcurrencyLoc)
+      : Located(item, loc), uncheckedLoc(uncheckedLoc),
+        preconcurrencyLoc(preconcurrencyLoc) {}
 };
 
 /// Retrieve the set of nominal type declarations that are directly

include/swift/AST/ProtocolConformance.h

@@ -444,11 +444,11 @@ class NormalProtocolConformance : public RootProtocolConformance,
 
   // Flag bits used in ContextAndBits.
   enum {
-    /// The conformance is invalid.
-    InvalidFlag = 0x01,
-
     /// The conformance was labeled with @unchecked.
-    UncheckedFlag = 0x02,
+    UncheckedFlag = 0x01,
+
+    /// The conformance was labeled with @preconcurrency.
+    PreconcurrencyFlag = 0x02,
 
     /// We have allocated the AssociatedConformances array (but not necessarily
     /// populated any of its elements).
@@ -458,10 +458,13 @@ class NormalProtocolConformance : public RootProtocolConformance,
   /// The declaration context containing the ExtensionDecl or
   /// NominalTypeDecl that declared the conformance.
   ///
-  /// Also stores the "invalid", "unchecked" and "has computed associated
+  /// Also stores the "unchecked", "preconcurrency" and "has computed associated
   /// conformances" bits.
   llvm::PointerIntPair<DeclContext *, 3, unsigned> ContextAndBits;
 
+  /// Indicates whether the conformance is invalid.
+  bool Invalid : 1;
+
   /// The reason that this conformance exists.
   ///
   /// Either Explicit (e.g. 'struct Foo: Protocol {}' or 'extension Foo:
@@ -501,12 +504,14 @@ class NormalProtocolConformance : public RootProtocolConformance,
 public:
   NormalProtocolConformance(Type conformingType, ProtocolDecl *protocol,
                             SourceLoc loc, DeclContext *dc,
-                            ProtocolConformanceState state,
-                            bool isUnchecked)
+                            ProtocolConformanceState state, bool isUnchecked,
+                            bool isPreconcurrency)
       : RootProtocolConformance(ProtocolConformanceKind::Normal,
                                 conformingType),
         ProtocolAndState(protocol, state), Loc(loc),
-        ContextAndBits(dc, isUnchecked ? UncheckedFlag : 0) {
+        ContextAndBits(dc, ((isUnchecked ? UncheckedFlag : 0) |
+                            (isPreconcurrency ? PreconcurrencyFlag : 0))),
+        Invalid(false) {
     assert(!conformingType->hasArchetype() &&
            "ProtocolConformances should store interface types");
   }
@@ -543,12 +548,12 @@ class NormalProtocolConformance : public RootProtocolConformance,
 
   /// Determine whether this conformance is invalid.
   bool isInvalid() const {
-    return ContextAndBits.getInt() & InvalidFlag;
+    return Invalid;
   }
 
   /// Mark this conformance as invalid.
   void setInvalid() {
-    ContextAndBits.setInt(ContextAndBits.getInt() | InvalidFlag);
+    Invalid = true;
   }
 
   /// Whether this is an "unchecked" conformance.
@@ -563,6 +568,9 @@ class NormalProtocolConformance : public RootProtocolConformance,
     ContextAndBits.setInt(ContextAndBits.getInt() | UncheckedFlag);
   }
 
+  /// Whether this is an preconcurrency conformance.
+  bool isPreconcurrency() const;
+
   /// Determine whether we've lazily computed the associated conformance array
   /// already.
   bool hasComputedAssociatedConformances() const {

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/ASTContext.cpp

@@ -2491,7 +2491,8 @@ ASTContext::getNormalConformance(Type conformingType,
                                  SourceLoc loc,
                                  DeclContext *dc,
                                  ProtocolConformanceState state,
-                                 bool isUnchecked) {
+                                 bool isUnchecked,
+                                 bool isPreconcurrency) {
   assert(dc->isTypeContext());
 
   llvm::FoldingSetNodeID id;
@@ -2505,10 +2506,9 @@ ASTContext::getNormalConformance(Type conformingType,
     return result;
 
   // Build a new normal protocol conformance.
-  auto result
-    = new (*this, AllocationArena::Permanent)
-        NormalProtocolConformance(
-          conformingType, protocol, loc, dc, state,isUnchecked);
+  auto result = new (*this, AllocationArena::Permanent)
+      NormalProtocolConformance(conformingType, protocol, loc, dc, state,
+                                isUnchecked, isPreconcurrency);
   normalConformances.InsertNode(result, insertPos);
 
   return result;

lib/AST/ASTPrinter.cpp

@@ -2732,6 +2732,8 @@ void PrintAST::printInherited(const Decl *decl) {
     if (inherited.isRetroactive &&
         !llvm::is_contained(Options.ExcludeAttrList, TAK_retroactive))
       Printer << "@retroactive ";
+    if (inherited.isPreconcurrency)
+      Printer << "@preconcurrency ";
 
     printTypeLoc(inherited);
   }, [&]() {
@@ -3906,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) {
@@ -8317,7 +8343,8 @@ swift::getInheritedForPrinting(
 
     Results.push_back({TypeLoc::withoutLoc(proto->getDeclaredInterfaceType()),
                        isUnchecked,
-                       /*isRetroactive=*/false});
+                       /*isRetroactive=*/false,
+                       /*isPreconcurrency=*/false});
   }
 }