[Diagnostics] Diagnose key path reference to initializer methods.

Author: LucianoPAlmeida

lib/Sema/CSDiagnostics.h

@@ -1519,24 +1519,26 @@ class InvalidMemberWithMutatingGetterInKeyPath final
   bool diagnoseAsError() override;
 };
 
-/// Diagnose an attempt to reference a method as a key path component
+/// Diagnose an attempt to reference a method or initializer as a key path component
 /// e.g.
 ///
 /// ```swift
 /// struct S {
+///   init() { }
 ///   func foo() -> Int { return 42 }
 ///   static func bar() -> Int { return 0 }
 /// }
 ///
 /// _ = \S.foo
 /// _ = \S.Type.bar
+/// _ = \S.init
 /// ```
 class InvalidMethodRefInKeyPath final : public InvalidMemberRefInKeyPath {
 public:
   InvalidMethodRefInKeyPath(const Solution &solution, ValueDecl *method,
                             ConstraintLocator *locator)
       : InvalidMemberRefInKeyPath(solution, method, locator) {
-    assert(isa<FuncDecl>(method));
+    assert(isa<FuncDecl>(method) || isa<ConstructorDecl>(method));
   }
 
   bool diagnoseAsError() override;

lib/Sema/CSFix.cpp

@@ -747,7 +747,8 @@ bool AllowInvalidRefInKeyPath::diagnose(const Solution &solution,
     return failure.diagnose(asNote);
   }
 
-  case RefKind::Method: {
+  case RefKind::Method:
+  case RefKind::Initializer: {
     InvalidMethodRefInKeyPath failure(solution, Member, getLocator());
     return failure.diagnose(asNote);
   }
@@ -764,6 +765,11 @@ AllowInvalidRefInKeyPath::forRef(ConstraintSystem &cs, ValueDecl *member,
     return AllowInvalidRefInKeyPath::create(cs, RefKind::Method, member,
                                             locator);
 
+  // Referencing initializers in key path is not currently allowed.
+  if (isa<ConstructorDecl>(member))
+    return AllowInvalidRefInKeyPath::create(cs, RefKind::Initializer,
+                                            member, locator);
+
   // Referencing static members in key path is not currently allowed.
   if (member->isStatic())
     return AllowInvalidRefInKeyPath::create(cs, RefKind::StaticMember, member,

lib/Sema/CSFix.h

@@ -1278,6 +1278,9 @@ class AllowInvalidRefInKeyPath final : public ConstraintFix {
     // Allow a reference to a method (instance or static) as
     // a key path component.
     Method,
+    // Allow a reference to a initializer instance as a key path
+    // component.
+    Initializer,
   } Kind;
 
   ValueDecl *Member;
@@ -1297,6 +1300,8 @@ class AllowInvalidRefInKeyPath final : public ConstraintFix {
              "path component";
     case RefKind::Method:
       return "allow reference to a method as a key path component";
+    case RefKind::Initializer:
+      return "allow reference to an init method as a key path component";
     }
     llvm_unreachable("covered switch");
   }

lib/Sema/CSSimplify.cpp

@@ -6305,6 +6305,9 @@ static ConstraintFix *validateInitializerRef(ConstraintSystem &cs,
     // which means MetatypeType has to be added after finding a type variable.
     if (locatorEndsWith(baseLocator, ConstraintLocator::MemberRefBase))
       baseType = MetatypeType::get(baseType);
+  } else if (auto *keyPathExpr = dyn_cast<KeyPathExpr>(anchor)) {
+    // Key path can't refer to initializers e.g. `\Type.init`
+    return AllowInvalidRefInKeyPath::forRef(cs, init, locator);
   }
 
   if (!baseType)