[CSFix] Create AllowKeyPathRootTypeMismatch to diagnose key path root fail on key path application

Author: LucianoPAlmeida

lib/Sema/CSFix.cpp

@@ -1293,3 +1293,17 @@ AllowCoercionToForceCast::create(ConstraintSystem &cs, Type fromType,
   return new (cs.getAllocator())
       AllowCoercionToForceCast(cs, fromType, toType, locator);
 }
+
+bool AllowKeyPathRootTypeMismatch::diagnose(const Solution &solution,
+                                            bool asNote) const {
+  KeyPathRootTypeMismatchFailure failure(solution, getFromType(), getToType(),
+                                         getLocator());
+  return failure.diagnose(asNote);
+}
+
+AllowKeyPathRootTypeMismatch *
+AllowKeyPathRootTypeMismatch::create(ConstraintSystem &cs, Type lhs, Type rhs,
+                                     ConstraintLocator *locator) {
+  return new (cs.getAllocator())
+      AllowKeyPathRootTypeMismatch(cs, lhs, rhs, locator);
+}

lib/Sema/CSFix.h

@@ -251,6 +251,10 @@ enum class FixKind : uint8_t {
 
   /// A warning fix that allows a coercion to perform a force-cast.
   AllowCoercionToForceCast,
+  
+  /// Allow key path root type mismatch when applying a key path with a 
+  /// root type not convertible to the type of the base instance.
+  AllowKeyPathRootTypeMismatch,
 };
 
 class ConstraintFix {
@@ -1768,6 +1772,32 @@ class AllowCoercionToForceCast final : public ContextualMismatch {
                                           ConstraintLocator *locator);
 };
 
+/// Attempt to fix a key path application where the key path type cannot be
+/// applied to a base instance of another type.
+///
+/// \code
+/// func f (_ bar: Bar , keyPath: KeyPath<Foo, Int> ) {
+///   bar[keyPath: keyPath]
+/// }
+/// \endcode
+class AllowKeyPathRootTypeMismatch : public ContextualMismatch {
+protected:
+  AllowKeyPathRootTypeMismatch(ConstraintSystem &cs, Type lhs, Type rhs,
+                               ConstraintLocator *locator)
+      : ContextualMismatch(cs, FixKind::AllowKeyPathRootTypeMismatch, lhs, rhs,
+                           locator) {}
+
+public:
+  std::string getName() const override {
+    return "allow key path root type mismatch";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  static AllowKeyPathRootTypeMismatch *
+  create(ConstraintSystem &cs, Type lhs, Type rhs, ConstraintLocator *locator);
+};
+
 } // end namespace constraints
 } // end namespace swift