[Sema/SILGen/IRGen] Implement method & initializer keypaths.

docs/ABI/Mangling.rst

@@ -259,6 +259,8 @@ types where the metadata itself has unknown layout.)
   global ::= from-type to-type generic-signature? 'Tr'  // obsolete mangling for reabstraction thunk
   global ::= entity generic-signature? type type* 'TK' // key path getter
   global ::= entity generic-signature? type type* 'Tk' // key path setter
+  global ::= entity generic-signature? type type* 'Tkmu' // key path unapplied method
+  global ::= entity generic-signature? type type* 'TkMA' // key path applied method
   global ::= type generic-signature 'TH' // key path equality
   global ::= type generic-signature 'Th' // key path hasher
   global ::= global generic-signature? 'TJ' AUTODIFF-FUNCTION-KIND INDEX-SUBSET 'p' INDEX-SUBSET 'r' // autodiff function

include/swift/AST/ASTMangler.h

@@ -346,16 +346,20 @@ class ASTMangler : public Mangler {
                                      AutoDiffLinearMapKind linearMapKind,
                                      const AutoDiffConfig &config);
 
-  std::string mangleKeyPathGetterThunkHelper(const AbstractStorageDecl *property,
-                                             GenericSignature signature,
-                                             CanType baseType,
-                                             SubstitutionMap subs,
-                                             ResilienceExpansion expansion);
+  std::string mangleKeyPathGetterThunkHelper(
+      const AbstractStorageDecl *property, GenericSignature signature,
+      CanType baseType, SubstitutionMap subs, ResilienceExpansion expansion);
   std::string mangleKeyPathSetterThunkHelper(const AbstractStorageDecl *property,
                                              GenericSignature signature,
                                              CanType baseType,
                                              SubstitutionMap subs,
                                              ResilienceExpansion expansion);
+  std::string mangleKeyPathUnappliedMethodThunkHelper(
+      const AbstractFunctionDecl *method, GenericSignature signature,
+      CanType baseType, SubstitutionMap subs, ResilienceExpansion expansion);
+  std::string mangleKeyPathAppliedMethodThunkHelper(
+      const AbstractFunctionDecl *method, GenericSignature signature,
+      CanType baseType, SubstitutionMap subs, ResilienceExpansion expansion);
   std::string mangleKeyPathEqualsHelper(ArrayRef<CanType> indices,
                                         GenericSignature signature,
                                         ResilienceExpansion expansion);

include/swift/AST/Decl.h

@@ -8171,6 +8171,18 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// The async function marked as the alternative to this function, if any.
   AbstractFunctionDecl *getAsyncAlternative() const;
 
+  /// True if the storage can be referenced by a keypath directly.
+  /// Otherwise, its override must be referenced.
+  bool isValidKeyPathComponent() const;
+
+  /// Do we need to use resilient access patterns outside of this
+  /// method's resilience domain?
+  bool isResilient() const;
+
+  /// Do we need to use resilient access patterns when accessing this
+  /// method from the given module?
+  bool isResilient(ModuleDecl *M, ResilienceExpansion expansion) const;
+
   /// If \p asyncAlternative is set, then compare its parameters to this
   /// (presumed synchronous) function's parameters to find the index of the
   /// completion handler parameter. This should be the only missing

include/swift/AST/DiagnosticsSema.def

@@ -687,6 +687,9 @@ NOTE(keypath_static_member_access_from_unsupported_module_note,none,
 ERROR(expr_keypath_enum_case,none,
       "%select{key path|dynamic key path member lookup}1 cannot refer to enum case %0",
       (const ValueDecl *, bool))
+ERROR(expr_keypath_mutating_method,none,
+      "%select{key path|dynamic key path member lookup}1 cannot refer to mutating method %0",
+      (const ValueDecl *, bool))
 ERROR(expr_keypath_empty,none,
       "empty key path does not refer to a property", ())
 ERROR(expr_unsupported_objc_key_path_component,none,
@@ -716,8 +719,8 @@ ERROR(expr_swift_keypath_empty, none,
       "key path must have at least one component", ())
 ERROR(expr_string_interpolation_outside_string,none,
       "string interpolation can only appear inside a string literal", ())
-ERROR(expr_keypath_subscript_index_not_hashable, none,
-      "subscript index of type %0 in a key path must be Hashable", (Type))
+ERROR(expr_keypath_arg_or_index_not_hashable, none,
+      "%select{method argument|subscript index}0 of type %1 in a key path must be Hashable", (bool, Type))
 ERROR(expr_smart_keypath_application_type_mismatch,none,
       "key path of type %0 cannot be applied to a base of type %1",
       (Type, Type))
@@ -1558,6 +1561,8 @@ ERROR(cannot_pass_inout_arg_to_subscript,none,
       "cannot pass an inout argument to a subscript; use "
       "'withUnsafeMutablePointer' to explicitly convert argument "
       "to a pointer", ())
+ERROR(cannot_pass_inout_arg_to_keypath_method,none,
+      "cannot pass an inout argument to a keypath method", ())
 
 ERROR(incorrect_property_wrapper_reference,none,
       "cannot convert value %0 of type %1 to expected type %2, "
@@ -5594,8 +5599,8 @@ ERROR(actor_isolated_keypath_component,none,
       "cannot form key path to %0 %kind1",
       (ActorIsolation, const ValueDecl *))
 ERROR(effectful_keypath_component,none,
-      "cannot form key path to %0 with 'throws' or 'async'",
-      (DescriptiveDeclKind))
+      "cannot form %select{key path|dynamic key path member lookup}1 to %0 with 'throws' or 'async'",
+      (DescriptiveDeclKind, bool))
 ERROR(local_function_executed_concurrently,none,
       "concurrently-executed %kind0 must be marked as '@Sendable'",
       (const ValueDecl *))