RequirementMachine: Factor out PropertyMap::concretizeTypeWitnessInConformance()

Author: slavapestov

lib/AST/RequirementMachine/PropertyMap.h

@@ -216,6 +216,13 @@ class PropertyMap {
                    llvm::TinyPtrVector<ProtocolConformance *> &conformances,
                    SmallVectorImpl<InducedRule> &inducedRules) const;
 
+  void concretizeTypeWitnessInConformance(
+                   Term key, RequirementKind requirementKind,
+                   CanType concreteType, ArrayRef<Term> substitutions,
+                   const ProtocolDecl *proto, ProtocolConformance *concrete,
+                   AssociatedTypeDecl *assocType,
+                   SmallVectorImpl<InducedRule> &inducedRules) const;
+
   MutableTerm computeConstraintTermForTypeWitness(
       Term key, CanType concreteType, CanType typeWitness,
       const MutableTerm &subjectType, ArrayRef<Term> substitutions) const;

lib/AST/RequirementMachine/PropertyUnification.cpp

@@ -428,7 +428,7 @@ void PropertyMap::concretizeNestedTypesFromConcreteParents(
           RequirementKind::SameType,
           props->ConcreteType->getConcreteType(),
           props->ConcreteType->getSubstitutions(),
-          props->getConformsTo(),
+          props->ConformsTo,
           props->ConcreteConformances,
           inducedRules);
     }
@@ -523,70 +523,83 @@ void PropertyMap::concretizeNestedTypesFromConcreteParent(
       continue;
 
     for (auto *assocType : assocTypes) {
-      if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
-        llvm::dbgs() << "^^ " << "Looking up type witness for "
-                     << proto->getName() << ":" << assocType->getName()
-                     << " on " << concreteType << "\n";
-      }
+      concretizeTypeWitnessInConformance(key, requirementKind,
+                                         concreteType, substitutions,
+                                         proto, concrete, assocType,
+                                         inducedRules);
+    }
+  }
+}
 
-      auto t = concrete->getTypeWitness(assocType);
-      if (!t) {
-        if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
-          llvm::dbgs() << "^^ " << "Type witness for " << assocType->getName()
-                       << " of " << concreteType << " could not be inferred\n";
-        }
+void PropertyMap::concretizeTypeWitnessInConformance(
+    Term key, RequirementKind requirementKind,
+    CanType concreteType, ArrayRef<Term> substitutions,
+    const ProtocolDecl *proto, ProtocolConformance *concrete,
+    AssociatedTypeDecl *assocType,
+    SmallVectorImpl<InducedRule> &inducedRules) const {
 
-        t = ErrorType::get(concreteType);
-      }
+  if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
+    llvm::dbgs() << "^^ " << "Looking up type witness for "
+                 << proto->getName() << ":" << assocType->getName()
+                 << " on " << concreteType << "\n";
+  }
 
-      auto typeWitness = t->getCanonicalType();
+  auto t = concrete->getTypeWitness(assocType);
+  if (!t) {
+    if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
+      llvm::dbgs() << "^^ " << "Type witness for " << assocType->getName()
+                   << " of " << concreteType << " could not be inferred\n";
+    }
 
-      if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
-        llvm::dbgs() << "^^ " << "Type witness for " << assocType->getName()
-                     << " of " << concreteType << " is " << typeWitness << "\n";
-      }
+    t = ErrorType::get(concreteType);
+  }
 
-      MutableTerm subjectType(key);
-      subjectType.add(Symbol::forAssociatedType(proto, assocType->getName(),
-                                                Context));
+  auto typeWitness = t->getCanonicalType();
 
-      MutableTerm constraintType;
+  if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
+    llvm::dbgs() << "^^ " << "Type witness for " << assocType->getName()
+                 << " of " << concreteType << " is " << typeWitness << "\n";
+  }
 
