clang  9.0.0svn
CodeCompleteConsumer.h
Go to the documentation of this file.
1 //===- CodeCompleteConsumer.h - Code Completion Interface -------*- C++ -*-===//
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 defines the CodeCompleteConsumer class.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_CLANG_SEMA_CODECOMPLETECONSUMER_H
14 #define LLVM_CLANG_SEMA_CODECOMPLETECONSUMER_H
15 
16 #include "clang-c/Index.h"
17 #include "clang/AST/Type.h"
18 #include "clang/Basic/LLVM.h"
19 #include "clang/Lex/MacroInfo.h"
21 #include "clang/Sema/DeclSpec.h"
22 #include "llvm/ADT/ArrayRef.h"
23 #include "llvm/ADT/DenseMap.h"
24 #include "llvm/ADT/None.h"
25 #include "llvm/ADT/Optional.h"
26 #include "llvm/ADT/SmallPtrSet.h"
27 #include "llvm/ADT/SmallVector.h"
28 #include "llvm/ADT/StringRef.h"
29 #include "llvm/Support/Allocator.h"
30 #include "llvm/Support/type_traits.h"
31 #include <cassert>
32 #include <memory>
33 #include <string>
34 #include <utility>
35 
36 namespace clang {
37 
38 class ASTContext;
39 class Decl;
40 class DeclContext;
41 class FunctionDecl;
42 class FunctionTemplateDecl;
43 class IdentifierInfo;
44 class LangOptions;
45 class NamedDecl;
46 class NestedNameSpecifier;
47 class Preprocessor;
48 class RawComment;
49 class Sema;
50 class UsingShadowDecl;
51 
52 /// Default priority values for code-completion results based
53 /// on their kind.
54 enum {
55  /// Priority for the next initialization in a constructor initializer
56  /// list.
58 
59  /// Priority for an enumeration constant inside a switch whose
60  /// condition is of the enumeration type.
62 
63  /// Priority for a send-to-super completion.
65 
66  /// Priority for a declaration that is in the local scope.
68 
69  /// Priority for a member declaration found from the current
70  /// method or member function.
72 
73  /// Priority for a language keyword (that isn't any of the other
74  /// categories).
76 
77  /// Priority for a code pattern.
79 
80  /// Priority for a non-type declaration.
82 
83  /// Priority for a type.
85 
86  /// Priority for a constant value (e.g., enumerator).
88 
89  /// Priority for a preprocessor macro.
90  CCP_Macro = 70,
91 
92  /// Priority for a nested-name-specifier.
94 
95  /// Priority for a result that isn't likely to be what the user wants,
96  /// but is included for completeness.
98 
99  /// Priority for the Objective-C "_cmd" implicit parameter.
101 };
102 
103 /// Priority value deltas that are added to code-completion results
104 /// based on the context of the result.
105 enum {
106  /// The result is in a base class.
108 
109  /// The result is a C++ non-static member function whose qualifiers
110  /// exactly match the object type on which the member function can be called.
112 
113  /// The selector of the given message exactly matches the selector
114  /// of the current method, which might imply that some kind of delegation
115  /// is occurring.
117 
118  /// Adjustment to the "bool" type in Objective-C, where the typedef
119  /// "BOOL" is preferred.
121 
122  /// Adjustment for KVC code pattern priorities when it doesn't look
123  /// like the
125 
126  /// An Objective-C method being used as a property.
128 
129  /// An Objective-C block property completed as a setter with a
130  /// block placeholder.
132 };
133 
134 /// Priority value factors by which we will divide or multiply the
135 /// priority of a code-completion result.
136 enum {
137  /// Divide by this factor when a code-completion result's type exactly
138  /// matches the type we expect.
140 
141  /// Divide by this factor when a code-completion result's type is
142  /// similar to the type we expect (e.g., both arithmetic types, both
143  /// Objective-C object pointer types).
145 };
146 
147 /// A simplified classification of types used when determining
148 /// "similar" types for code completion.
159 };
160 
161 /// Determine the simplified type class of the given canonical type.
163 
164 /// Determine the type that this declaration will have if it is used
165 /// as a type or in an expression.
167 
168 /// Determine the priority to be given to a macro code completion result
169 /// with the given name.
170 ///
171 /// \param MacroName The name of the macro.
172 ///
173 /// \param LangOpts Options describing the current language dialect.
174 ///
175 /// \param PreferredTypeIsPointer Whether the preferred type for the context
176 /// of this macro is a pointer type.
177 unsigned getMacroUsagePriority(StringRef MacroName,
178  const LangOptions &LangOpts,
179  bool PreferredTypeIsPointer = false);
180 
181 /// Determine the libclang cursor kind associated with the given
182 /// declaration.
184 
185 /// The context in which code completion occurred, so that the
186 /// code-completion consumer can process the results accordingly.
188 public:
189  enum Kind {
190  /// An unspecified code-completion context.
192 
193  /// An unspecified code-completion context where we should also add
194  /// macro completions.
196 
197  /// Code completion occurred within a "top-level" completion context,
198  /// e.g., at namespace or global scope.
200 
201  /// Code completion occurred within an Objective-C interface,
202  /// protocol, or category interface.
204 
205  /// Code completion occurred within an Objective-C implementation
206  /// or category implementation.
208 
209  /// Code completion occurred within the instance variable list of
210  /// an Objective-C interface, implementation, or category implementation.
212 
213  /// Code completion occurred within a class, struct, or union.
215 
216  /// Code completion occurred where a statement (or declaration) is
217  /// expected in a function, method, or block.
219 
220  /// Code completion occurred where an expression is expected.
222 
223  /// Code completion occurred where an Objective-C message receiver
224  /// is expected.
226 
227  /// Code completion occurred on the right-hand side of a member
228  /// access expression using the dot operator.
229  ///
230  /// The results of this completion are the members of the type being
231  /// accessed. The type itself is available via
232  /// \c CodeCompletionContext::getType().
234 
235  /// Code completion occurred on the right-hand side of a member
236  /// access expression using the arrow operator.
237  ///
238  /// The results of this completion are the members of the type being
239  /// accessed. The type itself is available via
240  /// \c CodeCompletionContext::getType().
242 
243  /// Code completion occurred on the right-hand side of an Objective-C
244  /// property access expression.
245  ///
246  /// The results of this completion are the members of the type being
247  /// accessed. The type itself is available via
248  /// \c CodeCompletionContext::getType().
250 
251  /// Code completion occurred after the "enum" keyword, to indicate
252  /// an enumeration name.
254 
255  /// Code completion occurred after the "union" keyword, to indicate
256  /// a union name.
258 
259  /// Code completion occurred after the "struct" or "class" keyword,
260  /// to indicate a struct or class name.
262 
263  /// Code completion occurred where a protocol name is expected.
265 
266  /// Code completion occurred where a namespace or namespace alias
267  /// is expected.
269 
270  /// Code completion occurred where a type name is expected.
272 
273  /// Code completion occurred where a new name is expected.
275 
276  /// Code completion occurred where both a new name and an existing symbol is
277  /// permissible.
279 
280  /// Code completion occurred where an existing name(such as type, function
281  /// or variable) is expected.
283 
284  /// Code completion occurred where an macro is being defined.
286 
287  /// Code completion occurred where a macro name is expected
288  /// (without any arguments, in the case of a function-like macro).
290 
291  /// Code completion occurred within a preprocessor expression.
293 
294  /// Code completion occurred where a preprocessor directive is
295  /// expected.
297 
298  /// Code completion occurred in a context where natural language is
299  /// expected, e.g., a comment or string literal.
300  ///
301  /// This context usually implies that no completions should be added,
302  /// unless they come from an appropriate natural-language dictionary.
304 
305  /// Code completion for a selector, as in an \@selector expression.
307 
308  /// Code completion within a type-qualifier list.
310 
311  /// Code completion in a parenthesized expression, which means that
312  /// we may also have types here in C and Objective-C (as well as in C++).
314 
315  /// Code completion where an Objective-C instance message is
316  /// expected.
318 
319  /// Code completion where an Objective-C class message is expected.
321 
322  /// Code completion where the name of an Objective-C class is
323  /// expected.
325 
326  /// Code completion where an Objective-C category name is expected.
328 
329  /// Code completion inside the filename part of a #include directive.
331 
332  /// An unknown context, in which we are recovering from a parsing
333  /// error and don't know which completions we should give.
335  };
336 
337  using VisitedContextSet = llvm::SmallPtrSet<DeclContext *, 8>;
338 
339 private:
340  Kind CCKind;
341 
342  /// The type that would prefer to see at this point (e.g., the type
343  /// of an initializer or function parameter).
344  QualType PreferredType;
345 
346  /// The type of the base object in a member access expression.
347  QualType BaseType;
348 
349  /// The identifiers for Objective-C selector parts.
350  ArrayRef<IdentifierInfo *> SelIdents;
351 
352  /// The scope specifier that comes before the completion token e.g.
353  /// "a::b::"
354  llvm::Optional<CXXScopeSpec> ScopeSpecifier;
355 
356  /// A set of declaration contexts visited by Sema when doing lookup for
357  /// code completion.
358  VisitedContextSet VisitedContexts;
359 
360 public:
361  /// Construct a new code-completion context of the given kind.
362  CodeCompletionContext(Kind CCKind) : CCKind(CCKind), SelIdents(None) {}
363 
364  /// Construct a new code-completion context of the given kind.
366  ArrayRef<IdentifierInfo *> SelIdents = None)
367  : CCKind(CCKind), SelIdents(SelIdents) {
368  if (CCKind == CCC_DotMemberAccess || CCKind == CCC_ArrowMemberAccess ||
369  CCKind == CCC_ObjCPropertyAccess || CCKind == CCC_ObjCClassMessage ||
370  CCKind == CCC_ObjCInstanceMessage)
371  BaseType = T;
372  else
373  PreferredType = T;
374  }
375 
376  /// Retrieve the kind of code-completion context.
377  Kind getKind() const { return CCKind; }
378 
379  /// Retrieve the type that this expression would prefer to have, e.g.,
380  /// if the expression is a variable initializer or a function argument, the
381  /// type of the corresponding variable or function parameter.
382  QualType getPreferredType() const { return PreferredType; }
383  void setPreferredType(QualType T) { PreferredType = T; }
384 
385  /// Retrieve the type of the base object in a member-access
386  /// expression.
387  QualType getBaseType() const { return BaseType; }
388 
389  /// Retrieve the Objective-C selector identifiers.
390  ArrayRef<IdentifierInfo *> getSelIdents() const { return SelIdents; }
391 
392  /// Determines whether we want C++ constructors as results within this
393  /// context.
394  bool wantConstructorResults() const;
395 
396  /// Sets the scope specifier that comes before the completion token.
397  /// This is expected to be set in code completions on qualfied specifiers
398  /// (e.g. "a::b::").
400  this->ScopeSpecifier = std::move(SS);
401  }
402 
403  /// Adds a visited context.
405  VisitedContexts.insert(Ctx);
406  }
407 
408  /// Retrieves all visited contexts.
410  return VisitedContexts;
411  }
412 
414  if (ScopeSpecifier)
415  return ScopeSpecifier.getPointer();
416  return llvm::None;
417  }
418 };
419 
420 /// Get string representation of \p Kind, useful for for debugging.
422 
423 /// A "string" used to describe how code completion can
424 /// be performed for an entity.
425 ///
426 /// A code completion string typically shows how a particular entity can be
427 /// used. For example, the code completion string for a function would show
428 /// the syntax to call it, including the parentheses, placeholders for the
429 /// arguments, etc.
431 public:
432  /// The different kinds of "chunks" that can occur within a code
433  /// completion string.
434  enum ChunkKind {
435  /// The piece of text that the user is expected to type to
436  /// match the code-completion string, typically a keyword or the name of a
437  /// declarator or macro.
439 
440  /// A piece of text that should be placed in the buffer, e.g.,
441  /// parentheses or a comma in a function call.
443 
444  /// A code completion string that is entirely optional. For example,
445  /// an optional code completion string that describes the default arguments
446  /// in a function call.
448 
449  /// A string that acts as a placeholder for, e.g., a function
450  /// call argument.
452 
453  /// A piece of text that describes something about the result but
454  /// should not be inserted into the buffer.
456  /// A piece of text that describes the type of an entity or, for
457  /// functions and methods, the return type.
459 
460  /// A piece of text that describes the parameter that corresponds
461  /// to the code-completion location within a function call, message send,
462  /// macro invocation, etc.
464 
465  /// A left parenthesis ('(').
467 
468  /// A right parenthesis (')').
470 
471  /// A left bracket ('[').
473 
474  /// A right bracket (']').
476 
477  /// A left brace ('{').
479 
480  /// A right brace ('}').
482 
483  /// A left angle bracket ('<').
485 
486  /// A right angle bracket ('>').
488 
489  /// A comma separator (',').
491 
492  /// A colon (':').
494 
495  /// A semicolon (';').
497 
498  /// An '=' sign.
500 
501  /// Horizontal whitespace (' ').
503 
504  /// Vertical whitespace ('\\n' or '\\r\\n', depending on the
505  /// platform).
506  CK_VerticalSpace
507  };
508 
509  /// One piece of the code completion string.
510  struct Chunk {
511  /// The kind of data stored in this piece of the code completion
512  /// string.
513  ChunkKind Kind = CK_Text;
514 
515  union {
516  /// The text string associated with a CK_Text, CK_Placeholder,
517  /// CK_Informative, or CK_Comma chunk.
518  /// The string is owned by the chunk and will be deallocated
519  /// (with delete[]) when the chunk is destroyed.
520  const char *Text;
521 
522  /// The code completion string associated with a CK_Optional chunk.
523  /// The optional code completion string is owned by the chunk, and will
524  /// be deallocated (with delete) when the chunk is destroyed.
526  };
527 
528  Chunk() : Text(nullptr) {}
529 
530  explicit Chunk(ChunkKind Kind, const char *Text = "");
531 
532  /// Create a new text chunk.
533  static Chunk CreateText(const char *Text);
534 
535  /// Create a new optional chunk.
536  static Chunk CreateOptional(CodeCompletionString *Optional);
537 
538  /// Create a new placeholder chunk.
539  static Chunk CreatePlaceholder(const char *Placeholder);
540 
541  /// Create a new informative chunk.
542  static Chunk CreateInformative(const char *Informative);
543 
544  /// Create a new result type chunk.
545  static Chunk CreateResultType(const char *ResultType);
546 
547  /// Create a new current-parameter chunk.
548  static Chunk CreateCurrentParameter(const char *CurrentParameter);
549  };
550 
551 private:
552  friend class CodeCompletionBuilder;
553  friend class CodeCompletionResult;
554 
555  /// The number of chunks stored in this string.
556  unsigned NumChunks : 16;
557 
558  /// The number of annotations for this code-completion result.
559  unsigned NumAnnotations : 16;
560 
561  /// The priority of this code-completion string.
562  unsigned Priority : 16;
563 
564  /// The availability of this code-completion result.
565  unsigned Availability : 2;
566 
567  /// The name of the parent context.
568  StringRef ParentName;
569 
570  /// A brief documentation comment attached to the declaration of
571  /// entity being completed by this result.
572  const char *BriefComment;
573 
574  CodeCompletionString(const Chunk *Chunks, unsigned NumChunks,
575  unsigned Priority, CXAvailabilityKind Availability,
576  const char **Annotations, unsigned NumAnnotations,
577  StringRef ParentName,
578  const char *BriefComment);
579  ~CodeCompletionString() = default;
580 
581 public:
582  CodeCompletionString(const CodeCompletionString &) = delete;
583  CodeCompletionString &operator=(const CodeCompletionString &) = delete;
584 
585  using iterator = const Chunk *;
586 
587  iterator begin() const { return reinterpret_cast<const Chunk *>(this + 1); }
588  iterator end() const { return begin() + NumChunks; }
589  bool empty() const { return NumChunks == 0; }
590  unsigned size() const { return NumChunks; }
591 
592  const Chunk &operator[](unsigned I) const {
593  assert(I < size() && "Chunk index out-of-range");
594  return begin()[I];
595  }
596 
597  /// Returns the text in the TypedText chunk.
598  const char *getTypedText() const;
599 
600  /// Retrieve the priority of this code completion result.
601  unsigned getPriority() const { return Priority; }
602 
603  /// Retrieve the availability of this code completion result.
604  unsigned getAvailability() const { return Availability; }
605 
606  /// Retrieve the number of annotations for this code completion result.
607  unsigned getAnnotationCount() const;
608 
609  /// Retrieve the annotation string specified by \c AnnotationNr.
610  const char *getAnnotation(unsigned AnnotationNr) const;
611 
612  /// Retrieve the name of the parent context.
613  StringRef getParentContextName() const {
614  return ParentName;
615  }
616 
617  const char *getBriefComment() const {
618  return BriefComment;
619  }
620 
621  /// Retrieve a string representation of the code completion string,
622  /// which is mainly useful for debugging.
623  std::string getAsString() const;
624 };
625 
626 /// An allocator used specifically for the purpose of code completion.
627 class CodeCompletionAllocator : public llvm::BumpPtrAllocator {
628 public:
629  /// Copy the given string into this allocator.
630  const char *CopyString(const Twine &String);
631 };
632 
633 /// Allocator for a cached set of global code completions.
635 
637  llvm::DenseMap<const DeclContext *, StringRef> ParentNames;
638  std::shared_ptr<GlobalCodeCompletionAllocator> AllocatorRef;
639 
640 public:
642  std::shared_ptr<GlobalCodeCompletionAllocator> Allocator)
643  : AllocatorRef(std::move(Allocator)) {}
644 
645  std::shared_ptr<GlobalCodeCompletionAllocator> getAllocatorRef() const {
646  return AllocatorRef;
647  }
648 
650  assert(AllocatorRef);
651  return *AllocatorRef;
652  }
653 
654  StringRef getParentName(const DeclContext *DC);
655 };
656 
657 } // namespace clang
658 
659 namespace clang {
660 
661 /// A builder class used to construct new code-completion strings.
663 public:
665 
666 private:
667  CodeCompletionAllocator &Allocator;
668  CodeCompletionTUInfo &CCTUInfo;
669  unsigned Priority = 0;
671  StringRef ParentName;
672  const char *BriefComment = nullptr;
673 
674  /// The chunks stored in this string.
675  SmallVector<Chunk, 4> Chunks;
676 
677  SmallVector<const char *, 2> Annotations;
678 
679 public:
681  CodeCompletionTUInfo &CCTUInfo)
682  : Allocator(Allocator), CCTUInfo(CCTUInfo) {}
683 
685  CodeCompletionTUInfo &CCTUInfo,
686  unsigned Priority, CXAvailabilityKind Availability)
687  : Allocator(Allocator), CCTUInfo(CCTUInfo), Priority(Priority),
688  Availability(Availability) {}
689 
690  /// Retrieve the allocator into which the code completion
691  /// strings should be allocated.
692  CodeCompletionAllocator &getAllocator() const { return Allocator; }
693 
694  CodeCompletionTUInfo &getCodeCompletionTUInfo() const { return CCTUInfo; }
695 
696  /// Take the resulting completion string.
697  ///
698  /// This operation can only be performed once.
699  CodeCompletionString *TakeString();
700 
701  /// Add a new typed-text chunk.
702  void AddTypedTextChunk(const char *Text);
703 
704  /// Add a new text chunk.
705  void AddTextChunk(const char *Text);
706 
707  /// Add a new optional chunk.
708  void AddOptionalChunk(CodeCompletionString *Optional);
709 
710  /// Add a new placeholder chunk.
711  void AddPlaceholderChunk(const char *Placeholder);
712 
713  /// Add a new informative chunk.
714  void AddInformativeChunk(const char *Text);
715 
716  /// Add a new result-type chunk.
717  void AddResultTypeChunk(const char *ResultType);
718 
719  /// Add a new current-parameter chunk.
720  void AddCurrentParameterChunk(const char *CurrentParameter);
721 
722  /// Add a new chunk.
723  void AddChunk(CodeCompletionString::ChunkKind CK, const char *Text = "");
724 
725  void AddAnnotation(const char *A) { Annotations.push_back(A); }
726 
727  /// Add the parent context information to this code completion.
728  void addParentContext(const DeclContext *DC);
729 
730  const char *getBriefComment() const { return BriefComment; }
731  void addBriefComment(StringRef Comment);
732 
733  StringRef getParentName() const { return ParentName; }
734 };
735 
736 /// Captures a result of code completion.
738 public:
739  /// Describes the kind of result generated.
740  enum ResultKind {
741  /// Refers to a declaration.
742  RK_Declaration = 0,
743 
744  /// Refers to a keyword or symbol.
746 
747  /// Refers to a macro.
749 
750  /// Refers to a precomputed pattern.
751  RK_Pattern
752  };
753 
754  /// When Kind == RK_Declaration or RK_Pattern, the declaration we are
755  /// referring to. In the latter case, the declaration might be NULL.
756  const NamedDecl *Declaration = nullptr;
757 
758  union {
759  /// When Kind == RK_Keyword, the string representing the keyword
760  /// or symbol's spelling.
761  const char *Keyword;
762 
763  /// When Kind == RK_Pattern, the code-completion string that
764  /// describes the completion text to insert.
766 
767  /// When Kind == RK_Macro, the identifier that refers to a macro.
769  };
770 
771  /// The priority of this particular code-completion result.
772  unsigned Priority;
773 
774  /// Specifies which parameter (of a function, Objective-C method,
775  /// macro, etc.) we should start with when formatting the result.
776  unsigned StartParameter = 0;
777 
778  /// The kind of result stored here.
780 
781  /// The cursor kind that describes this result.
783 
784  /// The availability of this result.
786 
787  /// Fix-its that *must* be applied before inserting the text for the
788  /// corresponding completion.
789  ///
790  /// By default, CodeCompletionBuilder only returns completions with empty
791  /// fix-its. Extra completions with non-empty fix-its should be explicitly
792  /// requested by setting CompletionOptions::IncludeFixIts.
793  ///
794  /// For the clients to be able to compute position of the cursor after
795  /// applying fix-its, the following conditions are guaranteed to hold for
796  /// RemoveRange of the stored fix-its:
797  /// - Ranges in the fix-its are guaranteed to never contain the completion
798  /// point (or identifier under completion point, if any) inside them, except
799  /// at the start or at the end of the range.
800  /// - If a fix-it range starts or ends with completion point (or starts or
801  /// ends after the identifier under completion point), it will contain at
802  /// least one character. It allows to unambiguously recompute completion
803  /// point after applying the fix-it.
804  ///
805  /// The intuition is that provided fix-its change code around the identifier
806  /// we complete, but are not allowed to touch the identifier itself or the
807  /// completion point. One example of completions with corrections are the ones
808  /// replacing '.' with '->' and vice versa:
809  ///
810  /// std::unique_ptr<std::vector<int>> vec_ptr;
811  /// In 'vec_ptr.^', one of the completions is 'push_back', it requires
812  /// replacing '.' with '->'.
813  /// In 'vec_ptr->^', one of the completions is 'release', it requires
814  /// replacing '->' with '.'.
815  std::vector<FixItHint> FixIts;
816 
817  /// Whether this result is hidden by another name.
818  bool Hidden : 1;
819 
820  /// Whether this is a class member from base class.
821  bool InBaseClass : 1;
822 
823  /// Whether this result was found via lookup into a base class.
825 
826  /// Whether this declaration is the beginning of a
827  /// nested-name-specifier and, therefore, should be followed by '::'.
829 
830  /// Whether all parameters (of a function, Objective-C
831  /// method, etc.) should be considered "informative".
833 
834  /// Whether we're completing a declaration of the given entity,
835  /// rather than a use of that entity.
836  bool DeclaringEntity : 1;
837 
838  /// If the result should have a nested-name-specifier, this is it.
839  /// When \c QualifierIsInformative, the nested-name-specifier is
840  /// informative rather than required.
841  NestedNameSpecifier *Qualifier = nullptr;
842 
843  /// If this Decl was unshadowed by using declaration, this can store a
844  /// pointer to the UsingShadowDecl which was used in the unshadowing process.
845  /// This information can be used to uprank CodeCompletionResults / which have
846  /// corresponding `using decl::qualified::name;` nearby.
847  const UsingShadowDecl *ShadowDecl = nullptr;
848 
849  /// If the result is RK_Macro, this can store the information about the macro
850  /// definition. This should be set in most cases but can be missing when
851  /// the macro has been undefined.
852  const MacroInfo *MacroDefInfo = nullptr;
853 
854  /// Build a result that refers to a declaration.
855  CodeCompletionResult(const NamedDecl *Declaration, unsigned Priority,
856  NestedNameSpecifier *Qualifier = nullptr,
857  bool QualifierIsInformative = false,
858  bool Accessible = true,
859  std::vector<FixItHint> FixIts = std::vector<FixItHint>())
860  : Declaration(Declaration), Priority(Priority), Kind(RK_Declaration),
861  FixIts(std::move(FixIts)), Hidden(false), InBaseClass(false),
862  QualifierIsInformative(QualifierIsInformative),
863  StartsNestedNameSpecifier(false), AllParametersAreInformative(false),
864  DeclaringEntity(false), Qualifier(Qualifier) {
865  // FIXME: Add assert to check FixIts range requirements.
866  computeCursorKindAndAvailability(Accessible);
867  }
868 
869  /// Build a result that refers to a keyword or symbol.
870  CodeCompletionResult(const char *Keyword, unsigned Priority = CCP_Keyword)
871  : Keyword(Keyword), Priority(Priority), Kind(RK_Keyword),
872  CursorKind(CXCursor_NotImplemented), Hidden(false), InBaseClass(false),
873  QualifierIsInformative(false), StartsNestedNameSpecifier(false),
874  AllParametersAreInformative(false), DeclaringEntity(false) {}
875 
876  /// Build a result that refers to a macro.
878  const MacroInfo *MI = nullptr,
879  unsigned Priority = CCP_Macro)
880  : Macro(Macro), Priority(Priority), Kind(RK_Macro),
881  CursorKind(CXCursor_MacroDefinition), Hidden(false), InBaseClass(false),
882  QualifierIsInformative(false), StartsNestedNameSpecifier(false),
883  AllParametersAreInformative(false), DeclaringEntity(false),
884  MacroDefInfo(MI) {}
885 
886  /// Build a result that refers to a pattern.
888  CodeCompletionString *Pattern, unsigned Priority = CCP_CodePattern,
891  const NamedDecl *D = nullptr)
892  : Declaration(D), Pattern(Pattern), Priority(Priority), Kind(RK_Pattern),
893  CursorKind(CursorKind), Availability(Availability), Hidden(false),
894  InBaseClass(false), QualifierIsInformative(false),
895  StartsNestedNameSpecifier(false), AllParametersAreInformative(false),
896  DeclaringEntity(false) {}
897 
898  /// Build a result that refers to a pattern with an associated
899  /// declaration.
901  unsigned Priority)
902  : Declaration(D), Pattern(Pattern), Priority(Priority), Kind(RK_Pattern),
903  Hidden(false), InBaseClass(false), QualifierIsInformative(false),
904  StartsNestedNameSpecifier(false), AllParametersAreInformative(false),
905  DeclaringEntity(false) {
906  computeCursorKindAndAvailability();
907  }
908 
909  /// Retrieve the declaration stored in this result. This might be nullptr if
910  /// Kind is RK_Pattern.
911  const NamedDecl *getDeclaration() const {
912  assert(((Kind == RK_Declaration) || (Kind == RK_Pattern)) &&
913  "Not a declaration or pattern result");
914  return Declaration;
915  }
916 
917  /// Retrieve the keyword stored in this result.
918  const char *getKeyword() const {
919  assert(Kind == RK_Keyword && "Not a keyword result");
920  return Keyword;
921  }
922 
923  /// Create a new code-completion string that describes how to insert
924  /// this result into a program.
925  ///
926  /// \param S The semantic analysis that created the result.
927  ///
928  /// \param Allocator The allocator that will be used to allocate the
929  /// string itself.
930  CodeCompletionString *CreateCodeCompletionString(Sema &S,
931  const CodeCompletionContext &CCContext,
932  CodeCompletionAllocator &Allocator,
933  CodeCompletionTUInfo &CCTUInfo,
934  bool IncludeBriefComments);
935  CodeCompletionString *CreateCodeCompletionString(ASTContext &Ctx,
936  Preprocessor &PP,
937  const CodeCompletionContext &CCContext,
938  CodeCompletionAllocator &Allocator,
939  CodeCompletionTUInfo &CCTUInfo,
940  bool IncludeBriefComments);
941  /// Creates a new code-completion string for the macro result. Similar to the
942  /// above overloads, except this only requires preprocessor information.
943  /// The result kind must be `RK_Macro`.
945  CreateCodeCompletionStringForMacro(Preprocessor &PP,
946  CodeCompletionAllocator &Allocator,
947  CodeCompletionTUInfo &CCTUInfo);
948 
949  CodeCompletionString *createCodeCompletionStringForDecl(
951  bool IncludeBriefComments, const CodeCompletionContext &CCContext,
952  PrintingPolicy &Policy);
953 
954  CodeCompletionString *createCodeCompletionStringForOverride(
955  Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result,
956  bool IncludeBriefComments, const CodeCompletionContext &CCContext,
957  PrintingPolicy &Policy);
958 
959  /// Retrieve the name that should be used to order a result.
960  ///
961  /// If the name needs to be constructed as a string, that string will be
962  /// saved into Saved and the returned StringRef will refer to it.
963  StringRef getOrderedName(std::string &Saved) const;
964 
965 private:
966  void computeCursorKindAndAvailability(bool Accessible = true);
967 };
968 
970 
971 inline bool operator>(const CodeCompletionResult &X,
972  const CodeCompletionResult &Y) {
973  return Y < X;
974 }
975 
976 inline bool operator<=(const CodeCompletionResult &X,
977  const CodeCompletionResult &Y) {
978  return !(Y < X);
979 }
980 
981 inline bool operator>=(const CodeCompletionResult &X,
982  const CodeCompletionResult &Y) {
983  return !(X < Y);
984 }
985 
986 raw_ostream &operator<<(raw_ostream &OS,
987  const CodeCompletionString &CCS);
988 
989 /// Abstract interface for a consumer of code-completion
990 /// information.
992 protected:
994 
995 public:
997  public:
998  /// Describes the type of overload candidate.
1000  /// The candidate is a function declaration.
1002 
1003  /// The candidate is a function template.
1005 
1006  /// The "candidate" is actually a variable, expression, or block
1007  /// for which we only have a function prototype.
1008  CK_FunctionType
1009  };
1010 
1011  private:
1012  /// The kind of overload candidate.
1014 
1015  union {
1016  /// The function overload candidate, available when
1017  /// Kind == CK_Function.
1019 
1020  /// The function template overload candidate, available when
1021  /// Kind == CK_FunctionTemplate.
1023 
1024  /// The function type that describes the entity being called,
1025  /// when Kind == CK_FunctionType.
1027  };
1028 
1029  public:
1031  : Kind(CK_Function), Function(Function) {}
1032 
1034  : Kind(CK_FunctionTemplate), FunctionTemplate(FunctionTemplateDecl) {}
1035 
1037  : Kind(CK_FunctionType), Type(Type) {}
1038 
1039  /// Determine the kind of overload candidate.
1040  CandidateKind getKind() const { return Kind; }
1041 
1042  /// Retrieve the function overload candidate or the templated
1043  /// function declaration for a function template.
1044  FunctionDecl *getFunction() const;
1045 
1046  /// Retrieve the function template overload candidate.
1048  assert(getKind() == CK_FunctionTemplate && "Not a function template");
1049  return FunctionTemplate;
1050  }
1051 
1052  /// Retrieve the function type of the entity, regardless of how the
1053  /// function is stored.
1054  const FunctionType *getFunctionType() const;
1055 
1056  /// Create a new code-completion string that describes the function
1057  /// signature of this overload candidate.
1058  CodeCompletionString *CreateSignatureString(unsigned CurrentArg,
1059  Sema &S,
1060  CodeCompletionAllocator &Allocator,
1061  CodeCompletionTUInfo &CCTUInfo,
1062  bool IncludeBriefComments) const;
1063  };
1064 
1066  : CodeCompleteOpts(CodeCompleteOpts) {}
1067 
1068  /// Whether the code-completion consumer wants to see macros.
1069  bool includeMacros() const {
1070  return CodeCompleteOpts.IncludeMacros;
1071  }
1072 
1073  /// Whether the code-completion consumer wants to see code patterns.
1074  bool includeCodePatterns() const {
1075  return CodeCompleteOpts.IncludeCodePatterns;
1076  }
1077 
1078  /// Whether to include global (top-level) declaration results.
1079  bool includeGlobals() const { return CodeCompleteOpts.IncludeGlobals; }
1080 
1081  /// Whether to include declarations in namespace contexts (including
1082  /// the global namespace). If this is false, `includeGlobals()` will be
1083  /// ignored.
1085  return CodeCompleteOpts.IncludeNamespaceLevelDecls;
1086  }
1087 
1088  /// Whether to include brief documentation comments within the set of
1089  /// code completions returned.
1090  bool includeBriefComments() const {
1091  return CodeCompleteOpts.IncludeBriefComments;
1092  }
1093 
1094  /// Whether to include completion items with small fix-its, e.g. change
1095  /// '.' to '->' on member access, etc.
1096  bool includeFixIts() const { return CodeCompleteOpts.IncludeFixIts; }
1097 
1098  /// Hint whether to load data from the external AST in order to provide
1099  /// full results. If false, declarations from the preamble may be omitted.
1100  bool loadExternal() const {
1101  return CodeCompleteOpts.LoadExternal;
1102  }
1103 
1104  /// Deregisters and destroys this code-completion consumer.
1105  virtual ~CodeCompleteConsumer();
1106 
1107  /// \name Code-completion filtering
1108  /// Check if the result should be filtered out.
1109  virtual bool isResultFilteredOut(StringRef Filter,
1110  CodeCompletionResult Results) {
1111  return false;
1112  }
1113 
1114  /// \name Code-completion callbacks
1115  //@{
1116  /// Process the finalized code-completion results.
1118  CodeCompletionContext Context,
1119  CodeCompletionResult *Results,
1120  unsigned NumResults) {}
1121 
1122  /// \param S the semantic-analyzer object for which code-completion is being
1123  /// done.
1124  ///
1125  /// \param CurrentArg the index of the current argument.
1126  ///
1127  /// \param Candidates an array of overload candidates.
1128  ///
1129  /// \param NumCandidates the number of overload candidates
1130  ///
1131  /// \param OpenParLoc location of the opening parenthesis of the argument
1132  /// list.
1133  virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
1134  OverloadCandidate *Candidates,
1135  unsigned NumCandidates,
1136  SourceLocation OpenParLoc) {}
1137  //@}
1138 
1139  /// Retrieve the allocator that will be used to allocate
1140  /// code completion strings.
1141  virtual CodeCompletionAllocator &getAllocator() = 0;
1142 
1143  virtual CodeCompletionTUInfo &getCodeCompletionTUInfo() = 0;
1144 };
1145 
1146 /// Get the documentation comment used to produce
1147 /// CodeCompletionString::BriefComment for RK_Declaration.
1148 const RawComment *getCompletionComment(const ASTContext &Ctx,
1149  const NamedDecl *Decl);
1150 
1151 /// Get the documentation comment used to produce
1152 /// CodeCompletionString::BriefComment for RK_Pattern.
1154  const NamedDecl *Decl);
1155 
1156 /// Get the documentation comment used to produce
1157 /// CodeCompletionString::BriefComment for OverloadCandidate.
1158 const RawComment *
1159 getParameterComment(const ASTContext &Ctx,
1161  unsigned ArgIndex);
1162 
1163 /// A simple code-completion consumer that prints the results it
1164 /// receives in a simple format.
1166  /// The raw output stream.
1167  raw_ostream &OS;
1168 
1169  CodeCompletionTUInfo CCTUInfo;
1170 
1171 public:
1172  /// Create a new printing code-completion consumer that prints its
1173  /// results to the given raw output stream.
1175  raw_ostream &OS)
1176  : CodeCompleteConsumer(CodeCompleteOpts), OS(OS),
1177  CCTUInfo(std::make_shared<GlobalCodeCompletionAllocator>()) {}
1178 
1179  /// Prints the finalized code-completion results.
1180  void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context,
1181  CodeCompletionResult *Results,
1182  unsigned NumResults) override;
1183 
1184  void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
1185  OverloadCandidate *Candidates,
1186  unsigned NumCandidates,
1187  SourceLocation OpenParLoc) override;
1188 
1189  bool isResultFilteredOut(StringRef Filter, CodeCompletionResult Results) override;
1190 
1192  return CCTUInfo.getAllocator();
1193  }
1194 
1195  CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo; }
1196 };
1197 
1198 } // namespace clang
1199 
1200 #endif // LLVM_CLANG_SEMA_CODECOMPLETECONSUMER_H
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
The result is a C++ non-static member function whose qualifiers exactly match the object type on whic...
CodeCompletionAllocator & getAllocator() const
Represents a function declaration or definition.
Definition: Decl.h:1737
llvm::SmallPtrSet< DeclContext *, 8 > VisitedContextSet
ResultKind Kind
The kind of result stored here.
Priority for a language keyword (that isn&#39;t any of the other categories).
An Objective-C method being used as a property.
std::vector< FixItHint > FixIts
Fix-its that must be applied before inserting the text for the corresponding completion.
const FunctionType * Type
The function type that describes the entity being called, when Kind == CK_FunctionType.
CXCursorKind CursorKind
The cursor kind that describes this result.
Priority for a constant value (e.g., enumerator).
A (possibly-)qualified type.
Definition: Type.h:639
unsigned IncludeBriefComments
Show brief documentation comments in code completion results.
llvm::Optional< const CXXScopeSpec * > getCXXScopeSpecifier()
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...
unsigned IncludeGlobals
Show top-level decls in code completion results.
Priority for a code pattern.
unsigned getMacroUsagePriority(StringRef MacroName, const LangOptions &LangOpts, bool PreferredTypeIsPointer=false)
Determine the priority to be given to a macro code completion result with the given name...
Code completion where an Objective-C class message is expected.
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3367
CodeCompletionResult(const NamedDecl *Declaration, unsigned Priority, NestedNameSpecifier *Qualifier=nullptr, bool QualifierIsInformative=false, bool Accessible=true, std::vector< FixItHint > FixIts=std::vector< FixItHint >())
Build a result that refers to a declaration.
C Language Family Type Representation.
Code completion within a type-qualifier list.
Priority for a non-type declaration.
static void AddResultTypeChunk(ASTContext &Context, const PrintingPolicy &Policy, const NamedDecl *ND, QualType BaseType, CodeCompletionBuilder &Result)
If the given declaration has an associated type, add it as a result type chunk.
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
CandidateKind
Describes the type of overload candidate.
Defines the clang::MacroInfo and clang::MacroDirective classes.
const DiagnosticBuilder & operator<<(const DiagnosticBuilder &DB, const Attr *At)
Definition: Attr.h:335
The base class of the type hierarchy.
Definition: Type.h:1414
An unspecified code-completion context.
Allocator for a cached set of global code completions.
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
bool loadExternal() const
Hint whether to load data from the external AST in order to provide full results. ...
Code completion occurred where an Objective-C message receiver is expected.
unsigned Priority
The priority of this particular code-completion result.
Priority for a result that isn&#39;t likely to be what the user wants, but is included for completeness...
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.
A piece of text that describes the type of an entity or, for functions and methods, the return type.
An Objective-C block property completed as a setter with a block placeholder.
bool StartsNestedNameSpecifier
Whether this declaration is the beginning of a nested-name-specifier and, therefore, should be followed by &#39;::&#39;.
const char * Keyword
When Kind == RK_Keyword, the string representing the keyword or symbol&#39;s spelling.
The selector of the given message exactly matches the selector of the current method, which might imply that some kind of delegation is occurring.
Code completion occurred within the instance variable list of an Objective-C interface, implementation, or category implementation.
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:37
bool operator<=(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
CodeCompletionBuilder(CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo, unsigned Priority, CXAvailabilityKind Availability)
The result is in a base class.
Code completion occurred where both a new name and an existing symbol is permissible.
Priority for a type.
One of these records is kept for each identifier that is lexed.
OverloadCandidate(FunctionTemplateDecl *FunctionTemplateDecl)
CodeCompletionResult(const IdentifierInfo *Macro, const MacroInfo *MI=nullptr, unsigned Priority=CCP_Macro)
Build a result that refers to a macro.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
A "string" used to describe how code completion can be performed for an entity.
Definition: Format.h:2222
Kind getKind() const
Retrieve the kind of code-completion context.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:49
bool operator>(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
Priority for a member declaration found from the current method or member function.
unsigned IncludeCodePatterns
Show code patterns in code completion results.
Divide by this factor when a code-completion result&#39;s type exactly matches the type we expect...
An allocator used specifically for the purpose of code completion.
CodeCompletionString * Pattern
When Kind == RK_Pattern, the code-completion string that describes the completion text to insert...
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
Code completion occurred where a preprocessor directive is expected.
Code completion occurred within an Objective-C implementation or category implementation.
bool QualifierIsInformative
Whether this result was found via lookup into a base class.
FunctionTemplateDecl * FunctionTemplate
The function template overload candidate, available when Kind == CK_FunctionTemplate.
QualType getDeclUsageType(ASTContext &C, const NamedDecl *ND)
Determine the type that this declaration will have if it is used as a type or in an expression...
Code completion occurred where a namespace or namespace alias is expected.
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:62
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.
Priority for a send-to-super completion.
virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, OverloadCandidate *Candidates, unsigned NumCandidates, SourceLocation OpenParLoc)
CXCursorKind
Describes the kind of entity that a cursor refers to.
Definition: Index.h:1714
FunctionTemplateDecl * getFunctionTemplate() const
Retrieve the function template overload candidate.
CodeCompletionAllocator & getAllocator() const
Retrieve the allocator into which the code completion strings should be allocated.
A right parenthesis (&#39;)&#39;).
Code completion where an Objective-C category name is expected.
Priority for a preprocessor macro.
Adjustment to the "bool" type in Objective-C, where the typedef "BOOL" is preferred.
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:328
Code completion occurred within a "top-level" completion context, e.g., at namespace or global scope...
CodeCompletionTUInfo & getCodeCompletionTUInfo() override
Priority for an enumeration constant inside a switch whose condition is of the enumeration type...
Code completion occurred where a protocol name is expected.
CXCursorKind getCursorKindForDecl(const Decl *D)
Determine the libclang cursor kind associated with the given declaration.
const RawComment * getCompletionComment(const ASTContext &Ctx, const NamedDecl *Decl)
Get the documentation comment used to produce CodeCompletionString::BriefComment for RK_Declaration...
A simple code-completion consumer that prints the results it receives in a simple format...
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.
llvm::StringRef getAsString(SyncScope S)
Definition: SyncScope.h:50
CodeCompletionResult(CodeCompletionString *Pattern, const NamedDecl *D, unsigned Priority)
Build a result that refers to a pattern with an associated declaration.
const char * Text
The text string associated with a CK_Text, CK_Placeholder, CK_Informative, or CK_Comma chunk...
This file defines the classes used to store parsed information about declaration-specifiers and decla...
virtual void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context, CodeCompletionResult *Results, unsigned NumResults)
Process the finalized code-completion results.
void addVisitedContext(DeclContext *Ctx)
Adds a visited context.
unsigned IncludeNamespaceLevelDecls
Show decls in namespace (including the global namespace) in code completion results.
Adjustment for KVC code pattern priorities when it doesn&#39;t look like the.
Captures a result of code completion.
ArrayRef< IdentifierInfo * > getSelIdents() const
Retrieve the Objective-C selector identifiers.
CodeCompletionContext(Kind CCKind)
Construct a new code-completion context of the given kind.
std::shared_ptr< GlobalCodeCompletionAllocator > getAllocatorRef() const
Code completion in a parenthesized expression, which means that we may also have types here in C and ...
Code completion occurred in a context where natural language is expected, e.g., a comment or string l...
virtual bool isResultFilteredOut(StringRef Filter, CodeCompletionResult Results)
FunctionDecl * Function
The function overload candidate, available when Kind == CK_Function.
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.
StringRef getParentContextName() const
Retrieve the name of the parent context.
CandidateKind getKind() const
Determine the kind of overload candidate.
Divide by this factor when a code-completion result&#39;s type is similar to the type we expect (e...
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.
PrintingCodeCompleteConsumer(const CodeCompleteOptions &CodeCompleteOpts, raw_ostream &OS)
Create a new printing code-completion consumer that prints its results to the given raw output stream...
Code completion occurred within a class, struct, or union.
llvm::cl::opt< std::string > Filter
const VisitedContextSet & getVisitedContexts() const
Retrieves all visited contexts.
#define false
Definition: stdbool.h:17
Encodes a location in the source.
Code completion occurred where a new name is expected.
const char * getBriefComment() const
Code completion where the name of an Objective-C class is expected.
const Chunk & operator[](unsigned I) const
Code completion occurred within an Objective-C interface, protocol, or category interface.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Represents a canonical, potentially-qualified type.
Definition: CanonicalType.h:65
The entity is available.
Definition: Index.h:135
SimplifiedTypeClass getSimplifiedTypeClass(CanQualType T)
Determine the simplified type class of the given canonical type.
const RawComment * getParameterComment(const ASTContext &Ctx, const CodeCompleteConsumer::OverloadCandidate &Result, unsigned ArgIndex)
Get the documentation comment used to produce CodeCompletionString::BriefComment for OverloadCandidat...
bool operator>=(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
bool operator<(DeclarationName LHS, DeclarationName RHS)
Ordering on two declaration names.
const char * getBriefComment() const
bool includeMacros() const
Whether the code-completion consumer wants to see macros.
bool InBaseClass
Whether this is a class member from base class.
CodeCompletionTUInfo & getCodeCompletionTUInfo() const
Priority for a nested-name-specifier.
Abstract interface for a consumer of code-completion information.
Options controlling the behavior of code completion.
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
Priority for the Objective-C "_cmd" implicit parameter.
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...
Priority for the next initialization in a constructor initializer list.
CodeCompletionResult(CodeCompletionString *Pattern, unsigned Priority=CCP_CodePattern, CXCursorKind CursorKind=CXCursor_NotImplemented, CXAvailabilityKind Availability=CXAvailability_Available, const NamedDecl *D=nullptr)
Build a result that refers to a pattern.
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...
bool includeFixIts() const
Whether to include completion items with small fix-its, e.g.
A builder class used to construct new code-completion strings.
Code completion where an Objective-C instance message is expected.
const RawComment * getPatternCompletionComment(const ASTContext &Ctx, const NamedDecl *Decl)
Get the documentation comment used to produce CodeCompletionString::BriefComment for RK_Pattern...
const char * getKeyword() const
Retrieve the keyword stored in this result.
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...
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:39
const CodeCompleteOptions CodeCompleteOpts
CodeCompletionResult(const char *Keyword, unsigned Priority=CCP_Keyword)
Build a result that refers to a keyword or symbol.
const NamedDecl * getDeclaration() const
Retrieve the declaration stored in this result.
QualType getBaseType() const
Retrieve the type of the base object in a member-access expression.
bool includeBriefComments() const
Whether to include brief documentation comments within the set of code completions returned...
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.
CodeCompletionContext(Kind CCKind, QualType T, ArrayRef< IdentifierInfo *> SelIdents=None)
Construct a new code-completion context of the given kind.
bool Hidden
Whether this result is hidden by another name.
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:14051
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.
bool AllParametersAreInformative
Whether all parameters (of a function, Objective-C method, etc.) should be considered "informative"...
An unspecified code-completion context where we should also add macro completions.
CodeCompletionAllocator & getAllocator() override
Retrieve the allocator that will be used to allocate code completion strings.
Priority for a declaration that is in the local scope.
unsigned IncludeFixIts
Include results after corrections (small fix-its), e.g.
A left angle bracket (&#39;<&#39;).
void setCXXScopeSpecifier(CXXScopeSpec SS)
Sets the scope specifier that comes before the completion token.
A right angle bracket (&#39;>&#39;).
ResultKind
Describes the kind of result generated.
CodeCompletionTUInfo(std::shared_ptr< GlobalCodeCompletionAllocator > Allocator)
unsigned LoadExternal
Hint whether to load data from the external AST to provide full results.
Code completion occurred on the right-hand side of a member access expression using the dot operator...
SimplifiedTypeClass
A simplified classification of types used when determining "similar" types for code completion...
Code completion occurred where a type name is expected.
Horizontal whitespace (&#39; &#39;).
bool includeCodePatterns() const
Whether the code-completion consumer wants to see code patterns.
StringRef Text
Definition: Format.cpp:1708
bool DeclaringEntity
Whether we&#39;re completing a declaration of the given entity, rather than a use of that entity...
unsigned getPriority() const
Retrieve the priority of this code completion result.
unsigned IncludeMacros
Show macros in code completion results.
CodeCompletionBuilder(CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo)
This represents a decl that may have a name.
Definition: Decl.h:248
bool includeNamespaceLevelDecls() const
Whether to include declarations in namespace contexts (including the global namespace).
Declaration of a template function.
Definition: DeclTemplate.h:968
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:3146
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:123
CodeCompleteConsumer(const CodeCompleteOptions &CodeCompleteOpts)
bool includeGlobals() const
Whether to include global (top-level) declaration results.