ModuleInterface: Resolve inherited types when computing unsatisfiable conformances.

Previously, unsatisfiable conformances could be omitted from emitted
`.swiftinterface` files in lazy typechecking mode since inherited types might
be unresolved when gathering the conformances.

Adding these test cases also revealed that serialization restrictions needed to
be relaxed in order to accomodate unsatisfiable conformances.

Author: tshortli

lib/Frontend/ModuleInterfaceSupport.cpp

@@ -527,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,6 +49,8 @@ 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}}
 }
@@ -90,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}}
 
@@ -173,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()
 }
@@ -50,3 +50,18 @@ func testConformances() {
     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,6 +26,8 @@
 // CHECK-NEXT:    }
 // CHECK-NEXT:  }
 
+// CHECK:       public protocol EmptyPublicProto {
+// CHECK:       }
 // CHECK:       public protocol PublicProto {
 // CHECK:         func req() -> Swift.Int
 // CHECK:       }
@@ -39,6 +41,9 @@
 // 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
@@ -74,4 +79,9 @@
 // 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

test/TBD/lazy-typecheck.swift

@@ -71,11 +71,16 @@ exports:
                        '_$s14lazy_typecheck12PublicStructV18publicStaticMethodyyFZ',
                        '_$s14lazy_typecheck12PublicStructV1xACSi_tcfC', '_$s14lazy_typecheck12PublicStructVMa',
                        '_$s14lazy_typecheck12PublicStructVMn', '_$s14lazy_typecheck12PublicStructVN',
-                       '_$s14lazy_typecheck13inlinableFuncSiyF', '_$s14lazy_typecheck18PublicDerivedClassC1xACSi_tcfC',
+                       '_$s14lazy_typecheck13inlinableFuncSiyF', '_$s14lazy_typecheck16EmptyPublicProtoMp',
+                       '_$s14lazy_typecheck16EmptyPublicProtoTL', '_$s14lazy_typecheck18PublicDerivedClassC1xACSi_tcfC',
                        '_$s14lazy_typecheck18PublicDerivedClassC1xACSi_tcfc', '_$s14lazy_typecheck18PublicDerivedClassCMa',
                        '_$s14lazy_typecheck18PublicDerivedClassCMm', '_$s14lazy_typecheck18PublicDerivedClassCMn',
                        '_$s14lazy_typecheck18PublicDerivedClassCMo', '_$s14lazy_typecheck18PublicDerivedClassCN',
                        '_$s14lazy_typecheck18PublicDerivedClassCfD', '_$s14lazy_typecheck18PublicDerivedClassCfd',
+                       '_$s14lazy_typecheck19PublicGenericStructV12publicMethodxyF',
+                       '_$s14lazy_typecheck19PublicGenericStructVMa', '_$s14lazy_typecheck19PublicGenericStructVMn',
+                       '_$s14lazy_typecheck19PublicGenericStructVyxGAA05EmptyC5ProtoA2A08InternalE13ForConstraintVRszlMc',
+                       '_$s14lazy_typecheck19PublicGenericStructVyxGAA05EmptyC5ProtoA2A08InternalE13ForConstraintVRszlWP',
                        '_$s14lazy_typecheck19PublicRethrowsProtoMp', '_$s14lazy_typecheck19PublicRethrowsProtoP3reqSiyKFTj',
                        '_$s14lazy_typecheck19PublicRethrowsProtoP3reqSiyKFTq', '_$s14lazy_typecheck19PublicRethrowsProtoTL',
                        '_$s14lazy_typecheck24publicFuncWithDefaultArgyS2iF', '_$s14lazy_typecheck30publicFuncWithOpaqueReturnTypeQryF',