[RequirementMachine] Compute and diagnose conflicting rules in the minimal

rewrite system of a generic/requirement signature.

Author: hborla

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -411,6 +411,7 @@ RequirementSignatureRequestRQM::evaluate(Evaluator &evaluator,
         RequirementMachineMode::Enabled) {
       SmallVector<RequirementError, 4> errors;
       machine->System.computeRedundantRequirementDiagnostics(errors);
+      machine->System.computeConflictDiagnostics(errors, proto->getLoc());
       diagnoseRequirementErrors(ctx, errors,
                                 /*allowConcreteGenericParams=*/false);
     }
@@ -844,6 +845,7 @@ InferredGenericSignatureRequestRQM::evaluate(
         ctx.LangOpts.RequirementMachineInferredSignatures ==
         RequirementMachineMode::Enabled) {
       machine->System.computeRedundantRequirementDiagnostics(errors);
+      machine->System.computeConflictDiagnostics(errors, loc);
       diagnoseRequirementErrors(ctx, errors, allowConcreteGenericParams);
     }
 

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -752,6 +752,73 @@ void RewriteSystem::freeze() {
   ConflictingRules.clear();
 }
 
+void RewriteSystem::computeConflictDiagnostics(
+    SmallVectorImpl<RequirementError> &errors, SourceLoc signatureLoc) {
+  for (auto pair : ConflictingRules) {
+    auto *firstRule = &getRule(pair.first);
+    auto *secondRule = &getRule(pair.second);
+
+    auto firstProperty = firstRule->isPropertyRule();
+    auto secondProperty = secondRule->isPropertyRule();
+    if (!firstProperty || !secondProperty)
+      continue;
+
+    auto recordError = [&](Symbol subject, Symbol constraint) {
+      auto subjectType = subject.getConcreteType();
+      switch (constraint.getKind()) {
+      case Symbol::Kind::ConcreteType:
+        errors.push_back(RequirementError::forConcreteTypeMismatch(
+            subjectType, constraint.getConcreteType(), signatureLoc));
+        return;
+
+      case Symbol::Kind::Superclass:
+        errors.push_back(RequirementError::forSameTypeMissingRequirement(
+            {RequirementKind::Superclass, subjectType, constraint.getConcreteType()},
+            signatureLoc));
+        return;
+
+      case Symbol::Kind::Protocol:
+        errors.push_back(RequirementError::forSameTypeMissingRequirement(
+            {RequirementKind::Conformance, subjectType,
+             constraint.getProtocol()->getDeclaredInterfaceType()},
+            signatureLoc));
+        return;
+
+      case Symbol::Kind::Layout:
+        errors.push_back(RequirementError::forSameTypeMissingRequirement(
+            {RequirementKind::Layout, subjectType, constraint.getLayoutConstraint()},
+            signatureLoc));
+        return;
+
+      case Symbol::Kind::ConcreteConformance:
+      case Symbol::Kind::AssociatedType:
+      case Symbol::Kind::GenericParam:
+      case Symbol::Kind::Name:
+        return;
+      }
+    };
+
+    if (firstProperty->getKind() == Symbol::Kind::ConcreteType) {
+      recordError(*firstProperty, *secondProperty);
+    } else if (secondProperty->getKind() == Symbol::Kind::ConcreteType) {
+      recordError(*secondProperty, *firstProperty);
+    } else {
+      // FIXME: This can happen when there are conflicting requirements
+      // on a type parameter, e.g. conflicting superclass requirements:
+      //
+      //   class C1 {}
+      //   class C2 {}
+      //   protocol P { associatedtype A: C1 }
+      //   func conflict<T: P>(_: T) where T.A: C2 {}
+      //
+      // In this case, we want to compute the type `T.A` from
+      // its corresponding term. For this, we need the property map
+      // from the RequirementMachine.
+      continue;
+    }
+  }
+}
+
 void RewriteSystem::dump(llvm::raw_ostream &out) const {
   out << "Rewrite system: {\n";
   for (const auto &rule : Rules) {

lib/AST/RequirementMachine/RewriteSystem.h

@@ -229,6 +229,9 @@ class RewriteSystem final {
 
   void computeRedundantRequirementDiagnostics(SmallVectorImpl<RequirementError> &errors);
 
+  void computeConflictDiagnostics(SmallVectorImpl<RequirementError> &errors,
+                                  SourceLoc signatureLoc);
+
 private:
   struct CriticalPair {
     MutableTerm LHS;

test/Generics/requirement_machine_diagnostics.swift

@@ -197,4 +197,107 @@ func inferred6<T : P11>(_: T) where T.Y : Hashable, T.Z == Set<T.X>, T.X == T.Y
 
 func typeMatcherSugar<T>(_: T) where Array<Int> == Array<T>, Array<Int> == Array<T> {}
 // expected-warning@-1 2{{redundant same-type constraint 'Array<Int>' == 'Array<T>'}}
-// expected-warning@-2{{redundant same-type constraint 'T' == 'Int'}}
+// expected-warning@-2{{redundant same-type constraint 'T' == 'Int'}}
+
+// MARK: - Conflict diagnostics
+
+protocol ProtoAlias1 {
+  typealias A1 = Int
+}
+
+protocol ProtoAlias2 {
+  typealias A2 = String
+}
+
+func basicConflict<T: ProtoAlias1 & ProtoAlias2>(_:T) where T.A1 == T.A2 {}
+// expected-error@-1{{generic signature requires types 'Int' and 'String' to be the same}}
+
+protocol RequiresAnyObject {
+  associatedtype A: AnyObject
+}
+
+protocol RequiresConformance {
+  associatedtype A: P
+}
+
+class Super {}
+protocol RequiresSuperclass {
+  associatedtype A: Super
+}
+
+func testMissingRequirements() {
+  struct S {}
+  func conflict1<T: RequiresAnyObject>(_: T) where T.A == S {}
+  // expected-error@-1{{same-type constraint type 'S' does not conform to required protocol 'AnyObject'}}
+
+  func conflict2<T: RequiresConformance>(_: T) where T.A == C {}
+  // expected-error@-1{{same-type constraint type 'C' does not conform to required protocol 'P'}}
+
+  // FIXME: Diagnose conflicting superclass requirements on T.A
+  class C {}
+  func conflict3<T: RequiresSuperclass>(_: T) where T.A == C {}
+  func conflict4<T: RequiresSuperclass>(_: T) where T.A: C {}
+}
+
+protocol Fooable {
+  associatedtype Foo
+
+  var foo: Foo { get }
+}
+
+protocol Barrable {
+  associatedtype Bar: Fooable
+  var bar: Bar { get }
+}
+
+func sameTypeConflicts() {
+
+  struct X {}
+  struct Y: Fooable {
+    typealias Foo = X
+    var foo: X { return X() }
+  }
+  struct Z: Barrable {
+    typealias Bar = Y
+    var bar: Y { return Y() }
+  }
+
+  // expected-error@+1{{generic signature requires types 'Y' and 'X' to be the same}}
+  func fail1<
+    T: Fooable, U: Fooable
+  >(_ t: T, u: U) -> (X, Y)
+    where T.Foo == X, U.Foo == Y, T.Foo == U.Foo {
+    fatalError()
+  }
+
+  // expected-error@+1{{generic signature requires types 'X' and 'Y' to be the same}}
+  func fail2<
+    T: Fooable, U: Fooable
+  >(_ t: T, u: U) -> (X, Y)
+    where T.Foo == U.Foo, T.Foo == X, U.Foo == Y {
+    fatalError()
+  }
+
+  // expected-error@+1{{same-type constraint type 'X' does not conform to required protocol 'Fooable'}}
+  func fail3<T: Barrable>(_ t: T) -> X
+    where T.Bar == X {
+    fatalError()
+  }
+
+  // expected-error@+1{{generic signature requires types 'Z' and 'X' to be the same}}
+  func fail4<T: Barrable>(_ t: T) -> (Y, Z)
+    where
+    T.Bar == Y,
+    T.Bar.Foo == Z {
+    fatalError()
+  }
+
+  // expected-error@+1{{generic signature requires types 'Z' and 'X' to be the same}}
+  func fail5<T: Barrable>(_ t: T) -> (Y, Z)
+    where
+    T.Bar.Foo == Z,
+    T.Bar == Y {
+    fatalError()
+  }
+
+}