RequirementMachine: Implement GenericSignature::getSuperclassBound() query

Author: slavapestov

include/swift/AST/RequirementMachine.h

@@ -60,6 +60,7 @@ class RequirementMachine final {
   LayoutConstraint getLayoutConstraint(Type depType) const;
   bool requiresProtocol(Type depType, const ProtocolDecl *proto) const;
   GenericSignature::RequiredProtocols getRequiredProtocols(Type depType) const;
+  Type getSuperclassBound(Type depType) const;
   bool isConcreteType(Type depType) const;
   bool areSameTypeParameterInContext(Type depType1, Type depType2) const;
   Type getCanonicalTypeInContext(Type type,

lib/AST/GenericSignature.cpp

@@ -332,19 +332,61 @@ Type GenericSignatureImpl::getSuperclassBound(Type type) const {
   assert(type->isTypeParameter() &&
          "Only type parameters can have superclass requirements");
 
-  auto &builder = *getGenericSignatureBuilder();
-  auto equivClass =
-  builder.resolveEquivalenceClass(
-                                type,
-                                ArchetypeResolutionKind::CompleteWellFormed);
-  if (!equivClass) return nullptr;
+  auto computeViaGSB = [&]() -> Type {
+    auto &builder = *getGenericSignatureBuilder();
+    auto equivClass =
+    builder.resolveEquivalenceClass(
+                                  type,
+                                  ArchetypeResolutionKind::CompleteWellFormed);
+    if (!equivClass) return nullptr;
+
+    // If this type was mapped to a concrete type, then there is no
+    // requirement.
+    if (equivClass->concreteType) return nullptr;
+
+    // Retrieve the superclass bound.
+    return equivClass->superclass;
+  };
+
+  auto computeViaRQM = [&]() {
+    auto *machine = getRequirementMachine();
+    return machine->getSuperclassBound(type);
+  };
+
+  auto &ctx = getASTContext();
+  if (ctx.LangOpts.EnableRequirementMachine) {
+    auto rqmResult = computeViaRQM();
+
+#ifndef NDEBUG
+    auto gsbResult = computeViaGSB();
 
-  // If this type was mapped to a concrete type, then there is no
-  // requirement.
-  if (equivClass->concreteType) return nullptr;
+    auto check = [&]() {
+      if (!gsbResult || !rqmResult)
+        return !gsbResult == !rqmResult;
+      return gsbResult->isEqual(rqmResult);
+    };
+
+    if (!check()) {
+      llvm::errs() << "RequirementMachine::getSuperclassBound() is broken\n";
+      llvm::errs() << "Generic signature: " << GenericSignature(this) << "\n";
+      llvm::errs() << "Dependent type: "; type.dump(llvm::errs());
+      llvm::errs() << "GenericSignatureBuilder says: " << gsbResult << "\n";
+      if (gsbResult)
+        gsbResult.dump(llvm::errs());
+      llvm::errs() << "\n";
+      llvm::errs() << "RequirementMachine says: " << rqmResult << "\n";
+      if (rqmResult)
+        rqmResult.dump(llvm::errs());
+      llvm::errs() << "\n";
+      getRequirementMachine()->dump(llvm::errs());
+      abort();
+    }
+#endif
 
-  // Retrieve the superclass bound.
-  return equivClass->superclass;
+    return rqmResult;
+  } else {
+    return computeViaGSB();
+  }
 }
 
 /// Determine the set of protocols to which the given type parameter is

lib/AST/RequirementMachine/EquivalenceClassMap.cpp

@@ -129,6 +129,20 @@ static Type getTypeFromSubstitutionSchema(Type schema,
   });
 }
 
+/// Get the superclass bound of this equivalence class.
+///
+/// Asserts if this equivalence class does not have a superclass bound.
+Type EquivalenceClass::getSuperclassBound(
+    TypeArrayView<GenericTypeParamType> genericParams,
+    const ProtocolGraph &protos,
+    RewriteContext &ctx) const {
+  return getTypeFromSubstitutionSchema(Superclass->getSuperclass(),
+                                       Superclass->getSubstitutions(),
+                                       genericParams,
+                                       protos,
+                                       ctx);
+}
+
 /// Get the concrete type of this equivalence class.
 ///
 /// Asserts if this equivalence class is not concrete.

lib/AST/RequirementMachine/EquivalenceClassMap.h

@@ -87,6 +87,11 @@ class EquivalenceClass {
     return Superclass.hasValue();
   }
 
+  Type getSuperclassBound(
+      TypeArrayView<GenericTypeParamType> genericParams,
+      const ProtocolGraph &protos,
+      RewriteContext &ctx) const;
+
   bool isConcreteType() const {
     return ConcreteType.hasValue();
   }

lib/AST/RequirementMachine/RequirementMachine.cpp

@@ -508,6 +508,23 @@ RequirementMachine::getRequiredProtocols(Type depType) const {
   return result;
 }
 
+Type RequirementMachine::getSuperclassBound(Type depType) const {
+  auto term = Impl->Context.getMutableTermForType(depType->getCanonicalType(),
+                                                  /*proto=*/nullptr);
+  Impl->System.simplify(term);
+  Impl->verify(term);
+
+  auto *equivClass = Impl->Map.lookUpEquivalenceClass(term);
+  if (!equivClass)
+    return Type();
+
+  if (!equivClass->hasSuperclassBound())
+    return Type();
+
+  auto &protos = Impl->System.getProtocols();
+  return equivClass->getSuperclassBound({ }, protos, Impl->Context);
+}
+
 bool RequirementMachine::isConcreteType(Type depType) const {
   auto term = Impl->Context.getMutableTermForType(depType->getCanonicalType(),
                                                   /*proto=*/nullptr);