[clang] Make sure codecompletion is called for calls even when inside a token.

[kadircet]

Summary

Currently CodeCompleteCall only gets called after a comma or parantheses. This
patch makes sure it is called even at the cases like:

foo(1^);

[ilya-biryukov]

Maybe add tests? Lit tests for code completion (clang/test/CodeCompletion) should be a good fit

include/clang/Parse/Parser.h

2976

Maybe put the field closer to the existing ones?

lib/Parse/ParseExpr.cpp

2845

Why should we set this flag here? Can it be handled by Completer function that we pass into ParseExperssionList instead?

[ilya-biryukov]

Sorry, missed the dependent revision adding tests to clangd at first. Having another test in sema would still be great, to make sure we guard against regressions if someone does not have clang-tools-extra checked out.

[kadircet]

• Resolve discussions.
• Add tests.
• Fix a bug noticed by lit tests.

[ilya-biryukov]

One major limitation of the current workaround is that IIRC clang can actually call code completion callbacks, including this method, multiple times (e.g. when completing inside a macro definition that gets expanded later in the file or during parser recovery).
The workaround will work at the first call, but won't trigger at the repeated calls. We could find a way around that by resetting the flag to false at the right points (probably at every top-level function call?) WDYT?

include/clang/Parse/Parser.h

217

NIT: would go with something less harsh, like "workaround to make sure we only call CodeCompleteCall on the deepest call expression"

lib/Parse/ParseExpr.cpp

1663

Shouldn't we ignore CodeCompleteCall if CalledOverloadCompletion is set to true?

1680

What's the special handling in ObjC? Can we unify with our workaround?

1682

Why don't we handle the CalledOverloadCompletion flag inside the Completer() itself?
We're currently special-casing the middle identifier and error case, why not have the same code path for CodeCompleteCall() calls at the start of the identifier?

[kadircet]

• Update tests.
• Update comment.
• Rebase.

[kadircet]

• Update comments.

[ilya-biryukov]

test/Index/complete-block-property-assignment.m

71

Any idea why behavior changed in that case?

[ilya-biryukov]

test/Index/complete-block-property-assignment.m

71

Looked at it more thoroughly now...
So we're now showing both the signature help and the completion, right?
If that the case, LG, but can we include the rest of completion items from CHECK-N0?

Maybe also add a comment that the last item is from overload set completion, rather than the ordinary code completion? (To avoid confusion and make it clear why we need an extra check there)

[kadircet]

• Fix tests.

test/Index/complete-block-property-assignment.m

71

Yes, c-index-test binary collects results from both ProcessOverloadCandidate and ProcessCodeCompleteResults. Therefore they are merged. Adding the same set of results on the above is not enough for that particular case, due to the clever nature of CodeCompleteOverloadResult at https://github.com/llvm-mirror/clang/blob/master/lib/Sema/SemaCodeComplete.cpp#L4439.

It doesn't just try to tell you the overloads of that particular function but also tries to complete the current argument. Therefore the list simply gets huge by expansion of all the macros and other stuff.

But when looking into it I found out I was checking for wrong return values fixing that with the new diff.

[ilya-biryukov]

test/Index/complete-block-property-assignment.m

71

I don't think it's correct to call CodeCompleteExpression and CodeCompleteOrdinaryName in this context.
This completion assume we're at the start of the argument, which is not true anymore.
E.g. we can be producing weird results in the middle of expressions. Some examples from the top of my head:

func(var.^); // <-- (1) we add top-level completions in addition to members of bar
func(&^); // <-- (2) we provide incorrect ParamType

For (2) if ParamType is int*, we would incorrectly uprank items of type int* (should uprank items of type int instead).

I'll investigate a bit more to see if we can refactor the code to untangle signature help from code completion.

[ilya-biryukov]

test/Index/complete-block-property-assignment.m

71

D51782 removes completion-specific bits out of functions that produce signature help.
After it lands, it should be significantly easier to produce results for these cases.

Specifically, we will be able to only run signature help in the middle of the args, and signature help followed by a normal completion at the start of the args.

[ilya-biryukov]

test/Index/complete-block-property-assignment.m

71

Landed D51782. This change should be easier now.
We can now call both signature help and code completion at the start of the arguments and only signature help in the middle of the arguments.

[kadircet]

• Rebase and use new signature help.

