Merge pull request #41303 from slavapestov/rqm-superclass-unification

RequirementMachine: Record rewrite loops during superclass unification

Author: slavapestov

include/swift/AST/Decl.h

@@ -4026,7 +4026,7 @@ class ClassDecl final : public NominalTypeDecl {
   ClassDecl *getSuperclassDecl() const;
 
   /// Check if this class is a superclass or equal to the given class.
-  bool isSuperclassOf(ClassDecl *other) const;
+  bool isSuperclassOf(const ClassDecl *other) const;
 
   /// Set the superclass of this class.
   void setSuperclass(Type superclass);
@@ -4121,7 +4121,7 @@ class ClassDecl final : public NominalTypeDecl {
 
   /// Whether the class uses the ObjC object model (reference counting,
   /// allocation, etc.), the Swift model, or has no reference counting at all.
-  ReferenceCounting getObjectModel() {
+  ReferenceCounting getObjectModel() const {
     if (isForeignReferenceType())
       return ReferenceCounting::None;
 
@@ -4131,7 +4131,7 @@ class ClassDecl final : public NominalTypeDecl {
     return ReferenceCounting::Native;
   }
 
-  LayoutConstraintKind getLayoutConstraintKind() {
+  LayoutConstraintKind getLayoutConstraintKind() const {
     if (getObjectModel() == ReferenceCounting::ObjC)
       return LayoutConstraintKind::Class;
 
@@ -4261,7 +4261,7 @@ class ClassDecl final : public NominalTypeDecl {
   /// Used to determine if this class decl is a foriegn reference type. I.e., a
   /// non-reference-counted swift reference type that was imported from a C++
   /// record.
-  bool isForeignReferenceType();
+  bool isForeignReferenceType() const;
 };
 
 /// The set of known protocols for which derived conformances are supported.

lib/AST/Decl.cpp

@@ -4936,7 +4936,7 @@ void swift::simple_display(llvm::raw_ostream &out, AncestryFlags value) {
   out << " }";
 }
 
-bool ClassDecl::isSuperclassOf(ClassDecl *other) const {
+bool ClassDecl::isSuperclassOf(const ClassDecl *other) const {
   llvm::SmallPtrSet<const ClassDecl *, 8> visited;
 
   do {
@@ -5081,7 +5081,7 @@ bool ClassDecl::walkSuperclasses(
   return false;
 }
 
-bool ClassDecl::isForeignReferenceType() {
+bool ClassDecl::isForeignReferenceType() const {
   return getClangDecl() && isa<clang::RecordDecl>(getClangDecl());
 }
 

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(
@@ -250,6 +269,18 @@ class PropertyMap {
 
   void addConformanceProperty(Term key, Symbol property, unsigned ruleID);
   void addLayoutProperty(Term key, Symbol property, unsigned ruleID);
+
+  void unifyConcreteTypes(Term key,
+                          Optional<Symbol> &existingProperty,
+                          Optional<unsigned> &existingRuleID,
+                          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);