[Associated type inference] Check solutions against full requirement signature

When we have a potential assignment of associated types to type
witnesses during associated type inference, check that set of type
witnesses against the requirements in the requirement signature, so
that we can reject any solutions that fail some of the protocol's
requirements.

This is most of rdar://problem/31830524 --- but gets thwarted by the
inability of associated type inference to work across multiple
protocols.

Author: DougGregor

lib/Sema/TypeCheckProtocol.cpp

@@ -4012,6 +4012,7 @@ void ConformanceChecker::resolveTypeWitnesses() {
   typedef decltype(typeWitnesses)::ScopeTy TypeWitnessesScope;
   unsigned numTypeWitnesses = 0;
   SmallVector<InferredTypeWitnessesSolution, 4> solutions;
+  SmallVector<InferredTypeWitnessesSolution, 4> nonViableSolutions;
 
   // Information to use for diagnosing failures when we don't have
   // something more specific.
@@ -4194,13 +4195,44 @@ void ConformanceChecker::resolveTypeWitnesses() {
         if (replaced.isNull())
           return true;
 
-        if (checkTypeWitness(TC, DC, assocType, replaced))
-          return true;
-
         known->first = replaced;
       }
     }
 
+    // Check any same-type requirements in the protocol's requirement signature.
+    if (Proto->isRequirementSignatureComputed()) {
+      SubstOptions options(None);
+      options.getTentativeTypeWitness =
+        [&](const NormalProtocolConformance *conformance,
+            AssociatedTypeDecl *assocType) -> Type {
+          if (conformance != Conformance) return Type(0);
+
+          return typeWitnesses.begin(assocType)->first;
+        };
+
+      auto substitutions =
+        SubstitutionMap::getProtocolSubstitutions(
+                                          Proto, Conformance->getType(),
+                                          ProtocolConformanceRef(Conformance));
+
+      auto requirementSig = Proto->getRequirementSignature();
+      auto result =
+        TC.checkGenericArguments(DC, SourceLoc(), SourceLoc(),
+                                 Conformance->getType(), requirementSig,
+                                 QuerySubstitutionMap{substitutions},
+                                 TypeChecker::LookUpConformance(
+                                   TC, Conformance->getDeclContext()),
+                                 nullptr, None, nullptr, options);
+      switch (result) {
+      case RequirementCheckResult::Failure:
+      case RequirementCheckResult::UnsatisfiedDependency:
+        return true;
+
+      case RequirementCheckResult::Success:
+      case RequirementCheckResult::SubstitutionFailure:
+        return false;
+      }
+    }
     return false;
   };
 
@@ -4262,9 +4294,7 @@ void ConformanceChecker::resolveTypeWitnesses() {
       }
 
       /// Check the current set of type witnesses.
-      if (checkCurrentTypeWitnesses()) {
-        return;
-      }
+      bool invalid = checkCurrentTypeWitnesses();
 
       // Determine whether there is already a solution with the same
       // bindings.
@@ -4284,8 +4314,9 @@ void ConformanceChecker::resolveTypeWitnesses() {
           return;
       }
 
-      solutions.push_back(InferredTypeWitnessesSolution());
-      auto &solution = solutions.back();
+      auto &solutionList = invalid ? nonViableSolutions : solutions;
+      solutionList.push_back(InferredTypeWitnessesSolution());
+      auto &solution = solutionList.back();
 
       // Copy the type witnesses.
       for (auto assocType : unresolvedAssocTypes) {
@@ -4479,6 +4510,12 @@ void ConformanceChecker::resolveTypeWitnesses() {
     }
   }
 