Currently the problem is, there are again some tests out there that rely on
CodeCompeleteOrdinaryName to be called even when getting overloads at an unknown
parameter type. These tests are:

Clang :: CodeCompletion/call.cpp
Clang :: Index/code-completion.cpp
Clang :: Index/complete-call.cpp
Clang :: Index/complete-functor-call.cpp
Clang :: Index/complete-optional-params.cpp
Clang :: Index/complete-pointer-and-reference-to-functions.cpp

You can run something like this to check for the output(change ../clangd_bugs):

ninja c-index-test && ./bin/c-index-test -code-completion-at=../clangd_bugs/tools/clang/test/Index/complete-call.cpp:53:12 ../clan
gd_bugs/tools/clang/test/Index/complete-call.cpp

As you can see current version generates only overloadcandidates, but tests
don't check them with a next loop, because they expect other completions, which
is not problematic but after checks for the items they also look for completion
context, which is not set as desired if CodeCompleteOrdinaryName or
CodeCompleteExpression is not called.

But for the first test case it is more complicated, it checks for code patterns
like dynamic_cast<EXPR>(EXPR); which is not generated if we don't call
CodeCompletionOrdinaryName or Expressions.

[ilya-biryukov]

Currently the problem is, there are again some tests out there that rely on
CodeCompeleteOrdinaryName to be called even when getting overloads at an unknown
parameter type

CodeCompleteExpression works just fine there. Unknown parameter type should not block code completion.
The idea is that anywhere except the start of the argument expression, we need to call only signature help. At the start of the argument, we have to call both signature help and code completion.
All existing tests pass with the following diff:

