Sema: Resolve type witnesses for conditional conformances early

This allows for correctly diagnosing references to default type witnesses
with unsatisfied requirements once we start realizing types in members.

This change also lays the groundwork for a special case of default type
witness resolution behavior when associated type collisions occur in the
presence of multiple regular and conditional conformances. Previously,
depending on evaluation order, a default type witness for a conditional
conformance could satisfy a type requirement for a regular conformance,
and the following snippet would have compiled:

 protocol A { associatedtype X }
 protocol B { associatedtype X = Bool }

 struct Foo<T>: A {} // error: type 'Foo<T>' does not conform to protocol 'A'
 extension Foo: B where T == Int {}

If the conditional requirements of a conformance are satisfied by those
of another conformance, default type witnesses for the former, more
general conformance, can now satisfy type requirements for the latter
conformance – but not vice versa – in case of associated type collisions.
For example, both conformances below will associate 'X' with a single type
witness synthesized for the less constrained conformance to B.

 struct Foo<T>: B {
   internal typealias X = Bool // synthesized!
 }
 extension Foo: A where T == Int {}

Author: AnthonyLatsis

lib/AST/DiagnosticEngine.cpp

@@ -425,6 +425,10 @@ static bool isInterestingTypealias(Type type) {
 /// Decide whether to show the desugared type or not.  We filter out some
 /// cases to avoid too much noise.
 static bool shouldShowAKA(Type type, StringRef typeName) {
+  // (aka '<<error type>>') does not contribute to a message whatsoever.
+  if (type->is<ErrorType>())
+    return false;
+
   // Canonical types are already desugared.
   if (type->isCanonical())
     return false;

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1736,6 +1736,11 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     // Check for circular inheritance of the raw type.
     (void)ED->hasCircularRawValue();
 
+    // Resolve all the type witnesses we need now to correctly diagnose
+    // references to default type witnesses with unsatisfied requirements
+    // once we start realizing types in members.
+    TypeChecker::resolveTypeWitnessesForConditionalConformances(ED);
+
     for (Decl *member : ED->getMembers())
       visit(member);
 
@@ -1775,6 +1780,11 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     checkGenericParams(SD);
 
+    // Resolve all the type witnesses we need now to correctly diagnose
+    // references to default type witnesses with unsatisfied requirements
+    // once we start realizing types in members.
+    TypeChecker::resolveTypeWitnessesForConditionalConformances(SD);
+
     // Force lowering of stored properties.
     (void) SD->getStoredProperties();
 
@@ -1905,6 +1915,11 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     // Check for circular inheritance.
     (void)CD->hasCircularInheritance();
 
+    // Resolve all the type witnesses we need now to correctly diagnose
+    // references to default type witnesses with unsatisfied requirements
+    // once we start realizing types in members.
+    TypeChecker::resolveTypeWitnessesForConditionalConformances(CD);
+
     // Force lowering of stored properties.
     (void) CD->getStoredProperties();
 

lib/Sema/TypeCheckProtocol.cpp

@@ -5055,6 +5055,69 @@ LookupAllConformancesInContextRequest::evaluate(
   return DC->getLocalConformances(ConformanceLookupKind::All);
 }
 
+void TypeChecker::resolveTypeWitnessesForConditionalConformances(
+                                          const NominalTypeDecl *nominal) {
+  // Non-generic types won't have conditional conformances.
+  const auto genericSig = nominal->getGenericSignature();
+  if (!genericSig)
+    return;
+
+  // Collect all the normal conformances for this nominal.
+  SmallVector<NormalProtocolConformance *, 2> conformances;
+  for (const auto conf: nominal->getAllConformances())
+    if (const auto normal = dyn_cast<NormalProtocolConformance>(conf))
+      conformances.push_back(normal);
+
+  // If the conditional requirements of a conformance are satisfied by those
+  // of another conformance, we want default type witnesses for the former,
+  // more general conformance, to be able to satisfy type requirements for
+  // the latter conformance in case of associated type collisions – but not
+  // vice versa (granted that the protocols do not match, of course).
+  // E.g., both conformances below should associate 'A' with a single
+  // type witness synthesized for the less constrained conformance to P1.
+  //
+  // protocol P1 { associatedtype A = Int }
+  // protocol P2 { associatedtype A }
+  //
+  // struct Foo<T>: P1 { }
+  // extension Foo: P2 where T == String { }
+  //
+  // To achieve this behavior, conformance X, whose conditional requirements
+  // are satisfied by those of conformance Y, must be checked before Y.
+  //
+  // First off, move all regular conformances to the front.
+  const auto it = llvm::partition(conformances,
+                                  [](const NormalProtocolConformance *conf) {
+    const auto reqs = conf->getConditionalRequirementsIfAvailable();
+    return reqs && reqs->empty();
+  });
+
+  // If there are no conditional conformances, there's nothing to resolve.
+  if (it == conformances.end())
+    return;
+
+  // Then, sort the remaining conditional conformances from less
+  // to more constrained.
+  std::sort(it, conformances.end(),
+            [](const NormalProtocolConformance *conf1,
+               const NormalProtocolConformance *conf2) {
+    const auto ext1 = cast<ExtensionDecl>(conf1->getDeclContext());
+    const auto ext2 = cast<ExtensionDecl>(conf2->getDeclContext());
+
+    return ext1->getGenericSignature()
+        ->requirementsNotSatisfiedBy(ext2->getGenericSignature()).empty();
+  });
+
+  for (const auto conf: conformances) {
+    llvm::SetVector<ValueDecl *> missingWitnesses;
+    ConformanceChecker checker(nominal->getASTContext(), conf,
+                               missingWitnesses,
+                               /*suppressDiagnostics*/true);
+    checker.resolveTypeWitnesses();
+    checker.diagnoseMissingWitnesses(MissingWitnessDiagnosisKind::ErrorFixIt);
+  }
+}
+
 void TypeChecker::checkConformancesInContext(DeclContext *dc,
                                              IterableDeclContext *idc) {
   // For anything imported from Clang, lazily check conformances.

lib/Sema/TypeCheckType.cpp

@@ -977,7 +977,9 @@ static void maybeDiagnoseBadConformanceRef(DeclContext *dc,
                                            Type parentTy,
                                            SourceLoc loc,
                                            TypeDecl *typeDecl) {
-  auto protocol = dyn_cast<ProtocolDecl>(typeDecl->getDeclContext());
+  assert(isa<AssociatedTypeDecl>(typeDecl) || isa<TypeAliasDecl>(typeDecl));
+
+  const auto protocol = dyn_cast<ProtocolDecl>(typeDecl->getDeclContext());
 
   // If we weren't given a conformance, go look it up.
   ProtocolConformance *conformance = nullptr;
@@ -991,16 +993,18 @@ static void maybeDiagnoseBadConformanceRef(DeclContext *dc,
 
   // If any errors have occurred, don't bother diagnosing this cross-file
   // issue.
-  ASTContext &ctx = dc->getASTContext();
+  const auto &ctx = dc->getASTContext();
   if (ctx.Diags.hadAnyError())
     return;
 
-  auto diagCode =
-    (!protocol || (conformance && !conformance->getConditionalRequirementsIfAvailable()))
-          ? diag::unsupported_recursion_in_associated_type_reference
-          : diag::broken_associated_type_witness;
+  const auto diagCode =
+    ((!protocol && !cast<TypeAliasDecl>(typeDecl)->isImplicit()) ||
+     (conformance && !conformance->getConditionalRequirementsIfAvailable()))
+      ? diag::unsupported_recursion_in_associated_type_reference
+      : diag::broken_associated_type_witness;
 
-  ctx.Diags.diagnose(loc, diagCode, isa<TypeAliasDecl>(typeDecl), typeDecl->getFullName(), parentTy);
+  ctx.Diags.diagnose(loc, diagCode, isa<TypeAliasDecl>(typeDecl),
+                     typeDecl->getFullName(), parentTy);
 }
 
 /// Returns a valid type or ErrorType in case of an error.

lib/Sema/TypeChecker.h

@@ -976,6 +976,9 @@ class LookUpConformance {
   /// Check all of the conformances in the given context.
   void checkConformancesInContext(DeclContext *dc, IterableDeclContext *idc);
 
+  void resolveTypeWitnessesForConditionalConformances(
+      const NominalTypeDecl *nominal);
+
   /// Check that the type of the given property conforms to NSCopying.
   ProtocolConformanceRef checkConformanceToNSCopying(VarDecl *var);
 

test/Generics/conditional_conformances.swift

@@ -1,6 +1,7 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -print-ast | %FileCheck %s -check-prefix=DEFAULT_TYPE_WITNESS
 // RUN: %target-typecheck-verify-swift -debug-generic-signatures > %t.dump 2>&1
 // RUN: %FileCheck %s < %t.dump
+// RUN: %target-typecheck-verify-swift
 
 protocol P1 {}
 protocol P2 {}
@@ -208,11 +209,11 @@ func subclass_bad() {
 struct InheritEqual<T> {}
 // CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritEqual
 // CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritEqual
+// CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritEqual
 // CHECK-NEXT:  (normal_conformance type=InheritEqual<T> protocol=P2
 // CHECK-NEXT:    conforms_to: T P1)
 extension InheritEqual: P2 where T: P1 {} // expected-note {{requirement from conditional conformance of 'InheritEqual<U>' to 'P2'}}
 // CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritEqual
-// CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritEqual
 // CHECK-NEXT:  (normal_conformance type=InheritEqual<T> protocol=P5
 // CHECK-NEXT:    (normal_conformance type=InheritEqual<T> protocol=P2
 // CHECK-NEXT:      conforms_to: T P1)
@@ -238,11 +239,11 @@ extension InheritLess: P5 {} // expected-error{{type 'T' does not conform to pro
 struct InheritMore<T> {}
 // CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritMore
 // CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritMore
+// CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritMore
 // CHECK-NEXT:  (normal_conformance type=InheritMore<T> protocol=P2
 // CHECK-NEXT:    conforms_to: T P1)
 extension InheritMore: P2 where T: P1 {} // expected-note {{requirement from conditional conformance of 'InheritMore<U>' to 'P2'}}
 // CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritMore
-// CHECK-LABEL: ExtensionDecl line={{.*}} base=InheritMore
 // CHECK-NEXT:  (normal_conformance type=InheritMore<T> protocol=P5
 // CHECK-NEXT:    (normal_conformance type=InheritMore<T> protocol=P2
 // CHECK-NEXT:      conforms_to: T P1)
@@ -429,3 +430,87 @@ func sr_10992_foo(_ fn: (SR_10992_S<String>) -> Void) {}
 func sr_10992_bar(_ fn: (SR_10992_P) -> Void) {
   sr_10992_foo(fn) // expected-error {{global function 'sr_10992_foo' requires that 'String' conform to 'SR_10992_P'}}
 }
+
+// SR-7516
+
+protocol SR_7516_P1 { associatedtype X = Void } // expected-note {{protocol requires nested type 'X'; do you want to add it?}}
+protocol SR_7516_P2 { associatedtype X = Bool }
+protocol SR_7516_P3 { associatedtype X = Void }
+protocol SR_7516_P4 { associatedtype X } // expected-note {{protocol requires nested type 'X'; do you want to add it?}}
+
+struct SR_7516_S1<T> {
+  class InnerBase<U: Sequence> where U.Element == X {}
+  class InnerDerived: InnerBase<[X]> {}
+  // expected-error@-2 {{'SR_7516_S1<T>.X' (aka '()') requires the types 'T' and 'Never' be equivalent}}
+  // expected-error@-2 {{'SR_7516_S1<T>.X' (aka '()') requires the types 'T' and 'Never' be equivalent}}
+}
+extension SR_7516_S1: SR_7516_P1 where T == Never { // expected-note 2{{requirement specified as 'T' == 'Never' [with T = T]}}
+  func bar(arg: X) {}
+// DEFAULT_TYPE_WITNESS: extension SR_7516_S1 : SR_7516_P1
+// DEFAULT_TYPE_WITNESS-NEXT: internal func bar(arg: X)
+// DEFAULT_TYPE_WITNESS-NEXT: internal typealias X = Void
+}
+
+struct SR_7516_S2<T>: SR_7516_P1 {
+// DEFAULT_TYPE_WITNESS: struct SR_7516_S2<T> : SR_7516_P1
+// DEFAULT_TYPE_WITNESS-NEXT: internal typealias X = Void
+}
+extension SR_7516_S2: SR_7516_P2 where T == Never {}
+extension SR_7516_S2 {
+  func foo(arg: X) {}
+}
+
+struct SR_7516_S3<T>: SR_7516_P1 {
+  let bar: X
+// DEFAULT_TYPE_WITNESS: struct SR_7516_S3<T> : SR_7516_P1
+// DEFAULT_TYPE_WITNESS-NEXT: internal let bar: X
+// DEFAULT_TYPE_WITNESS-NEXT: internal typealias X = Void
+}
+extension SR_7516_S3: SR_7516_P4 where T == Never {}
+
+struct SR_7516_S4<T>: SR_7516_P4 { // expected-error {{type 'SR_7516_S4<T>' does not conform to protocol 'SR_7516_P4'}}
+  let bar: X
+}
+extension SR_7516_S4: SR_7516_P1 where T == Never {} // expected-error {{type 'SR_7516_S4<T>' does not conform to protocol 'SR_7516_P1'}}
+
+class SR_7516_C1<T> {
+  var bar: X { fatalError() } // expected-error {{'SR_7516_C1<T>.X' (aka '()') requires the types 'T' and 'Never' be equivalent}}
+}
+// FIXME: Should this be an ambiguous situation where the user is
+// required to provide an explicit witness for X?
+extension SR_7516_C1: SR_7516_P1 where T == Never {
+  func foo(arg: X) {}
+}
+extension SR_7516_C1: SR_7516_P3 where T == Never { // expected-note 2{{requirement specified as 'T' == 'Never' [with T = T]}}
+
+// DEFAULT_TYPE_WITNESS: extension SR_7516_C1 : SR_7516_P3
+// DEFAULT_TYPE_WITNESS-NEXT: internal typealias X = Void
+}
+extension SR_7516_C1 {
+  typealias Y = X // expected-error {{'SR_7516_C1<T>.X' (aka '()') requires the types 'T' and 'Never' be equivalent}}
+}
+
+enum SR_7516_E1<T, U> {
+  // FIXME: Diagnostics QoI
+  case never(X) // expected-error {{type 'T' does not conform to protocol 'Equatable'}}
+}
+extension SR_7516_E1: SR_7516_P1 where T: Equatable {
+// DEFAULT_TYPE_WITNESS: extension SR_7516_E1 : SR_7516_P1
+// DEFAULT_TYPE_WITNESS-NEXT: internal typealias X = Void
+}
+extension SR_7516_E1: SR_7516_P4 where T: Equatable, U: Equatable {
+  func foo(arg: X) {}
+}
+
+struct SR_7516_S5<T> {
+  var bar: X { fatalError() }
+}
+extension SR_7516_S5: SR_7516_P2 where T == Never {}
+extension SR_7516_S5: SR_7516_P3 where T == String {}
+extension SR_7516_S5: SR_7516_P1 {
+  func foo(arg: X) {}
+// DEFAULT_TYPE_WITNESS: extension SR_7516_S5 : SR_7516_P1
+// DEFAULT_TYPE_WITNESS-NEXT: internal func foo(arg: X)
+// DEFAULT_TYPE_WITNESS-NEXT: internal typealias X = Void
+}
+extension SR_7516_S5: SR_7516_P4 where T: Equatable {}