[AST] Support @preconcurrency attribute on test/extension inheritance entries

Author: xedin

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

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);
   }, [&]() {
@@ -8308,7 +8310,8 @@ swift::getInheritedForPrinting(
 
     Results.push_back({TypeLoc::withoutLoc(proto->getDeclaredInterfaceType()),
                        isUnchecked,
-                       /*isRetroactive=*/false});
+                       /*isRetroactive=*/false,
+                       /*isPreconcurrency=*/false});
   }
 }
 

lib/AST/Decl.cpp

@@ -1592,6 +1592,7 @@ InheritedEntry::InheritedEntry(const TypeLoc &typeLoc)
   if (auto typeRepr = typeLoc.getTypeRepr()) {
     isUnchecked = typeRepr->findAttrLoc(TAK_unchecked).isValid();
     isRetroactive = typeRepr->findAttrLoc(TAK_retroactive).isValid();
+    isPreconcurrency = typeRepr->findAttrLoc(TAK_preconcurrency).isValid();
   }
 }
 

lib/ClangImporter/ImportDecl.cpp

@@ -7273,9 +7273,9 @@ void SwiftDeclConverter::importObjCProtocols(
             Impl.importDecl(*cp, getActiveSwiftVersion()))) {
       addProtocols(proto, protocols, knownProtocols);
       inheritedTypes.push_back(
-        InheritedEntry(
-          TypeLoc::withoutLoc(proto->getDeclaredInterfaceType()),
-          /*isUnchecked=*/false, /*isRetroactive=*/false));
+          InheritedEntry(TypeLoc::withoutLoc(proto->getDeclaredInterfaceType()),
+                         /*isUnchecked=*/false, /*isRetroactive=*/false,
+                         /*isPreconcurrency=*/false));
     }
   }
 

lib/Frontend/ModuleInterfaceSupport.cpp

@@ -746,7 +746,8 @@ class InheritedProtocolCollector {
     ASTContext &ctx = M->getASTContext();
     auto inherits = ctx.AllocateCopy(llvm::makeArrayRef(InheritedEntry(
         TypeLoc::withoutLoc(proto->getDeclaredInterfaceType()), isUnchecked,
-        /*isRetroactive=*/false)));
+        /*isRetroactive=*/false,
+        /*isPreconcurrency=*/false)));
     auto extension =
         ExtensionDecl::create(ctx, SourceLoc(), nullptr, inherits,
                               nominal->getModuleScopeContext(), nullptr);

lib/Sema/TypeCheckConcurrency.cpp

@@ -5556,7 +5556,8 @@ ProtocolConformance *swift::deriveImplicitSendableConformance(
       // FIXME: This is a hack--we should give conformances real availability.
       auto inherits = ctx.AllocateCopy(makeArrayRef(
           InheritedEntry(TypeLoc::withoutLoc(proto->getDeclaredInterfaceType()),
-                         /*isUnchecked*/true, /*isRetroactive=*/false)));
+                         /*isUnchecked*/ true, /*isRetroactive=*/false,
+                         /*isPreconcurrency=*/false)));
       // If you change the use of AtLoc in the ExtensionDecl, make sure you
       // update isNonSendableExtension() in ASTPrinter.
       auto extension = ExtensionDecl::create(ctx, attrMakingUnavailable->AtLoc,

lib/Serialization/Deserialization.cpp

@@ -3144,18 +3144,23 @@ class DeclDeserializer {
                        ArrayRef<uint64_t> rawInheritedIDs) {
     SmallVector<InheritedEntry, 2> inheritedTypes;
     for (auto rawID : rawInheritedIDs) {
-      // The low bit indicates "@unchecked".
+      // The first low bit indicates "@preconcurrency".
+      bool isPreconcurrency = rawID & 0x01;
+      rawID = rawID >> 1;
+
+      // The second low bit indicates "@unchecked".
       bool isUnchecked = rawID & 0x01;
-      TypeID typeID = rawID >> 1;
+      rawID = rawID >> 1;
 
+      TypeID typeID = rawID;
       auto maybeType = MF.getTypeChecked(typeID);
       if (!maybeType) {
         MF.diagnoseAndConsumeError(maybeType.takeError());
         continue;
       }
       inheritedTypes.push_back(
           InheritedEntry(TypeLoc::withoutLoc(maybeType.get()), isUnchecked,
-                         /*isRetroactive=*/false));
+                         /*isRetroactive=*/false, isPreconcurrency));
     }
 
     auto inherited = ctx.AllocateCopy(inheritedTypes);

lib/Serialization/ModuleFormat.h

@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 835; // remove Swift3Inferred
+const uint16_t SWIFTMODULE_VERSION_MINOR = 836; // @preconcurrency inheritance entry
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///

lib/Serialization/Serialization.cpp

@@ -3829,6 +3829,8 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
 
       // Encode "unchecked" in the low bit.
       typeRef = (typeRef << 1) | (inherited.isUnchecked ? 0x01 : 0x00);
+      // Encode "preconcurrency" in the low bit.
+      typeRef = (typeRef << 1) | (inherited.isPreconcurrency ? 0x01 : 0x00);
 
       result.push_back(typeRef);
     }

test/ModuleInterface/preconcurrency_conformances.swift

@@ -0,0 +1,44 @@
+// RUN: %empty-directory(%t/src)
+// RUN: split-file %s %t/src
+
+/// Build the library
+// RUN: %target-swift-frontend -emit-module %t/src/PublicModule.swift \
+// RUN:   -module-name PublicModule -swift-version 5 -enable-library-evolution \
+// RUN:   -emit-module-path %t/PublicModule.swiftmodule \
+// RUN:   -emit-module-interface-path %t/PublicModule.swiftinterface
+
+// Build the client and check the interface
+// 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: %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
+
+//--- PublicModule.swift
+public protocol P {
+  func test() -> Int
+}
+
+//--- Client.swift
+import PublicModule
+
+// CHECK: @_Concurrency.MainActor public struct GlobalActorTest : @preconcurrency PublicModule.P
+@MainActor
+public struct GlobalActorTest : @preconcurrency P {
+  public func test() -> Int { 0 }
+}
+
+@MainActor
+public class ExtTest {
+}
+
+// CHECK: extension Client.ExtTest : @preconcurrency PublicModule.P
+extension ExtTest : @preconcurrency P {
+  public func test() -> Int { 1 }
+}
+
+// TODO: 'actor' cannot be tested until @preconcurrency conformances are implemented.