[clangd] Expose completion range in code completion results (C++ API)

[sammccall]

Summary

Informative only, useful for positioning UI, interacting with other sources of
completion etc. As requested by an embedder of clangd.

[usaxena95]

Thanks. LG.

clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp

2680

Please fix the lint errors.

clang-tools-extra/clangd/CodeComplete.h

struct CodeCompletion {
   // Serialize this to an LSP completion item. This is a lossy operation.
   CompletionItem render(const CodeCompleteOptions &) const;
 };
 raw_ostream &operator<<(raw_ostream &, const CodeCompletion &);
 struct CodeCompleteResult {
   std::vector<CodeCompletion> Completions;
   bool HasMore = false;
   CodeCompletionContext::Kind Context = CodeCompletionContext::CCC_Other;
+  // The text that is being directly completed.
+  // Example: foo.pb^ -> foo.push_back()
+  //              ~~
+  // Typically matches the textEdit.range of Completions, but not guaranteed to.
+  llvm::Optional<Range> CompletionRange;
   // Usually the source will be parsed with a real C++ parser.
   // But heuristics may be used instead if e.g. the preamble is not ready.
   bool RanParser = true;
 };
 raw_ostream &operator<<(raw_ostream &, const CodeCompleteResult &);
 
 /// A speculative and asynchronous fuzzy find index request (based on cached
 /// request) that can be sent before parsing sema. This would reduce completion

clang-tools-extra/clangd/CodeComplete.cpp

toCodeCompleteResult(const std::vector<ScoredBundle> &Scored) {
     // Convert the results to final form, assembling the expensive strings.
     for (auto &C : Scored) {
       Output.Completions.push_back(toCodeCompletion(C.first));
       Output.Completions.back().Score = C.second;
       Output.Completions.back().CompletionTokenRange = ReplacedRange;
     }
     Output.HasMore = Incomplete;
     Output.Context = CCContextKind;
+    Output.CompletionRange = ReplacedRange;
     return Output;
   }
 
   SymbolSlab queryIndex() {
     trace::Span Tracer("Query index");
     SPAN_ATTACH(Tracer, "limit", int64_t(Opts.Limit));
 
     // Build the query.

clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp

for (llvm::StringRef Case : {
            "x.[[]][[ab]]^",
            "x.[[]][[]]^",
            "[[x::]][[ab]]^",
            "[[x::]][[]]^",
            "[[::x::]][[ab]]^",
            "some text [[scope::more::]][[identif]]^ier",
            "some text [[scope::]][[mor]]^e::identifier",
            "weird case foo::[[::bar::]][[baz]]^",
+           "/* [[]][[]]^ */",
        }) {
     Annotations F(Case);
     auto Offset = cantFail(positionToOffset(F.code(), F.point()));
     auto ToStringRef = [&](Range R) {
       return F.code().slice(cantFail(positionToOffset(F.code(), R.start)),
                             cantFail(positionToOffset(F.code(), R.end)));
     };
     auto WantQualifier = ToStringRef(F.ranges()[0]),
TEST(CompletionTest, NoCrashWithIncompleteLambda) {
   // callback, its type is not known, which affects the linkage calculation.
   // A bad linkage value gets cached, and subsequently updated.
   EXPECT_THAT(Completions, Contains(Named("x")));
 
   auto Signatures = signatures("auto x() { x(^").signatures;
   EXPECT_THAT(Signatures, Contains(Sig("x() -> auto")));
 }
 
+TEST(CompletionTest, CompletionRange) {
+  const char* WithRange = "auto x = [[abc]]^";
+  auto Completions = completions(WithRange);
+  EXPECT_EQ(Completions.CompletionRange, Annotations(WithRange).range());
+  Completions = completionsNoCompile(WithRange);
+  EXPECT_EQ(Completions.CompletionRange, Annotations(WithRange).range());
+
+  const char* EmptyRange = "auto x = [[]]^";
+  Completions = completions(EmptyRange);
+  EXPECT_EQ(Completions.CompletionRange, Annotations(EmptyRange).range());
+  Completions = completionsNoCompile(EmptyRange);
+  EXPECT_EQ(Completions.CompletionRange, Annotations(EmptyRange).range());
+
+  // Sema doesn't trigger at all here, while the no-sema completion runs
+  // heuristics as normal and reports a range. It'd be nice to be consistent.
+  const char* NoCompletion = "/* [[]]^ */";
+  Completions = completions(NoCompletion);
+  EXPECT_EQ(Completions.CompletionRange, llvm::None);
+  Completions = completionsNoCompile(NoCompletion);
+  EXPECT_EQ(Completions.CompletionRange, Annotations(NoCompletion).range());
+}
+
 TEST(NoCompileCompletionTest, Basic) {
   auto Results = completionsNoCompile(R"cpp(
     void func() {
       int xyz;
       int abc;
       ^
     }
   )cpp");