RequirementMachine: Implement GenericSignature::isCanonicalTypeInContext() query

Author: slavapestov

include/swift/AST/RequirementMachine.h

@@ -66,6 +66,7 @@ class RequirementMachine final {
   bool isConcreteType(Type depType) const;
   Type getConcreteType(Type depType) const;
   bool areSameTypeParameterInContext(Type depType1, Type depType2) const;
+  bool isCanonicalTypeInContext(Type type) const;
   Type getCanonicalTypeInContext(Type type,
                       TypeArrayView<GenericTypeParamType> genericParams) const;
   ConformanceAccessPath getConformanceAccessPath(Type type,

lib/AST/GenericSignature.cpp

@@ -787,8 +787,39 @@ bool GenericSignatureImpl::isCanonicalTypeInContext(Type type) const {
   if (!type->hasTypeParameter())
     return true;
 
-  auto &builder = *getGenericSignatureBuilder();
-  return isCanonicalTypeInContext(type, builder);
+  auto computeViaGSB = [&]() {
+    auto &builder = *getGenericSignatureBuilder();
+    return isCanonicalTypeInContext(type, builder);
+  };
+
+  auto computeViaRQM = [&]() {
+    auto *machine = getRequirementMachine();
+    return machine->isCanonicalTypeInContext(type);
+  };
+
+  auto &ctx = getASTContext();
+  if (ctx.LangOpts.EnableRequirementMachine) {
+    auto rqmResult = computeViaRQM();
+
+#ifndef NDEBUG
+    auto gsbResult = computeViaGSB();
+
+    if (gsbResult != rqmResult) {
+      llvm::errs() << "RequirementMachine::isCanonicalTypeInContext() is broken\n";
+      llvm::errs() << "Generic signature: " << GenericSignature(this) << "\n";
+      llvm::errs() << "Dependent type: "; type.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::isCanonicalTypeInContext(

lib/AST/RequirementMachine/RequirementMachine.cpp

@@ -637,7 +637,40 @@ RequirementMachine::Implementation::getLongestValidPrefix(const MutableTerm &ter
   return prefix;
 }
 
-/// Unlike the other queries, the input type can be any type, not just a
+/// Unlike most other queries, the input type can be any type, not just a
+/// type parameter.
+///
+/// Returns true if all structural components that are type parameters are
+/// in their canonical form, and are not concrete (in which case they're
+/// not considered canonical, since they can be replaced with their
+/// concrete type).
+bool RequirementMachine::isCanonicalTypeInContext(Type type) const {
+  auto &protos = Impl->System.getProtocols();
+
+  // Look for non-canonical type parameters.
+  return !type.findIf([&](Type component) -> bool {
+    if (!component->isTypeParameter())
+      return false;
+
+    auto term = Impl->Context.getMutableTermForType(component->getCanonicalType(),
+                                                    /*proto=*/nullptr);
+
+    Impl->System.simplify(term);
+    Impl->verify(term);
+
+    auto *equivClass = Impl->Map.lookUpEquivalenceClass(term);
+    if (!equivClass)
+      return false;
+
+    if (equivClass->isConcreteType())
+      return true;
+
+    auto anchor = Impl->Context.getTypeForTerm(term, {}, protos);
+    return CanType(anchor) != CanType(component);
+  });
+}
+
+/// Unlike most other queries, the input type can be any type, not just a
 /// type parameter.
 ///
 /// Replaces all structural components that are type parameters with their