[Sema] Update diagnostics.

Author: amritpan

include/swift/AST/DiagnosticsSema.def

@@ -663,8 +663,8 @@ ERROR(expr_keypath_mutating_getter,none,
       "which has a mutating getter",
       (const ValueDecl *, bool))
 ERROR(expr_keypath_static_member,none,
-      "%select{key path|dynamic key path member lookup}1 cannot refer to static member %0",
-      (const ValueDecl *, bool))
+      "static member %0 cannot be used on instance of type %1",
+      (const ValueDecl *, Type))
 ERROR(expr_keypath_enum_case,none,
       "%select{key path|dynamic key path member lookup}1 cannot refer to enum case %0",
       (const ValueDecl *, bool))

include/swift/Sema/CSFix.h

@@ -2023,11 +2023,13 @@ class AllowInvalidRefInKeyPath final : public ConstraintFix {
   } Kind;
 
   ValueDecl *Member;
+  Type BaseType;
 
   AllowInvalidRefInKeyPath(ConstraintSystem &cs, RefKind kind,
-                           ValueDecl *member, ConstraintLocator *locator)
+                           ValueDecl *member, ConstraintLocator *locator,
+                           Type baseType = Type())
       : ConstraintFix(cs, FixKind::AllowInvalidRefInKeyPath, locator),
-        Kind(kind), Member(member) {}
+        Kind(kind), Member(member), BaseType(baseType) {}
 
 public:
   std::string getName() const override {
@@ -2064,7 +2066,8 @@ class AllowInvalidRefInKeyPath final : public ConstraintFix {
 private:
   static AllowInvalidRefInKeyPath *create(ConstraintSystem &cs, RefKind kind,
                                           ValueDecl *member,
-                                          ConstraintLocator *locator);
+                                          ConstraintLocator *locator,
+                                          Type baseType = Type());
 };
 
 class RemoveReturn final : public ContextualMismatch {

lib/Sema/CSDiagnostics.cpp

@@ -4975,7 +4975,8 @@ bool AllowTypeOrInstanceMemberFailure::diagnoseAsError() {
     // components, let's provide a tailored diagnostic and return because
     // that is unsupported so there is no fix-it.
     if (locator->isInKeyPathComponent()) {
-      InvalidStaticMemberRefInKeyPath failure(getSolution(), Member, locator);
+      InvalidStaticMemberRefInKeyPath failure(getSolution(), BaseType, Member,
+                                              locator);
       return failure.diagnoseAsError();
     }
 
@@ -6266,8 +6267,7 @@ SourceLoc InvalidMemberRefInKeyPath::getLoc() const {
 }
 
 bool InvalidStaticMemberRefInKeyPath::diagnoseAsError() {
-  emitDiagnostic(diag::expr_keypath_static_member, getMember(),
-                 isForKeyPathDynamicMemberLookup());
+  emitDiagnostic(diag::expr_keypath_static_member, getMember(), getBaseType());
   return true;
 }
 

lib/Sema/CSDiagnostics.h

@@ -1749,20 +1749,25 @@ class InvalidMemberRefInKeyPath : public FailureDiagnostic {
 };
 
 /// Diagnose an attempt to reference a static member as a key path component
-/// e.g.
+/// without .Type e.g.
 ///
 /// ```swift
 /// struct S {
 ///   static var foo: Int = 42
 /// }
 ///
-/// _ = \S.Type.foo
+/// _ = \S.foo
 /// ```
 class InvalidStaticMemberRefInKeyPath final : public InvalidMemberRefInKeyPath {
+  Type BaseType;
+
 public:
-  InvalidStaticMemberRefInKeyPath(const Solution &solution, ValueDecl *member,
-                                  ConstraintLocator *locator)
-      : InvalidMemberRefInKeyPath(solution, member, locator) {}
+  InvalidStaticMemberRefInKeyPath(const Solution &solution, Type baseType,
+                                  ValueDecl *member, ConstraintLocator *locator)
+      : InvalidMemberRefInKeyPath(solution, member, locator),
+        BaseType(baseType->getRValueType()) {}
+
+  Type getBaseType() const { return BaseType; }
 
   bool diagnoseAsError() override;
 };

lib/Sema/CSFix.cpp

@@ -1206,7 +1206,8 @@ bool AllowInvalidRefInKeyPath::diagnose(const Solution &solution,
                                         bool asNote) const {
   switch (Kind) {
   case RefKind::StaticMember: {
-    InvalidStaticMemberRefInKeyPath failure(solution, Member, getLocator());
+    InvalidStaticMemberRefInKeyPath failure(solution, BaseType, Member,
+                                            getLocator());
     return failure.diagnose(asNote);
   }
 
@@ -1286,10 +1287,10 @@ AllowInvalidRefInKeyPath::forRef(ConstraintSystem &cs, ValueDecl *member,
 
 AllowInvalidRefInKeyPath *
 AllowInvalidRefInKeyPath::create(ConstraintSystem &cs, RefKind kind,
-                                 ValueDecl *member,
-                                 ConstraintLocator *locator) {
+                                 ValueDecl *member, ConstraintLocator *locator,
+                                 Type baseType) {
   return new (cs.getAllocator())
-      AllowInvalidRefInKeyPath(cs, kind, member, locator);
+      AllowInvalidRefInKeyPath(cs, kind, member, locator, baseType);
 }
 
 bool RemoveAddressOf::diagnose(const Solution &solution, bool asNote) const {