RequirementMachine: Introduce Rule::isIdentityConformanceRule()

Author: slavapestov

lib/AST/RequirementMachine/GeneratingConformances.cpp

@@ -89,6 +89,10 @@ void HomotopyGenerator::findProtocolConformanceRules(
   bool foundAny = false;
   for (unsigned ruleID : redundantRules) {
     const auto &rule = system.getRule(ruleID);
+
+    if (rule.isIdentityConformanceRule())
+      continue;
+
     if (auto *proto = rule.isProtocolConformanceRule()) {
       result[proto].first.push_back(ruleID);
       foundAny = true;
@@ -107,6 +111,10 @@ void HomotopyGenerator::findProtocolConformanceRules(
       switch (step.Kind) {
       case RewriteStep::ApplyRewriteRule: {
         const auto &rule = system.getRule(step.RuleID);
+
+        if (rule.isIdentityConformanceRule())
+          break;
+
         if (auto *proto = rule.isProtocolConformanceRule()) {
           if (step.StartOffset > 0 &&
               step.EndOffset == 0) {
@@ -157,7 +165,13 @@ RewriteSystem::decomposeTermIntoConformanceRuleLeftHandSides(
          "Canonical conformance term should simplify in one step");
 
   const auto &step = *steps.begin();
-  assert(getRule(step.RuleID).isProtocolConformanceRule());
+
+#ifndef NDEBUG
+  const auto &rule = getRule(step.RuleID);
+  assert(rule.isProtocolConformanceRule());
+  assert(!rule.isIdentityConformanceRule());
+#endif
+
   assert(step.Kind == RewriteStep::ApplyRewriteRule);
   assert(step.EndOffset == 0);
   assert(!step.Inverse);
@@ -183,6 +197,7 @@ RewriteSystem::decomposeTermIntoConformanceRuleLeftHandSides(
     SmallVectorImpl<unsigned> &result) const {
   const auto &rule = getRule(ruleID);
   assert(rule.isProtocolConformanceRule());
+  assert(!rule.isIdentityConformanceRule());
 
   // Compute domain(V).
   const auto &lhs = rule.getLHS();
@@ -596,6 +611,9 @@ void RewriteSystem::computeGeneratingConformances(
   // can be expressed as itself.
   for (unsigned ruleID : indices(Rules)) {
     const auto &rule = getRule(ruleID);
+    if (rule.isPermanent())
+      continue;
+
     if (rule.isRedundant())
       continue;
 
@@ -706,4 +724,4 @@ void RewriteSystem::computeGeneratingConformances(
       llvm::dbgs() << "- " << getRule(pair.first) << "\n";
     }
   }
-}
+}

lib/AST/RequirementMachine/HomotopyReduction.cpp

@@ -1087,6 +1087,10 @@ void RewriteSystem::verifyRedundantConformances(
     llvm::DenseSet<unsigned> redundantConformances) const {
   for (unsigned ruleID : redundantConformances) {
     const auto &rule = getRule(ruleID);
+    assert(!rule.isPermanent() &&
+           "Permanent rule cannot be redundant");
+    assert(!rule.isIdentityConformanceRule() &&
+           "Identity conformance cannot be redundant");
     assert(rule.isProtocolConformanceRule() &&
            "Redundant conformance is not a conformance rule?");
 

lib/AST/RequirementMachine/PropertyMap.cpp

@@ -334,6 +334,9 @@ RewriteSystem::buildPropertyMap(PropertyMap &map,
     if (rule.isSimplified())
       continue;
 
+    if (rule.isPermanent())
+      continue;
+
     // Collect all rules of the form T.[p] => T where T is canonical.
     auto property = rule.isPropertyRule();
     if (!property)

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -40,13 +40,6 @@ Optional<Symbol> Rule::isPropertyRule() const {
   if (!std::equal(RHS.begin(), RHS.end(), LHS.begin()))
     return None;
 
-  // A same-type requirement of the form 'Self.Foo == Self' can induce a
-  // conformance rule [P].[P] => [P]. Don't consider this a property-like
-  // rule, since it messes up the generating conformances algorithm and
-  // doesn't mean anything useful anyway.
-  if (RHS.size() == 1 && RHS[0] == LHS[1])
-    return None;
-
   return property;
 }
 
@@ -61,6 +54,16 @@ const ProtocolDecl *Rule::isProtocolConformanceRule() const {
   return nullptr;
 }
 
+/// If this is a rule of the form [P].[P] => [P] where [P] is a protocol
+/// symbol, return true, otherwise return false.
+bool Rule::isIdentityConformanceRule() const {
+  return (LHS.size() == 2 &&
+          RHS.size() == 1 &&
+          LHS[0] == RHS[0] &&
+          LHS[0] == LHS[1] &&
+          LHS[0].getKind() == Symbol::Kind::Protocol);
+}
+
 /// If this is a rule of the form [P].[Q] => [P] where [P] and [Q] are
 /// protocol symbols, return true, otherwise return false.
 bool Rule::isProtocolRefinementRule() const {

lib/AST/RequirementMachine/RewriteSystem.h

@@ -79,6 +79,8 @@ class Rule final {
 
   const ProtocolDecl *isProtocolConformanceRule() const;
 
+  bool isIdentityConformanceRule() const;
+
   bool isProtocolRefinementRule() const;
 
   /// See above for an explanation.