[clangd] Expose whether no-compile completion was used.

[sammccall]

Summary

Embedding clients want to experiment with showing such results in e.g. a different color.

[kadircet]

We already have CodeCompletion::Origin which is (at least should be)set to Identifier in those cases. Is there a reason for not using it?

[sammccall]

In D61588#1491728, @kadircet wrote:

We already have CodeCompletion::Origin which is (at least should be)set to Identifier in those cases. Is there a reason for not using it?

I'd forgotten about that. A couple I can think of:

• it's for each result, they want a result-set level flag (including when there are no results, possibly *because* we didn't parse)
• identifier completion doesn't inherently mean we didn't parse, that's just the case today. I think we're going to want to offer identifiers inside comments, e.g. https://github.com/clangd/clangd/issues/44

[kadircet]

Thanks for the info. LGTM

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;
+  // 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
 /// latency if the speculation succeeds.
 struct SpeculativeFuzzyFind {
   /// A cached request from past code completions.

clangd/CodeComplete.cpp

runWithoutSema(llvm::StringRef Content, size_t Offset,
     // First scope is the (modified) enclosing scope.
     QueryScopes = Scopes.scopesForIndexQuery();
     ScopeProximity.emplace(QueryScopes);
 
     SymbolSlab IndexResults = Opts.Index ? queryIndex() : SymbolSlab();
 
     CodeCompleteResult Output = toCodeCompleteResult(mergeResults(
         /*SemaResults=*/{}, IndexResults, IdentifierResults));
+    Output.RanParser = false;
     logResults(Output, Tracer);
     return Output;
   }
 
 private:
   void populateContextWords(llvm::StringRef Content) {
     // Take last 3 lines before the completion point.
     unsigned RangeEnd = HeuristicPrefix.Qualifier.begin() - Content.data(),

clangd/unittests/CodeCompleteTests.cpp

auto Results = completions(
         /// Doc for local_var.
         int local_var;
 
         ClassWithMembers().^
       }
       )cpp",
       {cls("IndexClass"), var("index_var"), func("index_func")}, Opts);
 
+  EXPECT_TRUE(Results.RanParser);
   // Class members. The only items that must be present in after-dot
   // completion.
   EXPECT_THAT(Results.Completions,
               AllOf(Has("method"), Has("field"), Not(Has("ClassWithMembers")),
                     Not(Has("operator=")), Not(Has("~ClassWithMembers"))));
   EXPECT_IFF(Opts.IncludeIneligibleResults, Results.Completions,
              Has("private_field"));
   // Global items.
auto Results = completions(
         /// Doc for local_var.
         int local_var;
 
         ^
       }
       )cpp",
       {cls("IndexClass"), var("index_var"), func("index_func")}, Opts);
 
+  EXPECT_TRUE(Results.RanParser);
   // Class members. Should never be present in global completions.
   EXPECT_THAT(Results.Completions,
               Not(AnyOf(Has("method"), Has("method()"), Has("field"))));
   // Global items.
   EXPECT_THAT(Results.Completions,
               AllOf(Has("global_var"), Has("index_var"), Has("global_func"),
                     Has("index_func" /* our fake symbol doesn't include () */),
                     Has("GlobalClass"), Has("IndexClass")));

 TEST(NoCompileCompletionTest, Basic) {
   auto Results = completionsNoCompile(R"cpp(
     void func() {
       int xyz;
       int abc;
       ^
     }
   )cpp");
+  EXPECT_FALSE(Results.RanParser);
   EXPECT_THAT(Results.Completions,
               UnorderedElementsAre(Named("void"), Named("func"), Named("int"),
                                    Named("xyz"), Named("abc")));
 }
 
 TEST(NoCompileCompletionTest, WithFilter) {
   auto Results = completionsNoCompile(R"cpp(
     void func() {