clang  14.0.0git
CodeCompleteConsumer.cpp
Go to the documentation of this file.
1 //===- CodeCompleteConsumer.cpp - Code Completion Interface ---------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the CodeCompleteConsumer class.
10 //
11 //===----------------------------------------------------------------------===//
12 
14 #include "clang-c/Index.h"
15 #include "clang/AST/Decl.h"
16 #include "clang/AST/DeclBase.h"
17 #include "clang/AST/DeclObjC.h"
18 #include "clang/AST/DeclTemplate.h"
20 #include "clang/AST/Type.h"
22 #include "clang/Lex/Preprocessor.h"
23 #include "clang/Sema/Sema.h"
24 #include "llvm/ADT/SmallString.h"
25 #include "llvm/ADT/SmallVector.h"
26 #include "llvm/ADT/StringExtras.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  case CCC_Attribute:
86  return false;
87  }
88 
89  llvm_unreachable("Invalid CodeCompletionContext::Kind!");
90 }
91 
93  using CCKind = CodeCompletionContext::Kind;
94  switch (Kind) {
95  case CCKind::CCC_Other:
96  return "Other";
97  case CCKind::CCC_OtherWithMacros:
98  return "OtherWithMacros";
99  case CCKind::CCC_TopLevel:
100  return "TopLevel";
101  case CCKind::CCC_ObjCInterface:
102  return "ObjCInterface";
103  case CCKind::CCC_ObjCImplementation:
104  return "ObjCImplementation";
105  case CCKind::CCC_ObjCIvarList:
106  return "ObjCIvarList";
107  case CCKind::CCC_ClassStructUnion:
108  return "ClassStructUnion";
109  case CCKind::CCC_Statement:
110  return "Statement";
111  case CCKind::CCC_Expression:
112  return "Expression";
113  case CCKind::CCC_ObjCMessageReceiver:
114  return "ObjCMessageReceiver";
115  case CCKind::CCC_DotMemberAccess:
116  return "DotMemberAccess";
117  case CCKind::CCC_ArrowMemberAccess:
118  return "ArrowMemberAccess";
119  case CCKind::CCC_ObjCPropertyAccess:
120  return "ObjCPropertyAccess";
121  case CCKind::CCC_EnumTag:
122  return "EnumTag";
123  case CCKind::CCC_UnionTag:
124  return "UnionTag";
125  case CCKind::CCC_ClassOrStructTag:
126  return "ClassOrStructTag";
127  case CCKind::CCC_ObjCProtocolName:
128  return "ObjCProtocolName";
129  case CCKind::CCC_Namespace:
130  return "Namespace";
131  case CCKind::CCC_Type:
132  return "Type";
133  case CCKind::CCC_NewName:
134  return "NewName";
135  case CCKind::CCC_Symbol:
136  return "Symbol";
137  case CCKind::CCC_SymbolOrNewName:
138  return "SymbolOrNewName";
139  case CCKind::CCC_MacroName:
140  return "MacroName";
141  case CCKind::CCC_MacroNameUse:
142  return "MacroNameUse";
143  case CCKind::CCC_PreprocessorExpression:
144  return "PreprocessorExpression";
145  case CCKind::CCC_PreprocessorDirective:
146  return "PreprocessorDirective";
147  case CCKind::CCC_NaturalLanguage:
148  return "NaturalLanguage";
149  case CCKind::CCC_SelectorName:
150  return "SelectorName";
151  case CCKind::CCC_TypeQualifiers:
152  return "TypeQualifiers";
153  case CCKind::CCC_ParenthesizedExpression:
154  return "ParenthesizedExpression";
155  case CCKind::CCC_ObjCInstanceMessage:
156  return "ObjCInstanceMessage";
157  case CCKind::CCC_ObjCClassMessage:
158  return "ObjCClassMessage";
159  case CCKind::CCC_ObjCInterfaceName:
160  return "ObjCInterfaceName";
161  case CCKind::CCC_ObjCCategoryName:
162  return "ObjCCategoryName";
163  case CCKind::CCC_IncludedFile:
164  return "IncludedFile";
165  case CCKind::CCC_Attribute:
166  return "Attribute";
167  case CCKind::CCC_Recovery:
168  return "Recovery";
169  }
170  llvm_unreachable("Invalid CodeCompletionContext::Kind!");
171 }
172 
173 //===----------------------------------------------------------------------===//
174 // Code completion string implementation
175 //===----------------------------------------------------------------------===//
176 
178  : Kind(Kind), Text("") {
179  switch (Kind) {
180  case CK_TypedText:
181  case CK_Text:
182  case CK_Placeholder:
183  case CK_Informative:
184  case CK_ResultType:
185  case CK_CurrentParameter:
186  this->Text = Text;
187  break;
188 
189  case CK_Optional:
190  llvm_unreachable("Optional strings cannot be created from text");
191 
192  case CK_LeftParen:
193  this->Text = "(";
194  break;
195 
196  case CK_RightParen:
197  this->Text = ")";
198  break;
199 
200  case CK_LeftBracket:
201  this->Text = "[";
202  break;
203 
204  case CK_RightBracket:
205  this->Text = "]";
206  break;
207 
208  case CK_LeftBrace:
209  this->Text = "{";
210  break;
211 
212  case CK_RightBrace:
213  this->Text = "}";
214  break;
215 
216  case CK_LeftAngle:
217  this->Text = "<";
218  break;
219 
220  case CK_RightAngle:
221  this->Text = ">";
222  break;
223 
224  case CK_Comma:
225  this->Text = ", ";
226  break;
227 
228  case CK_Colon:
229  this->Text = ":";
230  break;
231 
232  case CK_SemiColon:
233  this->Text = ";";
234  break;
235 
236  case CK_Equal:
237  this->Text = " = ";
238  break;
239 
240  case CK_HorizontalSpace:
241  this->Text = " ";
242  break;
243 
244  case CK_VerticalSpace:
245  this->Text = "\n";
246  break;
247  }
248 }
249 
252  return Chunk(CK_Text, Text);
253 }
254 
257  Chunk Result;
258  Result.Kind = CK_Optional;
259  Result.Optional = Optional;
260  return Result;
261 }
262 
265  return Chunk(CK_Placeholder, Placeholder);
266 }
267 
270  return Chunk(CK_Informative, Informative);
271 }
272 
275  return Chunk(CK_ResultType, ResultType);
276 }
277 
279  const char *CurrentParameter) {
280  return Chunk(CK_CurrentParameter, CurrentParameter);
281 }
282 
283 CodeCompletionString::CodeCompletionString(
284  const Chunk *Chunks, unsigned NumChunks, unsigned Priority,
285  CXAvailabilityKind Availability, const char **Annotations,
286  unsigned NumAnnotations, StringRef ParentName, const char *BriefComment)
287  : NumChunks(NumChunks), NumAnnotations(NumAnnotations), Priority(Priority),
288  Availability(Availability), ParentName(ParentName),
289  BriefComment(BriefComment) {
290  assert(NumChunks <= 0xffff);
291  assert(NumAnnotations <= 0xffff);
292 
293  Chunk *StoredChunks = reinterpret_cast<Chunk *>(this + 1);
294  for (unsigned I = 0; I != NumChunks; ++I)
295  StoredChunks[I] = Chunks[I];
296 
297  const char **StoredAnnotations =
298  reinterpret_cast<const char **>(StoredChunks + NumChunks);
299  for (unsigned I = 0; I != NumAnnotations; ++I)
300  StoredAnnotations[I] = Annotations[I];
301 }
302 
304  return NumAnnotations;
305 }
306 
307 const char *CodeCompletionString::getAnnotation(unsigned AnnotationNr) const {
308  if (AnnotationNr < NumAnnotations)
309  return reinterpret_cast<const char *const *>(end())[AnnotationNr];
310  else
311  return nullptr;
312 }
313 
315  std::string Result;
316  llvm::raw_string_ostream OS(Result);
317 
318  for (const Chunk &C : *this) {
319  switch (C.Kind) {
320  case CK_Optional:
321  OS << "{#" << C.Optional->getAsString() << "#}";
322  break;
323  case CK_Placeholder:
324  OS << "<#" << C.Text << "#>";
325  break;
326  case CK_Informative:
327  case CK_ResultType:
328  OS << "[#" << C.Text << "#]";
329  break;
330  case CK_CurrentParameter:
331  OS << "<#" << C.Text << "#>";
332  break;
333  default:
334  OS << C.Text;
335  break;
336  }
337  }
338  return OS.str();
339 }
340 
342  for (const Chunk &C : *this)
343  if (C.Kind == CK_TypedText)
344  return C.Text;
345 
346  return nullptr;
347 }
348 
349 const char *CodeCompletionAllocator::CopyString(const Twine &String) {
350  SmallString<128> Data;
351  StringRef Ref = String.toStringRef(Data);
352  // FIXME: It would be more efficient to teach Twine to tell us its size and
353  // then add a routine there to fill in an allocated char* with the contents
354  // of the string.
355  char *Mem = (char *)Allocate(Ref.size() + 1, 1);
356  std::copy(Ref.begin(), Ref.end(), Mem);
357  Mem[Ref.size()] = 0;
358  return Mem;
359 }
360 
362  if (!isa<NamedDecl>(DC))
363  return {};
364 
365  // Check whether we've already cached the parent name.
366  StringRef &CachedParentName = ParentNames[DC];
367  if (!CachedParentName.empty())
368  return CachedParentName;
369 
370  // If we already processed this DeclContext and assigned empty to it, the
371  // data pointer will be non-null.
372  if (CachedParentName.data() != nullptr)
373  return {};
374 
375  // Find the interesting names.
377  while (DC && !DC->isFunctionOrMethod()) {
378  if (const auto *ND = dyn_cast<NamedDecl>(DC)) {
379  if (ND->getIdentifier())
380  Contexts.push_back(DC);
381  }
382 
383  DC = DC->getParent();
384  }
385 
386  {
388  llvm::raw_svector_ostream OS(S);
389  bool First = true;
390  for (unsigned I = Contexts.size(); I != 0; --I) {
391  if (First)
392  First = false;
393  else {
394  OS << "::";
395  }
396 
397  const DeclContext *CurDC = Contexts[I - 1];
398  if (const auto *CatImpl = dyn_cast<ObjCCategoryImplDecl>(CurDC))
399  CurDC = CatImpl->getCategoryDecl();
400 
401  if (const auto *Cat = dyn_cast<ObjCCategoryDecl>(CurDC)) {
402  const ObjCInterfaceDecl *Interface = Cat->getClassInterface();
403  if (!Interface) {
404  // Assign an empty StringRef but with non-null data to distinguish
405  // between empty because we didn't process the DeclContext yet.
406  CachedParentName = StringRef((const char *)(uintptr_t)~0U, 0);
407  return {};
408  }
409 
410  OS << Interface->getName() << '(' << Cat->getName() << ')';
411  } else {
412  OS << cast<NamedDecl>(CurDC)->getName();
413  }
414  }
415 
416  CachedParentName = AllocatorRef->CopyString(OS.str());
417  }
418 
419  return CachedParentName;
420 }
421 
423  void *Mem = getAllocator().Allocate(
424  sizeof(CodeCompletionString) + sizeof(Chunk) * Chunks.size() +
425  sizeof(const char *) * Annotations.size(),
426  alignof(CodeCompletionString));
427  CodeCompletionString *Result = new (Mem) CodeCompletionString(
428  Chunks.data(), Chunks.size(), Priority, Availability, Annotations.data(),
429  Annotations.size(), ParentName, BriefComment);
430  Chunks.clear();
431  return Result;
432 }
433 
435  Chunks.push_back(Chunk(CodeCompletionString::CK_TypedText, Text));
436 }
437 
439  Chunks.push_back(Chunk::CreateText(Text));
440 }
441 
443  Chunks.push_back(Chunk::CreateOptional(Optional));
444 }
445 
446 void CodeCompletionBuilder::AddPlaceholderChunk(const char *Placeholder) {
447  Chunks.push_back(Chunk::CreatePlaceholder(Placeholder));
448 }
449 
451  Chunks.push_back(Chunk::CreateInformative(Text));
452 }
453 
454 void CodeCompletionBuilder::AddResultTypeChunk(const char *ResultType) {
455  Chunks.push_back(Chunk::CreateResultType(ResultType));
456 }
457 
459  const char *CurrentParameter) {
460  Chunks.push_back(Chunk::CreateCurrentParameter(CurrentParameter));
461 }
462 
464  const char *Text) {
465  Chunks.push_back(Chunk(CK, Text));
466 }
467 
469  if (DC->isTranslationUnit())
470  return;
471 
472  if (DC->isFunctionOrMethod())
473  return;
474 
475  if (!isa<NamedDecl>(DC))
476  return;
477 
478  ParentName = getCodeCompletionTUInfo().getParentName(DC);
479 }
480 
481 void CodeCompletionBuilder::addBriefComment(StringRef Comment) {
482  BriefComment = Allocator.CopyString(Comment);
483 }
484 
485 //===----------------------------------------------------------------------===//
486 // Code completion overload candidate implementation
487 //===----------------------------------------------------------------------===//
489  if (getKind() == CK_Function)
490  return Function;
491  else if (getKind() == CK_FunctionTemplate)
492  return FunctionTemplate->getTemplatedDecl();
493  else
494  return nullptr;
495 }
496 
497 const FunctionType *
499  switch (Kind) {
500  case CK_Function:
501  return Function->getType()->getAs<FunctionType>();
502 
503  case CK_FunctionTemplate:
504  return FunctionTemplate->getTemplatedDecl()
505  ->getType()
506  ->getAs<FunctionType>();
507 
508  case CK_FunctionType:
509  return Type;
510  }
511 
512  llvm_unreachable("Invalid CandidateKind!");
513 }
514 
515 //===----------------------------------------------------------------------===//
516 // Code completion consumer implementation
517 //===----------------------------------------------------------------------===//
518 
520 
522  StringRef Filter, CodeCompletionResult Result) {
523  switch (Result.Kind) {
525  return !(Result.Declaration->getIdentifier() &&
526  Result.Declaration->getIdentifier()->getName().startswith(Filter));
528  return !StringRef(Result.Keyword).startswith(Filter);
530  return !Result.Macro->getName().startswith(Filter);
532  return !(Result.Pattern->getTypedText() &&
533  StringRef(Result.Pattern->getTypedText()).startswith(Filter));
534  }
535  llvm_unreachable("Unknown code completion result Kind.");
536 }
537 
539  Sema &SemaRef, CodeCompletionContext Context, CodeCompletionResult *Results,
540  unsigned NumResults) {
541  std::stable_sort(Results, Results + NumResults);
542 
543  if (!Context.getPreferredType().isNull())
544  OS << "PREFERRED-TYPE: " << Context.getPreferredType().getAsString()
545  << "\n";
546 
547  StringRef Filter = SemaRef.getPreprocessor().getCodeCompletionFilter();
548  // Print the completions.
549  for (unsigned I = 0; I != NumResults; ++I) {
550  if (!Filter.empty() && isResultFilteredOut(Filter, Results[I]))
551  continue;
552  OS << "COMPLETION: ";
553  switch (Results[I].Kind) {
555  OS << *Results[I].Declaration;
556  {
557  std::vector<std::string> Tags;
558  if (Results[I].Hidden)
559  Tags.push_back("Hidden");
560  if (Results[I].InBaseClass)
561  Tags.push_back("InBase");
562  if (Results[I].Availability ==
564  Tags.push_back("Inaccessible");
565  if (!Tags.empty())
566  OS << " (" << llvm::join(Tags, ",") << ")";
567  }
568  if (CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(
569  SemaRef, Context, getAllocator(), CCTUInfo,
570  includeBriefComments())) {
571  OS << " : " << CCS->getAsString();
572  if (const char *BriefComment = CCS->getBriefComment())
573  OS << " : " << BriefComment;
574  }
575  break;
576 
578  OS << Results[I].Keyword;
579  break;
580 
582  OS << Results[I].Macro->getName();
583  if (CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(
584  SemaRef, Context, getAllocator(), CCTUInfo,
585  includeBriefComments())) {
586  OS << " : " << CCS->getAsString();
587  }
588  break;
589 
591  OS << "Pattern : " << Results[I].Pattern->getAsString();
592  break;
593  }
594  for (const FixItHint &FixIt : Results[I].FixIts) {
595  const SourceLocation BLoc = FixIt.RemoveRange.getBegin();
596  const SourceLocation ELoc = FixIt.RemoveRange.getEnd();
597 
598  SourceManager &SM = SemaRef.SourceMgr;
599  std::pair<FileID, unsigned> BInfo = SM.getDecomposedLoc(BLoc);
600  std::pair<FileID, unsigned> EInfo = SM.getDecomposedLoc(ELoc);
601  // Adjust for token ranges.
602  if (FixIt.RemoveRange.isTokenRange())
603  EInfo.second += Lexer::MeasureTokenLength(ELoc, SM, SemaRef.LangOpts);
604 
605  OS << " (requires fix-it:"
606  << " {" << SM.getLineNumber(BInfo.first, BInfo.second) << ':'
607  << SM.getColumnNumber(BInfo.first, BInfo.second) << '-'
608  << SM.getLineNumber(EInfo.first, EInfo.second) << ':'
609  << SM.getColumnNumber(EInfo.first, EInfo.second) << "}"
610  << " to \"" << FixIt.CodeToInsert << "\")";
611  }
612  OS << '\n';
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.
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.
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())
749  if (IdentifierInfo *Id = Name.getObjCSelector().getIdentifierInfoForSlot(0))
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_insensitive(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 }
clang::CodeCompletionContext::CCC_SymbolOrNewName
@ CCC_SymbolOrNewName
Code completion occurred where both a new name and an existing symbol is permissible.
Definition: CodeCompleteConsumer.h:278
clang::ObjCInterfaceDecl
Represents an ObjC class declaration.
Definition: DeclObjC.h:1148
clang::CodeCompletionContext::CCC_Other
@ CCC_Other
An unspecified code-completion context.
Definition: CodeCompleteConsumer.h:191
max
__DEVICE__ int max(int __a, int __b)
Definition: __clang_cuda_math.h:196
clang::CodeCompletionBuilder::addParentContext
void addParentContext(const DeclContext *DC)
Add the parent context information to this code completion.
Definition: CodeCompleteConsumer.cpp:468
clang::CodeCompletionString::getAnnotationCount
unsigned getAnnotationCount() const
Retrieve the number of annotations for this code completion result.
Definition: CodeCompleteConsumer.cpp:303
clang::CodeCompletionContext::Kind
Kind
Definition: CodeCompleteConsumer.h:189
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1347
clang::CodeCompletionBuilder::TakeString
CodeCompletionString * TakeString()
Take the resulting completion string.
Definition: CodeCompleteConsumer.cpp:422
clang::CodeCompletionContext::CCC_ObjCInstanceMessage
@ CCC_ObjCInstanceMessage
Code completion where an Objective-C instance message is expected.
Definition: CodeCompleteConsumer.h:317
Optional
llvm::Optional< T > Optional
Definition: ByteCodeExprGen.cpp:23
clang::CodeCompletionContext::CCC_Expression
@ CCC_Expression
Code completion occurred where an expression is expected.
Definition: CodeCompleteConsumer.h:221
clang::CodeCompletionBuilder::AddOptionalChunk
void AddOptionalChunk(CodeCompletionString *Optional)
Add a new optional chunk.
Definition: CodeCompleteConsumer.cpp:442
clang::Sema::SourceMgr
SourceManager & SourceMgr
Definition: Sema.h:414
clang::CodeCompletionAllocator::CopyString
const char * CopyString(const Twine &String)
Copy the given string into this allocator.
Definition: CodeCompleteConsumer.cpp:349
clang::PrintingCodeCompleteConsumer::isResultFilteredOut
bool isResultFilteredOut(StringRef Filter, CodeCompletionResult Results) override
Definition: CodeCompleteConsumer.cpp:521
llvm::SmallVector
Definition: LLVM.h:38
clang::AR_Deprecated
@ AR_Deprecated
Definition: DeclBase.h:78
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:88
clang::CodeCompletionContext::CCC_Type
@ CCC_Type
Code completion occurred where a type name is expected.
Definition: CodeCompleteConsumer.h:271
clang::CodeCompletionContext::CCC_ObjCImplementation
@ CCC_ObjCImplementation
Code completion occurred within an Objective-C implementation or category implementation.
Definition: CodeCompleteConsumer.h:207
clang::CodeCompletionBuilder::AddChunk
void AddChunk(CodeCompletionString::ChunkKind CK, const char *Text="")
Add a new chunk.
Definition: CodeCompleteConsumer.cpp:463
clang::CodeCompletionString::CK_Text
@ CK_Text
A piece of text that should be placed in the buffer, e.g., parentheses or a comma in a function call.
Definition: CodeCompleteConsumer.h:454
clang::tooling::Filter
llvm::cl::opt< std::string > Filter
clang::CodeCompleteConsumer::OverloadCandidate::getFunctionType
const FunctionType * getFunctionType() const
Retrieve the function type of the entity, regardless of how the function is stored.
Definition: CodeCompleteConsumer.cpp:498
Index.h
clang::CodeCompletionString::CK_RightParen
@ CK_RightParen
A right parenthesis (')').
Definition: CodeCompleteConsumer.h:481
clang::Sema::getSourceManager
SourceManager & getSourceManager() const
Definition: Sema.h:1567
CodeCompleteConsumer.h
clang::CodeCompletionString::CK_TypedText
@ CK_TypedText
The piece of text that the user is expected to type to match the code-completion string,...
Definition: CodeCompleteConsumer.h:450
llvm::Optional
Definition: LLVM.h:40
clang::ComparisonCategoryType::First
@ First
clang::CodeCompletionContext::CCC_IncludedFile
@ CCC_IncludedFile
Code completion inside the filename part of a include directive.
Definition: CodeCompleteConsumer.h:330
clang::CodeCompletionResult::RK_Keyword
@ RK_Keyword
Refers to a keyword or symbol.
Definition: CodeCompleteConsumer.h:757
clang::CodeCompletionString::Chunk::Chunk
Chunk()
Definition: CodeCompleteConsumer.h:540
clang::CodeCompletionString::CK_VerticalSpace
@ CK_VerticalSpace
Vertical whitespace ('\n' or '\r\n', depending on the platform).
Definition: CodeCompleteConsumer.h:518
clang::tooling::X
static ToolExecutorPluginRegistry::Add< AllTUsToolExecutorPlugin > X("all-TUs", "Runs FrontendActions on all TUs in the compilation database. " "Tool results are stored in memory.")
clang::Lexer::MeasureTokenLength
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:447
clang::CodeCompletionBuilder::AddTypedTextChunk
void AddTypedTextChunk(const char *Text)
Add a new typed-text chunk.
Definition: CodeCompleteConsumer.cpp:434
clang::FunctionType
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3546
clang::CodeCompletionString::CK_HorizontalSpace
@ CK_HorizontalSpace
Horizontal whitespace (' ').
Definition: CodeCompleteConsumer.h:514
clang::DeclarationName
The name of a declaration.
Definition: DeclarationName.h:145
clang::CodeCompletionString::end
iterator end() const
Definition: CodeCompleteConsumer.h:600
CXAvailability_NotAvailable
@ CXAvailability_NotAvailable
The entity is not available; any use of it will be an error.
Definition: Index.h:138
clang::CodeCompletionString::CK_ResultType
@ CK_ResultType
A piece of text that describes the type of an entity or, for functions and methods,...
Definition: CodeCompleteConsumer.h:470
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:626
clang::CodeCompletionResult
Captures a result of code completion.
Definition: CodeCompleteConsumer.h:749
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1490
Preprocessor.h
clang::Decl::getAvailability
AvailabilityResult getAvailability(std::string *Message=nullptr, VersionTuple EnclosingVersion=VersionTuple(), StringRef *RealizedPlatform=nullptr) const
Determine the availability of the given declaration.
Definition: DeclBase.cpp:622
Decl.h
DeclObjC.h
clang::CodeCompletionString::ChunkKind
ChunkKind
The different kinds of "chunks" that can occur within a code completion string.
Definition: CodeCompleteConsumer.h:446
clang::FixItHint
Annotates a diagnostic with some code that should be inserted, removed, or replaced to fix the proble...
Definition: Diagnostic.h:70
clang::CodeCompletionContext::CCC_ObjCCategoryName
@ CCC_ObjCCategoryName
Code completion where an Objective-C category name is expected.
Definition: CodeCompleteConsumer.h:327
U
clang::CodeCompletionContext::CCC_TopLevel
@ CCC_TopLevel
Code completion occurred within a "top-level" completion context, e.g., at namespace or global scope.
Definition: CodeCompleteConsumer.h:199
clang::CodeCompletionString::CK_LeftAngle
@ CK_LeftAngle
A left angle bracket ('<').
Definition: CodeCompleteConsumer.h:496
clang::SourceLocation::print
void print(raw_ostream &OS, const SourceManager &SM) const
Definition: SourceLocation.cpp:62
clang::Decl::Kind
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:92
clang::CodeCompletionBuilder::AddCurrentParameterChunk
void AddCurrentParameterChunk(const char *CurrentParameter)
Add a new current-parameter chunk.
Definition: CodeCompleteConsumer.cpp:458
clang::AR_Available
@ AR_Available
Definition: DeclBase.h:76
clang::CodeCompletionContext::CCC_Recovery
@ CCC_Recovery
An unknown context, in which we are recovering from a parsing error and don't know which completions ...
Definition: CodeCompleteConsumer.h:337
clang::CodeCompletionString::CK_RightBracket
@ CK_RightBracket
A right bracket (']').
Definition: CodeCompleteConsumer.h:487
DeclTemplate.h
clang::CodeCompletionContext::CCC_ObjCProtocolName
@ CCC_ObjCProtocolName
Code completion occurred where a protocol name is expected.
Definition: CodeCompleteConsumer.h:264
clang::CodeCompletionContext::CCC_EnumTag
@ CCC_EnumTag
Code completion occurred after the "enum" keyword, to indicate an enumeration name.
Definition: CodeCompleteConsumer.h:253
Id
int Id
Definition: ASTDiff.cpp:191
clang::CodeCompletionString::Chunk::CreateOptional
static Chunk CreateOptional(CodeCompletionString *Optional)
Create a new optional chunk.
Definition: CodeCompleteConsumer.cpp:256
DeclBase.h
CXCursor_NotImplemented
@ CXCursor_NotImplemented
Definition: Index.h:1904
getOverloadAsString
static std::string getOverloadAsString(const CodeCompletionString &CCS)
Definition: CodeCompleteConsumer.cpp:620
CXCursor_ObjCProtocolDecl
@ CXCursor_ObjCProtocolDecl
An Objective-C @protocol declaration.
Definition: Index.h:1744
clang::CodeCompletionContext::CCC_ArrowMemberAccess
@ CCC_ArrowMemberAccess
Code completion occurred on the right-hand side of a member access expression using the arrow operato...
Definition: CodeCompleteConsumer.h:241
clang::CodeCompletionContext::CCC_Symbol
@ CCC_Symbol
Code completion occurred where an existing name(such as type, function or variable) is expected.
Definition: CodeCompleteConsumer.h:282
clang::CodeCompletionBuilder::AddTextChunk
void AddTextChunk(const char *Text)
Add a new text chunk.
Definition: CodeCompleteConsumer.cpp:438
clang::CodeCompletionString::Chunk::CreateResultType
static Chunk CreateResultType(const char *ResultType)
Create a new result type chunk.
Definition: CodeCompleteConsumer.cpp:274
CXAvailability_NotAccessible
@ CXAvailability_NotAccessible
The entity is available, but not accessible; any use of it will be an error.
Definition: Index.h:143
clang::Type::getAs
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:7162
clang::CodeCompletionContext::CCC_ObjCInterfaceName
@ CCC_ObjCInterfaceName
Code completion where the name of an Objective-C class is expected.
Definition: CodeCompleteConsumer.h:324
uintptr_t
__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-base.h:124
clang::CodeCompletionString::CK_Informative
@ CK_Informative
A piece of text that describes something about the result but should not be inserted into the buffer.
Definition: CodeCompleteConsumer.h:467
IdentifierTable.h
clang::DeclContext::isTranslationUnit
bool isTranslationUnit() const
Definition: DeclBase.h:1935
Type.h
clang::CodeCompletionContext::CCC_Attribute
@ CCC_Attribute
Code completion of an attribute name.
Definition: CodeCompleteConsumer.h:333
llvm::SmallString< 128 >
clang::CodeCompletionString::CK_LeftParen
@ CK_LeftParen
A left parenthesis ('(').
Definition: CodeCompleteConsumer.h:478
clang::CodeCompletionContext::CCC_ObjCMessageReceiver
@ CCC_ObjCMessageReceiver
Code completion occurred where an Objective-C message receiver is expected.
Definition: CodeCompleteConsumer.h:225
clang::Preprocessor::getCodeCompletionFilter
StringRef getCodeCompletionFilter()
Get the code completion token for filtering purposes.
Definition: Preprocessor.h:1298
clang::CodeCompletionString::getAsString
std::string getAsString() const
Retrieve a string representation of the code completion string, which is mainly useful for debugging.
Definition: CodeCompleteConsumer.cpp:314
getKind
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:998
Sema.h
clang::CodeCompletionString
A "string" used to describe how code completion can be performed for an entity.
Definition: CodeCompleteConsumer.h:442
clang::CodeCompletionString::Chunk::CreateCurrentParameter
static Chunk CreateCurrentParameter(const char *CurrentParameter)
Create a new current-parameter chunk.
Definition: CodeCompleteConsumer.cpp:278
clang::Sema::LangOpts
const LangOptions & LangOpts
Definition: Sema.h:409
clang::CodeCompletionContext::CCC_OtherWithMacros
@ CCC_OtherWithMacros
An unspecified code-completion context where we should also add macro completions.
Definition: CodeCompleteConsumer.h:195
clang::CodeCompletionBuilder::AddResultTypeChunk
void AddResultTypeChunk(const char *ResultType)
Add a new result-type chunk.
Definition: CodeCompleteConsumer.cpp:454
clang::CodeCompletionContext::CCC_Namespace
@ CCC_Namespace
Code completion occurred where a namespace or namespace alias is expected.
Definition: CodeCompleteConsumer.h:268
clang::CodeCompletionResult::RK_Macro
@ RK_Macro
Refers to a macro.
Definition: CodeCompleteConsumer.h:760
clang::CodeCompleteConsumer::OverloadCandidate
Definition: CodeCompleteConsumer.h:1005
clang::CodeCompletionString::CK_RightBrace
@ CK_RightBrace
A right brace ('}').
Definition: CodeCompleteConsumer.h:493
clang::CodeCompletionContext::CCC_ObjCPropertyAccess
@ CCC_ObjCPropertyAccess
Code completion occurred on the right-hand side of an Objective-C property access expression.
Definition: CodeCompleteConsumer.h:249
clang::CodeCompletionString::Chunk::Kind
ChunkKind Kind
The kind of data stored in this piece of the code completion string.
Definition: CodeCompleteConsumer.h:525
clang::CodeCompletionString::CK_SemiColon
@ CK_SemiColon
A semicolon (';').
Definition: CodeCompleteConsumer.h:508
clang::CodeCompletionContext::CCC_PreprocessorExpression
@ CCC_PreprocessorExpression
Code completion occurred within a preprocessor expression.
Definition: CodeCompleteConsumer.h:292
clang::NamedDecl::getIdentifier
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:270
CXAvailability_Available
@ CXAvailability_Available
The entity is available.
Definition: Index.h:129
clang::DeclContext::getParent
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1860
clang::PrintingCodeCompleteConsumer::ProcessOverloadCandidates
void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, OverloadCandidate *Candidates, unsigned NumCandidates, SourceLocation OpenParLoc) override
Definition: CodeCompleteConsumer.cpp:647
CXAvailabilityKind
CXAvailabilityKind
Describes the availability of a particular entity, which indicates whether the use of this entity wil...
Definition: Index.h:125
clang::CodeCompletionString::getTypedText
const char * getTypedText() const
Returns the text in the TypedText chunk.
Definition: CodeCompleteConsumer.cpp:341
clang::frontend::FixIt
@ FixIt
Parse and apply any fixits to the source.
Definition: FrontendOptions.h:79
clang::CodeCompletionContext::CCC_PreprocessorDirective
@ CCC_PreprocessorDirective
Code completion occurred where a preprocessor directive is expected.
Definition: CodeCompleteConsumer.h:296
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:89
clang::PrintingCodeCompleteConsumer::ProcessCodeCompleteResults
void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context, CodeCompletionResult *Results, unsigned NumResults) override
Prints the finalized code-completion results.
Definition: CodeCompleteConsumer.cpp:538
clang::CodeCompletionString::CK_Equal
@ CK_Equal
An '=' sign.
Definition: CodeCompleteConsumer.h:511
clang::Sema
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:355
clang::CodeCompletionContext::CCC_ClassStructUnion
@ CCC_ClassStructUnion
Code completion occurred within a class, struct, or union.
Definition: CodeCompleteConsumer.h:214
clang::CodeCompletionContext::CCC_Statement
@ CCC_Statement
Code completion occurred where a statement (or declaration) is expected in a function,...
Definition: CodeCompleteConsumer.h:218
clang::CodeCompletionContext::CCC_DotMemberAccess
@ CCC_DotMemberAccess
Code completion occurred on the right-hand side of a member access expression using the dot operator.
Definition: CodeCompleteConsumer.h:233
clang::CodeCompletionString::CK_CurrentParameter
@ CK_CurrentParameter
A piece of text that describes the parameter that corresponds to the code-completion location within ...
Definition: CodeCompleteConsumer.h:475
clang::CodeCompletionString::getAnnotation
const char * getAnnotation(unsigned AnnotationNr) const
Retrieve the annotation string specified by AnnotationNr.
Definition: CodeCompleteConsumer.cpp:307
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:67
Priority
int Priority
Definition: Format.cpp:2337
clang::CodeCompletionString::CK_LeftBracket
@ CK_LeftBracket
A left bracket ('[').
Definition: CodeCompleteConsumer.h:484
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang::CodeCompletionResult::RK_Pattern
@ RK_Pattern
Refers to a precomputed pattern.
Definition: CodeCompleteConsumer.h:763
clang::Sema::getPreprocessor
Preprocessor & getPreprocessor() const
Definition: Sema.h:1568
DeclarationName.h
clang::CodeCompletionString::Chunk::CreatePlaceholder
static Chunk CreatePlaceholder(const char *Placeholder)
Create a new placeholder chunk.
Definition: CodeCompleteConsumer.cpp:264
clang::CodeCompletionContext::CCC_NaturalLanguage
@ CCC_NaturalLanguage
Code completion occurred in a context where natural language is expected, e.g., a comment or string l...
Definition: CodeCompleteConsumer.h:303
clang::CodeCompletionString::CK_Placeholder
@ CK_Placeholder
A string that acts as a placeholder for, e.g., a function call argument.
Definition: CodeCompleteConsumer.h:463
clang::AR_NotYetIntroduced
@ AR_NotYetIntroduced
Definition: DeclBase.h:77
clang::IdentifierInfo::getName
StringRef getName() const
Return the actual identifier string.
Definition: IdentifierTable.h:175
clang::AR_Unavailable
@ AR_Unavailable
Definition: DeclBase.h:79
clang
Definition: CalledOnceCheck.h:17
Text
StringRef Text
Definition: Format.cpp:2334
clang::CodeCompletionContext::CCC_NewName
@ CCC_NewName
Code completion occurred where a new name is expected.
Definition: CodeCompleteConsumer.h:274
clang::CodeCompletionString::Chunk::CreateInformative
static Chunk CreateInformative(const char *Informative)
Create a new informative chunk.
Definition: CodeCompleteConsumer.cpp:269
clang::AvailabilityResult
AvailabilityResult
Captures the result of checking the availability of a declaration.
Definition: DeclBase.h:75
clang::CodeCompletionResult::getOrderedName
StringRef getOrderedName(std::string &Saved) const
Retrieve the name that should be used to order a result.
Definition: CodeCompleteConsumer.cpp:729
clang::operator<
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
Definition: DeclarationName.h:540
clang::CodeCompletionBuilder::AddPlaceholderChunk
void AddPlaceholderChunk(const char *Placeholder)
Add a new placeholder chunk.
Definition: CodeCompleteConsumer.cpp:446
clang::CodeCompletionBuilder::addBriefComment
void addBriefComment(StringRef Comment)
Definition: CodeCompleteConsumer.cpp:481
CXCursor_UnexposedDecl
@ CXCursor_UnexposedDecl
A declaration whose specific kind is not exposed via this interface.
Definition: Index.h:1717
clang::CodeCompletionContext::CCC_ObjCIvarList
@ CCC_ObjCIvarList
Code completion occurred within the instance variable list of an Objective-C interface,...
Definition: CodeCompleteConsumer.h:211
clang::CodeCompletionString::CK_RightAngle
@ CK_RightAngle
A right angle bracket ('>').
Definition: CodeCompleteConsumer.h:499
clang::CodeCompletionResult::RK_Declaration
@ RK_Declaration
Refers to a declaration.
Definition: CodeCompleteConsumer.h:754
CXAvailability_Deprecated
@ CXAvailability_Deprecated
The entity is available, but has been deprecated (and its use is not recommended).
Definition: Index.h:134
clang::CodeCompletionContext::CCC_ParenthesizedExpression
@ CCC_ParenthesizedExpression
Code completion in a parenthesized expression, which means that we may also have types here in C and ...
Definition: CodeCompleteConsumer.h:313
clang::CodeCompletionString::Chunk::CreateText
static Chunk CreateText(const char *Text)
Create a new text chunk.
Definition: CodeCompleteConsumer.cpp:251
clang::CodeCompletionContext::wantConstructorResults
bool wantConstructorResults() const
Determines whether we want C++ constructors as results within this context.
Definition: CodeCompleteConsumer.cpp:45
clang::CodeCompletionString::Chunk
One piece of the code completion string.
Definition: CodeCompleteConsumer.h:522
clang::CodeCompletionContext::CCC_SelectorName
@ CCC_SelectorName
Code completion for a selector, as in an @selector expression.
Definition: CodeCompleteConsumer.h:306
clang::CodeCompleteConsumer::~CodeCompleteConsumer
virtual ~CodeCompleteConsumer()
Deregisters and destroys this code-completion consumer.
clang::index::SymbolKind::Function
@ Function
clang::CodeCompletionString::CK_Optional
@ CK_Optional
A code completion string that is entirely optional.
Definition: CodeCompleteConsumer.h:459
clang::getCursorKindForDecl
CXCursorKind getCursorKindForDecl(const Decl *D)
Determine the libclang cursor kind associated with the given declaration.
Definition: SemaCodeComplete.cpp:3838
clang::CodeCompletionContext
The context in which code completion occurred, so that the code-completion consumer can process the r...
Definition: CodeCompleteConsumer.h:187
clang::getCompletionKindString
llvm::StringRef getCompletionKindString(CodeCompletionContext::Kind Kind)
Get string representation of Kind, useful for for debugging.
Definition: CodeCompleteConsumer.cpp:92
clang::CodeCompletionBuilder::AddInformativeChunk
void AddInformativeChunk(const char *Text)
Add a new informative chunk.
Definition: CodeCompleteConsumer.cpp:450
clang::CodeCompletionString::CK_LeftBrace
@ CK_LeftBrace
A left brace ('{').
Definition: CodeCompleteConsumer.h:490
clang::CodeCompletionTUInfo::getParentName
StringRef getParentName(const DeclContext *DC)
Definition: CodeCompleteConsumer.cpp:361
SM
#define SM(sm)
Definition: Cuda.cpp:78
CXCursor_ObjCInterfaceDecl
@ CXCursor_ObjCInterfaceDecl
An Objective-C @interface.
Definition: Index.h:1740
clang::DeclContext::isFunctionOrMethod
bool isFunctionOrMethod() const
Definition: DeclBase.h:1912
clang::CodeCompletionString::CK_Colon
@ CK_Colon
A colon (':').
Definition: CodeCompleteConsumer.h:505
clang::CodeCompletionString::CK_Comma
@ CK_Comma
A comma separator (',').
Definition: CodeCompleteConsumer.h:502
clang::CodeCompletionString::Chunk::Text
const char * Text
The text string associated with a CK_Text, CK_Placeholder, CK_Informative, or CK_Comma chunk.
Definition: CodeCompleteConsumer.h:532
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1856
getDeclAvailability
static AvailabilityResult getDeclAvailability(const Decl *D)
Retrieve the effective availability of the given declaration.
Definition: CodeCompleteConsumer.cpp:664
clang::CodeCompletionContext::CCC_UnionTag
@ CCC_UnionTag
Code completion occurred after the "union" keyword, to indicate a union name.
Definition: CodeCompleteConsumer.h:257
clang::CodeCompleteConsumer::OverloadCandidate::getFunction
FunctionDecl * getFunction() const
Retrieve the function overload candidate or the templated function declaration for a function templat...
Definition: CodeCompleteConsumer.cpp:488
clang::CodeCompletionContext::CCC_MacroName
@ CCC_MacroName
Code completion occurred where an macro is being defined.
Definition: CodeCompleteConsumer.h:285
clang::CodeCompletionContext::CCC_ObjCClassMessage
@ CCC_ObjCClassMessage
Code completion where an Objective-C class message is expected.
Definition: CodeCompleteConsumer.h:320
clang::CodeCompletionContext::CCC_ObjCInterface
@ CCC_ObjCInterface
Code completion occurred within an Objective-C interface, protocol, or category interface.
Definition: CodeCompleteConsumer.h:203
clang::CodeCompletionContext::CCC_ClassOrStructTag
@ CCC_ClassOrStructTag
Code completion occurred after the "struct" or "class" keyword, to indicate a struct or class name.
Definition: CodeCompleteConsumer.h:261
clang::CodeCompletionContext::CCC_TypeQualifiers
@ CCC_TypeQualifiers
Code completion within a type-qualifier list.
Definition: CodeCompleteConsumer.h:309
clang::CodeCompletionContext::CCC_MacroNameUse
@ CCC_MacroNameUse
Code completion occurred where a macro name is expected (without any arguments, in the case of a func...
Definition: CodeCompleteConsumer.h:289
clang::Decl::getDeclContext
DeclContext * getDeclContext()
Definition: DeclBase.h:439
clang::NamedDecl::getName
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:276