RequirementMachine: Simplify RewriteSystem::processConflicts()

Remove the logic which incorrectly attempted to simulate the
GenericSignatureBuilder's minimization behavior in the presence
of conflicts, since it doesn't matter anymore.

Author: slavapestov

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -244,36 +244,25 @@ void RewriteSystem::propagateRedundantRequirementIDs() {
   }
 }
 
-/// After propagating the 'explicit' bit on rules, process pairs of
-/// conflicting rules, marking one or both of the rules as conflicting,
-/// which instructs minimization to drop them.
+/// Process pairs of conflicting rules, marking the more specific rule as
+/// conflicting, which instructs minimization to drop this rule.
 void RewriteSystem::processConflicts() {
   for (auto pair : ConflictingRules) {
-    auto existingRuleID = pair.first;
-    auto newRuleID = pair.second;
-
-    auto *existingRule = &getRule(existingRuleID);
-    auto *newRule = &getRule(newRuleID);
-
-    auto existingKind = existingRule->isPropertyRule()->getKind();
-    auto newKind = newRule->isPropertyRule()->getKind();
-
-    // The GSB preferred to drop an explicit rule in a conflict, but
-    // only if the kinds were the same.
-    if (existingRule->isExplicit() && !newRule->isExplicit() &&
-        existingKind == newKind) {
-      std::swap(existingRule, newRule);
-    }
-
-    if (newRule->getRHS().size() >= existingRule->getRHS().size()) {
+    auto *existingRule = &getRule(pair.first);
+    auto *newRule = &getRule(pair.second);
+
+    // The identity conformance rule ([P].[P] => [P]) will conflict with
+    // a concrete type requirement in an invalid protocol declaration
+    // where 'Self' is constrained to a type that does not conform to
+    // the protocol. This rule is permanent, so don't mark it as
+    // conflicting in this case.
+
+    if (!existingRule->isIdentityConformanceRule() &&
+        existingRule->getRHS().size() >= newRule->getRHS().size())
+      existingRule->markConflicting();
+    if (!newRule->isIdentityConformanceRule() &&
+        newRule->getRHS().size() >= existingRule->getRHS().size())
       newRule->markConflicting();
-    } else if (existingKind != Symbol::Kind::Superclass &&
-               existingKind == newKind) {
-      // The GSB only dropped the new rule in the case of a conflicting
-      // superclass requirement, so maintain that behavior here.
-      if (existingRule->getRHS().size() >= newRule->getRHS().size())
-        existingRule->markConflicting();
-    }
 
     // FIXME: Diagnose the conflict later.
   }

test/Generics/concrete_conflict.swift

@@ -36,7 +36,7 @@ class Class<T> {}
 
 extension Class where T == Bool {
   // CHECK-LABEL: .badRequirement()@
-  // CHECK-NEXT: <T where T == Bool>
+  // CHECK-NEXT: <T>
   func badRequirement() where T == Int { }
   // expected-error@-1 {{generic parameter 'T' cannot be equal to both 'Int' and 'Bool'}}
 }

test/Generics/superclass_and_concrete_requirement.swift

@@ -14,7 +14,7 @@ protocol P1 {
 }
 
 // CHECK-LABEL: .P2@
-// CHECK-NEXT: Requirement signature: <Self where Self.[P2]T == S>
+// CHECK-NEXT: Requirement signature: <Self>
 protocol P2 {
   associatedtype T where T : C, T == S
   // expected-error@-1 {{'Self.T' requires that 'S' inherit from 'C'}}
@@ -23,7 +23,7 @@ protocol P2 {
 }
 
 // CHECK-LABEL: .P3@
-// CHECK-NEXT: Requirement signature: <Self where Self.[P3]T == S>
+// CHECK-NEXT: Requirement signature: <Self>
 protocol P3 {
   associatedtype T where T == S, T : C
   // expected-error@-1 {{'Self.T' requires that 'S' inherit from 'C'}}

test/attr/attr_specialize.swift

@@ -177,6 +177,8 @@ func funcWithForbiddenSpecializeRequirement<T>(_ t: T) {
 // expected-warning@-3{{redundant constraint 'T' : '_Trivial'}}
 // expected-note@-4 {{constraint 'T' : '_Trivial' implied here}}
 // expected-note@-5 2{{constraint conflicts with 'T' : '_Trivial(32)'}}
+// expected-error@-6 {{too few generic parameters are specified in '_specialize' attribute (got 0, but expected 1)}}
+// expected-note@-7 {{missing constraint for 'T' in '_specialize' attribute}}
 @_specialize(where T: _Trivial, T: _Trivial(64))
 // expected-warning@-1{{redundant constraint 'T' : '_Trivial'}}
 // expected-note@-2 1{{constraint 'T' : '_Trivial' implied here}}