[CSBindings] Emit specific key path root arg if generic param type var being bound to hole has a key path root representatee

Author: LucianoPAlmeida

lib/Sema/CSBindings.cpp

@@ -1089,12 +1089,22 @@ bool TypeVariableBinding::attempt(ConstraintSystem &cs) const {
 
       ConstraintFix *fix = nullptr;
       if (auto *GP = TypeVar->getImpl().getGenericParameter()) {
-        auto path = dstLocator->getPath();
-        // Drop `generic parameter` locator element so that all missing
-        // generic parameters related to the same path can be coalesced later.
-        fix = DefaultGenericArgument::create(
-            cs, GP,
-            cs.getConstraintLocator(dstLocator->getAnchor(), path.drop_back()));
+        // If it is represetative for a key path root, let's emit a more
+        // specific diagnostic.
+        auto *keyPathRoot =
+            cs.isRepresentativeFor(TypeVar, ConstraintLocator::KeyPathRoot);
+        if (keyPathRoot) {
+          fix = SpecifyKeyPathRootType::create(
+              cs, keyPathRoot->getImpl().getLocator());
+        } else {
+          auto path = dstLocator->getPath();
+          // Drop `generic parameter` locator element so that all missing
+          // generic parameters related to the same path can be coalesced later.
+          fix = DefaultGenericArgument::create(
+              cs, GP,
+              cs.getConstraintLocator(dstLocator->getAnchor(),
+                                      path.drop_back()));
+        }
       } else if (TypeVar->getImpl().isClosureParameterType()) {
         fix = SpecifyClosureParameterType::create(cs, dstLocator);
       } else if (TypeVar->getImpl().isClosureResultType()) {

lib/Sema/ConstraintSystem.h

@@ -3071,6 +3071,35 @@ class ConstraintSystem {
     return typeVar->getImpl().getRepresentative(getSavedBindings());
   }
 
+  /// Finds if the given type variable is representative for a type
+  /// variable which last locator path element is of the specified kind.
+  /// If true returns the type variable which it is the representative for.
+  TypeVariableType *
+  isRepresentativeFor(TypeVariableType *typeVar,
+                      ConstraintLocator::PathElementKind kind) const {
+    // We only attempt to look for this if type variable is
+    // a representative.
+    if (getRepresentative(typeVar) != typeVar)
+      return nullptr;
+
+    auto &CG = getConstraintGraph();
+    auto result = CG.lookupNode(typeVar);
+    auto equivalence = result.first.getEquivalenceClass();
+    auto member = llvm::find_if(equivalence, [=](TypeVariableType *eq) {
+      auto *loc = eq->getImpl().getLocator();
+      if (!loc)
+        return false;
+
+      auto path = loc->getPath();
+      return !path.empty() && path.back().getKind() == kind;
+    });
+
+    if (member == equivalence.end())
+      return nullptr;
+
+    return *member;
+  }
+
   /// Gets the VarDecl associateed with resolvedOverload, and the type of the
   /// storage wrapper if the decl has an associated storage wrapper.
   Optional<std::pair<VarDecl *, Type>>