If static keypath is declared in module built with Swift 6.0 compiler or older,

emit diagnostic that recommends rebuilding that module.

Author: amritpan

include/swift/AST/DiagnosticsSema.def

@@ -724,6 +724,11 @@ WARNING(expr_deprecated_writable_keypath,Deprecation,
         "forming a writable keypath to property %0 that is read-only in this context "
         "is deprecated and will be removed in a future release",
         (const ValueDecl *))
+ERROR(static_keypath_older_compiler_version,none,
+      "cannot form a keypath to a static property %0 of type %1",
+      (const ValueDecl *, Type))
+NOTE(rebuild_module,none,
+     "rebuild %0 to enable the feature", (const ModuleDecl *))
 
 // Selector expressions.
 ERROR(expr_selector_no_objc_runtime,none,

include/swift/Sema/CSFix.h

@@ -2023,6 +2023,9 @@ class TreatKeyPathSubscriptIndexAsHashable final : public ConstraintFix {
 
 class AllowInvalidRefInKeyPath final : public ConstraintFix {
   enum RefKind {
+    // 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,
     // Allow a reference to a declaration with mutating getter as
     // a key path component.
     MutatingGetter,
@@ -2038,15 +2041,20 @@ class AllowInvalidRefInKeyPath final : public ConstraintFix {
 
   ValueDecl *Member;
   Type BaseType;
+  Identifier ModuleName;
 
   AllowInvalidRefInKeyPath(ConstraintSystem &cs, Type baseType, RefKind kind,
-                           ValueDecl *member, ConstraintLocator *locator)
+                           ValueDecl *member, Identifier moduleName, ConstraintLocator *locator)
       : ConstraintFix(cs, FixKind::AllowInvalidRefInKeyPath, locator),
-        Kind(kind), Member(member), BaseType(baseType) {}
+        Kind(kind), Member(member), BaseType(baseType), ModuleName(moduleName) {}
 
 public:
   std::string getName() const override {
     switch (Kind) {
+    case RefKind::StaticMember:
+      return "allow reference to a static member as a key path component if "
+             "member is declared in a module built with Swift 6.0 compiler or "
+             "older.";
     case RefKind::MutatingGetter:
       return "allow reference to a member with mutating getter as a key "
              "path component";
@@ -2077,7 +2085,7 @@ class AllowInvalidRefInKeyPath final : public ConstraintFix {
 
 private:
   static AllowInvalidRefInKeyPath *create(ConstraintSystem &cs, Type baseType,
-                                          RefKind kind, ValueDecl *member,
+                                          RefKind kind, ValueDecl *member, Identifier moduleName,
                                           ConstraintLocator *locator);
 };
 

lib/Sema/CSDiagnostics.cpp

@@ -4975,8 +4975,7 @@ bool AllowTypeOrInstanceMemberFailure::diagnoseAsError() {
     // If this is a reference to a static member by one of the key path
     // components, let's provide a tailored diagnostic with fix-it.
     if (locator->isInKeyPathComponent()) {
-      InvalidStaticMemberRefInKeyPath failure(getSolution(), BaseType, Member,
-                                              locator);
+      InvalidStaticMemberRefInKeyPath failure(getSolution(), BaseType, Member, Identifier(), locator);
       return failure.diagnoseAsError();
     }
 
@@ -6268,10 +6267,16 @@ SourceLoc InvalidMemberRefInKeyPath::getLoc() const {
 }
 
 bool InvalidStaticMemberRefInKeyPath::diagnoseAsError() {
+  if (!getModuleName().empty()) {
+    emitDiagnostic(diag::static_keypath_older_compiler_version, getMember(), getBaseType());
+  //  emitDiagnosticAt(getMember(), diag::rebuild_module, getModuleName());
+    return true;
+  }
+  
   auto *KPE = getAsExpr<KeyPathExpr>(getRawAnchor());
   auto rootTyRepr = KPE->getExplicitRootType();
   auto isProtocol = getBaseType()->isExistentialType();
-
+  
   if (rootTyRepr && !isProtocol) {
     emitDiagnostic(diag::expr_keypath_static_member, getMember(), getBaseType())
         .fixItInsert(rootTyRepr->getEndLoc(), ".Type");

lib/Sema/CSDiagnostics.h

@@ -1762,14 +1762,17 @@ class InvalidMemberRefInKeyPath : public FailureDiagnostic {
 /// ```
 class InvalidStaticMemberRefInKeyPath final : public InvalidMemberRefInKeyPath {
   Type BaseType;
+  Identifier ModuleName;
 
 public:
   InvalidStaticMemberRefInKeyPath(const Solution &solution, Type baseType,
-                                  ValueDecl *member, ConstraintLocator *locator)
+                                  ValueDecl *member, Identifier moduleName, ConstraintLocator *locator)
       : InvalidMemberRefInKeyPath(solution, member, locator),
-        BaseType(baseType->getRValueType()) {}
+        BaseType(baseType->getRValueType()), ModuleName(moduleName) {}
 
   Type getBaseType() const { return BaseType; }
+  
+  Identifier getModuleName() const { return ModuleName; }
 
   bool diagnoseAsError() override;
 };

lib/Sema/CSFix.cpp

@@ -1206,6 +1206,10 @@ TreatKeyPathSubscriptIndexAsHashable::create(ConstraintSystem &cs, Type type,
 bool AllowInvalidRefInKeyPath::diagnose(const Solution &solution,
                                         bool asNote) const {
   switch (Kind) {
+  case RefKind::StaticMember: {
+    InvalidStaticMemberRefInKeyPath failure(solution, BaseType, Member, ModuleName, getLocator());
+    return failure.diagnose(asNote);
+  }
   case RefKind::EnumCase: {
     InvalidEnumCaseRefInKeyPath failure(solution, Member, getLocator());
     return failure.diagnose(asNote);
@@ -1257,36 +1261,51 @@ AllowInvalidRefInKeyPath::forRef(ConstraintSystem &cs, Type baseType,
   // not currently allowed.
   if (isa<FuncDecl>(member))
     return AllowInvalidRefInKeyPath::create(cs, baseType, RefKind::Method,
-                                            member, locator);
+                                            member, Identifier(), locator);
 
   // Referencing enum cases in key path is not currently allowed.
   if (isa<EnumElementDecl>(member)) {
     return AllowInvalidRefInKeyPath::create(cs, baseType, RefKind::EnumCase,
-                                            member, locator);
+                                            member, Identifier(), locator);
   }
 
   // Referencing initializers in key path is not currently allowed.
   if (isa<ConstructorDecl>(member))
     return AllowInvalidRefInKeyPath::create(cs, baseType, RefKind::Initializer,
-                                            member, locator);
+                                            member, Identifier(), locator);
+
+  // Referencing static members in key path is not currently allowed if they are
+  // declared in a module built with Swift 6.0 compiler version or older.
+  if (cs.shouldAttemptFixes()) {
+    auto &ctx = cs.getASTContext();
+    auto langVersion = ctx.LangOpts.EffectiveLanguageVersion;
+    auto moduleDecl = member->getDeclContext()
+    ->getParentModule();
+    auto moduleName = moduleDecl->getExportAsName();
+    auto compatibilityVersion = moduleDecl
+                                    ->getLanguageVersionBuiltWith();
+    if (member->isStatic() && (compatibilityVersion < langVersion))
+      return AllowInvalidRefInKeyPath::create(
+          cs, baseType, RefKind::StaticMember, member, moduleName, locator);
+  }
 
   if (auto *storage = dyn_cast<AbstractStorageDecl>(member)) {
     // Referencing members with mutating getters in key path is not
     // currently allowed.
     if (storage->isGetterMutating())
       return AllowInvalidRefInKeyPath::create(
-          cs, baseType, RefKind::MutatingGetter, member, locator);
+          cs, baseType, RefKind::MutatingGetter, member, Identifier(), locator);
   }
 
   return nullptr;
 }
 
 AllowInvalidRefInKeyPath *
 AllowInvalidRefInKeyPath::create(ConstraintSystem &cs, Type baseType,
-                                 RefKind kind, ValueDecl *member,
+                                 RefKind kind, ValueDecl *member, Identifier moduleName,
                                  ConstraintLocator *locator) {
   return new (cs.getAllocator())
-      AllowInvalidRefInKeyPath(cs, baseType, kind, member, locator);
+      AllowInvalidRefInKeyPath(cs, baseType, kind, member, moduleName, locator);
 }
 
 bool RemoveAddressOf::diagnose(const Solution &solution, bool asNote) const {