[CSFix] Add a new kind of invalid ref in key path - unsupported static members

Replaces feature flag check with module compiler version check
which implements the behavior discussed in the SE-0438.

Author: xedin

include/swift/Sema/CSFix.h

@@ -2026,9 +2026,11 @@ class TreatKeyPathSubscriptIndexAsHashable final : public ConstraintFix {
 
 class AllowInvalidRefInKeyPath final : public ConstraintFix {
   enum RefKind {
+    // Allow invalid references to static members i.e. on instance of a type.
+    StaticMember,
     // Allow a reference to a static member as a key path component if it is
     // declared in a module with built with Swift 6.0 compiler version or older.
-    StaticMember,
+    UnsupportedStaticMember,
     // Allow a reference to a declaration with mutating getter as
     // a key path component.
     MutatingGetter,
@@ -2054,7 +2056,10 @@ class AllowInvalidRefInKeyPath final : public ConstraintFix {
   std::string getName() const override {
     switch (Kind) {
     case RefKind::StaticMember:
-      return "allow reference to a static member as a key path component";
+      return "allow reference to a static member on invalid base in key path "
+             "context";
+    case RefKind::UnsupportedStaticMember:
+      return "allow unsupported static member reference";
     case RefKind::MutatingGetter:
       return "allow reference to a member with mutating getter as a key "
              "path component";

lib/Sema/CSDiagnostics.cpp

@@ -6337,22 +6337,15 @@ SourceLoc InvalidMemberRefInKeyPath::getLoc() const {
 }
 
 bool InvalidStaticMemberRefInKeyPath::diagnoseAsError() {
-  auto *KPE = getAsExpr<KeyPathExpr>(getRawAnchor());
-  auto rootTyRepr = KPE->getExplicitRootType();
-  auto isProtocol = getBaseType()->isExistentialType();
-
-  if (!getConstraintSystem().getASTContext().LangOpts.hasFeature(
-          Feature::KeyPathWithStaticMembers)) {
-    emitDiagnostic(diag::expr_keypath_static_member, getMember(),
-                   isForKeyPathDynamicMemberLookup());
-  } else {
-    if (rootTyRepr && !isProtocol) {
-      emitDiagnostic(diag::could_not_use_type_member_on_instance, getBaseType(),
-                     DeclNameRef(getMember()->getName()))
-          .fixItInsert(rootTyRepr->getEndLoc(), ".Type");
-    } else {
+  auto diagnostic =
       emitDiagnostic(diag::could_not_use_type_member_on_instance, getBaseType(),
                      DeclNameRef(getMember()->getName()));
+
+  // Suggest adding `.Type` to an explicit root if possible.
+  if (auto *keyPath = getAsExpr<KeyPathExpr>(getRawAnchor())) {
+    if (auto *explicitRoot = keyPath->getExplicitRootType()) {
+      if (explicitRoot && !getBaseType()->isExistentialType())
+        diagnostic.fixItInsert(explicitRoot->getEndLoc(), ".Type");
     }
   }
 

lib/Sema/CSFix.cpp

@@ -1231,6 +1231,12 @@ bool AllowInvalidRefInKeyPath::diagnose(const Solution &solution,
                                         bool asNote) const {
   switch (Kind) {
   case RefKind::StaticMember: {
+    InvalidStaticMemberRefInKeyPath failure(solution, BaseType, Member,
+                                            getLocator());
+    return failure.diagnose(asNote);
+  }
+
+  case RefKind::UnsupportedStaticMember: {
     return false;
   }
 
@@ -1281,12 +1287,23 @@ AllowInvalidRefInKeyPath *
 AllowInvalidRefInKeyPath::forRef(ConstraintSystem &cs, Type baseType,
                                  ValueDecl *member,
                                  ConstraintLocator *locator) {
+  if (member->isStatic() && !isa<FuncDecl>(member)) {
+    // References to static members are supported only for modules that
+    // are built with 6.1+ compilers, libraries produced by earlier
+    // compilers don't have required symbols.
+    if (auto *module = member->getDeclContext()->getParentModule()) {
+      if (module->isBuiltFromInterface() &&
+          module->getSwiftInterfaceCompilerVersion() <
+              llvm::VersionTuple(6, 1)) {
+        return AllowInvalidRefInKeyPath::create(
+            cs, baseType, RefKind::UnsupportedStaticMember, member, locator);
+      }
+    }
 
-  if (!cs.getASTContext().LangOpts.hasFeature(
-          Feature::KeyPathWithStaticMembers) &&
-      member->isStatic())
-    return AllowInvalidRefInKeyPath::create(cs, baseType, RefKind::StaticMember,
-                                            member, locator);
+    if (!baseType->getRValueType()->is<AnyMetatypeType>())
+      return AllowInvalidRefInKeyPath::create(
+          cs, baseType, RefKind::StaticMember, member, locator);
+  }
 
   // Referencing (instance or static) methods in key path is
   // not currently allowed.