[continued] Add a way to get the CXCursor that corresponds to a completion result

[svenbrauch]

Summary

See https://reviews.llvm.org/D13599, I cannot update that because it has a different author.

Added a very simplistic auto test for the use case that motivated addition of the feature.

[milianw]

lgtm, but could we get some more tests rather than only this one for templates?

test/CodeCompletion/templates.cpp

28

isn't the source location going to be printed everywhere now? are really no other test files affected by this?

[svenbrauch]

I'll add some more, just wanted to post this to see if people think it's the right way to go.

Since the location is added at the end, all the other tests still pass, FileCheck just looks for the string and doesn't care about the extra suffix.

[svenbrauch]

I added a few more tests and found two issues:

• Cursors are also provided for implicit declarations. This is confusing and useless and shouldn't happen (e.g. for the implicit destructor, you don't want to get a cursor pointing to the class declaration). Instead, we return a null cursor now.
• clang_sortCodeCompletionResults sorts the results vector, but leaves the cursors vector untouched. That destroys the proper association between result and cursor ... instead, we now store the cursor in the result.

[svenbrauch]

Oh, one thing: I would like to remove the CursorKind member of the CXCompletionResult struct now since it is obsolete (same as clang_getCursorKind(Result->Cursor)). But, is that compatible with your API stability guarantees?

[milianw]

I don't think this upholds the ABI guarantee, but maybe I'm wrong? Can someone else chime in please? @klimek ?

include/clang-c/Index.h

4738

can you add context to the patch please? i.e. re-upload via arc?

I think what you are doing here breaks the ABI though, and that was the reason for why I used a separate vector the last time, afaik.

[svenbrauch]

Sorry for the wait.

Any opinions on whether this compatibility promises? If it does, I can also fix Milian's variant with the extra list but it will be a bit slower.

[milianw]

I'm pretty sure this is not ABI compatible. You change the size of CXCompletionResult, so when anyone is iterating over the array in CXCompletionResults it will break. If you don't want to, I can try to find some time to take this over again ;-)

[svenbrauch]

I know it breaks ABI compatiblity, I just don't know whether it needs to be kept (e.g. for clang-6.0). The alternative requires sorting by a separate index list which is a bit ugly (and slower). If you feel like working on it in the next few days that would of course be great, otherwise if it is clear that this solution doesn't work, I will pick it up again later. Thanks!

include/clang-c/Index.h

   unsigned NumResults;
 } CXCodeCompleteResults;
 
