RequirementMachine: Implement GenericSignature::isConcreteType() query

Author: slavapestov

include/swift/AST/RequirementMachine.h

@@ -57,6 +57,7 @@ class RequirementMachine final {
   bool requiresClass(Type depType) const;
   LayoutConstraint getLayoutConstraint(Type depType) const;
   bool requiresProtocol(Type depType, const ProtocolDecl *proto) const;
+  bool isConcreteType(Type depType) const;
 
   void dump(llvm::raw_ostream &out) const;
 };

lib/AST/GenericSignature.cpp

@@ -431,7 +431,47 @@ bool GenericSignatureImpl::requiresProtocol(Type type,
 
 /// Determine whether the given dependent type is equal to a concrete type.
 bool GenericSignatureImpl::isConcreteType(Type type) const {
-  return bool(getConcreteType(type));
+  assert(type->isTypeParameter() && "Expected a type parameter");
+
+  auto computeViaGSB = [&]() {
+    auto &builder = *getGenericSignatureBuilder();
+    auto equivClass =
+      builder.resolveEquivalenceClass(
+                                    type,
+                                    ArchetypeResolutionKind::CompleteWellFormed);
+    if (!equivClass) return false;
+
+    return bool(equivClass->concreteType);
+  };
+
+  auto computeViaRQM = [&]() {
+    auto *machine = getRequirementMachine();
+    return machine->isConcreteType(type);
+  };
+
+  auto &ctx = getASTContext();
+  if (ctx.LangOpts.EnableRequirementMachine) {
+    bool rqmResult = computeViaRQM();
+
+#ifndef NDEBUG
+    bool gsbResult = computeViaGSB();
+
+    if (gsbResult != rqmResult) {
+      llvm::errs() << "RequirementMachine::isConcreteType() 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();
+  }
 }
 
 /// Return the concrete type that the given type parameter is constrained to,

lib/AST/RequirementMachine/RequirementMachine.cpp

@@ -388,4 +388,16 @@ bool RequirementMachine::requiresProtocol(Type depType,
   }
 
   return false;
+}
+
+bool RequirementMachine::isConcreteType(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;
+
+  return equivClass->isConcreteType();
 }