clang  9.0.0svn
CodeCompleteConsumer.cpp
Go to the documentation of this file.
1 //===- CodeCompleteConsumer.cpp - Code Completion Interface ---------------===//
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 // This file implements the CodeCompleteConsumer class.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "clang-c/Index.h"
16 #include "clang/AST/Decl.h"
17 #include "clang/AST/DeclBase.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/DeclTemplate.h"
21 #include "clang/AST/Type.h"
23 #include "clang/Lex/Preprocessor.h"
24 #include "clang/Sema/Sema.h"
25 #include "llvm/ADT/SmallString.h"
26 #include "llvm/ADT/SmallVector.h"
27 #include "llvm/ADT/StringRef.h"
28 #include "llvm/ADT/Twine.h"
29 #include "llvm/Support/Casting.h"
30 #include "llvm/Support/Compiler.h"
31 #include "llvm/Support/ErrorHandling.h"
32 #include "llvm/Support/FormatVariadic.h"
33 #include "llvm/Support/raw_ostream.h"
34 #include <algorithm>
35 #include <cassert>
36 #include <cstdint>
37 #include <string>
38 
39 using namespace clang;
40 
41 //===----------------------------------------------------------------------===//
42 // Code completion context implementation
43 //===----------------------------------------------------------------------===//
44 
46  switch (CCKind) {
47  case CCC_Recovery:
48  case CCC_Statement:
49  case CCC_Expression:
52  case CCC_Symbol:
54  return true;
55 
56  case CCC_TopLevel:
57  case CCC_ObjCInterface:
59  case CCC_ObjCIvarList:
64  case CCC_EnumTag:
65  case CCC_UnionTag:
68  case CCC_Namespace:
69  case CCC_Type:
70  case CCC_NewName:
71  case CCC_MacroName:
72  case CCC_MacroNameUse:
76  case CCC_SelectorName:
77  case CCC_TypeQualifiers:
78  case CCC_Other:
84  case CCC_IncludedFile:
85  return false;
86  }
87 
88  llvm_unreachable("Invalid CodeCompletionContext::Kind!");
89 }
90 
92  using CCKind = CodeCompletionContext::Kind;
93  switch (Kind) {
94  case CCKind::CCC_Other:
95  return "Other";
96  case CCKind::CCC_OtherWithMacros:
97  return "OtherWithMacros";
98  case CCKind::CCC_TopLevel:
99  return "TopLevel";
100  case CCKind::CCC_ObjCInterface:
101  return "ObjCInterface";
102  case CCKind::CCC_ObjCImplementation:
103  return "ObjCImplementation";
104  case CCKind::CCC_ObjCIvarList:
105  return "ObjCIvarList";
106  case CCKind::CCC_ClassStructUnion:
107  return "ClassStructUnion";
108  case CCKind::CCC_Statement:
109  return "Statement";
110  case CCKind::CCC_Expression:
111  return "Expression";
112  case CCKind::CCC_ObjCMessageReceiver:
113  return "ObjCMessageReceiver";
114  case CCKind::CCC_DotMemberAccess:
115  return "DotMemberAccess";
116  case CCKind::CCC_ArrowMemberAccess:
117  return "ArrowMemberAccess";
118  case CCKind::CCC_ObjCPropertyAccess:
119  return "ObjCPropertyAccess";
120  case CCKind::CCC_EnumTag:
121  return "EnumTag";
122  case CCKind::CCC_UnionTag:
123  return "UnionTag";
124  case CCKind::CCC_ClassOrStructTag:
125  return "ClassOrStructTag";
126  case CCKind::CCC_ObjCProtocolName:
127  return "ObjCProtocolName";
128  case CCKind::CCC_Namespace:
129  return "Namespace";
130  case CCKind::CCC_Type:
131  return "Type";
132  case CCKind::CCC_NewName:
133  return "NewName";
134  case CCKind::CCC_Symbol:
135  return "Symbol";
136  case CCKind::CCC_SymbolOrNewName:
137  return "SymbolOrNewName";
138  case CCKind::CCC_MacroName:
139  return "MacroName";
140  case CCKind::CCC_MacroNameUse:
141  return "MacroNameUse";
142  case CCKind::CCC_PreprocessorExpression:
143  return "PreprocessorExpression";
144  case CCKind::CCC_PreprocessorDirective:
145  return "PreprocessorDirective";
146  case CCKind::CCC_NaturalLanguage:
147  return "NaturalLanguage";
148  case CCKind::CCC_SelectorName:
149  return "SelectorName";
150  case CCKind::CCC_TypeQualifiers:
151  return "TypeQualifiers";
152  case CCKind::CCC_ParenthesizedExpression:
153  return "ParenthesizedExpression";
154  case CCKind::CCC_ObjCInstanceMessage:
155  return "ObjCInstanceMessage";
156  case CCKind::CCC_ObjCClassMessage:
157  return "ObjCClassMessage";
158  case CCKind::CCC_ObjCInterfaceName:
159  return "ObjCInterfaceName";
160  case CCKind::CCC_ObjCCategoryName:
161  return "ObjCCategoryName";
162  case CCKind::CCC_IncludedFile:
163  return "IncludedFile";
164  case CCKind::CCC_Recovery:
165  return "Recovery";
166  }
167  llvm_unreachable("Invalid CodeCompletionContext::Kind!");
168 }
169 
170 //===----------------------------------------------------------------------===//
171 // Code completion string implementation
172 //===----------------------------------------------------------------------===//
173 
175  : Kind(Kind), Text("") {
176  switch (Kind) {
177  case CK_TypedText:
178  case CK_Text:
179  case CK_Placeholder:
180  case CK_Informative:
181  case CK_ResultType:
182  case CK_CurrentParameter:
183  this->Text = Text;
184  break;
185 
186  case CK_Optional:
187  llvm_unreachable("Optional strings cannot be created from text");
188 
189  case CK_LeftParen:
190  this->Text = "(";
191  break;
192 
193  case CK_RightParen:
194  this->Text = ")";
195  break;
196 
197  case CK_LeftBracket:
198  this->Text = "[";
199  break;
200 
201  case CK_RightBracket:
202  this->Text = "]";
203  break;
204 
205  case CK_LeftBrace:
206  this->Text = "{";
207  break;
208 
209  case CK_RightBrace:
210  this->Text = "}";
211  break;
212 
213  case CK_LeftAngle:
214  this->Text = "<";
215  break;
216 
217  case CK_RightAngle:
218  this->Text = ">";
219  break;
220 
221  case CK_Comma:
222  this->Text = ", ";
223  break;
224 
225  case CK_Colon:
226  this->Text = ":";
227  break;
228 
229  case CK_SemiColon:
230  this->Text = ";";
231  break;
232 
233  case CK_Equal:
234  this->Text = " = ";
235  break;
236 
237  case CK_HorizontalSpace:
238  this->Text = " ";
239  break;
240 
241  case CK_VerticalSpace:
242  this->Text = "\n";
243  break;
244  }
245 }
246 
249  return Chunk(CK_Text, Text);
250 }
251 
254  Chunk Result;
255  Result.Kind = CK_Optional;
256  Result.Optional = Optional;
257  return Result;
258 }
259 
262  return Chunk(CK_Placeholder, Placeholder);
263 }
264 
267  return Chunk(CK_Informative, Informative);
268 }
269 
272  return Chunk(CK_ResultType, ResultType);
273 }
274 
276  const char *CurrentParameter) {
277  return Chunk(CK_CurrentParameter, CurrentParameter);
278 }
279 
280 CodeCompletionString::CodeCompletionString(
281  const Chunk *Chunks, unsigned NumChunks, unsigned Priority,
282  CXAvailabilityKind Availability, const char **Annotations,
283  unsigned NumAnnotations, StringRef ParentName, const char *BriefComment)
284  : NumChunks(NumChunks), NumAnnotations(NumAnnotations), Priority(Priority),
285  Availability(Availability), ParentName(ParentName),
286  BriefComment(BriefComment) {
287  assert(NumChunks <= 0xffff);
288  assert(NumAnnotations <= 0xffff);
289 
290  Chunk *StoredChunks = reinterpret_cast<Chunk *>(this + 1);
291  for (unsigned I = 0; I != NumChunks; ++I)
292  StoredChunks[I] = Chunks[I];
293 
294  const char **StoredAnnotations =
295  reinterpret_cast<const char **>(StoredChunks + NumChunks);
296  for (unsigned I = 0; I != NumAnnotations; ++I)
297  StoredAnnotations[I] = Annotations[I];
298 }
299 
301  return NumAnnotations;
302 }
303 
304 const char *CodeCompletionString::getAnnotation(unsigned AnnotationNr) const {
305  if (AnnotationNr < NumAnnotations)
306  return reinterpret_cast<const char *const *>(end())[AnnotationNr];
307  else
308  return nullptr;
309 }
310 
312  std::string Result;
313  llvm::raw_string_ostream OS(Result);
314 
315  for (const Chunk &C : *this) {
316  switch (C.Kind) {
317  case CK_Optional:
318  OS << "{#" << C.Optional->getAsString() << "#}";
319  break;
320  case CK_Placeholder:
321  OS << "<#" << C.Text << "#>";
322  break;
323  case CK_Informative:
324  case CK_ResultType:
325  OS << "[#" << C.Text << "#]";
326  break;
327  case CK_CurrentParameter:
328  OS << "<#" << C.Text << "#>";
329  break;
330  default:
331  OS << C.Text;
332  break;
333  }
334  }
335  return OS.str();
336 }
337 
339  for (const Chunk &C : *this)
340  if (C.Kind == CK_TypedText)
341  return C.Text;
342 
343  return nullptr;
344 }
345 
346 const char *CodeCompletionAllocator::CopyString(const Twine &String) {
347  SmallString<128> Data;
348  StringRef Ref = String.toStringRef(Data);
349  // FIXME: It would be more efficient to teach Twine to tell us its size and
350  // then add a routine there to fill in an allocated char* with the contents
351  // of the string.
352  char *Mem = (char *)Allocate(Ref.size() + 1, 1);
353  std::copy(Ref.begin(), Ref.end(), Mem);
354  Mem[Ref.size()] = 0;
355  return Mem;
356 }
357 
359  const NamedDecl *ND = dyn_cast<NamedDecl>(DC);
360  if (!ND)
361  return {};
362 
363  // Check whether we've already cached the parent name.
364  StringRef &CachedParentName = ParentNames[DC];
365  if (!CachedParentName.empty())
366  return CachedParentName;
367 
368  // If we already processed this DeclContext and assigned empty to it, the
369  // data pointer will be non-null.
370  if (CachedParentName.data() != nullptr)
371  return {};
372 
373  // Find the interesting names.
375  while (DC && !DC->isFunctionOrMethod()) {
376  if (const auto *ND = dyn_cast<NamedDecl>(DC)) {
377  if (ND->getIdentifier())
378  Contexts.push_back(DC);
379  }
380 
381  DC = DC->getParent();
382  }
383 
384  {
386  llvm::raw_svector_ostream OS(S);
387  bool First = true;
388  for (unsigned I = Contexts.size(); I != 0; --I) {
389  if (First)
390  First = false;
391  else {
392  OS << "::";
393  }
394 
395  const DeclContext *CurDC = Contexts[I - 1];
396  if (const auto *CatImpl = dyn_cast<ObjCCategoryImplDecl>(CurDC))
397  CurDC = CatImpl->getCategoryDecl();
398 
399  if (const auto *Cat = dyn_cast<ObjCCategoryDecl>(CurDC)) {
400  const ObjCInterfaceDecl *Interface = Cat->getClassInterface();
401  if (!Interface) {
402  // Assign an empty StringRef but with non-null data to distinguish
403  // between empty because we didn't process the DeclContext yet.
404  CachedParentName = StringRef((const char *)(uintptr_t)~0U, 0);
405  return {};
406  }
407 
408  OS << Interface->getName() << '(' << Cat->getName() << ')';
409  } else {
410  OS << cast<NamedDecl>(CurDC)->getName();
411  }
412  }
413 
414  CachedParentName = AllocatorRef->CopyString(OS.str());
415  }
416 
417  return CachedParentName;
418 }
419 
421  void *Mem = getAllocator().Allocate(
422  sizeof(CodeCompletionString) + sizeof(Chunk) * Chunks.size() +
423  sizeof(const char *) * Annotations.size(),
424  alignof(CodeCompletionString));
426  Chunks.data(), Chunks.size(), Priority, Availability, Annotations.data(),
427  Annotations.size(), ParentName, BriefComment);
428  Chunks.clear();
429  return Result;
430 }
431 
433  Chunks.push_back(Chunk(CodeCompletionString::CK_TypedText, Text));
434 }
435 
437  Chunks.push_back(Chunk::CreateText(Text));
438 }
439 
441  Chunks.push_back(Chunk::CreateOptional(Optional));
442 }
443 
444 void CodeCompletionBuilder::AddPlaceholderChunk(const char *Placeholder) {
445  Chunks.push_back(Chunk::CreatePlaceholder(Placeholder));
446 }
447 
449  Chunks.push_back(Chunk::CreateInformative(Text));
450 }
451 
452 void CodeCompletionBuilder::AddResultTypeChunk(const char *ResultType) {
453  Chunks.push_back(Chunk::CreateResultType(ResultType));
454 }
455 
457  const char *CurrentParameter) {
458  Chunks.push_back(Chunk::CreateCurrentParameter(CurrentParameter));
459 }
460 
462  const char *Text) {
463  Chunks.push_back(Chunk(CK, Text));
464 }
465 
467  if (DC->isTranslationUnit())
468  return;
469 
470  if (DC->isFunctionOrMethod())
471  return;
472 
473  const NamedDecl *ND = dyn_cast<NamedDecl>(DC);
474  if (!ND)
475  return;
476 
477  ParentName = getCodeCompletionTUInfo().getParentName(DC);
478 }
479 
480 void CodeCompletionBuilder::addBriefComment(StringRef Comment) {
481  BriefComment = Allocator.CopyString(Comment);
482 }
483 
484 //===----------------------------------------------------------------------===//
485 // Code completion overload candidate implementation
486 //===----------------------------------------------------------------------===//
488  if (getKind() == CK_Function)
489  return Function;
490  else if (getKind() == CK_FunctionTemplate)
491  return FunctionTemplate->getTemplatedDecl();
492  else
493  return nullptr;
494 }
495 
496 const FunctionType *
498  switch (Kind) {
499  case CK_Function:
500  return Function->getType()->getAs<FunctionType>();
501 
502  case CK_FunctionTemplate:
503  return FunctionTemplate->getTemplatedDecl()
504  ->getType()
505  ->getAs<FunctionType>();
506 
507  case CK_FunctionType:
508  return Type;
509  }
510 
511  llvm_unreachable("Invalid CandidateKind!");
512 }
513 
514 //===----------------------------------------------------------------------===//
515 // Code completion consumer implementation
516 //===----------------------------------------------------------------------===//
517 
519 
521  StringRef Filter, CodeCompletionResult Result) {
522  switch (Result.Kind) {
524  return !(Result.Declaration->getIdentifier() &&
525  Result.Declaration->getIdentifier()->getName().startswith(Filter));
527  return !StringRef(Result.Keyword).startswith(Filter);
529  return !Result.Macro->getName().startswith(Filter);
531  return !(Result.Pattern->getTypedText() &&
532  StringRef(Result.Pattern->getTypedText()).startswith(Filter));
533  }
534  llvm_unreachable("Unknown code completion result Kind.");
535 }
536 
538  Sema &SemaRef, CodeCompletionContext Context, CodeCompletionResult *Results,
539  unsigned NumResults) {
540  std::stable_sort(Results, Results + NumResults);
541 
542  if (!Context.getPreferredType().isNull())
543  OS << "PREFERRED-TYPE: " << Context.getPreferredType().getAsString()
544  << "\n";
545 
546  StringRef Filter = SemaRef.getPreprocessor().getCodeCompletionFilter();
547  // Print the completions.
548  for (unsigned I = 0; I != NumResults; ++I) {
549  if (!Filter.empty() && isResultFilteredOut(Filter, Results[I]))
550  continue;
551  OS << "COMPLETION: ";
552  switch (Results[I].Kind) {
554  OS << *Results[I].Declaration;
555  {
556  std::vector<std::string> Tags;
557  if (Results[I].Hidden)
558  Tags.push_back("Hidden");
559  if (Results[I].InBaseClass)
560  Tags.push_back("InBase");
561  if (Results[I].Availability ==
563  Tags.push_back("Inaccessible");
564  if (!Tags.empty())
565  OS << " (" << llvm::join(Tags, ",") << ")";
566  }
567  if (CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(
568  SemaRef, Context, getAllocator(), CCTUInfo,
569  includeBriefComments())) {
570  OS << " : " << CCS->getAsString();
571  if (const char *BriefComment = CCS->getBriefComment())
572  OS << " : " << BriefComment;
573  }
574  for (const FixItHint &FixIt : Results[I].FixIts) {
575  const SourceLocation BLoc = FixIt.RemoveRange.getBegin();
576  const SourceLocation ELoc = FixIt.RemoveRange.getEnd();
577 
578  SourceManager &SM = SemaRef.SourceMgr;
579  std::pair<FileID, unsigned> BInfo = SM.getDecomposedLoc(BLoc);
580  std::pair<FileID, unsigned> EInfo = SM.getDecomposedLoc(ELoc);
581  // Adjust for token ranges.
582  if (FixIt.RemoveRange.isTokenRange())
583  EInfo.second += Lexer::MeasureTokenLength(ELoc, SM, SemaRef.LangOpts);
584 
585  OS << " (requires fix-it:"
586  << " {" << SM.getLineNumber(BInfo.first, BInfo.second) << ':'
587  << SM.getColumnNumber(BInfo.first, BInfo.second) << '-'
588  << SM.getLineNumber(EInfo.first, EInfo.second) << ':'
589  << SM.getColumnNumber(EInfo.first, EInfo.second) << "}"
590  << " to \"" << FixIt.CodeToInsert << "\")";
591  }
592  OS << '\n';
593  break;
594 
596  OS << Results[I].Keyword << '\n';
597  break;
598 
600  OS << Results[I].Macro->getName();
601  if (CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(
602  SemaRef, Context, getAllocator(), CCTUInfo,
603  includeBriefComments())) {
604  OS << " : " << CCS->getAsString();
605  }
606  OS << '\n';
607  break;
608 
610  OS << "Pattern : " << Results[I].Pattern->getAsString() << '\n';
611  break;
612  }
613  }
614 }
615 
616 // This function is used solely to preserve the former presentation of overloads
617 // by "clang -cc1 -code-completion-at", since CodeCompletionString::getAsString
618 // needs to be improved for printing the newer and more detailed overload
619 // chunks.
620 static std::string getOverloadAsString(const CodeCompletionString &CCS) {
621  std::string Result;
622  llvm::raw_string_ostream OS(Result);
623 
624  for (auto &C : CCS) {
625  switch (C.Kind) {
628  OS << "[#" << C.Text << "#]";
629  break;
630 
632  OS << "<#" << C.Text << "#>";
633  break;
634 
635  // FIXME: We can also print optional parameters of an overload.
637  break;
638 
639  default:
640  OS << C.Text;
641  break;
642  }
643  }
644  return OS.str();
645 }
646 
648  Sema &SemaRef, unsigned CurrentArg, OverloadCandidate *Candidates,
649  unsigned NumCandidates, SourceLocation OpenParLoc) {
650  OS << "OPENING_PAREN_LOC: ";
651  OpenParLoc.print(OS, SemaRef.getSourceManager());
652  OS << "\n";
653 
654  for (unsigned I = 0; I != NumCandidates; ++I) {
655  if (CodeCompletionString *CCS = Candidates[I].CreateSignatureString(
656  CurrentArg, SemaRef, getAllocator(), CCTUInfo,
657  includeBriefComments())) {
658  OS << "OVERLOAD: " << getOverloadAsString(*CCS) << "\n";
659  }
660  }
661 }
662 
663 /// Retrieve the effective availability of the given declaration.
666  if (isa<EnumConstantDecl>(D))
667  AR = std::max(AR, cast<Decl>(D->getDeclContext())->getAvailability());
668  return AR;
669 }
670 
671 void CodeCompletionResult::computeCursorKindAndAvailability(bool Accessible) {
672  switch (Kind) {
673  case RK_Pattern:
674  if (!Declaration) {
675  // Do nothing: Patterns can come with cursor kinds!
676  break;
677  }
678  LLVM_FALLTHROUGH;
679 
680  case RK_Declaration: {
681  // Set the availability based on attributes.
682  switch (getDeclAvailability(Declaration)) {
683  case AR_Available:
684  case AR_NotYetIntroduced:
685  Availability = CXAvailability_Available;
686  break;
687 
688  case AR_Deprecated:
689  Availability = CXAvailability_Deprecated;
690  break;
691 
692  case AR_Unavailable:
693  Availability = CXAvailability_NotAvailable;
694  break;
695  }
696 
697  if (const auto *Function = dyn_cast<FunctionDecl>(Declaration))
698  if (Function->isDeleted())
699  Availability = CXAvailability_NotAvailable;
700 
701  CursorKind = getCursorKindForDecl(Declaration);
702  if (CursorKind == CXCursor_UnexposedDecl) {
703  // FIXME: Forward declarations of Objective-C classes and protocols
704  // are not directly exposed, but we want code completion to treat them
705  // like a definition.
706  if (isa<ObjCInterfaceDecl>(Declaration))
707  CursorKind = CXCursor_ObjCInterfaceDecl;
708  else if (isa<ObjCProtocolDecl>(Declaration))
709  CursorKind = CXCursor_ObjCProtocolDecl;
710  else
711  CursorKind = CXCursor_NotImplemented;
712  }
713  break;
714  }
715 
716  case RK_Macro:
717  case RK_Keyword:
718  llvm_unreachable("Macro and keyword kinds are handled by the constructors");
719  }
720 
721  if (!Accessible)
722  Availability = CXAvailability_NotAccessible;
723 }
724 
725 /// Retrieve the name that should be used to order a result.
726 ///
727 /// If the name needs to be constructed as a string, that string will be
728 /// saved into Saved and the returned StringRef will refer to it.
729 StringRef CodeCompletionResult::getOrderedName(std::string &Saved) const {
730  switch (Kind) {
731  case RK_Keyword:
732  return Keyword;
733  case RK_Pattern:
734  return Pattern->getTypedText();
735  case RK_Macro:
736  return Macro->getName();
737  case RK_Declaration:
738  // Handle declarations below.
739  break;
740  }
741 
742  DeclarationName Name = Declaration->getDeclName();
743 
744  // If the name is a simple identifier (by far the common case), or a
745  // zero-argument selector, just return a reference to that identifier.
746  if (IdentifierInfo *Id = Name.getAsIdentifierInfo())
747  return Id->getName();
748  if (Name.isObjCZeroArgSelector())
750  return Id->getName();
751 
752  Saved = Name.getAsString();
753  return Saved;
754 }
755 
757  const CodeCompletionResult &Y) {
758  std::string XSaved, YSaved;
759  StringRef XStr = X.getOrderedName(XSaved);
760  StringRef YStr = Y.getOrderedName(YSaved);
761  int cmp = XStr.compare_lower(YStr);
762  if (cmp)
763  return cmp < 0;
764 
765  // If case-insensitive comparison fails, try case-sensitive comparison.
766  return XStr.compare(YStr) < 0;
767 }
One piece of the code completion string.
An unknown context, in which we are recovering from a parsing error and don&#39;t know which completions ...
A code completion string that is entirely optional.
CXAvailabilityKind
Describes the availability of a particular entity, which indicates whether the use of this entity wil...
Definition: Index.h:131
Represents a function declaration or definition.
Definition: Decl.h:1738
ResultKind Kind
The kind of result stored here.
StringRef getParentName(const DeclContext *DC)
Code completion for a selector, as in an @selector expression.
Code completion occurred where an existing name(such as type, function or variable) is expected...
const FunctionType * getFunctionType() const
Retrieve the function type of the entity, regardless of how the function is stored.
void AddTextChunk(const char *Text)
Add a new text chunk.
Code completion where an Objective-C class message is expected.
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3358
FunctionDecl * getFunction() const
Retrieve the function overload candidate or the templated function declaration for a function templat...
C Language Family Type Representation.
Code completion within a type-qualifier list.
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
void AddChunk(CodeCompletionString::ChunkKind CK, const char *Text="")
Add a new chunk.
Selector getObjCSelector() const
Get the Objective-C selector stored in this declaration name.
Defines the C++ template declaration subclasses.
unsigned getColumnNumber(FileID FID, unsigned FilePos, bool *Invalid=nullptr) const
Return the column # for the specified file position.
static Chunk CreateText(const char *Text)
Create a new text chunk.
The base class of the type hierarchy.
Definition: Type.h:1407
An unspecified code-completion context.
static Chunk CreateOptional(CodeCompletionString *Optional)
Create a new optional chunk.
Code completion occurred where an Objective-C message receiver is expected.
unsigned getAnnotationCount() const
Retrieve the number of annotations for this code completion result.
Code completion occurred on the right-hand side of a member access expression using the arrow operato...
ChunkKind
The different kinds of "chunks" that can occur within a code completion string.
Code completion occurred after the "enum" keyword, to indicate an enumeration name.
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6755
A piece of text that describes the type of an entity or, for functions and methods, the return type.
const char * Keyword
When Kind == RK_Keyword, the string representing the keyword or symbol&#39;s spelling.
static Chunk CreateResultType(const char *ResultType)
Create a new result type chunk.
void AddOptionalChunk(CodeCompletionString *Optional)
Add a new optional chunk.
Code completion occurred within the instance variable list of an Objective-C interface, implementation, or category implementation.
void AddTypedTextChunk(const char *Text)
Add a new typed-text chunk.
The entity is not available; any use of it will be an error.
Definition: Index.h:144
Parse and apply any fixits to the source.
std::string getName(ArrayRef< StringRef > Parts) const
Get the platform-specific name separator.
Code completion occurred where both a new name and an existing symbol is permissible.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:270
One of these records is kept for each identifier that is lexed.
CodeCompletionString * TakeString()
Take the resulting completion string.
void print(raw_ostream &OS, const SourceManager &SM) const
static Chunk CreateInformative(const char *Informative)
Create a new informative chunk.
A "string" used to describe how code completion can be performed for an entity.
An Objective-C @protocol declaration.
Definition: Index.h:1752
void AddResultTypeChunk(const char *ResultType)
Add a new result-type chunk.
static Chunk CreatePlaceholder(const char *Placeholder)
Create a new placeholder chunk.
CodeCompletionString * Pattern
When Kind == RK_Pattern, the code-completion string that describes the completion text to insert...
Code completion occurred where a preprocessor directive is expected.
Code completion occurred within an Objective-C implementation or category implementation.
Code completion occurred where a namespace or namespace alias is expected.
static Chunk CreateCurrentParameter(const char *CurrentParameter)
Create a new current-parameter chunk.
Represents an ObjC class declaration.
Definition: DeclObjC.h:1172
The piece of text that the user is expected to type to match the code-completion string, typically a keyword or the name of a declarator or macro.
A comma separator (&#39;,&#39;).
bool wantConstructorResults() const
Determines whether we want C++ constructors as results within this context.
const LangOptions & LangOpts
Definition: Sema.h:322
AvailabilityResult
Captures the result of checking the availability of a declaration.
Definition: DeclBase.h:73
A right parenthesis (&#39;)&#39;).
Code completion where an Objective-C category name is expected.
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:278
Code completion occurred within a "top-level" completion context, e.g., at namespace or global scope...
AvailabilityResult getAvailability(std::string *Message=nullptr, VersionTuple EnclosingVersion=VersionTuple(), StringRef *RealizedPlatform=nullptr) const
Determine the availability of the given declaration.
Definition: DeclBase.cpp:589
static std::string getOverloadAsString(const CodeCompletionString &CCS)
Code completion occurred where a protocol name is expected.
CXCursorKind getCursorKindForDecl(const Decl *D)
Determine the libclang cursor kind associated with the given declaration.
QualType getPreferredType() const
Retrieve the type that this expression would prefer to have, e.g., if the expression is a variable in...
llvm::StringRef getCompletionKindString(CodeCompletionContext::Kind Kind)
Get string representation of Kind, useful for for debugging.
int Id
Definition: ASTDiff.cpp:191
std::string getAsString() const
Retrieve a string representation of the code completion string, which is mainly useful for debugging...
static unsigned MeasureTokenLength(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
MeasureTokenLength - Relex the token at the specified location and return its length in bytes in the ...
Definition: Lexer.cpp:436
const char * Text
The text string associated with a CK_Text, CK_Placeholder, CK_Informative, or CK_Comma chunk...
std::string getAsString() const
Retrieve the human-readable string for this name.
Defines the clang::Preprocessor interface.
const NamedDecl * Declaration
When Kind == RK_Declaration or RK_Pattern, the declaration we are referring to.
DeclContext * getDeclContext()
Definition: DeclBase.h:427
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn&#39;t...
Captures a result of code completion.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
bool isFunctionOrMethod() const
Definition: DeclBase.h:1800
Code completion in a parenthesized expression, which means that we may also have types here in C and ...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1752
Code completion occurred in a context where natural language is expected, e.g., a comment or string l...
Preprocessor & getPreprocessor() const
Definition: Sema.h:1237
A piece of text that should be placed in the buffer, e.g., parentheses or a comma in a function call...
The result type of a method or function.
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:703
const char * CopyString(const Twine &String)
Copy the given string into this allocator.
const SourceManager & SM
Definition: Format.cpp:1490
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Definition: opencl-c.h:90
const char * getTypedText() const
Returns the text in the TypedText chunk.
CodeCompletionString * Optional
The code completion string associated with a CK_Optional chunk.
The context in which code completion occurred, so that the code-completion consumer can process the r...
const IdentifierInfo * Macro
When Kind == RK_Macro, the identifier that refers to a macro.
Code completion occurred within a class, struct, or union.
llvm::cl::opt< std::string > Filter
Kind
IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const
Retrieve the identifier at a given position in the selector.
Encodes a location in the source.
Code completion occurred where a new name is expected.
const char * getAnnotation(unsigned AnnotationNr) const
Retrieve the annotation string specified by AnnotationNr.
Code completion where the name of an Objective-C class is expected.
Code completion occurred within an Objective-C interface, protocol, or category interface.
unsigned getLineNumber(FileID FID, unsigned FilePos, bool *Invalid=nullptr) const
Given a SourceLocation, return the spelling line number for the position indicated.
The entity is available.
Definition: Index.h:135
void addParentContext(const DeclContext *DC)
Add the parent context information to this code completion.
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
The entity is available, but not accessible; any use of it will be an error.
Definition: Index.h:149
ChunkKind Kind
The kind of data stored in this piece of the code completion string.
void addBriefComment(StringRef Comment)
StringRef getName() const
Return the actual identifier string.
Dataflow Directional Tag Classes.
Code completion occurred where an macro is being defined.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1262
A piece of text that describes something about the result but should not be inserted into the buffer...
Code completion occurred after the "struct" or "class" keyword, to indicate a struct or class name...
static AvailabilityResult getDeclAvailability(const Decl *D)
Retrieve the effective availability of the given declaration.
void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context, CodeCompletionResult *Results, unsigned NumResults) override
Prints the finalized code-completion results.
Code completion occurred after the "union" keyword, to indicate a union name.
Code completion occurred where a macro name is expected (without any arguments, in the case of a func...
Code completion where an Objective-C instance message is expected.
The name of a declaration.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition: Type.h:971
StringRef getCodeCompletionFilter()
Get the code completion token for filtering purposes.
Refers to a precomputed pattern.
Code completion occurred where a statement (or declaration) is expected in a function, method, or block.
Code completion occurred on the right-hand side of an Objective-C property access expression...
void AddInformativeChunk(const char *Text)
Add a new informative chunk.
void AddCurrentParameterChunk(const char *CurrentParameter)
Add a new current-parameter chunk.
A declaration whose specific kind is not exposed via this interface.
Definition: Index.h:1725
A piece of text that describes the parameter that corresponds to the code-completion location within ...
A string that acts as a placeholder for, e.g., a function call argument.
unsigned getAvailability() const
Retrieve the availability of this code completion result.
A left parenthesis (&#39;(&#39;).
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:13954
Code completion occurred within a preprocessor expression.
Code completion occurred where an expression is expected.
Code completion inside the filename part of a #include directive.
An unspecified code-completion context where we should also add macro completions.
A left angle bracket (&#39;<&#39;).
void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, OverloadCandidate *Candidates, unsigned NumCandidates, SourceLocation OpenParLoc) override
A right angle bracket (&#39;>&#39;).
SourceManager & getSourceManager() const
Definition: Sema.h:1236
Vertical whitespace (&#39;\n&#39; or &#39;\r\n&#39;, depending on the platform).
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:276
__DEVICE__ int max(int __a, int __b)
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:954
StringRef getOrderedName(std::string &Saved) const
Retrieve the name that should be used to order a result.
Code completion occurred on the right-hand side of a member access expression using the dot operator...
void AddPlaceholderChunk(const char *Placeholder)
Add a new placeholder chunk.
Code completion occurred where a type name is expected.
Horizontal whitespace (&#39; &#39;).
SourceManager & SourceMgr
Definition: Sema.h:327
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:66
StringRef Text
Definition: Format.cpp:1630
bool isResultFilteredOut(StringRef Filter, CodeCompletionResult Results) override
The entity is available, but has been deprecated (and its use is not recommended).
Definition: Index.h:140
This represents a decl that may have a name.
Definition: Decl.h:249
bool isTranslationUnit() const
Definition: DeclBase.h:1823
An Objective-C @interface.
Definition: Index.h:1748
virtual ~CodeCompleteConsumer()
Deregisters and destroys this code-completion consumer.
bool isObjCZeroArgSelector() const
This class handles loading and caching of source files into memory.
std::pair< FileID, unsigned > getDecomposedLoc(SourceLocation Loc) const
Decompose the specified location into a raw FileID + Offset pair.