--- a/lib/Parse/ParseExpr.cpp
+++ b/lib/Parse/ParseExpr.cpp
@@ -1659,12 +1659,19 @@ Parser::ParsePostfixExpressionSuffix(ExprResult LHS) {
 
       if (OpKind == tok::l_paren || !LHS.isInvalid()) {
         if (Tok.isNot(tok::r_paren)) {
-          if (ParseExpressionList(ArgExprs, CommaLocs, [&] {
-                QualType PreferredType = Actions.ProduceCallSignatureHelp(
-                    getCurScope(), LHS.get(), ArgExprs, PT.getOpenLocation());
-                Actions.CodeCompleteExpression(getCurScope(), PreferredType);
-              })) {
+          auto Completer = [&] {
+            QualType PreferredType = Actions.ProduceCallSignatureHelp(
+                getCurScope(), LHS.get(), ArgExprs, PT.getOpenLocation());
+            Actions.CodeCompleteExpression(getCurScope(), PreferredType);
+            CalledOverloadCompletion = true;
+          };
+          if (ParseExpressionList(ArgExprs, CommaLocs, Completer)) {
             (void)Actions.CorrectDelayedTyposInExpr(LHS);
+            if (PP.isCodeCompletionReached() && !CalledOverloadCompletion) {
+              CalledOverloadCompletion = true;
+              Actions.ProduceCallSignatureHelp(
+                  getCurScope(), LHS.get(), ArgExprs, PT.getOpenLocation());
+            }
             LHS = ExprError();
           } else if (LHS.isInvalid()) {
             for (auto &E : ArgExprs)

Please note there are other places where signature help methods (ProduceCallSignatureHelp and ProduceConstructorSignatureHelp) are called, we need to handle all of them. List of files that have those calls:

• lib/Parse/ParseExprCXX.cpp
• lib/Parse/ParseOpenMP.cpp
• lib/Parse/ParseExpr.cpp
• lib/Parse/ParseDecl.cpp

include/clang/Parse/Parser.h

219

NIT: rename to CalledSignatureHelp, this shouldn't affect completion

[kadircet]

• Change "inside parameter" checking and fix completion string printing for optional parameters.
• Update tests.

[kadircet]

In D51038#1228618, @ilya-biryukov wrote:

Currently the problem is, there are again some tests out there that rely on
CodeCompeleteOrdinaryName to be called even when getting overloads at an unknown
parameter type

CodeCompleteExpression works just fine there. Unknown parameter type should not block code completion.
The idea is that anywhere except the start of the argument expression, we need to call only signature help. At the start of the argument, we have to call both signature help and code completion.

Yeah you are right, I thought I could check whether I am inside a parameter or not by looking at qual type, which was apparently wrong :D

But, unfortunately, there were still tests failing which was caused by printing of completion strings for overloaded methods with optional parameters. It was trying to access Text field, which is not defined for Optional parameters.
Since it didn't print optional parameters in the original behavior I kept it that way. Can send it as a different patch if need be.

[ilya-biryukov]

include/clang/Parse/Parser.h

217

s/ProduceSignaturehelp/ProduceSignatureHelp

lib/Parse/ParseDecl.cpp

2325

Maybe call signature help here directly and remove param from lamdba?
Having a parameter in lambda adds both makes the lamdba body more complicated and adds extra state that we have to reason about.

Same for the other calls.

[ilya-biryukov]

This comment has been deleted.

lib/Sema/CodeCompleteConsumer.cpp

622

This change is really sneaky and unrelated to the rest of the patch. It should definitely be done separately from this patch.

Could you give more details on what fails exactly instead? Can we update the test instead?

[kadircet]

• Resolve discussions.

[ilya-biryukov]

lib/Parse/ParseExpr.cpp

1663–1672

NIT: inline completer.

1663–1672

Maybe inline this into lambda body again?
Now that it's not called outside it, we don't need a variable anymore.

lib/Parse/ParseExprCXX.cpp

2826

ActOnTypeName is called at a different point now, please move it back into the lambda.

2827–2842

Same here: maybe inline the lambda into the call to keep the changes minimal?

lib/Parse/ParseOpenMP.cpp

419–432

Same here: maybe inline the lambda?

[ilya-biryukov]

lib/Sema/CodeCompleteConsumer.cpp

622

As Kadir mentioned offline this actually LG, we shouldn't read C.Text for CK_Optional chunks.

Maybe leave a FIXME that we could actually print the CodeCompletionString from the optional chunk?

[ilya-biryukov]

lib/Parse/ParseExprCXX.cpp

2826

As discussed offline, this actually LG.
It's weird that result of ActOnTypeName seems to be only needed for code completion and it's called even when completion is disabled.

However, this was the case before the patch as well

[kadircet]

• Inline completers.

[ilya-biryukov]

Thanks! LGTM

lib/Parse/ParseExprCXX.cpp

1687–1699

NIT: inline this last completer.

[kadircet]

• One last completer

include/clang/Parse/Parser.h

class Parser : public CodeCompletionHandler {
 
   /// When true, we are directly inside an Objective-C message
   /// send expression.
   ///
   /// This is managed by the \c InMessageExpressionRAIIObject class, and
   /// should not be set directly.
   bool InMessageExpression;
 
+  /// Gets set to true after calling ProduceSignaturehelp, it is for a
+  /// workaround to make sure ProduceSignatureHelp is only called at the deepest
+  /// function call.
+  bool CalledSignatureHelp = false;
+
   /// The "depth" of the template parameters currently being parsed.
   unsigned TemplateParameterDepth;
 
   /// RAII class that manages the template parameter depth.
   class TemplateParameterDepthRAII {
     unsigned &Depth;
     unsigned AddedLevels;
   public:
private:
   void CodeCompleteMacroName(bool IsDefinition) override;
   void CodeCompletePreprocessorExpression() override;
   void CodeCompleteMacroArgument(IdentifierInfo *Macro, MacroInfo *MacroInfo,
                                  unsigned ArgumentIndex) override;
   void CodeCompleteNaturalLanguage() override;
 };
 
 }  // end namespace clang
 
 #endif

lib/Parse/ParseDecl.cpp

if (isTokenEqualOrEqualTypo()) {
 
     ExprVector Exprs;
     CommaLocsTy CommaLocs;
 
     InitializerScopeRAII InitScope(*this, D, ThisDecl);
 
     llvm::function_ref<void()> ExprListCompleter;
     auto ThisVarDecl = dyn_cast_or_null<VarDecl>(ThisDecl);
-    auto ConstructorCompleter = [&, ThisVarDecl] {
+    auto ConstructorCompleter = [&, ThisVarDecl](bool InsideParam = false) {
+      if(CalledSignatureHelp)
+        return;
       QualType PreferredType = Actions.ProduceConstructorSignatureHelp(
           getCurScope(), ThisVarDecl->getType()->getCanonicalTypeInternal(),
           ThisDecl->getLocation(), Exprs, T.getOpenLocation());
+      CalledSignatureHelp = true;
+      if(!InsideParam)
         Actions.CodeCompleteExpression(getCurScope(), PreferredType);
     };
     if (ThisVarDecl) {
       // ParseExpressionList can sometimes succeed even when ThisDecl is not
       // VarDecl. This is an error and it is reported in a call to
       // Actions.ActOnInitializerError(). However, we call
       // ProduceConstructorSignatureHelp only on VarDecls, falling back to
       // default completer in other cases.
       ExprListCompleter = ConstructorCompleter;
     }
 
     if (ParseExpressionList(Exprs, CommaLocs, ExprListCompleter)) {
+      if (ThisVarDecl && PP.isCodeCompletionReached())
+        ConstructorCompleter(true);
       Actions.ActOnInitializerError(ThisDecl);
       SkipUntil(tok::r_paren, StopAtSemi);
     } else {
       // Match the ')'.
       T.consumeClose();
 
       assert(!Exprs.empty() && Exprs.size()-1 == CommaLocs.size() &&
              "Unexpected number of commas!");

lib/Parse/ParseExpr.cpp

case tok::lesslessless: {  // p-e: p-e '<<<' argument-expression-list '>>>'
       }
 
       ExprVector ArgExprs;
       CommaLocsTy CommaLocs;
 
       if (Tok.is(tok::code_completion)) {
         QualType PreferredType = Actions.ProduceCallSignatureHelp(
             getCurScope(), LHS.get(), None, PT.getOpenLocation());
+        CalledSignatureHelp = true;
         Actions.CodeCompleteExpression(getCurScope(), PreferredType);
         cutOffParsing();
         return ExprError();
       }
 
       if (OpKind == tok::l_paren || !LHS.isInvalid()) {
         if (Tok.isNot(tok::r_paren)) {
-          if (ParseExpressionList(ArgExprs, CommaLocs, [&] {
-                QualType PreferredType = Actions.ProduceCallSignatureHelp(
-                    getCurScope(), LHS.get(), ArgExprs, PT.getOpenLocation());
-                Actions.CodeCompleteExpression(getCurScope(), PreferredType);
-              })) {
+          auto Completer = [&](bool InsideParam = false) {
+            if(CalledSignatureHelp)
+              return;
+            CalledSignatureHelp = true;
+            if(!InsideParam)
+          };
+          if (ParseExpressionList(ArgExprs, CommaLocs, Completer)) {
             (void)Actions.CorrectDelayedTyposInExpr(LHS);
+            // If we got an error when parsing expression list, we don't call
+            // the CodeCompleteCall handler inside the parser. So call it here
+            // to make sure we get overload suggestions even when we are in the
+            // middle of a parameter.
+            if (PP.isCodeCompletionReached())
+              Completer(true);
             LHS = ExprError();
           } else if (LHS.isInvalid()) {
             for (auto &E : ArgExprs)
               Actions.CorrectDelayedTyposInExpr(E);
           }
         }
       }
 
       // Match the ')'.
       if (LHS.isInvalid()) {
         SkipUntil(tok::r_paren, StopAtSemi);
bool Parser::ParseExpressionList(SmallVectorImpl<Expr *> &Exprs,
                                  llvm::function_ref<void()> Completer) {
   bool SawError = false;
   while (1) {
     if (Tok.is(tok::code_completion)) {
       if (Completer)
         Completer();
       else
         Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Expression);
       cutOffParsing();
       return true;
     }
 
     ExprResult Expr;
     if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
       Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
       Expr = ParseBraceInitializer();
     } else

lib/Parse/ParseExprCXX.cpp

Parser::ParseCXXTypeConstructExpression(const DeclSpec &DS) {
   } else {
     BalancedDelimiterTracker T(*this, tok::l_paren);
     T.consumeOpen();
 
     ExprVector Exprs;
     CommaLocsTy CommaLocs;
 
     if (Tok.isNot(tok::r_paren)) {
-      if (ParseExpressionList(Exprs, CommaLocs, [&] {
-            QualType PreferredType = Actions.ProduceConstructorSignatureHelp(
-                getCurScope(), TypeRep.get()->getCanonicalTypeInternal(),
-                DS.getEndLoc(), Exprs, T.getOpenLocation());
-            Actions.CodeCompleteExpression(getCurScope(), PreferredType);
-          })) {
+      auto Completer = [&](bool InsideParam = false) {
+        if(CalledSignatureHelp)
+          return;
+        CalledSignatureHelp = true;
+        if(!InsideParam)
+      };
+      if (ParseExpressionList(Exprs, CommaLocs, Completer)) {
+        if (PP.isCodeCompletionReached())
+          Completer(true);
         SkipUntil(tok::r_paren, StopAtSemi);
         return ExprError();
       }
     }
 
     // Match the ')'.
     T.consumeClose();
 
Parser::ParseCXXNewExpression(bool UseGlobal, SourceLocation Start) {
 
   if (Tok.is(tok::l_paren)) {
     SourceLocation ConstructorLParen, ConstructorRParen;
     ExprVector ConstructorArgs;
     BalancedDelimiterTracker T(*this, tok::l_paren);
     T.consumeOpen();
     ConstructorLParen = T.getOpenLocation();
     if (Tok.isNot(tok::r_paren)) {
       CommaLocsTy CommaLocs;
-      if (ParseExpressionList(ConstructorArgs, CommaLocs, [&] {
-            ParsedType TypeRep = Actions.ActOnTypeName(getCurScope(),
-                                                       DeclaratorInfo).get();
-            QualType PreferredType = Actions.ProduceConstructorSignatureHelp(
-                getCurScope(), TypeRep.get()->getCanonicalTypeInternal(),
-                DeclaratorInfo.getEndLoc(), ConstructorArgs, ConstructorLParen);
-            Actions.CodeCompleteExpression(getCurScope(), PreferredType);
-      })) {
+      auto Completer = [&](bool InsideParam = false) {
+        if (CalledSignatureHelp)
+          return;
+        ParsedType TypeRep =
+            Actions.ActOnTypeName(getCurScope(), DeclaratorInfo).get();
+        CalledSignatureHelp = true;
+        if (!InsideParam)
+          Actions.CodeCompleteExpression(getCurScope(), PreferredType);
+      };
+      if (ParseExpressionList(ConstructorArgs, CommaLocs, Completer)) {
+        if (PP.isCodeCompletionReached())
+          Completer(true);
         SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);
         return ExprError();
       }
     }
     T.consumeClose();
     ConstructorRParen = T.getCloseLocation();
     if (ConstructorRParen.isInvalid()) {
       SkipUntil(tok::semi, StopAtSemi | StopBeforeMatch);

lib/Parse/ParseOpenMP.cpp

if (isTokenEqualOrEqualTypo()) {
     // Parse C++ direct initializer: '(' expression-list ')'
     BalancedDelimiterTracker T(*this, tok::l_paren);
     T.consumeOpen();
 
     ExprVector Exprs;
     CommaLocsTy CommaLocs;
 
     SourceLocation LParLoc = T.getOpenLocation();
-    if (ParseExpressionList(
-            Exprs, CommaLocs, [this, OmpPrivParm, LParLoc, &Exprs] {
-              QualType PreferredType = Actions.ProduceConstructorSignatureHelp(
-                  getCurScope(),
-                  OmpPrivParm->getType()->getCanonicalTypeInternal(),
-                  OmpPrivParm->getLocation(), Exprs, LParLoc);
-              Actions.CodeCompleteExpression(getCurScope(), PreferredType);
-            })) {
+    auto Completer = [this, OmpPrivParm, LParLoc,
+                      &Exprs](bool InsideParam = false) {
+      if (CalledSignatureHelp)
+        return;
+          getCurScope(), OmpPrivParm->getType()->getCanonicalTypeInternal(),
+      CalledSignatureHelp = true;
+      if (!InsideParam)
+    };
+    if (ParseExpressionList(Exprs, CommaLocs, Completer)) {
+      if (PP.isCodeCompletionReached())
+        Completer(true);
       Actions.ActOnInitializerError(OmpPrivParm);
       SkipUntil(tok::r_paren, tok::annot_pragma_openmp_end, StopBeforeMatch);
     } else {
       // Match the ')'.
       SourceLocation RLoc = Tok.getLocation();
       if (!T.consumeClose())
         RLoc = T.getCloseLocation();
 

lib/Sema/CodeCompleteConsumer.cpp

for (auto &C : CCS) {
     case CodeCompletionString::CK_ResultType:
       OS << "[#" << C.Text << "#]";
       break;
 
     case CodeCompletionString::CK_CurrentParameter:
       OS << "<#" << C.Text << "#>";
       break;
 
+    case CodeCompletionString::CK_Optional:
+      break;
+
     default: OS << C.Text; break;
     }
   }
   return OS.str();
 }
 
 void PrintingCodeCompleteConsumer::ProcessOverloadCandidates(
     Sema &SemaRef, unsigned CurrentArg, OverloadCandidate *Candidates,

test/CodeCompletion/function-overloads.cpp

+int f(int i, int j = 2, int k = 5);
+int f(float x, float y...);
+
+class A {
+ public:
+  A(int, int, int);
+};
+
+void test() {
+  A a(f(1, 2, 3, 4), 2, 3);
+}
+
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:10:9 %s -o - | FileCheck -check-prefix=CHECK-CC1 %s
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:10:10 %s -o - | FileCheck -check-prefix=CHECK-CC1 %s
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:10:17 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:10:19 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:10:20 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:10:21 %s -o - | FileCheck -check-prefix=CHECK-CC4 %s
+// CHECK-CC1: OVERLOAD: [#int#]f(<#float x#>, float y)
+// CHECK-CC1: OVERLOAD: [#int#]f(<#int i#>)
+// CHECK-CC1-NOT, CHECK-CC2-NOT: OVERLOAD: A(
+// CHECK-CC2: OVERLOAD: [#int#]f(float x, float y)
+// CHECK-CC2-NOT: OVERLOAD: [#int#]f(int i)
+// CHECK-CC3: OVERLOAD: A(<#int#>, int, int)
+// CHECK-CC3: OVERLOAD: A(<#const A &#>)
+// CHECK-CC3: OVERLOAD: A(<#A &&#>)
+// CHECK-CC4: OVERLOAD: A(int, <#int#>, int)

test/Index/complete-block-property-assignment.m

- (int) testFailures {
   }
   return self.foo;
 }
 
 // RUN: c-index-test -code-completion-at=%s:50:9 %s | FileCheck -check-prefix=CHECK-NO %s
 // RUN: c-index-test -code-completion-at=%s:51:16 %s | FileCheck -check-prefix=CHECK-NO %s
 // RUN: c-index-test -code-completion-at=%s:52:23 %s | FileCheck -check-prefix=CHECK-NO %s
 // RUN: c-index-test -code-completion-at=%s:53:12 %s | FileCheck -check-prefix=CHECK-NO %s
-// RUN: c-index-test -code-completion-at=%s:54:15 %s | FileCheck -check-prefix=CHECK-NO %s
 // RUN: c-index-test -code-completion-at=%s:56:15 %s | FileCheck -check-prefix=CHECK-NO %s
 // CHECK-NO: ObjCPropertyDecl:{ResultType int}{TypedText foo} (35)
 // CHECK-NO-NEXT: ObjCPropertyDecl:{ResultType Obj *}{TypedText obj} (35)
 // CHECK-NO-NEXT: ObjCPropertyDecl:{ResultType void (^)(Obj *)}{TypedText onAction} (35)
 // CHECK-NO-NEXT: ObjCPropertyDecl:{ResultType FooBlock}{TypedText onEventHandler} (35)
 // CHECK-NO-NEXT: ObjCPropertyDecl:{ResultType void (^)(int *)}{TypedText onReadonly} (35)
 // CHECK-NO-NEXT: ObjCPropertyDecl:{ResultType int (^)(int)}{TypedText processEvent} (35)
 
+// RUN: c-index-test -code-completion-at=%s:54:15 %s | FileCheck -check-prefix=CHECK-NO1 %s
+// CHECK-NO1: ObjCPropertyDecl:{ResultType int}{TypedText foo} (35)
+// CHECK-NO1-NEXT: ObjCPropertyDecl:{ResultType Obj *}{TypedText obj} (35)
+// CHECK-NO1-NEXT: ObjCPropertyDecl:{ResultType void (^)(Obj *)}{TypedText onAction} (35)
+// CHECK-NO1-NEXT: ObjCPropertyDecl:{ResultType FooBlock}{TypedText onEventHandler} (35)
+// CHECK-NO1-NEXT: ObjCPropertyDecl:{ResultType void (^)(int *)}{TypedText onReadonly} (35)
+// CHECK-NO1-NEXT: ObjCPropertyDecl:{ResultType int (^)(int)}{TypedText processEvent} (35)
+// CHECK-NO1-NEXT: OverloadCandidate:{ResultType void}{Text func}{LeftParen (}{CurrentParameter int x}{RightParen )} (1)
 @end