RequirementMachine: Implement GenericSignature::requiresClass() query

Author: slavapestov

include/swift/AST/RequirementMachine.h

@@ -22,6 +22,7 @@ class CanType;
 class GenericSignature;
 class ProtocolDecl;
 class Requirement;
+class Type;
 
 /// Wraps a rewrite system with higher-level operations in terms of
 /// generic signatures and interface types.
@@ -47,6 +48,8 @@ class RequirementMachine final {
 
 public:
   ~RequirementMachine();
+
+  bool requiresClass(Type depType) const;
 };
 
 } // end namespace swift

lib/AST/GenericSignature.cpp

@@ -280,21 +280,50 @@ bool GenericSignatureImpl::requiresClass(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 false;
+  auto computeViaGSB = [&]() {
+    auto &builder = *getGenericSignatureBuilder();
+    auto equivClass =
+      builder.resolveEquivalenceClass(
+                                    type,
+                                    ArchetypeResolutionKind::CompleteWellFormed);
+    if (!equivClass) return false;
 
-  // If this type was mapped to a concrete type, then there is no
-  // requirement.
-  if (equivClass->concreteType) return false;
+    // If this type was mapped to a concrete type, then there is no
+    // requirement.
+    if (equivClass->concreteType) return false;
 
-  // If there is a layout constraint, it might be a class.
-  if (equivClass->layout && equivClass->layout->isClass()) return true;
+    // If there is a layout constraint, it might be a class.
+    if (equivClass->layout && equivClass->layout->isClass()) return true;
 
-  return false;
+    return false;
+  };
+
+  auto computeViaRQM = [&]() {
+    auto *machine = getRequirementMachine();
+    return machine->requiresClass(type);
+  };
+
+  auto &ctx = getASTContext();
+  if (ctx.LangOpts.EnableRequirementMachine) {
+    bool rqmResult = computeViaRQM();
+
+#ifndef NDEBUG
+    bool gsbResult = computeViaGSB();
+
+    if (gsbResult != rqmResult) {
+      llvm::errs() << "RequirementMachine::requiresClass() is broken\n";
+      llvm::errs() << "Generic signature: " << GenericSignature(this) << "\n";
+      llvm::errs() << "Dependent type: "; type.dump(llvm::errs());
+      llvm::errs() << "GenericSignatureBuilder says: " << gsbResult << "\n";
+      llvm::errs() << "RequirementMachine says: " << rqmResult << "\n";
+      abort();
+    }
+#endif
+
+    return rqmResult;
+  } else {
+    return computeViaGSB();
+  }
 }
 
 /// Determine the superclass bound on the given dependent type.

lib/AST/RequirementMachine/RequirementMachine.cpp

@@ -336,3 +336,19 @@ void RequirementMachine::computeCompletion(CanGenericSignature sig) {
 bool RequirementMachine::isComplete() const {
   return Impl->Complete;
 }
+
+bool RequirementMachine::requiresClass(Type depType) const {
+  auto term = Impl->Context.getMutableTermForType(depType->getCanonicalType(),
+                                                  /*proto=*/nullptr);
+  Impl->System.simplify(term);
+
+  auto *equivClass = Impl->Map.lookUpEquivalenceClass(term);
+  if (!equivClass)
+    return false;
+
+  if (equivClass->isConcreteType())
+    return false;
+
+  auto layout = equivClass->getLayoutConstraint();
+  return (layout && layout->isClass());
+}