clang-tools  8.0.0svn
CodeComplete.cpp
Go to the documentation of this file.
1 //===--- CodeComplete.cpp ----------------------------------------*- C++-*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Code completion has several moving parts:
11 // - AST-based completions are provided using the completion hooks in Sema.
12 // - external completions are retrieved from the index (using hints from Sema)
13 // - the two sources overlap, and must be merged and overloads bundled
14 // - results must be scored and ranked (see Quality.h) before rendering
15 //
16 // Signature help works in a similar way as code completion, but it is simpler:
17 // it's purely AST-based, and there are few candidates.
18 //
19 //===----------------------------------------------------------------------===//
20 
21 #include "CodeComplete.h"
22 #include "AST.h"
23 #include "ClangdUnit.h"
24 #include "CodeCompletionStrings.h"
25 #include "Compiler.h"
26 #include "Diagnostics.h"
27 #include "FileDistance.h"
28 #include "FuzzyMatch.h"
29 #include "Headers.h"
30 #include "Logger.h"
31 #include "Quality.h"
32 #include "SourceCode.h"
33 #include "TUScheduler.h"
34 #include "Trace.h"
35 #include "URI.h"
36 #include "index/Index.h"
37 #include "clang/AST/Decl.h"
38 #include "clang/AST/DeclBase.h"
39 #include "clang/ASTMatchers/ASTMatchFinder.h"
40 #include "clang/Basic/LangOptions.h"
41 #include "clang/Basic/SourceLocation.h"
42 #include "clang/Format/Format.h"
43 #include "clang/Frontend/CompilerInstance.h"
44 #include "clang/Frontend/FrontendActions.h"
45 #include "clang/Lex/PreprocessorOptions.h"
46 #include "clang/Sema/CodeCompleteConsumer.h"
47 #include "clang/Sema/Sema.h"
48 #include "llvm/ADT/ArrayRef.h"
49 #include "llvm/ADT/None.h"
50 #include "llvm/ADT/Optional.h"
51 #include "llvm/ADT/SmallVector.h"
52 #include "llvm/Support/Error.h"
53 #include "llvm/Support/Format.h"
54 #include "llvm/Support/FormatVariadic.h"
55 #include "llvm/Support/ScopedPrinter.h"
56 #include <algorithm>
57 #include <iterator>
58 
59 // We log detailed candidate here if you run with -debug-only=codecomplete.
60 #define DEBUG_TYPE "CodeComplete"
61 
62 using namespace llvm;
63 namespace clang {
64 namespace clangd {
65 namespace {
66 
67 CompletionItemKind toCompletionItemKind(index::SymbolKind Kind) {
68  using SK = index::SymbolKind;
69  switch (Kind) {
70  case SK::Unknown:
71  return CompletionItemKind::Missing;
72  case SK::Module:
73  case SK::Namespace:
74  case SK::NamespaceAlias:
75  return CompletionItemKind::Module;
76  case SK::Macro:
77  return CompletionItemKind::Text;
78  case SK::Enum:
79  return CompletionItemKind::Enum;
80  // FIXME(ioeric): use LSP struct instead of class when it is suppoted in the
81  // protocol.
82  case SK::Struct:
83  case SK::Class:
84  case SK::Protocol:
85  case SK::Extension:
86  case SK::Union:
87  return CompletionItemKind::Class;
88  // FIXME(ioeric): figure out whether reference is the right type for aliases.
89  case SK::TypeAlias:
90  case SK::Using:
91  return CompletionItemKind::Reference;
92  case SK::Function:
93  // FIXME(ioeric): this should probably be an operator. This should be fixed
94  // when `Operator` is support type in the protocol.
95  case SK::ConversionFunction:
96  return CompletionItemKind::Function;
97  case SK::Variable:
98  case SK::Parameter:
99  return CompletionItemKind::Variable;
100  case SK::Field:
101  return CompletionItemKind::Field;
102  // FIXME(ioeric): use LSP enum constant when it is supported in the protocol.
103  case SK::EnumConstant:
104  return CompletionItemKind::Value;
105  case SK::InstanceMethod:
106  case SK::ClassMethod:
107  case SK::StaticMethod:
108  case SK::Destructor:
109  return CompletionItemKind::Method;
110  case SK::InstanceProperty:
111  case SK::ClassProperty:
112  case SK::StaticProperty:
113  return CompletionItemKind::Property;
114  case SK::Constructor:
115  return CompletionItemKind::Constructor;
116  }
117  llvm_unreachable("Unhandled clang::index::SymbolKind.");
118 }
119 
121 toCompletionItemKind(CodeCompletionResult::ResultKind ResKind,
122  const NamedDecl *Decl,
123  CodeCompletionContext::Kind CtxKind) {
124  if (Decl)
125  return toCompletionItemKind(index::getSymbolInfo(Decl).Kind);
126  if (CtxKind == CodeCompletionContext::CCC_IncludedFile)
128  switch (ResKind) {
129  case CodeCompletionResult::RK_Declaration:
130  llvm_unreachable("RK_Declaration without Decl");
131  case CodeCompletionResult::RK_Keyword:
132  return CompletionItemKind::Keyword;
133  case CodeCompletionResult::RK_Macro:
134  return CompletionItemKind::Text; // unfortunately, there's no 'Macro'
135  // completion items in LSP.
136  case CodeCompletionResult::RK_Pattern:
137  return CompletionItemKind::Snippet;
138  }
139  llvm_unreachable("Unhandled CodeCompletionResult::ResultKind.");
140 }
141 
142 /// Get the optional chunk as a string. This function is possibly recursive.
143 ///
144 /// The parameter info for each parameter is appended to the Parameters.
145 std::string getOptionalParameters(const CodeCompletionString &CCS,
146  std::vector<ParameterInformation> &Parameters,
147  SignatureQualitySignals &Signal) {
148  std::string Result;
149  for (const auto &Chunk : CCS) {
150  switch (Chunk.Kind) {
151  case CodeCompletionString::CK_Optional:
152  assert(Chunk.Optional &&
153  "Expected the optional code completion string to be non-null.");
154  Result += getOptionalParameters(*Chunk.Optional, Parameters, Signal);
155  break;
156  case CodeCompletionString::CK_VerticalSpace:
157  break;
158  case CodeCompletionString::CK_Placeholder:
159  // A string that acts as a placeholder for, e.g., a function call
160  // argument.
161  // Intentional fallthrough here.
162  case CodeCompletionString::CK_CurrentParameter: {
163  // A piece of text that describes the parameter that corresponds to
164  // the code-completion location within a function call, message send,
165  // macro invocation, etc.
166  Result += Chunk.Text;
167  ParameterInformation Info;
168  Info.label = Chunk.Text;
169  Parameters.push_back(std::move(Info));
170  Signal.ContainsActiveParameter = true;
171  Signal.NumberOfOptionalParameters++;
172  break;
173  }
174  default:
175  Result += Chunk.Text;
176  break;
177  }
178  }
179  return Result;
180 }
181 
182 /// Creates a `HeaderFile` from \p Header which can be either a URI or a literal
183 /// include.
184 static Expected<HeaderFile> toHeaderFile(StringRef Header, StringRef HintPath) {
185  if (isLiteralInclude(Header))
186  return HeaderFile{Header.str(), /*Verbatim=*/true};
187  auto U = URI::parse(Header);
188  if (!U)
189  return U.takeError();
190 
191  auto IncludePath = URI::includeSpelling(*U);
192  if (!IncludePath)
193  return IncludePath.takeError();
194  if (!IncludePath->empty())
195  return HeaderFile{std::move(*IncludePath), /*Verbatim=*/true};
196 
197  auto Resolved = URI::resolve(*U, HintPath);
198  if (!Resolved)
199  return Resolved.takeError();
200  return HeaderFile{std::move(*Resolved), /*Verbatim=*/false};
201 }
202 
203 /// A code completion result, in clang-native form.
204 /// It may be promoted to a CompletionItem if it's among the top-ranked results.
205 struct CompletionCandidate {
206  StringRef Name; // Used for filtering and sorting.
207  // We may have a result from Sema, from the index, or both.
208  const CodeCompletionResult *SemaResult = nullptr;
209  const Symbol *IndexResult = nullptr;
210  SmallVector<StringRef, 1> RankedIncludeHeaders;
211 
212  // Returns a token identifying the overload set this is part of.
213  // 0 indicates it's not part of any overload set.
214  size_t overloadSet() const {
215  SmallString<256> Scratch;
216  if (IndexResult) {
217  switch (IndexResult->SymInfo.Kind) {
218  case index::SymbolKind::ClassMethod:
219  case index::SymbolKind::InstanceMethod:
220  case index::SymbolKind::StaticMethod:
221 #ifndef NDEBUG
222  llvm_unreachable("Don't expect members from index in code completion");
223 #else
224  LLVM_FALLTHROUGH;
225 #endif
226  case index::SymbolKind::Function:
227  // We can't group overloads together that need different #includes.
228  // This could break #include insertion.
229  return hash_combine(
230  (IndexResult->Scope + IndexResult->Name).toStringRef(Scratch),
231  headerToInsertIfAllowed().getValueOr(""));
232  default:
233  return 0;
234  }
235  }
236  assert(SemaResult);
237  // We need to make sure we're consistent with the IndexResult case!
238  const NamedDecl *D = SemaResult->Declaration;
239  if (!D || !D->isFunctionOrFunctionTemplate())
240  return 0;
241  {
242  raw_svector_ostream OS(Scratch);
243  D->printQualifiedName(OS);
244  }
245  return hash_combine(Scratch, headerToInsertIfAllowed().getValueOr(""));
246  }
247 
248  // The best header to include if include insertion is allowed.
249  Optional<StringRef> headerToInsertIfAllowed() const {
250  if (RankedIncludeHeaders.empty())
251  return None;
252  if (SemaResult && SemaResult->Declaration) {
253  // Avoid inserting new #include if the declaration is found in the current
254  // file e.g. the symbol is forward declared.
255  auto &SM = SemaResult->Declaration->getASTContext().getSourceManager();
256  for (const Decl *RD : SemaResult->Declaration->redecls())
257  if (SM.isInMainFile(SM.getExpansionLoc(RD->getBeginLoc())))
258  return None;
259  }
260  return RankedIncludeHeaders[0];
261  }
262 
263  using Bundle = SmallVector<CompletionCandidate, 4>;
264 };
265 using ScoredBundle =
266  std::pair<CompletionCandidate::Bundle, CodeCompletion::Scores>;
267 struct ScoredBundleGreater {
268  bool operator()(const ScoredBundle &L, const ScoredBundle &R) {
269  if (L.second.Total != R.second.Total)
270  return L.second.Total > R.second.Total;
271  return L.first.front().Name <
272  R.first.front().Name; // Earlier name is better.
273  }
274 };
275 
276 // Assembles a code completion out of a bundle of >=1 completion candidates.
277 // Many of the expensive strings are only computed at this point, once we know
278 // the candidate bundle is going to be returned.
279 //
280 // Many fields are the same for all candidates in a bundle (e.g. name), and are
281 // computed from the first candidate, in the constructor.
282 // Others vary per candidate, so add() must be called for remaining candidates.
283 struct CodeCompletionBuilder {
284  CodeCompletionBuilder(ASTContext &ASTCtx, const CompletionCandidate &C,
285  CodeCompletionString *SemaCCS,
286  ArrayRef<std::string> QueryScopes,
287  const IncludeInserter &Includes, StringRef FileName,
288  CodeCompletionContext::Kind ContextKind,
289  const CodeCompleteOptions &Opts)
290  : ASTCtx(ASTCtx), ExtractDocumentation(Opts.IncludeComments),
291  EnableFunctionArgSnippets(Opts.EnableFunctionArgSnippets) {
292  add(C, SemaCCS);
293  if (C.SemaResult) {
294  Completion.Origin |= SymbolOrigin::AST;
295  Completion.Name = StringRef(SemaCCS->getTypedText());
296  if (Completion.Scope.empty()) {
297  if ((C.SemaResult->Kind == CodeCompletionResult::RK_Declaration) ||
298  (C.SemaResult->Kind == CodeCompletionResult::RK_Pattern))
299  if (const auto *D = C.SemaResult->getDeclaration())
300  if (const auto *ND = dyn_cast<NamedDecl>(D))
301  Completion.Scope =
303  }
304  Completion.Kind = toCompletionItemKind(
305  C.SemaResult->Kind, C.SemaResult->Declaration, ContextKind);
306  // Sema could provide more info on whether the completion was a file or
307  // folder.
308  if (Completion.Kind == CompletionItemKind::File &&
309  Completion.Name.back() == '/')
310  Completion.Kind = CompletionItemKind::Folder;
311  for (const auto &FixIt : C.SemaResult->FixIts) {
312  Completion.FixIts.push_back(
313  toTextEdit(FixIt, ASTCtx.getSourceManager(), ASTCtx.getLangOpts()));
314  }
315  llvm::sort(Completion.FixIts, [](const TextEdit &X, const TextEdit &Y) {
316  return std::tie(X.range.start.line, X.range.start.character) <
317  std::tie(Y.range.start.line, Y.range.start.character);
318  });
319  Completion.Deprecated |=
320  (C.SemaResult->Availability == CXAvailability_Deprecated);
321  }
322  if (C.IndexResult) {
323  Completion.Origin |= C.IndexResult->Origin;
324  if (Completion.Scope.empty())
325  Completion.Scope = C.IndexResult->Scope;
326  if (Completion.Kind == CompletionItemKind::Missing)
327  Completion.Kind = toCompletionItemKind(C.IndexResult->SymInfo.Kind);
328  if (Completion.Name.empty())
329  Completion.Name = C.IndexResult->Name;
330  // If the completion was visible to Sema, no qualifier is needed. This
331  // avoids unneeded qualifiers in cases like with `using ns::X`.
332  if (Completion.RequiredQualifier.empty() && !C.SemaResult) {
333  StringRef ShortestQualifier = C.IndexResult->Scope;
334  for (StringRef Scope : QueryScopes) {
335  StringRef Qualifier = C.IndexResult->Scope;
336  if (Qualifier.consume_front(Scope) &&
337  Qualifier.size() < ShortestQualifier.size())
338  ShortestQualifier = Qualifier;
339  }
340  Completion.RequiredQualifier = ShortestQualifier;
341  }
342  Completion.Deprecated |= (C.IndexResult->Flags & Symbol::Deprecated);
343  }
344 
345  // Turn absolute path into a literal string that can be #included.
346  auto Inserted =
347  [&](StringRef Header) -> Expected<std::pair<std::string, bool>> {
348  auto ResolvedDeclaring =
349  toHeaderFile(C.IndexResult->CanonicalDeclaration.FileURI, FileName);
350  if (!ResolvedDeclaring)
351  return ResolvedDeclaring.takeError();
352  auto ResolvedInserted = toHeaderFile(Header, FileName);
353  if (!ResolvedInserted)
354  return ResolvedInserted.takeError();
355  return std::make_pair(
356  Includes.calculateIncludePath(*ResolvedDeclaring, *ResolvedInserted),
357  Includes.shouldInsertInclude(*ResolvedDeclaring, *ResolvedInserted));
358  };
359  bool ShouldInsert = C.headerToInsertIfAllowed().hasValue();
360  // Calculate include paths and edits for all possible headers.
361  for (const auto &Inc : C.RankedIncludeHeaders) {
362  if (auto ToInclude = Inserted(Inc)) {
363  CodeCompletion::IncludeCandidate Include;
364  Include.Header = ToInclude->first;
365  if (ToInclude->second && ShouldInsert)
366  Include.Insertion = Includes.insert(ToInclude->first);
367  Completion.Includes.push_back(std::move(Include));
368  } else
369  log("Failed to generate include insertion edits for adding header "
370  "(FileURI='{0}', IncludeHeader='{1}') into {2}",
371  C.IndexResult->CanonicalDeclaration.FileURI, Inc, FileName);
372  }
373  // Prefer includes that do not need edits (i.e. already exist).
374  std::stable_partition(Completion.Includes.begin(),
375  Completion.Includes.end(),
376  [](const CodeCompletion::IncludeCandidate &I) {
377  return !I.Insertion.hasValue();
378  });
379  }
380 
381  void add(const CompletionCandidate &C, CodeCompletionString *SemaCCS) {
382  assert(bool(C.SemaResult) == bool(SemaCCS));
383  Bundled.emplace_back();
384  BundledEntry &S = Bundled.back();
385  if (C.SemaResult) {
386  getSignature(*SemaCCS, &S.Signature, &S.SnippetSuffix,
387  &Completion.RequiredQualifier);
388  S.ReturnType = getReturnType(*SemaCCS);
389  } else if (C.IndexResult) {
390  S.Signature = C.IndexResult->Signature;
391  S.SnippetSuffix = C.IndexResult->CompletionSnippetSuffix;
392  S.ReturnType = C.IndexResult->ReturnType;
393  }
394  if (ExtractDocumentation && Completion.Documentation.empty()) {
395  if (C.IndexResult)
396  Completion.Documentation = C.IndexResult->Documentation;
397  else if (C.SemaResult)
398  Completion.Documentation = getDocComment(ASTCtx, *C.SemaResult,
399  /*CommentsFromHeader=*/false);
400  }
401  }
402 
403  CodeCompletion build() {
404  Completion.ReturnType = summarizeReturnType();
405  Completion.Signature = summarizeSignature();
406  Completion.SnippetSuffix = summarizeSnippet();
407  Completion.BundleSize = Bundled.size();
408  return std::move(Completion);
409  }
410 
411 private:
412  struct BundledEntry {
413  std::string SnippetSuffix;
414  std::string Signature;
415  std::string ReturnType;
416  };
417 
418  // If all BundledEntrys have the same value for a property, return it.
419  template <std::string BundledEntry::*Member>
420  const std::string *onlyValue() const {
421  auto B = Bundled.begin(), E = Bundled.end();
422  for (auto I = B + 1; I != E; ++I)
423  if (I->*Member != B->*Member)
424  return nullptr;
425  return &(B->*Member);
426  }
427 
428  template <bool BundledEntry::*Member> const bool *onlyValue() const {
429  auto B = Bundled.begin(), E = Bundled.end();
430  for (auto I = B + 1; I != E; ++I)
431  if (I->*Member != B->*Member)
432  return nullptr;
433  return &(B->*Member);
434  }
435 
436  std::string summarizeReturnType() const {
437  if (auto *RT = onlyValue<&BundledEntry::ReturnType>())
438  return *RT;
439  return "";
440  }
441 
442  std::string summarizeSnippet() const {
443  auto *Snippet = onlyValue<&BundledEntry::SnippetSuffix>();
444  if (!Snippet)
445  // All bundles are function calls.
446  // FIXME(ibiryukov): sometimes add template arguments to a snippet, e.g.
447  // we need to complete 'forward<$1>($0)'.
448  return "($0)";
450  return *Snippet;
451 
452  // Replace argument snippets with a simplified pattern.
453  if (Snippet->empty())
454  return "";
455  if (Completion.Kind == CompletionItemKind::Function ||
456  Completion.Kind == CompletionItemKind::Method) {
457  // Functions snippets can be of 2 types:
458  // - containing only function arguments, e.g.
459  // foo(${1:int p1}, ${2:int p2});
460  // We transform this pattern to '($0)' or '()'.
461  // - template arguments and function arguments, e.g.
462  // foo<${1:class}>(${2:int p1}).
463  // We transform this pattern to '<$1>()$0' or '<$0>()'.
464 
465  bool EmptyArgs = StringRef(*Snippet).endswith("()");
466  if (Snippet->front() == '<')
467  return EmptyArgs ? "<$1>()$0" : "<$1>($0)";
468  if (Snippet->front() == '(')
469  return EmptyArgs ? "()" : "($0)";
470  return *Snippet; // Not an arg snippet?
471  }
472  if (Completion.Kind == CompletionItemKind::Reference ||
473  Completion.Kind == CompletionItemKind::Class) {
474  if (Snippet->front() != '<')
475  return *Snippet; // Not an arg snippet?
476 
477  // Classes and template using aliases can only have template arguments,
478  // e.g. Foo<${1:class}>.
479  if (StringRef(*Snippet).endswith("<>"))
480  return "<>"; // can happen with defaulted template arguments.
481  return "<$0>";
482  }
483  return *Snippet;
484  }
485 
486  std::string summarizeSignature() const {
487  if (auto *Signature = onlyValue<&BundledEntry::Signature>())
488  return *Signature;
489  // All bundles are function calls.
490  return "(…)";
491  }
492 
493  ASTContext &ASTCtx;
494  CodeCompletion Completion;
495  SmallVector<BundledEntry, 1> Bundled;
496  bool ExtractDocumentation;
498 };
499 
500 // Determine the symbol ID for a Sema code completion result, if possible.
501 Optional<SymbolID> getSymbolID(const CodeCompletionResult &R,
502  const SourceManager &SM) {
503  switch (R.Kind) {
504  case CodeCompletionResult::RK_Declaration:
505  case CodeCompletionResult::RK_Pattern: {
506  return clang::clangd::getSymbolID(R.Declaration);
507  }
508  case CodeCompletionResult::RK_Macro:
509  return clang::clangd::getSymbolID(*R.Macro, R.MacroDefInfo, SM);
510  case CodeCompletionResult::RK_Keyword:
511  return None;
512  }
513  llvm_unreachable("unknown CodeCompletionResult kind");
514 }
515 
516 // Scopes of the paritial identifier we're trying to complete.
517 // It is used when we query the index for more completion results.
518 struct SpecifiedScope {
519  // The scopes we should look in, determined by Sema.
520  //
521  // If the qualifier was fully resolved, we look for completions in these
522  // scopes; if there is an unresolved part of the qualifier, it should be
523  // resolved within these scopes.
524  //
525  // Examples of qualified completion:
526  //
527  // "::vec" => {""}
528  // "using namespace std; ::vec^" => {"", "std::"}
529  // "namespace ns {using namespace std;} ns::^" => {"ns::", "std::"}
530  // "std::vec^" => {""} // "std" unresolved
531  //
532  // Examples of unqualified completion:
533  //
534  // "vec^" => {""}
535  // "using namespace std; vec^" => {"", "std::"}
536  // "using namespace std; namespace ns { vec^ }" => {"ns::", "std::", ""}
537  //
538  // "" for global namespace, "ns::" for normal namespace.
539  std::vector<std::string> AccessibleScopes;
540  // The full scope qualifier as typed by the user (without the leading "::").
541  // Set if the qualifier is not fully resolved by Sema.
542  Optional<std::string> UnresolvedQualifier;
543 
544  // Construct scopes being queried in indexes. The results are deduplicated.
545  // This method format the scopes to match the index request representation.
546  std::vector<std::string> scopesForIndexQuery() {
547  std::set<std::string> Results;
548  for (StringRef AS : AccessibleScopes)
549  Results.insert(
550  ((UnresolvedQualifier ? *UnresolvedQualifier : "") + AS).str());
551  return {Results.begin(), Results.end()};
552  }
553 };
554 
555 // Get all scopes that will be queried in indexes and whether symbols from
556 // any scope is allowed. The first scope in the list is the preferred scope
557 // (e.g. enclosing namespace).
558 std::pair<std::vector<std::string>, bool>
559 getQueryScopes(CodeCompletionContext &CCContext, const Sema &CCSema,
560  const CodeCompleteOptions &Opts) {
561  auto GetAllAccessibleScopes = [](CodeCompletionContext &CCContext) {
562  SpecifiedScope Info;
563  for (auto *Context : CCContext.getVisitedContexts()) {
564  if (isa<TranslationUnitDecl>(Context))
565  Info.AccessibleScopes.push_back(""); // global namespace
566  else if (isa<NamespaceDecl>(Context))
567  Info.AccessibleScopes.push_back(printNamespaceScope(*Context));
568  }
569  return Info;
570  };
571 
572  auto SS = CCContext.getCXXScopeSpecifier();
573 
574  // Unqualified completion (e.g. "vec^").
575  if (!SS) {
576  std::vector<std::string> Scopes;
577  std::string EnclosingScope = printNamespaceScope(*CCSema.CurContext);
578  Scopes.push_back(EnclosingScope);
579  for (auto &S : GetAllAccessibleScopes(CCContext).scopesForIndexQuery()) {
580  if (EnclosingScope != S)
581  Scopes.push_back(std::move(S));
582  }
583  // Allow AllScopes completion only for there is no explicit scope qualifier.
584  return {Scopes, Opts.AllScopes};
585  }
586 
587  // Qualified completion ("std::vec^"), we have two cases depending on whether
588  // the qualifier can be resolved by Sema.
589  if ((*SS)->isValid()) { // Resolved qualifier.
590  return {GetAllAccessibleScopes(CCContext).scopesForIndexQuery(), false};
591  }
592 
593  // Unresolved qualifier.
594  // FIXME: When Sema can resolve part of a scope chain (e.g.
595  // "known::unknown::id"), we should expand the known part ("known::") rather
596  // than treating the whole thing as unknown.
597  SpecifiedScope Info;
598  Info.AccessibleScopes.push_back(""); // global namespace
599 
600  Info.UnresolvedQualifier =
601  Lexer::getSourceText(CharSourceRange::getCharRange((*SS)->getRange()),
602  CCSema.SourceMgr, clang::LangOptions())
603  .ltrim("::");
604  // Sema excludes the trailing "::".
605  if (!Info.UnresolvedQualifier->empty())
606  *Info.UnresolvedQualifier += "::";
607 
608  return {Info.scopesForIndexQuery(), false};
609 }
610 
611 // Should we perform index-based completion in a context of the specified kind?
612 // FIXME: consider allowing completion, but restricting the result types.
613 bool contextAllowsIndex(enum CodeCompletionContext::Kind K) {
614  switch (K) {
615  case CodeCompletionContext::CCC_TopLevel:
616  case CodeCompletionContext::CCC_ObjCInterface:
617  case CodeCompletionContext::CCC_ObjCImplementation:
618  case CodeCompletionContext::CCC_ObjCIvarList:
619  case CodeCompletionContext::CCC_ClassStructUnion:
620  case CodeCompletionContext::CCC_Statement:
621  case CodeCompletionContext::CCC_Expression:
622  case CodeCompletionContext::CCC_ObjCMessageReceiver:
623  case CodeCompletionContext::CCC_EnumTag:
624  case CodeCompletionContext::CCC_UnionTag:
625  case CodeCompletionContext::CCC_ClassOrStructTag:
626  case CodeCompletionContext::CCC_ObjCProtocolName:
627  case CodeCompletionContext::CCC_Namespace:
628  case CodeCompletionContext::CCC_Type:
629  case CodeCompletionContext::CCC_ParenthesizedExpression:
630  case CodeCompletionContext::CCC_ObjCInterfaceName:
631  case CodeCompletionContext::CCC_ObjCCategoryName:
632  case CodeCompletionContext::CCC_Symbol:
633  case CodeCompletionContext::CCC_SymbolOrNewName:
634  return true;
635  case CodeCompletionContext::CCC_OtherWithMacros:
636  case CodeCompletionContext::CCC_DotMemberAccess:
637  case CodeCompletionContext::CCC_ArrowMemberAccess:
638  case CodeCompletionContext::CCC_ObjCPropertyAccess:
639  case CodeCompletionContext::CCC_MacroName:
640  case CodeCompletionContext::CCC_MacroNameUse:
641  case CodeCompletionContext::CCC_PreprocessorExpression:
642  case CodeCompletionContext::CCC_PreprocessorDirective:
643  case CodeCompletionContext::CCC_SelectorName:
644  case CodeCompletionContext::CCC_TypeQualifiers:
645  case CodeCompletionContext::CCC_ObjCInstanceMessage:
646  case CodeCompletionContext::CCC_ObjCClassMessage:
647  case CodeCompletionContext::CCC_IncludedFile:
648  // FIXME: Provide identifier based completions for the following contexts:
649  case CodeCompletionContext::CCC_Other: // Be conservative.
650  case CodeCompletionContext::CCC_NaturalLanguage:
651  case CodeCompletionContext::CCC_Recovery:
652  case CodeCompletionContext::CCC_NewName:
653  return false;
654  }
655  llvm_unreachable("unknown code completion context");
656 }
657 
658 // Some member calls are blacklisted because they're so rarely useful.
659 static bool isBlacklistedMember(const NamedDecl &D) {
660  // Destructor completion is rarely useful, and works inconsistently.
661  // (s.^ completes ~string, but s.~st^ is an error).
662  if (D.getKind() == Decl::CXXDestructor)
663  return true;
664  // Injected name may be useful for A::foo(), but who writes A::A::foo()?
665  if (auto *R = dyn_cast_or_null<RecordDecl>(&D))
666  if (R->isInjectedClassName())
667  return true;
668  // Explicit calls to operators are also rare.
669  auto NameKind = D.getDeclName().getNameKind();
670  if (NameKind == DeclarationName::CXXOperatorName ||
671  NameKind == DeclarationName::CXXLiteralOperatorName ||
672  NameKind == DeclarationName::CXXConversionFunctionName)
673  return true;
674  return false;
675 }
676 
677 // The CompletionRecorder captures Sema code-complete output, including context.
678 // It filters out ignored results (but doesn't apply fuzzy-filtering yet).
679 // It doesn't do scoring or conversion to CompletionItem yet, as we want to
680 // merge with index results first.
681 // Generally the fields and methods of this object should only be used from
682 // within the callback.
683 struct CompletionRecorder : public CodeCompleteConsumer {
684  CompletionRecorder(const CodeCompleteOptions &Opts,
685  unique_function<void()> ResultsCallback)
686  : CodeCompleteConsumer(Opts.getClangCompleteOpts(),
687  /*OutputIsBinary=*/false),
688  CCContext(CodeCompletionContext::CCC_Other), Opts(Opts),
689  CCAllocator(std::make_shared<GlobalCodeCompletionAllocator>()),
690  CCTUInfo(CCAllocator), ResultsCallback(std::move(ResultsCallback)) {
691  assert(this->ResultsCallback);
692  }
693 
694  std::vector<CodeCompletionResult> Results;
695  CodeCompletionContext CCContext;
696  Sema *CCSema = nullptr; // Sema that created the results.
697  // FIXME: Sema is scary. Can we store ASTContext and Preprocessor, instead?
698 
699  void ProcessCodeCompleteResults(class Sema &S, CodeCompletionContext Context,
700  CodeCompletionResult *InResults,
701  unsigned NumResults) override final {
702  // Results from recovery mode are generally useless, and the callback after
703  // recovery (if any) is usually more interesting. To make sure we handle the
704  // future callback from sema, we just ignore all callbacks in recovery mode,
705  // as taking only results from recovery mode results in poor completion
706  // results.
707  // FIXME: in case there is no future sema completion callback after the
708  // recovery mode, we might still want to provide some results (e.g. trivial
709  // identifier-based completion).
710  if (Context.getKind() == CodeCompletionContext::CCC_Recovery) {
711  log("Code complete: Ignoring sema code complete callback with Recovery "
712  "context.");
713  return;
714  }
715  // If a callback is called without any sema result and the context does not
716  // support index-based completion, we simply skip it to give way to
717  // potential future callbacks with results.
718  if (NumResults == 0 && !contextAllowsIndex(Context.getKind()))
719  return;
720  if (CCSema) {
721  log("Multiple code complete callbacks (parser backtracked?). "
722  "Dropping results from context {0}, keeping results from {1}.",
723  getCompletionKindString(Context.getKind()),
724  getCompletionKindString(this->CCContext.getKind()));
725  return;
726  }
727  // Record the completion context.
728  CCSema = &S;
729  CCContext = Context;
730 
731  // Retain the results we might want.
732  for (unsigned I = 0; I < NumResults; ++I) {
733  auto &Result = InResults[I];
734  // Class members that are shadowed by subclasses are usually noise.
735  if (Result.Hidden && Result.Declaration &&
736  Result.Declaration->isCXXClassMember())
737  continue;
738  if (!Opts.IncludeIneligibleResults &&
739  (Result.Availability == CXAvailability_NotAvailable ||
740  Result.Availability == CXAvailability_NotAccessible))
741  continue;
742  if (Result.Declaration &&
743  !Context.getBaseType().isNull() // is this a member-access context?
744  && isBlacklistedMember(*Result.Declaration))
745  continue;
746  // We choose to never append '::' to completion results in clangd.
747  Result.StartsNestedNameSpecifier = false;
748  Results.push_back(Result);
749  }
750  ResultsCallback();
751  }
752 
753  CodeCompletionAllocator &getAllocator() override { return *CCAllocator; }
754  CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo; }
755 
756  // Returns the filtering/sorting name for Result, which must be from Results.
757  // Returned string is owned by this recorder (or the AST).
758  StringRef getName(const CodeCompletionResult &Result) {
759  switch (Result.Kind) {
760  case CodeCompletionResult::RK_Declaration:
761  if (auto *ID = Result.Declaration->getIdentifier())
762  return ID->getName();
763  break;
764  case CodeCompletionResult::RK_Keyword:
765  return Result.Keyword;
766  case CodeCompletionResult::RK_Macro:
767  return Result.Macro->getName();
768  case CodeCompletionResult::RK_Pattern:
769  return Result.Pattern->getTypedText();
770  }
771  auto *CCS = codeCompletionString(Result);
772  return CCS->getTypedText();
773  }
774 
775  // Build a CodeCompletion string for R, which must be from Results.
776  // The CCS will be owned by this recorder.
777  CodeCompletionString *codeCompletionString(const CodeCompletionResult &R) {
778  // CodeCompletionResult doesn't seem to be const-correct. We own it, anyway.
779  return const_cast<CodeCompletionResult &>(R).CreateCodeCompletionString(
780  *CCSema, CCContext, *CCAllocator, CCTUInfo,
781  /*IncludeBriefComments=*/false);
782  }
783 
784 private:
785  CodeCompleteOptions Opts;
786  std::shared_ptr<GlobalCodeCompletionAllocator> CCAllocator;
787  CodeCompletionTUInfo CCTUInfo;
788  unique_function<void()> ResultsCallback;
789 };
790 
791 struct ScoredSignature {
792  // When set, requires documentation to be requested from the index with this
793  // ID.
794  Optional<SymbolID> IDForDoc;
795  SignatureInformation Signature;
796  SignatureQualitySignals Quality;
797 };
798 
799 class SignatureHelpCollector final : public CodeCompleteConsumer {
800 public:
801  SignatureHelpCollector(const clang::CodeCompleteOptions &CodeCompleteOpts,
802  const SymbolIndex *Index, SignatureHelp &SigHelp)
803  : CodeCompleteConsumer(CodeCompleteOpts,
804  /*OutputIsBinary=*/false),
805  SigHelp(SigHelp),
806  Allocator(std::make_shared<clang::GlobalCodeCompletionAllocator>()),
807  CCTUInfo(Allocator), Index(Index) {}
808 
809  void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
810  OverloadCandidate *Candidates,
811  unsigned NumCandidates,
812  SourceLocation OpenParLoc) override {
813  assert(!OpenParLoc.isInvalid());
814  SourceManager &SrcMgr = S.getSourceManager();
815  OpenParLoc = SrcMgr.getFileLoc(OpenParLoc);
816  if (SrcMgr.isInMainFile(OpenParLoc))
817  SigHelp.argListStart = sourceLocToPosition(SrcMgr, OpenParLoc);
818  else
819  elog("Location oustide main file in signature help: {0}",
820  OpenParLoc.printToString(SrcMgr));
821 
822  std::vector<ScoredSignature> ScoredSignatures;
823  SigHelp.signatures.reserve(NumCandidates);
824  ScoredSignatures.reserve(NumCandidates);
825  // FIXME(rwols): How can we determine the "active overload candidate"?
826  // Right now the overloaded candidates seem to be provided in a "best fit"
827  // order, so I'm not too worried about this.
828  SigHelp.activeSignature = 0;
829  assert(CurrentArg <= (unsigned)std::numeric_limits<int>::max() &&
830  "too many arguments");
831  SigHelp.activeParameter = static_cast<int>(CurrentArg);
832  for (unsigned I = 0; I < NumCandidates; ++I) {
833  OverloadCandidate Candidate = Candidates[I];
834  // We want to avoid showing instantiated signatures, because they may be
835  // long in some cases (e.g. when 'T' is substituted with 'std::string', we
836  // would get 'std::basic_string<char>').
837  if (auto *Func = Candidate.getFunction()) {
838  if (auto *Pattern = Func->getTemplateInstantiationPattern())
839  Candidate = OverloadCandidate(Pattern);
840  }
841 
842  const auto *CCS = Candidate.CreateSignatureString(
843  CurrentArg, S, *Allocator, CCTUInfo, true);
844  assert(CCS && "Expected the CodeCompletionString to be non-null");
845  ScoredSignatures.push_back(processOverloadCandidate(
846  Candidate, *CCS,
847  Candidate.getFunction()
848  ? getDeclComment(S.getASTContext(), *Candidate.getFunction())
849  : ""));
850  }
851 
852  // Sema does not load the docs from the preamble, so we need to fetch extra
853  // docs from the index instead.
854  DenseMap<SymbolID, std::string> FetchedDocs;
855  if (Index) {
856  LookupRequest IndexRequest;
857  for (const auto &S : ScoredSignatures) {
858  if (!S.IDForDoc)
859  continue;
860  IndexRequest.IDs.insert(*S.IDForDoc);
861  }
862  Index->lookup(IndexRequest, [&](const Symbol &S) {
863  if (!S.Documentation.empty())
864  FetchedDocs[S.ID] = S.Documentation;
865  });
866  log("SigHelp: requested docs for {0} symbols from the index, got {1} "
867  "symbols with non-empty docs in the response",
868  IndexRequest.IDs.size(), FetchedDocs.size());
869  }
870 
871  llvm::sort(
872  ScoredSignatures,
873  [](const ScoredSignature &L, const ScoredSignature &R) {
874  // Ordering follows:
875  // - Less number of parameters is better.
876  // - Function is better than FunctionType which is better than
877  // Function Template.
878  // - High score is better.
879  // - Shorter signature is better.
880  // - Alphebatically smaller is better.
881  if (L.Quality.NumberOfParameters != R.Quality.NumberOfParameters)
882  return L.Quality.NumberOfParameters < R.Quality.NumberOfParameters;
883  if (L.Quality.NumberOfOptionalParameters !=
884  R.Quality.NumberOfOptionalParameters)
885  return L.Quality.NumberOfOptionalParameters <
886  R.Quality.NumberOfOptionalParameters;
887  if (L.Quality.Kind != R.Quality.Kind) {
888  using OC = CodeCompleteConsumer::OverloadCandidate;
889  switch (L.Quality.Kind) {
890  case OC::CK_Function:
891  return true;
892  case OC::CK_FunctionType:
893  return R.Quality.Kind != OC::CK_Function;
894  case OC::CK_FunctionTemplate:
895  return false;
896  }
897  llvm_unreachable("Unknown overload candidate type.");
898  }
899  if (L.Signature.label.size() != R.Signature.label.size())
900  return L.Signature.label.size() < R.Signature.label.size();
901  return L.Signature.label < R.Signature.label;
902  });
903 
904  for (auto &SS : ScoredSignatures) {
905  auto IndexDocIt =
906  SS.IDForDoc ? FetchedDocs.find(*SS.IDForDoc) : FetchedDocs.end();
907  if (IndexDocIt != FetchedDocs.end())
908  SS.Signature.documentation = IndexDocIt->second;
909 
910  SigHelp.signatures.push_back(std::move(SS.Signature));
911  }
912  }
913 
914  GlobalCodeCompletionAllocator &getAllocator() override { return *Allocator; }
915 
916  CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo; }
917 
918 private:
919  // FIXME(ioeric): consider moving CodeCompletionString logic here to
920  // CompletionString.h.
921  ScoredSignature processOverloadCandidate(const OverloadCandidate &Candidate,
922  const CodeCompletionString &CCS,
923  StringRef DocComment) const {
924  SignatureInformation Signature;
925  SignatureQualitySignals Signal;
926  const char *ReturnType = nullptr;
927 
928  Signature.documentation = formatDocumentation(CCS, DocComment);
929  Signal.Kind = Candidate.getKind();
930 
931  for (const auto &Chunk : CCS) {
932  switch (Chunk.Kind) {
933  case CodeCompletionString::CK_ResultType:
934  // A piece of text that describes the type of an entity or,
935  // for functions and methods, the return type.
936  assert(!ReturnType && "Unexpected CK_ResultType");
937  ReturnType = Chunk.Text;
938  break;
939  case CodeCompletionString::CK_Placeholder:
940  // A string that acts as a placeholder for, e.g., a function call
941  // argument.
942  // Intentional fallthrough here.
943  case CodeCompletionString::CK_CurrentParameter: {
944  // A piece of text that describes the parameter that corresponds to
945  // the code-completion location within a function call, message send,
946  // macro invocation, etc.
947  Signature.label += Chunk.Text;
948  ParameterInformation Info;
949  Info.label = Chunk.Text;
950  Signature.parameters.push_back(std::move(Info));
951  Signal.NumberOfParameters++;
952  Signal.ContainsActiveParameter = true;
953  break;
954  }
955  case CodeCompletionString::CK_Optional: {
956  // The rest of the parameters are defaulted/optional.
957  assert(Chunk.Optional &&
958  "Expected the optional code completion string to be non-null.");
959  Signature.label += getOptionalParameters(*Chunk.Optional,
960  Signature.parameters, Signal);
961  break;
962  }
963  case CodeCompletionString::CK_VerticalSpace:
964  break;
965  default:
966  Signature.label += Chunk.Text;
967  break;
968  }
969  }
970  if (ReturnType) {
971  Signature.label += " -> ";
972  Signature.label += ReturnType;
973  }
974  dlog("Signal for {0}: {1}", Signature, Signal);
975  ScoredSignature Result;
976  Result.Signature = std::move(Signature);
977  Result.Quality = Signal;
978  Result.IDForDoc =
979  Result.Signature.documentation.empty() && Candidate.getFunction()
980  ? clangd::getSymbolID(Candidate.getFunction())
981  : None;
982  return Result;
983  }
984 
985  SignatureHelp &SigHelp;
986  std::shared_ptr<clang::GlobalCodeCompletionAllocator> Allocator;
987  CodeCompletionTUInfo CCTUInfo;
988  const SymbolIndex *Index;
989 }; // SignatureHelpCollector
990 
991 struct SemaCompleteInput {
993  const tooling::CompileCommand &Command;
994  const PreambleData *Preamble;
995  StringRef Contents;
996  Position Pos;
997  IntrusiveRefCntPtr<vfs::FileSystem> VFS;
998  std::shared_ptr<PCHContainerOperations> PCHs;
999 };
1000 
1001 // Invokes Sema code completion on a file.
1002 // If \p Includes is set, it will be updated based on the compiler invocation.
1003 bool semaCodeComplete(std::unique_ptr<CodeCompleteConsumer> Consumer,
1004  const clang::CodeCompleteOptions &Options,
1005  const SemaCompleteInput &Input,
1006  IncludeStructure *Includes = nullptr) {
1007  trace::Span Tracer("Sema completion");
1008  std::vector<const char *> ArgStrs;
1009  for (const auto &S : Input.Command.CommandLine)
1010  ArgStrs.push_back(S.c_str());
1011 
1012  if (Input.VFS->setCurrentWorkingDirectory(Input.Command.Directory)) {
1013  log("Couldn't set working directory");
1014  // We run parsing anyway, our lit-tests rely on results for non-existing
1015  // working dirs.
1016  }
1017 
1018  IntrusiveRefCntPtr<vfs::FileSystem> VFS = Input.VFS;
1019  if (Input.Preamble && Input.Preamble->StatCache)
1020  VFS = Input.Preamble->StatCache->getConsumingFS(std::move(VFS));
1021  IgnoreDiagnostics DummyDiagsConsumer;
1022  auto CI = createInvocationFromCommandLine(
1023  ArgStrs,
1024  CompilerInstance::createDiagnostics(new DiagnosticOptions,
1025  &DummyDiagsConsumer, false),
1026  VFS);
1027  if (!CI) {
1028  elog("Couldn't create CompilerInvocation");
1029  return false;
1030  }
1031  auto &FrontendOpts = CI->getFrontendOpts();
1032  FrontendOpts.DisableFree = false;
1033  FrontendOpts.SkipFunctionBodies = true;
1034  CI->getLangOpts()->CommentOpts.ParseAllComments = true;
1035  // Disable typo correction in Sema.
1036  CI->getLangOpts()->SpellChecking = false;
1037  // Setup code completion.
1038  FrontendOpts.CodeCompleteOpts = Options;
1039  FrontendOpts.CodeCompletionAt.FileName = Input.FileName;
1040  auto Offset = positionToOffset(Input.Contents, Input.Pos);
1041  if (!Offset) {
1042  elog("Code completion position was invalid {0}", Offset.takeError());
1043  return false;
1044  }
1045  std::tie(FrontendOpts.CodeCompletionAt.Line,
1046  FrontendOpts.CodeCompletionAt.Column) =
1047  offsetToClangLineColumn(Input.Contents, *Offset);
1048 
1049  std::unique_ptr<MemoryBuffer> ContentsBuffer =
1050  MemoryBuffer::getMemBufferCopy(Input.Contents, Input.FileName);
1051  // The diagnostic options must be set before creating a CompilerInstance.
1052  CI->getDiagnosticOpts().IgnoreWarnings = true;
1053  // We reuse the preamble whether it's valid or not. This is a
1054  // correctness/performance tradeoff: building without a preamble is slow, and
1055  // completion is latency-sensitive.
1056  // However, if we're completing *inside* the preamble section of the draft,
1057  // overriding the preamble will break sema completion. Fortunately we can just
1058  // skip all includes in this case; these completions are really simple.
1059  bool CompletingInPreamble =
1060  ComputePreambleBounds(*CI->getLangOpts(), ContentsBuffer.get(), 0).Size >
1061  *Offset;
1062  // NOTE: we must call BeginSourceFile after prepareCompilerInstance. Otherwise
1063  // the remapped buffers do not get freed.
1064  auto Clang = prepareCompilerInstance(
1065  std::move(CI),
1066  (Input.Preamble && !CompletingInPreamble) ? &Input.Preamble->Preamble
1067  : nullptr,
1068  std::move(ContentsBuffer), std::move(Input.PCHs), std::move(VFS),
1069  DummyDiagsConsumer);
1070  Clang->getPreprocessorOpts().SingleFileParseMode = CompletingInPreamble;
1071  Clang->setCodeCompletionConsumer(Consumer.release());
1072 
1074  if (!Action.BeginSourceFile(*Clang, Clang->getFrontendOpts().Inputs[0])) {
1075  log("BeginSourceFile() failed when running codeComplete for {0}",
1076  Input.FileName);
1077  return false;
1078  }
1079  if (Includes)
1080  Clang->getPreprocessor().addPPCallbacks(
1081  collectIncludeStructureCallback(Clang->getSourceManager(), Includes));
1082  if (!Action.Execute()) {
1083  log("Execute() failed when running codeComplete for {0}", Input.FileName);
1084  return false;
1085  }
1086  Action.EndSourceFile();
1087 
1088  return true;
1089 }
1090 
1091 // Should we allow index completions in the specified context?
1092 bool allowIndex(CodeCompletionContext &CC) {
1093  if (!contextAllowsIndex(CC.getKind()))
1094  return false;
1095  // We also avoid ClassName::bar (but allow namespace::bar).
1096  auto Scope = CC.getCXXScopeSpecifier();
1097  if (!Scope)
1098  return true;
1099  NestedNameSpecifier *NameSpec = (*Scope)->getScopeRep();
1100  if (!NameSpec)
1101  return true;
1102  // We only query the index when qualifier is a namespace.
1103  // If it's a class, we rely solely on sema completions.
1104  switch (NameSpec->getKind()) {
1105  case NestedNameSpecifier::Global:
1106  case NestedNameSpecifier::Namespace:
1107  case NestedNameSpecifier::NamespaceAlias:
1108  return true;
1109  case NestedNameSpecifier::Super:
1110  case NestedNameSpecifier::TypeSpec:
1111  case NestedNameSpecifier::TypeSpecWithTemplate:
1112  // Unresolved inside a template.
1113  case NestedNameSpecifier::Identifier:
1114  return false;
1115  }
1116  llvm_unreachable("invalid NestedNameSpecifier kind");
1117 }
1118 
1119 std::future<SymbolSlab> startAsyncFuzzyFind(const SymbolIndex &Index,
1120  const FuzzyFindRequest &Req) {
1121  return runAsync<SymbolSlab>([&Index, Req]() {
1122  trace::Span Tracer("Async fuzzyFind");
1123  SymbolSlab::Builder Syms;
1124  Index.fuzzyFind(Req, [&Syms](const Symbol &Sym) { Syms.insert(Sym); });
1125  return std::move(Syms).build();
1126  });
1127 }
1128 
1129 // Creates a `FuzzyFindRequest` based on the cached index request from the
1130 // last completion, if any, and the speculated completion filter text in the
1131 // source code.
1132 Optional<FuzzyFindRequest> speculativeFuzzyFindRequestForCompletion(
1133  FuzzyFindRequest CachedReq, PathRef File, StringRef Content, Position Pos) {
1134  auto Filter = speculateCompletionFilter(Content, Pos);
1135  if (!Filter) {
1136  elog("Failed to speculate filter text for code completion at Pos "
1137  "{0}:{1}: {2}",
1138  Pos.line, Pos.character, Filter.takeError());
1139  return None;
1140  }
1141  CachedReq.Query = *Filter;
1142  return CachedReq;
1143 }
1144 
1145 } // namespace
1146 
1147 clang::CodeCompleteOptions CodeCompleteOptions::getClangCompleteOpts() const {
1148  clang::CodeCompleteOptions Result;
1149  Result.IncludeCodePatterns = EnableSnippets && IncludeCodePatterns;
1150  Result.IncludeMacros = IncludeMacros;
1151  Result.IncludeGlobals = true;
1152  // We choose to include full comments and not do doxygen parsing in
1153  // completion.
1154  // FIXME: ideally, we should support doxygen in some form, e.g. do markdown
1155  // formatting of the comments.
1156  Result.IncludeBriefComments = false;
1157 
1158  // When an is used, Sema is responsible for completing the main file,
1159  // the index can provide results from the preamble.
1160  // Tell Sema not to deserialize the preamble to look for results.
1161  Result.LoadExternal = !Index;
1162  Result.IncludeFixIts = IncludeFixIts;
1163 
1164  return Result;
1165 }
1166 
1167 // Returns the most popular include header for \p Sym. If two headers are
1168 // equally popular, prefer the shorter one. Returns empty string if \p Sym has
1169 // no include header.
1170 SmallVector<StringRef, 1> getRankedIncludes(const Symbol &Sym) {
1171  auto Includes = Sym.IncludeHeaders;
1172  // Sort in descending order by reference count and header length.
1173  llvm::sort(Includes, [](const Symbol::IncludeHeaderWithReferences &LHS,
1175  if (LHS.References == RHS.References)
1176  return LHS.IncludeHeader.size() < RHS.IncludeHeader.size();
1177  return LHS.References > RHS.References;
1178  });
1179  SmallVector<StringRef, 1> Headers;
1180  for (const auto &Include : Includes)
1181  Headers.push_back(Include.IncludeHeader);
1182  return Headers;
1183 }
1184 
1185 // Runs Sema-based (AST) and Index-based completion, returns merged results.
1186 //
1187 // There are a few tricky considerations:
1188 // - the AST provides information needed for the index query (e.g. which
1189 // namespaces to search in). So Sema must start first.
1190 // - we only want to return the top results (Opts.Limit).
1191 // Building CompletionItems for everything else is wasteful, so we want to
1192 // preserve the "native" format until we're done with scoring.
1193 // - the data underlying Sema completion items is owned by the AST and various
1194 // other arenas, which must stay alive for us to build CompletionItems.
1195 // - we may get duplicate results from Sema and the Index, we need to merge.
1196 //
1197 // So we start Sema completion first, and do all our work in its callback.
1198 // We use the Sema context information to query the index.
1199 // Then we merge the two result sets, producing items that are Sema/Index/Both.
1200 // These items are scored, and the top N are synthesized into the LSP response.
1201 // Finally, we can clean up the data structures created by Sema completion.
1202 //
1203 // Main collaborators are:
1204 // - semaCodeComplete sets up the compiler machinery to run code completion.
1205 // - CompletionRecorder captures Sema completion results, including context.
1206 // - SymbolIndex (Opts.Index) provides index completion results as Symbols
1207 // - CompletionCandidates are the result of merging Sema and Index results.
1208 // Each candidate points to an underlying CodeCompletionResult (Sema), a
1209 // Symbol (Index), or both. It computes the result quality score.
1210 // CompletionCandidate also does conversion to CompletionItem (at the end).
1211 // - FuzzyMatcher scores how the candidate matches the partial identifier.
1212 // This score is combined with the result quality score for the final score.
1213 // - TopN determines the results with the best score.
1215  PathRef FileName;
1216  IncludeStructure Includes; // Complete once the compiler runs.
1217  SpeculativeFuzzyFind *SpecFuzzyFind; // Can be nullptr.
1218  const CodeCompleteOptions &Opts;
1219 
1220  // Sema takes ownership of Recorder. Recorder is valid until Sema cleanup.
1221  CompletionRecorder *Recorder = nullptr;
1222  int NSema = 0, NIndex = 0, NBoth = 0; // Counters for logging.
1223  bool Incomplete = false; // Would more be available with a higher limit?
1224  Optional<FuzzyMatcher> Filter; // Initialized once Sema runs.
1225  std::vector<std::string> QueryScopes; // Initialized once Sema runs.
1226  // Initialized once QueryScopes is initialized, if there are scopes.
1227  Optional<ScopeDistance> ScopeProximity;
1228  // Whether to query symbols from any scope. Initialized once Sema runs.
1229  bool AllScopes = false;
1230  // Include-insertion and proximity scoring rely on the include structure.
1231  // This is available after Sema has run.
1232  Optional<IncludeInserter> Inserter; // Available during runWithSema.
1233  Optional<URIDistance> FileProximity; // Initialized once Sema runs.
1234  /// Speculative request based on the cached request and the filter text before
1235  /// the cursor.
1236  /// Initialized right before sema run. This is only set if `SpecFuzzyFind` is
1237  /// set and contains a cached request.
1238  Optional<FuzzyFindRequest> SpecReq;
1239 
1240 public:
1241  // A CodeCompleteFlow object is only useful for calling run() exactly once.
1242  CodeCompleteFlow(PathRef FileName, const IncludeStructure &Includes,
1243  SpeculativeFuzzyFind *SpecFuzzyFind,
1244  const CodeCompleteOptions &Opts)
1245  : FileName(FileName), Includes(Includes), SpecFuzzyFind(SpecFuzzyFind),
1246  Opts(Opts) {}
1247 
1248  CodeCompleteResult run(const SemaCompleteInput &SemaCCInput) && {
1249  trace::Span Tracer("CodeCompleteFlow");
1250  if (Opts.Index && SpecFuzzyFind && SpecFuzzyFind->CachedReq.hasValue()) {
1251  assert(!SpecFuzzyFind->Result.valid());
1252  if ((SpecReq = speculativeFuzzyFindRequestForCompletion(
1253  *SpecFuzzyFind->CachedReq, SemaCCInput.FileName,
1254  SemaCCInput.Contents, SemaCCInput.Pos)))
1255  SpecFuzzyFind->Result = startAsyncFuzzyFind(*Opts.Index, *SpecReq);
1256  }
1257 
1258  // We run Sema code completion first. It builds an AST and calculates:
1259  // - completion results based on the AST.
1260  // - partial identifier and context. We need these for the index query.
1261  CodeCompleteResult Output;
1262  auto RecorderOwner = llvm::make_unique<CompletionRecorder>(Opts, [&]() {
1263  assert(Recorder && "Recorder is not set");
1264  auto Style =
1265  format::getStyle(format::DefaultFormatStyle, SemaCCInput.FileName,
1266  format::DefaultFallbackStyle, SemaCCInput.Contents,
1267  SemaCCInput.VFS.get());
1268  if (!Style) {
1269  log("getStyle() failed for file {0}: {1}. Fallback is LLVM style.",
1270  SemaCCInput.FileName, Style.takeError());
1271  Style = format::getLLVMStyle();
1272  }
1273  // If preprocessor was run, inclusions from preprocessor callback should
1274  // already be added to Includes.
1275  Inserter.emplace(
1276  SemaCCInput.FileName, SemaCCInput.Contents, *Style,
1277  SemaCCInput.Command.Directory,
1278  Recorder->CCSema->getPreprocessor().getHeaderSearchInfo());
1279  for (const auto &Inc : Includes.MainFileIncludes)
1280  Inserter->addExisting(Inc);
1281 
1282  // Most of the cost of file proximity is in initializing the FileDistance
1283  // structures based on the observed includes, once per query. Conceptually
1284  // that happens here (though the per-URI-scheme initialization is lazy).
1285  // The per-result proximity scoring is (amortized) very cheap.
1286  FileDistanceOptions ProxOpts{}; // Use defaults.
1287  const auto &SM = Recorder->CCSema->getSourceManager();
1288  StringMap<SourceParams> ProxSources;
1289  for (auto &Entry : Includes.includeDepth(
1290  SM.getFileEntryForID(SM.getMainFileID())->getName())) {
1291  auto &Source = ProxSources[Entry.getKey()];
1292  Source.Cost = Entry.getValue() * ProxOpts.IncludeCost;
1293  // Symbols near our transitive includes are good, but only consider
1294  // things in the same directory or below it. Otherwise there can be
1295  // many false positives.
1296  if (Entry.getValue() > 0)
1297  Source.MaxUpTraversals = 1;
1298  }
1299  FileProximity.emplace(ProxSources, ProxOpts);
1300 
1301  Output = runWithSema();
1302  Inserter.reset(); // Make sure this doesn't out-live Clang.
1303  SPAN_ATTACH(Tracer, "sema_completion_kind",
1304  getCompletionKindString(Recorder->CCContext.getKind()));
1305  log("Code complete: sema context {0}, query scopes [{1}] (AnyScope={2})",
1306  getCompletionKindString(Recorder->CCContext.getKind()),
1307  join(QueryScopes.begin(), QueryScopes.end(), ","), AllScopes);
1308  });
1309 
1310  Recorder = RecorderOwner.get();
1311 
1312  semaCodeComplete(std::move(RecorderOwner), Opts.getClangCompleteOpts(),
1313  SemaCCInput, &Includes);
1314 
1315  SPAN_ATTACH(Tracer, "sema_results", NSema);
1316  SPAN_ATTACH(Tracer, "index_results", NIndex);
1317  SPAN_ATTACH(Tracer, "merged_results", NBoth);
1318  SPAN_ATTACH(Tracer, "returned_results", int64_t(Output.Completions.size()));
1319  SPAN_ATTACH(Tracer, "incomplete", Output.HasMore);
1320  log("Code complete: {0} results from Sema, {1} from Index, "
1321  "{2} matched, {3} returned{4}.",
1322  NSema, NIndex, NBoth, Output.Completions.size(),
1323  Output.HasMore ? " (incomplete)" : "");
1324  assert(!Opts.Limit || Output.Completions.size() <= Opts.Limit);
1325  // We don't assert that isIncomplete means we hit a limit.
1326  // Indexes may choose to impose their own limits even if we don't have one.
1327  return Output;
1328  }
1329 
1330 private:
1331  // This is called by run() once Sema code completion is done, but before the
1332  // Sema data structures are torn down. It does all the real work.
1333  CodeCompleteResult runWithSema() {
1334  const auto &CodeCompletionRange = CharSourceRange::getCharRange(
1335  Recorder->CCSema->getPreprocessor().getCodeCompletionTokenRange());
1336  Range TextEditRange;
1337  // When we are getting completions with an empty identifier, for example
1338  // std::vector<int> asdf;
1339  // asdf.^;
1340  // Then the range will be invalid and we will be doing insertion, use
1341  // current cursor position in such cases as range.
1342  if (CodeCompletionRange.isValid()) {
1343  TextEditRange = halfOpenToRange(Recorder->CCSema->getSourceManager(),
1344  CodeCompletionRange);
1345  } else {
1346  const auto &Pos = sourceLocToPosition(
1347  Recorder->CCSema->getSourceManager(),
1348  Recorder->CCSema->getPreprocessor().getCodeCompletionLoc());
1349  TextEditRange.start = TextEditRange.end = Pos;
1350  }
1351  Filter = FuzzyMatcher(
1352  Recorder->CCSema->getPreprocessor().getCodeCompletionFilter());
1353  std::tie(QueryScopes, AllScopes) =
1354  getQueryScopes(Recorder->CCContext, *Recorder->CCSema, Opts);
1355  if (!QueryScopes.empty())
1356  ScopeProximity.emplace(QueryScopes);
1357  // Sema provides the needed context to query the index.
1358  // FIXME: in addition to querying for extra/overlapping symbols, we should
1359  // explicitly request symbols corresponding to Sema results.
1360  // We can use their signals even if the index can't suggest them.
1361  // We must copy index results to preserve them, but there are at most Limit.
1362  auto IndexResults = (Opts.Index && allowIndex(Recorder->CCContext))
1363  ? queryIndex()
1364  : SymbolSlab();
1365  trace::Span Tracer("Populate CodeCompleteResult");
1366  // Merge Sema and Index results, score them, and pick the winners.
1367  auto Top = mergeResults(Recorder->Results, IndexResults);
1368  CodeCompleteResult Output;
1369 
1370  // Convert the results to final form, assembling the expensive strings.
1371  for (auto &C : Top) {
1372  Output.Completions.push_back(toCodeCompletion(C.first));
1373  Output.Completions.back().Score = C.second;
1374  Output.Completions.back().CompletionTokenRange = TextEditRange;
1375  }
1376  Output.HasMore = Incomplete;
1377  Output.Context = Recorder->CCContext.getKind();
1378 
1379  return Output;
1380  }
1381 
1382  SymbolSlab queryIndex() {
1383  trace::Span Tracer("Query index");
1384  SPAN_ATTACH(Tracer, "limit", int64_t(Opts.Limit));
1385 
1386  // Build the query.
1387  FuzzyFindRequest Req;
1388  if (Opts.Limit)
1389  Req.Limit = Opts.Limit;
1390  Req.Query = Filter->pattern();
1391  Req.RestrictForCodeCompletion = true;
1392  Req.Scopes = QueryScopes;
1393  Req.AnyScope = AllScopes;
1394  // FIXME: we should send multiple weighted paths here.
1395  Req.ProximityPaths.push_back(FileName);
1396  vlog("Code complete: fuzzyFind({0:2})", toJSON(Req));
1397 
1398  if (SpecFuzzyFind)
1399  SpecFuzzyFind->NewReq = Req;
1400  if (SpecFuzzyFind && SpecFuzzyFind->Result.valid() && (*SpecReq == Req)) {
1401  vlog("Code complete: speculative fuzzy request matches the actual index "
1402  "request. Waiting for the speculative index results.");
1403  SPAN_ATTACH(Tracer, "Speculative results", true);
1404 
1405  trace::Span WaitSpec("Wait speculative results");
1406  return SpecFuzzyFind->Result.get();
1407  }
1408 
1409  SPAN_ATTACH(Tracer, "Speculative results", false);
1410 
1411  // Run the query against the index.
1412  SymbolSlab::Builder ResultsBuilder;
1413  if (Opts.Index->fuzzyFind(
1414  Req, [&](const Symbol &Sym) { ResultsBuilder.insert(Sym); }))
1415  Incomplete = true;
1416  return std::move(ResultsBuilder).build();
1417  }
1418 
1419  // Merges Sema and Index results where possible, to form CompletionCandidates.
1420  // Groups overloads if desired, to form CompletionCandidate::Bundles. The
1421  // bundles are scored and top results are returned, best to worst.
1422  std::vector<ScoredBundle>
1423  mergeResults(const std::vector<CodeCompletionResult> &SemaResults,
1424  const SymbolSlab &IndexResults) {
1425  trace::Span Tracer("Merge and score results");
1426  std::vector<CompletionCandidate::Bundle> Bundles;
1427  DenseMap<size_t, size_t> BundleLookup;
1428  auto AddToBundles = [&](const CodeCompletionResult *SemaResult,
1429  const Symbol *IndexResult) {
1430  CompletionCandidate C;
1431  C.SemaResult = SemaResult;
1432  C.IndexResult = IndexResult;
1433  if (C.IndexResult)
1434  C.RankedIncludeHeaders = getRankedIncludes(*C.IndexResult);
1435  C.Name = IndexResult ? IndexResult->Name : Recorder->getName(*SemaResult);
1436  if (auto OverloadSet = Opts.BundleOverloads ? C.overloadSet() : 0) {
1437  auto Ret = BundleLookup.try_emplace(OverloadSet, Bundles.size());
1438  if (Ret.second)
1439  Bundles.emplace_back();
1440  Bundles[Ret.first->second].push_back(std::move(C));
1441  } else {
1442  Bundles.emplace_back();
1443  Bundles.back().push_back(std::move(C));
1444  }
1445  };
1446  DenseSet<const Symbol *> UsedIndexResults;
1447  auto CorrespondingIndexResult =
1448  [&](const CodeCompletionResult &SemaResult) -> const Symbol * {
1449  if (auto SymID =
1450  getSymbolID(SemaResult, Recorder->CCSema->getSourceManager())) {
1451  auto I = IndexResults.find(*SymID);
1452  if (I != IndexResults.end()) {
1453  UsedIndexResults.insert(&*I);
1454  return &*I;
1455  }
1456  }
1457  return nullptr;
1458  };
1459  // Emit all Sema results, merging them with Index results if possible.
1460  for (auto &SemaResult : Recorder->Results)
1461  AddToBundles(&SemaResult, CorrespondingIndexResult(SemaResult));
1462  // Now emit any Index-only results.
1463  for (const auto &IndexResult : IndexResults) {
1464  if (UsedIndexResults.count(&IndexResult))
1465  continue;
1466  AddToBundles(/*SemaResult=*/nullptr, &IndexResult);
1467  }
1468  // We only keep the best N results at any time, in "native" format.
1470  Opts.Limit == 0 ? std::numeric_limits<size_t>::max() : Opts.Limit);
1471  for (auto &Bundle : Bundles)
1472  addCandidate(Top, std::move(Bundle));
1473  return std::move(Top).items();
1474  }
1475 
1476  Optional<float> fuzzyScore(const CompletionCandidate &C) {
1477  // Macros can be very spammy, so we only support prefix completion.
1478  // We won't end up with underfull index results, as macros are sema-only.
1479  if (C.SemaResult && C.SemaResult->Kind == CodeCompletionResult::RK_Macro &&
1480  !C.Name.startswith_lower(Filter->pattern()))
1481  return None;
1482  return Filter->match(C.Name);
1483  }
1484 
1485  // Scores a candidate and adds it to the TopN structure.
1486  void addCandidate(TopN<ScoredBundle, ScoredBundleGreater> &Candidates,
1487  CompletionCandidate::Bundle Bundle) {
1489  SymbolRelevanceSignals Relevance;
1490  Relevance.Context = Recorder->CCContext.getKind();
1491  Relevance.Query = SymbolRelevanceSignals::CodeComplete;
1492  Relevance.FileProximityMatch = FileProximity.getPointer();
1493  if (ScopeProximity)
1494  Relevance.ScopeProximityMatch = ScopeProximity.getPointer();
1495 
1496  auto &First = Bundle.front();
1497  if (auto FuzzyScore = fuzzyScore(First))
1498  Relevance.NameMatch = *FuzzyScore;
1499  else
1500  return;
1502  bool FromIndex = false;
1503  for (const auto &Candidate : Bundle) {
1504  if (Candidate.IndexResult) {
1505  Quality.merge(*Candidate.IndexResult);
1506  Relevance.merge(*Candidate.IndexResult);
1507  Origin |= Candidate.IndexResult->Origin;
1508  FromIndex = true;
1509  }
1510  if (Candidate.SemaResult) {
1511  Quality.merge(*Candidate.SemaResult);
1512  Relevance.merge(*Candidate.SemaResult);
1513  Origin |= SymbolOrigin::AST;
1514  }
1515  }
1516 
1517  CodeCompletion::Scores Scores;
1518  Scores.Quality = Quality.evaluate();
1519  Scores.Relevance = Relevance.evaluate();
1520  Scores.Total = evaluateSymbolAndRelevance(Scores.Quality, Scores.Relevance);
1521  // NameMatch is in fact a multiplier on total score, so rescoring is sound.
1522  Scores.ExcludingName = Relevance.NameMatch
1523  ? Scores.Total / Relevance.NameMatch
1524  : Scores.Quality;
1525 
1526  dlog("CodeComplete: {0} ({1}) = {2}\n{3}{4}\n", First.Name,
1527  to_string(Origin), Scores.Total, to_string(Quality),
1528  to_string(Relevance));
1529 
1530  NSema += bool(Origin & SymbolOrigin::AST);
1531  NIndex += FromIndex;
1532  NBoth += bool(Origin & SymbolOrigin::AST) && FromIndex;
1533  if (Candidates.push({std::move(Bundle), Scores}))
1534  Incomplete = true;
1535  }
1536 
1537  CodeCompletion toCodeCompletion(const CompletionCandidate::Bundle &Bundle) {
1538  Optional<CodeCompletionBuilder> Builder;
1539  for (const auto &Item : Bundle) {
1540  CodeCompletionString *SemaCCS =
1541  Item.SemaResult ? Recorder->codeCompletionString(*Item.SemaResult)
1542  : nullptr;
1543  if (!Builder)
1544  Builder.emplace(Recorder->CCSema->getASTContext(), Item, SemaCCS,
1545  QueryScopes, *Inserter, FileName,
1546  Recorder->CCContext.getKind(), Opts);
1547  else
1548  Builder->add(Item, SemaCCS);
1549  }
1550  return Builder->build();
1551  }
1552 };
1553 
1554 Expected<StringRef> speculateCompletionFilter(StringRef Content, Position Pos) {
1555  auto Offset = positionToOffset(Content, Pos);
1556  if (!Offset)
1557  return make_error<StringError>(
1558  "Failed to convert position to offset in content.",
1559  inconvertibleErrorCode());
1560  if (*Offset == 0)
1561  return "";
1562 
1563  // Start from the character before the cursor.
1564  int St = *Offset - 1;
1565  // FIXME(ioeric): consider UTF characters?
1566  auto IsValidIdentifierChar = [](char c) {
1567  return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
1568  (c >= '0' && c <= '9') || (c == '_'));
1569  };
1570  size_t Len = 0;
1571  for (; (St >= 0) && IsValidIdentifierChar(Content[St]); --St, ++Len) {
1572  }
1573  if (Len > 0)
1574  St++; // Shift to the first valid character.
1575  return Content.substr(St, Len);
1576 }
1577 
1579 codeComplete(PathRef FileName, const tooling::CompileCommand &Command,
1580  const PreambleData *Preamble, StringRef Contents, Position Pos,
1581  IntrusiveRefCntPtr<vfs::FileSystem> VFS,
1582  std::shared_ptr<PCHContainerOperations> PCHs,
1583  CodeCompleteOptions Opts, SpeculativeFuzzyFind *SpecFuzzyFind) {
1584  return CodeCompleteFlow(FileName,
1585  Preamble ? Preamble->Includes : IncludeStructure(),
1586  SpecFuzzyFind, Opts)
1587  .run({FileName, Command, Preamble, Contents, Pos, VFS, PCHs});
1588 }
1589 
1591  const tooling::CompileCommand &Command,
1592  const PreambleData *Preamble, StringRef Contents,
1593  Position Pos,
1594  IntrusiveRefCntPtr<vfs::FileSystem> VFS,
1595  std::shared_ptr<PCHContainerOperations> PCHs,
1596  const SymbolIndex *Index) {
1598  clang::CodeCompleteOptions Options;
1599  Options.IncludeGlobals = false;
1600  Options.IncludeMacros = false;
1601  Options.IncludeCodePatterns = false;
1602  Options.IncludeBriefComments = false;
1603  IncludeStructure PreambleInclusions; // Unused for signatureHelp
1604  semaCodeComplete(
1605  llvm::make_unique<SignatureHelpCollector>(Options, Index, Result),
1606  Options,
1607  {FileName, Command, Preamble, Contents, Pos, std::move(VFS),
1608  std::move(PCHs)});
1609  return Result;
1610 }
1611 
1612 bool isIndexedForCodeCompletion(const NamedDecl &ND, ASTContext &ASTCtx) {
1613  using namespace clang::ast_matchers;
1614  auto InTopLevelScope = hasDeclContext(
1615  anyOf(namespaceDecl(), translationUnitDecl(), linkageSpecDecl()));
1616  return !match(decl(anyOf(InTopLevelScope,
1617  hasDeclContext(
1618  enumDecl(InTopLevelScope, unless(isScoped()))))),
1619  ND, ASTCtx)
1620  .empty();
1621 }
1622 
1623 CompletionItem CodeCompletion::render(const CodeCompleteOptions &Opts) const {
1624  CompletionItem LSP;
1625  const auto *InsertInclude = Includes.empty() ? nullptr : &Includes[0];
1626  LSP.label = ((InsertInclude && InsertInclude->Insertion)
1627  ? Opts.IncludeIndicator.Insert
1628  : Opts.IncludeIndicator.NoInsert) +
1629  (Opts.ShowOrigins ? "[" + to_string(Origin) + "]" : "") +
1630  RequiredQualifier + Name + Signature;
1631 
1632  LSP.kind = Kind;
1633  LSP.detail =
1634  BundleSize > 1 ? formatv("[{0} overloads]", BundleSize) : ReturnType;
1635  LSP.deprecated = Deprecated;
1636  if (InsertInclude)
1637  LSP.detail += "\n" + InsertInclude->Header;
1638  LSP.documentation = Documentation;
1639  LSP.sortText = sortText(Score.Total, Name);
1640  LSP.filterText = Name;
1641  LSP.textEdit = {CompletionTokenRange, RequiredQualifier + Name};
1642  // Merge continuous additionalTextEdits into main edit. The main motivation
1643  // behind this is to help LSP clients, it seems most of them are confused when
1644  // they are provided with additionalTextEdits that are consecutive to main
1645  // edit.
1646  // Note that we store additional text edits from back to front in a line. That
1647  // is mainly to help LSP clients again, so that changes do not effect each
1648  // other.
1649  for (const auto &FixIt : FixIts) {
1650  if (IsRangeConsecutive(FixIt.range, LSP.textEdit->range)) {
1651  LSP.textEdit->newText = FixIt.newText + LSP.textEdit->newText;
1652  LSP.textEdit->range.start = FixIt.range.start;
1653  } else {
1654  LSP.additionalTextEdits.push_back(FixIt);
1655  }
1656  }
1657  if (Opts.EnableSnippets)
1658  LSP.textEdit->newText += SnippetSuffix;
1659 
1660  // FIXME(kadircet): Do not even fill insertText after making sure textEdit is
1661  // compatible with most of the editors.
1662  LSP.insertText = LSP.textEdit->newText;
1663  LSP.insertTextFormat = Opts.EnableSnippets ? InsertTextFormat::Snippet
1664  : InsertTextFormat::PlainText;
1665  if (InsertInclude && InsertInclude->Insertion)
1666  LSP.additionalTextEdits.push_back(*InsertInclude->Insertion);
1667 
1668  return LSP;
1669 }
1670 
1671 raw_ostream &operator<<(raw_ostream &OS, const CodeCompletion &C) {
1672  // For now just lean on CompletionItem.
1673  return OS << C.render(CodeCompleteOptions());
1674 }
1675 
1676 raw_ostream &operator<<(raw_ostream &OS, const CodeCompleteResult &R) {
1677  OS << "CodeCompleteResult: " << R.Completions.size() << (R.HasMore ? "+" : "")
1678  << " (" << getCompletionKindString(R.Context) << ")"
1679  << " items:\n";
1680  for (const auto &C : R.Completions)
1681  OS << C << "\n";
1682  return OS;
1683 }
1684 
1685 } // namespace clangd
1686 } // namespace clang
std::string insertText
A string that should be inserted to a document when selecting this completion.
Definition: Protocol.h:762
std::vector< std::string > AccessibleScopes
Sema * CCSema
Expected< StringRef > speculateCompletionFilter(StringRef Content, Position Pos)
std::future< SymbolSlab > Result
The result is consumed by codeComplete() if speculation succeeded.
Definition: CodeComplete.h:214
bool ShowOrigins
Expose origins of completion items in the label (for debugging).
Definition: CodeComplete.h:79
const tooling::CompileCommand & Command
bool BundleOverloads
Combine overloads into a single completion item where possible.
Definition: CodeComplete.h:65
std::pair< size_t, size_t > offsetToClangLineColumn(StringRef Code, size_t Offset)
Definition: SourceCode.cpp:154
size_t Limit
Limit the number of results returned (0 means no limit).
Definition: CodeComplete.h:69
SignatureQualitySignals Quality
json::Value toJSON(const FuzzyFindRequest &Request)
Definition: Index.cpp:219
bool AnyScope
If set to true, allow symbols from any scope.
Definition: Index.h:481
CodeCompletionContext::Kind Context
Definition: CodeComplete.h:198
void merge(const CodeCompletionResult &SemaCCResult)
Definition: Quality.cpp:176
std::string printQualifiedName(const NamedDecl &ND)
Returns the qualified name of ND.
Definition: AST.cpp:49
llvm::Optional< TextEdit > textEdit
An edit which is applied to a document when selecting this completion.
Definition: Protocol.h:773
Some operations such as code completion produce a set of candidates.
SmallVector< StringRef, 1 > RankedIncludeHeaders
Optional< SymbolID > getSymbolID(const Decl *D)
Gets the symbol ID for a declaration, if possible.
Definition: AST.cpp:72
Optional< Expected< tooling::AtomicChanges > > Result
bool RestrictForCodeCompletion
If set to true, only symbols for completion support will be considered.
Definition: Index.h:486
CompletionItemKind kind
The kind of this completion item.
Definition: Protocol.h:743
unsigned References
The number of translation units that reference this symbol and include this header.
Definition: Index.h:262
bool EnableSnippets
When true, completion items will contain expandable code snippets in completion (e.g.
Definition: CodeComplete.h:47
void log(Logger::Level, const llvm::formatv_object_base &)
clang::find_all_symbols::SymbolInfo::SymbolKind SymbolKind
Definition: SymbolInfo.cpp:22
HeaderHandle File
std::string printNamespaceScope(const DeclContext &DC)
Returns the first enclosing namespace scope starting from DC.
Definition: AST.cpp:64
std::vector< CodeCompletion > Completions
Definition: CodeComplete.h:196
Interface for symbol indexes that can be used for searching or matching symbols among a set of symbol...
Definition: Index.h:513
const_iterator find(const SymbolID &SymID) const
Definition: Index.cpp:107
std::pair< StringRef, StringRef > splitQualifiedName(StringRef QName)
Definition: SourceCode.cpp:164
bool IsRangeConsecutive(const Range &Left, const Range &Right)
Definition: SourceCode.cpp:225
void merge(const CodeCompletionResult &SemaResult)
Definition: Quality.cpp:286
Optional< std::string > UnresolvedQualifier
virtual bool fuzzyFind(const FuzzyFindRequest &Req, llvm::function_ref< void(const Symbol &)> Callback) const =0
Matches symbols in the index fuzzily and applies Callback on each matched symbol before returning...
llvm::StringRef PathRef
A typedef to represent a ref to file path.
Definition: Path.h:24
std::vector< CodeCompletionResult > Results
CodeCompletionContext::Kind Context
Definition: Quality.h:120
static cl::opt< bool > EnableFunctionArgSnippets("function-arg-placeholders", cl::desc("When disabled, completions contain only parentheses for " "function calls. When enabled, completions also contain " "placeholders for method parameters."), cl::init(clangd::CodeCompleteOptions().EnableFunctionArgSnippets))
std::string sortText
A string that should be used when comparing this item with other items.
Definition: Protocol.h:754
std::string getDocComment(const ASTContext &Ctx, const CodeCompletionResult &Result, bool CommentsFromHeaders)
Gets a minimally formatted documentation comment of Result, with comment markers stripped.
Attributes of a symbol that affect how much we like it.
Definition: Quality.h:56
StringRef Name
std::string documentation
A human-readable string that represents a doc-comment.
Definition: Protocol.h:750
llvm::StringMap< unsigned > includeDepth(llvm::StringRef Root) const
Definition: Headers.cpp:96
CodeCompleteResult codeComplete(PathRef FileName, const tooling::CompileCommand &Command, const PreambleData *Preamble, StringRef Contents, Position Pos, IntrusiveRefCntPtr< vfs::FileSystem > VFS, std::shared_ptr< PCHContainerOperations > PCHs, CodeCompleteOptions Opts, SpeculativeFuzzyFind *SpecFuzzyFind)
void vlog(const char *Fmt, Ts &&... Vals)
Definition: Logger.h:68
std::vector< TextEdit > additionalTextEdits
An optional array of additional text edits that are applied when selecting this completion.
Definition: Protocol.h:778
void elog(const char *Fmt, Ts &&... Vals)
Definition: Logger.h:57
StringRef Contents
static ClangTidyModuleRegistry::Add< AbseilModule > X("abseil-module", "Add Abseil checks.")
std::vector< std::string > Scopes
If this is non-empty, symbols must be in at least one of the scopes (e.g.
Definition: Index.h:478
CompletionItemKind
The kind of a completion entry.
Definition: Protocol.h:237
std::string getReturnType(const CodeCompletionString &CCS)
Gets detail to be used as the detail field in an LSP completion item.
BindArgumentKind Kind
llvm::Optional< FuzzyFindRequest > CachedReq
A cached request from past code completions.
Definition: CodeComplete.h:208
std::string detail
A human-readable string with additional information about this item, like type or symbol information...
Definition: Protocol.h:747
bool isLiteralInclude(StringRef Include)
Definition: Headers.cpp:64
Optional< SymbolID > IDForDoc
std::string formatDocumentation(const CodeCompletionString &CCS, StringRef DocComment)
TextEdit toTextEdit(const FixItHint &FixIt, const SourceManager &M, const LangOptions &L)
Definition: SourceCode.cpp:216
enum clang::clangd::SymbolRelevanceSignals::QueryType Query
raw_ostream & operator<<(raw_ostream &OS, const CodeCompleteResult &R)
bool isIndexedForCodeCompletion(const NamedDecl &ND, ASTContext &ASTCtx)
llvm::SmallVector< IncludeHeaderWithReferences, 1 > IncludeHeaders
One Symbol can potentially be incuded via different headers.
Definition: Index.h:268
std::string filterText
A string that should be used when filtering a set of completion items.
Definition: Protocol.h:758
CodeCompleteFlow(PathRef FileName, const IncludeStructure &Includes, SpeculativeFuzzyFind *SpecFuzzyFind, const CodeCompleteOptions &Opts)
A speculative and asynchronous fuzzy find index request (based on cached request) that can be sent be...
Definition: CodeComplete.h:205
std::unique_ptr< CompilerInstance > prepareCompilerInstance(std::unique_ptr< clang::CompilerInvocation > CI, const PrecompiledPreamble *Preamble, std::unique_ptr< MemoryBuffer > Buffer, std::shared_ptr< PCHContainerOperations > PCHs, IntrusiveRefCntPtr< vfs::FileSystem > VFS, DiagnosticConsumer &DiagsClient)
Definition: Compiler.cpp:44
bool deprecated
Indicates if this item is deprecated.
Definition: Protocol.h:781
std::string Signature
std::string sortText(float Score, StringRef Name)
Definition: Quality.cpp:436
std::string Query
A query string for the fuzzy find.
Definition: Index.h:471
#define dlog(...)
Definition: Logger.h:73
bool push(value_type &&V)
Definition: Quality.h:146
const Decl * D
Definition: XRefs.cpp:79
llvm::Optional< FuzzyFindRequest > NewReq
The actual request used by codeComplete().
Definition: CodeComplete.h:211
const Symbol * IndexResult
PathRef FileName
std::string ReturnType
std::string SnippetSuffix
Position sourceLocToPosition(const SourceManager &SM, SourceLocation Loc)
Turn a SourceLocation into a [line, column] pair.
Definition: SourceCode.cpp:129
Position Pos
IntrusiveRefCntPtr< vfs::FileSystem > VFS
float evaluateSymbolAndRelevance(float SymbolQuality, float SymbolRelevance)
Combine symbol quality and relevance into a single score.
Definition: Quality.cpp:418
Expected< size_t > positionToOffset(StringRef Code, Position P, bool AllowColumnsBeyondLineLength)
Definition: SourceCode.cpp:82
FunctionInfo Info
const SymbolIndex * Index
If Index is set, it is used to augment the code completion results.
Definition: CodeComplete.h:96
std::string getDeclComment(const ASTContext &Ctx, const NamedDecl &Decl)
Similar to getDocComment, but returns the comment for a NamedDecl.
llvm::StringRef IncludeHeader
This can be either a URI of the header to be #include&#39;d for this symbol, or a literal header quoted w...
Definition: Index.h:259
Represents the signature of a callable.
Definition: Protocol.h:833
void getSignature(const CodeCompletionString &CCS, std::string *Signature, std::string *Snippet, std::string *RequiredQualifiers)
Formats the signature for an item, as a display string and snippet.
std::vector< Inclusion > MainFileIncludes
Definition: Headers.h:59
const PreambleData * Preamble
std::unique_ptr< PPCallbacks > collectIncludeStructureCallback(const SourceManager &SM, IncludeStructure *Out)
Returns a PPCallback that visits all inclusions in the main file.
Definition: Headers.cpp:74
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
std::vector< std::string > ProximityPaths
Contextually relevant files (e.g.
Definition: Index.h:489
std::string label
The label of this completion item.
Definition: Protocol.h:739
CompletionItem render(const CodeCompleteOptions &) const
std::shared_ptr< PCHContainerOperations > PCHs
struct clang::clangd::CodeCompleteOptions::IncludeInsertionIndicator IncludeIndicator
const CodeCompletionResult * SemaResult
llvm::Optional< uint32_t > Limit
The number of top candidates to return.
Definition: Index.h:484
float NameMatch
0-1+ fuzzy-match score for unqualified name. Must be explicitly assigned.
Definition: Quality.h:86
SignatureHelp signatureHelp(PathRef FileName, const tooling::CompileCommand &Command, const PreambleData *Preamble, StringRef Contents, Position Pos, IntrusiveRefCntPtr< vfs::FileSystem > VFS, std::shared_ptr< PCHContainerOperations > PCHs, const SymbolIndex *Index)
llvm::Optional< FixItHint > FixIt
const_iterator end() const
Definition: Index.h:333
static std::string join(ArrayRef< SpecialMemberFunctionsCheck::SpecialMemberFunctionKind > SMFS, llvm::StringRef AndOr)
IncludeStructure Includes
Definition: ClangdUnit.h:57
Records an event whose duration is the lifetime of the Span object.
Definition: Trace.h:83
InsertTextFormat insertTextFormat
The format of the insert text.
Definition: Protocol.h:766
Attributes of a symbol-query pair that affect how much we like it.
Definition: Quality.h:84
CodeCompletionContext CCContext
#define SPAN_ATTACH(S, Name, Expr)
Attach a key-value pair to a Span event.
Definition: Trace.h:99
SmallVector< StringRef, 1 > getRankedIncludes(const Symbol &Sym)
CodeCompleteResult run(const SemaCompleteInput &SemaCCInput) &&
TopN<T> is a lossy container that preserves only the "best" N elements.
Definition: Quality.h:138
Range halfOpenToRange(const SourceManager &SM, CharSourceRange R)
Definition: SourceCode.cpp:146
unique_function< void()> Action