+  // If we have no solution, but we did find something that is nonviable,
+  // use the first nonviable one to improve error reporting.
+  if (solutions.empty() && !nonViableSolutions.empty()) {
+    solutions.push_back(std::move(nonViableSolutions.front()));
+  }
+
   // If we found a single solution, take it.
   if (solutions.size() == 1) {
     // Record each of the deduced witnesses.

test/Constraints/associated_types.swift

@@ -62,8 +62,8 @@ protocol XReqt {}
 protocol YReqt {}
 
 protocol SameTypedDefaultWithReqts {
-    associatedtype X: XReqt // expected-note{{}}
-    associatedtype Y: YReqt // expected-note{{}}
+    associatedtype X: XReqt
+    associatedtype Y: YReqt
     static var x: X { get }
     static var y: Y { get }
 }
@@ -86,7 +86,7 @@ struct UsesSameTypedDefaultWithoutSatisfyingReqts: SameTypedDefaultWithReqts {
 }
 
 protocol SameTypedDefaultBaseWithReqts {
-    associatedtype X: XReqt // expected-note{{}}
+    associatedtype X: XReqt
     static var x: X { get }
 }
 protocol SameTypedDefaultDerivedWithReqts: SameTypedDefaultBaseWithReqts {

test/Generics/associated_type_where_clause.swift

@@ -157,3 +157,48 @@ protocol P4 {
 protocol P5: P3, P4 {
   associatedtype B where B == A?
 }
+
+// Associated type inference should account for where clauses.
+protocol P6 {
+  associatedtype A
+}
+
+struct X1 { }
+
+struct X2 { }
+
+struct Y1 : P6 {
+  typealias A = X1
+}
+
+struct Y2 : P6 {
+  typealias A = X2
+}
+
+protocol P7 {
+  associatedtype B: P6 // expected-note{{ambiguous inference of associated type 'B': 'Y1' vs. 'Y2'}}
+  associatedtype C: P6 where B.A == C.A
+
+  func getB() -> B
+  func getC() -> C
+}
+
+struct Z1 : P7 {
+  func getB() -> Y1 { return Y1() }
+  func getB() -> Y2 { return Y2() }
+
+  func getC() -> Y1 { return Y1() }
+}
+
+func testZ1(z1: Z1) {
+  let _: Z1.C = Y1()
+}
+
+
+struct Z2 : P7 { // expected-error{{type 'Z2' does not conform to protocol 'P7'}}
+  func getB() -> Y1 { return Y1() } // expected-note{{matching requirement 'getB()' to this declaration inferred associated type to 'Y1'}}
+  func getB() -> Y2 { return Y2() } // expected-note{{matching requirement 'getB()' to this declaration inferred associated type to 'Y2'}}
+
+  func getC() -> Y1 { return Y1() }
+  func getC() -> Y2 { return Y2() }
+}

test/decl/protocol/conforms/failure.swift

@@ -75,17 +75,17 @@ struct P5Conformer : P5 { // expected-error {{does not conform}}
 
 
 protocol P6Base {
-  associatedtype Foo // expected-note {{protocol requires nested type 'Foo'; do you want to add it?}}
+  associatedtype Foo
   func foo()
-  func bar() -> Foo
+  func bar() -> Foo // expected-note{{protocol requires function 'bar()' with type '() -> P6Conformer.Bar?'; do you want to add a stub?}}
 }
 extension P6Base {
 }
 protocol P6 : P6Base {
   associatedtype Bar // expected-note {{protocol requires nested type 'Bar'}}
 }
 extension P6 {
-  func bar() -> Bar? { return nil }
+  func bar() -> Bar? { return nil } // expected-note{{candidate has non-matching type '<Self> () -> Self.Bar?' [with Foo = P6Conformer.Bar?]}}
 }
 
 struct P6Conformer : P6 { // expected-error 2 {{does not conform}}

validation-test/compiler_crashers/28737-genericenv-nullptr-too-much-circularity.swift renamed to validation-test/compiler_crashers_fixed/28737-genericenv-nullptr-too-much-circularity.swift

@@ -6,5 +6,5 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
 // REQUIRES: asserts
-// RUN: not --crash %target-swift-frontend %s -emit-ir
+// RUN: not %target-swift-frontend %s -emit-ir
 protocol A:a{typealias e}class a:A{typealias e:S