-      auto simplify = [&](CanType t) -> CanType {
-        return CanType(t.transformRec([&](Type t) -> Optional<Type> {
-          if (!t->isTypeParameter())
-            return None;
+  MutableTerm subjectType(key);
+  subjectType.add(Symbol::forAssociatedType(proto, assocType->getName(),
+                                            Context));
 
-          auto term = Context.getRelativeTermForType(t->getCanonicalType(),
-                                                     substitutions);
-          System.simplify(term);
-          return Context.getTypeForTerm(term, { });
-        }));
-      };
+  MutableTerm constraintType;
 
-      if (simplify(concreteType) == simplify(typeWitness) &&
-          requirementKind == RequirementKind::SameType) {
-        // FIXME: ConcreteTypeInDomainMap should support substitutions so
-        // that we can remove this.
+  auto simplify = [&](CanType t) -> CanType {
+    return CanType(t.transformRec([&](Type t) -> Optional<Type> {
+      if (!t->isTypeParameter())
+        return None;
 
-        if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
-          llvm::dbgs() << "^^ Type witness is the same as the concrete type\n";
-        }
+      auto term = Context.getRelativeTermForType(t->getCanonicalType(),
+                                                 substitutions);
+      System.simplify(term);
+      return Context.getTypeForTerm(term, { });
+    }));
+  };
 
-        // Add a rule T.[P:A] => T.
-        constraintType = MutableTerm(key);
-      } else {
-        constraintType = computeConstraintTermForTypeWitness(
-            key, concreteType, typeWitness, subjectType,
-            substitutions);
-      }
+  if (simplify(concreteType) == simplify(typeWitness) &&
+      requirementKind == RequirementKind::SameType) {
+    // FIXME: ConcreteTypeInDomainMap should support substitutions so
+    // that we can remove this.
 
-      inducedRules.emplace_back(subjectType, constraintType);
-      if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
-        llvm::dbgs() << "^^ Induced rule " << constraintType
-                     << " => " << subjectType << "\n";
-      }
+    if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
+      llvm::dbgs() << "^^ Type witness is the same as the concrete type\n";
     }
+
+    // Add a rule T.[P:A] => T.
+    constraintType = MutableTerm(key);
+  } else {
+    constraintType = computeConstraintTermForTypeWitness(
+        key, concreteType, typeWitness, subjectType,
+        substitutions);
+  }
+
+  inducedRules.emplace_back(subjectType, constraintType);
+  if (Debug.contains(DebugFlags::ConcretizeNestedTypes)) {
+    llvm::dbgs() << "^^ Induced rule " << constraintType
+                 << " => " << subjectType << "\n";
   }
 }
 
@@ -677,12 +690,36 @@ void PropertyMap::recordConcreteConformanceRules(
       // minimizes as
       //
       // <T where T == Int>.
+      //
+      // We model this by marking unsatisfied conformance rules as conflicts.
+
+      // The conformances in ConcreteConformances should appear in the same
+      // order as the protocols in ConformsTo.
+      auto conformanceIter = props->ConcreteConformances.begin();
+
       for (unsigned i : indices(props->ConformsTo)) {
-        auto *proto = props->ConformsTo[i];
         auto conformanceRuleID = props->ConformsToRules[i];
+        if (conformanceIter == props->ConcreteConformances.end()) {
+          // FIXME: We should mark the more specific rule of the conformance and
+          // concrete type rules as conflicting.
+          System.getRule(conformanceRuleID).markConflicting();
+          continue;
+        }
+
+        auto *proto = props->ConformsTo[i];
+        if (proto != (*conformanceIter)->getProtocol()) {
+          // FIXME: We should mark the more specific rule of the conformance and
+          // concrete type rules as conflicting.
+          System.getRule(conformanceRuleID).markConflicting();
+          continue;
+        }
+
         recordConcreteConformanceRule(concreteRuleID, conformanceRuleID, proto,
                                       inducedRules);
+        ++conformanceIter;
       }
+
+      assert(conformanceIter == props->ConcreteConformances.end());
     }
 
     if (props->Superclass) {