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

DougGregor · DougGregor · commit 814a08a5da55 · 2016-05-21T22:28:51.000-07:00
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
diff --git a/include/swift/IDE/CodeCompletion.h b/include/swift/IDE/CodeCompletion.h
@@ -487,6 +487,8 @@ enum class CompletionKind {
   PostfixExprParen,
   SuperExpr,
   SuperExprDot,
+  KeyPathExpr,
+  KeyPathExprDot,
   TypeSimpleBeginning,
   TypeIdentifierWithDot,
   TypeIdentifierWithoutDot,
diff --git a/include/swift/Parse/CodeCompletionCallbacks.h b/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;
diff --git a/include/swift/Sema/IDETypeChecking.h b/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.
diff --git a/lib/IDE/CodeCompletion.cpp b/lib/IDE/CodeCompletion.cpp
@@ -280,6 +280,10 @@ void getSwiftDocKeyword(const Decl* D, CommandWordsPairs &Words) {
 
 typedef llvm::function_ref<bool(ValueDecl*, DeclVisibilityKind)> DeclFilter;
 DeclFilter DefaultFilter = [] (ValueDecl* VD, DeclVisibilityKind Kind) {return true;};
+DeclFilter KeyPathFilter = [](ValueDecl* decl, DeclVisibilityKind) -> bool {
+  return isa<TypeDecl>(decl) ||
+         (isa<VarDecl>(decl) && decl->getDeclContext()->isTypeContext());
+};
 
 std::string swift::ide::removeCodeCompletionTokens(
     StringRef Input, StringRef TokenName, unsigned *CompletionOffset) {
@@ -1281,16 +1285,24 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks {
 
   Optional<Type> getTypeOfParsedExpr() {
     assert(ParsedExpr && "should have an expression");
+
+    // Figure out the kind of type-check we'll be performing.
+    auto CheckKind = CompletionTypeCheckKind::Normal;
+    if (Kind == CompletionKind::KeyPathExpr ||
+        Kind == CompletionKind::KeyPathExprDot)
+      CheckKind = CompletionTypeCheckKind::ObjCKeyPath;
+
     // If we've already successfully type-checked the expression for some
     // reason, just return the type.
     // FIXME: if it's ErrorType but we've already typechecked we shouldn't
     // typecheck again. rdar://21466394
-    if (ParsedExpr->getType() && !ParsedExpr->getType()->is<ErrorType>())
+    if (CheckKind == CompletionTypeCheckKind::Normal &&
+        ParsedExpr->getType() && !ParsedExpr->getType()->is<ErrorType>())
       return ParsedExpr->getType();
 
     Expr *ModifiedExpr = ParsedExpr;
     if (auto T = getTypeOfCompletionContextExpr(P.Context, CurDeclContext,
-                                                ModifiedExpr)) {
+                                                CheckKind, ModifiedExpr)) {
       // FIXME: even though we don't apply the solution, the type checker may
       // modify the original expression. We should understand what effect that
       // may have on code completion.
@@ -1323,6 +1335,7 @@ class CodeCompletionCallbacksImpl : public CodeCompletionCallbacks {
   void completePostfixExprParen(Expr *E, Expr *CodeCompletionE) override;
   void completeExprSuper(SuperRefExpr *SRE) override;
   void completeExprSuperDot(SuperRefExpr *SRE) override;
+  void completeExprKeyPath(ObjCKeyPathExpr *KPE, bool HasDot) override;
 
   void completeTypeSimpleBeginning() override;
   void completeTypeIdentifierWithDot(IdentTypeRepr *ITR) override;
@@ -1525,6 +1538,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
   bool HaveLParen = false;
   bool HaveRParen = false;
   bool IsSuperRefExpr = false;
+  bool IsKeyPathExpr = false;
   bool IsDynamicLookup = false;
   bool PreferFunctionReferencesToCalls = false;
   bool HaveLeadingSpace = false;
@@ -1677,6 +1691,10 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     IsSuperRefExpr = true;
   }
 
+  void setIsKeyPathExpr() {
+    IsKeyPathExpr = true;
+  }
+
   void setIsDynamicLookup() {
     IsDynamicLookup = true;
   }
@@ -2147,6 +2165,25 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     Builder.addRightParen();
   }
 
+  void addPoundKeyPath(bool needPound) {
+    // #keyPath is only available when the Objective-C runtime is.
+    if (!Ctx.LangOpts.EnableObjCInterop) return;
+
+    CodeCompletionResultBuilder Builder(
+                                  Sink,
+                                  CodeCompletionResult::ResultKind::Keyword,
+                                  SemanticContextKind::ExpressionSpecific,
+                                  ExpectedTypes);
+    if (needPound)
+      Builder.addTextChunk("#keyPath");
+    else
+      Builder.addTextChunk("keyPath");
+    Builder.addLeftParen();
+    Builder.addSimpleTypedParameter("@objc property sequence",
+                                    /*isVarArg=*/false);
+    Builder.addRightParen();
+  }
+
   void addFunctionCallPattern(const AnyFunctionType *AFT,
                               const AbstractFunctionDecl *AFD = nullptr) {
     foundFunction(AFT);
@@ -2596,6 +2633,9 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     if (D->getName().isEditorPlaceholder())
       return;
 
+    if (IsKeyPathExpr && !KeyPathFilter(D, Reason))
+      return;
+        
     if (!D->hasType())
       TypeResolver->resolveDeclSignature(D);
     else if (isa<TypeAliasDecl>(D)) {
@@ -3046,7 +3086,9 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
 
     if (auto T = getTypeOfCompletionContextExpr(
             CurrDeclContext->getASTContext(),
-            const_cast<DeclContext *>(CurrDeclContext), tempExpr))
+            const_cast<DeclContext *>(CurrDeclContext),
+            CompletionTypeCheckKind::Normal,
+            tempExpr))
       addPostfixOperatorCompletion(op, *T);
   }
 
@@ -3371,7 +3413,8 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
   void getValueCompletionsInDeclContext(SourceLoc Loc,
                                         DeclFilter Filter = DefaultFilter,
                                         bool IncludeTopLevel = false,
-                                        bool RequestCache = true) {
+                                        bool RequestCache = true,
+                                        bool LiteralCompletions = true) {
     Kind = LookupKind::ValueInDeclContext;
     NeedLeadingDot = false;
     FilteredDeclConsumer Consumer(*this, Filter);
@@ -3397,19 +3440,33 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
       }
     }
 
-    addValueLiteralCompletions();
+    if (LiteralCompletions)
+      addValueLiteralCompletions();
 
-    // If the expected type is ObjectiveC.Selector, add #selector.
+    // If the expected type is ObjectiveC.Selector, add #selector. If
+    // it's String, add #keyPath.
     if (Ctx.LangOpts.EnableObjCInterop) {
+      bool addedSelector = false;
+      bool addedKeyPath = false;
       for (auto T : ExpectedTypes) {
         T = T->lookThroughAllAnyOptionalTypes();
         if (auto structDecl = T->getStructOrBoundGenericStruct()) {
-          if (structDecl->getName() == Ctx.Id_Selector &&
+          if (!addedSelector &&
+              structDecl->getName() == Ctx.Id_Selector &&
               structDecl->getParentModule()->getName() == Ctx.Id_ObjectiveC) {
             addPoundSelector(/*needPound=*/true);
-            break;
+            if (addedKeyPath) break;
+            addedSelector = true;
+            continue;
           }
         }
+
+        if (!addedKeyPath && T->getAnyNominal() == Ctx.getStringDecl()) {
+          addPoundKeyPath(/*needPound=*/true);
+          if (addedSelector) break;
+          addedKeyPath = true;
+          continue;
+        }
       }
     }
   }
@@ -4192,6 +4249,13 @@ void CodeCompletionCallbacksImpl::completeExprSuperDot(SuperRefExpr *SRE) {
   CurDeclContext = P.CurDeclContext;
 }
 
+void CodeCompletionCallbacksImpl::completeExprKeyPath(ObjCKeyPathExpr *KPE,
+                                                      bool HasDot) {
+  Kind = HasDot ? CompletionKind::KeyPathExprDot : CompletionKind::KeyPathExpr;
+  ParsedExpr = KPE;
+  CurDeclContext = P.CurDeclContext;
+}
+
 void CodeCompletionCallbacksImpl::completePoundAvailablePlatform() {
   Kind = CompletionKind::PoundAvailablePlatform;
   CurDeclContext = P.CurDeclContext;
@@ -4447,6 +4511,8 @@ void CodeCompletionCallbacksImpl::addKeywords(CodeCompletionResultSink &Sink) {
   case CompletionKind::CallArg:
   case CompletionKind::AfterPound:
   case CompletionKind::GenericParams:
+  case CompletionKind::KeyPathExpr:
+  case CompletionKind::KeyPathExprDot:
     break;
 
   case CompletionKind::StmtOrExpr:
@@ -4722,7 +4788,9 @@ void CodeCompletionCallbacksImpl::doneParsing() {
   if (ParsedExpr) {
     ExprType = getTypeOfParsedExpr();
     if (!ExprType && Kind != CompletionKind::PostfixExprParen &&
-        Kind != CompletionKind::CallArg)
+        Kind != CompletionKind::CallArg &&
+        Kind != CompletionKind::KeyPathExpr &&
+        Kind != CompletionKind::KeyPathExprDot)
       return;
     if (ExprType)
       ParsedExpr->setType(*ExprType);
@@ -4856,6 +4924,27 @@ void CodeCompletionCallbacksImpl::doneParsing() {
     break;
   }
 
+  case CompletionKind::KeyPathExprDot:
+    Lookup.setHaveDot(SourceLoc());
+    SWIFT_FALLTHROUGH;
+
+  case CompletionKind::KeyPathExpr: {
+    Lookup.setIsKeyPathExpr();
+    Lookup.includeInstanceMembers();
+
+    if (ExprType) {
+      if (isDynamicLookup(*ExprType))
+        Lookup.setIsDynamicLookup();
+
+      Lookup.getValueExprCompletions(*ExprType);
+    } else {
+      SourceLoc Loc = P.Context.SourceMgr.getCodeCompletionLoc();
+      Lookup.getValueCompletionsInDeclContext(Loc, KeyPathFilter,
+                                              false, true, false);
+    }
+    break;
+  }
+
   case CompletionKind::TypeSimpleBeginning: {
     Lookup.getTypeCompletionsInDeclContext(
         P.Context.SourceMgr.getCodeCompletionLoc());
@@ -4965,6 +5054,7 @@ void CodeCompletionCallbacksImpl::doneParsing() {
   case CompletionKind::AfterPound: {
     Lookup.addPoundAvailable(ParentStmtKind);
     Lookup.addPoundSelector(/*needPound=*/false);
+    Lookup.addPoundKeyPath(/*needPound=*/false);
     break;
   }
 
diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp
@@ -566,12 +566,30 @@ ParserResult<Expr> Parser::parseExprKeyPath() {
   }
   SourceLoc lParenLoc = consumeToken(tok::l_paren);
 
-  // Parse the sequence of unqualified-names.
+  // Handle code completion.
   SmallVector<Identifier, 4> names;
   SmallVector<SourceLoc, 4> nameLocs;
+  auto handleCodeCompletion = [&](bool hasDot) -> ParserResult<Expr> {
+    ObjCKeyPathExpr *expr = nullptr;
+    if (!names.empty()) {
+      expr = ObjCKeyPathExpr::create(Context, keywordLoc, lParenLoc, names,
+                                     nameLocs, Tok.getLoc());
+    }
+
+    if (CodeCompletion)
+      CodeCompletion->completeExprKeyPath(expr, hasDot);
+
+    // Eat the code completion token because we handled it.
+    consumeToken(tok::code_complete);
+    return makeParserCodeCompletionResult(expr);
+  };
+
+  // Parse the sequence of unqualified-names.
   ParserStatus status;
   while (true) {
-    // FIXME: Code completion.
+    // Handle code completion.
+    if (Tok.is(tok::code_complete))
+      return handleCodeCompletion(!names.empty());
 
     // Parse the next name.
     DeclNameLoc nameLoc;
@@ -595,6 +613,10 @@ ParserResult<Expr> Parser::parseExprKeyPath() {
     names.push_back(name.getBaseName());
     nameLocs.push_back(nameLoc.getBaseNameLoc());
 
+    // Handle code completion.
+    if (Tok.is(tok::code_complete))
+      return handleCodeCompletion(false);
+
     // Parse the next period to continue the path.
     if (consumeIf(tok::period))
       continue;
diff --git a/lib/Sema/TypeCheckExprObjC.cpp b/lib/Sema/TypeCheckExprObjC.cpp
@@ -18,10 +18,11 @@
 #include "swift/Basic/Range.h"
 using namespace swift;
 
-ObjCKeyPathExpr *TypeChecker::checkObjCKeyPathExpr(DeclContext *dc,
-                                                   ObjCKeyPathExpr *expr) {
+Optional<Type> TypeChecker::checkObjCKeyPathExpr(DeclContext *dc,
+                                                 ObjCKeyPathExpr *expr,
+                                                 bool requireResultType) {
   // If there is already a semantic expression, do nothing.
-  if (expr->getSemanticExpr()) return expr;
+  if (expr->getSemanticExpr() && !requireResultType) return None;
 
   // #keyPath only makes sense when we have the Objective-C runtime.
   if (!Context.LangOpts.EnableObjCInterop) {
@@ -30,7 +31,7 @@ ObjCKeyPathExpr *TypeChecker::checkObjCKeyPathExpr(DeclContext *dc,
     expr->setSemanticExpr(
       new (Context) StringLiteralExpr("", expr->getSourceRange(),
                                       /*Implicit=*/true));
-    return expr;
+    return None;
   }
 
   // The key path string we're forming.
@@ -70,7 +71,7 @@ ObjCKeyPathExpr *TypeChecker::checkObjCKeyPathExpr(DeclContext *dc,
     anyObjectType = anyObject->getDeclaredInterfaceType();
   } else {
     diagnose(expr->getLoc(), diag::stdlib_anyobject_not_found);
-    return expr;
+    return None;
   }
 
   // Local function to update the state after we've resolved a
@@ -332,10 +333,13 @@ ObjCKeyPathExpr *TypeChecker::checkObjCKeyPathExpr(DeclContext *dc,
     diagnose(expr->getLoc(), diag::expr_keypath_empty);
 
   // Set the semantic expression.
-  expr->setSemanticExpr(
-    new (Context) StringLiteralExpr(Context.AllocateCopy(keyPathString),
-                                    expr->getSourceRange(),
-                                    /*Implicit=*/true));
-  return expr;
-}
+  if (!expr->getSemanticExpr()) {
+    expr->setSemanticExpr(
+      new (Context) StringLiteralExpr(Context.AllocateCopy(keyPathString),
+                                      expr->getSourceRange(),
+                                      /*Implicit=*/true));
+  }
 
+  if (!currentType) return None;
+  return currentType;
+}
diff --git a/lib/Sema/TypeChecker.cpp b/lib/Sema/TypeChecker.cpp
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
diff --git a/test/IDE/complete_pound_keypath.swift b/test/IDE/complete_pound_keypath.swift
