RequirementMachine: Fix potential 'pollution' from installing an invalid requirement machine

If the substitution terms of a concrete type symbol contain unresolved
name symbols, we have an invalid requirement that is dropped from the
minimized signature. In this case, the rewrite system used for minimization
cannot be installed as the official rewrite system for this generic
signature, because building a rewrite system from the signature will
produce a different result.

This might be the cause of the crash in rdar://114111159.

Author: slavapestov

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -646,7 +646,10 @@ void RewriteSystem::minimizeRewriteSystem(const PropertyMap &map) {
 }
 
 /// Returns flags indicating if the rewrite system has unresolved or
-/// conflicting rules in our minimization domain.
+/// conflicting rules in our minimization domain. If these flags are
+/// set, we do not install this rewrite system in the rewrite context
+/// after minimization. Instead, we will rebuild a new rewrite system
+/// from the minimized requirements.
 GenericSignatureErrors RewriteSystem::getErrors() const {
   assert(Complete);
   assert(Minimized);
@@ -668,10 +671,19 @@ GenericSignatureErrors RewriteSystem::getErrors() const {
     if (rule.isConflicting() || rule.isRecursive())
       result |= GenericSignatureErrorFlags::HasInvalidRequirements;
 
-    if (!rule.isRedundant())
-      if (auto property = rule.isPropertyRule())
+    if (!rule.isRedundant()) {
+      if (auto property = rule.isPropertyRule()) {
         if (property->getKind() == Symbol::Kind::ConcreteConformance)
           result |= GenericSignatureErrorFlags::HasConcreteConformances;
+
+        if (property->hasSubstitutions()) {
+          for (auto t : property->getSubstitutions()) {
+            if (t.containsUnresolvedSymbols())
+              result |= GenericSignatureErrorFlags::HasInvalidRequirements;
+          }
+        }
+      }
+    }
   }
 
   return result;

test/Generics/rdar113943346.swift

@@ -0,0 +1,15 @@
+// RUN: %target-typecheck-verify-swift
+
+struct G<T, U, V> {}
+
+struct Foo<T> {}
+
+extension G where T == Foo<V.Bar>, U == Foo<Int> {}
+// expected-error@-1 {{'Bar' is not a member type of type 'V'}}
+
+extension G where U == Foo<Int> {
+  func f() {
+    print(T.self)
+    print(U.self)
+  }
+}