RequirementMachine: Record rewrite loops during superclass unification

This is the second half of rdar://problem/88134910.

Also addresses rdar://problem/25065503.

Author: slavapestov

lib/AST/RequirementMachine/ConcreteTypeWitness.cpp

@@ -63,12 +63,13 @@ void PropertyMap::concretizeNestedTypesFromConcreteParents() {
         llvm::dbgs() << "- via superclass requirement\n";
       }
 
+      const auto &superclassReq = props->getSuperclassRequirement();
       concretizeNestedTypesFromConcreteParent(
           props->getKey(),
           RequirementKind::Superclass,
-          *props->SuperclassRule,
-          props->Superclass->getConcreteType(),
-          props->Superclass->getSubstitutions(),
+          *superclassReq.SuperclassRule,
+          superclassReq.SuperclassType->getConcreteType(),
+          superclassReq.SuperclassType->getSubstitutions(),
           props->ConformsToRules,
           props->ConformsTo,
           props->SuperclassConformances);

lib/AST/RequirementMachine/PropertyMap.cpp

@@ -115,11 +115,12 @@ void PropertyBag::dump(llvm::raw_ostream &out) const {
     out << " layout: " << Layout;
   }
 
-  if (Superclass) {
-    out << " superclass: " << *Superclass;
+  if (hasSuperclassBound()) {
+    const auto &superclassReq = getSuperclassRequirement();
+    out << " superclass: " << *superclassReq.SuperclassType;
   }
 
-  if (ConcreteType) {
+  if (isConcreteType()) {
     out << " concrete_type: " << *ConcreteType;
   }
 
@@ -154,8 +155,10 @@ Type PropertyBag::getSuperclassBound(
     const MutableTerm &lookupTerm,
     const PropertyMap &map) const {
   MutableTerm prefix = getPrefixAfterStrippingKey(lookupTerm);
-  return map.getTypeFromSubstitutionSchema(Superclass->getConcreteType(),
-                                           Superclass->getSubstitutions(),
+
+  const auto &req = getSuperclassRequirement();
+  return map.getTypeFromSubstitutionSchema(req.SuperclassType->getConcreteType(),
+                                           req.SuperclassType->getSubstitutions(),
                                            genericParams, prefix);
 }
 
@@ -199,17 +202,23 @@ void PropertyBag::copyPropertiesFrom(const PropertyBag *next,
   // T := UV should have substitutions {UX1, ..., UXn}.
   MutableTerm prefix(Key.begin(), Key.begin() + prefixLength);
 
-  if (next->Superclass) {
-    Superclass = next->Superclass->prependPrefixToConcreteSubstitutions(
-        prefix, ctx);
-    SuperclassRule = next->SuperclassRule;
-  }
-
   if (next->ConcreteType) {
     ConcreteType = next->ConcreteType->prependPrefixToConcreteSubstitutions(
         prefix, ctx);
     ConcreteTypeRule = next->ConcreteTypeRule;
   }
+
+  // Copy over class hierarchy information.
+  SuperclassDecl = next->SuperclassDecl;
+  if (!next->Superclasses.empty()) {
+    Superclasses = next->Superclasses;
+
+    for (auto &pair : Superclasses) {
+      pair.second.SuperclassType =
+          pair.second.SuperclassType->prependPrefixToConcreteSubstitutions(
+              prefix, ctx);
+    }
+  }
 }
 
 void PropertyBag::verify(const RewriteSystem &system) const {
@@ -221,11 +230,18 @@ void PropertyBag::verify(const RewriteSystem &system) const {
     assert(symbol.getProtocol() == ConformsTo[i]);
   }
 
-  // FIXME: Once unification introduces new rules, add asserts requiring
-  // that the layout, superclass and concrete type symbols match, as above
+  // FIXME: Add asserts requiring that the layout, superclass and
+  // concrete type symbols match, as above
   assert(!Layout.isNull() == LayoutRule.hasValue());
-  assert(Superclass.hasValue() == SuperclassRule.hasValue());
   assert(ConcreteType.hasValue() == ConcreteTypeRule.hasValue());
+
+  assert((SuperclassDecl == nullptr) == Superclasses.empty());
+  for (const auto &pair : Superclasses) {
+    const auto &req = pair.second;
+    assert(req.SuperclassType.hasValue());
+    assert(req.SuperclassRule.hasValue());
+  }
+
 #endif
 }
 

lib/AST/RequirementMachine/PropertyMap.h

@@ -44,6 +44,16 @@ namespace rewriting {
 class MutableTerm;
 class Term;
 
+/// Records a superclass constraint at a given level in the class hierarchy.
+struct SuperclassRequirement {
+  /// The most specific superclass constraint (in type difference order) for
+  /// this level in the class hierarchy.
+  Optional<Symbol> SuperclassType;
+
+  /// The corresponding superclass rule for the above.
+  Optional<unsigned> SuperclassRule;
+};
+
 /// Stores a convenient representation of all "property-like" rewrite rules of
 /// the form T.[p] => T, where [p] is a property symbol, for some term 'T'.
 class PropertyBag {
@@ -64,11 +74,14 @@ class PropertyBag {
   /// The corresponding layout rule for the above.
   Optional<unsigned> LayoutRule;
 
-  /// The most specific superclass constraint this type satisfies.
-  Optional<Symbol> Superclass;
+  /// The most specific superclass declaration for which this type has a
+  /// superclass constraint.
+  const ClassDecl *SuperclassDecl = nullptr;
 
-  /// The corresponding superclass rule for the above.
-  Optional<unsigned> SuperclassRule;
+  /// Used for unifying superclass rules at different levels in the class
+  /// hierarchy. For each class declaration, stores a symbol and rule pair
+  /// for the most specific substituted type.
+  llvm::SmallDenseMap<const ClassDecl *, SuperclassRequirement, 2> Superclasses;
 
   /// All concrete conformances of Superclass to the protocols in the
   /// ConformsTo list.
@@ -97,16 +110,22 @@ class PropertyBag {
   PropertyBag &operator=(const PropertyBag &) = delete;
   PropertyBag &operator=(PropertyBag &&) = delete;
 
+  const SuperclassRequirement &getSuperclassRequirement() const {
+    assert(SuperclassDecl != nullptr);
+    auto found = Superclasses.find(SuperclassDecl);
+    return found->second;
+  }
+
 public:
   Term getKey() const { return Key; }
   void dump(llvm::raw_ostream &out) const;
 
   bool hasSuperclassBound() const {
-    return Superclass.hasValue();
+    return SuperclassDecl != nullptr;
   }
 
   CanType getSuperclassBound() const {
-    return Superclass->getConcreteType();
+    return getSuperclassRequirement().SuperclassType->getConcreteType();
   }
 
   Type getSuperclassBound(
@@ -257,6 +276,11 @@ class PropertyMap {
                           Symbol property,
                           unsigned ruleID);
 
+  void recordSuperclassRelation(Term key,
+                                Symbol superclassType,
+                                unsigned superclassRuleID,
+                                const ClassDecl *otherClass);
+
   void addSuperclassProperty(Term key, Symbol property, unsigned ruleID);
   void addConcreteTypeProperty(Term key, Symbol property, unsigned ruleID);