Guard feature behind experimental flag.

Author: amritpan

include/swift/Basic/Features.def

@@ -294,6 +294,7 @@ EXPERIMENTAL_FEATURE(MacrosOnImports, true)
 EXPERIMENTAL_FEATURE(TupleConformances, false)
 EXPERIMENTAL_FEATURE(FullTypedThrows, false)
 EXPERIMENTAL_FEATURE(SameElementRequirements, false)
+EXPERIMENTAL_FEATURE(KeyPathWithMethodMembers, false)
 
 // Whether to enable @_used and @_section attributes
 EXPERIMENTAL_FEATURE(SymbolLinkageMarkers, true)

include/swift/Sema/CSFix.h

@@ -2009,6 +2009,11 @@ class AllowInvalidRefInKeyPath final : public ConstraintFix {
     // a key path component.
     MutatingGetter,
     // Allow a reference to a mutating method.
+    Method,
+    // Allow a reference to a initializer instance as a key path
+    // component.
+    Initializer,
+    // Allow a reference to an enum case as a key path component.
     MutatingMethod,
     // Allow a reference to an async or throwing method.
     AsyncOrThrowsMethod,
@@ -2035,6 +2040,10 @@ class AllowInvalidRefInKeyPath final : public ConstraintFix {
     case RefKind::MutatingGetter:
       return "allow reference to a member with mutating getter as a key "
              "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";
     case RefKind::EnumCase:
       return "allow reference to an enum case as a key path component";
     case RefKind::MutatingMethod:

lib/AST/FeatureSet.cpp

@@ -125,6 +125,7 @@ UNINTERESTING_FEATURE(StructLetDestructuring)
 UNINTERESTING_FEATURE(MacrosOnImports)
 UNINTERESTING_FEATURE(AsyncCallerExecution)
 UNINTERESTING_FEATURE(ExtensibleEnums)
+UNINTERESTING_FEATURE(KeyPathWithMethodMembers)
 
 static bool usesFeatureNonescapableTypes(Decl *decl) {
   auto containsNonEscapable =

lib/Sema/CSDiagnostics.cpp

@@ -6418,6 +6418,12 @@ bool InvalidMemberWithMutatingGetterInKeyPath::diagnoseAsError() {
   return true;
 }
 
+bool UnsupportedMethodRefInKeyPath::diagnoseAsError() {
+  emitDiagnostic(diag::expr_keypath_not_property, getMember(),
+                 isForKeyPathDynamicMemberLookup());
+  return true;
+}
+
 bool InvalidMutatingMethodRefInKeyPath::diagnoseAsError() {
   emitDiagnostic(diag::expr_keypath_mutating_method, getMember(),
                  isForKeyPathDynamicMemberLookup());

lib/Sema/CSDiagnostics.h

@@ -1807,6 +1807,33 @@ class InvalidEnumCaseRefInKeyPath final : public InvalidMemberRefInKeyPath {
   bool diagnoseAsError() override;
 };
 
+/// Diagnose an attempt to reference a method or initializer as a key path
+/// component.
+///
+/// Only diagnosed if `-KeyPathWithMethodMember` feature flag is not set.
+///
+/// ```swift
+/// struct S {
+///   init() { }
+///   func foo() -> Int { return 42 }
+///   static func bar() -> Int { return 0 }
+/// }
+///
+/// _ = \S.foo
+/// _ = \S.Type.bar
+/// _ = \S.init
+/// ```
+class UnsupportedMethodRefInKeyPath final : public InvalidMemberRefInKeyPath {
+public:
+  UnsupportedMethodRefInKeyPath(const Solution &solution, ValueDecl *method,
+                                ConstraintLocator *locator)
+      : InvalidMemberRefInKeyPath(solution, method, locator) {
+    assert(isa<FuncDecl>(method) || isa<ConstructorDecl>(method));
+  }
+
+  bool diagnoseAsError() override;
+};
+
 /// Diagnose an attempt to reference a mutating method as a key path component
 /// e.g.
 ///

lib/Sema/CSFix.cpp

@@ -1251,6 +1251,11 @@ bool AllowInvalidRefInKeyPath::diagnose(const Solution &solution,
                                                      getLocator());
     return failure.diagnose(asNote);
   }
+  case RefKind::Method:
+  case RefKind::Initializer: {
+    UnsupportedMethodRefInKeyPath failure(solution, Member, getLocator());
+    return failure.diagnose(asNote);
+  }
   case RefKind::MutatingMethod: {
     InvalidMutatingMethodRefInKeyPath failure(solution, Member, getLocator());
     return failure.diagnose(asNote);
@@ -1323,22 +1328,41 @@ AllowInvalidRefInKeyPath::forRef(ConstraintSystem &cs, Type baseType,
           cs, baseType, RefKind::MutatingGetter, member, locator);
   }
 
-  // Referencing mutating, throws or async method members is not currently
-  // allowed.
-  if (auto method = dyn_cast<FuncDecl>(member)) {
-    if (method->isAsyncContext())
-      return AllowInvalidRefInKeyPath::create(
-          cs, baseType, RefKind::AsyncOrThrowsMethod, member, locator);
-    if (auto methodType = method->getInterfaceType()->getAs<AnyFunctionType>()) {
-      if (methodType->getResult()->getAs<AnyFunctionType>()->isThrowing())
+  if (cs.getASTContext().LangOpts.hasFeature(
+          Feature::KeyPathWithMethodMembers)) {
+    // Referencing mutating, throws or async method members is not currently
+    // allowed.
+    if (auto method = dyn_cast<FuncDecl>(member)) {
+      if (method->isAsyncContext())
         return AllowInvalidRefInKeyPath::create(
             cs, baseType, RefKind::AsyncOrThrowsMethod, member, locator);
+      if (auto methodType =
+              method->getInterfaceType()->getAs<AnyFunctionType>()) {
+        if (methodType->getResult()->getAs<AnyFunctionType>()->isThrowing())
+          return AllowInvalidRefInKeyPath::create(
+              cs, baseType, RefKind::AsyncOrThrowsMethod, member, locator);
+      }
+      if (method->isMutating())
+        return AllowInvalidRefInKeyPath::create(
+            cs, baseType, RefKind::MutatingMethod, member, locator);
+      return nullptr;
     }
-    if (method->isMutating())
-      return AllowInvalidRefInKeyPath::create(
-          cs, baseType, RefKind::MutatingMethod, member, locator);
+
+    if (isa<ConstructorDecl>(member))
+      return nullptr;
   }
 
+  // Referencing (instance or static) methods in key path is
+  // not currently allowed.
+  if (isa<FuncDecl>(member))
+    return AllowInvalidRefInKeyPath::create(cs, baseType, RefKind::Method,
+                                            member, locator);
+
+  // Referencing initializers in key path is not currently allowed.
+  if (isa<ConstructorDecl>(member))
+    return AllowInvalidRefInKeyPath::create(cs, baseType, RefKind::Initializer,
+                                            member, locator);
+
   return nullptr;
 }
 

lib/Sema/CSSimplify.cpp

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

test/Constraints/keypath.swift

@@ -1,4 +1,5 @@
-// RUN: %target-swift-frontend -typecheck -verify %S/Inputs/keypath.swift -primary-file %s
+// RUN: %target-swift-frontend -enable-experimental-feature KeyPathWithMethodMembers -typecheck -verify %S/Inputs/keypath.swift -primary-file %s
+// REQUIRES: swift_feature_KeyPathWithMethodMembers
 
 struct S {
   let i: Int

test/Constraints/rdar68155466.swift

@@ -1,5 +1,6 @@
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -verify %s
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -enable-experimental-feature KeyPathWithMethodMembers -typecheck -verify %s
 // REQUIRES: objc_interop
+// REQUIRES: swift_feature_KeyPathWithMethodMembers
 
 import Foundation
 

test/Interpreter/keypath.swift

@@ -1,6 +1,7 @@
-// RUN: %target-run-simple-swift | %FileCheck %s
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-feature -Xfrontend KeyPathWithMethodMembers) | %FileCheck %s
 
 // REQUIRES: executable_test
+// REQUIRES: swift_feature_KeyPathWithMethodMembers
 
 // UNSUPPORTED: use_os_stdlib
 // UNSUPPORTED: back_deployment_runtime