Merge pull request #68384 from tshortli/emit-module-lazy-typecheck-inherited-protocol-printing

ModuleInterface: Fix inheritance clauses in lazily emitted swiftinterfaces

Author: tshortli

lib/AST/ASTPrinter.cpp

@@ -2955,8 +2955,8 @@ static bool usesFeatureRethrowsProtocol(
 
   // Check an inheritance clause for a marker protocol.
   auto checkInherited = [&](InheritedTypes inherited) -> bool {
-    for (const auto &inheritedEntry : inherited.getEntries()) {
-      if (auto inheritedType = inheritedEntry.getType()) {
+    for (unsigned i : inherited.getIndices()) {
+      if (auto inheritedType = inherited.getResolvedType(i)) {
         if (inheritedType->isExistentialType()) {
           auto layout = inheritedType->getExistentialLayout();
           for (ProtocolDecl *proto : layout.getProtocols()) {
@@ -7688,8 +7688,8 @@ swift::getInheritedForPrinting(
   InheritedTypes inherited = InheritedTypes(decl);
 
   // Collect explicit inherited types.
-  for (auto entry : inherited.getEntries()) {
-    if (auto ty = entry.getType()) {
+  for (auto i : inherited.getIndices()) {
+    if (auto ty = inherited.getResolvedType(i)) {
       bool foundUnprintable = ty.findIf([&](Type subTy) {
         if (auto aliasTy = dyn_cast<TypeAliasType>(subTy.getPointer()))
           return !options.shouldPrint(aliasTy->getDecl());
@@ -7703,7 +7703,7 @@ swift::getInheritedForPrinting(
         continue;
     }
 
-    Results.push_back(entry);
+    Results.push_back(inherited.getEntry(i));
   }
 
   // Collect synthesized conformances.

lib/AST/ConformanceLookupTable.cpp

@@ -226,16 +226,18 @@ void ConformanceLookupTable::inheritConformances(ClassDecl *classDecl,
     if (superclassLoc.isValid())
       return superclassLoc;
 
-    for (const auto &inherited : classDecl->getInherited().getEntries()) {
-      if (auto inheritedType = inherited.getType()) {
+    auto inheritedTypes = classDecl->getInherited();
+    for (unsigned i : inheritedTypes.getIndices()) {
+      if (auto inheritedType = inheritedTypes.getResolvedType(i)) {
+
         if (inheritedType->getClassOrBoundGenericClass()) {
-          superclassLoc = inherited.getSourceRange().Start;
+          superclassLoc = inheritedTypes.getEntry(i).getSourceRange().Start;
           return superclassLoc;
         }
         if (inheritedType->isExistentialType()) {
           auto layout = inheritedType->getExistentialLayout();
           if (layout.explicitSuperclass) {
-            superclassLoc = inherited.getSourceRange().Start;
+            superclassLoc = inheritedTypes.getEntry(i).getSourceRange().Start;
             return superclassLoc;
           }
         }

lib/Frontend/ModuleInterfaceSupport.cpp

@@ -483,15 +483,16 @@ class InheritedProtocolCollector {
                        bool skipExtra = false) {
     llvm::Optional<AvailableAttrList> availableAttrs;
 
-    for (InheritedEntry inherited : directlyInherited.getEntries()) {
-      Type inheritedTy = inherited.getType();
+    for (int i : directlyInherited.getIndices()) {
+      Type inheritedTy = directlyInherited.getResolvedType(i);
       if (!inheritedTy || !inheritedTy->isExistentialType())
         continue;
 
       bool canPrintNormally = canPrintProtocolTypeNormally(inheritedTy, D);
       if (!canPrintNormally && skipExtra)
         continue;
 
+      auto inherited = directlyInherited.getEntry(i);
       ExistentialLayout layout = inheritedTy->getExistentialLayout();
       for (ProtocolDecl *protoDecl : layout.getProtocols()) {
         if (canPrintNormally)
@@ -526,8 +527,9 @@ class InheritedProtocolCollector {
   /// For each type directly inherited by \p extension, record any protocols
   /// that we would have printed in ConditionalConformanceProtocols.
   void recordConditionalConformances(const ExtensionDecl *extension) {
-    for (TypeLoc inherited : extension->getInherited().getEntries()) {
-      Type inheritedTy = inherited.getType();
+    auto inheritedTypes = extension->getInherited();
+    for (unsigned i : inheritedTypes.getIndices()) {
+      Type inheritedTy = inheritedTypes.getResolvedType(i);
       if (!inheritedTy || !inheritedTy->isExistentialType())
         continue;
 

lib/Serialization/Serialization.cpp

@@ -3264,9 +3264,6 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
   size_t addConformances(const IterableDeclContext *declContext,
                          ConformanceLookupKind lookupKind,
                          SmallVectorImpl<TypeID> &data) {
-    // We don't expect to be serializing conformances for skipped decls.
-    assert(!S.shouldSkipDecl(declContext->getDecl()));
-
     size_t count = 0;
     for (auto conformance : declContext->getLocalConformances(lookupKind)) {
       if (S.shouldSkipDecl(conformance->getProtocol()))
@@ -3353,6 +3350,10 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
           return true;
     }
 
+    // Paramters don't have meaningful access control.
+    if (isa<ParamDecl>(decl) || isa<GenericTypeParamDecl>(decl))
+      return true;
+
     return false;
   }
 
@@ -4897,11 +4898,16 @@ static bool canSkipWhenInvalid(const Decl *D) {
 }
 
 bool Serializer::shouldSkipDecl(const Decl *D) const {
-  if (Options.SerializeExternalDeclsOnly &&
-      !DeclSerializer::isDeserializationSafe(D))
-    return true;
+  // The presence of -experimental-serialize-external-decls-only is the only
+  // reason to omit decls during serialization.
+  if (!Options.SerializeExternalDeclsOnly)
+    return false;
 
-  return false;
+  // For our purposes, "deserialization safe" is the same thing as "external".
+  if (DeclSerializer::isDeserializationSafe(D))
+    return false;
+
+  return true;
 }
 
 void Serializer::writeASTBlockEntity(const Decl *D) {

test/Inputs/lazy_typecheck.swift

@@ -49,15 +49,25 @@ public func publicFuncWithOpaqueReturnType() -> some PublicProto { // expected-n
 
 // MARK: - Nominal types
 
+public protocol EmptyPublicProto {}
+
 public protocol PublicProto {
   func req() -> Int // expected-note 2 {{protocol requires function 'req()' with type '() -> Int'; add a stub for conformance}}
 }
 
+@rethrows public protocol PublicRethrowsProto {
+  func req() throws -> Int
+}
+
 protocol InternalProto {
-  func goodReq() -> Int // expected-note {{protocol requires function 'goodReq()' with type '() -> Int'; add a stub for conformance}}
+  func goodReq() -> Int // expected-note 2 {{protocol requires function 'goodReq()' with type '() -> Int'; add a stub for conformance}}
   func badReq() -> DoesNotExist // expected-error {{cannot find type 'DoesNotExist' in scope}}
 }
 
+protocol InternalProtoConformingToPublicProto: PublicProto {
+  func internalReq() -> DoesNotExist // expected-error {{cannot find type 'DoesNotExist' in scope}}
+}
+
 public struct PublicStruct {
   // FIXME: Test properties
 
@@ -82,6 +92,12 @@ public struct PublicStruct {
   }
 }
 
+public struct PublicGenericStruct<T> {
+  public func publicMethod() -> T {
+    return true // expected-error {{cannot convert return expression of type 'Bool' to return type 'T'}}
+  }
+}
+
 struct InternalStruct: DoesNotExist { // expected-error {{cannot find type 'DoesNotExist' in scope}}
   var x: DoesNotExist // expected-error {{cannot find type 'DoesNotExist' in scope}}
 
@@ -111,6 +127,8 @@ public class PublicClass {
 //  class func internalClassMethod() -> DoesNotExist {}
 }
 
+public class PublicDerivedClass: PublicClass {}
+
 class InternalClass: DoesNotExist { // expected-error {{cannot find type 'DoesNotExist' in scope}}
   init(x: DoesNotExist) {} // expected-error {{cannot find type 'DoesNotExist' in scope}}
 }
@@ -124,19 +142,36 @@ public struct PublicStructConformingToPublicProto: PublicProto {
   }
 }
 
+public struct PublicStructIndirectlyConformingToPublicProto: InternalProtoConformingToPublicProto {
+  public init() {}
+  public func req() -> Int {
+    return true // expected-error {{cannot convert return expression of type 'Bool' to return type 'Int'}}
+  }
+}
+
 public class PublicClassConformingToPublicProto: PublicProto {
   public init() {}
   public func req() -> Int {
     return true // expected-error {{cannot convert return expression of type 'Bool' to return type 'Int'}}
   }
 }
 
+public class PublicClassInheritingConformanceToPublicProto: PublicClassConformingToPublicProto {}
+
 extension String: PublicProto {
   public func req() -> Int {
     return true // expected-error {{cannot convert return expression of type 'Bool' to return type 'Int'}}
   }
 }
 
+extension String: InternalProto {} // expected-error {{type 'String' does not conform to protocol 'InternalProto'}}
+
+extension Int: PublicRethrowsProto {
+  public func req() throws -> Int {
+    return true // expected-error {{cannot convert return expression of type 'Bool' to return type 'Int'}}
+  }
+}
+
 struct InternalStructConformingToPublicProto: PublicProto { // expected-error {{type 'InternalStructConformingToPublicProto' does not conform to protocol 'PublicProto'}}
 }
 
@@ -146,5 +181,11 @@ extension InternalStruct: PublicProto { // expected-error {{type 'InternalStruct
 struct InternalStructConformingToInternalProto: InternalProto { // expected-error {{type 'InternalStructConformingToInternalProto' does not conform to protocol 'InternalProto'}}
 }
 
+struct InternalStructForConstraint {}
+
+extension PublicGenericStruct where T == InternalStructForConstraint {}
+
+extension PublicGenericStruct: EmptyPublicProto where T == InternalStructForConstraint {}
+
 // FIXME: Test enums
 // FIXME: Test global vars

test/Inputs/lazy_typecheck_client.swift

@@ -21,7 +21,7 @@ func testGlobalFunctions() {
 }
 
 func testPublicStruct() {
-  var s = PublicStruct(x: 1)
+  let s = PublicStruct(x: 1)
   _ = s.publicMethod()
   PublicStruct.publicStaticMethod()
 }
@@ -30,12 +30,38 @@ func testPublicClass() {
   let c = PublicClass(x: 2)
   _ = c.publicMethod()
   PublicClass.publicClassMethod()
+
+  let d = PublicDerivedClass(x: 3)
+  _ = d.publicMethod()
+  PublicDerivedClass.publicClassMethod()
 }
 
 func testConformances() {
-  let _: [any PublicProto] = [
+  let array: [any PublicProto] = [
     PublicStructConformingToPublicProto(),
+    PublicStructIndirectlyConformingToPublicProto(),
     PublicClassConformingToPublicProto(),
     "string",
+    PublicClassInheritingConformanceToPublicProto(),
   ]
+
+  for x in array {
+    _ = x.req()
+    constrainedGenericPublicFunction(x)
+  }
+}
+
+// FIXME: This conformance ought to be included to verify that a redundant
+// conformance diagnostic is emitted.
+// However, it turns out that the mechanism implemented by
+// https://github.com/apple/swift/pull/20433 doesn't actually work when a
+// module is built from .swiftinterface because the dummy conformance is marked
+// unavailable.
+//extension PublicGenericStruct: EmptyPublicProto {}
+
+func takesEmptyProto<T: EmptyPublicProto>(_ t: T) {}
+
+@available(*, unavailable)
+func testConditionalConformance<T>(_ s: PublicGenericStruct<T>) {
+  takesEmptyProto(s) // expected-error {{global function 'takesEmptyProto' requires}}
 }

test/ModuleInterface/lazy-typecheck.swift

@@ -4,7 +4,7 @@
 // RUN: %FileCheck %s < %t/lazy_typecheck.swiftinterface
 
 // RUN: rm -rf %t/*.swiftmodule
-// RUN: %target-swift-frontend -package-name Package -typecheck %S/../Inputs/lazy_typecheck_client.swift -I %t
+// RUN: %target-swift-frontend -package-name Package -typecheck -verify %S/../Inputs/lazy_typecheck_client.swift -I %t
 
 // CHECK: import Swift
 
@@ -26,29 +26,62 @@
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
 
+// CHECK:       public protocol EmptyPublicProto {
+// CHECK:       }
 // CHECK:       public protocol PublicProto {
 // CHECK:         func req() -> Swift.Int
 // CHECK:       }
+// CHECK:       #if compiler(>=5.3) && $RethrowsProtocol
+// CHECK:       @rethrows public protocol PublicRethrowsProto {
+// CHECK:         func req() throws -> Swift.Int
+// CHECK:       }
+// CHECK:       #endif
 // CHECK:       public struct PublicStruct {
 // CHECK:         public init(x: Swift.Int)
 // CHECK:         public func publicMethod() -> Swift.Int
 // CHECK:         public static func publicStaticMethod()
 // CHECK:       }
+// CHECK:       public struct PublicGenericStruct<T> {
+// CHECK:         public func publicMethod() -> T
+// CHECK:       }
 // CHECK:       public class PublicClass {
 // CHECK:         public init(x: Swift.Int)
 // CHECK:         public func publicMethod() -> Swift.Int
 // CHECK:         public class func publicClassMethod()
 // CHECK:         deinit
 // CHECK:       }
-// CHECK:       public struct PublicStructConformingToPublicProto : PublicProto {
+// CHECK:       @_inheritsConvenienceInitializers public class PublicDerivedClass : lazy_typecheck.PublicClass {
+// CHECK:         override public init(x: Swift.Int)
+// CHECK:         deinit
+// CHECK:       }
+// CHECK:       public struct PublicStructConformingToPublicProto : lazy_typecheck.PublicProto {
+// CHECK:         public init()
+// CHECK:         public func req() -> Swift.Int
+// CHECK:       }
+// CHECK:       public struct PublicStructIndirectlyConformingToPublicProto {
 // CHECK:         public init()
 // CHECK:         public func req() -> Swift.Int
 // CHECK:       }
-// CHECK:       public class PublicClassConformingToPublicProto : PublicProto {
+// CHECK:       public class PublicClassConformingToPublicProto : lazy_typecheck.PublicProto {
 // CHECK:         public init()
 // CHECK:         public func req() -> Swift.Int
 // CHECK:         deinit
 // CHECK:       }
-// CHECK:       extension Swift.String : PublicProto {
+// CHECK:       @_inheritsConvenienceInitializers public class PublicClassInheritingConformanceToPublicProto : lazy_typecheck.PublicClassConformingToPublicProto {
+// CHECK:         override public init()
+// CHECK:         deinit
+// CHECK:       }
+// CHECK:       extension Swift.String : lazy_typecheck.PublicProto {
 // CHECK:         public func req() -> Swift.Int
 // CHECK:       }
+// CHECK:       #if compiler(>=5.3) && $RethrowsProtocol
+// CHECK:       extension Swift.Int : lazy_typecheck.PublicRethrowsProto {
+// CHECK:         public func req() throws -> Swift.Int
+// CHECK:       }
+// CHECK:       #endif
+// CHECK:       @available(*, unavailable)
+// CHECK-NEXT:  extension lazy_typecheck.PublicGenericStruct : lazy_typecheck.EmptyPublicProto where T : _ConstraintThatIsNotPartOfTheAPIOfThisLibrary {}
+// CHECK:       extension lazy_typecheck.PublicStructIndirectlyConformingToPublicProto : lazy_typecheck.PublicProto {}
+
+// CHECK:       @usableFromInline
+// CHECK:       internal protocol _ConstraintThatIsNotPartOfTheAPIOfThisLibrary {}

test/Serialization/serialize-external-decls-only-lazy-typecheck.swift

@@ -2,4 +2,4 @@
 // RUN: %target-swift-frontend -swift-version 5 %S/../Inputs/lazy_typecheck.swift -enable-library-evolution -parse-as-library -package-name Package -typecheck -verify
 // RUN: %target-swift-frontend -swift-version 5 %S/../Inputs/lazy_typecheck.swift -module-name lazy_typecheck -emit-module -emit-module-path %t/lazy_typecheck.swiftmodule -enable-library-evolution -parse-as-library -package-name Package -experimental-lazy-typecheck -experimental-skip-all-function-bodies -experimental-serialize-external-decls-only
 
-// RUN: %target-swift-frontend -package-name Package -typecheck %S/../Inputs/lazy_typecheck_client.swift -D TEST_PACKAGE -I %t
+// RUN: %target-swift-frontend -package-name Package -typecheck -verify %S/../Inputs/lazy_typecheck_client.swift -D TEST_PACKAGE -I %t