+/**
+ * \brief Retrieve a cursor corresponding to the completion result at the given index.
+ *
+ * \param result The results in which to look for the cursor.
+ * \param index The index into the CXCompletionResult array in CXCodeCompleteResults.
+ *
+ * \returns The cursor that represents the completion result at the given index,
+ *          or a null cursor when the result does not represent a cursor. This
+ *          will happen e.g. for language keywords.
+ */
+CINDEX_LINKAGE CXCursor
+clang_getCompletionCursor(CXCodeCompleteResults *Results, int Index);
+
 /**
  * \brief Flags that can be passed to \c clang_codeCompleteAt() to
  * modify its behavior.

test/CodeCompletion/templates.cpp

   // CHECK-CC2: foo
   // CHECK-CC2: in_base
   // CHECK-CC2: stop
-  
+  // RUN: c-index-test -code-completion-at=%s:18:8 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
+  // CHECK-CC3: ClassTemplate:{TypedText allocator}{LeftAngle <}{Placeholder typename T}{RightAngle >} (50) (source location: 3:9)
+  // CHECK-CC3-NEXT: ClassTemplate:{TypedText vector}{LeftAngle <}{Placeholder typename T}{Optional {Comma , }{Placeholder typename Alloc}}{RightAngle >} (50) (source location: 9:9)
+
 

tools/c-index-test/c-index-test.c

 }
 
 static void print_completion_result(CXCompletionResult *completion_result,
-                                    FILE *file) {
+                                    FILE *file,
+                                    CXCodeCompleteResults *all_results,
+                                    int index_in_results) {
   CXString ks = clang_getCursorKindSpelling(completion_result->CursorKind);
   unsigned annotationCount;
   enum CXCursorKind ParentKind;
   CXString ParentName;
   CXString BriefComment;
   CXString Annotation;
+  CXCursor SourceCursor;
+  CXSourceLocation SourceLocation;
+  uint SourceLine = 0;
+  uint SourceColumn = 0;
+  CXFile SourceFile;
+  CXString SourceFileName;
   const char *BriefCommentCString;
   
   fprintf(file, "%s:", clang_getCString(ks));

     fprintf(file, "(brief comment: %s)", BriefCommentCString);
   }
   clang_disposeString(BriefComment);
-  
+  SourceCursor = clang_getCompletionCursor(all_results, index_in_results);
+  SourceLocation = clang_getCursorLocation(SourceCursor);
+  clang_getFileLocation(SourceLocation, &SourceFile, &SourceLine, &SourceColumn, 0);
+  fprintf(file, " (source location: %i:%i)", SourceLine, SourceColumn);
+
   fprintf(file, "\n");
 }
 

       clang_sortCodeCompletionResults(results->Results, results->NumResults);
 
       for (i = 0; i != n; ++i)
-        print_completion_result(results->Results + i, stdout);
+        print_completion_result(results->Results + i, stdout, results, i);
     }
     n = clang_codeCompleteGetNumDiagnostics(results);
     for (i = 0; i != n; ++i) {

tools/libclang/CIndexCodeCompletion.cpp

   /// \brief A string containing the Objective-C selector entered thus far for a
   /// message send.
   std::string Selector;
+
+  /// \brief the list of cursors for the results
+  SmallVector<CXCursor, 16> Cursors;
 };
 
 } // end anonymous namespace

                                     CodeCompletionResult *Results,
                                     unsigned NumResults) override {
       StoredResults.reserve(StoredResults.size() + NumResults);
+      AllocatedResults.Cursors.reserve(AllocatedResults.Cursors.size() + NumResults);
       for (unsigned I = 0; I != NumResults; ++I) {
+        auto& Result = Results[I];
         CodeCompletionString *StoredCompletion        
-          = Results[I].CreateCodeCompletionString(S, Context, getAllocator(),
+          = Result.CreateCodeCompletionString(S, Context, getAllocator(),
                                                   getCodeCompletionTUInfo(),
                                                   includeBriefComments());
         
         CXCompletionResult R;
-        R.CursorKind = Results[I].CursorKind;
+        R.CursorKind = Result.CursorKind;
         R.CompletionString = StoredCompletion;
         StoredResults.push_back(R);
+
+        CXCursor cursor = clang_getNullCursor();
+        switch (Result.Kind) {
+        case CodeCompletionResult::RK_Pattern:
+        case CodeCompletionResult::RK_Declaration:
+            if (auto Declaration = Result.Declaration)
+                cursor = cxcursor::MakeCXCursor(Declaration, *TU);
+            break;
+        case CodeCompletionResult::RK_Macro:
+            // TODO: build the CXCursor that represents the Resul.Macro
+            //       I have no idea how to get the MacroDefinitionRecord
+            //       corresponding to the IdentifierInfo
+            break;
+        case CodeCompletionResult::RK_Keyword:
+            // not representable by a cursor
+            break;
+        }
+        AllocatedResults.Cursors.push_back(cursor);
       }
       
       enum CodeCompletionContext::Kind contextKind = Context.getKind();

                                    OverloadCandidate *Candidates,
                                    unsigned NumCandidates) override {
       StoredResults.reserve(StoredResults.size() + NumCandidates);
+      AllocatedResults.Cursors.reserve(AllocatedResults.Cursors.size() + NumCandidates);
       for (unsigned I = 0; I != NumCandidates; ++I) {
+        const auto& Candidate = Candidates[I];
         CodeCompletionString *StoredCompletion
-          = Candidates[I].CreateSignatureString(CurrentArg, S, getAllocator(),
+          = Candidate.CreateSignatureString(CurrentArg, S, getAllocator(),
                                                 getCodeCompletionTUInfo(),
                                                 includeBriefComments());
         

         R.CursorKind = CXCursor_OverloadCandidate;
         R.CompletionString = StoredCompletion;
         StoredResults.push_back(R);
+
+        auto FunctionDecl = Candidate.getFunction();
+        CXCursor cursor = FunctionDecl ? cxcursor::MakeCXCursor(FunctionDecl, *TU) : clang_getNullCursor();
+        AllocatedResults.Cursors.push_back(cursor);
       }
     }
 

   };
 }
 
+CXCursor clang_getCompletionCursor(CXCodeCompleteResults *ResultsIn, int Index)
+{
+  if (!ResultsIn || Index >= ResultsIn->NumResults)
+    return clang_getNullCursor();
+
+  AllocatedCXCodeCompleteResults *Results
+    = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn);
+
+  return Results->Cursors[Index];
+}
+
 void clang_sortCodeCompletionResults(CXCompletionResult *Results,
                                      unsigned NumResults) {
   std::stable_sort(Results, Results + NumResults, OrderCompletionResults());

tools/libclang/libclang.exports

 clang_getCanonicalType
 clang_getChildDiagnostics
 clang_getClangVersion
+clang_getCompletionCursor
 clang_getCompletionAnnotation
 clang_getCompletionAvailability
 clang_getCompletionBriefComment