Implement SE-0062: Referencing Objective-C key-paths (#2640)

* SE-0062: Implement #keyPath expression.

Implement the Objective-C #keyPath expression, which maps a sequence
of @objc property accesses to a key-path suitable for use with
Cocoa[Touch]. The implementation handles @objc properties of types
that are either @objc or can be bridged to Objective-C, including the
collections that work with key-value coding (Array/NSArray,
Dictionary/NSDictionary, Set/NSSet).

Still to come: code completion support and Fix-Its to migrate string
literal keypaths to #keyPath.

Implements the bulk of SR-1237 / rdar://problem/25710611.

* Fix a test for the #keyPath expression.

* [IDE] Code completion for Objective-C #keyPath expressions.

Implement code completion support for Objective-C #keyPath
expressions, using semantic analysis of the partially-typed keypath
argument to provide an appropriate set of results (i.e., just
properties and types).

This implements all of the necessary parts of SE-0062 / SR-1237 /
rdar://problem/25710611, although at some point I'd like to follow it
up with some warnings to help migrate existing string literals to

* Fix the # of Expr bits used by ObjCKeyPathExpr.

* Add SE-0062 to the changelog.

Author: DougGregor

CHANGELOG.md

@@ -219,6 +219,11 @@ Swift 3.0
     let sel2 = #selector(setter: UIView.backgroundColor) // sel2 has type Selector
     ```
 
+* [SE-0062](https://github.com/apple/swift-evolution/blob/master/proposals/0062-objc-keypaths.md): A key-path can now be formed with `#keyPath`. For example:
+
+    ```swift
+    person.valueForKeyPath(#keyPath(Person.bestFriend.lastName))
+    ```
 
 Swift 2.2
 ---------

include/swift/AST/DiagnosticsParse.def

@@ -1081,11 +1081,23 @@ ERROR(expected_type_after_as,none,
 ERROR(string_interpolation_extra,none,
       "extra tokens after interpolated string expression", ())
 
+// Keypath expressions.
+ERROR(expr_keypath_expected_lparen,PointsToFirstBadToken,
+      "expected '(' following '#keyPath'", ())
+ERROR(expr_keypath_expected_property_or_type,PointsToFirstBadToken,
+      "expected property or type name within '#keyPath(...)'", ())
+ERROR(expr_keypath_expected_rparen,PointsToFirstBadToken,
+      "expected ')' to complete '#keyPath' expression", ())
+ERROR(expr_keypath_compound_name,none,
+      "cannot use compound name %0 in '#keyPath' expression", (DeclName))
+
 // Selector expressions.
 ERROR(expr_selector_expected_lparen,PointsToFirstBadToken,
       "expected '(' following '#selector'", ())
-ERROR(expr_selector_expected_expr,PointsToFirstBadToken,
+ERROR(expr_selector_expected_method_expr,PointsToFirstBadToken,
       "expected expression naming a method within '#selector(...)'", ())
+ERROR(expr_selector_expected_property_expr,PointsToFirstBadToken,
+      "expected expression naming a property within '#selector(...)'", ())
 ERROR(expr_selector_expected_rparen,PointsToFirstBadToken,
       "expected ')' to complete '#selector' expression", ())
 

include/swift/AST/DiagnosticsSema.def

@@ -368,6 +368,26 @@ ERROR(noescape_functiontype_mismatch,none,
       "invalid conversion from non-escaping function of type %0 to "
       "potentially escaping function type %1", (Type, Type))
 
+// Key-path expressions.
+ERROR(expr_keypath_no_objc_runtime,none,
+      "'#keyPath' can only be used with the Objective-C runtime", ())
+ERROR(expression_unused_keypath_result,none,
+      "result of '#keyPath' is unused", ())
+ERROR(expr_keypath_non_objc_property,none,
+      "argument of '#keyPath' refers to non-'@objc' property %0",
+      (DeclName))
+ERROR(stdlib_anyobject_not_found,none,
+      "broken standard library: cannot find 'AnyObject' protocol", ())
+ERROR(expr_keypath_type_of_property,none,
+      "cannot refer to type member %0 within instance of type %1",
+      (DeclName, Type))
+ERROR(expr_keypath_generic_type,none,
+      "'#keyPath' cannot refer to generic type %0", (DeclName))
+ERROR(expr_keypath_not_property,none,
+      "'#keyPath' cannot refer to %0 %1", (DescriptiveDeclKind, DeclName))
+ERROR(expr_keypath_empty,none,
+      "empty '#keyPath' does not refer to a property", ())
+
 // Selector expressions.
 ERROR(expr_selector_no_objc_runtime,none,
       "'#selector' can only be used with the Objective-C runtime", ())
@@ -401,7 +421,7 @@ ERROR(expr_selector_not_objc,none,
       "argument of '#selector' refers to %0 %1 that is not exposed to "
       "Objective-C",
       (DescriptiveDeclKind, DeclName))
-NOTE(expr_selector_make_objc,none,
+NOTE(make_decl_objc,none,
      "add '@objc' to expose this %0 to Objective-C",
      (DescriptiveDeclKind))
 

include/swift/AST/Expr.h

@@ -311,6 +311,19 @@ class alignas(8) Expr {
   enum { NumObjCSelectorExprBits = NumExprBits + 2 };
   static_assert(NumObjCSelectorExprBits <= 32, "fits in an unsigned");
 
+  class ObjCKeyPathExprBitfields {
+    friend class ObjCKeyPathExpr;
+    unsigned : NumExprBits;
+
+    /// The number of components in the selector path.
+    unsigned NumComponents : 8;
+
+    /// Whether the names have corresponding source locations.
+    unsigned HaveSourceLocations : 1;
+  };
+  enum { NumObjCKeyPathExprBits = NumExprBits + 9 };
+  static_assert(NumObjCKeyPathExprBits <= 32, "fits in an unsigned");
+
 protected:
   union {
     ExprBitfields ExprBits;
@@ -333,6 +346,7 @@ class alignas(8) Expr {
     CollectionUpcastConversionExprBitfields CollectionUpcastConversionExprBits;
     TupleShuffleExprBitfields TupleShuffleExprBits;
     ObjCSelectorExprBitfields ObjCSelectorExprBits;
+    ObjCKeyPathExprBitfields ObjCKeyPathExprBits;
   };
 
 private:
@@ -3860,6 +3874,111 @@ class ObjCSelectorExpr : public Expr {
   }
 };
 
+/// Produces a keypath string for the given referenced property.
+///
+/// \code
+/// #keyPath(Person.friends.firstName)
+/// \endcode
+class ObjCKeyPathExpr : public Expr {
+  SourceLoc KeywordLoc;
+  SourceLoc LParenLoc;
+  SourceLoc RParenLoc;
+  Expr *SemanticExpr = nullptr;
+
+  /// A single stored component, which will be either an identifier or
+  /// a resolved declaration.
+  typedef llvm::PointerUnion<Identifier, ValueDecl *> StoredComponent;
+
+  ObjCKeyPathExpr(SourceLoc keywordLoc, SourceLoc lParenLoc,
+              ArrayRef<Identifier> names,
+              ArrayRef<SourceLoc> nameLocs,
+              SourceLoc rParenLoc);
+
+  /// Retrieve a mutable version of the "components" array, for
+  /// initialization purposes.
+  MutableArrayRef<StoredComponent> getComponentsMutable() {
+    return { reinterpret_cast<StoredComponent *>(this + 1), getNumComponents() };
+  }
+
+  /// Retrieve the "components" storage.
+  ArrayRef<StoredComponent> getComponents() const {
+    return { reinterpret_cast<StoredComponent const *>(this + 1),
+             getNumComponents() };
+  }
+
+  /// Retrieve a mutable version of the name locations array, for
+  /// initialization purposes.
+  MutableArrayRef<SourceLoc> getNameLocsMutable() {
+    if (!ObjCKeyPathExprBits.HaveSourceLocations) return { };
+
+    auto mutableComponents = getComponentsMutable();
+    return { reinterpret_cast<SourceLoc *>(mutableComponents.end()),
+             mutableComponents.size() };
+  }
+
+public:
+  /// Create a new #keyPath expression.
+  ///
+  /// \param nameLocs The locations of the names in the key-path,
+  /// which must either have the same number of entries as \p names or
+  /// must be empty.
+  static ObjCKeyPathExpr *create(ASTContext &ctx,
+                             SourceLoc keywordLoc, SourceLoc lParenLoc,
+                             ArrayRef<Identifier> names,
+                             ArrayRef<SourceLoc> nameLocs,
+                             SourceLoc rParenLoc);
+
+  SourceLoc getLoc() const { return KeywordLoc; }
+  SourceRange getSourceRange() const {
+    return SourceRange(KeywordLoc, RParenLoc);
+  }
+
+  /// Retrieve the number of components in the key-path.
+  unsigned getNumComponents() const {
+    return ObjCKeyPathExprBits.NumComponents;
+  }
+
+  /// Retrieve's the name for the (i)th component;
+  Identifier getComponentName(unsigned i) const;
+
+  /// Retrieve's the declaration corresponding to the (i)th component,
+  /// or null if this component has not yet been resolved.
+  ValueDecl *getComponentDecl(unsigned i) const {
+    return getComponents()[i].dyn_cast<ValueDecl *>();
+  }
+
+  /// Retrieve the location corresponding to the (i)th name.
+  ///
+  /// If no location information is available, returns an empty
+  /// \c DeclNameLoc.
+  SourceLoc getComponentNameLoc(unsigned i) const {
+    if (!ObjCKeyPathExprBits.HaveSourceLocations) return { };
+
+    auto components = getComponents();
+    ArrayRef<SourceLoc> nameLocs(
+        reinterpret_cast<SourceLoc const *>(components.end()),
+        components.size());
+
+    return nameLocs[i];
+  }
+
+  /// Retrieve the semantic expression, which will be \c NULL prior to
+  /// type checking and a string literal after type checking.
+  Expr *getSemanticExpr() const { return SemanticExpr; }
+
+  /// Set the semantic expression.
+  void setSemanticExpr(Expr *expr) { SemanticExpr = expr; }
+
+  /// Resolve the given component to the given declaration.
+  void resolveComponent(unsigned idx, ValueDecl *decl) {
+    getComponentsMutable()[idx] = decl;
+  }
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::ObjCKeyPath;
+  }
+};
+
 #undef SWIFT_FORWARD_SOURCE_LOCS_TO
 
 } // end namespace swift

include/swift/AST/ExprNodes.def

@@ -158,6 +158,7 @@ EXPR(CodeCompletion, Expr)
 UNCHECKED_EXPR(UnresolvedPattern, Expr)
 EXPR(EditorPlaceholder, Expr)
 EXPR(ObjCSelector, Expr)
+EXPR(ObjCKeyPath, Expr)
 
 #undef EXPR_RANGE
 #undef UNCHECKED_EXPR

include/swift/IDE/CodeCompletion.h

@@ -487,6 +487,8 @@ enum class CompletionKind {
   PostfixExprParen,
   SuperExpr,
   SuperExprDot,
+  KeyPathExpr,
+  KeyPathExprDot,
   TypeSimpleBeginning,
   TypeIdentifierWithDot,
   TypeIdentifierWithoutDot,

include/swift/Parse/CodeCompletionCallbacks.h

@@ -165,6 +165,14 @@ class CodeCompletionCallbacks {
   /// a dot.
   virtual void completeExprSuperDot(SuperRefExpr *SRE) = 0;
 
+  /// \brief Complete the argument to an Objective-C #keyPath
+  /// expression.
+  ///
+  /// \param KPE A partial #keyPath expression that can be used to
+  /// provide context. This will be \c NULL if no components of the
+  /// #keyPath argument have been parsed yet.
+  virtual void completeExprKeyPath(ObjCKeyPathExpr *KPE, bool HasDot) = 0;
+
   /// \brief Complete the beginning of type-simple -- no tokens provided
   /// by user.
   virtual void completeTypeSimpleBeginning() = 0;

include/swift/Parse/Parser.h

@@ -1109,6 +1109,7 @@ class Parser {
                                               bool isExprBasic);
   ParserResult<Expr> parseExprPostfix(Diag<> ID, bool isExprBasic);
   ParserResult<Expr> parseExprUnary(Diag<> ID, bool isExprBasic);
+  ParserResult<Expr> parseExprKeyPath();
   ParserResult<Expr> parseExprSelector();
   ParserResult<Expr> parseExprSuper();
   ParserResult<Expr> parseExprConfiguration();

include/swift/Parse/Tokens.def

@@ -195,6 +195,7 @@ POUND_KEYWORD(if)
 POUND_KEYWORD(else)
 POUND_KEYWORD(elseif)
 POUND_KEYWORD(endif)
+POUND_KEYWORD(keyPath)
 POUND_KEYWORD(line)
 POUND_KEYWORD(setline)
 POUND_KEYWORD(sourceLocation)

include/swift/Sema/IDETypeChecking.h

@@ -77,10 +77,20 @@ namespace swift {
   /// \returns True on applied, false on not applied.
   bool isExtensionApplied(DeclContext &DC, Type Ty, const ExtensionDecl *ED);
 
+/// The kind of type checking to perform for code completion.
+  enum class CompletionTypeCheckKind {
+    /// Type check the expression as normal.
+    Normal,
+
+    /// Type check the argument to an Objective-C #keyPath.
+    ObjCKeyPath,
+  };
+
   /// \brief Return the type of an expression parsed during code completion, or
   /// None on error.
   Optional<Type> getTypeOfCompletionContextExpr(ASTContext &Ctx,
                                                 DeclContext *DC,
+                                                CompletionTypeCheckKind kind,
                                                 Expr *&parsedExpr);
 
   /// Typecheck the sequence expression \p parsedExpr for code completion.