RequirementMachine: Implement GenericSignature::areSameTypeParametersInContext() query

Author: slavapestov

include/swift/AST/RequirementMachine.h

@@ -54,10 +54,12 @@ class RequirementMachine final {
 public:
   ~RequirementMachine();
 
+  // Generic signature queries
   bool requiresClass(Type depType) const;
   LayoutConstraint getLayoutConstraint(Type depType) const;
   bool requiresProtocol(Type depType, const ProtocolDecl *proto) const;
   bool isConcreteType(Type depType) const;
+  bool areSameTypeParameterInContext(Type depType1, Type depType2) const;
 
   void dump(llvm::raw_ostream &out) const;
 };

lib/AST/GenericSignature.cpp

@@ -543,8 +543,40 @@ bool GenericSignatureImpl::areSameTypeParameterInContext(Type type1,
   if (type1.getPointer() == type2.getPointer())
     return true;
 
-  return areSameTypeParameterInContext(type1, type2,
-                                       *getGenericSignatureBuilder());
+  auto computeViaGSB = [&]() {
+    return areSameTypeParameterInContext(type1, type2,
+                                         *getGenericSignatureBuilder());
+  };
+
+  auto computeViaRQM = [&]() {
+    auto *machine = getRequirementMachine();
+    return machine->areSameTypeParameterInContext(type1, type2);
+  };
+
+  auto &ctx = getASTContext();
+  if (ctx.LangOpts.EnableRequirementMachine) {
+    auto rqmResult = computeViaRQM();
+
+#ifndef NDEBUG
+    auto gsbResult = computeViaGSB();
+
+    if (gsbResult != rqmResult) {
+      llvm::errs() << "RequirementMachine::areSameTypeParameterInContext() is broken\n";
+      llvm::errs() << "Generic signature: " << GenericSignature(this) << "\n";
+      llvm::errs() << "First dependent type: "; type1.dump(llvm::errs());
+      llvm::errs() << "Second dependent type: "; type2.dump(llvm::errs());
+      llvm::errs() << "\n";
+      llvm::errs() << "GenericSignatureBuilder says: " << gsbResult << "\n";
+      llvm::errs() << "RequirementMachine says: " << rqmResult << "\n";
+      getRequirementMachine()->dump(llvm::errs());
+      abort();
+    }
+#endif
+
+    return rqmResult;
+  } else {
+    return computeViaGSB();
+  }
 }
 
 bool GenericSignatureImpl::areSameTypeParameterInContext(Type type1,

lib/AST/RequirementMachine/RequirementMachine.cpp

@@ -400,4 +400,17 @@ bool RequirementMachine::isConcreteType(Type depType) const {
     return false;
 
   return equivClass->isConcreteType();
+}
+
+bool RequirementMachine::areSameTypeParameterInContext(Type depType1,
+                                                       Type depType2) const {
+  auto term1 = Impl->Context.getMutableTermForType(depType1->getCanonicalType(),
+                                                   /*proto=*/nullptr);
+  Impl->System.simplify(term1);
+
+  auto term2 = Impl->Context.getMutableTermForType(depType2->getCanonicalType(),
+                                                   /*proto=*/nullptr);
+  Impl->System.simplify(term2);
+
+  return (term1 == term2);
 }