Guard feature behind experimental flag.

Author: amritpan

include/swift/AST/DiagnosticsSema.def

@@ -663,6 +663,9 @@ ERROR(expr_keypath_mutating_getter,none,
       "%select{key path|dynamic key path member lookup}1 cannot refer to %0, "
       "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))
 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/Basic/Features.def

@@ -233,6 +233,7 @@ EXPERIMENTAL_FEATURE(TupleConformances, false)
 EXPERIMENTAL_FEATURE(FullTypedThrows, false)
 EXPERIMENTAL_FEATURE(SameElementRequirements, false)
 EXPERIMENTAL_FEATURE(GlobalActorInferenceCutoff, false)
+EXPERIMENTAL_FEATURE(KeyPathWithStaticMembers, false)
 
 // Whether to enable @_used and @_section attributes
 EXPERIMENTAL_FEATURE(SymbolLinkageMarkers, true)

include/swift/Sema/CSFix.h

@@ -2026,6 +2026,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,
@@ -2050,6 +2053,8 @@ class AllowInvalidRefInKeyPath final : public ConstraintFix {
 public:
   std::string getName() const override {
     switch (Kind) {
+    case RefKind::StaticMember:
+      return "allow reference to a static member as a key path component";
     case RefKind::MutatingGetter:
       return "allow reference to a member with mutating getter as a key "
              "path component";

lib/AST/FeatureSet.cpp

@@ -196,6 +196,7 @@ UNINTERESTING_FEATURE(GroupActorErrors)
 UNINTERESTING_FEATURE(SameElementRequirements)
 UNINTERESTING_FEATURE(UnspecifiedMeansMainActorIsolated)
 UNINTERESTING_FEATURE(GlobalActorInferenceCutoff)
+UNINTERESTING_FEATURE(KeyPathWithStaticMembers)
 
 static bool usesFeatureSendingArgsAndResults(Decl *decl) {
   auto isFunctionTypeWithSending = [](Type type) {

lib/Sema/CSDiagnostics.cpp

@@ -6339,13 +6339,19 @@ bool InvalidStaticMemberRefInKeyPath::diagnoseAsError() {
   auto rootTyRepr = KPE->getExplicitRootType();
   auto isProtocol = getBaseType()->isExistentialType();
 
-  if (rootTyRepr && !isProtocol) {
-    emitDiagnostic(diag::could_not_use_type_member_on_instance, getBaseType(),
-                   DeclNameRef(getMember()->getName()))
-        .fixItInsert(rootTyRepr->getEndLoc(), ".Type");
+  if (!getConstraintSystem().getASTContext().LangOpts.hasFeature(
+          Feature::KeyPathWithStaticMembers)) {
+    emitDiagnostic(diag::expr_keypath_static_member, getMember(),
+                   isForKeyPathDynamicMemberLookup());
   } else {
-    emitDiagnostic(diag::could_not_use_type_member_on_instance, getBaseType(),
-                   DeclNameRef(getMember()->getName()));
+    if (rootTyRepr && !isProtocol) {
+      emitDiagnostic(diag::could_not_use_type_member_on_instance, getBaseType(),
+                     DeclNameRef(getMember()->getName()))
+          .fixItInsert(rootTyRepr->getEndLoc(), ".Type");
+    } else {
+      emitDiagnostic(diag::could_not_use_type_member_on_instance, getBaseType(),
+                     DeclNameRef(getMember()->getName()));
+    }
   }
 
   return true;

lib/Sema/CSFix.cpp

@@ -1230,6 +1230,10 @@ TreatKeyPathSubscriptIndexAsHashable::create(ConstraintSystem &cs, Type type,
 bool AllowInvalidRefInKeyPath::diagnose(const Solution &solution,
                                         bool asNote) const {
   switch (Kind) {
+  case RefKind::StaticMember: {
+    return false;
+  }
+
   case RefKind::EnumCase: {
     InvalidEnumCaseRefInKeyPath failure(solution, Member, getLocator());
     return failure.diagnose(asNote);
@@ -1277,6 +1281,13 @@ AllowInvalidRefInKeyPath *
 AllowInvalidRefInKeyPath::forRef(ConstraintSystem &cs, Type baseType,
                                  ValueDecl *member,
                                  ConstraintLocator *locator) {
+
+  if (!cs.getASTContext().LangOpts.hasFeature(
+          Feature::KeyPathWithStaticMembers) &&
+      member->isStatic())
+    return AllowInvalidRefInKeyPath::create(cs, baseType, RefKind::StaticMember,
+                                            member, locator);
+
   // Referencing (instance or static) methods in key path is
   // not currently allowed.
   if (isa<FuncDecl>(member))

test/Interpreter/keypath.swift

@@ -1,5 +1,6 @@
-// RUN: %target-run-simple-swift | %FileCheck %s
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-feature -Xfrontend KeyPathWithStaticMembers) | %FileCheck %s
 
+// REQUIRES: asserts
 // REQUIRES: executable_test
 
 // UNSUPPORTED: use_os_stdlib

test/Interpreter/static_keypaths.swift

@@ -2,13 +2,13 @@
 // RUN: split-file %s %t/src
 
 /// Build LibA
-// RUN: %host-build-swift %t/src/LibA.swift -swift-version 5 -emit-module -emit-library -enable-library-evolution -module-name LibA -o %t/%target-library-name(LibA) -emit-module-interface-path %t/LibA.swiftinterface
+// RUN: %host-build-swift %t/src/LibA.swift -swift-version 5 -enable-experimental-feature KeyPathWithStaticMembers -emit-module -emit-library -enable-library-evolution -module-name LibA -o %t/%target-library-name(LibA) -emit-module-interface-path %t/LibA.swiftinterface
 
 // Build LibB
-// RUN: %target-build-swift %t/src/LibB.swift -I %t -L %t -l LibA -swift-version 5 -emit-module -emit-library -module-name LibB -o %t/%target-library-name(LibB)
+// RUN: %target-build-swift %t/src/LibB.swift -I %t -L %t -l LibA -swift-version 5 -enable-experimental-feature KeyPathWithStaticMembers -emit-module -emit-library -module-name LibB -o %t/%target-library-name(LibB)
 
 // Build LibC
-// RUN: %target-build-swift %t/src/LibC.swift -I %t -L %t -l LibA -swift-version 5 -emit-module -emit-library -module-name LibC -o %t/%target-library-name(LibC)
+// RUN: %target-build-swift %t/src/LibC.swift -I %t -L %t -l LibA -swift-version 5 -enable-experimental-feature KeyPathWithStaticMembers -emit-module -emit-library -module-name LibC -o %t/%target-library-name(LibC)
 
 // Build & run main.swift
 // RUN: %target-build-swift -I %t -L %t -l LibA -l LibB -l LibC %t/src/main.swift -o %t/a.out

test/SILGen/keypaths.swift

@@ -1,4 +1,6 @@
-// RUN: %target-swift-emit-silgen -disable-availability-checking -parse-stdlib -module-name keypaths %s | %FileCheck %s
+// RUN: %target-swift-emit-silgen -enable-experimental-feature KeyPathWithStaticMembers -disable-availability-checking -parse-stdlib -module-name keypaths %s | %FileCheck %s
+
+// REQUIRES: asserts
 
 import Swift
 
@@ -719,4 +721,4 @@ protocol HasAlias {
 
 func testHasAlias() {
   _ = \HasAlias.id
-}
+}

test/SILOptimizer/access_wmo_diagnose.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -parse-as-library -emit-sil -enforce-exclusivity=checked -primary-file %s -o /dev/null -verify
+// RUN: %target-swift-frontend -enable-experimental-feature KeyPathWithStaticMembers -parse-as-library -emit-sil -enforce-exclusivity=checked -primary-file %s -o /dev/null -verify
 
 // AccessEnforcementWMO assumes that the only way to address a global or static
 // property is via a formal begin_access. If we ever allow keypaths for static