clang  7.0.0
SemaCodeComplete.cpp
Go to the documentation of this file.
1 //===---------------- SemaCodeComplete.cpp - Code Completion ----*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the code-completion semantic actions.
11 //
12 //===----------------------------------------------------------------------===//
13 #include "clang/AST/DeclCXX.h"
14 #include "clang/AST/DeclObjC.h"
15 #include "clang/AST/ExprCXX.h"
16 #include "clang/AST/ExprObjC.h"
18 #include "clang/Basic/CharInfo.h"
19 #include "clang/Lex/HeaderSearch.h"
20 #include "clang/Lex/MacroInfo.h"
21 #include "clang/Lex/Preprocessor.h"
23 #include "clang/Sema/Lookup.h"
24 #include "clang/Sema/Overload.h"
25 #include "clang/Sema/Scope.h"
26 #include "clang/Sema/ScopeInfo.h"
28 #include "llvm/ADT/DenseSet.h"
29 #include "llvm/ADT/SmallBitVector.h"
30 #include "llvm/ADT/SmallPtrSet.h"
31 #include "llvm/ADT/SmallString.h"
32 #include "llvm/ADT/StringExtras.h"
33 #include "llvm/ADT/StringSwitch.h"
34 #include "llvm/ADT/Twine.h"
35 #include <list>
36 #include <map>
37 #include <vector>
38 
39 using namespace clang;
40 using namespace sema;
41 
42 namespace {
43  /// A container of code-completion results.
44  class ResultBuilder {
45  public:
46  /// The type of a name-lookup filter, which can be provided to the
47  /// name-lookup routines to specify which declarations should be included in
48  /// the result set (when it returns true) and which declarations should be
49  /// filtered out (returns false).
50  typedef bool (ResultBuilder::*LookupFilter)(const NamedDecl *) const;
51 
52  typedef CodeCompletionResult Result;
53 
54  private:
55  /// The actual results we have found.
56  std::vector<Result> Results;
57 
58  /// A record of all of the declarations we have found and placed
59  /// into the result set, used to ensure that no declaration ever gets into
60  /// the result set twice.
61  llvm::SmallPtrSet<const Decl*, 16> AllDeclsFound;
62 
63  typedef std::pair<const NamedDecl *, unsigned> DeclIndexPair;
64 
65  /// An entry in the shadow map, which is optimized to store
66  /// a single (declaration, index) mapping (the common case) but
67  /// can also store a list of (declaration, index) mappings.
68  class ShadowMapEntry {
69  typedef SmallVector<DeclIndexPair, 4> DeclIndexPairVector;
70 
71  /// Contains either the solitary NamedDecl * or a vector
72  /// of (declaration, index) pairs.
73  llvm::PointerUnion<const NamedDecl *, DeclIndexPairVector*> DeclOrVector;
74 
75  /// When the entry contains a single declaration, this is
76  /// the index associated with that entry.
77  unsigned SingleDeclIndex;
78 
79  public:
80  ShadowMapEntry() : DeclOrVector(), SingleDeclIndex(0) { }
81 
82  void Add(const NamedDecl *ND, unsigned Index) {
83  if (DeclOrVector.isNull()) {
84  // 0 - > 1 elements: just set the single element information.
85  DeclOrVector = ND;
86  SingleDeclIndex = Index;
87  return;
88  }
89 
90  if (const NamedDecl *PrevND =
91  DeclOrVector.dyn_cast<const NamedDecl *>()) {
92  // 1 -> 2 elements: create the vector of results and push in the
93  // existing declaration.
94  DeclIndexPairVector *Vec = new DeclIndexPairVector;
95  Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex));
96  DeclOrVector = Vec;
97  }
98 
99  // Add the new element to the end of the vector.
100  DeclOrVector.get<DeclIndexPairVector*>()->push_back(
101  DeclIndexPair(ND, Index));
102  }
103 
104  void Destroy() {
105  if (DeclIndexPairVector *Vec
106  = DeclOrVector.dyn_cast<DeclIndexPairVector *>()) {
107  delete Vec;
108  DeclOrVector = ((NamedDecl *)nullptr);
109  }
110  }
111 
112  // Iteration.
113  class iterator;
114  iterator begin() const;
115  iterator end() const;
116  };
117 
118  /// A mapping from declaration names to the declarations that have
119  /// this name within a particular scope and their index within the list of
120  /// results.
121  typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
122 
123  /// The semantic analysis object for which results are being
124  /// produced.
125  Sema &SemaRef;
126 
127  /// The allocator used to allocate new code-completion strings.
128  CodeCompletionAllocator &Allocator;
129 
130  CodeCompletionTUInfo &CCTUInfo;
131 
132  /// If non-NULL, a filter function used to remove any code-completion
133  /// results that are not desirable.
134  LookupFilter Filter;
135 
136  /// Whether we should allow declarations as
137  /// nested-name-specifiers that would otherwise be filtered out.
138  bool AllowNestedNameSpecifiers;
139 
140  /// If set, the type that we would prefer our resulting value
141  /// declarations to have.
142  ///
143  /// Closely matching the preferred type gives a boost to a result's
144  /// priority.
145  CanQualType PreferredType;
146 
147  /// A list of shadow maps, which is used to model name hiding at
148  /// different levels of, e.g., the inheritance hierarchy.
149  std::list<ShadowMap> ShadowMaps;
150 
151  /// If we're potentially referring to a C++ member function, the set
152  /// of qualifiers applied to the object type.
153  Qualifiers ObjectTypeQualifiers;
154 
155  /// Whether the \p ObjectTypeQualifiers field is active.
156  bool HasObjectTypeQualifiers;
157 
158  /// The selector that we prefer.
159  Selector PreferredSelector;
160 
161  /// The completion context in which we are gathering results.
162  CodeCompletionContext CompletionContext;
163 
164  /// If we are in an instance method definition, the \@implementation
165  /// object.
166  ObjCImplementationDecl *ObjCImplementation;
167 
168  void AdjustResultPriorityForDecl(Result &R);
169 
170  void MaybeAddConstructorResults(Result R);
171 
172  public:
173  explicit ResultBuilder(Sema &SemaRef, CodeCompletionAllocator &Allocator,
174  CodeCompletionTUInfo &CCTUInfo,
175  const CodeCompletionContext &CompletionContext,
176  LookupFilter Filter = nullptr)
177  : SemaRef(SemaRef), Allocator(Allocator), CCTUInfo(CCTUInfo),
178  Filter(Filter),
179  AllowNestedNameSpecifiers(false), HasObjectTypeQualifiers(false),
180  CompletionContext(CompletionContext),
181  ObjCImplementation(nullptr)
182  {
183  // If this is an Objective-C instance method definition, dig out the
184  // corresponding implementation.
185  switch (CompletionContext.getKind()) {
191  if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl())
192  if (Method->isInstanceMethod())
193  if (ObjCInterfaceDecl *Interface = Method->getClassInterface())
194  ObjCImplementation = Interface->getImplementation();
195  break;
196 
197  default:
198  break;
199  }
200  }
201 
202  /// Determine the priority for a reference to the given declaration.
203  unsigned getBasePriority(const NamedDecl *D);
204 
205  /// Whether we should include code patterns in the completion
206  /// results.
207  bool includeCodePatterns() const {
208  return SemaRef.CodeCompleter &&
210  }
211 
212  /// Set the filter used for code-completion results.
213  void setFilter(LookupFilter Filter) {
214  this->Filter = Filter;
215  }
216 
217  Result *data() { return Results.empty()? nullptr : &Results.front(); }
218  unsigned size() const { return Results.size(); }
219  bool empty() const { return Results.empty(); }
220 
221  /// Specify the preferred type.
222  void setPreferredType(QualType T) {
223  PreferredType = SemaRef.Context.getCanonicalType(T);
224  }
225 
226  /// Set the cv-qualifiers on the object type, for us in filtering
227  /// calls to member functions.
228  ///
229  /// When there are qualifiers in this set, they will be used to filter
230  /// out member functions that aren't available (because there will be a
231  /// cv-qualifier mismatch) or prefer functions with an exact qualifier
232  /// match.
233  void setObjectTypeQualifiers(Qualifiers Quals) {
234  ObjectTypeQualifiers = Quals;
235  HasObjectTypeQualifiers = true;
236  }
237 
238  /// Set the preferred selector.
239  ///
240  /// When an Objective-C method declaration result is added, and that
241  /// method's selector matches this preferred selector, we give that method
242  /// a slight priority boost.
243  void setPreferredSelector(Selector Sel) {
244  PreferredSelector = Sel;
245  }
246 
247  /// Retrieve the code-completion context for which results are
248  /// being collected.
249  const CodeCompletionContext &getCompletionContext() const {
250  return CompletionContext;
251  }
252 
253  /// Specify whether nested-name-specifiers are allowed.
254  void allowNestedNameSpecifiers(bool Allow = true) {
255  AllowNestedNameSpecifiers = Allow;
256  }
257 
258  /// Return the semantic analysis object for which we are collecting
259  /// code completion results.
260  Sema &getSema() const { return SemaRef; }
261 
262  /// Retrieve the allocator used to allocate code completion strings.
263  CodeCompletionAllocator &getAllocator() const { return Allocator; }
264 
265  CodeCompletionTUInfo &getCodeCompletionTUInfo() const { return CCTUInfo; }
266 
267  /// Determine whether the given declaration is at all interesting
268  /// as a code-completion result.
269  ///
270  /// \param ND the declaration that we are inspecting.
271  ///
272  /// \param AsNestedNameSpecifier will be set true if this declaration is
273  /// only interesting when it is a nested-name-specifier.
274  bool isInterestingDecl(const NamedDecl *ND,
275  bool &AsNestedNameSpecifier) const;
276 
277  /// Check whether the result is hidden by the Hiding declaration.
278  ///
279  /// \returns true if the result is hidden and cannot be found, false if
280  /// the hidden result could still be found. When false, \p R may be
281  /// modified to describe how the result can be found (e.g., via extra
282  /// qualification).
283  bool CheckHiddenResult(Result &R, DeclContext *CurContext,
284  const NamedDecl *Hiding);
285 
286  /// Add a new result to this result set (if it isn't already in one
287  /// of the shadow maps), or replace an existing result (for, e.g., a
288  /// redeclaration).
289  ///
290  /// \param R the result to add (if it is unique).
291  ///
292  /// \param CurContext the context in which this result will be named.
293  void MaybeAddResult(Result R, DeclContext *CurContext = nullptr);
294 
295  /// Add a new result to this result set, where we already know
296  /// the hiding declaration (if any).
297  ///
298  /// \param R the result to add (if it is unique).
299  ///
300  /// \param CurContext the context in which this result will be named.
301  ///
302  /// \param Hiding the declaration that hides the result.
303  ///
304  /// \param InBaseClass whether the result was found in a base
305  /// class of the searched context.
306  void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding,
307  bool InBaseClass);
308 
309  /// Add a new non-declaration result to this result set.
310  void AddResult(Result R);
311 
312  /// Enter into a new scope.
313  void EnterNewScope();
314 
315  /// Exit from the current scope.
316  void ExitScope();
317 
318  /// Ignore this declaration, if it is seen again.
319  void Ignore(const Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); }
320 
321  /// Add a visited context.
322  void addVisitedContext(DeclContext *Ctx) {
323  CompletionContext.addVisitedContext(Ctx);
324  }
325 
326  /// \name Name lookup predicates
327  ///
328  /// These predicates can be passed to the name lookup functions to filter the
329  /// results of name lookup. All of the predicates have the same type, so that
330  ///
331  //@{
332  bool IsOrdinaryName(const NamedDecl *ND) const;
333  bool IsOrdinaryNonTypeName(const NamedDecl *ND) const;
334  bool IsIntegralConstantValue(const NamedDecl *ND) const;
335  bool IsOrdinaryNonValueName(const NamedDecl *ND) const;
336  bool IsNestedNameSpecifier(const NamedDecl *ND) const;
337  bool IsEnum(const NamedDecl *ND) const;
338  bool IsClassOrStruct(const NamedDecl *ND) const;
339  bool IsUnion(const NamedDecl *ND) const;
340  bool IsNamespace(const NamedDecl *ND) const;
341  bool IsNamespaceOrAlias(const NamedDecl *ND) const;
342  bool IsType(const NamedDecl *ND) const;
343  bool IsMember(const NamedDecl *ND) const;
344  bool IsObjCIvar(const NamedDecl *ND) const;
345  bool IsObjCMessageReceiver(const NamedDecl *ND) const;
346  bool IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const;
347  bool IsObjCCollection(const NamedDecl *ND) const;
348  bool IsImpossibleToSatisfy(const NamedDecl *ND) const;
349  //@}
350  };
351 }
352 
354  llvm::PointerUnion<const NamedDecl *, const DeclIndexPair *> DeclOrIterator;
355  unsigned SingleDeclIndex;
356 
357 public:
358  typedef DeclIndexPair value_type;
359  typedef value_type reference;
361  typedef std::input_iterator_tag iterator_category;
362 
363  class pointer {
364  DeclIndexPair Value;
365 
366  public:
367  pointer(const DeclIndexPair &Value) : Value(Value) { }
368 
369  const DeclIndexPair *operator->() const {
370  return &Value;
371  }
372  };
373 
374  iterator() : DeclOrIterator((NamedDecl *)nullptr), SingleDeclIndex(0) {}
375 
376  iterator(const NamedDecl *SingleDecl, unsigned Index)
377  : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) { }
378 
379  iterator(const DeclIndexPair *Iterator)
380  : DeclOrIterator(Iterator), SingleDeclIndex(0) { }
381 
383  if (DeclOrIterator.is<const NamedDecl *>()) {
384  DeclOrIterator = (NamedDecl *)nullptr;
385  SingleDeclIndex = 0;
386  return *this;
387  }
388 
389  const DeclIndexPair *I = DeclOrIterator.get<const DeclIndexPair*>();
390  ++I;
391  DeclOrIterator = I;
392  return *this;
393  }
394 
395  /*iterator operator++(int) {
396  iterator tmp(*this);
397  ++(*this);
398  return tmp;
399  }*/
400 
401  reference operator*() const {
402  if (const NamedDecl *ND = DeclOrIterator.dyn_cast<const NamedDecl *>())
403  return reference(ND, SingleDeclIndex);
404 
405  return *DeclOrIterator.get<const DeclIndexPair*>();
406  }
407 
408  pointer operator->() const {
409  return pointer(**this);
410  }
411 
412  friend bool operator==(const iterator &X, const iterator &Y) {
413  return X.DeclOrIterator.getOpaqueValue()
414  == Y.DeclOrIterator.getOpaqueValue() &&
415  X.SingleDeclIndex == Y.SingleDeclIndex;
416  }
417 
418  friend bool operator!=(const iterator &X, const iterator &Y) {
419  return !(X == Y);
420  }
421 };
422 
424 ResultBuilder::ShadowMapEntry::begin() const {
425  if (DeclOrVector.isNull())
426  return iterator();
427 
428  if (const NamedDecl *ND = DeclOrVector.dyn_cast<const NamedDecl *>())
429  return iterator(ND, SingleDeclIndex);
430 
431  return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin());
432 }
433 
435 ResultBuilder::ShadowMapEntry::end() const {
436  if (DeclOrVector.is<const NamedDecl *>() || DeclOrVector.isNull())
437  return iterator();
438 
439  return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end());
440 }
441 
442 /// Compute the qualification required to get from the current context
443 /// (\p CurContext) to the target context (\p TargetContext).
444 ///
445 /// \param Context the AST context in which the qualification will be used.
446 ///
447 /// \param CurContext the context where an entity is being named, which is
448 /// typically based on the current scope.
449 ///
450 /// \param TargetContext the context in which the named entity actually
451 /// resides.
452 ///
453 /// \returns a nested name specifier that refers into the target context, or
454 /// NULL if no qualification is needed.
455 static NestedNameSpecifier *
457  const DeclContext *CurContext,
458  const DeclContext *TargetContext) {
460 
461  for (const DeclContext *CommonAncestor = TargetContext;
462  CommonAncestor && !CommonAncestor->Encloses(CurContext);
463  CommonAncestor = CommonAncestor->getLookupParent()) {
464  if (CommonAncestor->isTransparentContext() ||
465  CommonAncestor->isFunctionOrMethod())
466  continue;
467 
468  TargetParents.push_back(CommonAncestor);
469  }
470 
471  NestedNameSpecifier *Result = nullptr;
472  while (!TargetParents.empty()) {
473  const DeclContext *Parent = TargetParents.pop_back_val();
474 
475  if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Parent)) {
476  if (!Namespace->getIdentifier())
477  continue;
478 
479  Result = NestedNameSpecifier::Create(Context, Result, Namespace);
480  }
481  else if (const TagDecl *TD = dyn_cast<TagDecl>(Parent))
482  Result = NestedNameSpecifier::Create(Context, Result,
483  false,
484  Context.getTypeDeclType(TD).getTypePtr());
485  }
486  return Result;
487 }
488 
489 /// Determine whether \p Id is a name reserved for the implementation (C99
490 /// 7.1.3, C++ [lib.global.names]).
491 static bool isReservedName(const IdentifierInfo *Id,
492  bool doubleUnderscoreOnly = false) {
493  if (Id->getLength() < 2)
494  return false;
495  const char *Name = Id->getNameStart();
496  return Name[0] == '_' &&
497  (Name[1] == '_' || (Name[1] >= 'A' && Name[1] <= 'Z' &&
498  !doubleUnderscoreOnly));
499 }
500 
501 // Some declarations have reserved names that we don't want to ever show.
502 // Filter out names reserved for the implementation if they come from a
503 // system header.
504 static bool shouldIgnoreDueToReservedName(const NamedDecl *ND, Sema &SemaRef) {
505  const IdentifierInfo *Id = ND->getIdentifier();
506  if (!Id)
507  return false;
508 
509  // Ignore reserved names for compiler provided decls.
510  if (isReservedName(Id) && ND->getLocation().isInvalid())
511  return true;
512 
513  // For system headers ignore only double-underscore names.
514  // This allows for system headers providing private symbols with a single
515  // underscore.
516  if (isReservedName(Id, /*doubleUnderscoreOnly=*/true) &&
517  SemaRef.SourceMgr.isInSystemHeader(
518  SemaRef.SourceMgr.getSpellingLoc(ND->getLocation())))
519  return true;
520 
521  return false;
522 }
523 
524 bool ResultBuilder::isInterestingDecl(const NamedDecl *ND,
525  bool &AsNestedNameSpecifier) const {
526  AsNestedNameSpecifier = false;
527 
528  auto *Named = ND;
529  ND = ND->getUnderlyingDecl();
530 
531  // Skip unnamed entities.
532  if (!ND->getDeclName())
533  return false;
534 
535  // Friend declarations and declarations introduced due to friends are never
536  // added as results.
538  return false;
539 
540  // Class template (partial) specializations are never added as results.
541  if (isa<ClassTemplateSpecializationDecl>(ND) ||
542  isa<ClassTemplatePartialSpecializationDecl>(ND))
543  return false;
544 
545  // Using declarations themselves are never added as results.
546  if (isa<UsingDecl>(ND))
547  return false;
548 
549  if (shouldIgnoreDueToReservedName(ND, SemaRef))
550  return false;
551 
552  if (Filter == &ResultBuilder::IsNestedNameSpecifier ||
553  (isa<NamespaceDecl>(ND) &&
554  Filter != &ResultBuilder::IsNamespace &&
555  Filter != &ResultBuilder::IsNamespaceOrAlias &&
556  Filter != nullptr))
557  AsNestedNameSpecifier = true;
558 
559  // Filter out any unwanted results.
560  if (Filter && !(this->*Filter)(Named)) {
561  // Check whether it is interesting as a nested-name-specifier.
562  if (AllowNestedNameSpecifiers && SemaRef.getLangOpts().CPlusPlus &&
563  IsNestedNameSpecifier(ND) &&
564  (Filter != &ResultBuilder::IsMember ||
565  (isa<CXXRecordDecl>(ND) &&
566  cast<CXXRecordDecl>(ND)->isInjectedClassName()))) {
567  AsNestedNameSpecifier = true;
568  return true;
569  }
570 
571  return false;
572  }
573  // ... then it must be interesting!
574  return true;
575 }
576 
577 bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext,
578  const NamedDecl *Hiding) {
579  // In C, there is no way to refer to a hidden name.
580  // FIXME: This isn't true; we can find a tag name hidden by an ordinary
581  // name if we introduce the tag type.
582  if (!SemaRef.getLangOpts().CPlusPlus)
583  return true;
584 
585  const DeclContext *HiddenCtx =
586  R.Declaration->getDeclContext()->getRedeclContext();
587 
588  // There is no way to qualify a name declared in a function or method.
589  if (HiddenCtx->isFunctionOrMethod())
590  return true;
591 
592  if (HiddenCtx == Hiding->getDeclContext()->getRedeclContext())
593  return true;
594 
595  // We can refer to the result with the appropriate qualification. Do it.
596  R.Hidden = true;
597  R.QualifierIsInformative = false;
598 
599  if (!R.Qualifier)
600  R.Qualifier = getRequiredQualification(SemaRef.Context,
601  CurContext,
602  R.Declaration->getDeclContext());
603  return false;
604 }
605 
606 /// A simplified classification of types used to determine whether two
607 /// types are "similar enough" when adjusting priorities.
609  switch (T->getTypeClass()) {
610  case Type::Builtin:
611  switch (cast<BuiltinType>(T)->getKind()) {
612  case BuiltinType::Void:
613  return STC_Void;
614 
615  case BuiltinType::NullPtr:
616  return STC_Pointer;
617 
618  case BuiltinType::Overload:
619  case BuiltinType::Dependent:
620  return STC_Other;
621 
622  case BuiltinType::ObjCId:
623  case BuiltinType::ObjCClass:
624  case BuiltinType::ObjCSel:
625  return STC_ObjectiveC;
626 
627  default:
628  return STC_Arithmetic;
629  }
630 
631  case Type::Complex:
632  return STC_Arithmetic;
633 
634  case Type::Pointer:
635  return STC_Pointer;
636 
637  case Type::BlockPointer:
638  return STC_Block;
639 
640  case Type::LValueReference:
641  case Type::RValueReference:
643 
644  case Type::ConstantArray:
645  case Type::IncompleteArray:
646  case Type::VariableArray:
647  case Type::DependentSizedArray:
648  return STC_Array;
649 
650  case Type::DependentSizedExtVector:
651  case Type::Vector:
652  case Type::ExtVector:
653  return STC_Arithmetic;
654 
655  case Type::FunctionProto:
656  case Type::FunctionNoProto:
657  return STC_Function;
658 
659  case Type::Record:
660  return STC_Record;
661 
662  case Type::Enum:
663  return STC_Arithmetic;
664 
665  case Type::ObjCObject:
666  case Type::ObjCInterface:
667  case Type::ObjCObjectPointer:
668  return STC_ObjectiveC;
669 
670  default:
671  return STC_Other;
672  }
673 }
674 
675 /// Get the type that a given expression will have if this declaration
676 /// is used as an expression in its "typical" code-completion form.
678  ND = ND->getUnderlyingDecl();
679 
680  if (const TypeDecl *Type = dyn_cast<TypeDecl>(ND))
681  return C.getTypeDeclType(Type);
682  if (const ObjCInterfaceDecl *Iface = dyn_cast<ObjCInterfaceDecl>(ND))
683  return C.getObjCInterfaceType(Iface);
684 
685  QualType T;
686  if (const FunctionDecl *Function = ND->getAsFunction())
687  T = Function->getCallResultType();
688  else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND))
689  T = Method->getSendResultType();
690  else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
691  T = C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext()));
692  else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND))
693  T = Property->getType();
694  else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND))
695  T = Value->getType();
696  else
697  return QualType();
698 
699  // Dig through references, function pointers, and block pointers to
700  // get down to the likely type of an expression when the entity is
701  // used.
702  do {
703  if (const ReferenceType *Ref = T->getAs<ReferenceType>()) {
704  T = Ref->getPointeeType();
705  continue;
706  }
707 
708  if (const PointerType *Pointer = T->getAs<PointerType>()) {
709  if (Pointer->getPointeeType()->isFunctionType()) {
710  T = Pointer->getPointeeType();
711  continue;
712  }
713 
714  break;
715  }
716 
717  if (const BlockPointerType *Block = T->getAs<BlockPointerType>()) {
718  T = Block->getPointeeType();
719  continue;
720  }
721 
722  if (const FunctionType *Function = T->getAs<FunctionType>()) {
723  T = Function->getReturnType();
724  continue;
725  }
726 
727  break;
728  } while (true);
729 
730  return T;
731 }
732 
733 unsigned ResultBuilder::getBasePriority(const NamedDecl *ND) {
734  if (!ND)
735  return CCP_Unlikely;
736 
737  // Context-based decisions.
738  const DeclContext *LexicalDC = ND->getLexicalDeclContext();
739  if (LexicalDC->isFunctionOrMethod()) {
740  // _cmd is relatively rare
741  if (const ImplicitParamDecl *ImplicitParam =
742  dyn_cast<ImplicitParamDecl>(ND))
743  if (ImplicitParam->getIdentifier() &&
744  ImplicitParam->getIdentifier()->isStr("_cmd"))
745  return CCP_ObjC_cmd;
746 
747  return CCP_LocalDeclaration;
748  }
749 
750  const DeclContext *DC = ND->getDeclContext()->getRedeclContext();
751  if (DC->isRecord() || isa<ObjCContainerDecl>(DC)) {
752  // Explicit destructor calls are very rare.
753  if (isa<CXXDestructorDecl>(ND))
754  return CCP_Unlikely;
755  // Explicit operator and conversion function calls are also very rare.
756  auto DeclNameKind = ND->getDeclName().getNameKind();
757  if (DeclNameKind == DeclarationName::CXXOperatorName ||
758  DeclNameKind == DeclarationName::CXXLiteralOperatorName ||
760  return CCP_Unlikely;
761  return CCP_MemberDeclaration;
762  }
763 
764  // Content-based decisions.
765  if (isa<EnumConstantDecl>(ND))
766  return CCP_Constant;
767 
768  // Use CCP_Type for type declarations unless we're in a statement, Objective-C
769  // message receiver, or parenthesized expression context. There, it's as
770  // likely that the user will want to write a type as other declarations.
771  if ((isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) &&
772  !(CompletionContext.getKind() == CodeCompletionContext::CCC_Statement ||
773  CompletionContext.getKind()
775  CompletionContext.getKind()
777  return CCP_Type;
778 
779  return CCP_Declaration;
780 }
781 
782 void ResultBuilder::AdjustResultPriorityForDecl(Result &R) {
783  // If this is an Objective-C method declaration whose selector matches our
784  // preferred selector, give it a priority boost.
785  if (!PreferredSelector.isNull())
786  if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(R.Declaration))
787  if (PreferredSelector == Method->getSelector())
788  R.Priority += CCD_SelectorMatch;
789 
790  // If we have a preferred type, adjust the priority for results with exactly-
791  // matching or nearly-matching types.
792  if (!PreferredType.isNull()) {
793  QualType T = getDeclUsageType(SemaRef.Context, R.Declaration);
794  if (!T.isNull()) {
795  CanQualType TC = SemaRef.Context.getCanonicalType(T);
796  // Check for exactly-matching types (modulo qualifiers).
797  if (SemaRef.Context.hasSameUnqualifiedType(PreferredType, TC))
798  R.Priority /= CCF_ExactTypeMatch;
799  // Check for nearly-matching types, based on classification of each.
800  else if ((getSimplifiedTypeClass(PreferredType)
801  == getSimplifiedTypeClass(TC)) &&
802  !(PreferredType->isEnumeralType() && TC->isEnumeralType()))
803  R.Priority /= CCF_SimilarTypeMatch;
804  }
805  }
806 }
807 
808 void ResultBuilder::MaybeAddConstructorResults(Result R) {
809  if (!SemaRef.getLangOpts().CPlusPlus || !R.Declaration ||
810  !CompletionContext.wantConstructorResults())
811  return;
812 
813  ASTContext &Context = SemaRef.Context;
814  const NamedDecl *D = R.Declaration;
815  const CXXRecordDecl *Record = nullptr;
816  if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D))
817  Record = ClassTemplate->getTemplatedDecl();
818  else if ((Record = dyn_cast<CXXRecordDecl>(D))) {
819  // Skip specializations and partial specializations.
820  if (isa<ClassTemplateSpecializationDecl>(Record))
821  return;
822  } else {
823  // There are no constructors here.
824  return;
825  }
826 
827  Record = Record->getDefinition();
828  if (!Record)
829  return;
830 
831 
832  QualType RecordTy = Context.getTypeDeclType(Record);
833  DeclarationName ConstructorName
835  Context.getCanonicalType(RecordTy));
836  DeclContext::lookup_result Ctors = Record->lookup(ConstructorName);
837  for (DeclContext::lookup_iterator I = Ctors.begin(),
838  E = Ctors.end();
839  I != E; ++I) {
840  R.Declaration = *I;
841  R.CursorKind = getCursorKindForDecl(R.Declaration);
842  Results.push_back(R);
843  }
844 }
845 
846 static bool isConstructor(const Decl *ND) {
847  if (const auto *Tmpl = dyn_cast<FunctionTemplateDecl>(ND))
848  ND = Tmpl->getTemplatedDecl();
849  return isa<CXXConstructorDecl>(ND);
850 }
851 
852 void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) {
853  assert(!ShadowMaps.empty() && "Must enter into a results scope");
854 
855  if (R.Kind != Result::RK_Declaration) {
856  // For non-declaration results, just add the result.
857  Results.push_back(R);
858  return;
859  }
860 
861  // Look through using declarations.
862  if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
863  CodeCompletionResult Result(Using->getTargetDecl(),
864  getBasePriority(Using->getTargetDecl()),
865  R.Qualifier);
866  Result.ShadowDecl = Using;
867  MaybeAddResult(Result, CurContext);
868  return;
869  }
870 
871  const Decl *CanonDecl = R.Declaration->getCanonicalDecl();
872  unsigned IDNS = CanonDecl->getIdentifierNamespace();
873 
874  bool AsNestedNameSpecifier = false;
875  if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
876  return;
877 
878  // C++ constructors are never found by name lookup.
879  if (isConstructor(R.Declaration))
880  return;
881 
882  ShadowMap &SMap = ShadowMaps.back();
883  ShadowMapEntry::iterator I, IEnd;
884  ShadowMap::iterator NamePos = SMap.find(R.Declaration->getDeclName());
885  if (NamePos != SMap.end()) {
886  I = NamePos->second.begin();
887  IEnd = NamePos->second.end();
888  }
889 
890  for (; I != IEnd; ++I) {
891  const NamedDecl *ND = I->first;
892  unsigned Index = I->second;
893  if (ND->getCanonicalDecl() == CanonDecl) {
894  // This is a redeclaration. Always pick the newer declaration.
895  Results[Index].Declaration = R.Declaration;
896 
897  // We're done.
898  return;
899  }
900  }
901 
902  // This is a new declaration in this scope. However, check whether this
903  // declaration name is hidden by a similarly-named declaration in an outer
904  // scope.
905  std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end();
906  --SMEnd;
907  for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) {
908  ShadowMapEntry::iterator I, IEnd;
909  ShadowMap::iterator NamePos = SM->find(R.Declaration->getDeclName());
910  if (NamePos != SM->end()) {
911  I = NamePos->second.begin();
912  IEnd = NamePos->second.end();
913  }
914  for (; I != IEnd; ++I) {
915  // A tag declaration does not hide a non-tag declaration.
916  if (I->first->hasTagIdentifierNamespace() &&
919  continue;
920 
921  // Protocols are in distinct namespaces from everything else.
922  if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol)
923  || (IDNS & Decl::IDNS_ObjCProtocol)) &&
924  I->first->getIdentifierNamespace() != IDNS)
925  continue;
926 
927  // The newly-added result is hidden by an entry in the shadow map.
928  if (CheckHiddenResult(R, CurContext, I->first))
929  return;
930 
931  break;
932  }
933  }
934 
935  // Make sure that any given declaration only shows up in the result set once.
936  if (!AllDeclsFound.insert(CanonDecl).second)
937  return;
938 
939  // If the filter is for nested-name-specifiers, then this result starts a
940  // nested-name-specifier.
941  if (AsNestedNameSpecifier) {
942  R.StartsNestedNameSpecifier = true;
943  R.Priority = CCP_NestedNameSpecifier;
944  } else
945  AdjustResultPriorityForDecl(R);
946 
947  // If this result is supposed to have an informative qualifier, add one.
948  if (R.QualifierIsInformative && !R.Qualifier &&
949  !R.StartsNestedNameSpecifier) {
950  const DeclContext *Ctx = R.Declaration->getDeclContext();
951  if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
952  R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr,
953  Namespace);
954  else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
955  R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr,
956  false, SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
957  else
958  R.QualifierIsInformative = false;
959  }
960 
961  // Insert this result into the set of results and into the current shadow
962  // map.
963  SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
964  Results.push_back(R);
965 
966  if (!AsNestedNameSpecifier)
967  MaybeAddConstructorResults(R);
968 }
969 
970 void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
971  NamedDecl *Hiding, bool InBaseClass = false) {
972  if (R.Kind != Result::RK_Declaration) {
973  // For non-declaration results, just add the result.
974  Results.push_back(R);
975  return;
976  }
977 
978  // Look through using declarations.
979  if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
980  CodeCompletionResult Result(Using->getTargetDecl(),
981  getBasePriority(Using->getTargetDecl()),
982  R.Qualifier);
983  Result.ShadowDecl = Using;
984  AddResult(Result, CurContext, Hiding);
985  return;
986  }
987 
988  bool AsNestedNameSpecifier = false;
989  if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
990  return;
991 
992  // C++ constructors are never found by name lookup.
993  if (isConstructor(R.Declaration))
994  return;
995 
996  if (Hiding && CheckHiddenResult(R, CurContext, Hiding))
997  return;
998 
999  // Make sure that any given declaration only shows up in the result set once.
1000  if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()).second)
1001  return;
1002 
1003  // If the filter is for nested-name-specifiers, then this result starts a
1004  // nested-name-specifier.
1005  if (AsNestedNameSpecifier) {
1006  R.StartsNestedNameSpecifier = true;
1007  R.Priority = CCP_NestedNameSpecifier;
1008  } else if (Filter == &ResultBuilder::IsMember && !R.Qualifier &&
1009  InBaseClass &&
1010  isa<CXXRecordDecl>(
1011  R.Declaration->getDeclContext()->getRedeclContext()))
1012  R.QualifierIsInformative = true;
1013 
1014  // If this result is supposed to have an informative qualifier, add one.
1015  if (R.QualifierIsInformative && !R.Qualifier &&
1016  !R.StartsNestedNameSpecifier) {
1017  const DeclContext *Ctx = R.Declaration->getDeclContext();
1018  if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
1019  R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr,
1020  Namespace);
1021  else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
1022  R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr, false,
1023  SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
1024  else
1025  R.QualifierIsInformative = false;
1026  }
1027 
1028  // Adjust the priority if this result comes from a base class.
1029  if (InBaseClass)
1030  R.Priority += CCD_InBaseClass;
1031 
1032  AdjustResultPriorityForDecl(R);
1033 
1034  if (HasObjectTypeQualifiers)
1035  if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(R.Declaration))
1036  if (Method->isInstance()) {
1037  Qualifiers MethodQuals
1038  = Qualifiers::fromCVRMask(Method->getTypeQualifiers());
1039  if (ObjectTypeQualifiers == MethodQuals)
1040  R.Priority += CCD_ObjectQualifierMatch;
1041  else if (ObjectTypeQualifiers - MethodQuals) {
1042  // The method cannot be invoked, because doing so would drop
1043  // qualifiers.
1044  return;
1045  }
1046  }
1047 
1048  // Insert this result into the set of results.
1049  Results.push_back(R);
1050 
1051  if (!AsNestedNameSpecifier)
1052  MaybeAddConstructorResults(R);
1053 }
1054 
1055 void ResultBuilder::AddResult(Result R) {
1056  assert(R.Kind != Result::RK_Declaration &&
1057  "Declaration results need more context");
1058  Results.push_back(R);
1059 }
1060 
1061 /// Enter into a new scope.
1062 void ResultBuilder::EnterNewScope() { ShadowMaps.emplace_back(); }
1063 
1064 /// Exit from the current scope.
1065 void ResultBuilder::ExitScope() {
1066  for (ShadowMap::iterator E = ShadowMaps.back().begin(),
1067  EEnd = ShadowMaps.back().end();
1068  E != EEnd;
1069  ++E)
1070  E->second.Destroy();
1071 
1072  ShadowMaps.pop_back();
1073 }
1074 
1075 /// Determines whether this given declaration will be found by
1076 /// ordinary name lookup.
1077 bool ResultBuilder::IsOrdinaryName(const NamedDecl *ND) const {
1078  ND = ND->getUnderlyingDecl();
1079 
1080  // If name lookup finds a local extern declaration, then we are in a
1081  // context where it behaves like an ordinary name.
1082  unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1083  if (SemaRef.getLangOpts().CPlusPlus)
1085  else if (SemaRef.getLangOpts().ObjC1) {
1086  if (isa<ObjCIvarDecl>(ND))
1087  return true;
1088  }
1089 
1090  return ND->getIdentifierNamespace() & IDNS;
1091 }
1092 
1093 /// Determines whether this given declaration will be found by
1094 /// ordinary name lookup but is not a type name.
1095 bool ResultBuilder::IsOrdinaryNonTypeName(const NamedDecl *ND) const {
1096  ND = ND->getUnderlyingDecl();
1097  if (isa<TypeDecl>(ND))
1098  return false;
1099  // Objective-C interfaces names are not filtered by this method because they
1100  // can be used in a class property expression. We can still filter out
1101  // @class declarations though.
1102  if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND)) {
1103  if (!ID->getDefinition())
1104  return false;
1105  }
1106 
1107  unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1108  if (SemaRef.getLangOpts().CPlusPlus)
1110  else if (SemaRef.getLangOpts().ObjC1) {
1111  if (isa<ObjCIvarDecl>(ND))
1112  return true;
1113  }
1114 
1115  return ND->getIdentifierNamespace() & IDNS;
1116 }
1117 
1118 bool ResultBuilder::IsIntegralConstantValue(const NamedDecl *ND) const {
1119  if (!IsOrdinaryNonTypeName(ND))
1120  return 0;
1121 
1122  if (const ValueDecl *VD = dyn_cast<ValueDecl>(ND->getUnderlyingDecl()))
1123  if (VD->getType()->isIntegralOrEnumerationType())
1124  return true;
1125 
1126  return false;
1127 }
1128 
1129 /// Determines whether this given declaration will be found by
1130 /// ordinary name lookup.
1131 bool ResultBuilder::IsOrdinaryNonValueName(const NamedDecl *ND) const {
1132  ND = ND->getUnderlyingDecl();
1133 
1134  unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1135  if (SemaRef.getLangOpts().CPlusPlus)
1137 
1138  return (ND->getIdentifierNamespace() & IDNS) &&
1139  !isa<ValueDecl>(ND) && !isa<FunctionTemplateDecl>(ND) &&
1140  !isa<ObjCPropertyDecl>(ND);
1141 }
1142 
1143 /// Determines whether the given declaration is suitable as the
1144 /// start of a C++ nested-name-specifier, e.g., a class or namespace.
1145 bool ResultBuilder::IsNestedNameSpecifier(const NamedDecl *ND) const {
1146  // Allow us to find class templates, too.
1147  if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1148  ND = ClassTemplate->getTemplatedDecl();
1149 
1150  return SemaRef.isAcceptableNestedNameSpecifier(ND);
1151 }
1152 
1153 /// Determines whether the given declaration is an enumeration.
1154 bool ResultBuilder::IsEnum(const NamedDecl *ND) const {
1155  return isa<EnumDecl>(ND);
1156 }
1157 
1158 /// Determines whether the given declaration is a class or struct.
1159 bool ResultBuilder::IsClassOrStruct(const NamedDecl *ND) const {
1160  // Allow us to find class templates, too.
1161  if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1162  ND = ClassTemplate->getTemplatedDecl();
1163 
1164  // For purposes of this check, interfaces match too.
1165  if (const RecordDecl *RD = dyn_cast<RecordDecl>(ND))
1166  return RD->getTagKind() == TTK_Class ||
1167  RD->getTagKind() == TTK_Struct ||
1168  RD->getTagKind() == TTK_Interface;
1169 
1170  return false;
1171 }
1172 
1173 /// Determines whether the given declaration is a union.
1174 bool ResultBuilder::IsUnion(const NamedDecl *ND) const {
1175  // Allow us to find class templates, too.
1176  if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1177  ND = ClassTemplate->getTemplatedDecl();
1178 
1179  if (const RecordDecl *RD = dyn_cast<RecordDecl>(ND))
1180  return RD->getTagKind() == TTK_Union;
1181 
1182  return false;
1183 }
1184 
1185 /// Determines whether the given declaration is a namespace.
1186 bool ResultBuilder::IsNamespace(const NamedDecl *ND) const {
1187  return isa<NamespaceDecl>(ND);
1188 }
1189 
1190 /// Determines whether the given declaration is a namespace or
1191 /// namespace alias.
1192 bool ResultBuilder::IsNamespaceOrAlias(const NamedDecl *ND) const {
1193  return isa<NamespaceDecl>(ND->getUnderlyingDecl());
1194 }
1195 
1196 /// Determines whether the given declaration is a type.
1197 bool ResultBuilder::IsType(const NamedDecl *ND) const {
1198  ND = ND->getUnderlyingDecl();
1199  return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
1200 }
1201 
1202 /// Determines which members of a class should be visible via
1203 /// "." or "->". Only value declarations, nested name specifiers, and
1204 /// using declarations thereof should show up.
1205 bool ResultBuilder::IsMember(const NamedDecl *ND) const {
1206  ND = ND->getUnderlyingDecl();
1207  return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) ||
1208  isa<ObjCPropertyDecl>(ND);
1209 }
1210 
1212  T = C.getCanonicalType(T);
1213  switch (T->getTypeClass()) {
1214  case Type::ObjCObject:
1215  case Type::ObjCInterface:
1216  case Type::ObjCObjectPointer:
1217  return true;
1218 
1219  case Type::Builtin:
1220  switch (cast<BuiltinType>(T)->getKind()) {
1221  case BuiltinType::ObjCId:
1222  case BuiltinType::ObjCClass:
1223  case BuiltinType::ObjCSel:
1224  return true;
1225 
1226  default:
1227  break;
1228  }
1229  return false;
1230 
1231  default:
1232  break;
1233  }
1234 
1235  if (!C.getLangOpts().CPlusPlus)
1236  return false;
1237 
1238  // FIXME: We could perform more analysis here to determine whether a
1239  // particular class type has any conversions to Objective-C types. For now,
1240  // just accept all class types.
1241  return T->isDependentType() || T->isRecordType();
1242 }
1243 
1244 bool ResultBuilder::IsObjCMessageReceiver(const NamedDecl *ND) const {
1245  QualType T = getDeclUsageType(SemaRef.Context, ND);
1246  if (T.isNull())
1247  return false;
1248 
1249  T = SemaRef.Context.getBaseElementType(T);
1250  return isObjCReceiverType(SemaRef.Context, T);
1251 }
1252 
1253 bool ResultBuilder::IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const {
1254  if (IsObjCMessageReceiver(ND))
1255  return true;
1256 
1257  const VarDecl *Var = dyn_cast<VarDecl>(ND);
1258  if (!Var)
1259  return false;
1260 
1261  return Var->hasLocalStorage() && !Var->hasAttr<BlocksAttr>();
1262 }
1263 
1264 bool ResultBuilder::IsObjCCollection(const NamedDecl *ND) const {
1265  if ((SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryName(ND)) ||
1266  (!SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryNonTypeName(ND)))
1267  return false;
1268 
1269  QualType T = getDeclUsageType(SemaRef.Context, ND);
1270  if (T.isNull())
1271  return false;
1272 
1273  T = SemaRef.Context.getBaseElementType(T);
1274  return T->isObjCObjectType() || T->isObjCObjectPointerType() ||
1275  T->isObjCIdType() ||
1276  (SemaRef.getLangOpts().CPlusPlus && T->isRecordType());
1277 }
1278 
1279 bool ResultBuilder::IsImpossibleToSatisfy(const NamedDecl *ND) const {
1280  return false;
1281 }
1282 
1283 /// Determines whether the given declaration is an Objective-C
1284 /// instance variable.
1285 bool ResultBuilder::IsObjCIvar(const NamedDecl *ND) const {
1286  return isa<ObjCIvarDecl>(ND);
1287 }
1288 
1289 namespace {
1290  /// Visible declaration consumer that adds a code-completion result
1291  /// for each visible declaration.
1292  class CodeCompletionDeclConsumer : public VisibleDeclConsumer {
1293  ResultBuilder &Results;
1294  DeclContext *CurContext;
1295  std::vector<FixItHint> FixIts;
1296 
1297  public:
1298  CodeCompletionDeclConsumer(
1299  ResultBuilder &Results, DeclContext *CurContext,
1300  std::vector<FixItHint> FixIts = std::vector<FixItHint>())
1301  : Results(Results), CurContext(CurContext), FixIts(std::move(FixIts)) {}
1302 
1303  void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
1304  bool InBaseClass) override {
1305  bool Accessible = true;
1306  if (Ctx)
1307  Accessible = Results.getSema().IsSimplyAccessible(ND, Ctx);
1308  ResultBuilder::Result Result(ND, Results.getBasePriority(ND), nullptr,
1309  false, Accessible, FixIts);
1310  Results.AddResult(Result, CurContext, Hiding, InBaseClass);
1311  }
1312 
1313  void EnteredContext(DeclContext* Ctx) override {
1314  Results.addVisitedContext(Ctx);
1315  }
1316  };
1317 }
1318 
1319 /// Add type specifiers for the current language as keyword results.
1320 static void AddTypeSpecifierResults(const LangOptions &LangOpts,
1321  ResultBuilder &Results) {
1322  typedef CodeCompletionResult Result;
1323  Results.AddResult(Result("short", CCP_Type));
1324  Results.AddResult(Result("long", CCP_Type));
1325  Results.AddResult(Result("signed", CCP_Type));
1326  Results.AddResult(Result("unsigned", CCP_Type));
1327  Results.AddResult(Result("void", CCP_Type));
1328  Results.AddResult(Result("char", CCP_Type));
1329  Results.AddResult(Result("int", CCP_Type));
1330  Results.AddResult(Result("float", CCP_Type));
1331  Results.AddResult(Result("double", CCP_Type));
1332  Results.AddResult(Result("enum", CCP_Type));
1333  Results.AddResult(Result("struct", CCP_Type));
1334  Results.AddResult(Result("union", CCP_Type));
1335  Results.AddResult(Result("const", CCP_Type));
1336  Results.AddResult(Result("volatile", CCP_Type));
1337 
1338  if (LangOpts.C99) {
1339  // C99-specific
1340  Results.AddResult(Result("_Complex", CCP_Type));
1341  Results.AddResult(Result("_Imaginary", CCP_Type));
1342  Results.AddResult(Result("_Bool", CCP_Type));
1343  Results.AddResult(Result("restrict", CCP_Type));
1344  }
1345 
1346  CodeCompletionBuilder Builder(Results.getAllocator(),
1347  Results.getCodeCompletionTUInfo());
1348  if (LangOpts.CPlusPlus) {
1349  // C++-specific
1350  Results.AddResult(Result("bool", CCP_Type +
1351  (LangOpts.ObjC1? CCD_bool_in_ObjC : 0)));
1352  Results.AddResult(Result("class", CCP_Type));
1353  Results.AddResult(Result("wchar_t", CCP_Type));
1354 
1355  // typename qualified-id
1356  Builder.AddTypedTextChunk("typename");
1357  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1358  Builder.AddPlaceholderChunk("qualifier");
1359  Builder.AddTextChunk("::");
1360  Builder.AddPlaceholderChunk("name");
1361  Results.AddResult(Result(Builder.TakeString()));
1362 
1363  if (LangOpts.CPlusPlus11) {
1364  Results.AddResult(Result("auto", CCP_Type));
1365  Results.AddResult(Result("char16_t", CCP_Type));
1366  Results.AddResult(Result("char32_t", CCP_Type));
1367 
1368  Builder.AddTypedTextChunk("decltype");
1369  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1370  Builder.AddPlaceholderChunk("expression");
1371  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1372  Results.AddResult(Result(Builder.TakeString()));
1373  }
1374  } else
1375  Results.AddResult(Result("__auto_type", CCP_Type));
1376 
1377  // GNU keywords
1378  if (LangOpts.GNUKeywords) {
1379  // FIXME: Enable when we actually support decimal floating point.
1380  // Results.AddResult(Result("_Decimal32"));
1381  // Results.AddResult(Result("_Decimal64"));
1382  // Results.AddResult(Result("_Decimal128"));
1383 
1384  Builder.AddTypedTextChunk("typeof");
1385  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1386  Builder.AddPlaceholderChunk("expression");
1387  Results.AddResult(Result(Builder.TakeString()));
1388 
1389  Builder.AddTypedTextChunk("typeof");
1390  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1391  Builder.AddPlaceholderChunk("type");
1392  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1393  Results.AddResult(Result(Builder.TakeString()));
1394  }
1395 
1396  // Nullability
1397  Results.AddResult(Result("_Nonnull", CCP_Type));
1398  Results.AddResult(Result("_Null_unspecified", CCP_Type));
1399  Results.AddResult(Result("_Nullable", CCP_Type));
1400 }
1401 
1403  const LangOptions &LangOpts,
1404  ResultBuilder &Results) {
1405  typedef CodeCompletionResult Result;
1406  // Note: we don't suggest either "auto" or "register", because both
1407  // are pointless as storage specifiers. Elsewhere, we suggest "auto"
1408  // in C++0x as a type specifier.
1409  Results.AddResult(Result("extern"));
1410  Results.AddResult(Result("static"));
1411 
1412  if (LangOpts.CPlusPlus11) {
1413  CodeCompletionAllocator &Allocator = Results.getAllocator();
1414  CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1415 
1416  // alignas
1417  Builder.AddTypedTextChunk("alignas");
1418  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1419  Builder.AddPlaceholderChunk("expression");
1420  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1421  Results.AddResult(Result(Builder.TakeString()));
1422 
1423  Results.AddResult(Result("constexpr"));
1424  Results.AddResult(Result("thread_local"));
1425  }
1426 }
1427 
1429  const LangOptions &LangOpts,
1430  ResultBuilder &Results) {
1431  typedef CodeCompletionResult Result;
1432  switch (CCC) {
1433  case Sema::PCC_Class:
1435  if (LangOpts.CPlusPlus) {
1436  Results.AddResult(Result("explicit"));
1437  Results.AddResult(Result("friend"));
1438  Results.AddResult(Result("mutable"));
1439  Results.AddResult(Result("virtual"));
1440  }
1441  LLVM_FALLTHROUGH;
1442 
1445  case Sema::PCC_Namespace:
1446  case Sema::PCC_Template:
1447  if (LangOpts.CPlusPlus || LangOpts.C99)
1448  Results.AddResult(Result("inline"));
1449  break;
1450 
1452  case Sema::PCC_Expression:
1453  case Sema::PCC_Statement:
1454  case Sema::PCC_ForInit:
1455  case Sema::PCC_Condition:
1457  case Sema::PCC_Type:
1460  break;
1461  }
1462 }
1463 
1464 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt);
1465 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt);
1466 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
1467  ResultBuilder &Results,
1468  bool NeedAt);
1469 static void AddObjCImplementationResults(const LangOptions &LangOpts,
1470  ResultBuilder &Results,
1471  bool NeedAt);
1472 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
1473  ResultBuilder &Results,
1474  bool NeedAt);
1475 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt);
1476 
1477 static void AddTypedefResult(ResultBuilder &Results) {
1478  CodeCompletionBuilder Builder(Results.getAllocator(),
1479  Results.getCodeCompletionTUInfo());
1480  Builder.AddTypedTextChunk("typedef");
1481  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1482  Builder.AddPlaceholderChunk("type");
1483  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1484  Builder.AddPlaceholderChunk("name");
1485  Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1486 }
1487 
1489  const LangOptions &LangOpts) {
1490  switch (CCC) {
1491  case Sema::PCC_Namespace:
1492  case Sema::PCC_Class:
1494  case Sema::PCC_Template:
1496  case Sema::PCC_Statement:
1498  case Sema::PCC_Type:
1501  return true;
1502 
1503  case Sema::PCC_Expression:
1504  case Sema::PCC_Condition:
1505  return LangOpts.CPlusPlus;
1506 
1509  return false;
1510 
1511  case Sema::PCC_ForInit:
1512  return LangOpts.CPlusPlus || LangOpts.ObjC1 || LangOpts.C99;
1513  }
1514 
1515  llvm_unreachable("Invalid ParserCompletionContext!");
1516 }
1517 
1519  const Preprocessor &PP) {
1520  PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP);
1521  Policy.AnonymousTagLocations = false;
1522  Policy.SuppressStrongLifetime = true;
1523  Policy.SuppressUnwrittenScope = true;
1524  Policy.SuppressScope = true;
1525  return Policy;
1526 }
1527 
1528 /// Retrieve a printing policy suitable for code completion.
1530  return getCompletionPrintingPolicy(S.Context, S.PP);
1531 }
1532 
1533 /// Retrieve the string representation of the given type as a string
1534 /// that has the appropriate lifetime for code completion.
1535 ///
1536 /// This routine provides a fast path where we provide constant strings for
1537 /// common type names.
1538 static const char *GetCompletionTypeString(QualType T,
1539  ASTContext &Context,
1540  const PrintingPolicy &Policy,
1541  CodeCompletionAllocator &Allocator) {
1542  if (!T.getLocalQualifiers()) {
1543  // Built-in type names are constant strings.
1544  if (const BuiltinType *BT = dyn_cast<BuiltinType>(T))
1545  return BT->getNameAsCString(Policy);
1546 
1547  // Anonymous tag types are constant strings.
1548  if (const TagType *TagT = dyn_cast<TagType>(T))
1549  if (TagDecl *Tag = TagT->getDecl())
1550  if (!Tag->hasNameForLinkage()) {
1551  switch (Tag->getTagKind()) {
1552  case TTK_Struct: return "struct <anonymous>";
1553  case TTK_Interface: return "__interface <anonymous>";
1554  case TTK_Class: return "class <anonymous>";
1555  case TTK_Union: return "union <anonymous>";
1556  case TTK_Enum: return "enum <anonymous>";
1557  }
1558  }
1559  }
1560 
1561  // Slow path: format the type as a string.
1562  std::string Result;
1563  T.getAsStringInternal(Result, Policy);
1564  return Allocator.CopyString(Result);
1565 }
1566 
1567 /// Add a completion for "this", if we're in a member function.
1568 static void addThisCompletion(Sema &S, ResultBuilder &Results) {
1569  QualType ThisTy = S.getCurrentThisType();
1570  if (ThisTy.isNull())
1571  return;
1572 
1573  CodeCompletionAllocator &Allocator = Results.getAllocator();
1574  CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1576  Builder.AddResultTypeChunk(GetCompletionTypeString(ThisTy,
1577  S.Context,
1578  Policy,
1579  Allocator));
1580  Builder.AddTypedTextChunk("this");
1581  Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1582 }
1583 
1585  ResultBuilder &Results,
1586  const LangOptions &LangOpts) {
1587  if (!LangOpts.CPlusPlus11)
1588  return;
1589 
1590  Builder.AddTypedTextChunk("static_assert");
1592  Builder.AddPlaceholderChunk("expression");
1594  Builder.AddPlaceholderChunk("message");
1596  Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1597 }
1598 
1599 /// Add language constructs that show up for "ordinary" names.
1601  Scope *S,
1602  Sema &SemaRef,
1603  ResultBuilder &Results) {
1604  CodeCompletionAllocator &Allocator = Results.getAllocator();
1605  CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1606 
1607  typedef CodeCompletionResult Result;
1608  switch (CCC) {
1609  case Sema::PCC_Namespace:
1610  if (SemaRef.getLangOpts().CPlusPlus) {
1611  if (Results.includeCodePatterns()) {
1612  // namespace <identifier> { declarations }
1613  Builder.AddTypedTextChunk("namespace");
1614  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1615  Builder.AddPlaceholderChunk("identifier");
1616  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1617  Builder.AddPlaceholderChunk("declarations");
1618  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1619  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1620  Results.AddResult(Result(Builder.TakeString()));
1621  }
1622 
1623  // namespace identifier = identifier ;
1624  Builder.AddTypedTextChunk("namespace");
1625  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1626  Builder.AddPlaceholderChunk("name");
1627  Builder.AddChunk(CodeCompletionString::CK_Equal);
1628  Builder.AddPlaceholderChunk("namespace");
1629  Results.AddResult(Result(Builder.TakeString()));
1630 
1631  // Using directives
1632  Builder.AddTypedTextChunk("using");
1633  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1634  Builder.AddTextChunk("namespace");
1635  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1636  Builder.AddPlaceholderChunk("identifier");
1637  Results.AddResult(Result(Builder.TakeString()));
1638 
1639  // asm(string-literal)
1640  Builder.AddTypedTextChunk("asm");
1641  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1642  Builder.AddPlaceholderChunk("string-literal");
1643  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1644  Results.AddResult(Result(Builder.TakeString()));
1645 
1646  if (Results.includeCodePatterns()) {
1647  // Explicit template instantiation
1648  Builder.AddTypedTextChunk("template");
1649  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1650  Builder.AddPlaceholderChunk("declaration");
1651  Results.AddResult(Result(Builder.TakeString()));
1652  }
1653  }
1654 
1655  if (SemaRef.getLangOpts().ObjC1)
1656  AddObjCTopLevelResults(Results, true);
1657 
1658  AddTypedefResult(Results);
1659  LLVM_FALLTHROUGH;
1660 
1661  case Sema::PCC_Class:
1662  if (SemaRef.getLangOpts().CPlusPlus) {
1663  // Using declaration
1664  Builder.AddTypedTextChunk("using");
1665  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1666  Builder.AddPlaceholderChunk("qualifier");
1667  Builder.AddTextChunk("::");
1668  Builder.AddPlaceholderChunk("name");
1669  Results.AddResult(Result(Builder.TakeString()));
1670 
1671  // using typename qualifier::name (only in a dependent context)
1672  if (SemaRef.CurContext->isDependentContext()) {
1673  Builder.AddTypedTextChunk("using");
1674  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1675  Builder.AddTextChunk("typename");
1676  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1677  Builder.AddPlaceholderChunk("qualifier");
1678  Builder.AddTextChunk("::");
1679  Builder.AddPlaceholderChunk("name");
1680  Results.AddResult(Result(Builder.TakeString()));
1681  }
1682 
1683  AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts());
1684 
1685  if (CCC == Sema::PCC_Class) {
1686  AddTypedefResult(Results);
1687 
1688  bool IsNotInheritanceScope =
1690  // public:
1691  Builder.AddTypedTextChunk("public");
1692  if (IsNotInheritanceScope && Results.includeCodePatterns())
1693  Builder.AddChunk(CodeCompletionString::CK_Colon);
1694  Results.AddResult(Result(Builder.TakeString()));
1695 
1696  // protected:
1697  Builder.AddTypedTextChunk("protected");
1698  if (IsNotInheritanceScope && Results.includeCodePatterns())
1699  Builder.AddChunk(CodeCompletionString::CK_Colon);
1700  Results.AddResult(Result(Builder.TakeString()));
1701 
1702  // private:
1703  Builder.AddTypedTextChunk("private");
1704  if (IsNotInheritanceScope && Results.includeCodePatterns())
1705  Builder.AddChunk(CodeCompletionString::CK_Colon);
1706  Results.AddResult(Result(Builder.TakeString()));
1707  }
1708  }
1709  LLVM_FALLTHROUGH;
1710 
1711  case Sema::PCC_Template:
1713  if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) {
1714  // template < parameters >
1715  Builder.AddTypedTextChunk("template");
1716  Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1717  Builder.AddPlaceholderChunk("parameters");
1718  Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1719  Results.AddResult(Result(Builder.TakeString()));
1720  }
1721 
1722  AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1723  AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1724  break;
1725 
1727  AddObjCInterfaceResults(SemaRef.getLangOpts(), Results, true);
1728  AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1729  AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1730  break;
1731 
1733  AddObjCImplementationResults(SemaRef.getLangOpts(), Results, true);
1734  AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1735  AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1736  break;
1737 
1739  AddObjCVisibilityResults(SemaRef.getLangOpts(), Results, true);
1740  break;
1741 
1743  case Sema::PCC_Statement: {
1744  AddTypedefResult(Results);
1745 
1746  if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns() &&
1747  SemaRef.getLangOpts().CXXExceptions) {
1748  Builder.AddTypedTextChunk("try");
1749  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1750  Builder.AddPlaceholderChunk("statements");
1751  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1752  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1753  Builder.AddTextChunk("catch");
1754  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1755  Builder.AddPlaceholderChunk("declaration");
1756  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1757  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1758  Builder.AddPlaceholderChunk("statements");
1759  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1760  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1761  Results.AddResult(Result(Builder.TakeString()));
1762  }
1763  if (SemaRef.getLangOpts().ObjC1)
1764  AddObjCStatementResults(Results, true);
1765 
1766  if (Results.includeCodePatterns()) {
1767  // if (condition) { statements }
1768  Builder.AddTypedTextChunk("if");
1769  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1770  if (SemaRef.getLangOpts().CPlusPlus)
1771  Builder.AddPlaceholderChunk("condition");
1772  else
1773  Builder.AddPlaceholderChunk("expression");
1774  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1775  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1776  Builder.AddPlaceholderChunk("statements");
1777  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1778  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1779  Results.AddResult(Result(Builder.TakeString()));
1780 
1781  // switch (condition) { }
1782  Builder.AddTypedTextChunk("switch");
1783  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1784  if (SemaRef.getLangOpts().CPlusPlus)
1785  Builder.AddPlaceholderChunk("condition");
1786  else
1787  Builder.AddPlaceholderChunk("expression");
1788  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1789  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1790  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1791  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1792  Results.AddResult(Result(Builder.TakeString()));
1793  }
1794 
1795  // Switch-specific statements.
1796  if (!SemaRef.getCurFunction()->SwitchStack.empty()) {
1797  // case expression:
1798  Builder.AddTypedTextChunk("case");
1799  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1800  Builder.AddPlaceholderChunk("expression");
1801  Builder.AddChunk(CodeCompletionString::CK_Colon);
1802  Results.AddResult(Result(Builder.TakeString()));
1803 
1804  // default:
1805  Builder.AddTypedTextChunk("default");
1806  Builder.AddChunk(CodeCompletionString::CK_Colon);
1807  Results.AddResult(Result(Builder.TakeString()));
1808  }
1809 
1810  if (Results.includeCodePatterns()) {
1811  /// while (condition) { statements }
1812  Builder.AddTypedTextChunk("while");
1813  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1814  if (SemaRef.getLangOpts().CPlusPlus)
1815  Builder.AddPlaceholderChunk("condition");
1816  else
1817  Builder.AddPlaceholderChunk("expression");
1818  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1819  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1820  Builder.AddPlaceholderChunk("statements");
1821  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1822  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1823  Results.AddResult(Result(Builder.TakeString()));
1824 
1825  // do { statements } while ( expression );
1826  Builder.AddTypedTextChunk("do");
1827  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1828  Builder.AddPlaceholderChunk("statements");
1829  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1830  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1831  Builder.AddTextChunk("while");
1832  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1833  Builder.AddPlaceholderChunk("expression");
1834  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1835  Results.AddResult(Result(Builder.TakeString()));
1836 
1837  // for ( for-init-statement ; condition ; expression ) { statements }
1838  Builder.AddTypedTextChunk("for");
1839  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1840  if (SemaRef.getLangOpts().CPlusPlus || SemaRef.getLangOpts().C99)
1841  Builder.AddPlaceholderChunk("init-statement");
1842  else
1843  Builder.AddPlaceholderChunk("init-expression");
1844  Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1845  Builder.AddPlaceholderChunk("condition");
1846  Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1847  Builder.AddPlaceholderChunk("inc-expression");
1848  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1849  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1850  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1851  Builder.AddPlaceholderChunk("statements");
1852  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1853  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1854  Results.AddResult(Result(Builder.TakeString()));
1855  }
1856 
1857  if (S->getContinueParent()) {
1858  // continue ;
1859  Builder.AddTypedTextChunk("continue");
1860  Results.AddResult(Result(Builder.TakeString()));
1861  }
1862 
1863  if (S->getBreakParent()) {
1864  // break ;
1865  Builder.AddTypedTextChunk("break");
1866  Results.AddResult(Result(Builder.TakeString()));
1867  }
1868 
1869  // "return expression ;" or "return ;", depending on whether we
1870  // know the function is void or not.
1871  bool isVoid = false;
1872  if (FunctionDecl *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext))
1873  isVoid = Function->getReturnType()->isVoidType();
1874  else if (ObjCMethodDecl *Method
1875  = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext))
1876  isVoid = Method->getReturnType()->isVoidType();
1877  else if (SemaRef.getCurBlock() &&
1878  !SemaRef.getCurBlock()->ReturnType.isNull())
1879  isVoid = SemaRef.getCurBlock()->ReturnType->isVoidType();
1880  Builder.AddTypedTextChunk("return");
1881  if (!isVoid) {
1882  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1883  Builder.AddPlaceholderChunk("expression");
1884  }
1885  Results.AddResult(Result(Builder.TakeString()));
1886 
1887  // goto identifier ;
1888  Builder.AddTypedTextChunk("goto");
1889  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1890  Builder.AddPlaceholderChunk("label");
1891  Results.AddResult(Result(Builder.TakeString()));
1892 
1893  // Using directives
1894  Builder.AddTypedTextChunk("using");
1895  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1896  Builder.AddTextChunk("namespace");
1897  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1898  Builder.AddPlaceholderChunk("identifier");
1899  Results.AddResult(Result(Builder.TakeString()));
1900 
1901  AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts());
1902  }
1903  LLVM_FALLTHROUGH;
1904 
1905  // Fall through (for statement expressions).
1906  case Sema::PCC_ForInit:
1907  case Sema::PCC_Condition:
1908  AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1909  // Fall through: conditions and statements can have expressions.
1910  LLVM_FALLTHROUGH;
1911 
1913  if (SemaRef.getLangOpts().ObjCAutoRefCount &&
1915  // (__bridge <type>)<expression>
1916  Builder.AddTypedTextChunk("__bridge");
1917  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1918  Builder.AddPlaceholderChunk("type");
1919  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1920  Builder.AddPlaceholderChunk("expression");
1921  Results.AddResult(Result(Builder.TakeString()));
1922 
1923  // (__bridge_transfer <Objective-C type>)<expression>
1924  Builder.AddTypedTextChunk("__bridge_transfer");
1925  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1926  Builder.AddPlaceholderChunk("Objective-C type");
1927  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1928  Builder.AddPlaceholderChunk("expression");
1929  Results.AddResult(Result(Builder.TakeString()));
1930 
1931  // (__bridge_retained <CF type>)<expression>
1932  Builder.AddTypedTextChunk("__bridge_retained");
1933  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1934  Builder.AddPlaceholderChunk("CF type");
1935  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1936  Builder.AddPlaceholderChunk("expression");
1937  Results.AddResult(Result(Builder.TakeString()));
1938  }
1939  // Fall through
1940  LLVM_FALLTHROUGH;
1941 
1942  case Sema::PCC_Expression: {
1943  if (SemaRef.getLangOpts().CPlusPlus) {
1944  // 'this', if we're in a non-static member function.
1945  addThisCompletion(SemaRef, Results);
1946 
1947  // true
1948  Builder.AddResultTypeChunk("bool");
1949  Builder.AddTypedTextChunk("true");
1950  Results.AddResult(Result(Builder.TakeString()));
1951 
1952  // false
1953  Builder.AddResultTypeChunk("bool");
1954  Builder.AddTypedTextChunk("false");
1955  Results.AddResult(Result(Builder.TakeString()));
1956 
1957  if (SemaRef.getLangOpts().RTTI) {
1958  // dynamic_cast < type-id > ( expression )
1959  Builder.AddTypedTextChunk("dynamic_cast");
1960  Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1961  Builder.AddPlaceholderChunk("type");
1962  Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1963  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1964  Builder.AddPlaceholderChunk("expression");
1965  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1966  Results.AddResult(Result(Builder.TakeString()));
1967  }
1968 
1969  // static_cast < type-id > ( expression )
1970  Builder.AddTypedTextChunk("static_cast");
1971  Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1972  Builder.AddPlaceholderChunk("type");
1973  Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1974  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1975  Builder.AddPlaceholderChunk("expression");
1976  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1977  Results.AddResult(Result(Builder.TakeString()));
1978 
1979  // reinterpret_cast < type-id > ( expression )
1980  Builder.AddTypedTextChunk("reinterpret_cast");
1981  Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1982  Builder.AddPlaceholderChunk("type");
1983  Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1984  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1985  Builder.AddPlaceholderChunk("expression");
1986  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1987  Results.AddResult(Result(Builder.TakeString()));
1988 
1989  // const_cast < type-id > ( expression )
1990  Builder.AddTypedTextChunk("const_cast");
1991  Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1992  Builder.AddPlaceholderChunk("type");
1993  Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1994  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1995  Builder.AddPlaceholderChunk("expression");
1996  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1997  Results.AddResult(Result(Builder.TakeString()));
1998 
1999  if (SemaRef.getLangOpts().RTTI) {
2000  // typeid ( expression-or-type )
2001  Builder.AddResultTypeChunk("std::type_info");
2002  Builder.AddTypedTextChunk("typeid");
2003  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2004  Builder.AddPlaceholderChunk("expression-or-type");
2005  Builder.AddChunk(CodeCompletionString::CK_RightParen);
2006  Results.AddResult(Result(Builder.TakeString()));
2007  }
2008 
2009  // new T ( ... )
2010  Builder.AddTypedTextChunk("new");
2011  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2012  Builder.AddPlaceholderChunk("type");
2013  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2014  Builder.AddPlaceholderChunk("expressions");
2015  Builder.AddChunk(CodeCompletionString::CK_RightParen);
2016  Results.AddResult(Result(Builder.TakeString()));
2017 
2018  // new T [ ] ( ... )
2019  Builder.AddTypedTextChunk("new");
2020  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2021  Builder.AddPlaceholderChunk("type");
2022  Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
2023  Builder.AddPlaceholderChunk("size");
2024  Builder.AddChunk(CodeCompletionString::CK_RightBracket);
2025  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2026  Builder.AddPlaceholderChunk("expressions");
2027  Builder.AddChunk(CodeCompletionString::CK_RightParen);
2028  Results.AddResult(Result(Builder.TakeString()));
2029 
2030  // delete expression
2031  Builder.AddResultTypeChunk("void");
2032  Builder.AddTypedTextChunk("delete");
2033  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2034  Builder.AddPlaceholderChunk("expression");
2035  Results.AddResult(Result(Builder.TakeString()));
2036 
2037  // delete [] expression
2038  Builder.AddResultTypeChunk("void");
2039  Builder.AddTypedTextChunk("delete");
2040  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2041  Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
2042  Builder.AddChunk(CodeCompletionString::CK_RightBracket);
2043  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2044  Builder.AddPlaceholderChunk("expression");
2045  Results.AddResult(Result(Builder.TakeString()));
2046 
2047  if (SemaRef.getLangOpts().CXXExceptions) {
2048  // throw expression
2049  Builder.AddResultTypeChunk("void");
2050  Builder.AddTypedTextChunk("throw");
2051  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2052  Builder.AddPlaceholderChunk("expression");
2053  Results.AddResult(Result(Builder.TakeString()));
2054  }
2055 
2056  // FIXME: Rethrow?
2057 
2058  if (SemaRef.getLangOpts().CPlusPlus11) {
2059  // nullptr
2060  Builder.AddResultTypeChunk("std::nullptr_t");
2061  Builder.AddTypedTextChunk("nullptr");
2062  Results.AddResult(Result(Builder.TakeString()));
2063 
2064  // alignof
2065  Builder.AddResultTypeChunk("size_t");
2066  Builder.AddTypedTextChunk("alignof");
2067  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2068  Builder.AddPlaceholderChunk("type");
2069  Builder.AddChunk(CodeCompletionString::CK_RightParen);
2070  Results.AddResult(Result(Builder.TakeString()));
2071 
2072  // noexcept
2073  Builder.AddResultTypeChunk("bool");
2074  Builder.AddTypedTextChunk("noexcept");
2075  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2076  Builder.AddPlaceholderChunk("expression");
2077  Builder.AddChunk(CodeCompletionString::CK_RightParen);
2078  Results.AddResult(Result(Builder.TakeString()));
2079 
2080  // sizeof... expression
2081  Builder.AddResultTypeChunk("size_t");
2082  Builder.AddTypedTextChunk("sizeof...");
2083  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2084  Builder.AddPlaceholderChunk("parameter-pack");
2085  Builder.AddChunk(CodeCompletionString::CK_RightParen);
2086  Results.AddResult(Result(Builder.TakeString()));
2087  }
2088  }
2089 
2090  if (SemaRef.getLangOpts().ObjC1) {
2091  // Add "super", if we're in an Objective-C class with a superclass.
2092  if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
2093  // The interface can be NULL.
2094  if (ObjCInterfaceDecl *ID = Method->getClassInterface())
2095  if (ID->getSuperClass()) {
2096  std::string SuperType;
2097  SuperType = ID->getSuperClass()->getNameAsString();
2098  if (Method->isInstanceMethod())
2099  SuperType += " *";
2100 
2101  Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
2102  Builder.AddTypedTextChunk("super");
2103  Results.AddResult(Result(Builder.TakeString()));
2104  }
2105  }
2106 
2107  AddObjCExpressionResults(Results, true);
2108  }
2109 
2110  if (SemaRef.getLangOpts().C11) {
2111  // _Alignof
2112  Builder.AddResultTypeChunk("size_t");
2113  if (SemaRef.PP.isMacroDefined("alignof"))
2114  Builder.AddTypedTextChunk("alignof");
2115  else
2116  Builder.AddTypedTextChunk("_Alignof");
2117  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2118  Builder.AddPlaceholderChunk("type");
2119  Builder.AddChunk(CodeCompletionString::CK_RightParen);
2120  Results.AddResult(Result(Builder.TakeString()));
2121  }
2122 
2123  // sizeof expression
2124  Builder.AddResultTypeChunk("size_t");
2125  Builder.AddTypedTextChunk("sizeof");
2126  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2127  Builder.AddPlaceholderChunk("expression-or-type");
2128  Builder.AddChunk(CodeCompletionString::CK_RightParen);
2129  Results.AddResult(Result(Builder.TakeString()));
2130  break;
2131  }
2132 
2133  case Sema::PCC_Type:
2135  break;
2136  }
2137 
2138  if (WantTypesInContext(CCC, SemaRef.getLangOpts()))
2139  AddTypeSpecifierResults(SemaRef.getLangOpts(), Results);
2140 
2141  if (SemaRef.getLangOpts().CPlusPlus && CCC != Sema::PCC_Type)
2142  Results.AddResult(Result("operator"));
2143 }
2144 
2145 /// If the given declaration has an associated type, add it as a result
2146 /// type chunk.
2147 static void AddResultTypeChunk(ASTContext &Context,
2148  const PrintingPolicy &Policy,
2149  const NamedDecl *ND,
2150  QualType BaseType,
2151  CodeCompletionBuilder &Result) {
2152  if (!ND)
2153  return;
2154 
2155  // Skip constructors and conversion functions, which have their return types
2156  // built into their names.
2157  if (isConstructor(ND) || isa<CXXConversionDecl>(ND))
2158  return;
2159 
2160  // Determine the type of the declaration (if it has a type).
2161  QualType T;
2162  if (const FunctionDecl *Function = ND->getAsFunction())
2163  T = Function->getReturnType();
2164  else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2165  if (!BaseType.isNull())
2166  T = Method->getSendResultType(BaseType);
2167  else
2168  T = Method->getReturnType();
2169  } else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND)) {
2170  T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
2172  } else if (isa<UnresolvedUsingValueDecl>(ND)) {
2173  /* Do nothing: ignore unresolved using declarations*/
2174  } else if (const ObjCIvarDecl *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
2175  if (!BaseType.isNull())
2176  T = Ivar->getUsageType(BaseType);
2177  else
2178  T = Ivar->getType();
2179  } else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND)) {
2180  T = Value->getType();
2181  } else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND)) {
2182  if (!BaseType.isNull())
2183  T = Property->getUsageType(BaseType);
2184  else
2185  T = Property->getType();
2186  }
2187 
2188  if (T.isNull() || Context.hasSameType(T, Context.DependentTy))
2189  return;
2190 
2191  Result.AddResultTypeChunk(GetCompletionTypeString(T, Context, Policy,
2192  Result.getAllocator()));
2193 }
2194 
2196  const NamedDecl *FunctionOrMethod,
2197  CodeCompletionBuilder &Result) {
2198  if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>())
2199  if (Sentinel->getSentinel() == 0) {
2200  if (PP.getLangOpts().ObjC1 && PP.isMacroDefined("nil"))
2201  Result.AddTextChunk(", nil");
2202  else if (PP.isMacroDefined("NULL"))
2203  Result.AddTextChunk(", NULL");
2204  else
2205  Result.AddTextChunk(", (void*)0");
2206  }
2207 }
2208 
2209 static std::string formatObjCParamQualifiers(unsigned ObjCQuals,
2210  QualType &Type) {
2211  std::string Result;
2212  if (ObjCQuals & Decl::OBJC_TQ_In)
2213  Result += "in ";
2214  else if (ObjCQuals & Decl::OBJC_TQ_Inout)
2215  Result += "inout ";
2216  else if (ObjCQuals & Decl::OBJC_TQ_Out)
2217  Result += "out ";
2218  if (ObjCQuals & Decl::OBJC_TQ_Bycopy)
2219  Result += "bycopy ";
2220  else if (ObjCQuals & Decl::OBJC_TQ_Byref)
2221  Result += "byref ";
2222  if (ObjCQuals & Decl::OBJC_TQ_Oneway)
2223  Result += "oneway ";
2224  if (ObjCQuals & Decl::OBJC_TQ_CSNullability) {
2225  if (auto nullability = AttributedType::stripOuterNullability(Type)) {
2226  switch (*nullability) {
2228  Result += "nonnull ";
2229  break;
2230 
2232  Result += "nullable ";
2233  break;
2234 
2236  Result += "null_unspecified ";
2237  break;
2238  }
2239  }
2240  }
2241  return Result;
2242 }
2243 
2244 /// Tries to find the most appropriate type location for an Objective-C
2245 /// block placeholder.
2246 ///
2247 /// This function ignores things like typedefs and qualifiers in order to
2248 /// present the most relevant and accurate block placeholders in code completion
2249 /// results.
2251  FunctionTypeLoc &Block,
2252  FunctionProtoTypeLoc &BlockProto,
2253  bool SuppressBlock = false) {
2254  if (!TSInfo)
2255  return;
2256  TypeLoc TL = TSInfo->getTypeLoc().getUnqualifiedLoc();
2257  while (true) {
2258  // Look through typedefs.
2259  if (!SuppressBlock) {
2260  if (TypedefTypeLoc TypedefTL = TL.getAs<TypedefTypeLoc>()) {
2261  if (TypeSourceInfo *InnerTSInfo =
2262  TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) {
2263  TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc();
2264  continue;
2265  }
2266  }
2267 
2268  // Look through qualified types
2269  if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>()) {
2270  TL = QualifiedTL.getUnqualifiedLoc();
2271  continue;
2272  }
2273 
2274  if (AttributedTypeLoc AttrTL = TL.getAs<AttributedTypeLoc>()) {
2275  TL = AttrTL.getModifiedLoc();
2276  continue;
2277  }
2278  }
2279 
2280  // Try to get the function prototype behind the block pointer type,
2281  // then we're done.
2282  if (BlockPointerTypeLoc BlockPtr = TL.getAs<BlockPointerTypeLoc>()) {
2283  TL = BlockPtr.getPointeeLoc().IgnoreParens();
2284  Block = TL.getAs<FunctionTypeLoc>();
2285  BlockProto = TL.getAs<FunctionProtoTypeLoc>();
2286  }
2287  break;
2288  }
2289 }
2290 
2291 static std::string
2293  FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
2294  bool SuppressBlockName = false,
2295  bool SuppressBlock = false,
2296  Optional<ArrayRef<QualType>> ObjCSubsts = None);
2297 
2298 static std::string FormatFunctionParameter(const PrintingPolicy &Policy,
2299  const ParmVarDecl *Param,
2300  bool SuppressName = false,
2301  bool SuppressBlock = false,
2302  Optional<ArrayRef<QualType>> ObjCSubsts = None) {
2303  bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
2304  if (Param->getType()->isDependentType() ||
2305  !Param->getType()->isBlockPointerType()) {
2306  // The argument for a dependent or non-block parameter is a placeholder
2307  // containing that parameter's type.
2308  std::string Result;
2309 
2310  if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
2311  Result = Param->getIdentifier()->getName();
2312 
2313  QualType Type = Param->getType();
2314  if (ObjCSubsts)
2315  Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts,
2317  if (ObjCMethodParam) {
2318  Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(),
2319  Type);
2320  Result += Type.getAsString(Policy) + ")";
2321  if (Param->getIdentifier() && !SuppressName)
2322  Result += Param->getIdentifier()->getName();
2323  } else {
2324  Type.getAsStringInternal(Result, Policy);
2325  }
2326  return Result;
2327  }
2328 
2329  // The argument for a block pointer parameter is a block literal with
2330  // the appropriate type.
2331  FunctionTypeLoc Block;
2332  FunctionProtoTypeLoc BlockProto;
2333  findTypeLocationForBlockDecl(Param->getTypeSourceInfo(), Block, BlockProto,
2334  SuppressBlock);
2335  // Try to retrieve the block type information from the property if this is a
2336  // parameter in a setter.
2337  if (!Block && ObjCMethodParam &&
2338  cast<ObjCMethodDecl>(Param->getDeclContext())->isPropertyAccessor()) {
2339  if (const auto *PD = cast<ObjCMethodDecl>(Param->getDeclContext())
2340  ->findPropertyDecl(/*CheckOverrides=*/false))
2341  findTypeLocationForBlockDecl(PD->getTypeSourceInfo(), Block, BlockProto,
2342  SuppressBlock);
2343  }
2344 
2345  if (!Block) {
2346  // We were unable to find a FunctionProtoTypeLoc with parameter names
2347  // for the block; just use the parameter type as a placeholder.
2348  std::string Result;
2349  if (!ObjCMethodParam && Param->getIdentifier())
2350  Result = Param->getIdentifier()->getName();
2351 
2352  QualType Type = Param->getType().getUnqualifiedType();
2353 
2354  if (ObjCMethodParam) {
2355  Result = Type.getAsString(Policy);
2356  std::string Quals =
2358  if (!Quals.empty())
2359  Result = "(" + Quals + " " + Result + ")";
2360  if (Result.back() != ')')
2361  Result += " ";
2362  if (Param->getIdentifier())
2363  Result += Param->getIdentifier()->getName();
2364  } else {
2365  Type.getAsStringInternal(Result, Policy);
2366  }
2367 
2368  return Result;
2369  }
2370 
2371  // We have the function prototype behind the block pointer type, as it was
2372  // written in the source.
2373  return formatBlockPlaceholder(Policy, Param, Block, BlockProto,
2374  /*SuppressBlockName=*/false, SuppressBlock,
2375  ObjCSubsts);
2376 }
2377 
2378 /// Returns a placeholder string that corresponds to an Objective-C block
2379 /// declaration.
2380 ///
2381 /// \param BlockDecl A declaration with an Objective-C block type.
2382 ///
2383 /// \param Block The most relevant type location for that block type.
2384 ///
2385 /// \param SuppressBlockName Determines whether or not the name of the block
2386 /// declaration is included in the resulting string.
2387 static std::string
2388 formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
2389  FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
2390  bool SuppressBlockName, bool SuppressBlock,
2391  Optional<ArrayRef<QualType>> ObjCSubsts) {
2392  std::string Result;
2393  QualType ResultType = Block.getTypePtr()->getReturnType();
2394  if (ObjCSubsts)
2395  ResultType =
2396  ResultType.substObjCTypeArgs(BlockDecl->getASTContext(), *ObjCSubsts,
2398  if (!ResultType->isVoidType() || SuppressBlock)
2399  ResultType.getAsStringInternal(Result, Policy);
2400 
2401  // Format the parameter list.
2402  std::string Params;
2403  if (!BlockProto || Block.getNumParams() == 0) {
2404  if (BlockProto && BlockProto.getTypePtr()->isVariadic())
2405  Params = "(...)";
2406  else
2407  Params = "(void)";
2408  } else {
2409  Params += "(";
2410  for (unsigned I = 0, N = Block.getNumParams(); I != N; ++I) {
2411  if (I)
2412  Params += ", ";
2413  Params += FormatFunctionParameter(Policy, Block.getParam(I),
2414  /*SuppressName=*/false,
2415  /*SuppressBlock=*/true, ObjCSubsts);
2416 
2417  if (I == N - 1 && BlockProto.getTypePtr()->isVariadic())
2418  Params += ", ...";
2419  }
2420  Params += ")";
2421  }
2422 
2423  if (SuppressBlock) {
2424  // Format as a parameter.
2425  Result = Result + " (^";
2426  if (!SuppressBlockName && BlockDecl->getIdentifier())
2427  Result += BlockDecl->getIdentifier()->getName();
2428  Result += ")";
2429  Result += Params;
2430  } else {
2431  // Format as a block literal argument.
2432  Result = '^' + Result;
2433  Result += Params;
2434 
2435  if (!SuppressBlockName && BlockDecl->getIdentifier())
2436  Result += BlockDecl->getIdentifier()->getName();
2437  }
2438 
2439  return Result;
2440 }
2441 
2442 static std::string GetDefaultValueString(const ParmVarDecl *Param,
2443  const SourceManager &SM,
2444  const LangOptions &LangOpts) {
2445  const SourceRange SrcRange = Param->getDefaultArgRange();
2446  CharSourceRange CharSrcRange = CharSourceRange::getTokenRange(SrcRange);
2447  bool Invalid = CharSrcRange.isInvalid();
2448  if (Invalid)
2449  return "";
2450  StringRef srcText = Lexer::getSourceText(CharSrcRange, SM, LangOpts, &Invalid);
2451  if (Invalid)
2452  return "";
2453 
2454  if (srcText.empty() || srcText == "=") {
2455  // Lexer can't determine the value.
2456  // This happens if the code is incorrect (for example class is forward declared).
2457  return "";
2458  }
2459  std::string DefValue(srcText.str());
2460  // FIXME: remove this check if the Lexer::getSourceText value is fixed and
2461  // this value always has (or always does not have) '=' in front of it
2462  if (DefValue.at(0) != '=') {
2463  // If we don't have '=' in front of value.
2464  // Lexer returns built-in types values without '=' and user-defined types values with it.
2465  return " = " + DefValue;
2466  }
2467  return " " + DefValue;
2468 }
2469 
2470 /// Add function parameter chunks to the given code completion string.
2472  const PrintingPolicy &Policy,
2473  const FunctionDecl *Function,
2474  CodeCompletionBuilder &Result,
2475  unsigned Start = 0,
2476  bool InOptional = false) {
2477  bool FirstParameter = true;
2478 
2479  for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) {
2480  const ParmVarDecl *Param = Function->getParamDecl(P);
2481 
2482  if (Param->hasDefaultArg() && !InOptional) {
2483  // When we see an optional default argument, put that argument and
2484  // the remaining default arguments into a new, optional string.
2485  CodeCompletionBuilder Opt(Result.getAllocator(),
2486  Result.getCodeCompletionTUInfo());
2487  if (!FirstParameter)
2489  AddFunctionParameterChunks(PP, Policy, Function, Opt, P, true);
2490  Result.AddOptionalChunk(Opt.TakeString());
2491  break;
2492  }
2493 
2494  if (FirstParameter)
2495  FirstParameter = false;
2496  else
2498 
2499  InOptional = false;
2500 
2501  // Format the placeholder string.
2502  std::string PlaceholderStr = FormatFunctionParameter(Policy, Param);
2503  if (Param->hasDefaultArg())
2504  PlaceholderStr += GetDefaultValueString(Param, PP.getSourceManager(), PP.getLangOpts());
2505 
2506  if (Function->isVariadic() && P == N - 1)
2507  PlaceholderStr += ", ...";
2508 
2509  // Add the placeholder string.
2510  Result.AddPlaceholderChunk(
2511  Result.getAllocator().CopyString(PlaceholderStr));
2512  }
2513 
2514  if (const FunctionProtoType *Proto
2515  = Function->getType()->getAs<FunctionProtoType>())
2516  if (Proto->isVariadic()) {
2517  if (Proto->getNumParams() == 0)
2518  Result.AddPlaceholderChunk("...");
2519 
2520  MaybeAddSentinel(PP, Function, Result);
2521  }
2522 }
2523 
2524 /// Add template parameter chunks to the given code completion string.
2526  const PrintingPolicy &Policy,
2527  const TemplateDecl *Template,
2528  CodeCompletionBuilder &Result,
2529  unsigned MaxParameters = 0,
2530  unsigned Start = 0,
2531  bool InDefaultArg = false) {
2532  bool FirstParameter = true;
2533 
2534  // Prefer to take the template parameter names from the first declaration of
2535  // the template.
2536  Template = cast<TemplateDecl>(Template->getCanonicalDecl());
2537 
2538  TemplateParameterList *Params = Template->getTemplateParameters();
2539  TemplateParameterList::iterator PEnd = Params->end();
2540  if (MaxParameters)
2541  PEnd = Params->begin() + MaxParameters;
2542  for (TemplateParameterList::iterator P = Params->begin() + Start;
2543  P != PEnd; ++P) {
2544  bool HasDefaultArg = false;
2545  std::string PlaceholderStr;
2546  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
2547  if (TTP->wasDeclaredWithTypename())
2548  PlaceholderStr = "typename";
2549  else
2550  PlaceholderStr = "class";
2551 
2552  if (TTP->getIdentifier()) {
2553  PlaceholderStr += ' ';
2554  PlaceholderStr += TTP->getIdentifier()->getName();
2555  }
2556 
2557  HasDefaultArg = TTP->hasDefaultArgument();
2558  } else if (NonTypeTemplateParmDecl *NTTP
2559  = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
2560  if (NTTP->getIdentifier())
2561  PlaceholderStr = NTTP->getIdentifier()->getName();
2562  NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
2563  HasDefaultArg = NTTP->hasDefaultArgument();
2564  } else {
2565  assert(isa<TemplateTemplateParmDecl>(*P));
2566  TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
2567 
2568  // Since putting the template argument list into the placeholder would
2569  // be very, very long, we just use an abbreviation.
2570  PlaceholderStr = "template<...> class";
2571  if (TTP->getIdentifier()) {
2572  PlaceholderStr += ' ';
2573  PlaceholderStr += TTP->getIdentifier()->getName();
2574  }
2575 
2576  HasDefaultArg = TTP->hasDefaultArgument();
2577  }
2578 
2579  if (HasDefaultArg && !InDefaultArg) {
2580  // When we see an optional default argument, put that argument and
2581  // the remaining default arguments into a new, optional string.
2582  CodeCompletionBuilder Opt(Result.getAllocator(),
2583  Result.getCodeCompletionTUInfo());
2584  if (!FirstParameter)
2586  AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
2587  P - Params->begin(), true);
2588  Result.AddOptionalChunk(Opt.TakeString());
2589  break;
2590  }
2591 
2592  InDefaultArg = false;
2593 
2594  if (FirstParameter)
2595  FirstParameter = false;
2596  else
2598 
2599  // Add the placeholder string.
2600  Result.AddPlaceholderChunk(
2601  Result.getAllocator().CopyString(PlaceholderStr));
2602  }
2603 }
2604 
2605 /// Add a qualifier to the given code-completion string, if the
2606 /// provided nested-name-specifier is non-NULL.
2607 static void
2609  NestedNameSpecifier *Qualifier,
2610  bool QualifierIsInformative,
2611  ASTContext &Context,
2612  const PrintingPolicy &Policy) {
2613  if (!Qualifier)
2614  return;
2615 
2616  std::string PrintedNNS;
2617  {
2618  llvm::raw_string_ostream OS(PrintedNNS);
2619  Qualifier->print(OS, Policy);
2620  }
2621  if (QualifierIsInformative)
2622  Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS));
2623  else
2624  Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS));
2625 }
2626 
2627 static void
2629  const FunctionDecl *Function) {
2630  const FunctionProtoType *Proto
2631  = Function->getType()->getAs<FunctionProtoType>();
2632  if (!Proto || !Proto->getTypeQuals())
2633  return;
2634 
2635  // FIXME: Add ref-qualifier!
2636 
2637  // Handle single qualifiers without copying
2638  if (Proto->getTypeQuals() == Qualifiers::Const) {
2639  Result.AddInformativeChunk(" const");
2640  return;
2641  }
2642 
2643  if (Proto->getTypeQuals() == Qualifiers::Volatile) {
2644  Result.AddInformativeChunk(" volatile");
2645  return;
2646  }
2647 
2648  if (Proto->getTypeQuals() == Qualifiers::Restrict) {
2649  Result.AddInformativeChunk(" restrict");
2650  return;
2651  }
2652 
2653  // Handle multiple qualifiers.
2654  std::string QualsStr;
2655  if (Proto->isConst())
2656  QualsStr += " const";
2657  if (Proto->isVolatile())
2658  QualsStr += " volatile";
2659  if (Proto->isRestrict())
2660  QualsStr += " restrict";
2661  Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
2662 }
2663 
2664 /// Add the name of the given declaration
2665 static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy,
2666  const NamedDecl *ND,
2667  CodeCompletionBuilder &Result) {
2668  DeclarationName Name = ND->getDeclName();
2669  if (!Name)
2670  return;
2671 
2672  switch (Name.getNameKind()) {
2674  const char *OperatorName = nullptr;
2675  switch (Name.getCXXOverloadedOperator()) {
2676  case OO_None:
2677  case OO_Conditional:
2679  OperatorName = "operator";
2680  break;
2681 
2682 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2683  case OO_##Name: OperatorName = "operator" Spelling; break;
2684 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2685 #include "clang/Basic/OperatorKinds.def"
2686 
2687  case OO_New: OperatorName = "operator new"; break;
2688  case OO_Delete: OperatorName = "operator delete"; break;
2689  case OO_Array_New: OperatorName = "operator new[]"; break;
2690  case OO_Array_Delete: OperatorName = "operator delete[]"; break;
2691  case OO_Call: OperatorName = "operator()"; break;
2692  case OO_Subscript: OperatorName = "operator[]"; break;
2693  }
2694  Result.AddTypedTextChunk(OperatorName);
2695  break;
2696  }
2697 
2702  Result.AddTypedTextChunk(
2703  Result.getAllocator().CopyString(ND->getNameAsString()));
2704  break;
2705 
2711  break;
2712 
2714  CXXRecordDecl *Record = nullptr;
2715  QualType Ty = Name.getCXXNameType();
2716  if (const RecordType *RecordTy = Ty->getAs<RecordType>())
2717  Record = cast<CXXRecordDecl>(RecordTy->getDecl());
2718  else if (const InjectedClassNameType *InjectedTy
2719  = Ty->getAs<InjectedClassNameType>())
2720  Record = InjectedTy->getDecl();
2721  else {
2722  Result.AddTypedTextChunk(
2723  Result.getAllocator().CopyString(ND->getNameAsString()));
2724  break;
2725  }
2726 
2727  Result.AddTypedTextChunk(
2728  Result.getAllocator().CopyString(Record->getNameAsString()));
2729  if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) {
2731  AddTemplateParameterChunks(Context, Policy, Template, Result);
2733  }
2734  break;
2735  }
2736  }
2737 }
2738 
2740  const CodeCompletionContext &CCContext,
2741  CodeCompletionAllocator &Allocator,
2742  CodeCompletionTUInfo &CCTUInfo,
2743  bool IncludeBriefComments) {
2744  return CreateCodeCompletionString(S.Context, S.PP, CCContext, Allocator,
2745  CCTUInfo, IncludeBriefComments);
2746 }
2747 
2749  Preprocessor &PP, CodeCompletionAllocator &Allocator,
2750  CodeCompletionTUInfo &CCTUInfo) {
2751  assert(Kind == RK_Macro);
2752  CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
2753  const MacroInfo *MI = PP.getMacroInfo(Macro);
2754  Result.AddTypedTextChunk(Result.getAllocator().CopyString(Macro->getName()));
2755 
2756  if (!MI || !MI->isFunctionLike())
2757  return Result.TakeString();
2758 
2759  // Format a function-like macro with placeholders for the arguments.
2761  MacroInfo::param_iterator A = MI->param_begin(), AEnd = MI->param_end();
2762 
2763  // C99 variadic macros add __VA_ARGS__ at the end. Skip it.
2764  if (MI->isC99Varargs()) {
2765  --AEnd;
2766 
2767  if (A == AEnd) {
2768  Result.AddPlaceholderChunk("...");
2769  }
2770  }
2771 
2772  for (MacroInfo::param_iterator A = MI->param_begin(); A != AEnd; ++A) {
2773  if (A != MI->param_begin())
2775 
2776  if (MI->isVariadic() && (A + 1) == AEnd) {
2777  SmallString<32> Arg = (*A)->getName();
2778  if (MI->isC99Varargs())
2779  Arg += ", ...";
2780  else
2781  Arg += "...";
2782  Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2783  break;
2784  }
2785 
2786  // Non-variadic macros are simple.
2787  Result.AddPlaceholderChunk(
2788  Result.getAllocator().CopyString((*A)->getName()));
2789  }
2791  return Result.TakeString();
2792 }
2793 
2794 /// If possible, create a new code completion string for the given
2795 /// result.
2796 ///
2797 /// \returns Either a new, heap-allocated code completion string describing
2798 /// how to use this result, or NULL to indicate that the string or name of the
2799 /// result is all that is needed.
2802  Preprocessor &PP,
2803  const CodeCompletionContext &CCContext,
2804  CodeCompletionAllocator &Allocator,
2805  CodeCompletionTUInfo &CCTUInfo,
2806  bool IncludeBriefComments) {
2807  if (Kind == RK_Macro)
2808  return CreateCodeCompletionStringForMacro(PP, Allocator, CCTUInfo);
2809 
2810  CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
2811 
2812  PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
2813  if (Kind == RK_Pattern) {
2814  Pattern->Priority = Priority;
2815  Pattern->Availability = Availability;
2816 
2817  if (Declaration) {
2818  Result.addParentContext(Declaration->getDeclContext());
2819  Pattern->ParentName = Result.getParentName();
2820  if (const RawComment *RC =
2821  getPatternCompletionComment(Ctx, Declaration)) {
2822  Result.addBriefComment(RC->getBriefText(Ctx));
2823  Pattern->BriefComment = Result.getBriefComment();
2824  }
2825  }
2826 
2827  return Pattern;
2828  }
2829 
2830  if (Kind == RK_Keyword) {
2831  Result.AddTypedTextChunk(Keyword);
2832  return Result.TakeString();
2833  }
2834  assert(Kind == RK_Declaration && "Missed a result kind?");
2835  const NamedDecl *ND = Declaration;
2836  Result.addParentContext(ND->getDeclContext());
2837 
2838  if (IncludeBriefComments) {
2839  // Add documentation comment, if it exists.
2840  if (const RawComment *RC = getCompletionComment(Ctx, Declaration)) {
2841  Result.addBriefComment(RC->getBriefText(Ctx));
2842  }
2843  }
2844 
2845  if (StartsNestedNameSpecifier) {
2846  Result.AddTypedTextChunk(
2847  Result.getAllocator().CopyString(ND->getNameAsString()));
2848  Result.AddTextChunk("::");
2849  return Result.TakeString();
2850  }
2851 
2852  for (const auto *I : ND->specific_attrs<AnnotateAttr>())
2853  Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation()));
2854 
2855  AddResultTypeChunk(Ctx, Policy, ND, CCContext.getBaseType(), Result);
2856 
2857  if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) {
2858  AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2859  Ctx, Policy);
2860  AddTypedNameChunk(Ctx, Policy, ND, Result);
2862  AddFunctionParameterChunks(PP, Policy, Function, Result);
2864  AddFunctionTypeQualsToCompletionString(Result, Function);
2865  return Result.TakeString();
2866  }
2867 
2868  if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) {
2869  AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2870  Ctx, Policy);
2871  FunctionDecl *Function = FunTmpl->getTemplatedDecl();
2872  AddTypedNameChunk(Ctx, Policy, Function, Result);
2873 
2874  // Figure out which template parameters are deduced (or have default
2875  // arguments).
2876  llvm::SmallBitVector Deduced;
2877  Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced);
2878  unsigned LastDeducibleArgument;
2879  for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
2880  --LastDeducibleArgument) {
2881  if (!Deduced[LastDeducibleArgument - 1]) {
2882  // C++0x: Figure out if the template argument has a default. If so,
2883  // the user doesn't need to type this argument.
2884  // FIXME: We need to abstract template parameters better!
2885  bool HasDefaultArg = false;
2886  NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
2887  LastDeducibleArgument - 1);
2888  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
2889  HasDefaultArg = TTP->hasDefaultArgument();
2890  else if (NonTypeTemplateParmDecl *NTTP
2891  = dyn_cast<NonTypeTemplateParmDecl>(Param))
2892  HasDefaultArg = NTTP->hasDefaultArgument();
2893  else {
2894  assert(isa<TemplateTemplateParmDecl>(Param));
2895  HasDefaultArg
2896  = cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
2897  }
2898 
2899  if (!HasDefaultArg)
2900  break;
2901  }
2902  }
2903 
2904  if (LastDeducibleArgument) {
2905  // Some of the function template arguments cannot be deduced from a
2906  // function call, so we introduce an explicit template argument list
2907  // containing all of the arguments up to the first deducible argument.
2909  AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result,
2910  LastDeducibleArgument);
2912  }
2913 
2914  // Add the function parameters
2916  AddFunctionParameterChunks(PP, Policy, Function, Result);
2918  AddFunctionTypeQualsToCompletionString(Result, Function);
2919  return Result.TakeString();
2920  }
2921 
2922  if (const TemplateDecl *Template = dyn_cast<TemplateDecl>(ND)) {
2923  AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2924  Ctx, Policy);
2925  Result.AddTypedTextChunk(
2926  Result.getAllocator().CopyString(Template->getNameAsString()));
2928  AddTemplateParameterChunks(Ctx, Policy, Template, Result);
2930  return Result.TakeString();
2931  }
2932 
2933  if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2934  Selector Sel = Method->getSelector();
2935  if (Sel.isUnarySelector()) {
2936  Result.AddTypedTextChunk(Result.getAllocator().CopyString(
2937  Sel.getNameForSlot(0)));
2938  return Result.TakeString();
2939  }
2940 
2941  std::string SelName = Sel.getNameForSlot(0).str();
2942  SelName += ':';
2943  if (StartParameter == 0)
2944  Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
2945  else {
2946  Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName));
2947 
2948  // If there is only one parameter, and we're past it, add an empty
2949  // typed-text chunk since there is nothing to type.
2950  if (Method->param_size() == 1)
2951  Result.AddTypedTextChunk("");
2952  }
2953  unsigned Idx = 0;
2954  for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(),
2955  PEnd = Method->param_end();
2956  P != PEnd; (void)++P, ++Idx) {
2957  if (Idx > 0) {
2958  std::string Keyword;
2959  if (Idx > StartParameter)
2961  if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx))
2962  Keyword += II->getName();
2963  Keyword += ":";
2964  if (Idx < StartParameter || AllParametersAreInformative)
2965  Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword));
2966  else
2967  Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword));
2968  }
2969 
2970  // If we're before the starting parameter, skip the placeholder.
2971  if (Idx < StartParameter)
2972  continue;
2973 
2974  std::string Arg;
2975  QualType ParamType = (*P)->getType();
2976  Optional<ArrayRef<QualType>> ObjCSubsts;
2977  if (!CCContext.getBaseType().isNull())
2978  ObjCSubsts = CCContext.getBaseType()->getObjCSubstitutions(Method);
2979 
2980  if (ParamType->isBlockPointerType() && !DeclaringEntity)
2981  Arg = FormatFunctionParameter(Policy, *P, true,
2982  /*SuppressBlock=*/false,
2983  ObjCSubsts);
2984  else {
2985  if (ObjCSubsts)
2986  ParamType = ParamType.substObjCTypeArgs(Ctx, *ObjCSubsts,
2988  Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier(),
2989  ParamType);
2990  Arg += ParamType.getAsString(Policy) + ")";
2991  if (IdentifierInfo *II = (*P)->getIdentifier())
2992  if (DeclaringEntity || AllParametersAreInformative)
2993  Arg += II->getName();
2994  }
2995 
2996  if (Method->isVariadic() && (P + 1) == PEnd)
2997  Arg += ", ...";
2998 
2999  if (DeclaringEntity)
3000  Result.AddTextChunk(Result.getAllocator().CopyString(Arg));
3001  else if (AllParametersAreInformative)
3002  Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg));
3003  else
3004  Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
3005  }
3006 
3007  if (Method->isVariadic()) {
3008  if (Method->param_size() == 0) {
3009  if (DeclaringEntity)
3010  Result.AddTextChunk(", ...");
3011  else if (AllParametersAreInformative)
3012  Result.AddInformativeChunk(", ...");
3013  else
3014  Result.AddPlaceholderChunk(", ...");
3015  }
3016 
3017  MaybeAddSentinel(PP, Method, Result);
3018  }
3019 
3020  return Result.TakeString();
3021  }
3022 
3023  if (Qualifier)
3024  AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3025  Ctx, Policy);
3026 
3027  Result.AddTypedTextChunk(
3028  Result.getAllocator().CopyString(ND->getNameAsString()));
3029  return Result.TakeString();
3030 }
3031 
3033  const NamedDecl *ND) {
3034  if (!ND)
3035  return nullptr;
3036  if (auto *RC = Ctx.getRawCommentForAnyRedecl(ND))
3037  return RC;
3038 
3039  // Try to find comment from a property for ObjC methods.
3040  const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(ND);
3041  if (!M)
3042  return nullptr;
3043  const ObjCPropertyDecl *PDecl = M->findPropertyDecl();
3044  if (!PDecl)
3045  return nullptr;
3046 
3047  return Ctx.getRawCommentForAnyRedecl(PDecl);
3048 }
3049 
3051  const NamedDecl *ND) {
3052  const ObjCMethodDecl *M = dyn_cast_or_null<ObjCMethodDecl>(ND);
3053  if (!M || !M->isPropertyAccessor())
3054  return nullptr;
3055 
3056  // Provide code completion comment for self.GetterName where
3057  // GetterName is the getter method for a property with name
3058  // different from the property name (declared via a property
3059  // getter attribute.
3060  const ObjCPropertyDecl *PDecl = M->findPropertyDecl();
3061  if (!PDecl)
3062  return nullptr;
3063  if (PDecl->getGetterName() == M->getSelector() &&
3064  PDecl->getIdentifier() != M->getIdentifier()) {
3065  if (auto *RC = Ctx.getRawCommentForAnyRedecl(M))
3066  return RC;
3067  if (auto *RC = Ctx.getRawCommentForAnyRedecl(PDecl))
3068  return RC;
3069  }
3070  return nullptr;
3071 }
3072 
3074  const ASTContext &Ctx,
3076  unsigned ArgIndex) {
3077  auto FDecl = Result.getFunction();
3078  if (!FDecl)
3079  return nullptr;
3080  if (ArgIndex < FDecl->getNumParams())
3081  return Ctx.getRawCommentForAnyRedecl(FDecl->getParamDecl(ArgIndex));
3082  return nullptr;
3083 }
3084 
3085 /// Add function overload parameter chunks to the given code completion
3086 /// string.
3088  const PrintingPolicy &Policy,
3089  const FunctionDecl *Function,
3090  const FunctionProtoType *Prototype,
3091  CodeCompletionBuilder &Result,
3092  unsigned CurrentArg,
3093  unsigned Start = 0,
3094  bool InOptional = false) {
3095  bool FirstParameter = true;
3096  unsigned NumParams = Function ? Function->getNumParams()
3097  : Prototype->getNumParams();
3098 
3099  for (unsigned P = Start; P != NumParams; ++P) {
3100  if (Function && Function->getParamDecl(P)->hasDefaultArg() && !InOptional) {
3101  // When we see an optional default argument, put that argument and
3102  // the remaining default arguments into a new, optional string.
3103  CodeCompletionBuilder Opt(Result.getAllocator(),
3104  Result.getCodeCompletionTUInfo());
3105  if (!FirstParameter)
3107  // Optional sections are nested.
3108  AddOverloadParameterChunks(Context, Policy, Function, Prototype, Opt,
3109  CurrentArg, P, /*InOptional=*/true);
3110  Result.AddOptionalChunk(Opt.TakeString());
3111  return;
3112  }
3113 
3114  if (FirstParameter)
3115  FirstParameter = false;
3116  else
3118 
3119  InOptional = false;
3120 
3121  // Format the placeholder string.
3122  std::string Placeholder;
3123  if (Function) {
3124  const ParmVarDecl *Param = Function->getParamDecl(P);
3125  Placeholder = FormatFunctionParameter(Policy, Param);
3126  if (Param->hasDefaultArg())
3127  Placeholder += GetDefaultValueString(Param, Context.getSourceManager(), Context.getLangOpts());
3128  } else {
3129  Placeholder = Prototype->getParamType(P).getAsString(Policy);
3130  }
3131 
3132  if (P == CurrentArg)
3133  Result.AddCurrentParameterChunk(
3134  Result.getAllocator().CopyString(Placeholder));
3135  else
3136  Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Placeholder));
3137  }
3138 
3139  if (Prototype && Prototype->isVariadic()) {
3140  CodeCompletionBuilder Opt(Result.getAllocator(),
3141  Result.getCodeCompletionTUInfo());
3142  if (!FirstParameter)
3144 
3145  if (CurrentArg < NumParams)
3146  Opt.AddPlaceholderChunk("...");
3147  else
3148  Opt.AddCurrentParameterChunk("...");
3149 
3150  Result.AddOptionalChunk(Opt.TakeString());
3151  }
3152 }
3153 
3156  unsigned CurrentArg, Sema &S,
3157  CodeCompletionAllocator &Allocator,
3158  CodeCompletionTUInfo &CCTUInfo,
3159  bool IncludeBriefComments) const {
3161 
3162  // FIXME: Set priority, availability appropriately.
3163  CodeCompletionBuilder Result(Allocator,CCTUInfo, 1, CXAvailability_Available);
3164  FunctionDecl *FDecl = getFunction();
3165  const FunctionProtoType *Proto
3166  = dyn_cast<FunctionProtoType>(getFunctionType());
3167  if (!FDecl && !Proto) {
3168  // Function without a prototype. Just give the return type and a
3169  // highlighted ellipsis.
3170  const FunctionType *FT = getFunctionType();
3171  Result.AddResultTypeChunk(Result.getAllocator().CopyString(
3172  FT->getReturnType().getAsString(Policy)));
3176  return Result.TakeString();
3177  }
3178 
3179  if (FDecl) {
3180  if (IncludeBriefComments) {
3181  if (auto RC = getParameterComment(S.getASTContext(), *this, CurrentArg))
3182  Result.addBriefComment(RC->getBriefText(S.getASTContext()));
3183  }
3184  AddResultTypeChunk(S.Context, Policy, FDecl, QualType(), Result);
3185  Result.AddTextChunk(
3186  Result.getAllocator().CopyString(FDecl->getNameAsString()));
3187  } else {
3188  Result.AddResultTypeChunk(
3189  Result.getAllocator().CopyString(
3190  Proto->getReturnType().getAsString(Policy)));
3191  }
3192 
3194  AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result,
3195  CurrentArg);
3196  Result.AddChunk(CodeCompletionString::CK_RightParen);
3197 
3198  return Result.TakeString();
3199 }
3200 
3201 unsigned clang::getMacroUsagePriority(StringRef MacroName,
3202  const LangOptions &LangOpts,
3203  bool PreferredTypeIsPointer) {
3204  unsigned Priority = CCP_Macro;
3205 
3206  // Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
3207  if (MacroName.equals("nil") || MacroName.equals("NULL") ||
3208  MacroName.equals("Nil")) {
3209  Priority = CCP_Constant;
3210  if (PreferredTypeIsPointer)
3211  Priority = Priority / CCF_SimilarTypeMatch;
3212  }
3213  // Treat "YES", "NO", "true", and "false" as constants.
3214  else if (MacroName.equals("YES") || MacroName.equals("NO") ||
3215  MacroName.equals("true") || MacroName.equals("false"))
3216  Priority = CCP_Constant;
3217  // Treat "bool" as a type.
3218  else if (MacroName.equals("bool"))
3219  Priority = CCP_Type + (LangOpts.ObjC1? CCD_bool_in_ObjC : 0);
3220 
3221 
3222  return Priority;
3223 }
3224 
3226  if (!D)
3227  return CXCursor_UnexposedDecl;
3228 
3229  switch (D->getKind()) {
3230  case Decl::Enum: return CXCursor_EnumDecl;
3231  case Decl::EnumConstant: return CXCursor_EnumConstantDecl;
3232  case Decl::Field: return CXCursor_FieldDecl;
3233  case Decl::Function:
3234  return CXCursor_FunctionDecl;
3235  case Decl::ObjCCategory: return CXCursor_ObjCCategoryDecl;
3236  case Decl::ObjCCategoryImpl: return CXCursor_ObjCCategoryImplDecl;
3237  case Decl::ObjCImplementation: return CXCursor_ObjCImplementationDecl;
3238 
3239  case Decl::ObjCInterface: return CXCursor_ObjCInterfaceDecl;
3240  case Decl::ObjCIvar: return CXCursor_ObjCIvarDecl;
3241  case Decl::ObjCMethod:
3242  return cast<ObjCMethodDecl>(D)->isInstanceMethod()
3244  case Decl::CXXMethod: return CXCursor_CXXMethod;
3245  case Decl::CXXConstructor: return CXCursor_Constructor;
3246  case Decl::CXXDestructor: return CXCursor_Destructor;
3247  case Decl::CXXConversion: return CXCursor_ConversionFunction;
3248  case Decl::ObjCProperty: return CXCursor_ObjCPropertyDecl;
3249  case Decl::ObjCProtocol: return CXCursor_ObjCProtocolDecl;
3250  case Decl::ParmVar: return CXCursor_ParmDecl;
3251  case Decl::Typedef: return CXCursor_TypedefDecl;
3252  case Decl::TypeAlias: return CXCursor_TypeAliasDecl;
3253  case Decl::TypeAliasTemplate: return CXCursor_TypeAliasTemplateDecl;
3254  case Decl::Var: return CXCursor_VarDecl;
3255  case Decl::Namespace: return CXCursor_Namespace;
3256  case Decl::NamespaceAlias: return CXCursor_NamespaceAlias;
3257  case Decl::TemplateTypeParm: return CXCursor_TemplateTypeParameter;
3258  case Decl::NonTypeTemplateParm:return CXCursor_NonTypeTemplateParameter;
3259  case Decl::TemplateTemplateParm:return CXCursor_TemplateTemplateParameter;
3260  case Decl::FunctionTemplate: return CXCursor_FunctionTemplate;
3261  case Decl::ClassTemplate: return CXCursor_ClassTemplate;
3262  case Decl::AccessSpec: return CXCursor_CXXAccessSpecifier;
3263  case Decl::ClassTemplatePartialSpecialization:
3265  case Decl::UsingDirective: return CXCursor_UsingDirective;
3266  case Decl::StaticAssert: return CXCursor_StaticAssert;
3267  case Decl::Friend: return CXCursor_FriendDecl;
3268  case Decl::TranslationUnit: return CXCursor_TranslationUnit;
3269 
3270  case Decl::Using:
3271  case Decl::UnresolvedUsingValue:
3272  case Decl::UnresolvedUsingTypename:
3274 
3275  case Decl::ObjCPropertyImpl:
3276  switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
3278  return CXCursor_ObjCDynamicDecl;
3279 
3282  }
3283 
3284  case Decl::Import:
3286 
3287  case Decl::ObjCTypeParam: return CXCursor_TemplateTypeParameter;
3288 
3289  default:
3290  if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
3291  switch (TD->getTagKind()) {
3292  case TTK_Interface: // fall through
3293  case TTK_Struct: return CXCursor_StructDecl;
3294  case TTK_Class: return CXCursor_ClassDecl;
3295  case TTK_Union: return CXCursor_UnionDecl;
3296  case TTK_Enum: return CXCursor_EnumDecl;
3297  }
3298  }
3299  }
3300 
3301  return CXCursor_UnexposedDecl;
3302 }
3303 
3304 static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results,
3305  bool IncludeUndefined,
3306  bool TargetTypeIsPointer = false) {
3307  typedef CodeCompletionResult Result;
3308 
3309  Results.EnterNewScope();
3310 
3312  MEnd = PP.macro_end();
3313  M != MEnd; ++M) {
3314  auto MD = PP.getMacroDefinition(M->first);
3315  if (IncludeUndefined || MD) {
3316  if (MacroInfo *MI = MD.getMacroInfo())
3317  if (MI->isUsedForHeaderGuard())
3318  continue;
3319 
3320  Results.AddResult(Result(M->first,
3321  getMacroUsagePriority(M->first->getName(),
3322  PP.getLangOpts(),
3323  TargetTypeIsPointer)));
3324  }
3325  }
3326 
3327  Results.ExitScope();
3328 
3329 }
3330 
3331 static void AddPrettyFunctionResults(const LangOptions &LangOpts,
3332  ResultBuilder &Results) {
3333  typedef CodeCompletionResult Result;
3334 
3335  Results.EnterNewScope();
3336 
3337  Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant));
3338  Results.AddResult(Result("__FUNCTION__", CCP_Constant));
3339  if (LangOpts.C99 || LangOpts.CPlusPlus11)
3340  Results.AddResult(Result("__func__", CCP_Constant));
3341  Results.ExitScope();
3342 }
3343 
3345  CodeCompleteConsumer *CodeCompleter,
3346  CodeCompletionContext Context,
3347  CodeCompletionResult *Results,
3348  unsigned NumResults) {
3349  if (CodeCompleter)
3350  CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults);
3351 }
3352 
3355  switch (PCC) {
3356  case Sema::PCC_Namespace:
3358 
3359  case Sema::PCC_Class:
3361 
3364 
3367 
3370 
3371  case Sema::PCC_Template:
3373  if (S.CurContext->isFileContext())
3375  if (S.CurContext->isRecord())
3378 
3381 
3382  case Sema::PCC_ForInit:
3383  if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 ||
3384  S.getLangOpts().ObjC1)
3386  else
3388 
3389  case Sema::PCC_Expression:
3390  case Sema::PCC_Condition:
3392 
3393  case Sema::PCC_Statement:
3395 
3396  case Sema::PCC_Type:
3398 
3401 
3404  }
3405 
3406  llvm_unreachable("Invalid ParserCompletionContext!");
3407 }
3408 
3409 /// If we're in a C++ virtual member function, add completion results
3410 /// that invoke the functions we override, since it's common to invoke the
3411 /// overridden function as well as adding new functionality.
3412 ///
3413 /// \param S The semantic analysis object for which we are generating results.
3414 ///
3415 /// \param InContext This context in which the nested-name-specifier preceding
3416 /// the code-completion point
3417 static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
3418  ResultBuilder &Results) {
3419  // Look through blocks.
3420  DeclContext *CurContext = S.CurContext;
3421  while (isa<BlockDecl>(CurContext))
3422  CurContext = CurContext->getParent();
3423 
3424 
3425  CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
3426  if (!Method || !Method->isVirtual())
3427  return;
3428 
3429  // We need to have names for all of the parameters, if we're going to
3430  // generate a forwarding call.
3431  for (auto P : Method->parameters())
3432  if (!P->getDeclName())
3433  return;
3434 
3436  for (const CXXMethodDecl *Overridden : Method->overridden_methods()) {
3437  CodeCompletionBuilder Builder(Results.getAllocator(),
3438  Results.getCodeCompletionTUInfo());
3439  if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
3440  continue;
3441 
3442  // If we need a nested-name-specifier, add one now.
3443  if (!InContext) {
3444  NestedNameSpecifier *NNS
3445  = getRequiredQualification(S.Context, CurContext,
3446  Overridden->getDeclContext());
3447  if (NNS) {
3448  std::string Str;
3449  llvm::raw_string_ostream OS(Str);
3450  NNS->print(OS, Policy);
3451  Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
3452  }
3453  } else if (!InContext->Equals(Overridden->getDeclContext()))
3454  continue;
3455 
3456  Builder.AddTypedTextChunk(Results.getAllocator().CopyString(
3457  Overridden->getNameAsString()));
3458  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
3459  bool FirstParam = true;
3460  for (auto P : Method->parameters()) {
3461  if (FirstParam)
3462  FirstParam = false;
3463  else
3464  Builder.AddChunk(CodeCompletionString::CK_Comma);
3465 
3466  Builder.AddPlaceholderChunk(
3467  Results.getAllocator().CopyString(P->getIdentifier()->getName()));
3468  }
3469  Builder.AddChunk(CodeCompletionString::CK_RightParen);
3470  Results.AddResult(CodeCompletionResult(Builder.TakeString(),
3474  Overridden));
3475  Results.Ignore(Overridden);
3476  }
3477 }
3478 
3480  ModuleIdPath Path) {
3481  typedef CodeCompletionResult Result;
3482  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3483  CodeCompleter->getCodeCompletionTUInfo(),
3485  Results.EnterNewScope();
3486 
3487  CodeCompletionAllocator &Allocator = Results.getAllocator();
3488  CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
3489  typedef CodeCompletionResult Result;
3490  if (Path.empty()) {
3491  // Enumerate all top-level modules.
3492  SmallVector<Module *, 8> Modules;
3493  PP.getHeaderSearchInfo().collectAllModules(Modules);
3494  for (unsigned I = 0, N = Modules.size(); I != N; ++I) {
3495  Builder.AddTypedTextChunk(
3496  Builder.getAllocator().CopyString(Modules[I]->Name));
3497  Results.AddResult(Result(Builder.TakeString(),
3500  Modules[I]->isAvailable()
3503  }
3504  } else if (getLangOpts().Modules) {
3505  // Load the named module.
3506  Module *Mod = PP.getModuleLoader().loadModule(ImportLoc, Path,
3508  /*IsInclusionDirective=*/false);
3509  // Enumerate submodules.
3510  if (Mod) {
3511  for (Module::submodule_iterator Sub = Mod->submodule_begin(),
3512  SubEnd = Mod->submodule_end();
3513  Sub != SubEnd; ++Sub) {
3514 
3515  Builder.AddTypedTextChunk(
3516  Builder.getAllocator().CopyString((*Sub)->Name));
3517  Results.AddResult(Result(Builder.TakeString(),
3520  (*Sub)->isAvailable()
3523  }
3524  }
3525  }
3526  Results.ExitScope();
3527  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3528  Results.data(),Results.size());
3529 }
3530 
3532  ParserCompletionContext CompletionContext) {
3533  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3534  CodeCompleter->getCodeCompletionTUInfo(),
3535  mapCodeCompletionContext(*this, CompletionContext));
3536  Results.EnterNewScope();
3537 
3538  // Determine how to filter results, e.g., so that the names of
3539  // values (functions, enumerators, function templates, etc.) are
3540  // only allowed where we can have an expression.
3541  switch (CompletionContext) {
3542  case PCC_Namespace:
3543  case PCC_Class:
3544  case PCC_ObjCInterface:
3545  case PCC_ObjCImplementation:
3546  case PCC_ObjCInstanceVariableList:
3547  case PCC_Template:
3548  case PCC_MemberTemplate:
3549  case PCC_Type:
3550  case PCC_LocalDeclarationSpecifiers:
3551  Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
3552  break;
3553 
3554  case PCC_Statement:
3555  case PCC_ParenthesizedExpression:
3556  case PCC_Expression:
3557  case PCC_ForInit:
3558  case PCC_Condition:
3559  if (WantTypesInContext(CompletionContext, getLangOpts()))
3560  Results.setFilter(&ResultBuilder::IsOrdinaryName);
3561  else
3562  Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3563 
3564  if (getLangOpts().CPlusPlus)
3565  MaybeAddOverrideCalls(*this, /*InContext=*/nullptr, Results);
3566  break;
3567 
3568  case PCC_RecoveryInFunction:
3569  // Unfiltered
3570  break;
3571  }
3572 
3573  // If we are in a C++ non-static member function, check the qualifiers on
3574  // the member function to filter/prioritize the results list.
3575  if (CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext))
3576  if (CurMethod->isInstance())
3577  Results.setObjectTypeQualifiers(
3578  Qualifiers::fromCVRMask(CurMethod->getTypeQualifiers()));
3579 
3580  CodeCompletionDeclConsumer Consumer(Results, CurContext);
3581  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3582  CodeCompleter->includeGlobals(),
3583  CodeCompleter->loadExternal());
3584 
3585  AddOrdinaryNameResults(CompletionContext, S, *this, Results);
3586  Results.ExitScope();
3587 
3588  switch (CompletionContext) {
3589  case PCC_ParenthesizedExpression:
3590  case PCC_Expression:
3591  case PCC_Statement:
3592  case PCC_RecoveryInFunction:
3593  if (S->getFnParent())
3594  AddPrettyFunctionResults(getLangOpts(), Results);
3595  break;
3596 
3597  case PCC_Namespace:
3598  case PCC_Class:
3599  case PCC_ObjCInterface:
3600  case PCC_ObjCImplementation:
3601  case PCC_ObjCInstanceVariableList:
3602  case PCC_Template:
3603  case PCC_MemberTemplate:
3604  case PCC_ForInit:
3605  case PCC_Condition:
3606  case PCC_Type:
3607  case PCC_LocalDeclarationSpecifiers:
3608  break;
3609  }
3610 
3611  if (CodeCompleter->includeMacros())
3612  AddMacroResults(PP, Results, false);
3613 
3614  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3615  Results.data(),Results.size());
3616 }
3617 
3618 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
3619  ParsedType Receiver,
3620  ArrayRef<IdentifierInfo *> SelIdents,
3621  bool AtArgumentExpression,
3622  bool IsSuper,
3623  ResultBuilder &Results);
3624 
3626  bool AllowNonIdentifiers,
3627  bool AllowNestedNameSpecifiers) {
3628  typedef CodeCompletionResult Result;
3629  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3630  CodeCompleter->getCodeCompletionTUInfo(),
3631  AllowNestedNameSpecifiers
3634  Results.EnterNewScope();
3635 
3636  // Type qualifiers can come after names.
3637  Results.AddResult(Result("const"));
3638  Results.AddResult(Result("volatile"));
3639  if (getLangOpts().C99)
3640  Results.AddResult(Result("restrict"));
3641 
3642  if (getLangOpts().CPlusPlus) {
3643  if (getLangOpts().CPlusPlus11 &&
3646  Results.AddResult("final");
3647 
3648  if (AllowNonIdentifiers) {
3649  Results.AddResult(Result("operator"));
3650  }
3651 
3652  // Add nested-name-specifiers.
3653  if (AllowNestedNameSpecifiers) {
3654  Results.allowNestedNameSpecifiers();
3655  Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
3656  CodeCompletionDeclConsumer Consumer(Results, CurContext);
3657  LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
3658  CodeCompleter->includeGlobals(),
3659  CodeCompleter->loadExternal());
3660  Results.setFilter(nullptr);
3661  }
3662  }
3663  Results.ExitScope();
3664 
3665  // If we're in a context where we might have an expression (rather than a
3666  // declaration), and what we've seen so far is an Objective-C type that could
3667  // be a receiver of a class message, this may be a class message send with
3668  // the initial opening bracket '[' missing. Add appropriate completions.
3669  if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
3674  !DS.isTypeAltiVecVector() &&
3675  S &&
3676  (S->getFlags() & Scope::DeclScope) != 0 &&
3679  Scope::AtCatchScope)) == 0) {
3680  ParsedType T = DS.getRepAsType();
3681  if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
3682  AddClassMessageCompletions(*this, S, T, None, false, false, Results);
3683  }
3684 
3685  // Note that we intentionally suppress macro results here, since we do not
3686  // encourage using macros to produce the names of entities.
3687 
3688  HandleCodeCompleteResults(this, CodeCompleter,
3689  Results.getCompletionContext(),
3690  Results.data(), Results.size());
3691 }
3692 
3695  : PreferredType(PreferredType), IntegralConstantExpression(false),
3696  ObjCCollection(false) { }
3697 
3702 };
3703 
3704 /// Perform code-completion in an expression context when we know what
3705 /// type we're looking for.
3707  const CodeCompleteExpressionData &Data) {
3708  ResultBuilder Results(
3709  *this, CodeCompleter->getAllocator(),
3710  CodeCompleter->getCodeCompletionTUInfo(),
3712  Data.PreferredType));
3713  if (Data.ObjCCollection)
3714  Results.setFilter(&ResultBuilder::IsObjCCollection);
3715  else if (Data.IntegralConstantExpression)
3716  Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
3717  else if (WantTypesInContext(PCC_Expression, getLangOpts()))
3718  Results.setFilter(&ResultBuilder::IsOrdinaryName);
3719  else
3720  Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3721 
3722  if (!Data.PreferredType.isNull())
3723  Results.setPreferredType(Data.PreferredType.getNonReferenceType());
3724 
3725  // Ignore any declarations that we were told that we don't care about.
3726  for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
3727  Results.Ignore(Data.IgnoreDecls[I]);
3728 
3729  CodeCompletionDeclConsumer Consumer(Results, CurContext);
3730  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3731  CodeCompleter->includeGlobals(),
3732  CodeCompleter->loadExternal());
3733 
3734  Results.EnterNewScope();
3735  AddOrdinaryNameResults(PCC_Expression, S, *this, Results);
3736  Results.ExitScope();
3737 
3738  bool PreferredTypeIsPointer = false;
3739  if (!Data.PreferredType.isNull())
3740  PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType()
3742  || Data.PreferredType->isBlockPointerType();
3743 
3744  if (S->getFnParent() &&
3745  !Data.ObjCCollection &&
3747  AddPrettyFunctionResults(getLangOpts(), Results);
3748 
3749  if (CodeCompleter->includeMacros())
3750  AddMacroResults(PP, Results, false, PreferredTypeIsPointer);
3751  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3752  Results.data(), Results.size());
3753 }
3754 
3756  if (E.isInvalid())
3757  CodeCompleteOrdinaryName(S, PCC_RecoveryInFunction);
3758  else if (getLangOpts().ObjC1)
3759  CodeCompleteObjCInstanceMessage(S, E.get(), None, false);
3760 }
3761 
3762 /// The set of properties that have already been added, referenced by
3763 /// property name.
3764 typedef llvm::SmallPtrSet<IdentifierInfo*, 16> AddedPropertiesSet;
3765 
3766 /// Retrieve the container definition, if any?
3768  if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
3769  if (Interface->hasDefinition())
3770  return Interface->getDefinition();
3771 
3772  return Interface;
3773  }
3774 
3775  if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3776  if (Protocol->hasDefinition())
3777  return Protocol->getDefinition();
3778 
3779  return Protocol;
3780  }
3781  return Container;
3782 }
3783 
3784 /// Adds a block invocation code completion result for the given block
3785 /// declaration \p BD.
3786 static void AddObjCBlockCall(ASTContext &Context, const PrintingPolicy &Policy,
3787  CodeCompletionBuilder &Builder,
3788  const NamedDecl *BD,
3789  const FunctionTypeLoc &BlockLoc,
3790  const FunctionProtoTypeLoc &BlockProtoLoc) {
3791  Builder.AddResultTypeChunk(
3792  GetCompletionTypeString(BlockLoc.getReturnLoc().getType(), Context,
3793  Policy, Builder.getAllocator()));
3794 
3795  AddTypedNameChunk(Context, Policy, BD, Builder);
3797 
3798  if (BlockProtoLoc && BlockProtoLoc.getTypePtr()->isVariadic()) {
3799  Builder.AddPlaceholderChunk("...");
3800  } else {
3801  for (unsigned I = 0, N = BlockLoc.getNumParams(); I != N; ++I) {
3802  if (I)
3804 
3805  // Format the placeholder string.
3806  std::string PlaceholderStr =
3807  FormatFunctionParameter(Policy, BlockLoc.getParam(I));
3808 
3809  if (I == N - 1 && BlockProtoLoc &&
3810  BlockProtoLoc.getTypePtr()->isVariadic())
3811  PlaceholderStr += ", ...";
3812 
3813  // Add the placeholder string.
3814  Builder.AddPlaceholderChunk(
3815  Builder.getAllocator().CopyString(PlaceholderStr));
3816  }
3817  }
3818 
3820 }
3821 
3822 static void AddObjCProperties(
3823  const CodeCompletionContext &CCContext, ObjCContainerDecl *Container,
3824  bool AllowCategories, bool AllowNullaryMethods, DeclContext *CurContext,
3825  AddedPropertiesSet &AddedProperties, ResultBuilder &Results,
3826  bool IsBaseExprStatement = false, bool IsClassProperty = false) {
3827  typedef CodeCompletionResult Result;
3828 
3829  // Retrieve the definition.
3830  Container = getContainerDef(Container);
3831 
3832  // Add properties in this container.
3833  const auto AddProperty = [&](const ObjCPropertyDecl *P) {
3834  if (!AddedProperties.insert(P->getIdentifier()).second)
3835  return;
3836 
3837  // FIXME: Provide block invocation completion for non-statement
3838  // expressions.
3839  if (!P->getType().getTypePtr()->isBlockPointerType() ||
3840  !IsBaseExprStatement) {
3841  Results.MaybeAddResult(Result(P, Results.getBasePriority(P), nullptr),
3842  CurContext);
3843  return;
3844  }
3845 
3846  // Block setter and invocation completion is provided only when we are able
3847  // to find the FunctionProtoTypeLoc with parameter names for the block.
3848  FunctionTypeLoc BlockLoc;
3849  FunctionProtoTypeLoc BlockProtoLoc;
3850  findTypeLocationForBlockDecl(P->getTypeSourceInfo(), BlockLoc,
3851  BlockProtoLoc);
3852  if (!BlockLoc) {
3853  Results.MaybeAddResult(Result(P, Results.getBasePriority(P), nullptr),
3854  CurContext);
3855  return;
3856  }
3857 
3858  // The default completion result for block properties should be the block
3859  // invocation completion when the base expression is a statement.
3860  CodeCompletionBuilder Builder(Results.getAllocator(),
3861  Results.getCodeCompletionTUInfo());
3862  AddObjCBlockCall(Container->getASTContext(),
3863  getCompletionPrintingPolicy(Results.getSema()), Builder, P,
3864  BlockLoc, BlockProtoLoc);
3865  Results.MaybeAddResult(
3866  Result(Builder.TakeString(), P, Results.getBasePriority(P)),
3867  CurContext);
3868 
3869  // Provide additional block setter completion iff the base expression is a
3870  // statement and the block property is mutable.
3871  if (!P->isReadOnly()) {
3872  CodeCompletionBuilder Builder(Results.getAllocator(),
3873  Results.getCodeCompletionTUInfo());
3874  AddResultTypeChunk(Container->getASTContext(),
3875  getCompletionPrintingPolicy(Results.getSema()), P,
3876  CCContext.getBaseType(), Builder);
3877  Builder.AddTypedTextChunk(
3878  Results.getAllocator().CopyString(P->getName()));
3879  Builder.AddChunk(CodeCompletionString::CK_Equal);
3880 
3881  std::string PlaceholderStr = formatBlockPlaceholder(
3882  getCompletionPrintingPolicy(Results.getSema()), P, BlockLoc,
3883  BlockProtoLoc, /*SuppressBlockName=*/true);
3884  // Add the placeholder string.
3885  Builder.AddPlaceholderChunk(
3886  Builder.getAllocator().CopyString(PlaceholderStr));
3887 
3888  // When completing blocks properties that return void the default
3889  // property completion result should show up before the setter,
3890  // otherwise the setter completion should show up before the default
3891  // property completion, as we normally want to use the result of the
3892  // call.
3893  Results.MaybeAddResult(
3894  Result(Builder.TakeString(), P,
3895  Results.getBasePriority(P) +
3896  (BlockLoc.getTypePtr()->getReturnType()->isVoidType()
3899  CurContext);
3900  }
3901  };
3902 
3903  if (IsClassProperty) {
3904  for (const auto *P : Container->class_properties())
3905  AddProperty(P);
3906  } else {
3907  for (const auto *P : Container->instance_properties())
3908  AddProperty(P);
3909  }
3910 
3911  // Add nullary methods or implicit class properties
3912  if (AllowNullaryMethods) {
3913  ASTContext &Context = Container->getASTContext();
3914  PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
3915  // Adds a method result
3916  const auto AddMethod = [&](const ObjCMethodDecl *M) {
3917  IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0);
3918  if (!Name)
3919  return;
3920  if (!AddedProperties.insert(Name).second)
3921  return;
3922  CodeCompletionBuilder Builder(Results.getAllocator(),
3923  Results.getCodeCompletionTUInfo());
3924  AddResultTypeChunk(Context, Policy, M, CCContext.getBaseType(), Builder);
3925  Builder.AddTypedTextChunk(
3926  Results.getAllocator().CopyString(Name->getName()));
3927  Results.MaybeAddResult(
3928  Result(Builder.TakeString(), M,
3930  CurContext);
3931  };
3932 
3933  if (IsClassProperty) {
3934  for (const auto *M : Container->methods()) {
3935  // Gather the class method that can be used as implicit property
3936  // getters. Methods with arguments or methods that return void aren't
3937  // added to the results as they can't be used as a getter.
3938  if (!M->getSelector().isUnarySelector() ||
3939  M->getReturnType()->isVoidType() || M->isInstanceMethod())
3940  continue;
3941  AddMethod(M);
3942  }
3943  } else {
3944  for (auto *M : Container->methods()) {
3945  if (M->getSelector().isUnarySelector())
3946  AddMethod(M);
3947  }
3948  }
3949  }
3950 
3951  // Add properties in referenced protocols.
3952  if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3953  for (auto *P : Protocol->protocols())
3954  AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3955  CurContext, AddedProperties, Results,
3956  IsBaseExprStatement, IsClassProperty);
3957  } else if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)){
3958  if (AllowCategories) {
3959  // Look through categories.
3960  for (auto *Cat : IFace->known_categories())
3961  AddObjCProperties(CCContext, Cat, AllowCategories, AllowNullaryMethods,
3962  CurContext, AddedProperties, Results,
3963  IsBaseExprStatement, IsClassProperty);
3964  }
3965 
3966  // Look through protocols.
3967  for (auto *I : IFace->all_referenced_protocols())
3968  AddObjCProperties(CCContext, I, AllowCategories, AllowNullaryMethods,
3969  CurContext, AddedProperties, Results,
3970  IsBaseExprStatement, IsClassProperty);
3971 
3972  // Look in the superclass.
3973  if (IFace->getSuperClass())
3974  AddObjCProperties(CCContext, IFace->getSuperClass(), AllowCategories,
3975  AllowNullaryMethods, CurContext, AddedProperties,
3976  Results, IsBaseExprStatement, IsClassProperty);
3977  } else if (const ObjCCategoryDecl *Category
3978  = dyn_cast<ObjCCategoryDecl>(Container)) {
3979  // Look through protocols.
3980  for (auto *P : Category->protocols())
3981  AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3982  CurContext, AddedProperties, Results,
3983  IsBaseExprStatement, IsClassProperty);
3984  }
3985 }
3986 
3988  ResultBuilder &Results, Scope *S,
3989  QualType BaseType,
3990  RecordDecl *RD,
3991  Optional<FixItHint> AccessOpFixIt) {
3992  // Indicate that we are performing a member access, and the cv-qualifiers
3993  // for the base object type.
3994  Results.setObjectTypeQualifiers(BaseType.getQualifiers());
3995 
3996  // Access to a C/C++ class, struct, or union.
3997  Results.allowNestedNameSpecifiers();
3998  std::vector<FixItHint> FixIts;
3999  if (AccessOpFixIt)
4000  FixIts.emplace_back(AccessOpFixIt.getValue());
4001  CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext, std::move(FixIts));
4002  SemaRef.LookupVisibleDecls(RD, Sema::LookupMemberName, Consumer,
4003  SemaRef.CodeCompleter->includeGlobals(),
4004  /*IncludeDependentBases=*/true,
4005  SemaRef.CodeCompleter->loadExternal());
4006 
4007  if (SemaRef.getLangOpts().CPlusPlus) {
4008  if (!Results.empty()) {
4009  // The "template" keyword can follow "->" or "." in the grammar.
4010  // However, we only want to suggest the template keyword if something
4011  // is dependent.
4012  bool IsDependent = BaseType->isDependentType();
4013  if (!IsDependent) {
4014  for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
4015  if (DeclContext *Ctx = DepScope->getEntity()) {
4016  IsDependent = Ctx->isDependentContext();
4017  break;
4018  }
4019  }
4020 
4021  if (IsDependent)
4022  Results.AddResult(CodeCompletionResult("template"));
4023  }
4024  }
4025 }
4026 
4028  Expr *OtherOpBase,
4029  SourceLocation OpLoc, bool IsArrow,
4030  bool IsBaseExprStatement) {
4031  if (!Base || !CodeCompleter)
4032  return;
4033 
4034  ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
4035  if (ConvertedBase.isInvalid())
4036  return;
4037  QualType ConvertedBaseType = ConvertedBase.get()->getType();
4038 
4039  enum CodeCompletionContext::Kind contextKind;
4040 
4041  if (IsArrow) {
4042  if (const PointerType *Ptr = ConvertedBaseType->getAs<PointerType>())
4043  ConvertedBaseType = Ptr->getPointeeType();
4044  }
4045 
4046  if (IsArrow) {
4048  } else {
4049  if (ConvertedBaseType->isObjCObjectPointerType() ||
4050  ConvertedBaseType->isObjCObjectOrInterfaceType()) {
4052  } else {
4054  }
4055  }
4056 
4057  CodeCompletionContext CCContext(contextKind, ConvertedBaseType);
4058  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4059  CodeCompleter->getCodeCompletionTUInfo(), CCContext,
4060  &ResultBuilder::IsMember);
4061 
4062  auto DoCompletion = [&](Expr *Base, bool IsArrow, Optional<FixItHint> AccessOpFixIt) -> bool {
4063  if (!Base)
4064  return false;
4065 
4066  ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
4067  if (ConvertedBase.isInvalid())
4068  return false;
4069  Base = ConvertedBase.get();
4070 
4071  QualType BaseType = Base->getType();
4072 
4073  if (IsArrow) {
4074  if (const PointerType *Ptr = BaseType->getAs<PointerType>())
4075  BaseType = Ptr->getPointeeType();
4076  else if (BaseType->isObjCObjectPointerType())
4077  /*Do nothing*/;
4078  else
4079  return false;
4080  }
4081 
4082  if (const RecordType *Record = BaseType->getAs<RecordType>()) {
4083  AddRecordMembersCompletionResults(*this, Results, S, BaseType,
4084  Record->getDecl(),
4085  std::move(AccessOpFixIt));
4086  } else if (const auto *TST =
4087  BaseType->getAs<TemplateSpecializationType>()) {
4088  TemplateName TN = TST->getTemplateName();
4089  if (const auto *TD =
4090  dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl())) {
4091  CXXRecordDecl *RD = TD->getTemplatedDecl();
4092  AddRecordMembersCompletionResults(*this, Results, S, BaseType, RD,
4093  std::move(AccessOpFixIt));
4094  }
4095  } else if (const auto *ICNT = BaseType->getAs<InjectedClassNameType>()) {
4096  if (auto *RD = ICNT->getDecl())
4097  AddRecordMembersCompletionResults(*this, Results, S, BaseType, RD,
4098  std::move(AccessOpFixIt));
4099  } else if (!IsArrow && BaseType->isObjCObjectPointerType()) {
4100  // Objective-C property reference.
4101  AddedPropertiesSet AddedProperties;
4102 
4103  if (const ObjCObjectPointerType *ObjCPtr =
4104  BaseType->getAsObjCInterfacePointerType()) {
4105  // Add property results based on our interface.
4106  assert(ObjCPtr && "Non-NULL pointer guaranteed above!");
4107  AddObjCProperties(CCContext, ObjCPtr->getInterfaceDecl(), true,
4108  /*AllowNullaryMethods=*/true, CurContext,
4109  AddedProperties, Results, IsBaseExprStatement);
4110  }
4111 
4112  // Add properties from the protocols in a qualified interface.
4113  for (auto *I : BaseType->getAs<ObjCObjectPointerType>()->quals())
4114  AddObjCProperties(CCContext, I, true, /*AllowNullaryMethods=*/true,
4115  CurContext, AddedProperties, Results,
4116  IsBaseExprStatement);
4117  } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
4118  (!IsArrow && BaseType->isObjCObjectType())) {
4119  // Objective-C instance variable access.
4120  ObjCInterfaceDecl *Class = nullptr;
4121  if (const ObjCObjectPointerType *ObjCPtr =
4122  BaseType->getAs<ObjCObjectPointerType>())
4123  Class = ObjCPtr->getInterfaceDecl();
4124  else
4125  Class = BaseType->getAs<ObjCObjectType>()->getInterface();
4126 
4127  // Add all ivars from this class and its superclasses.
4128  if (Class) {
4129  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4130  Results.setFilter(&ResultBuilder::IsObjCIvar);
4132  Class, LookupMemberName, Consumer, CodeCompleter->includeGlobals(),
4133  /*IncludeDependentBases=*/false, CodeCompleter->loadExternal());
4134  }
4135  }
4136 
4137  // FIXME: How do we cope with isa?
4138  return true;
4139  };
4140 
4141  Results.EnterNewScope();
4142 
4143  bool CompletionSucceded = DoCompletion(Base, IsArrow, None);
4144  if (CodeCompleter->includeFixIts()) {
4145  const CharSourceRange OpRange =
4146  CharSourceRange::getTokenRange(OpLoc, OpLoc);
4147  CompletionSucceded |= DoCompletion(
4148  OtherOpBase, !IsArrow,
4149  FixItHint::CreateReplacement(OpRange, IsArrow ? "." : "->"));
4150  }
4151 
4152  Results.ExitScope();
4153 
4154  if (!CompletionSucceded)
4155  return;
4156 
4157  // Hand off the results found for code completion.
4158  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4159  Results.data(), Results.size());
4160 }
4161 
4163  IdentifierInfo &ClassName,
4164  SourceLocation ClassNameLoc,
4165  bool IsBaseExprStatement) {
4166  IdentifierInfo *ClassNamePtr = &ClassName;
4167  ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(ClassNamePtr, ClassNameLoc);
4168  if (!IFace)
4169  return;
4170  CodeCompletionContext CCContext(
4172  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4173  CodeCompleter->getCodeCompletionTUInfo(), CCContext,
4174  &ResultBuilder::IsMember);
4175  Results.EnterNewScope();
4176  AddedPropertiesSet AddedProperties;
4177  AddObjCProperties(CCContext, IFace, true,
4178  /*AllowNullaryMethods=*/true, CurContext, AddedProperties,
4179  Results, IsBaseExprStatement,
4180  /*IsClassProperty=*/true);
4181  Results.ExitScope();
4182  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4183  Results.data(), Results.size());
4184 }
4185 
4186 void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
4187  if (!CodeCompleter)
4188  return;
4189 
4190  ResultBuilder::LookupFilter Filter = nullptr;
4193  switch ((DeclSpec::TST)TagSpec) {
4194  case DeclSpec::TST_enum:
4195  Filter = &ResultBuilder::IsEnum;
4196  ContextKind = CodeCompletionContext::CCC_EnumTag;
4197  break;
4198 
4199  case DeclSpec::TST_union:
4200  Filter = &ResultBuilder::IsUnion;
4202  break;
4203 
4204  case DeclSpec::TST_struct:
4205  case DeclSpec::TST_class:
4207  Filter = &ResultBuilder::IsClassOrStruct;
4209  break;
4210 
4211  default:
4212  llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
4213  }
4214 
4215  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4216  CodeCompleter->getCodeCompletionTUInfo(), ContextKind);
4217  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4218 
4219  // First pass: look for tags.
4220  Results.setFilter(Filter);
4221  LookupVisibleDecls(S, LookupTagName, Consumer,
4222  CodeCompleter->includeGlobals(),
4223  CodeCompleter->loadExternal());
4224 
4225  if (CodeCompleter->includeGlobals()) {
4226  // Second pass: look for nested name specifiers.
4227  Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
4228  LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
4229  CodeCompleter->includeGlobals(),
4230  CodeCompleter->loadExternal());
4231  }
4232 
4233  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4234  Results.data(),Results.size());
4235 }
4236 
4237 static void AddTypeQualifierResults(DeclSpec &DS, ResultBuilder &Results,
4238  const LangOptions &LangOpts) {
4239  if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
4240  Results.AddResult("const");
4242  Results.AddResult("volatile");
4243  if (LangOpts.C99 && !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
4244  Results.AddResult("restrict");
4245  if (LangOpts.C11 && !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic))
4246  Results.AddResult("_Atomic");
4247  if (LangOpts.MSVCCompat && !(DS.getTypeQualifiers() & DeclSpec::TQ_unaligned))
4248  Results.AddResult("__unaligned");
4249 }
4250 
4252  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4253  CodeCompleter->getCodeCompletionTUInfo(),
4255  Results.EnterNewScope();
4256  AddTypeQualifierResults(DS, Results, LangOpts);
4257  Results.ExitScope();
4258  HandleCodeCompleteResults(this, CodeCompleter,
4259  Results.getCompletionContext(),
4260  Results.data(), Results.size());
4261 }
4262 
4264  const VirtSpecifiers *VS) {
4265  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4266  CodeCompleter->getCodeCompletionTUInfo(),
4268  Results.EnterNewScope();
4269  AddTypeQualifierResults(DS, Results, LangOpts);
4270  if (LangOpts.CPlusPlus11) {
4271  Results.AddResult("noexcept");
4273  !D.isCtorOrDtor() && !D.isStaticMember()) {
4274  if (!VS || !VS->isFinalSpecified())
4275  Results.AddResult("final");
4276  if (!VS || !VS->isOverrideSpecified())
4277  Results.AddResult("override");
4278  }
4279  }
4280  Results.ExitScope();
4281  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4282  Results.data(), Results.size());
4283 }
4284 
4286  CodeCompleteExpression(S, QualType(getASTContext().getSizeType()));
4287 }
4288 
4290  if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
4291  return;
4292 
4293  SwitchStmt *Switch = getCurFunction()->SwitchStack.back().getPointer();
4294  QualType type = Switch->getCond()->IgnoreImplicit()->getType();
4295  if (!type->isEnumeralType()) {
4296  CodeCompleteExpressionData Data(type);
4297  Data.IntegralConstantExpression = true;
4298  CodeCompleteExpression(S, Data);
4299  return;
4300  }
4301 
4302  // Code-complete the cases of a switch statement over an enumeration type
4303  // by providing the list of
4304  EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
4305  if (EnumDecl *Def = Enum->getDefinition())
4306  Enum = Def;
4307 
4308  // Determine which enumerators we have already seen in the switch statement.
4309  // FIXME: Ideally, we would also be able to look *past* the code-completion
4310  // token, in case we are code-completing in the middle of the switch and not
4311  // at the end. However, we aren't able to do so at the moment.
4312  llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen;
4313  NestedNameSpecifier *Qualifier = nullptr;
4314  for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
4315  SC = SC->getNextSwitchCase()) {
4316  CaseStmt *Case = dyn_cast<CaseStmt>(SC);
4317  if (!Case)
4318  continue;
4319 
4320  Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
4321  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal))
4322  if (EnumConstantDecl *Enumerator
4323  = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
4324  // We look into the AST of the case statement to determine which
4325  // enumerator was named. Alternatively, we could compute the value of
4326  // the integral constant expression, then compare it against the
4327  // values of each enumerator. However, value-based approach would not
4328  // work as well with C++ templates where enumerators declared within a
4329  // template are type- and value-dependent.
4330  EnumeratorsSeen.insert(Enumerator);
4331 
4332  // If this is a qualified-id, keep track of the nested-name-specifier
4333  // so that we can reproduce it as part of code completion, e.g.,
4334  //
4335  // switch (TagD.getKind()) {
4336  // case TagDecl::TK_enum:
4337  // break;
4338  // case XXX
4339  //
4340  // At the XXX, our completions are TagDecl::TK_union,
4341  // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
4342  // TK_struct, and TK_class.
4343  Qualifier = DRE->getQualifier();
4344  }
4345  }
4346 
4347  if (getLangOpts().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) {
4348  // If there are no prior enumerators in C++, check whether we have to
4349  // qualify the names of the enumerators that we suggest, because they
4350  // may not be visible in this scope.
4351  Qualifier = getRequiredQualification(Context, CurContext, Enum);
4352  }
4353 
4354  // Add any enumerators that have not yet been mentioned.
4355  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4356  CodeCompleter->getCodeCompletionTUInfo(),
4358  Results.EnterNewScope();
4359  for (auto *E : Enum->enumerators()) {
4360  if (EnumeratorsSeen.count(E))
4361  continue;
4362 
4363  CodeCompletionResult R(E, CCP_EnumInCase, Qualifier);
4364  Results.AddResult(R, CurContext, nullptr, false);
4365  }
4366  Results.ExitScope();
4367 
4368  if (CodeCompleter->includeMacros()) {
4369  AddMacroResults(PP, Results, false);
4370  }
4371  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4372  Results.data(), Results.size());
4373 }
4374 
4375 static bool anyNullArguments(ArrayRef<Expr *> Args) {
4376  if (Args.size() && !Args.data())
4377  return true;
4378 
4379  for (unsigned I = 0; I != Args.size(); ++I)
4380  if (!Args[I])
4381  return true;
4382 
4383  return false;
4384 }
4385 
4387 
4388 static void mergeCandidatesWithResults(Sema &SemaRef,
4390  OverloadCandidateSet &CandidateSet,
4391  SourceLocation Loc) {
4392  if (!CandidateSet.empty()) {
4393  // Sort the overload candidate set by placing the best overloads first.
4394  std::stable_sort(
4395  CandidateSet.begin(), CandidateSet.end(),
4396  [&](const OverloadCandidate &X, const OverloadCandidate &Y) {
4397  return isBetterOverloadCandidate(SemaRef, X, Y, Loc,
4398  CandidateSet.getKind());
4399  });
4400 
4401  // Add the remaining viable overload candidates as code-completion results.
4402  for (auto &Candidate : CandidateSet) {
4403  if (Candidate.Function && Candidate.Function->isDeleted())
4404  continue;
4405  if (Candidate.Viable)
4406  Results.push_back(ResultCandidate(Candidate.Function));
4407  }
4408  }
4409 }
4410 
4411 /// Get the type of the Nth parameter from a given set of overload
4412 /// candidates.
4413 static QualType getParamType(Sema &SemaRef,
4414  ArrayRef<ResultCandidate> Candidates,
4415  unsigned N) {
4416 
4417  // Given the overloads 'Candidates' for a function call matching all arguments
4418  // up to N, return the type of the Nth parameter if it is the same for all
4419  // overload candidates.
4420  QualType ParamType;
4421  for (auto &Candidate : Candidates) {
4422  if (auto FType = Candidate.getFunctionType())
4423  if (auto Proto = dyn_cast<FunctionProtoType>(FType))
4424  if (N < Proto->getNumParams()) {
4425  if (ParamType.isNull())
4426  ParamType = Proto->getParamType(N);
4427  else if (!SemaRef.Context.hasSameUnqualifiedType(
4428  ParamType.getNonReferenceType(),
4429  Proto->getParamType(N).getNonReferenceType()))
4430  // Otherwise return a default-constructed QualType.
4431  return QualType();
4432  }
4433  }
4434 
4435  return ParamType;
4436 }
4437 
4438 static void CodeCompleteOverloadResults(Sema &SemaRef, Scope *S,
4440  unsigned CurrentArg,
4441  bool CompleteExpressionWithCurrentArg = true) {
4442  QualType ParamType;
4443  if (CompleteExpressionWithCurrentArg)
4444  ParamType = getParamType(SemaRef, Candidates, CurrentArg);
4445 
4446  if (ParamType.isNull())
4448  else
4449  SemaRef.CodeCompleteExpression(S, ParamType);
4450 
4451  if (!Candidates.empty())
4452  SemaRef.CodeCompleter->ProcessOverloadCandidates(SemaRef, CurrentArg,
4453  Candidates.data(),
4454  Candidates.size());
4455 }
4456 
4458  if (!CodeCompleter)
4459  return;
4460 
4461  // When we're code-completing for a call, we fall back to ordinary
4462  // name code-completion whenever we can't produce specific
4463  // results. We may want to revisit this strategy in the future,
4464  // e.g., by merging the two kinds of results.
4465 
4466  // FIXME: Provide support for variadic template functions.
4467 
4468  // Ignore type-dependent call expressions entirely.
4469  if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args) ||
4471  CodeCompleteOrdinaryName(S, PCC_Expression);
4472  return;
4473  }
4474 
4475  // Build an overload candidate set based on the functions we find.
4476  SourceLocation Loc = Fn->getExprLoc();
4478 
4480 
4481  Expr *NakedFn = Fn->IgnoreParenCasts();
4482  if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
4483  AddOverloadedCallCandidates(ULE, Args, CandidateSet,
4484  /*PartialOverloading=*/true);
4485  else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) {
4486  TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
4487  if (UME->hasExplicitTemplateArgs()) {
4488  UME->copyTemplateArgumentsInto(TemplateArgsBuffer);
4489  TemplateArgs = &TemplateArgsBuffer;
4490  }
4491 
4492  // Add the base as first argument (use a nullptr if the base is implicit).
4493  SmallVector<Expr *, 12> ArgExprs(
4494  1, UME->isImplicitAccess() ? nullptr : UME->getBase());
4495  ArgExprs.append(Args.begin(), Args.end());
4496  UnresolvedSet<8> Decls;
4497  Decls.append(UME->decls_begin(), UME->decls_end());
4498  const bool FirstArgumentIsBase = !UME->isImplicitAccess() && UME->getBase();
4499  AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs,
4500  /*SuppressUsedConversions=*/false,
4501  /*PartialOverloading=*/true,
4502  FirstArgumentIsBase);
4503  } else {
4504  FunctionDecl *FD = nullptr;
4505  if (auto MCE = dyn_cast<MemberExpr>(NakedFn))
4506  FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl());
4507  else if (auto DRE = dyn_cast<DeclRefExpr>(NakedFn))
4508  FD = dyn_cast<FunctionDecl>(DRE->getDecl());
4509  if (FD) { // We check whether it's a resolved function declaration.
4510  if (!getLangOpts().CPlusPlus ||
4511  !FD->getType()->getAs<FunctionProtoType>())
4512  Results.push_back(ResultCandidate(FD));
4513  else
4514  AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()),
4515  Args, CandidateSet,
4516  /*SuppressUsedConversions=*/false,
4517  /*PartialOverloading=*/true);
4518 
4519  } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) {
4520  // If expression's type is CXXRecordDecl, it may overload the function
4521  // call operator, so we check if it does and add them as candidates.
4522  // A complete type is needed to lookup for member function call operators.
4523  if (isCompleteType(Loc, NakedFn->getType())) {
4524  DeclarationName OpName = Context.DeclarationNames
4525  .getCXXOperatorName(OO_Call);
4526  LookupResult R(*this, OpName, Loc, LookupOrdinaryName);
4527  LookupQualifiedName(R, DC);
4528  R.suppressDiagnostics();
4529  SmallVector<Expr *, 12> ArgExprs(1, NakedFn);
4530  ArgExprs.append(Args.begin(), Args.end());
4531  AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet,
4532  /*ExplicitArgs=*/nullptr,
4533  /*SuppressUsedConversions=*/false,
4534  /*PartialOverloading=*/true);
4535  }
4536  } else {
4537  // Lastly we check whether expression's type is function pointer or
4538  // function.
4539  QualType T = NakedFn->getType();
4540  if (!T->getPointeeType().isNull())
4541  T = T->getPointeeType();
4542 
4543  if (auto FP = T->getAs<FunctionProtoType>()) {
4544  if (!TooManyArguments(FP->getNumParams(), Args.size(),
4545  /*PartialOverloading=*/true) ||
4546  FP->isVariadic())
4547  Results.push_back(ResultCandidate(FP));
4548  } else if (auto FT = T->getAs<FunctionType>())
4549  // No prototype and declaration, it may be a K & R style function.
4550  Results.push_back(ResultCandidate(FT));
4551  }
4552  }
4553 
4554  mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4555  CodeCompleteOverloadResults(*this, S, Results, Args.size(),
4556  !CandidateSet.empty());
4557 }
4558 
4560  ArrayRef<Expr *> Args) {
4561  if (!CodeCompleter)
4562  return;
4563 
4564  // A complete type is needed to lookup for constructors.
4565  CXXRecordDecl *RD =
4566  isCompleteType(Loc, Type) ? Type->getAsCXXRecordDecl() : nullptr;
4567  if (!RD) {
4568  CodeCompleteExpression(S, Type);
4569  return;
4570  }
4571 
4572  // FIXME: Provide support for member initializers.
4573  // FIXME: Provide support for variadic template constructors.
4574 
4576 
4577  for (auto C : LookupConstructors(RD)) {
4578  if (auto FD = dyn_cast<FunctionDecl>(C)) {
4579  AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()),
4580  Args, CandidateSet,
4581  /*SuppressUsedConversions=*/false,
4582  /*PartialOverloading=*/true);
4583  } else if (auto FTD = dyn_cast<FunctionTemplateDecl>(C)) {
4584  AddTemplateOverloadCandidate(FTD,
4585  DeclAccessPair::make(FTD, C->getAccess()),
4586  /*ExplicitTemplateArgs=*/nullptr,
4587  Args, CandidateSet,
4588  /*SuppressUsedConversions=*/false,
4589  /*PartialOverloading=*/true);
4590  }
4591  }
4592 
4594  mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4595  CodeCompleteOverloadResults(*this, S, Results, Args.size());
4596 }
4597 
4599  ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
4600  if (!VD) {
4601  CodeCompleteOrdinaryName(S, PCC_Expression);
4602  return;
4603  }
4604 
4605  CodeCompleteExpression(S, VD->getType());
4606 }
4607 
4609  QualType ResultType;
4610  if (isa<BlockDecl>(CurContext)) {
4611  if (BlockScopeInfo *BSI = getCurBlock())
4612  ResultType = BSI->ReturnType;
4613  } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext))
4614  ResultType = Function->getReturnType();
4615  else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext))
4616  ResultType = Method->getReturnType();
4617 
4618  if (ResultType.isNull())
4619  CodeCompleteOrdinaryName(S, PCC_Expression);
4620  else
4621  CodeCompleteExpression(S, ResultType);
4622 }
4623 
4625  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4626  CodeCompleter->getCodeCompletionTUInfo(),
4627  mapCodeCompletionContext(*this, PCC_Statement));
4628  Results.setFilter(&ResultBuilder::IsOrdinaryName);
4629  Results.EnterNewScope();
4630 
4631  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4632  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4633  CodeCompleter->includeGlobals(),
4634  CodeCompleter->loadExternal());
4635 
4636  AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
4637 
4638  // "else" block
4639  CodeCompletionBuilder Builder(Results.getAllocator(),
4640  Results.getCodeCompletionTUInfo());
4641  Builder.AddTypedTextChunk("else");
4642  if (Results.includeCodePatterns()) {
4643  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4644  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4645  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4646  Builder.AddPlaceholderChunk("statements");
4647  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4648  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4649  }
4650  Results.AddResult(Builder.TakeString());
4651 
4652  // "else if" block
4653  Builder.AddTypedTextChunk("else");
4654  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4655  Builder.AddTextChunk("if");
4656  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4657  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4658  if (getLangOpts().CPlusPlus)
4659  Builder.AddPlaceholderChunk("condition");
4660  else
4661  Builder.AddPlaceholderChunk("expression");
4662  Builder.AddChunk(CodeCompletionString::CK_RightParen);
4663  if (Results.includeCodePatterns()) {
4664  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4665  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4666  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4667  Builder.AddPlaceholderChunk("statements");
4668  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4669  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4670  }
4671  Results.AddResult(Builder.TakeString());
4672 
4673  Results.ExitScope();
4674 
4675  if (S->getFnParent())
4676  AddPrettyFunctionResults(getLangOpts(), Results);
4677 
4678  if (CodeCompleter->includeMacros())
4679  AddMacroResults(PP, Results, false);
4680 
4681  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4682  Results.data(),Results.size());
4683 }
4684 
4686  if (LHS)
4687  CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType());
4688  else
4689  CodeCompleteOrdinaryName(S, PCC_Expression);
4690 }
4691 
4693  bool EnteringContext) {
4694  if (SS.isEmpty() || !CodeCompleter)
4695  return;
4696 
4697  // We want to keep the scope specifier even if it's invalid (e.g. the scope
4698  // "a::b::" is not corresponding to any context/namespace in the AST), since
4699  // it can be useful for global code completion which have information about
4700  // contexts/symbols that are not in the AST.
4701  if (SS.isInvalid()) {
4703  CC.setCXXScopeSpecifier(SS);
4704  HandleCodeCompleteResults(this, CodeCompleter, CC, nullptr, 0);
4705  return;
4706  }
4707  // Always pretend to enter a context to ensure that a dependent type
4708  // resolves to a dependent record.
4709  DeclContext *Ctx = computeDeclContext(SS, /*EnteringContext=*/true);
4710  if (!Ctx)
4711  return;
4712 
4713  // Try to instantiate any non-dependent declaration contexts before
4714  // we look in them.
4715  if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
4716  return;
4717 
4718  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4719  CodeCompleter->getCodeCompletionTUInfo(),
4721  Results.EnterNewScope();
4722 
4723  // The "template" keyword can follow "::" in the grammar, but only
4724  // put it into the grammar if the nested-name-specifier is dependent.
4725  NestedNameSpecifier *NNS = SS.getScopeRep();
4726  if (!Results.empty() && NNS->isDependent())
4727  Results.AddResult("template");
4728 
4729  // Add calls to overridden virtual functions, if there are any.
4730  //
4731  // FIXME: This isn't wonderful, because we don't know whether we're actually
4732  // in a context that permits expressions. This is a general issue with
4733  // qualified-id completions.
4734  if (!EnteringContext)
4735  MaybeAddOverrideCalls(*this, Ctx, Results);
4736  Results.ExitScope();
4737 
4738  if (CodeCompleter->includeNamespaceLevelDecls() ||
4739  (!Ctx->isNamespace() && !Ctx->isTranslationUnit())) {
4740  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4741  LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer,
4742  /*IncludeGlobalScope=*/true,
4743  /*IncludeDependentBases=*/true,
4744  CodeCompleter->loadExternal());
4745  }
4746 
4747  auto CC = Results.getCompletionContext();
4748  CC.setCXXScopeSpecifier(SS);
4749 
4750  HandleCodeCompleteResults(this, CodeCompleter, CC, Results.data(),
4751  Results.size());
4752 }
4753 
4755  if (!CodeCompleter)
4756  return;
4757 
4758  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4759  CodeCompleter->getCodeCompletionTUInfo(),
4761  &ResultBuilder::IsNestedNameSpecifier);
4762  Results.EnterNewScope();
4763 
4764  // If we aren't in class scope, we could see the "namespace" keyword.
4765  if (!S->isClassScope())
4766  Results.AddResult(CodeCompletionResult("namespace"));
4767 
4768  // After "using", we can see anything that would start a
4769  // nested-name-specifier.
4770  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4771  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4772  CodeCompleter->includeGlobals(),
4773  CodeCompleter->loadExternal());
4774  Results.ExitScope();
4775 
4776  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4777  Results.data(), Results.size());
4778 }
4779 
4781  if (!CodeCompleter)
4782  return;
4783 
4784  // After "using namespace", we expect to see a namespace name or namespace
4785  // alias.
4786  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4787  CodeCompleter->getCodeCompletionTUInfo(),
4789  &ResultBuilder::IsNamespaceOrAlias);
4790  Results.EnterNewScope();
4791  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4792  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4793  CodeCompleter->includeGlobals(),
4794  CodeCompleter->loadExternal());
4795  Results.ExitScope();
4796  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4797  Results.data(), Results.size());
4798 }
4799 
4801  if (!CodeCompleter)
4802  return;
4803 
4804  DeclContext *Ctx = S->getEntity();
4805  if (!S->getParent())
4806  Ctx = Context.getTranslationUnitDecl();
4807 
4808  bool SuppressedGlobalResults
4809  = Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
4810 
4811  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4812  CodeCompleter->getCodeCompletionTUInfo(),
4813  SuppressedGlobalResults
4816  &ResultBuilder::IsNamespace);
4817 
4818  if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
4819  // We only want to see those namespaces that have already been defined
4820  // within this scope, because its likely that the user is creating an
4821  // extended namespace declaration. Keep track of the most recent
4822  // definition of each namespace.
4823  std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
4825  NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end());
4826  NS != NSEnd; ++NS)
4827  OrigToLatest[NS->getOriginalNamespace()] = *NS;
4828 
4829  // Add the most recent definition (or extended definition) of each
4830  // namespace to the list of results.
4831  Results.EnterNewScope();
4832  for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
4833  NS = OrigToLatest.begin(),
4834  NSEnd = OrigToLatest.end();
4835  NS != NSEnd; ++NS)
4836  Results.AddResult(CodeCompletionResult(
4837  NS->second, Results.getBasePriority(NS->second),
4838  nullptr),
4839  CurContext, nullptr, false);
4840  Results.ExitScope();
4841  }
4842 
4843  HandleCodeCompleteResults(this, CodeCompleter,
4844  Results.getCompletionContext(),
4845  Results.data(),Results.size());
4846 }
4847 
4849  if (!CodeCompleter)
4850  return;
4851 
4852  // After "namespace", we expect to see a namespace or alias.
4853  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4854  CodeCompleter->getCodeCompletionTUInfo(),
4856  &ResultBuilder::IsNamespaceOrAlias);
4857  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4858  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4859  CodeCompleter->includeGlobals(),
4860  CodeCompleter->loadExternal());
4861  HandleCodeCompleteResults(this, CodeCompleter,
4862  Results.getCompletionContext(),
4863  Results.data(),Results.size());
4864 }
4865 
4867  if (!CodeCompleter)
4868  return;
4869 
4870  typedef CodeCompletionResult Result;
4871  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4872  CodeCompleter->getCodeCompletionTUInfo(),
4874  &ResultBuilder::IsType);
4875  Results.EnterNewScope();
4876 
4877  // Add the names of overloadable operators.
4878 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4879  if (std::strcmp(Spelling, "?")) \
4880  Results.AddResult(Result(Spelling));
4881 #include "clang/Basic/OperatorKinds.def"
4882 
4883  // Add any type names visible from the current scope
4884  Results.allowNestedNameSpecifiers();
4885  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4886  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4887  CodeCompleter->includeGlobals(),
4888  CodeCompleter->loadExternal());
4889 
4890  // Add any type specifiers
4891  AddTypeSpecifierResults(getLangOpts(), Results);
4892  Results.ExitScope();
4893 
4894  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4895  Results.data(), Results.size());
4896 }
4897 
4899  Decl *ConstructorD,
4900  ArrayRef <CXXCtorInitializer *> Initializers) {
4901  if (!ConstructorD)
4902  return;
4903 
4904  AdjustDeclIfTemplate(ConstructorD);
4905 
4906  CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ConstructorD);
4907  if (!Constructor)
4908  return;
4909 
4910  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4911  CodeCompleter->getCodeCompletionTUInfo(),
4913  Results.EnterNewScope();
4914 
4915  // Fill in any already-initialized fields or base classes.
4916  llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
4917  llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
4918  for (unsigned I = 0, E = Initializers.size(); I != E; ++I) {
4919  if (Initializers[I]->isBaseInitializer())
4920  InitializedBases.insert(
4921  Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0)));
4922  else
4923  InitializedFields.insert(cast<FieldDecl>(
4924  Initializers[I]->getAnyMember()));
4925  }
4926 
4927  // Add completions for base classes.
4928  CodeCompletionBuilder Builder(Results.getAllocator(),
4929  Results.getCodeCompletionTUInfo());
4931  bool SawLastInitializer = Initializers.empty();
4932  CXXRecordDecl *ClassDecl = Constructor->getParent();
4933  for (const auto &Base : ClassDecl->bases()) {
4934  if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4935  .second) {
4936  SawLastInitializer
4937  = !Initializers.empty() &&
4938  Initializers.back()->isBaseInitializer() &&
4939  Context.hasSameUnqualifiedType(Base.getType(),
4940  QualType(Initializers.back()->getBaseClass(), 0));
4941  continue;
4942  }
4943 
4944  Builder.AddTypedTextChunk(
4945  Results.getAllocator().CopyString(
4946  Base.getType().getAsString(Policy)));
4947  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4948  Builder.AddPlaceholderChunk("args");
4949  Builder.AddChunk(CodeCompletionString::CK_RightParen);
4950  Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4951  SawLastInitializer? CCP_NextInitializer
4953  SawLastInitializer = false;
4954  }
4955 
4956  // Add completions for virtual base classes.
4957  for (const auto &Base : ClassDecl->vbases()) {
4958  if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4959  .second) {
4960  SawLastInitializer
4961  = !Initializers.empty() &&
4962  Initializers.back()->isBaseInitializer() &&
4963  Context.hasSameUnqualifiedType(Base.getType(),
4964  QualType(Initializers.back()->getBaseClass(), 0));
4965  continue;
4966  }
4967 
4968  Builder.AddTypedTextChunk(
4969  Builder.getAllocator().CopyString(
4970  Base.getType().getAsString(Policy)));
4971  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4972  Builder.AddPlaceholderChunk("args");
4973  Builder.AddChunk(CodeCompletionString::CK_RightParen);
4974  Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4975  SawLastInitializer? CCP_NextInitializer
4977  SawLastInitializer = false;
4978  }
4979 
4980  // Add completions for members.
4981  for (auto *Field : ClassDecl->fields()) {
4982  if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))
4983  .second) {
4984  SawLastInitializer
4985  = !Initializers.empty() &&
4986  Initializers.back()->isAnyMemberInitializer() &&
4987  Initializers.back()->getAnyMember() == Field;
4988  continue;
4989  }
4990 
4991  if (!Field->getDeclName())
4992  continue;
4993 
4994  Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
4995  Field->getIdentifier()->getName()));
4996  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4997  Builder.AddPlaceholderChunk("args");
4998  Builder.AddChunk(CodeCompletionString::CK_RightParen);
4999  Results.AddResult(CodeCompletionResult(Builder.TakeString(),
5000  SawLastInitializer? CCP_NextInitializer
5004  Field));
5005  SawLastInitializer = false;
5006  }
5007  Results.ExitScope();
5008 
5009  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5010  Results.data(), Results.size());
5011 }
5012 
5013 /// Determine whether this scope denotes a namespace.
5014 static bool isNamespaceScope(Scope *S) {
5015  DeclContext *DC = S->getEntity();
5016  if (!DC)
5017  return false;
5018 
5019  return DC->isFileContext();
5020 }
5021 
5023  bool AfterAmpersand) {
5024  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5025  CodeCompleter->getCodeCompletionTUInfo(),
5027  Results.EnterNewScope();
5028 
5029  // Note what has already been captured.
5030  llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
5031  bool IncludedThis = false;
5032  for (const auto &C : Intro.Captures) {
5033  if (C.Kind == LCK_This) {
5034  IncludedThis = true;
5035  continue;
5036  }
5037 
5038  Known.insert(C.Id);
5039  }
5040 
5041  // Look for other capturable variables.
5042  for (; S && !isNamespaceScope(S); S = S->getParent()) {
5043  for (const auto *D : S->decls()) {
5044  const auto *Var = dyn_cast<VarDecl>(D);
5045  if (!Var ||
5046  !Var->hasLocalStorage() ||
5047  Var->hasAttr<BlocksAttr>())
5048  continue;
5049 
5050  if (Known.insert(Var->getIdentifier()).second)
5051  Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration),
5052  CurContext, nullptr, false);
5053  }
5054  }
5055 
5056  // Add 'this', if it would be valid.
5057  if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy)
5058  addThisCompletion(*this, Results);
5059 
5060  Results.ExitScope();
5061 
5062  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5063  Results.data(), Results.size());
5064 }
5065 
5066 /// Macro that optionally prepends an "@" to the string literal passed in via
5067 /// Keyword, depending on whether NeedAt is true or false.
5068 #define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) ((NeedAt)? "@" Keyword : Keyword)
5069 
5070 static void AddObjCImplementationResults(const LangOptions &LangOpts,
5071  ResultBuilder &Results,
5072  bool NeedAt) {
5073  typedef CodeCompletionResult Result;
5074  // Since we have an implementation, we can end it.
5075  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
5076 
5077  CodeCompletionBuilder Builder(Results.getAllocator(),
5078  Results.getCodeCompletionTUInfo());
5079  if (LangOpts.ObjC2) {
5080  // @dynamic
5081  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"dynamic"));
5082  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5083  Builder.AddPlaceholderChunk("property");
5084  Results.AddResult(Result(Builder.TakeString()));
5085 
5086  // @synthesize
5087  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synthesize"));
5088  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5089  Builder.AddPlaceholderChunk("property");
5090  Results.AddResult(Result(Builder.TakeString()));
5091  }
5092 }
5093 
5094 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
5095  ResultBuilder &Results,
5096  bool NeedAt) {
5097  typedef CodeCompletionResult Result;
5098 
5099  // Since we have an interface or protocol, we can end it.
5100  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
5101 
5102  if (LangOpts.ObjC2) {
5103  // @property
5104  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"property")));
5105 
5106  // @required
5107  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"required")));
5108 
5109  // @optional
5110  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"optional")));
5111  }
5112 }
5113 
5114 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
5115  typedef CodeCompletionResult Result;
5116  CodeCompletionBuilder Builder(Results.getAllocator(),
5117  Results.getCodeCompletionTUInfo());
5118 
5119  // @class name ;
5120  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"class"));
5121  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5122  Builder.AddPlaceholderChunk("name");
5123  Results.AddResult(Result(Builder.TakeString()));
5124 
5125  if (Results.includeCodePatterns()) {
5126  // @interface name
5127  // FIXME: Could introduce the whole pattern, including superclasses and
5128  // such.
5129  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"interface"));
5130  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5131  Builder.AddPlaceholderChunk("class");
5132  Results.AddResult(Result(Builder.TakeString()));
5133 
5134  // @protocol name
5135  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
5136  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5137  Builder.AddPlaceholderChunk("protocol");
5138  Results.AddResult(Result(Builder.TakeString()));
5139 
5140  // @implementation name
5141  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"implementation"));
5142  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5143  Builder.AddPlaceholderChunk("class");
5144  Results.AddResult(Result(Builder.TakeString()));
5145  }
5146 
5147  // @compatibility_alias name
5148  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"compatibility_alias"));
5149  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5150  Builder.AddPlaceholderChunk("alias");
5151  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5152  Builder.AddPlaceholderChunk("class");
5153  Results.AddResult(Result(Builder.TakeString()));
5154 
5155  if (Results.getSema().getLangOpts().Modules) {
5156  // @import name
5157  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import"));
5158  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5159  Builder.AddPlaceholderChunk("module");
5160  Results.AddResult(Result(Builder.TakeString()));
5161  }
5162 }
5163 
5165  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5166  CodeCompleter->getCodeCompletionTUInfo(),
5168  Results.EnterNewScope();
5169  if (isa<ObjCImplDecl>(CurContext))
5170  AddObjCImplementationResults(getLangOpts(), Results, false);
5171  else if (CurContext->isObjCContainer())
5172  AddObjCInterfaceResults(getLangOpts(), Results, false);
5173  else
5174  AddObjCTopLevelResults(Results, false);
5175  Results.ExitScope();
5176  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5177  Results.data(), Results.size());
5178 }
5179 
5180 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
5181  typedef CodeCompletionResult Result;
5182  CodeCompletionBuilder Builder(Results.getAllocator(),
5183  Results.getCodeCompletionTUInfo());
5184 
5185  // @encode ( type-name )
5186  const char *EncodeType = "char[]";
5187  if (Results.getSema().getLangOpts().CPlusPlus ||
5188  Results.getSema().getLangOpts().ConstStrings)
5189  EncodeType = "const char[]";
5190  Builder.AddResultTypeChunk(EncodeType);
5191  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"encode"));
5192  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5193  Builder.AddPlaceholderChunk("type-name");
5194  Builder.AddChunk(CodeCompletionString::CK_RightParen);
5195  Results.AddResult(Result(Builder.TakeString()));
5196 
5197  // @protocol ( protocol-name )
5198  Builder.AddResultTypeChunk("Protocol *");
5199  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
5200  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5201  Builder.AddPlaceholderChunk("protocol-name");
5202  Builder.AddChunk(CodeCompletionString::CK_RightParen);
5203  Results.AddResult(Result(Builder.TakeString()));
5204 
5205  // @selector ( selector )
5206  Builder.AddResultTypeChunk("SEL");
5207  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"selector"));
5208  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5209  Builder.AddPlaceholderChunk("selector");
5210  Builder.AddChunk(CodeCompletionString::CK_RightParen);
5211  Results.AddResult(Result(Builder.TakeString()));
5212 
5213  // @"string"
5214  Builder.AddResultTypeChunk("NSString *");
5215  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"\""));
5216  Builder.AddPlaceholderChunk("string");
5217  Builder.AddTextChunk("\"");
5218  Results.AddResult(Result(Builder.TakeString()));
5219 
5220  // @[objects, ...]
5221  Builder.AddResultTypeChunk("NSArray *");
5222  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"["));
5223  Builder.AddPlaceholderChunk("objects, ...");
5224  Builder.AddChunk(CodeCompletionString::CK_RightBracket);
5225  Results.AddResult(Result(Builder.TakeString()));
5226 
5227  // @{key : object, ...}
5228  Builder.AddResultTypeChunk("NSDictionary *");
5229  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"{"));
5230  Builder.AddPlaceholderChunk("key");
5231  Builder.AddChunk(CodeCompletionString::CK_Colon);
5232  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5233  Builder.AddPlaceholderChunk("object, ...");
5234  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5235  Results.AddResult(Result(Builder.TakeString()));
5236 
5237  // @(expression)
5238  Builder.AddResultTypeChunk("id");
5239  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "("));
5240  Builder.AddPlaceholderChunk("expression");
5241  Builder.AddChunk(CodeCompletionString::CK_RightParen);
5242  Results.AddResult(Result(Builder.TakeString()));
5243 }
5244 
5245 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
5246  typedef CodeCompletionResult Result;
5247  CodeCompletionBuilder Builder(Results.getAllocator(),
5248  Results.getCodeCompletionTUInfo());
5249 
5250  if (Results.includeCodePatterns()) {
5251  // @try { statements } @catch ( declaration ) { statements } @finally
5252  // { statements }
5253  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"try"));
5254  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5255  Builder.AddPlaceholderChunk("statements");
5256  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5257  Builder.AddTextChunk("@catch");
5258  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5259  Builder.AddPlaceholderChunk("parameter");
5260  Builder.AddChunk(CodeCompletionString::CK_RightParen);
5261  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5262  Builder.AddPlaceholderChunk("statements");
5263  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5264  Builder.AddTextChunk("@finally");
5265  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5266  Builder.AddPlaceholderChunk("statements");
5267  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5268  Results.AddResult(Result(Builder.TakeString()));
5269  }
5270 
5271  // @throw
5272  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"throw"));
5273  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5274  Builder.AddPlaceholderChunk("expression");
5275  Results.AddResult(Result(Builder.TakeString()));
5276 
5277  if (Results.includeCodePatterns()) {
5278  // @synchronized ( expression ) { statements }
5279  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synchronized"));
5280  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5281  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5282  Builder.AddPlaceholderChunk("expression");
5283  Builder.AddChunk(CodeCompletionString::CK_RightParen);
5284  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5285  Builder.AddPlaceholderChunk("statements");
5286  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5287  Results.AddResult(Result(Builder.TakeString()));
5288  }
5289 }
5290 
5291 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
5292  ResultBuilder &Results,
5293  bool NeedAt) {
5294  typedef CodeCompletionResult Result;
5295  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"private")));
5296  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"protected")));
5297  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"public")));
5298  if (LangOpts.ObjC2)
5299  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"package")));
5300 }
5301 
5303  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5304  CodeCompleter->getCodeCompletionTUInfo(),
5306  Results.EnterNewScope();
5307  AddObjCVisibilityResults(getLangOpts(), Results, false);
5308  Results.ExitScope();
5309  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5310  Results.data(), Results.size());
5311 }
5312 
5314  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5315  CodeCompleter->getCodeCompletionTUInfo(),
5317  Results.EnterNewScope();
5318  AddObjCStatementResults(Results, false);
5319  AddObjCExpressionResults(Results, false);
5320  Results.ExitScope();
5321  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5322  Results.data(), Results.size());
5323 }
5324 
5326  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5327  CodeCompleter->getCodeCompletionTUInfo(),
5329  Results.EnterNewScope();
5330  AddObjCExpressionResults(Results, false);
5331  Results.ExitScope();
5332  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5333  Results.data(), Results.size());
5334 }
5335 
5336 /// Determine whether the addition of the given flag to an Objective-C
5337 /// property's attributes will cause a conflict.
5338 static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
5339  // Check if we've already added this flag.
5340  if (Attributes & NewFlag)
5341  return true;
5342 
5343  Attributes |= NewFlag;
5344 
5345  // Check for collisions with "readonly".
5346  if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
5347  (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
5348  return true;
5349 
5350  // Check for more than one of { assign, copy, retain, strong, weak }.
5351  unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign |
5357  if (AssignCopyRetMask &&
5358  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
5359  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
5360  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
5361  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
5362  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong &&
5363  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_weak)
5364  return true;
5365 
5366  return false;
5367 }
5368 
5370  if (!CodeCompleter)
5371  return;
5372 
5373  unsigned Attributes = ODS.getPropertyAttributes();
5374 
5375  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5376  CodeCompleter->getCodeCompletionTUInfo(),
5378  Results.EnterNewScope();
5380  Results.AddResult(CodeCompletionResult("readonly"));
5382  Results.AddResult(CodeCompletionResult("assign"));
5383  if (!ObjCPropertyFlagConflicts(Attributes,
5385  Results.AddResult(CodeCompletionResult("unsafe_unretained"));
5387  Results.AddResult(CodeCompletionResult("readwrite"));
5389  Results.AddResult(CodeCompletionResult("retain"));
5391  Results.AddResult(CodeCompletionResult("strong"));
5393  Results.AddResult(CodeCompletionResult("copy"));
5395  Results.AddResult(CodeCompletionResult("nonatomic"));
5397  Results.AddResult(CodeCompletionResult("atomic"));
5398 
5399  // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC.
5400  if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC)
5402  Results.AddResult(CodeCompletionResult("weak"));
5403 
5405  CodeCompletionBuilder Setter(Results.getAllocator(),
5406  Results.getCodeCompletionTUInfo());
5407  Setter.AddTypedTextChunk("setter");
5408  Setter.AddTextChunk("=");
5409  Setter.AddPlaceholderChunk("method");
5410  Results.AddResult(CodeCompletionResult(Setter.TakeString()));
5411  }
5413  CodeCompletionBuilder Getter(Results.getAllocator(),
5414  Results.getCodeCompletionTUInfo());
5415  Getter.AddTypedTextChunk("getter");
5416  Getter.AddTextChunk("=");
5417  Getter.AddPlaceholderChunk("method");
5418  Results.AddResult(CodeCompletionResult(Getter.TakeString()));
5419  }
5421  Results.AddResult(CodeCompletionResult("nonnull"));
5422  Results.AddResult(CodeCompletionResult("nullable"));
5423  Results.AddResult(CodeCompletionResult("null_unspecified"));
5424  Results.AddResult(CodeCompletionResult("null_resettable"));
5425  }
5426  Results.ExitScope();
5427  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5428  Results.data(), Results.size());
5429 }
5430 
5431 /// Describes the kind of Objective-C method that we want to find
5432 /// via code completion.
5434  MK_Any, ///< Any kind of method, provided it means other specified criteria.
5435  MK_ZeroArgSelector, ///< Zero-argument (unary) selector.
5436  MK_OneArgSelector ///< One-argument selector.
5437 };
5438 
5440  ObjCMethodKind WantKind,
5441  ArrayRef<IdentifierInfo *> SelIdents,
5442  bool AllowSameLength = true) {
5443  unsigned NumSelIdents = SelIdents.size();
5444  if (NumSelIdents > Sel.getNumArgs())
5445  return false;
5446 
5447  switch (WantKind) {
5448  case MK_Any: break;
5449  case MK_ZeroArgSelector: return Sel.isUnarySelector();
5450  case MK_OneArgSelector: return Sel.getNumArgs() == 1;
5451  }
5452 
5453  if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
5454  return false;
5455 
5456  for (unsigned I = 0; I != NumSelIdents; ++I)
5457  if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
5458  return false;
5459 
5460  return true;
5461 }
5462 
5464  ObjCMethodKind WantKind,
5465  ArrayRef<IdentifierInfo *> SelIdents,
5466  bool AllowSameLength = true) {
5467  return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
5468  AllowSameLength);
5469 }
5470 
5471 namespace {
5472  /// A set of selectors, which is used to avoid introducing multiple
5473  /// completions with the same selector into the result set.
5474  typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
5475 }
5476 
5477 /// Add all of the Objective-C methods in the given Objective-C
5478 /// container to the set of results.
5479 ///
5480 /// The container will be a class, protocol, category, or implementation of
5481 /// any of the above. This mether will recurse to include methods from
5482 /// the superclasses of classes along with their categories, protocols, and
5483 /// implementations.
5484 ///
5485 /// \param Container the container in which we'll look to find methods.
5486 ///
5487 /// \param WantInstanceMethods Whether to add instance methods (only); if
5488 /// false, this routine will add factory methods (only).
5489 ///
5490 /// \param CurContext the context in which we're performing the lookup that
5491 /// finds methods.
5492 ///
5493 /// \param AllowSameLength Whether we allow a method to be added to the list
5494 /// when it has the same number of parameters as we have selector identifiers.
5495 ///
5496 /// \param Results the structure into which we'll add results.
5497 static void AddObjCMethods(ObjCContainerDecl *Container,
5498  bool WantInstanceMethods, ObjCMethodKind WantKind,
5499  ArrayRef<IdentifierInfo *> SelIdents,
5500  DeclContext *CurContext,
5501  VisitedSelectorSet &Selectors, bool AllowSameLength,
5502  ResultBuilder &Results, bool InOriginalClass = true,
5503  bool IsRootClass = false) {
5504  typedef CodeCompletionResult Result;
5505  Container = getContainerDef(Container);
5506  ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
5507  IsRootClass = IsRootClass || (IFace && !IFace->getSuperClass());
5508  for (auto *M : Container->methods()) {
5509  // The instance methods on the root class can be messaged via the
5510  // metaclass.
5511  if (M->isInstanceMethod() == WantInstanceMethods ||
5512  (IsRootClass && !WantInstanceMethods)) {
5513  // Check whether the selector identifiers we've been given are a
5514  // subset of the identifiers for this particular method.
5515  if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength))
5516  continue;
5517 
5518  if (!Selectors.insert(M->getSelector()).second)
5519  continue;
5520 
5521  Result R = Result(M, Results.getBasePriority(M), nullptr);
5522  R.StartParameter = SelIdents.size();
5523  R.AllParametersAreInformative = (WantKind != MK_Any);
5524  if (!InOriginalClass)
5525  R.Priority += CCD_InBaseClass;
5526  Results.MaybeAddResult(R, CurContext);
5527  }
5528  }
5529 
5530  // Visit the protocols of protocols.
5531  if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
5532  if (Protocol->hasDefinition()) {
5533  const ObjCList<ObjCProtocolDecl> &Protocols
5534  = Protocol->getReferencedProtocols();
5535  for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5536  E = Protocols.end();
5537  I != E; ++I)
5538  AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5539  Selectors, AllowSameLength, Results, false, IsRootClass);
5540  }
5541  }
5542 
5543  if (!IFace || !IFace->hasDefinition())
5544  return;
5545 
5546  // Add methods in protocols.
5547  for (auto *I : IFace->protocols())
5548  AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5549  Selectors, AllowSameLength, Results, false, IsRootClass);
5550 
5551  // Add methods in categories.
5552  for (auto *CatDecl : IFace->known_categories()) {
5553  AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
5554  CurContext, Selectors, AllowSameLength, Results,
5555  InOriginalClass, IsRootClass);
5556 
5557  // Add a categories protocol methods.
5558  const ObjCList<ObjCProtocolDecl> &Protocols
5559  = CatDecl->getReferencedProtocols();
5560  for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5561  E = Protocols.end();
5562  I != E; ++I)
5563  AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5564  Selectors, AllowSameLength, Results, false, IsRootClass);
5565 
5566  // Add methods in category implementations.
5567  if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
5568  AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
5569  Selectors, AllowSameLength, Results, InOriginalClass,
5570  IsRootClass);
5571  }
5572 
5573  // Add methods in superclass.
5574  // Avoid passing in IsRootClass since root classes won't have super classes.
5575  if (IFace->getSuperClass())
5576  AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
5577  SelIdents, CurContext, Selectors, AllowSameLength, Results,
5578  /*IsRootClass=*/false);
5579 
5580  // Add methods in our implementation, if any.
5581  if (ObjCImplementationDecl *Impl = IFace->getImplementation())
5582  AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext,
5583  Selectors, AllowSameLength, Results, InOriginalClass,
5584  IsRootClass);
5585 }
5586 
5587 
5589  // Try to find the interface where getters might live.
5590  ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5591  if (!Class) {
5593  = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5594  Class = Category->getClassInterface();
5595 
5596  if (!Class)
5597  return;
5598  }
5599 
5600  // Find all of the potential getters.
5601  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5602  CodeCompleter->getCodeCompletionTUInfo(),
5604  Results.EnterNewScope();
5605 
5606  VisitedSelectorSet Selectors;
5607  AddObjCMethods(Class, true, MK_ZeroArgSelector, None, CurContext, Selectors,
5608  /*AllowSameLength=*/true, Results);
5609  Results.ExitScope();
5610  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5611  Results.data(), Results.size());
5612 }
5613 
5615  // Try to find the interface where setters might live.
5616  ObjCInterfaceDecl *Class
5617  = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5618  if (!Class) {
5620  = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5621  Class = Category->getClassInterface();
5622 
5623  if (!Class)
5624  return;
5625  }
5626 
5627  // Find all of the potential getters.
5628  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5629  CodeCompleter->getCodeCompletionTUInfo(),
5631  Results.EnterNewScope();
5632 
5633  VisitedSelectorSet Selectors;
5634  AddObjCMethods(Class, true, MK_OneArgSelector, None, CurContext,
5635  Selectors, /*AllowSameLength=*/true, Results);
5636 
5637  Results.ExitScope();
5638  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5639  Results.data(), Results.size());
5640 }
5641 
5643  bool IsParameter) {
5644  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5645  CodeCompleter->getCodeCompletionTUInfo(),
5647  Results.EnterNewScope();
5648 
5649  // Add context-sensitive, Objective-C parameter-passing keywords.
5650  bool AddedInOut = false;
5651  if ((DS.getObjCDeclQualifier() &
5653  Results.AddResult("in");
5654  Results.AddResult("inout");
5655  AddedInOut = true;
5656  }
5657  if ((DS.getObjCDeclQualifier() &
5659  Results.AddResult("out");
5660  if (!AddedInOut)
5661  Results.AddResult("inout");
5662  }
5663  if ((DS.getObjCDeclQualifier() &
5665  ObjCDeclSpec::DQ_Oneway)) == 0) {
5666  Results.AddResult("bycopy");
5667  Results.AddResult("byref");
5668  Results.AddResult("oneway");
5669  }
5671  Results.AddResult("nonnull");
5672  Results.AddResult("nullable");
5673  Results.AddResult("null_unspecified");
5674  }
5675 
5676  // If we're completing the return type of an Objective-C method and the
5677  // identifier IBAction refers to a macro, provide a completion item for
5678  // an action, e.g.,
5679  // IBAction)<#selector#>:(id)sender
5680  if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
5681  PP.isMacroDefined("IBAction")) {
5682  CodeCompletionBuilder Builder(Results.getAllocator(),
5683  Results.getCodeCompletionTUInfo(),
5685  Builder.AddTypedTextChunk("IBAction");
5686  Builder.AddChunk(CodeCompletionString::CK_RightParen);
5687  Builder.AddPlaceholderChunk("selector");
5688  Builder.AddChunk(CodeCompletionString::CK_Colon);
5689  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5690  Builder.AddTextChunk("id");
5691  Builder.AddChunk(CodeCompletionString::CK_RightParen);
5692  Builder.AddTextChunk("sender");
5693  Results.AddResult(CodeCompletionResult(Builder.TakeString()));
5694  }
5695 
5696  // If we're completing the return type, provide 'instancetype'.
5697  if (!IsParameter) {
5698  Results.AddResult(CodeCompletionResult("instancetype"));
5699  }
5700 
5701  // Add various builtin type names and specifiers.
5702  AddOrdinaryNameResults(PCC_Type, S, *this, Results);
5703  Results.ExitScope();
5704 
5705  // Add the various type names
5706  Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
5707  CodeCompletionDeclConsumer Consumer(Results, CurContext);
5708  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5709  CodeCompleter->includeGlobals(),
5710  CodeCompleter->loadExternal());
5711 
5712  if (CodeCompleter->includeMacros())
5713  AddMacroResults(PP, Results, false);
5714 
5715  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5716  Results.data(), Results.size());
5717 }
5718 
5719 /// When we have an expression with type "id", we may assume
5720 /// that it has some more-specific class type based on knowledge of
5721 /// common uses of Objective-C. This routine returns that class type,
5722 /// or NULL if no better result could be determined.
5724  ObjCMessageExpr *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
5725  if (!Msg)
5726  return nullptr;
5727 
5728  Selector Sel = Msg->getSelector();
5729  if (Sel.isNull())
5730  return nullptr;
5731 
5733  if (!Id)
5734  return nullptr;
5735 
5736  ObjCMethodDecl *Method = Msg->getMethodDecl();
5737  if (!Method)
5738  return nullptr;
5739 
5740  // Determine the class that we're sending the message to.
5741  ObjCInterfaceDecl *IFace = nullptr;
5742  switch (Msg->getReceiverKind()) {
5744  if (const ObjCObjectType *ObjType
5745  = Msg->getClassReceiver()->getAs<ObjCObjectType>())
5746  IFace = ObjType->getInterface();
5747  break;
5748 
5750  QualType T = Msg->getInstanceReceiver()->getType();
5751  if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
5752  IFace = Ptr->getInterfaceDecl();
5753  break;
5754  }
5755 
5758  break;
5759  }
5760 
5761  if (!IFace)
5762  return nullptr;
5763 
5764  ObjCInterfaceDecl *Super = IFace->getSuperClass();
5765  if (Method->isInstanceMethod())
5766  return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5767  .Case("retain", IFace)
5768  .Case("strong", IFace)
5769  .Case("autorelease", IFace)
5770  .Case("copy", IFace)
5771  .Case("copyWithZone", IFace)
5772  .Case("mutableCopy", IFace)
5773  .Case("mutableCopyWithZone", IFace)
5774  .Case("awakeFromCoder", IFace)
5775  .Case("replacementObjectFromCoder", IFace)
5776  .Case("class", IFace)
5777  .Case("classForCoder", IFace)
5778  .Case("superclass", Super)
5779  .Default(nullptr);
5780 
5781  return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5782  .Case("new", IFace)
5783  .Case("alloc", IFace)
5784  .Case("allocWithZone", IFace)
5785  .Case("class", IFace)
5786  .Case("superclass", Super)
5787  .Default(nullptr);
5788 }
5789 
5790 // Add a special completion for a message send to "super", which fills in the
5791 // most likely case of forwarding all of our arguments to the superclass
5792 // function.
5793 ///
5794 /// \param S The semantic analysis object.
5795 ///
5796 /// \param NeedSuperKeyword Whether we need to prefix this completion with
5797 /// the "super" keyword. Otherwise, we just need to provide the arguments.
5798 ///
5799 /// \param SelIdents The identifiers in the selector that have already been
5800 /// provided as arguments for a send to "super".
5801 ///
5802 /// \param Results The set of results to augment.
5803 ///
5804 /// \returns the Objective-C method declaration that would be invoked by
5805 /// this "super" completion. If NULL, no completion was added.
5807  Sema &S, bool NeedSuperKeyword,
5808  ArrayRef<IdentifierInfo *> SelIdents,
5809  ResultBuilder &Results) {
5810  ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
5811  if (!CurMethod)
5812  return nullptr;
5813 
5814  ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
5815  if (!Class)
5816  return nullptr;
5817 
5818  // Try to find a superclass method with the same selector.
5819  ObjCMethodDecl *SuperMethod = nullptr;
5820  while ((Class = Class->getSuperClass()) && !SuperMethod) {
5821  // Check in the class
5822  SuperMethod = Class->getMethod(CurMethod->getSelector(),
5823  CurMethod->isInstanceMethod());
5824 
5825  // Check in categories or class extensions.
5826  if (!SuperMethod) {
5827  for (const auto *Cat : Class->known_categories()) {
5828  if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(),
5829  CurMethod->isInstanceMethod())))
5830  break;
5831  }
5832  }
5833  }
5834 
5835  if (!SuperMethod)
5836  return nullptr;
5837 
5838  // Check whether the superclass method has the same signature.
5839  if (CurMethod->param_size() != SuperMethod->param_size() ||
5840  CurMethod->isVariadic() != SuperMethod->isVariadic())
5841  return nullptr;
5842 
5843  for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
5844  CurPEnd = CurMethod->param_end(),
5845  SuperP = SuperMethod->param_begin();
5846  CurP != CurPEnd; ++CurP, ++SuperP) {
5847  // Make sure the parameter types are compatible.
5848  if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
5849  (*SuperP)->getType()))
5850  return nullptr;
5851 
5852  // Make sure we have a parameter name to forward!
5853  if (!(*CurP)->getIdentifier())
5854  return nullptr;
5855  }
5856 
5857  // We have a superclass method. Now, form the send-to-super completion.
5858  CodeCompletionBuilder Builder(Results.getAllocator(),
5859  Results.getCodeCompletionTUInfo());
5860 
5861  // Give this completion a return type.
5863  Results.getCompletionContext().getBaseType(),
5864  Builder);
5865 
5866  // If we need the "super" keyword, add it (plus some spacing).
5867  if (NeedSuperKeyword) {
5868  Builder.AddTypedTextChunk("super");
5869  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5870  }
5871 
5872  Selector Sel = CurMethod->getSelector();
5873  if (Sel.isUnarySelector()) {
5874  if (NeedSuperKeyword)
5875  Builder.AddTextChunk(Builder.getAllocator().CopyString(
5876  Sel.getNameForSlot(0)));
5877  else
5878  Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
5879  Sel.getNameForSlot(0)));
5880  } else {
5881  ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
5882  for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
5883  if (I > SelIdents.size())
5884  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5885 
5886  if (I < SelIdents.size())
5887  Builder.AddInformativeChunk(
5888  Builder.getAllocator().CopyString(
5889  Sel.getNameForSlot(I) + ":"));
5890  else if (NeedSuperKeyword || I > SelIdents.size()) {
5891  Builder.AddTextChunk(
5892  Builder.getAllocator().CopyString(
5893  Sel.getNameForSlot(I) + ":"));
5894  Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5895  (*CurP)->getIdentifier()->getName()));
5896  } else {
5897  Builder.AddTypedTextChunk(
5898  Builder.getAllocator().CopyString(
5899  Sel.getNameForSlot(I) + ":"));
5900  Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5901  (*CurP)->getIdentifier()->getName()));
5902  }
5903  }
5904  }
5905 
5906  Results.AddResult(CodeCompletionResult(Builder.TakeString(), SuperMethod,
5908  return SuperMethod;
5909 }
5910 
5912  typedef CodeCompletionResult Result;
5913  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5914  CodeCompleter->getCodeCompletionTUInfo(),
5916  getLangOpts().CPlusPlus11
5917  ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture
5918  : &ResultBuilder::IsObjCMessageReceiver);
5919 
5920  CodeCompletionDeclConsumer Consumer(Results, CurContext);
5921  Results.EnterNewScope();
5922  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5923  CodeCompleter->includeGlobals(),
5924  CodeCompleter->loadExternal());
5925 
5926  // If we are in an Objective-C method inside a class that has a superclass,
5927  // add "super" as an option.
5928  if (ObjCMethodDecl *Method = getCurMethodDecl())
5929  if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
5930  if (Iface->getSuperClass()) {
5931  Results.AddResult(Result("super"));
5932 
5933  AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, None, Results);
5934  }
5935 
5936  if (getLangOpts().CPlusPlus11)
5937  addThisCompletion(*this, Results);
5938 
5939  Results.ExitScope();
5940 
5941  if (CodeCompleter->includeMacros())
5942  AddMacroResults(PP, Results, false);
5943  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5944  Results.data(), Results.size());
5945 
5946 }
5947 
5949  ArrayRef<IdentifierInfo *> SelIdents,
5950  bool AtArgumentExpression) {
5951  ObjCInterfaceDecl *CDecl = nullptr;
5952  if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5953  // Figure out which interface we're in.
5954  CDecl = CurMethod->getClassInterface();
5955  if (!CDecl)
5956  return;
5957 
5958  // Find the superclass of this class.
5959  CDecl = CDecl->getSuperClass();
5960  if (!CDecl)
5961  return;
5962 
5963  if (CurMethod->isInstanceMethod()) {
5964  // We are inside an instance method, which means that the message
5965  // send [super ...] is actually calling an instance method on the
5966  // current object.
5967  return CodeCompleteObjCInstanceMessage(S, nullptr, SelIdents,
5968  AtArgumentExpression,
5969  CDecl);
5970  }
5971 
5972  // Fall through to send to the superclass in CDecl.
5973  } else {
5974  // "super" may be the name of a type or variable. Figure out which
5975  // it is.
5976  IdentifierInfo *Super = getSuperIdentifier();
5977  NamedDecl *ND = LookupSingleName(S, Super, SuperLoc,
5978  LookupOrdinaryName);
5979  if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
5980  // "super" names an interface. Use it.
5981  } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
5982  if (const ObjCObjectType *Iface
5983  = Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
5984  CDecl = Iface->getInterface();
5985  } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
5986  // "super" names an unresolved type; we can't be more specific.
5987  } else {
5988  // Assume that "super" names some kind of value and parse that way.
5989  CXXScopeSpec SS;
5990  SourceLocation TemplateKWLoc;
5991  UnqualifiedId id;
5992  id.setIdentifier(Super, SuperLoc);
5993  ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id,
5994  false, false);
5995  return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
5996  SelIdents,
5997  AtArgumentExpression);
5998  }
5999 
6000  // Fall through
6001  }
6002 
6003  ParsedType Receiver;
6004  if (CDecl)
6005  Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
6006  return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
6007  AtArgumentExpression,
6008  /*IsSuper=*/true);
6009 }
6010 
6011 /// Given a set of code-completion results for the argument of a message
6012 /// send, determine the preferred type (if any) for that argument expression.
6013 static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
6014  unsigned NumSelIdents) {
6015  typedef CodeCompletionResult Result;
6016  ASTContext &Context = Results.getSema().Context;
6017 
6018  QualType PreferredType;
6019  unsigned BestPriority = CCP_Unlikely * 2;
6020  Result *ResultsData = Results.data();
6021  for (unsigned I = 0, N = Results.size(); I != N; ++I) {
6022  Result &R = ResultsData[I];
6023  if (R.Kind == Result::RK_Declaration &&
6024  isa<ObjCMethodDecl>(R.Declaration)) {
6025  if (R.Priority <= BestPriority) {
6026  const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
6027  if (NumSelIdents <= Method->param_size()) {
6028  QualType MyPreferredType = Method->parameters()[NumSelIdents - 1]
6029  ->getType();
6030  if (R.Priority < BestPriority || PreferredType.isNull()) {
6031  BestPriority = R.Priority;
6032  PreferredType = MyPreferredType;
6033  } else if (!Context.hasSameUnqualifiedType(PreferredType,
6034  MyPreferredType)) {
6035  PreferredType = QualType();
6036  }
6037  }
6038  }
6039  }
6040  }
6041 
6042  return PreferredType;
6043 }
6044 
6045 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
6046  ParsedType Receiver,
6047  ArrayRef<IdentifierInfo *> SelIdents,
6048  bool AtArgumentExpression,
6049  bool IsSuper,
6050  ResultBuilder &Results) {
6051  typedef CodeCompletionResult Result;
6052  ObjCInterfaceDecl *CDecl = nullptr;
6053 
6054  // If the given name refers to an interface type, retrieve the
6055  // corresponding declaration.
6056  if (Receiver) {
6057  QualType T = SemaRef.GetTypeFromParser(Receiver, nullptr);
6058  if (!T.isNull())
6059  if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
6060  CDecl = Interface->getInterface();
6061  }
6062 
6063  // Add all of the factory methods in this Objective-C class, its protocols,
6064  // superclasses, categories, implementation, etc.
6065  Results.EnterNewScope();
6066 
6067  // If this is a send-to-super, try to add the special "super" send
6068  // completion.
6069  if (IsSuper) {
6070  if (ObjCMethodDecl *SuperMethod
6071  = AddSuperSendCompletion(SemaRef, false, SelIdents, Results))
6072  Results.Ignore(SuperMethod);
6073  }
6074 
6075  // If we're inside an Objective-C method definition, prefer its selector to
6076  // others.
6077  if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
6078  Results.setPreferredSelector(CurMethod->getSelector());
6079 
6080  VisitedSelectorSet Selectors;
6081  if (CDecl)
6082  AddObjCMethods(CDecl, false, MK_Any, SelIdents,
6083  SemaRef.CurContext, Selectors, AtArgumentExpression,
6084  Results);
6085  else {
6086  // We're messaging "id" as a type; provide all class/factory methods.
6087 
6088  // If we have an external source, load the entire class method
6089  // pool from the AST file.
6090  if (SemaRef.getExternalSource()) {
6091  for (uint32_t I = 0,
6092  N = SemaRef.getExternalSource()->GetNumExternalSelectors();
6093  I != N; ++I) {
6094  Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(I);
6095  if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
6096  continue;
6097 
6098  SemaRef.ReadMethodPool(Sel);
6099  }
6100  }
6101 
6102  for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
6103  MEnd = SemaRef.MethodPool.end();
6104  M != MEnd; ++M) {
6105  for (ObjCMethodList *MethList = &M->second.second;
6106  MethList && MethList->getMethod();
6107  MethList = MethList->getNext()) {
6108  if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
6109  continue;
6110 
6111  Result R(MethList->getMethod(),
6112  Results.getBasePriority(MethList->getMethod()), nullptr);
6113  R.StartParameter = SelIdents.size();
6114  R.AllParametersAreInformative = false;
6115  Results.MaybeAddResult(R, SemaRef.CurContext);
6116  }
6117  }
6118  }
6119 
6120  Results.ExitScope();
6121 }
6122 
6124  ArrayRef<IdentifierInfo *> SelIdents,
6125  bool AtArgumentExpression,
6126  bool IsSuper) {
6127 
6128  QualType T = this->GetTypeFromParser(Receiver);
6129 
6130  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6131  CodeCompleter->getCodeCompletionTUInfo(),
6133  T, SelIdents));
6134 
6135  AddClassMessageCompletions(*this, S, Receiver, SelIdents,
6136  AtArgumentExpression, IsSuper, Results);
6137 
6138  // If we're actually at the argument expression (rather than prior to the
6139  // selector), we're actually performing code completion for an expression.
6140  // Determine whether we have a single, best method. If so, we can
6141  // code-complete the expression using the corresponding parameter type as
6142  // our preferred type, improving completion results.
6143  if (AtArgumentExpression) {
6144  QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
6145  SelIdents.size());
6146  if (PreferredType.isNull())
6147  CodeCompleteOrdinaryName(S, PCC_Expression);
6148  else
6149  CodeCompleteExpression(S, PreferredType);
6150  return;
6151  }
6152 
6153  HandleCodeCompleteResults(this, CodeCompleter,
6154  Results.getCompletionContext(),
6155  Results.data(), Results.size());
6156 }
6157 
6159  ArrayRef<IdentifierInfo *> SelIdents,
6160  bool AtArgumentExpression,
6161  ObjCInterfaceDecl *Super) {
6162  typedef CodeCompletionResult Result;
6163 
6164  Expr *RecExpr = static_cast<Expr *>(Receiver);
6165 
6166  // If necessary, apply function/array conversion to the receiver.
6167  // C99 6.7.5.3p[7,8].
6168  if (RecExpr) {
6169  ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
6170  if (Conv.isInvalid()) // conversion failed. bail.
6171  return;
6172  RecExpr = Conv.get();
6173  }
6174  QualType ReceiverType = RecExpr? RecExpr->getType()
6175  : Super? Context.getObjCObjectPointerType(
6176  Context.getObjCInterfaceType(Super))
6177  : Context.getObjCIdType();
6178 
6179  // If we're messaging an expression with type "id" or "Class", check
6180  // whether we know something special about the receiver that allows
6181  // us to assume a more-specific receiver type.
6182  if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) {
6183  if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
6184  if (ReceiverType->isObjCClassType())
6185  return CodeCompleteObjCClassMessage(S,
6186  ParsedType::make(Context.getObjCInterfaceType(IFace)),
6187  SelIdents,
6188  AtArgumentExpression, Super);
6189 
6190  ReceiverType = Context.getObjCObjectPointerType(
6191  Context.getObjCInterfaceType(IFace));
6192  }
6193  } else if (RecExpr && getLangOpts().CPlusPlus) {
6194  ExprResult Conv = PerformContextuallyConvertToObjCPointer(RecExpr);
6195  if (Conv.isUsable()) {
6196  RecExpr = Conv.get();
6197  ReceiverType = RecExpr->getType();
6198  }
6199  }
6200 
6201  // Build the set of methods we can see.
6202  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6203  CodeCompleter->getCodeCompletionTUInfo(),
6205  ReceiverType, SelIdents));
6206 
6207  Results.EnterNewScope();
6208 
6209  // If this is a send-to-super, try to add the special "super" send
6210  // completion.
6211  if (Super) {
6212  if (ObjCMethodDecl *SuperMethod
6213  = AddSuperSendCompletion(*this, false, SelIdents, Results))
6214  Results.Ignore(SuperMethod);
6215  }
6216 
6217  // If we're inside an Objective-C method definition, prefer its selector to
6218  // others.
6219  if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
6220  Results.setPreferredSelector(CurMethod->getSelector());
6221 
6222  // Keep track of the selectors we've already added.
6223  VisitedSelectorSet Selectors;
6224 
6225  // Handle messages to Class. This really isn't a message to an instance
6226  // method, so we treat it the same way we would treat a message send to a
6227  // class method.
6228  if (ReceiverType->isObjCClassType() ||
6229  ReceiverType->isObjCQualifiedClassType()) {
6230  if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
6231  if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
6232  AddObjCMethods(ClassDecl, false, MK_Any, SelIdents,
6233  CurContext, Selectors, AtArgumentExpression, Results);
6234  }
6235  }
6236  // Handle messages to a qualified ID ("id<foo>").
6237  else if (const ObjCObjectPointerType *QualID
6238  = ReceiverType->getAsObjCQualifiedIdType()) {
6239  // Search protocols for instance methods.
6240  for (auto *I : QualID->quals())
6241  AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
6242  Selectors, AtArgumentExpression, Results);
6243  }
6244  // Handle messages to a pointer to interface type.
6245  else if (const ObjCObjectPointerType *IFacePtr
6246  = ReceiverType->getAsObjCInterfacePointerType()) {
6247  // Search the class, its superclasses, etc., for instance methods.
6248  AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
6249  CurContext, Selectors, AtArgumentExpression,
6250  Results);
6251 
6252  // Search protocols for instance methods.
6253  for (auto *I : IFacePtr->quals())
6254  AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
6255  Selectors, AtArgumentExpression, Results);
6256  }
6257  // Handle messages to "id".
6258  else if (ReceiverType->isObjCIdType()) {
6259  // We're messaging "id", so provide all instance methods we know
6260  // about as code-completion results.
6261 
6262  // If we have an external source, load the entire class method
6263  // pool from the AST file.
6264  if (ExternalSource) {
6265  for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6266  I != N; ++I) {
6267  Selector Sel = ExternalSource->GetExternalSelector(I);
6268  if (Sel.isNull() || MethodPool.count(Sel))
6269  continue;
6270 
6271  ReadMethodPool(Sel);
6272  }
6273  }
6274 
6275  for (GlobalMethodPool::iterator M = MethodPool.begin(),
6276  MEnd = MethodPool.end();
6277  M != MEnd; ++M) {
6278  for (ObjCMethodList *MethList = &M->second.first;
6279  MethList && MethList->getMethod();
6280  MethList = MethList->getNext()) {
6281  if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
6282  continue;
6283 
6284  if (!Selectors.insert(MethList->getMethod()->getSelector()).second)
6285  continue;
6286 
6287  Result R(MethList->getMethod(),
6288  Results.getBasePriority(MethList->getMethod()), nullptr);
6289  R.StartParameter = SelIdents.size();
6290  R.AllParametersAreInformative = false;
6291  Results.MaybeAddResult(R, CurContext);
6292  }
6293  }
6294  }
6295  Results.ExitScope();
6296 
6297 
6298  // If we're actually at the argument expression (rather than prior to the
6299  // selector), we're actually performing code completion for an expression.
6300  // Determine whether we have a single, best method. If so, we can
6301  // code-complete the expression using the corresponding parameter type as
6302  // our preferred type, improving completion results.
6303  if (AtArgumentExpression) {
6304  QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
6305  SelIdents.size());
6306  if (PreferredType.isNull())
6307  CodeCompleteOrdinaryName(S, PCC_Expression);
6308  else
6309  CodeCompleteExpression(S, PreferredType);
6310  return;
6311  }
6312 
6313  HandleCodeCompleteResults(this, CodeCompleter,
6314  Results.getCompletionContext(),
6315  Results.data(),Results.size());
6316 }
6317 
6319  DeclGroupPtrTy IterationVar) {
6321  Data.ObjCCollection = true;
6322 
6323  if (IterationVar.getAsOpaquePtr()) {
6324  DeclGroupRef DG = IterationVar.get();
6325  for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
6326  if (*I)
6327  Data.IgnoreDecls.push_back(*I);
6328  }
6329  }
6330 
6331  CodeCompleteExpression(S, Data);
6332 }
6333 
6335  ArrayRef<IdentifierInfo *> SelIdents) {
6336  // If we have an external source, load the entire class method
6337  // pool from the AST file.
6338  if (ExternalSource) {
6339  for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
6340  I != N; ++I) {
6341  Selector Sel = ExternalSource->GetExternalSelector(I);
6342  if (Sel.isNull() || MethodPool.count(Sel))
6343  continue;
6344 
6345  ReadMethodPool(Sel);
6346  }
6347  }
6348 
6349  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6350  CodeCompleter->getCodeCompletionTUInfo(),
6352  Results.EnterNewScope();
6353  for (GlobalMethodPool::iterator M = MethodPool.begin(),
6354  MEnd = MethodPool.end();
6355  M != MEnd; ++M) {
6356 
6357  Selector Sel = M->first;
6358  if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents))
6359  continue;
6360 
6361  CodeCompletionBuilder Builder(Results.getAllocator(),
6362  Results.getCodeCompletionTUInfo());
6363  if (Sel.isUnarySelector()) {
6364  Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
6365  Sel.getNameForSlot(0)));
6366  Results.AddResult(Builder.TakeString());
6367  continue;
6368  }
6369 
6370  std::string Accumulator;
6371  for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
6372  if (I == SelIdents.size()) {
6373  if (!Accumulator.empty()) {
6374  Builder.AddInformativeChunk(Builder.getAllocator().CopyString(
6375  Accumulator));
6376  Accumulator.clear();
6377  }
6378  }
6379 
6380  Accumulator += Sel.getNameForSlot(I);
6381  Accumulator += ':';
6382  }
6383  Builder.AddTypedTextChunk(Builder.getAllocator().CopyString( Accumulator));
6384  Results.AddResult(Builder.TakeString());
6385  }
6386  Results.ExitScope();
6387 
6388  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6389  Results.data(), Results.size());
6390 }
6391 
6392 /// Add all of the protocol declarations that we find in the given
6393 /// (translation unit) context.
6394 static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
6395  bool OnlyForwardDeclarations,
6396  ResultBuilder &Results) {
6397  typedef CodeCompletionResult Result;
6398 
6399  for (const auto *D : Ctx->decls()) {
6400  // Record any protocols we find.
6401  if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(D))
6402  if (!OnlyForwardDeclarations || !Proto->hasDefinition())
6403  Results.AddResult(Result(Proto, Results.getBasePriority(Proto),nullptr),
6404  CurContext, nullptr, false);
6405  }
6406 }
6407 
6409  ArrayRef<IdentifierLocPair> Protocols) {
6410  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6411  CodeCompleter->getCodeCompletionTUInfo(),
6413 
6414  if (CodeCompleter->includeGlobals()) {
6415  Results.EnterNewScope();
6416 
6417  // Tell the result set to ignore all of the protocols we have
6418  // already seen.
6419  // FIXME: This doesn't work when caching code-completion results.
6420  for (const IdentifierLocPair &Pair : Protocols)
6421  if (ObjCProtocolDecl *Protocol = LookupProtocol(Pair.first,
6422  Pair.second))
6423  Results.Ignore(Protocol);
6424 
6425  // Add all protocols.
6426  AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
6427  Results);
6428 
6429  Results.ExitScope();
6430  }
6431 
6432  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6433  Results.data(), Results.size());
6434 }
6435 
6437  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6438  CodeCompleter->getCodeCompletionTUInfo(),
6440 
6441  if (CodeCompleter->includeGlobals()) {
6442  Results.EnterNewScope();
6443 
6444  // Add all protocols.
6445  AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
6446  Results);
6447 
6448  Results.ExitScope();
6449  }
6450 
6451  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6452  Results.data(), Results.size());
6453 }
6454 
6455 /// Add all of the Objective-C interface declarations that we find in
6456 /// the given (translation unit) context.
6457 static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
6458  bool OnlyForwardDeclarations,
6459  bool OnlyUnimplemented,
6460  ResultBuilder &Results) {
6461  typedef CodeCompletionResult Result;
6462 
6463  for (const auto *D : Ctx->decls()) {
6464  // Record any interfaces we find.
6465  if (const auto *Class = dyn_cast<ObjCInterfaceDecl>(D))
6466  if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
6467  (!OnlyUnimplemented || !Class->getImplementation()))
6468  Results.AddResult(Result(Class, Results.getBasePriority(Class),nullptr),
6469  CurContext, nullptr, false);
6470  }
6471 }
6472 
6474  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6475  CodeCompleter->getCodeCompletionTUInfo(),
6477  Results.EnterNewScope();
6478 
6479  if (CodeCompleter->includeGlobals()) {
6480  // Add all classes.
6481  AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6482  false, Results);
6483  }
6484 
6485  Results.ExitScope();
6486 
6487  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6488  Results.data(), Results.size());
6489 }
6490 
6492  SourceLocation ClassNameLoc) {
6493  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6494  CodeCompleter->getCodeCompletionTUInfo(),
6496  Results.EnterNewScope();
6497 
6498  // Make sure that we ignore the class we're currently defining.
6499  NamedDecl *CurClass
6500  = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6501  if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
6502  Results.Ignore(CurClass);
6503 
6504  if (CodeCompleter->includeGlobals()) {
6505  // Add all classes.
6506  AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6507  false, Results);
6508  }
6509 
6510  Results.ExitScope();
6511 
6512  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6513  Results.data(), Results.size());
6514 }
6515 
6517  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6518  CodeCompleter->getCodeCompletionTUInfo(),
6520  Results.EnterNewScope();
6521 
6522  if (CodeCompleter->includeGlobals()) {
6523  // Add all unimplemented classes.
6524  AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6525  true, Results);
6526  }
6527 
6528  Results.ExitScope();
6529 
6530  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6531  Results.data(), Results.size());
6532 }
6533 
6535  IdentifierInfo *ClassName,
6536  SourceLocation ClassNameLoc) {
6537  typedef CodeCompletionResult Result;
6538 
6539  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6540  CodeCompleter->getCodeCompletionTUInfo(),
6542 
6543  // Ignore any categories we find that have already been implemented by this
6544  // interface.
6545  llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6546  NamedDecl *CurClass
6547  = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6548  if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)){
6549  for (const auto *Cat : Class->visible_categories())
6550  CategoryNames.insert(Cat->getIdentifier());
6551  }
6552 
6553  // Add all of the categories we know about.
6554  Results.EnterNewScope();
6556  for (const auto *D : TU->decls())
6557  if (const auto *Category = dyn_cast<ObjCCategoryDecl>(D))
6558  if (CategoryNames.insert(Category->getIdentifier()).second)
6559  Results.AddResult(Result(Category, Results.getBasePriority(Category),
6560  nullptr),
6561  CurContext, nullptr, false);
6562  Results.ExitScope();
6563 
6564  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6565  Results.data(), Results.size());
6566 }
6567 
6569  IdentifierInfo *ClassName,
6570  SourceLocation ClassNameLoc) {
6571  typedef CodeCompletionResult Result;
6572 
6573  // Find the corresponding interface. If we couldn't find the interface, the
6574  // program itself is ill-formed. However, we'll try to be helpful still by
6575  // providing the list of all of the categories we know about.
6576  NamedDecl *CurClass
6577  = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6578  ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
6579  if (!Class)
6580  return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
6581 
6582  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6583  CodeCompleter->getCodeCompletionTUInfo(),
6585 
6586  // Add all of the categories that have have corresponding interface
6587  // declarations in this class and any of its superclasses, except for
6588  // already-implemented categories in the class itself.
6589  llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6590  Results.EnterNewScope();
6591  bool IgnoreImplemented = true;
6592  while (Class) {
6593  for (const auto *Cat : Class->visible_categories()) {
6594  if ((!IgnoreImplemented || !Cat->getImplementation()) &&
6595  CategoryNames.insert(Cat->getIdentifier()).second)
6596  Results.AddResult(Result(Cat, Results.getBasePriority(Cat), nullptr),
6597  CurContext, nullptr, false);
6598  }
6599 
6600  Class = Class->getSuperClass();
6601  IgnoreImplemented = false;
6602  }
6603  Results.ExitScope();
6604 
6605  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6606  Results.data(), Results.size());
6607 }
6608 
6611  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6612  CodeCompleter->getCodeCompletionTUInfo(),
6613  CCContext);
6614 
6615  // Figure out where this @synthesize lives.
6616  ObjCContainerDecl *Container
6617  = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6618  if (!Container ||
6619  (!isa<ObjCImplementationDecl>(Container) &&
6620  !isa<ObjCCategoryImplDecl>(Container)))
6621  return;
6622 
6623  // Ignore any properties that have already been implemented.
6624  Container = getContainerDef(Container);
6625  for (const auto *D : Container->decls())
6626  if (const auto *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(D))
6627  Results.Ignore(PropertyImpl->getPropertyDecl());
6628 
6629  // Add any properties that we find.
6630  AddedPropertiesSet AddedProperties;
6631  Results.EnterNewScope();
6632  if (ObjCImplementationDecl *ClassImpl
6633  = dyn_cast<ObjCImplementationDecl>(Container))
6634  AddObjCProperties(CCContext, ClassImpl->getClassInterface(), false,
6635  /*AllowNullaryMethods=*/false, CurContext,
6636  AddedProperties, Results);
6637  else
6638  AddObjCProperties(CCContext,
6639  cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
6640  false, /*AllowNullaryMethods=*/false, CurContext,
6641  AddedProperties, Results);
6642  Results.ExitScope();
6643 
6644  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6645  Results.data(), Results.size());
6646 }
6647 
6649  IdentifierInfo *PropertyName) {
6650  typedef CodeCompletionResult Result;
6651  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6652  CodeCompleter->getCodeCompletionTUInfo(),
6654 
6655  // Figure out where this @synthesize lives.
6656  ObjCContainerDecl *Container
6657  = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6658  if (!Container ||
6659  (!isa<ObjCImplementationDecl>(Container) &&
6660  !isa<ObjCCategoryImplDecl>(Container)))
6661  return;
6662 
6663  // Figure out which interface we're looking into.
6664  ObjCInterfaceDecl *Class = nullptr;
6665  if (ObjCImplementationDecl *ClassImpl
6666  = dyn_cast<ObjCImplementationDecl>(Container))
6667  Class = ClassImpl->getClassInterface();
6668  else
6669  Class = cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl()
6670  ->getClassInterface();
6671 
6672  // Determine the type of the property we're synthesizing.
6673  QualType PropertyType = Context.getObjCIdType();
6674  if (Class) {
6677  PropertyType
6678  = Property->getType().getNonReferenceType().getUnqualifiedType();
6679 
6680  // Give preference to ivars
6681  Results.setPreferredType(PropertyType);
6682  }
6683  }
6684 
6685  // Add all of the instance variables in this class and its superclasses.
6686  Results.EnterNewScope();
6687  bool SawSimilarlyNamedIvar = false;
6688  std::string NameWithPrefix;
6689  NameWithPrefix += '_';
6690  NameWithPrefix += PropertyName->getName();
6691  std::string NameWithSuffix = PropertyName->getName().str();
6692  NameWithSuffix += '_';
6693  for(; Class; Class = Class->getSuperClass()) {
6694  for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
6695  Ivar = Ivar->getNextIvar()) {
6696  Results.AddResult(Result(Ivar, Results.getBasePriority(Ivar), nullptr),
6697  CurContext, nullptr, false);
6698 
6699  // Determine whether we've seen an ivar with a name similar to the
6700  // property.
6701  if ((PropertyName == Ivar->getIdentifier() ||
6702  NameWithPrefix == Ivar->getName() ||
6703  NameWithSuffix == Ivar->getName())) {
6704  SawSimilarlyNamedIvar = true;
6705 
6706  // Reduce the priority of this result by one, to give it a slight
6707  // advantage over other results whose names don't match so closely.
6708  if (Results.size() &&
6709  Results.data()[Results.size() - 1].Kind
6711  Results.data()[Results.size() - 1].Declaration == Ivar)
6712  Results.data()[Results.size() - 1].Priority--;
6713  }
6714  }
6715  }
6716 
6717  if (!SawSimilarlyNamedIvar) {
6718  // Create ivar result _propName, that the user can use to synthesize
6719  // an ivar of the appropriate type.
6720  unsigned Priority = CCP_MemberDeclaration + 1;
6721  typedef CodeCompletionResult Result;
6722  CodeCompletionAllocator &Allocator = Results.getAllocator();
6723  CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(),
6724  Priority,CXAvailability_Available);
6725 
6727  Builder.AddResultTypeChunk(GetCompletionTypeString(PropertyType, Context,
6728  Policy, Allocator));
6729  Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
6730  Results.AddResult(Result(Builder.TakeString(), Priority,
6732  }
6733 
6734  Results.ExitScope();
6735 
6736  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
6737  Results.data(), Results.size());
6738 }
6739 
6740 // Mapping from selectors to the methods that implement that selector, along
6741 // with the "in original class" flag.
6742 typedef llvm::DenseMap<
6743  Selector, llvm::PointerIntPair<ObjCMethodDecl *, 1, bool> > KnownMethodsMap;
6744 
6745 /// Find all of the methods that reside in the given container
6746 /// (and its superclasses, protocols, etc.) that meet the given
6747 /// criteria. Insert those methods into the map of known methods,
6748 /// indexed by selector so they can be easily found.
6750  ObjCContainerDecl *Container,
6751  Optional<bool> WantInstanceMethods,
6752  QualType ReturnType,
6753  KnownMethodsMap &KnownMethods,
6754  bool InOriginalClass = true) {
6755  if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
6756  // Make sure we have a definition; that's what we'll walk.
6757  if (!IFace->hasDefinition())
6758  return;
6759 
6760  IFace = IFace->getDefinition();
6761  Container = IFace;
6762 
6763  const ObjCList<ObjCProtocolDecl> &Protocols
6764  = IFace->getReferencedProtocols();
6765  for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6766  E = Protocols.end();
6767  I != E; ++I)
6768  FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6769  KnownMethods, InOriginalClass);
6770 
6771  // Add methods from any class extensions and categories.
6772  for (auto *Cat : IFace->visible_categories()) {
6773  FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType,
6774  KnownMethods, false);
6775  }
6776 
6777  // Visit the superclass.
6778  if (IFace->getSuperClass())
6779  FindImplementableMethods(Context, IFace->getSuperClass(),
6780  WantInstanceMethods, ReturnType,
6781  KnownMethods, false);
6782  }
6783 
6784  if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
6785  // Recurse into protocols.
6786  const ObjCList<ObjCProtocolDecl> &Protocols
6787  = Category->getReferencedProtocols();
6788  for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6789  E = Protocols.end();
6790  I != E; ++I)
6791  FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6792  KnownMethods, InOriginalClass);
6793 
6794  // If this category is the original class, jump to the interface.
6795  if (InOriginalClass && Category->getClassInterface())
6796  FindImplementableMethods(Context, Category->getClassInterface(),
6797  WantInstanceMethods, ReturnType, KnownMethods,
6798  false);
6799  }
6800 
6801  if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
6802  // Make sure we have a definition; that's what we'll walk.
6803  if (!Protocol->hasDefinition())
6804  return;
6805  Protocol = Protocol->getDefinition();
6806  Container = Protocol;
6807 
6808  // Recurse into protocols.
6809  const ObjCList<ObjCProtocolDecl> &Protocols
6810  = Protocol->getReferencedProtocols();
6811  for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6812  E = Protocols.end();
6813  I != E; ++I)
6814  FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6815  KnownMethods, false);
6816  }
6817 
6818  // Add methods in this container. This operation occurs last because
6819  // we want the methods from this container to override any methods
6820  // we've previously seen with the same selector.
6821  for (auto *M : Container->methods()) {
6822  if (!WantInstanceMethods || M->isInstanceMethod() == *WantInstanceMethods) {
6823  if (!ReturnType.isNull() &&
6824  !Context.hasSameUnqualifiedType(ReturnType, M->getReturnType()))
6825  continue;
6826 
6827  KnownMethods[M->getSelector()] =
6828  KnownMethodsMap::mapped_type(M, InOriginalClass);
6829  }
6830  }
6831 }
6832 
6833 /// Add the parenthesized return or parameter type chunk to a code
6834 /// completion string.
6836  unsigned ObjCDeclQuals,
6837  ASTContext &Context,
6838  const PrintingPolicy &Policy,
6839  CodeCompletionBuilder &Builder) {
6841  std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals, Type);
6842  if (!Quals.empty())
6843  Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals));
6844  Builder.AddTextChunk(GetCompletionTypeString(Type, Context, Policy,
6845  Builder.getAllocator()));
6847 }
6848 
6849 /// Determine whether the given class is or inherits from a class by
6850 /// the given name.
6852  StringRef Name) {
6853  if (!Class)
6854  return false;
6855 
6856  if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
6857  return true;
6858 
6859  return InheritsFromClassNamed(Class->getSuperClass(), Name);
6860 }
6861 
6862 /// Add code completions for Objective-C Key-Value Coding (KVC) and
6863 /// Key-Value Observing (KVO).
6865  bool IsInstanceMethod,
6866  QualType ReturnType,
6867  ASTContext &Context,
6868  VisitedSelectorSet &KnownSelectors,
6869  ResultBuilder &Results) {
6870  IdentifierInfo *PropName = Property->getIdentifier();
6871  if (!PropName || PropName->getLength() == 0)
6872  return;
6873 
6874  PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
6875 
6876  // Builder that will create each code completion.
6877  typedef CodeCompletionResult Result;
6878  CodeCompletionAllocator &Allocator = Results.getAllocator();
6879  CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
6880 
6881  // The selector table.
6882  SelectorTable &Selectors = Context.Selectors;
6883 
6884  // The property name, copied into the code completion allocation region
6885  // on demand.
6886  struct KeyHolder {
6887  CodeCompletionAllocator &Allocator;
6888  StringRef Key;
6889  const char *CopiedKey;
6890 
6891  KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
6892  : Allocator(Allocator), Key(Key), CopiedKey(nullptr) {}
6893 
6894  operator const char *() {
6895  if (CopiedKey)
6896  return CopiedKey;
6897 
6898  return CopiedKey = Allocator.CopyString(Key);
6899  }
6900  } Key(Allocator, PropName->getName());
6901 
6902  // The uppercased name of the property name.
6903  std::string UpperKey = PropName->getName();
6904  if (!UpperKey.empty())
6905  UpperKey[0] = toUppercase(UpperKey[0]);
6906 
6907  bool ReturnTypeMatchesProperty = ReturnType.isNull() ||
6908  Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
6909  Property->getType());
6910  bool ReturnTypeMatchesVoid
6911  = ReturnType.isNull() || ReturnType->isVoidType();
6912 
6913  // Add the normal accessor -(type)key.
6914  if (IsInstanceMethod &&
6915  KnownSelectors.insert(Selectors.getNullarySelector(PropName)).second &&
6916  ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
6917  if (ReturnType.isNull())
6918  AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6919  Context, Policy, Builder);
6920 
6921  Builder.AddTypedTextChunk(Key);
6922  Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6924  }
6925 
6926  // If we have an integral or boolean property (or the user has provided
6927  // an integral or boolean return type), add the accessor -(type)isKey.
6928  if (IsInstanceMethod &&
6929  ((!ReturnType.isNull() &&
6930  (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
6931  (ReturnType.isNull() &&
6932  (Property->getType()->isIntegerType() ||
6933  Property->getType()->isBooleanType())))) {
6934  std::string SelectorName = (Twine("is") + UpperKey).str();
6935  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6936  if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6937  .second) {
6938  if (ReturnType.isNull()) {
6939  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6940  Builder.AddTextChunk("BOOL");
6941  Builder.AddChunk(CodeCompletionString::CK_RightParen);
6942  }
6943 
6944  Builder.AddTypedTextChunk(
6945  Allocator.CopyString(SelectorId->getName()));
6946  Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6948  }
6949  }
6950 
6951  // Add the normal mutator.
6952  if (IsInstanceMethod && ReturnTypeMatchesVoid &&
6953  !Property->getSetterMethodDecl()) {
6954  std::string SelectorName = (Twine("set") + UpperKey).str();
6955  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6956  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6957  if (ReturnType.isNull()) {
6958  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
6959  Builder.AddTextChunk("void");
6960  Builder.AddChunk(CodeCompletionString::CK_RightParen);
6961  }
6962 
6963  Builder.AddTypedTextChunk(
6964  Allocator.CopyString(SelectorId->getName()));
6965  Builder.AddTypedTextChunk(":");
6966  AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6967  Context, Policy, Builder);
6968  Builder.AddTextChunk(Key);
6969  Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6971  }
6972  }
6973 
6974  // Indexed and unordered accessors
6975  unsigned IndexedGetterPriority = CCP_CodePattern;
6976  unsigned IndexedSetterPriority = CCP_CodePattern;
6977  unsigned UnorderedGetterPriority = CCP_CodePattern;
6978  unsigned UnorderedSetterPriority = CCP_CodePattern;
6979  if (const ObjCObjectPointerType *ObjCPointer
6980  = Property->getType()->getAs<ObjCObjectPointerType>()) {
6981  if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
6982  // If this interface type is not provably derived from a known
6983  // collection, penalize the corresponding completions.
6984  if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
6985  IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6986  if (!InheritsFromClassNamed(IFace, "NSArray"))
6987  IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6988  }
6989 
6990  if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
6991  UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6992  if (!InheritsFromClassNamed(IFace, "NSSet"))
6993  UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6994  }
6995  }
6996  } else {
6997  IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6998  IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6999  UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
7000  UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
7001  }
7002 
7003  // Add -(NSUInteger)countOf<key>
7004  if (IsInstanceMethod &&
7005  (ReturnType.isNull() || ReturnType->isIntegerType())) {
7006  std::string SelectorName = (Twine("countOf") + UpperKey).str();
7007  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7008  if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7009  .second) {
7010  if (ReturnType.isNull()) {
7011  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7012  Builder.AddTextChunk("NSUInteger");
7013  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7014  }
7015 
7016  Builder.AddTypedTextChunk(
7017  Allocator.CopyString(SelectorId->getName()));
7018  Results.AddResult(Result(Builder.TakeString(),
7019  std::min(IndexedGetterPriority,
7020  UnorderedGetterPriority),
7022  }
7023  }
7024 
7025  // Indexed getters
7026  // Add -(id)objectInKeyAtIndex:(NSUInteger)index
7027  if (IsInstanceMethod &&
7028  (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
7029  std::string SelectorName
7030  = (Twine("objectIn") + UpperKey + "AtIndex").str();
7031  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7032  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7033  if (ReturnType.isNull()) {
7034  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7035  Builder.AddTextChunk("id");
7036  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7037  }
7038 
7039  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7040  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7041  Builder.AddTextChunk("NSUInteger");
7042  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7043  Builder.AddTextChunk("index");
7044  Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
7046  }
7047  }
7048 
7049  // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
7050  if (IsInstanceMethod &&
7051  (ReturnType.isNull() ||
7052  (ReturnType->isObjCObjectPointerType() &&
7053  ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7054  ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
7055  ->getName() == "NSArray"))) {
7056  std::string SelectorName
7057  = (Twine(Property->getName()) + "AtIndexes").str();
7058  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7059  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7060  if (ReturnType.isNull()) {
7061  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7062  Builder.AddTextChunk("NSArray *");
7063  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7064  }
7065 
7066  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7067  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7068  Builder.AddTextChunk("NSIndexSet *");
7069  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7070  Builder.AddTextChunk("indexes");
7071  Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
7073  }
7074  }
7075 
7076  // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
7077  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7078  std::string SelectorName = (Twine("get") + UpperKey).str();
7079  IdentifierInfo *SelectorIds[2] = {
7080  &Context.Idents.get(SelectorName),
7081  &Context.Idents.get("range")
7082  };
7083 
7084  if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7085  if (ReturnType.isNull()) {
7086  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7087  Builder.AddTextChunk("void");
7088  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7089  }
7090 
7091  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7092  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7093  Builder.AddPlaceholderChunk("object-type");
7094  Builder.AddTextChunk(" **");
7095  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7096  Builder.AddTextChunk("buffer");
7097  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7098  Builder.AddTypedTextChunk("range:");
7099  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7100  Builder.AddTextChunk("NSRange");
7101  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7102  Builder.AddTextChunk("inRange");
7103  Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
7105  }
7106  }
7107 
7108  // Mutable indexed accessors
7109 
7110  // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
7111  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7112  std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
7113  IdentifierInfo *SelectorIds[2] = {
7114  &Context.Idents.get("insertObject"),
7115  &Context.Idents.get(SelectorName)
7116  };
7117 
7118  if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7119  if (ReturnType.isNull()) {
7120  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7121  Builder.AddTextChunk("void");
7122  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7123  }
7124 
7125  Builder.AddTypedTextChunk("insertObject:");
7126  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7127  Builder.AddPlaceholderChunk("object-type");
7128  Builder.AddTextChunk(" *");
7129  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7130  Builder.AddTextChunk("object");
7131  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7132  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7133  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7134  Builder.AddPlaceholderChunk("NSUInteger");
7135  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7136  Builder.AddTextChunk("index");
7137  Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7139  }
7140  }
7141 
7142  // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
7143  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7144  std::string SelectorName = (Twine("insert") + UpperKey).str();
7145  IdentifierInfo *SelectorIds[2] = {
7146  &Context.Idents.get(SelectorName),
7147  &Context.Idents.get("atIndexes")
7148  };
7149 
7150  if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7151  if (ReturnType.isNull()) {
7152  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7153  Builder.AddTextChunk("void");
7154  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7155  }
7156 
7157  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7158  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7159  Builder.AddTextChunk("NSArray *");
7160  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7161  Builder.AddTextChunk("array");
7162  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7163  Builder.AddTypedTextChunk("atIndexes:");
7164  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7165  Builder.AddPlaceholderChunk("NSIndexSet *");
7166  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7167  Builder.AddTextChunk("indexes");
7168  Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7170  }
7171  }
7172 
7173  // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
7174  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7175  std::string SelectorName
7176  = (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
7177  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7178  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7179  if (ReturnType.isNull()) {
7180  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7181  Builder.AddTextChunk("void");
7182  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7183  }
7184 
7185  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7186  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7187  Builder.AddTextChunk("NSUInteger");
7188  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7189  Builder.AddTextChunk("index");
7190  Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7192  }
7193  }
7194 
7195  // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
7196  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7197  std::string SelectorName
7198  = (Twine("remove") + UpperKey + "AtIndexes").str();
7199  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7200  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7201  if (ReturnType.isNull()) {
7202  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7203  Builder.AddTextChunk("void");
7204  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7205  }
7206 
7207  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7208  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7209  Builder.AddTextChunk("NSIndexSet *");
7210  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7211  Builder.AddTextChunk("indexes");
7212  Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7214  }
7215  }
7216 
7217  // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
7218  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7219  std::string SelectorName
7220  = (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
7221  IdentifierInfo *SelectorIds[2] = {
7222  &Context.Idents.get(SelectorName),
7223  &Context.Idents.get("withObject")
7224  };
7225 
7226  if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7227  if (ReturnType.isNull()) {
7228  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7229  Builder.AddTextChunk("void");
7230  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7231  }
7232 
7233  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7234  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7235  Builder.AddPlaceholderChunk("NSUInteger");
7236  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7237  Builder.AddTextChunk("index");
7238  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7239  Builder.AddTypedTextChunk("withObject:");
7240  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7241  Builder.AddTextChunk("id");
7242  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7243  Builder.AddTextChunk("object");
7244  Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7246  }
7247  }
7248 
7249  // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
7250  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7251  std::string SelectorName1
7252  = (Twine("replace") + UpperKey + "AtIndexes").str();
7253  std::string SelectorName2 = (Twine("with") + UpperKey).str();
7254  IdentifierInfo *SelectorIds[2] = {
7255  &Context.Idents.get(SelectorName1),
7256  &Context.Idents.get(SelectorName2)
7257  };
7258 
7259  if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
7260  if (ReturnType.isNull()) {
7261  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7262  Builder.AddTextChunk("void");
7263  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7264  }
7265 
7266  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":"));
7267  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7268  Builder.AddPlaceholderChunk("NSIndexSet *");
7269  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7270  Builder.AddTextChunk("indexes");
7271  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7272  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
7273  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7274  Builder.AddTextChunk("NSArray *");
7275  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7276  Builder.AddTextChunk("array");
7277  Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
7279  }
7280  }
7281 
7282  // Unordered getters
7283  // - (NSEnumerator *)enumeratorOfKey
7284  if (IsInstanceMethod &&
7285  (ReturnType.isNull() ||
7286  (ReturnType->isObjCObjectPointerType() &&
7287  ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7288  ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
7289  ->getName() == "NSEnumerator"))) {
7290  std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
7291  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7292  if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7293  .second) {
7294  if (ReturnType.isNull()) {
7295  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7296  Builder.AddTextChunk("NSEnumerator *");
7297  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7298  }
7299 
7300  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7301  Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
7303  }
7304  }
7305 
7306  // - (type *)memberOfKey:(type *)object
7307  if (IsInstanceMethod &&
7308  (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
7309  std::string SelectorName = (Twine("memberOf") + UpperKey).str();
7310  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7311  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7312  if (ReturnType.isNull()) {
7313  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7314  Builder.AddPlaceholderChunk("object-type");
7315  Builder.AddTextChunk(" *");
7316  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7317  }
7318 
7319  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7320  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7321  if (ReturnType.isNull()) {
7322  Builder.AddPlaceholderChunk("object-type");
7323  Builder.AddTextChunk(" *");
7324  } else {
7325  Builder.AddTextChunk(GetCompletionTypeString(ReturnType, Context,
7326  Policy,
7327  Builder.getAllocator()));
7328  }
7329  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7330  Builder.AddTextChunk("object");
7331  Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
7333  }
7334  }
7335 
7336  // Mutable unordered accessors
7337  // - (void)addKeyObject:(type *)object
7338  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7339  std::string SelectorName
7340  = (Twine("add") + UpperKey + Twine("Object")).str();
7341  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7342  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7343  if (ReturnType.isNull()) {
7344  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7345  Builder.AddTextChunk("void");
7346  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7347  }
7348 
7349  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7350  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7351  Builder.AddPlaceholderChunk("object-type");
7352  Builder.AddTextChunk(" *");
7353  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7354  Builder.AddTextChunk("object");
7355  Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7357  }
7358  }
7359 
7360  // - (void)addKey:(NSSet *)objects
7361  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7362  std::string SelectorName = (Twine("add") + UpperKey).str();
7363  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7364  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7365  if (ReturnType.isNull()) {
7366  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7367  Builder.AddTextChunk("void");
7368  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7369  }
7370 
7371  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7372  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7373  Builder.AddTextChunk("NSSet *");
7374  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7375  Builder.AddTextChunk("objects");
7376  Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7378  }
7379  }
7380 
7381  // - (void)removeKeyObject:(type *)object
7382  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7383  std::string SelectorName
7384  = (Twine("remove") + UpperKey + Twine("Object")).str();
7385  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7386  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7387  if (ReturnType.isNull()) {
7388  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7389  Builder.AddTextChunk("void");
7390  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7391  }
7392 
7393  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7394  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7395  Builder.AddPlaceholderChunk("object-type");
7396  Builder.AddTextChunk(" *");
7397  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7398  Builder.AddTextChunk("object");
7399  Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7401  }
7402  }
7403 
7404  // - (void)removeKey:(NSSet *)objects
7405  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7406  std::string SelectorName = (Twine("remove") + UpperKey).str();
7407  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7408  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7409  if (ReturnType.isNull()) {
7410  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7411  Builder.AddTextChunk("void");
7412  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7413  }
7414 
7415  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7416  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7417  Builder.AddTextChunk("NSSet *");
7418  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7419  Builder.AddTextChunk("objects");
7420  Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7422  }
7423  }
7424 
7425  // - (void)intersectKey:(NSSet *)objects
7426  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
7427  std::string SelectorName = (Twine("intersect") + UpperKey).str();
7428  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7429  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
7430  if (ReturnType.isNull()) {
7431  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7432  Builder.AddTextChunk("void");
7433  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7434  }
7435 
7436  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
7437  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7438  Builder.AddTextChunk("NSSet *");
7439  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7440  Builder.AddTextChunk("objects");
7441  Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
7443  }
7444  }
7445 
7446  // Key-Value Observing
7447  // + (NSSet *)keyPathsForValuesAffectingKey
7448  if (!IsInstanceMethod &&
7449  (ReturnType.isNull() ||
7450  (ReturnType->isObjCObjectPointerType() &&
7451  ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7452  ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
7453  ->getName() == "NSSet"))) {
7454  std::string SelectorName
7455  = (Twine("keyPathsForValuesAffecting") + UpperKey).str();
7456  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7457  if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7458  .second) {
7459  if (ReturnType.isNull()) {
7460  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7461  Builder.AddTextChunk("NSSet<NSString *> *");
7462  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7463  }
7464 
7465  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7466  Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7468  }
7469  }
7470 
7471  // + (BOOL)automaticallyNotifiesObserversForKey
7472  if (!IsInstanceMethod &&
7473  (ReturnType.isNull() ||
7474  ReturnType->isIntegerType() ||
7475  ReturnType->isBooleanType())) {
7476  std::string SelectorName
7477  = (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
7478  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7479  if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7480  .second) {
7481  if (ReturnType.isNull()) {
7482  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7483  Builder.AddTextChunk("BOOL");
7484  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7485  }
7486 
7487  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7488  Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7490  }
7491  }
7492 }
7493 
7495  ParsedType ReturnTy) {
7496  // Determine the return type of the method we're declaring, if
7497  // provided.
7498  QualType ReturnType = GetTypeFromParser(ReturnTy);
7499  Decl *IDecl = nullptr;
7500  if (CurContext->isObjCContainer()) {
7501  ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
7502  IDecl = OCD;
7503  }
7504  // Determine where we should start searching for methods.
7505  ObjCContainerDecl *SearchDecl = nullptr;
7506  bool IsInImplementation = false;
7507  if (Decl *D = IDecl) {
7508  if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
7509  SearchDecl = Impl->getClassInterface();
7510  IsInImplementation = true;
7511  } else if (ObjCCategoryImplDecl *CatImpl
7512  = dyn_cast<ObjCCategoryImplDecl>(D)) {
7513  SearchDecl = CatImpl->getCategoryDecl();
7514  IsInImplementation = true;
7515  } else
7516  SearchDecl = dyn_cast<ObjCContainerDecl>(D);
7517  }
7518 
7519  if (!SearchDecl && S) {
7520  if (DeclContext *DC = S->getEntity())
7521  SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
7522  }
7523 
7524  if (!SearchDecl) {
7525  HandleCodeCompleteResults(this, CodeCompleter,
7527  nullptr, 0);
7528  return;
7529  }
7530 
7531  // Find all of the methods that we could declare/implement here.
7532  KnownMethodsMap KnownMethods;
7533  FindImplementableMethods(Context, SearchDecl, IsInstanceMethod,
7534  ReturnType, KnownMethods);
7535 
7536  // Add declarations or definitions for each of the known methods.
7537  typedef CodeCompletionResult Result;
7538  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7539  CodeCompleter->getCodeCompletionTUInfo(),
7541  Results.EnterNewScope();
7543  for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7544  MEnd = KnownMethods.end();
7545  M != MEnd; ++M) {
7546  ObjCMethodDecl *Method = M->second.getPointer();
7547  CodeCompletionBuilder Builder(Results.getAllocator(),
7548  Results.getCodeCompletionTUInfo());
7549 
7550  // Add the '-'/'+' prefix if it wasn't provided yet.
7551  if (!IsInstanceMethod) {
7552  Builder.AddTextChunk(Method->isInstanceMethod() ? "-" : "+");
7553  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7554  }
7555 
7556  // If the result type was not already provided, add it to the
7557  // pattern as (type).
7558  if (ReturnType.isNull()) {
7559  QualType ResTy = Method->getSendResultType().stripObjCKindOfType(Context);
7562  Method->getObjCDeclQualifier(), Context, Policy,
7563  Builder);
7564  }
7565 
7566  Selector Sel = Method->getSelector();
7567 
7568  // Add the first part of the selector to the pattern.
7569  Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7570  Sel.getNameForSlot(0)));
7571 
7572  // Add parameters to the pattern.
7573  unsigned I = 0;
7574  for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
7575  PEnd = Method->param_end();
7576  P != PEnd; (void)++P, ++I) {
7577  // Add the part of the selector name.
7578  if (I == 0)
7579  Builder.AddTypedTextChunk(":");
7580  else if (I < Sel.getNumArgs()) {
7581  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7582  Builder.AddTypedTextChunk(
7583  Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
7584  } else
7585  break;
7586 
7587  // Add the parameter type.
7588  QualType ParamType;
7589  if ((*P)->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
7590  ParamType = (*P)->getType();
7591  else
7592  ParamType = (*P)->getOriginalType();
7593  ParamType = ParamType.substObjCTypeArgs(Context, {},
7596  AddObjCPassingTypeChunk(ParamType,
7597  (*P)->getObjCDeclQualifier(),
7598  Context, Policy,
7599  Builder);
7600 
7601  if (IdentifierInfo *Id = (*P)->getIdentifier())
7602  Builder.AddTextChunk(Builder.getAllocator().CopyString( Id->getName()));
7603  }
7604 
7605  if (Method->isVariadic()) {
7606  if (Method->param_size() > 0)
7607  Builder.AddChunk(CodeCompletionString::CK_Comma);
7608  Builder.AddTextChunk("...");
7609  }
7610 
7611  if (IsInImplementation && Results.includeCodePatterns()) {
7612  // We will be defining the method here, so add a compound statement.
7613  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7614  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
7615  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
7616  if (!Method->getReturnType()->isVoidType()) {
7617  // If the result type is not void, add a return clause.
7618  Builder.AddTextChunk("return");
7619  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7620  Builder.AddPlaceholderChunk("expression");
7621  Builder.AddChunk(CodeCompletionString::CK_SemiColon);
7622  } else
7623  Builder.AddPlaceholderChunk("statements");
7624 
7625  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
7626  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
7627  }
7628 
7629  unsigned Priority = CCP_CodePattern;
7630  if (!M->second.getInt())
7631  Priority += CCD_InBaseClass;
7632 
7633  Results.AddResult(Result(Builder.TakeString(), Method, Priority));
7634  }
7635 
7636  // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
7637  // the properties in this class and its categories.
7638  if (Context.getLangOpts().ObjC2) {
7640  Containers.push_back(SearchDecl);
7641 
7642  VisitedSelectorSet KnownSelectors;
7643  for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7644  MEnd = KnownMethods.end();
7645  M != MEnd; ++M)
7646  KnownSelectors.insert(M->first);
7647 
7648 
7649  ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
7650  if (!IFace)
7651  if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
7652  IFace = Category->getClassInterface();
7653 
7654  if (IFace)
7655  for (auto *Cat : IFace->visible_categories())
7656  Containers.push_back(Cat);
7657 
7658  if (IsInstanceMethod) {
7659  for (unsigned I = 0, N = Containers.size(); I != N; ++I)
7660  for (auto *P : Containers[I]->instance_properties())
7661  AddObjCKeyValueCompletions(P, *IsInstanceMethod, ReturnType, Context,
7662  KnownSelectors, Results);
7663  }
7664  }
7665 
7666  Results.ExitScope();
7667 
7668  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7669  Results.data(), Results.size());
7670 }
7671 
7673  bool IsInstanceMethod,
7674  bool AtParameterName,
7675  ParsedType ReturnTy,
7676  ArrayRef<IdentifierInfo *> SelIdents) {
7677  // If we have an external source, load the entire class method
7678  // pool from the AST file.
7679  if (ExternalSource) {
7680  for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
7681  I != N; ++I) {
7682  Selector Sel = ExternalSource->GetExternalSelector(I);
7683  if (Sel.isNull() || MethodPool.count(Sel))
7684  continue;
7685 
7686  ReadMethodPool(Sel);
7687  }
7688  }
7689 
7690  // Build the set of methods we can see.
7691  typedef CodeCompletionResult Result;
7692  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7693  CodeCompleter->getCodeCompletionTUInfo(),
7695 
7696  if (ReturnTy)
7697  Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
7698 
7699  Results.EnterNewScope();
7700  for (GlobalMethodPool::iterator M = MethodPool.begin(),
7701  MEnd = MethodPool.end();
7702  M != MEnd; ++M) {
7703  for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first :
7704  &M->second.second;
7705  MethList && MethList->getMethod();
7706  MethList = MethList->getNext()) {
7707  if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
7708  continue;
7709 
7710  if (AtParameterName) {
7711  // Suggest parameter names we've seen before.
7712  unsigned NumSelIdents = SelIdents.size();
7713  if (NumSelIdents &&
7714  NumSelIdents <= MethList->getMethod()->param_size()) {
7715  ParmVarDecl *Param =
7716  MethList->getMethod()->parameters()[NumSelIdents - 1];
7717  if (Param->getIdentifier()) {
7718  CodeCompletionBuilder Builder(Results.getAllocator(),
7719  Results.getCodeCompletionTUInfo());
7720  Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7721  Param->getIdentifier()->getName()));
7722  Results.AddResult(Builder.TakeString());
7723  }
7724  }
7725 
7726  continue;
7727  }
7728 
7729  Result R(MethList->getMethod(),
7730  Results.getBasePriority(MethList->getMethod()), nullptr);
7731  R.StartParameter = SelIdents.size();
7732  R.AllParametersAreInformative = false;
7733  R.DeclaringEntity = true;
7734  Results.MaybeAddResult(R, CurContext);
7735  }
7736  }
7737 
7738  Results.ExitScope();
7739 
7740  if (!AtParameterName && !SelIdents.empty() &&
7741  SelIdents.front()->getName().startswith("init")) {
7742  for (const auto &M : PP.macros()) {
7743  if (M.first->getName() != "NS_DESIGNATED_INITIALIZER")
7744  continue;
7745  Results.EnterNewScope();
7746  CodeCompletionBuilder Builder(Results.getAllocator(),
7747  Results.getCodeCompletionTUInfo());
7748  Builder.AddTypedTextChunk(
7749  Builder.getAllocator().CopyString(M.first->getName()));
7750  Results.AddResult(CodeCompletionResult(Builder.TakeString(), CCP_Macro,
7752  Results.ExitScope();
7753  }
7754  }
7755 
7756  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7757  Results.data(), Results.size());
7758 }
7759 
7761  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7762  CodeCompleter->getCodeCompletionTUInfo(),
7764  Results.EnterNewScope();
7765 
7766  // #if <condition>
7767  CodeCompletionBuilder Builder(Results.getAllocator(),
7768  Results.getCodeCompletionTUInfo());
7769  Builder.AddTypedTextChunk("if");
7770  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7771  Builder.AddPlaceholderChunk("condition");
7772  Results.AddResult(Builder.TakeString());
7773 
7774  // #ifdef <macro>
7775  Builder.AddTypedTextChunk("ifdef");
7776  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7777  Builder.AddPlaceholderChunk("macro");
7778  Results.AddResult(Builder.TakeString());
7779 
7780  // #ifndef <macro>
7781  Builder.AddTypedTextChunk("ifndef");
7782  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7783  Builder.AddPlaceholderChunk("macro");
7784  Results.AddResult(Builder.TakeString());
7785 
7786  if (InConditional) {
7787  // #elif <condition>
7788  Builder.AddTypedTextChunk("elif");
7789  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7790  Builder.AddPlaceholderChunk("condition");
7791  Results.AddResult(Builder.TakeString());
7792 
7793  // #else
7794  Builder.AddTypedTextChunk("else");
7795  Results.AddResult(Builder.TakeString());
7796 
7797  // #endif
7798  Builder.AddTypedTextChunk("endif");
7799  Results.AddResult(Builder.TakeString());
7800  }
7801 
7802  // #include "header"
7803  Builder.AddTypedTextChunk("include");
7804  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7805  Builder.AddTextChunk("\"");
7806  Builder.AddPlaceholderChunk("header");
7807  Builder.AddTextChunk("\"");
7808  Results.AddResult(Builder.TakeString());
7809 
7810  // #include <header>
7811  Builder.AddTypedTextChunk("include");
7812  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7813  Builder.AddTextChunk("<");
7814  Builder.AddPlaceholderChunk("header");
7815  Builder.AddTextChunk(">");
7816  Results.AddResult(Builder.TakeString());
7817 
7818  // #define <macro>
7819  Builder.AddTypedTextChunk("define");
7820  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7821  Builder.AddPlaceholderChunk("macro");
7822  Results.AddResult(Builder.TakeString());
7823 
7824  // #define <macro>(<args>)
7825  Builder.AddTypedTextChunk("define");
7826  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7827  Builder.AddPlaceholderChunk("macro");
7828  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7829  Builder.AddPlaceholderChunk("args");
7830  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7831  Results.AddResult(Builder.TakeString());
7832 
7833  // #undef <macro>
7834  Builder.AddTypedTextChunk("undef");
7835  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7836  Builder.AddPlaceholderChunk("macro");
7837  Results.AddResult(Builder.TakeString());
7838 
7839  // #line <number>
7840  Builder.AddTypedTextChunk("line");
7841  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7842  Builder.AddPlaceholderChunk("number");
7843  Results.AddResult(Builder.TakeString());
7844 
7845  // #line <number> "filename"
7846  Builder.AddTypedTextChunk("line");
7847  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7848  Builder.AddPlaceholderChunk("number");
7849  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7850  Builder.AddTextChunk("\"");
7851  Builder.AddPlaceholderChunk("filename");
7852  Builder.AddTextChunk("\"");
7853  Results.AddResult(Builder.TakeString());
7854 
7855  // #error <message>
7856  Builder.AddTypedTextChunk("error");
7857  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7858  Builder.AddPlaceholderChunk("message");
7859  Results.AddResult(Builder.TakeString());
7860 
7861  // #pragma <arguments>
7862  Builder.AddTypedTextChunk("pragma");
7863  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7864  Builder.AddPlaceholderChunk("arguments");
7865  Results.AddResult(Builder.TakeString());
7866 
7867  if (getLangOpts().ObjC1) {
7868  // #import "header"
7869  Builder.AddTypedTextChunk("import");
7870  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7871  Builder.AddTextChunk("\"");
7872  Builder.AddPlaceholderChunk("header");
7873  Builder.AddTextChunk("\"");
7874  Results.AddResult(Builder.TakeString());
7875 
7876  // #import <header>
7877  Builder.AddTypedTextChunk("import");
7878  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7879  Builder.AddTextChunk("<");
7880  Builder.AddPlaceholderChunk("header");
7881  Builder.AddTextChunk(">");
7882  Results.AddResult(Builder.TakeString());
7883  }
7884 
7885  // #include_next "header"
7886  Builder.AddTypedTextChunk("include_next");
7887  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7888  Builder.AddTextChunk("\"");
7889  Builder.AddPlaceholderChunk("header");
7890  Builder.AddTextChunk("\"");
7891  Results.AddResult(Builder.TakeString());
7892 
7893  // #include_next <header>
7894  Builder.AddTypedTextChunk("include_next");
7895  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7896  Builder.AddTextChunk("<");
7897  Builder.AddPlaceholderChunk("header");
7898  Builder.AddTextChunk(">");
7899  Results.AddResult(Builder.TakeString());
7900 
7901  // #warning <message>
7902  Builder.AddTypedTextChunk("warning");
7903  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7904  Builder.AddPlaceholderChunk("message");
7905  Results.AddResult(Builder.TakeString());
7906 
7907  // Note: #ident and #sccs are such crazy anachronisms that we don't provide
7908  // completions for them. And __include_macros is a Clang-internal extension
7909  // that we don't want to encourage anyone to use.
7910 
7911  // FIXME: we don't support #assert or #unassert, so don't suggest them.
7912  Results.ExitScope();
7913 
7914  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7915  Results.data(), Results.size());
7916 }
7917 
7919  CodeCompleteOrdinaryName(S,
7922 }
7923 
7925  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7926  CodeCompleter->getCodeCompletionTUInfo(),
7929  if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
7930  // Add just the names of macros, not their arguments.
7931  CodeCompletionBuilder Builder(Results.getAllocator(),
7932  Results.getCodeCompletionTUInfo());
7933  Results.EnterNewScope();
7934  for (Preprocessor::macro_iterator M = PP.macro_begin(),
7935  MEnd = PP.macro_end();
7936  M != MEnd; ++M) {
7937  Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7938  M->first->getName()));
7939  Results.AddResult(CodeCompletionResult(Builder.TakeString(),
7942  }
7943  Results.ExitScope();
7944  } else if (IsDefinition) {
7945  // FIXME: Can we detect when the user just wrote an include guard above?
7946  }
7947 
7948  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7949  Results.data(), Results.size());
7950 }
7951 
7953  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7954  CodeCompleter->getCodeCompletionTUInfo(),
7956 
7957  if (!CodeCompleter || CodeCompleter->includeMacros())
7958  AddMacroResults(PP, Results, true);
7959 
7960  // defined (<macro>)
7961  Results.EnterNewScope();
7962  CodeCompletionBuilder Builder(Results.getAllocator(),
7963  Results.getCodeCompletionTUInfo());
7964  Builder.AddTypedTextChunk("defined");
7965  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
7966  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
7967  Builder.AddPlaceholderChunk("macro");
7968  Builder.AddChunk(CodeCompletionString::CK_RightParen);
7969  Results.AddResult(Builder.TakeString());
7970  Results.ExitScope();
7971 
7972  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7973  Results.data(), Results.size());
7974 }
7975 
7977  IdentifierInfo *Macro,
7979  unsigned Argument) {
7980  // FIXME: In the future, we could provide "overload" results, much like we
7981  // do for function calls.
7982 
7983  // Now just ignore this. There will be another code-completion callback
7984  // for the expanded tokens.
7985 }
7986 
7988  HandleCodeCompleteResults(this, CodeCompleter,
7990  nullptr, 0);
7991 }
7992 
7994  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7995  CodeCompleter->getCodeCompletionTUInfo(),
7997  Results.EnterNewScope();
7998  static const char *Platforms[] = {"macOS", "iOS", "watchOS", "tvOS"};
7999  for (const char *Platform : llvm::makeArrayRef(Platforms)) {
8000  Results.AddResult(CodeCompletionResult(Platform));
8001  Results.AddResult(CodeCompletionResult(Results.getAllocator().CopyString(
8002  Twine(Platform) + "ApplicationExtension")));
8003  }
8004  Results.ExitScope();
8005  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
8006  Results.data(), Results.size());
8007 }
8008 
8010  CodeCompletionTUInfo &CCTUInfo,
8012  ResultBuilder Builder(*this, Allocator, CCTUInfo,
8014  if (!CodeCompleter || CodeCompleter->includeGlobals()) {
8015  CodeCompletionDeclConsumer Consumer(Builder,
8016  Context.getTranslationUnitDecl());
8017  LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
8018  Consumer,
8019  !CodeCompleter || CodeCompleter->loadExternal());
8020  }
8021 
8022  if (!CodeCompleter || CodeCompleter->includeMacros())
8023  AddMacroResults(PP, Builder, true);
8024 
8025  Results.clear();
8026  Results.insert(Results.end(),
8027  Builder.data(), Builder.data() + Builder.size());
8028 }
An unknown context, in which we are recovering from a parsing error and don&#39;t know which completions ...
The receiver is the instance of the superclass object.
Definition: ExprObjC.h:1082
A C++ function template.
Definition: Index.h:1777
static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property, bool IsInstanceMethod, QualType ReturnType, ASTContext &Context, VisitedSelectorSet &KnownSelectors, ResultBuilder &Results)
Add code completions for Objective-C Key-Value Coding (KVC) and Key-Value Observing (KVO)...
static void AddPrettyFunctionResults(const LangOptions &LangOpts, ResultBuilder &Results)
bool hasDefinition() const
Determine whether this class has been defined.
Definition: DeclObjC.h:1556
QualType getCurrentThisType()
Try to retrieve the type of the &#39;this&#39; pointer.
static void MaybeAddSentinel(Preprocessor &PP, const NamedDecl *FunctionOrMethod, CodeCompletionBuilder &Result)
Represents a function declaration or definition.
Definition: Decl.h:1716
void CodeCompleteObjCPropertySynthesizeIvar(Scope *S, IdentifierInfo *PropertyName)
A C++ alias declaration.
Definition: Index.h:1789
The receiver is an object instance.
Definition: ExprObjC.h:1076
ExternalSemaSource * getExternalSource() const
Definition: Sema.h:1214
A C++ namespace alias declaration.
Definition: Index.h:1783
protocol_range protocols() const
Definition: DeclObjC.h:1387
Priority for the Objective-C "_cmd" implicit parameter.
Smart pointer class that efficiently represents Objective-C method names.
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1834
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:497
PtrTy get() const
Definition: Ownership.h:81
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T -> getSizeExpr()))
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2393
A (possibly-)qualified type.
Definition: Type.h:655
Any kind of method, provided it means other specified criteria.
bool isBlockPointerType() const
Definition: Type.h:6121
QualType substObjCTypeArgs(ASTContext &ctx, ArrayRef< QualType > typeArgs, ObjCSubstitutionContext context) const
Substitute type arguments for the Objective-C type parameters used in the subject type...
Definition: Type.cpp:1153
This is a scope that corresponds to the parameters within a function prototype.
Definition: Scope.h:81
param_iterator param_begin() const
Definition: MacroInfo.h:181
base_class_range bases()
Definition: DeclCXX.h:825
bool isNull() const
Definition: CanonicalType.h:98
bool isMemberPointerType() const
Definition: Type.h:6144
std::vector< Module * >::iterator submodule_iterator
Definition: Module.h:553
unsigned param_size() const
Definition: DeclObjC.h:381
A static_assert or _Static_assert node.
Definition: Index.h:2582
Selector getSelector() const
Definition: ExprObjC.cpp:312
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.cpp:1098
static void AddQualifierToCompletionString(CodeCompletionBuilder &Result, NestedNameSpecifier *Qualifier, bool QualifierIsInformative, ASTContext &Context, const PrintingPolicy &Policy)
Add a qualifier to the given code-completion string, if the provided nested-name-specifier is non-NUL...
CodeCompletionString * CreateCodeCompletionString(Sema &S, const CodeCompletionContext &CCContext, CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo, bool IncludeBriefComments)
Create a new code-completion string that describes how to insert this result into a program...
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: DeclSpec.h:821
iterator begin() const
Definition: DeclObjC.h:91
static void LookupVisibleDecls(DeclContext *Ctx, LookupResult &Result, bool QualifiedNameLookup, bool InBaseClass, VisibleDeclConsumer &Consumer, VisibleDeclsRecord &Visited, bool IncludeDependentBases, bool LoadExternal)
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:404
Code completion occurs within a class, struct, or union.
Definition: Sema.h:10197
void CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver, ArrayRef< IdentifierInfo *> SelIdents, bool AtArgumentExpression, bool IsSuper=false)
A variable.
Definition: Index.h:1735
Code completion for a selector, as in an @selector expression.
DeclarationName getCXXConstructorName(CanQualType Ty)
getCXXConstructorName - Returns the name of a C++ constructor for the given Type. ...
CodeCompleteConsumer::OverloadCandidate ResultCandidate
submodule_iterator submodule_begin()
Definition: Module.h:556
void AddTextChunk(const char *Text)
Add a new text chunk.
static void AddObjCInterfaceResults(const LangOptions &LangOpts, ResultBuilder &Results, bool NeedAt)
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.
Adjustment to the "bool" type in Objective-C, where the typedef "BOOL" is preferred.
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3211
FunctionDecl * getFunction() const
Retrieve the function overload candidate or the templated function declaration for a function templat...
static bool isObjCReceiverType(ASTContext &C, QualType T)
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:497
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:2741
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
Definition: ScopeInfo.h:633
void CodeCompleteAssignmentRHS(Scope *S, Expr *LHS)
static CharSourceRange getTokenRange(SourceRange R)
Code completion within a type-qualifier list.
bool isRecordType() const
Definition: Type.h:6186
static bool isReservedName(const IdentifierInfo *Id, bool doubleUnderscoreOnly=false)
Determine whether Id is a name reserved for the implementation (C99 7.1.3, C++ [lib.global.names]).
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
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.
iterator end()
Definition: DeclGroup.h:106
bool isBetterOverloadCandidate(Sema &S, const OverloadCandidate &Cand1, const OverloadCandidate &Cand2, SourceLocation Loc, OverloadCandidateSet::CandidateSetKind Kind)
isBetterOverloadCandidate - Determines whether the first overload candidate is a better candidate tha...
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
bool isVariadic() const
Definition: Type.h:3774
void AddChunk(CodeCompletionString::ChunkKind CK, const char *Text="")
Add a new chunk.
bool isVirtual() const
Definition: DeclCXX.h:2090
Captures information about "declaration specifiers" specific to Objective-C.
Definition: DeclSpec.h:777
void CodeCompleteUsing(Scope *S)
void CodeCompleteExpression(Scope *S, const CodeCompleteExpressionData &Data)
Perform code-completion in an expression context when we know what type we&#39;re looking for...
StringRef P
static void AddFunctionSpecifiers(Sema::ParserCompletionContext CCC, const LangOptions &LangOpts, ResultBuilder &Results)
virtual uint32_t GetNumExternalSelectors()
Returns the number of selectors known to the external AST source.
bool isOverrideSpecified() const
Definition: DeclSpec.h:2506
An access specifier.
Definition: Index.h:1795
known_categories_range known_categories() const
Definition: DeclObjC.h:1708
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:6062
void CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc, ArrayRef< IdentifierInfo *> SelIdents, bool AtArgumentExpression)
Defines the clang::MacroInfo and clang::MacroDirective classes.
void CodeCompleteNaturalLanguage()
The base class of the type hierarchy.
Definition: Type.h:1428
An unspecified code-completion context.
bool isObjCContainer() const
Definition: DeclBase.h:1380
Represent a C++ namespace.
Definition: Decl.h:514
Wrapper for source info for typedefs.
Definition: TypeLoc.h:665
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
Definition: Type.cpp:1604
A C++ non-type template parameter.
Definition: Index.h:1773
An Objective-C @interface for a category.
Definition: Index.h:1741
void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, bool EnteringContext)
A container of type source information.
Definition: Decl.h:86
bool isAcceptableNestedNameSpecifier(const NamedDecl *SD, bool *CanCorrect=nullptr)
Determines whether the given declaration is an valid acceptable result for name lookup of a nested-na...
constexpr XRayInstrMask Function
Definition: XRayInstr.h:39
ObjCMethodDecl * getMethod() const
bool isVariadic() const
Definition: MacroInfo.h:208
Scope * getContinueParent()
getContinueParent - Return the closest scope that a continue statement would be affected by...
Definition: Scope.h:239
bool loadExternal() const
Hint whether to load data from the external AST in order to provide full results. ...
void CodeCompleteDeclSpec(Scope *S, DeclSpec &DS, bool AllowNonIdentifiers, bool AllowNestedNameSpecifiers)
static bool isAcceptableObjCSelector(Selector Sel, ObjCMethodKind WantKind, ArrayRef< IdentifierInfo *> SelIdents, bool AllowSameLength=true)
Priority for a member declaration found from the current method or member function.
param_const_iterator param_end() const
Definition: DeclObjC.h:392
unsigned getIdentifierNamespace() const
Definition: DeclBase.h:799
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2477
Code completion occurred where an Objective-C message receiver is expected.
iterator(const NamedDecl *SingleDecl, unsigned Index)
void CodeCompleteObjCMessageReceiver(Scope *S)
void CodeCompleteObjCPropertyGetter(Scope *S)
Code completion occurred on the right-hand side of a member access expression using the arrow operato...
Consumes visible declarations found when searching for all visible names within a given scope or cont...
Definition: Lookup.h:749
Code completion occurred after the "enum" keyword, to indicate an enumeration name.
enumerator_range enumerators() const
Definition: Decl.h:3415
static const char * GetCompletionTypeString(QualType T, ASTContext &Context, const PrintingPolicy &Policy, CodeCompletionAllocator &Allocator)
Retrieve the string representation of the given type as a string that has the appropriate lifetime fo...
Represents a variable declaration or definition.
Definition: Decl.h:814
static NestedNameSpecifier * Create(const ASTContext &Context, NestedNameSpecifier *Prefix, IdentifierInfo *II)
Builds a specifier combining a prefix and an identifier.
Information about one declarator, including the parsed type information and the identifier.
Definition: DeclSpec.h:1752
unsigned getNumParams() const
Definition: Type.h:3668
bool isEnumeralType() const
Definition: Type.h:6190
void CodeCompleteObjCClassPropertyRefExpr(Scope *S, IdentifierInfo &ClassName, SourceLocation ClassNameLoc, bool IsBaseExprStatement)
QualType getCXXNameType() const
getCXXNameType - If this name is one of the C++ names (of a constructor, destructor, or conversion function), return the type associated with that name.
Wrapper of type source information for a type with non-trivial direct qualifiers. ...
Definition: TypeLoc.h:272
A C++ using directive.
Definition: Index.h:1785
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6526
bool hasDefaultArg() const
Determines whether this parameter has a default argument, either parsed or not.
Definition: Decl.cpp:2587
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition: Sema.h:2136
static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt)
The "union" keyword.
Definition: Type.h:4855
unsigned getParsedSpecifiers() const
Return a bitmask of which flavors of specifiers this DeclSpec includes.
Definition: DeclSpec.cpp:415
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:1588
virtual Selector GetExternalSelector(uint32_t ID)
Resolve a selector ID into a selector.
TypeSpecifierType
Specifies the kind of type.
Definition: Specifiers.h:45
The "__interface" keyword.
Definition: Type.h:4852
An Objective-C @synthesize definition.
Definition: Index.h:1791
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:431
static const TST TST_interface
Definition: DeclSpec.h:295
void AddOptionalChunk(CodeCompletionString *Optional)
Add a new optional chunk.
Expr * IgnoreImplicit() LLVM_READONLY
IgnoreImplicit - Skip past any implicit AST nodes which might surround this expression.
Definition: Expr.h:741
bool isConst() const
Definition: Type.h:3377
Code completion occurred within the instance variable list of an Objective-C interface, implementation, or category implementation.
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
void AddTypedTextChunk(const char *Text)
Add a new typed-text chunk.
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
Code completion occurs within an Objective-C implementation or category implementation.
Definition: Sema.h:10203
The entity is not available; any use of it will be an error.
Definition: Index.h:144
Represents a parameter to a function.
Definition: Decl.h:1535
A C++ class method.
Definition: Index.h:1759
Defines the clang::Expr interface and subclasses for C++ expressions.
The collection of all-type qualifiers we support.
Definition: Type.h:154
tok::TokenKind ContextKind
iterator end() const
Definition: DeclObjC.h:92
bool isObjCObjectOrInterfaceType() const
Definition: Type.h:6218
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:269
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:56
void CodeCompleteOrdinaryName(Scope *S, ParserCompletionContext CompletionContext)
Represents a struct/union/class.
Definition: Decl.h:3570
static void AddTypedefResult(ResultBuilder &Results)
static void AddObjCProperties(const CodeCompletionContext &CCContext, ObjCContainerDecl *Container, bool AllowCategories, bool AllowNullaryMethods, DeclContext *CurContext, AddedPropertiesSet &AddedProperties, ResultBuilder &Results, bool IsBaseExprStatement=false, bool IsClassProperty=false)
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
instprop_range instance_properties() const
Definition: DeclObjC.h:1023
static void AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result, const FunctionDecl *Function)
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:1110
One of these records is kept for each identifier that is lexed.
CodeCompletionString * TakeString()
Take the resulting completion string.
This table allows us to fully hide how we implement multi-keyword caching.
void CodeCompleteObjCInterfaceDecl(Scope *S)
Represents a class type in Objective C.
Definition: Type.h:5355
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:150
CodeCompletionString * CreateCodeCompletionStringForMacro(Preprocessor &PP, CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo)
Creates a new code-completion string for the macro result.
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1190
const ParmVarDecl *const * param_const_iterator
Definition: DeclObjC.h:383
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
void CodeCompleteConstructor(Scope *S, QualType Type, SourceLocation Loc, ArrayRef< Expr *> Args)
A "string" used to describe how code completion can be performed for an entity.
field_range fields() const
Definition: Decl.h:3786
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
Definition: Sema.cpp:1454
static const TST TST_class
Definition: DeclSpec.h:296
bool isObjCIdType() const
Definition: Type.h:6239
bool isNamespace() const
Definition: DeclBase.h:1421
An Objective-C @protocol declaration.
Definition: Index.h:1743
const ObjCObjectPointerType * getAsObjCQualifiedIdType() const
Definition: Type.cpp:1576
void CodeCompleteObjCInterfaceCategory(Scope *S, IdentifierInfo *ClassName, SourceLocation ClassNameLoc)
static void AddTypeSpecifierResults(const LangOptions &LangOpts, ResultBuilder &Results)
Add type specifiers for the current language as keyword results.
void CodeCompleteObjCProtocolReferences(ArrayRef< IdentifierLocPair > Protocols)
Code completion occurs following one or more template headers within a class.
Definition: Sema.h:10212
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2126
method_range methods() const
Definition: DeclObjC.h:1057
ObjCMethodDecl * getSetterMethodDecl() const
Definition: DeclObjC.h:944
Kind getKind() const
Retrieve the kind of code-completion context.
A C++ template template parameter.
Definition: Index.h:1775
void CodeCompleteCase(Scope *S)
ParmVarDecl * getParam(unsigned i) const
Definition: TypeLoc.h:1477
An Objective-C instance method.
Definition: Index.h:1749
int Category
Definition: Format.cpp:1608
static const TST TST_enum
Definition: DeclSpec.h:292
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1463
void CodeCompletePreprocessorMacroArgument(Scope *S, IdentifierInfo *Macro, MacroInfo *MacroInfo, unsigned Argument)
void AddResultTypeChunk(const char *ResultType)
Add a new result-type chunk.
TSC getTypeSpecComplex() const
Definition: DeclSpec.h:481
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:50
visible_categories_range visible_categories() const
Definition: DeclObjC.h:1674
llvm::DenseMap< Selector, llvm::PointerIntPair< ObjCMethodDecl *, 1, bool > > KnownMethodsMap
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:821
bool isObjCQualifiedClassType() const
Definition: Type.h:6233
void * getAsOpaquePtr() const
Definition: Ownership.h:91
A C++ constructor.
Definition: Index.h:1765
Scope * getBreakParent()
getBreakParent - Return the closest scope that a break statement would be affected by...
Definition: Scope.h:249
Describes a module or submodule.
Definition: Module.h:65
Code completion occurs where only a type is permitted.
Definition: Sema.h:10229
IdentifierTable & Idents
Definition: ASTContext.h:545
unsigned getTypeQuals() const
Definition: Type.h:3786
Qualifiers getLocalQualifiers() const
Retrieve the set of qualifiers local to this particular QualType instance, not including any qualifie...
Definition: Type.h:5908
unsigned SuppressStrongLifetime
When true, suppress printing of the __strong lifetime qualifier in ARC.
Code completion occurs at top-level or namespace context.
Definition: Sema.h:10195
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2231
Values of this type can be null.
bool isUnarySelector() const
An Objective-C @property declaration.
Definition: Index.h:1745
static bool shouldIgnoreDueToReservedName(const NamedDecl *ND, Sema &SemaRef)
static ObjCContainerDecl * getContainerDef(ObjCContainerDecl *Container)
Retrieve the container definition, if any?
void CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro, bool AfterAmpersand)
An allocator used specifically for the purpose of code completion.
Code completion occurs within the body of a function on a recovery path, where we do not have a speci...
Definition: Sema.h:10227
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:922
param_iterator param_end() const
Definition: MacroInfo.h:182
Represents the results of name lookup.
Definition: Lookup.h:47
PtrTy get() const
Definition: Ownership.h:174
Divide by this factor when a code-completion result&#39;s type exactly matches the type we expect...
static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag)
Determine whether the addition of the given flag to an Objective-C property&#39;s attributes will cause a...
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:988
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
Definition: Sema.cpp:1199
Namespaces, declared with &#39;namespace foo {}&#39;.
Definition: DeclBase.h:140
A convenient class for passing around template argument information.
Definition: TemplateBase.h:552
macro_iterator macro_begin(bool IncludeExternalMacros=true) const
Code completion occurs following one or more template headers.
Definition: Sema.h:10209
void CodeCompleteBracketDeclarator(Scope *S)
static void AddStaticAssertResult(CodeCompletionBuilder &Builder, ResultBuilder &Results, const LangOptions &LangOpts)
Wrapper for source info for functions.
Definition: TypeLoc.h:1396
void CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS)
static std::string formatObjCParamQualifiers(unsigned ObjCQuals, QualType &Type)
Code completion occurs within an expression.
Definition: Sema.h:10214
Whether values of this type can be null is (explicitly) unspecified.
Code completion occurred where a preprocessor directive is expected.
A friend of a previously-undeclared entity.
Definition: DeclBase.h:1103
GlobalMethodPool MethodPool
Method Pool - allows efficient lookup when typechecking messages to "id".
Definition: Sema.h:1133
Represents a declaration of a type.
Definition: Decl.h:2829
void CodeCompleteModuleImport(SourceLocation ImportLoc, ModuleIdPath Path)
bool SuppressScope
Suppresses printing of scope specifiers.
An enumerator constant.
Definition: Index.h:1731
Code completion occurred within an Objective-C implementation or category implementation.
iterator begin()
Definition: DeclGroup.h:100
static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext, bool OnlyForwardDeclarations, bool OnlyUnimplemented, ResultBuilder &Results)
Add all of the Objective-C interface declarations that we find in the given (translation unit) contex...
void MarkDeducedTemplateParameters(const FunctionTemplateDecl *FunctionTemplate, llvm::SmallBitVector &Deduced)
Definition: Sema.h:7110
static void AddObjCMethods(ObjCContainerDecl *Container, bool WantInstanceMethods, ObjCMethodKind WantKind, ArrayRef< IdentifierInfo *> SelIdents, DeclContext *CurContext, VisitedSelectorSet &Selectors, bool AllowSameLength, ResultBuilder &Results, bool InOriginalClass=true, bool IsRootClass=false)
Add all of the Objective-C methods in the given Objective-C container to the set of results...
static void AddObjCBlockCall(ASTContext &Context, const PrintingPolicy &Policy, CodeCompletionBuilder &Builder, const NamedDecl *BD, const FunctionTypeLoc &BlockLoc, const FunctionProtoTypeLoc &BlockProtoLoc)
Adds a block invocation code completion result for the given block declaration BD.
TSS getTypeSpecSign() const
Definition: DeclSpec.h:482
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2544
Values of this type can never be null.
void CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName, SourceLocation ClassNameLoc)
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5889
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
Definition: Type.h:1015
submodule_iterator submodule_end()
Definition: Module.h:558
Priority for a constant value (e.g., enumerator).
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...
void append(iterator I, iterator E)
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:63
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2085
static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results, bool IncludeUndefined, bool TargetTypeIsPointer=false)
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:828
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID. ...
Preprocessor & PP
Definition: Sema.h:318
const LangOptions & getLangOpts() const
Definition: Sema.h:1204
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:167
static void findTypeLocationForBlockDecl(const TypeSourceInfo *TSInfo, FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto, bool SuppressBlock=false)
Tries to find the most appropriate type location for an Objective-C block placeholder.
void CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D, const VirtSpecifiers *VS=nullptr)
Represents an ObjC class declaration.
Definition: DeclObjC.h:1193
An Objective-C method being used as a property.
QualType getReturnType() const
Definition: DeclObjC.h:363
static bool isAcceptableObjCMethod(ObjCMethodDecl *Method, ObjCMethodKind WantKind, ArrayRef< IdentifierInfo *> SelIdents, bool AllowSameLength=true)
Member name lookup, which finds the names of class/struct/union members.
Definition: Sema.h:3024
A comma separator (&#39;,&#39;).
bool wantConstructorResults() const
Determines whether we want C++ constructors as results within this context.
macro_iterator macro_end(bool IncludeExternalMacros=true) const
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results, unsigned NumSelIdents)
Given a set of code-completion results for the argument of a message send, determine the preferred ty...
Ordinary names.
Definition: DeclBase.h:144
unsigned getLength() const
Efficiently return the length of this identifier info.
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:877
Priority for a preprocessor macro.
CXCursorKind
Describes the kind of entity that a cursor refers to.
Definition: Index.h:1705
void CodeCompleteAvailabilityPlatformName()
void CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver, ArrayRef< IdentifierInfo *> SelIdents, bool AtArgumentExpression, ObjCInterfaceDecl *Super=nullptr)
CodeCompletionAllocator & getAllocator() const
Retrieve the allocator into which the code completion strings should be allocated.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1545
Code completion occurs within a sequence of declaration specifiers within a function, method, or block.
Definition: Sema.h:10235
IdentifierInfo *const * param_iterator
Parameters - The list of parameters for a function-like macro.
Definition: MacroInfo.h:179
bool isFinalSpecified() const
Definition: DeclSpec.h:2509
A right parenthesis (&#39;)&#39;).
NodeId Parent
Definition: ASTDiff.cpp:192
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:217
Code completion where an Objective-C category name is expected.
static void AddStorageSpecifiers(Sema::ParserCompletionContext CCC, const LangOptions &LangOpts, ResultBuilder &Results)
bool hasAttr() const
Definition: DeclBase.h:538
void LookupVisibleDecls(Scope *S, LookupNameKind Kind, VisibleDeclConsumer &Consumer, bool IncludeGlobalScope=true, bool LoadExternal=true)
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:277
Code completion occurred within a "top-level" completion context, e.g., at namespace or global scope...
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1627
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3432
static ObjCInterfaceDecl * GetAssumedMessageSendExprType(Expr *E)
When we have an expression with type "id", we may assume that it has some more-specific class type ba...
Objective C @protocol.
Definition: DeclBase.h:147
Zero-argument (unary) selector.
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:548
OverloadedOperatorKind getCXXOverloadedOperator() const
getCXXOverloadedOperator - If this name is the name of an overloadable operator in C++ (e...
a friend declaration.
Definition: Index.h:2586
CandidateSetKind getKind() const
Definition: Overload.h:906
SmallVector< LambdaCapture, 4 > Captures
Definition: DeclSpec.h:2563
const UsingShadowDecl * ShadowDecl
If this Decl was unshadowed by using declaration, this can store a pointer to the UsingShadowDecl whi...
void ReadMethodPool(Selector Sel)
Read the contents of the method pool for a given selector from external storage.
void print(raw_ostream &OS, const PrintingPolicy &Policy) const
Print this nested name specifier to the given output stream.
TST getTypeSpecType() const
Definition: DeclSpec.h:483
iterator(const DeclIndexPair *Iterator)
static StringRef getSourceText(CharSourceRange Range, const SourceManager &SM, const LangOptions &LangOpts, bool *Invalid=nullptr)
Returns a string for the source that the range encompasses.
Definition: Lexer.cpp:932
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...
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:432
Retains information about a block that is currently being parsed.
Definition: ScopeInfo.h:694
classprop_range class_properties() const
Definition: DeclObjC.h:1040
Type source information for an attributed type.
Definition: TypeLoc.h:859
static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class, StringRef Name)
Determine whether the given class is or inherits from a class by the given name.
Pepresents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:3860
void CodeCompleteObjCMethodDecl(Scope *S, Optional< bool > IsInstanceMethod, ParsedType ReturnType)
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:637
Expr - This represents one expression.
Definition: Expr.h:106
QualType getPointeeType() const
Definition: Type.h:2550
SourceLocation End
Code completion occurred where a new name is expected.
Represents a character-granular source range.
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2620
int Id
Definition: ASTDiff.cpp:191
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
Definition: Decl.h:1035
static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context, const Preprocessor &PP)
A C++ class.
Definition: Index.h:1722
Declaration of a template type parameter.
void CodeCompleteObjCPropertyDefinition(Scope *S)
DeclContext * getEntity() const
Definition: Scope.h:324
UnqualTypeLoc getUnqualifiedLoc() const
Skips past any qualifiers, if this is qualified.
Definition: TypeLoc.h:321
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6589
virtual void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context, CodeCompletionResult *Results, unsigned NumResults)
Process the finalized code-completion results.
bool isTypeAltiVecVector() const
Definition: DeclSpec.h:484
void CodeCompleteCall(Scope *S, Expr *Fn, ArrayRef< Expr *> Args)
static bool WantTypesInContext(Sema::ParserCompletionContext CCC, const LangOptions &LangOpts)
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:86
Priority for a non-type declaration.
void addVisitedContext(DeclContext *Ctx)
Adds a visited context.
Code completion occurs within an Objective-C interface, protocol, or category.
Definition: Sema.h:10200
SmallVector< SwitchInfo, 8 > SwitchStack
SwitchStack - This is the current set of active switch statements in the block.
Definition: ScopeInfo.h:184
Defines the clang::Preprocessor interface.
An Objective-C block property completed as a setter with a block placeholder.
#define bool
Definition: stdbool.h:31
void CodeCompleteObjCAtVisibility(Scope *S)
overridden_method_range overridden_methods() const
Definition: DeclCXX.cpp:2132
bool isFileContext() const
Definition: DeclBase.h:1409
An Objective-C @implementation for a category.
Definition: Index.h:1755
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
void CodeCompleteObjCImplementationCategory(Scope *S, IdentifierInfo *ClassName, SourceLocation ClassNameLoc)
bool isObjCClassType() const
Definition: Type.h:6245
DeclContext * getDeclContext()
Definition: DeclBase.h:428
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:771
ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.cpp:331
internal::Matcher< T > id(StringRef ID, const internal::BindableMatcher< T > &InnerMatcher)
If the provided matcher matches a node, binds the node to ID.
Definition: ASTMatchers.h:137
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents a C++ template name within the type system.
Definition: TemplateName.h:178
void CodeCompletePreprocessorExpression()
EnumDecl * getDefinition() const
Definition: Decl.h:3389
ParmVarDecl *const * param_iterator
Definition: DeclObjC.h:384
Code completion occurs within a statement, which may also be an expression or a declaration.
Definition: Sema.h:10217
Captures a result of code completion.
Code completion occurred where a new name is expected and a qualified name is permissible.
A C++ class template partial specialization.
Definition: Index.h:1781
const MacroInfo * getMacroInfo(const IdentifierInfo *II) const
Definition: Preprocessor.h:991
bool isClassScope() const
isClassScope - Return true if this scope is a class/struct/union scope.
Definition: Scope.h:337
QualType getType() const
Definition: Expr.h:128
bool isFunctionOrMethod() const
Definition: DeclBase.h:1392
static Optional< NullabilityKind > stripOuterNullability(QualType &T)
Strip off the top-level nullability annotation on the given type, if it&#39;s there.
Definition: Type.cpp:3850
decl_range decls() const
Definition: Scope.h:280
void CodeCompleteConstructorInitializer(Decl *Constructor, ArrayRef< CXXCtorInitializer *> Initializers)
Code completion in a parenthesized expression, which means that we may also have types here in C and ...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1343
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:925
Code completion occurred in a context where natural language is expected, e.g., a comment or string l...
static std::string formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl, FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto, bool SuppressBlockName=false, bool SuppressBlock=false, Optional< ArrayRef< QualType >> ObjCSubsts=None)
Returns a placeholder string that corresponds to an Objective-C block declaration.
bool isInvalid() const
Definition: Ownership.h:170
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl...
bool isInstanceMethod() const
Definition: DeclObjC.h:454
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Definition: ExprObjC.h:1209
A C or C++ struct.
Definition: Index.h:1718
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1040
unsigned getNumArgs() const
bool isUsable() const
Definition: Ownership.h:171
Selector getSelector() const
Definition: DeclObjC.h:361
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1381
The result type of a method or function.
Code completion occurs within the list of instance variables in an Objective-C interface, protocol, category, or implementation.
Definition: Sema.h:10206
void CodeCompleteNamespaceDecl(Scope *S)
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:720
const char * CopyString(const Twine &String)
Copy the given string into this allocator.
Priority for a result that isn&#39;t likely to be what the user wants, but is included for completeness...
QualType getType() const
Definition: DeclObjC.h:848
const SourceManager & SM
Definition: Format.cpp:1475
void CodeCompleteInitializer(Scope *S, Decl *D)
TypeLoc getReturnLoc() const
Definition: TypeLoc.h:1480
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so...
Definition: DeclBase.h:1110
A C++ destructor.
Definition: Index.h:1767
void CodeCompleteObjCPropertySetter(Scope *S)
static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt)
Priority for a type.
The context in which code completion occurred, so that the code-completion consumer can process the r...
void CodeCompleteObjCAtExpression(Scope *S)
SourceManager & getSourceManager() const
Definition: Preprocessor.h:825
Priority for the next initialization in a constructor initializer list.
void CodeCompleteTypeQualifiers(DeclSpec &DS)
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
bool isCtorOrDtor()
Returns true if this declares a constructor or a destructor.
Definition: DeclSpec.cpp:401
static void AddFunctionParameterChunks(Preprocessor &PP, const PrintingPolicy &Policy, const FunctionDecl *Function, CodeCompletionBuilder &Result, unsigned Start=0, bool InOptional=false)
Add function parameter chunks to the given code completion string.
void CodeCompleteObjCSelector(Scope *S, ArrayRef< IdentifierInfo *> SelIdents)
Code completion occurred within a class, struct, or union.
void CodeCompleteObjCAtDirective(Scope *S)
Priority for a send-to-super completion.
#define false
Definition: stdbool.h:33
The "struct" keyword.
Definition: Type.h:4849
SelectorTable & Selectors
Definition: ASTContext.h:546
Kind
A C++ template type parameter.
Definition: Index.h:1771
void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base, Expr *OtherOpBase, SourceLocation OpLoc, bool IsArrow, bool IsBaseExprStatement)
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:157
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1196
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
Definition: Overload.h:730
IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const
Retrieve the identifier at a given position in the selector.
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:218
ASTContext & getASTContext() const
Definition: Sema.h:1211
Encodes a location in the source.
static void AddClassMessageCompletions(Sema &SemaRef, Scope *S, ParsedType Receiver, ArrayRef< IdentifierInfo *> SelIdents, bool AtArgumentExpression, bool IsSuper, ResultBuilder &Results)
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
QualType getReturnType() const
Definition: Type.h:3365
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:4161
Members, declared with object declarations within tag definitions.
Definition: DeclBase.h:136
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1332
const SwitchCase * getSwitchCaseList() const
Definition: Stmt.h:1094
std::string getNameAsString() const
Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...
Definition: Decl.h:291
Expr * getLHS()
Definition: Stmt.h:791
static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt)
The nullability qualifier is set when the nullability of the result or parameter was expressed via a ...
Definition: DeclBase.h:207
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3020
This is a scope that corresponds to the Objective-C @catch statement.
Definition: Scope.h:91
CodeCompletionString * CreateSignatureString(unsigned CurrentArg, Sema &S, CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo, bool IncludeBriefComments) const
Create a new code-completion string that describes the function signature of this overload candidate...
MacroDefinition getMacroDefinition(const IdentifierInfo *II)
Definition: Preprocessor.h:950
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:376
static const TST TST_union
Definition: DeclSpec.h:293
static void AddRecordMembersCompletionResults(Sema &SemaRef, ResultBuilder &Results, Scope *S, QualType BaseType, RecordDecl *RD, Optional< FixItHint > AccessOpFixIt)
void CodeCompleteReturn(Scope *S)
bool isRestrict() const
Definition: Type.h:3379
Code completion where the name of an Objective-C class is expected.
A typedef.
Definition: Index.h:1757
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2045
A field (in C) or non-static data member (in C++) in a struct, union, or C++ class.
Definition: Index.h:1729
Code completion occurred within an Objective-C interface, protocol, or category interface.
virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, OverloadCandidate *Candidates, unsigned NumCandidates)
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
void CodeCompleteOperatorName(Scope *S)
void CodeCompletePreprocessorDirective(bool InConditional)
const char * getNameStart() const
Return the beginning of the actual null-terminated string for this identifier.
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2254
ObjCPropertyAttributeKind getPropertyAttributes() const
Definition: DeclSpec.h:831
static void AddOverloadParameterChunks(ASTContext &Context, const PrintingPolicy &Policy, const FunctionDecl *Function, const FunctionProtoType *Prototype, CodeCompletionBuilder &Result, unsigned CurrentArg, unsigned Start=0, bool InOptional=false)
Add function overload parameter chunks to the given code completion string.
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2301
One-argument selector.
static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC, Scope *S, Sema &SemaRef, ResultBuilder &Results)
Add language constructs that show up for "ordinary" names.
The result is a C++ non-static member function whose qualifiers exactly match the object type on whic...
bool hasDefaultArgument() const
Determine whether this template parameter has a default argument.
bool isAnyPointerType() const
Definition: Type.h:6117
bool isObjCObjectPointerType() const
Definition: Type.h:6210
static void CodeCompleteOverloadResults(Sema &SemaRef, Scope *S, MutableArrayRef< ResultCandidate > Candidates, unsigned CurrentArg, bool CompleteExpressionWithCurrentArg=true)
Represents a C++11 virt-specifier-seq.
Definition: DeclSpec.h:2488
CodeCompleteConsumer * CodeCompleter
Code-completion consumer.
Definition: Sema.h:328
The entity is available.
Definition: Index.h:135
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:748
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...
void addParentContext(const DeclContext *DC)
Add the parent context information to this code completion.
TypeClass getTypeClass() const
Definition: Type.h:1691
static void AddObjCVisibilityResults(const LangOptions &LangOpts, ResultBuilder &Results, bool NeedAt)
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: DeclObjC.h:299
bool isC99Varargs() const
Definition: MacroInfo.h:206
const ObjCMethodDecl * getMethodDecl() const
Definition: ExprObjC.h:1324
ObjCMethodKind
Describes the kind of Objective-C method that we want to find via code completion.
bool isStaticMember()
Returns true if this declares a static member.
Definition: DeclSpec.cpp:393
const char * getBriefComment() const
A C++ using declaration.
Definition: Index.h:1787
static bool anyNullArguments(ArrayRef< Expr *> Args)
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13...
Definition: Overload.h:830
ObjCImplementationDecl * getImplementation() const
Definition: DeclObjC.cpp:1503
llvm::SmallPtrSet< IdentifierInfo *, 16 > AddedPropertiesSet
The set of properties that have already been added, referenced by property name.
A C++ namespace.
Definition: Index.h:1761
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:194
__PTRDIFF_TYPE__ ptrdiff_t
A signed integer type that is the result of subtracting two pointers.
Definition: opencl-c.h:68
void CodeCompletePreprocessorMacroName(bool IsDefinition)
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2275
void addBriefComment(StringRef Comment)
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:4794
A C++ class template.
Definition: Index.h:1779
CodeCompletionTUInfo & getCodeCompletionTUInfo() const
CanProxy< U > getAs() const
Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed...
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: Decl.h:1592
StringRef getName() const
Return the actual identifier string.
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
Definition: ExprObjC.h:1228
The scope of a struct/union/class definition.
Definition: Scope.h:65
ObjCIvarDecl * getNextIvar()
Definition: DeclObjC.h:1999
bool isMacroDefined(StringRef Id)
Definition: Preprocessor.h:926
static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext, bool OnlyForwardDeclarations, ResultBuilder &Results)
Add all of the protocol declarations that we find in the given (translation unit) context...
Abstract interface for a consumer of code-completion information.
An Objective-C instance variable.
Definition: Index.h:1747
ParserCompletionContext
Describes the context in which code completion occurs.
Definition: Sema.h:10193
static bool isConstructor(const Decl *ND)
Dataflow Directional Tag Classes.
std::pair< IdentifierInfo *, SourceLocation > IdentifierLocPair
A simple pair of identifier info and location.
static const TSS TSS_unspecified
Definition: DeclSpec.h:266
LambdaCaptureDefault Default
Definition: DeclSpec.h:2562
ObjCPropertyDecl * FindPropertyDeclaration(const IdentifierInfo *PropertyId, ObjCPropertyQueryKind QueryKind) const
FindPropertyDeclaration - Finds declaration of the property given its name in &#39;PropertyId&#39; and return...
Definition: DeclObjC.cpp:229
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:1264
QualType getFullyQualifiedType(QualType QT, const ASTContext &Ctx, bool WithGlobalNsPrefix=false)
Generates a QualType that can be used to name the same type if used at the end of the current transla...
Priority for a declaration that is in the local scope.
bool isFunctionLike() const
Definition: MacroInfo.h:200
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
void CodeCompleteObjCMethodDeclSelector(Scope *S, bool IsInstanceMethod, bool AtParameterName, ParsedType ReturnType, ArrayRef< IdentifierInfo *> SelIdents)
static NestedNameSpecifier * getRequiredQualification(ASTContext &Context, const DeclContext *CurContext, const DeclContext *TargetContext)
Compute the qualification required to get from the current context (CurContext) to the target context...
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:225
A function or method parameter.
Definition: Index.h:1737
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition: TypeLoc.h:130
A C or C++ union.
Definition: Index.h:1720
bool isRecord() const
Definition: DeclBase.h:1417
Code completion occurred after the "struct" or "class" keyword, to indicate a struct or class name...
void CodeCompleteTag(Scope *S, unsigned TagSpec)
bool isDependent() const
Whether this nested name specifier refers to a dependent type or not.
AccessSpecifier getAccess() const
Definition: DeclBase.h:463
QualType stripObjCKindOfType(const ASTContext &ctx) const
Strip Objective-C "__kindof" types from the given type.
Definition: Type.cpp:1351
This is a scope that corresponds to the template parameters of a C++ template.
Definition: Scope.h:77
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...
static void AddTypeQualifierResults(DeclSpec &DS, ResultBuilder &Results, const LangOptions &LangOpts)
A builder class used to construct new code-completion strings.
Code completion where an Objective-C instance message is expected.
DeclarationName - The name of a declaration.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition: Type.h:988
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2165
bool isBooleanType() const
Definition: Type.h:6453
Kind getKind() const
Definition: DeclBase.h:422
Represents an enum.
Definition: Decl.h:3313
Divide by this factor when a code-completion result&#39;s type is similar to the type we expect (e...
const RawComment * getPatternCompletionComment(const ASTContext &Ctx, const NamedDecl *Decl)
Get the documentation comment used to produce CodeCompletionString::BriefComment for RK_Pattern...
static void addThisCompletion(Sema &S, ResultBuilder &Results)
Add a completion for "this", if we&#39;re in a member function.
static void HandleCodeCompleteResults(Sema *S, CodeCompleteConsumer *CodeCompleter, CodeCompletionContext Context, CodeCompletionResult *Results, unsigned NumResults)
Tags, declared with &#39;struct foo;&#39; and referenced with &#39;struct foo&#39;.
Definition: DeclBase.h:125
The result is in a base class.
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Definition: DeclBase.h:1608
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...
All of the names in this module are visible.
Definition: Module.h:271
static ObjCMethodDecl * AddSuperSendCompletion(Sema &S, bool NeedSuperKeyword, ArrayRef< IdentifierInfo *> SelIdents, ResultBuilder &Results)
void CodeCompleteNamespaceAliasDecl(Scope *S)
unsigned getNumParams() const
Definition: TypeLoc.h:1471
static void FindImplementableMethods(ASTContext &Context, ObjCContainerDecl *Container, Optional< bool > WantInstanceMethods, QualType ReturnType, KnownMethodsMap &KnownMethods, bool InOriginalClass=true)
Find all of the methods that reside in the given container (and its superclasses, protocols...
void CodeCompleteUsingDirective(Scope *S)
QualType getClassReceiver() const
Returns the type of a class message send, or NULL if the message is not a class message.
Definition: ExprObjC.h:1247
Represents a pointer to an Objective C object.
Definition: Type.h:5611
SwitchStmt - This represents a &#39;switch&#39; stmt.
Definition: Stmt.h:1054
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:40
Pointer to a block type.
Definition: Type.h:2495
bool SuppressUnwrittenScope
Suppress printing parts of scope specifiers that don&#39;t need to be written, e.g., for inline or anonym...
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2573
Not an overloaded operator.
Definition: OperatorKinds.h:23
void AddInformativeChunk(const char *Text)
Add a new informative chunk.
const UnresolvedSetImpl & asUnresolvedSet() const
Definition: Lookup.h:320
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4135
unsigned getTypeQualifiers() const
getTypeQualifiers - Return a set of TQs.
Definition: DeclSpec.h:549
static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy, const NamedDecl *ND, CodeCompletionBuilder &Result)
Add the name of the given declaration.
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:6374
A reference to a member of a struct, union, or class that occurs in some non-expression context...
Definition: Index.h:1835
QualType getBaseType() const
Retrieve the type of the base object in a member-access expression.
T * getAttr() const
Definition: DeclBase.h:534
A module import declaration.
Definition: Index.h:2577
CanQualType DependentTy
Definition: ASTContext.h:1033
void AddCurrentParameterChunk(const char *CurrentParameter)
Add a new current-parameter chunk.
A declaration whose specific kind is not exposed via this interface.
Definition: Index.h:1716
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:716
A piece of text that describes the parameter that corresponds to the code-completion location within ...
void CodeCompleteObjCForCollection(Scope *S, DeclGroupPtrTy IterationVar)
static const TST TST_typename
Definition: DeclSpec.h:297
param_const_iterator param_begin() const
Definition: DeclObjC.h:388
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2529
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1675
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2251
An Objective-C @dynamic definition.
Definition: Index.h:1793
void CodeCompleteObjCAtStatement(Scope *S)
bool isVolatile() const
Definition: Type.h:3378
qual_range quals() const
Definition: Type.h:5734
Optional< ArrayRef< QualType > > getObjCSubstitutions(const DeclContext *dc) const
Retrieve the set of substitutions required when accessing a member of the Objective-C receiver type t...
Definition: Type.cpp:1381
We are between inheritance colon and the real class/struct definition scope.
Definition: Scope.h:133
The "class" keyword.
Definition: Type.h:4858
Capturing the *this object by reference.
Definition: Lambda.h:35
An Objective-C class method.
Definition: Index.h:1751
void CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS, bool IsParameter)
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2543
friend bool operator!=(const iterator &X, const iterator &Y)
This is a scope that can contain a declaration.
Definition: Scope.h:59
SourceManager & getSourceManager()
Definition: ASTContext.h:651
bool isObjCObjectType() const
Definition: Type.h:6214
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
Definition: DeclBase.h:520
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2235
A left parenthesis (&#39;(&#39;).
An enumeration.
Definition: Index.h:1724
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:239
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1585
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:13820
const SwitchCase * getNextSwitchCase() const
Definition: Stmt.h:738
Code completion occurred within a preprocessor expression.
Code completion occurred where an expression is expected.
const ObjCPropertyDecl * findPropertyDecl(bool CheckOverrides=true) const
Returns the property associated with this method&#39;s selector.
Definition: DeclObjC.cpp:1256
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
QualType getParamType(unsigned i) const
Definition: Type.h:3670
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:997
static bool isInstanceMethod(const Decl *D)
Captures information about "declaration specifiers".
Definition: DeclSpec.h:228
Code completion occurs at the beginning of the initialization statement (or expression) in a for loop...
Definition: Sema.h:10220
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5969
Represents a C++ struct/union/class.
Definition: DeclCXX.h:302
Priority for a nested-name-specifier.
An Objective-C @implementation.
Definition: Index.h:1753
bool isVoidType() const
Definition: Type.h:6340
CodeCompleteExpressionData(QualType PreferredType=QualType())
static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext, ResultBuilder &Results)
If we&#39;re in a C++ virtual member function, add completion results that invoke the functions we overri...
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1331
static bool hasAnyTypeDependentArguments(ArrayRef< Expr *> Exprs)
hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.
Definition: Expr.cpp:2824
void CodeCompletePostfixExpression(Scope *S, ExprResult LHS)
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5916
The parameter type of a method or function.
The selector of the given message exactly matches the selector of the current method, which might imply that some kind of delegation is occurring.
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1966
A left angle bracket (&#39;<&#39;).
QualType getSendResultType() const
Determine the type of an expression that sends a message to this function.
Definition: DeclObjC.cpp:1117
void setCXXScopeSpecifier(CXXScopeSpec SS)
Sets the scope specifier that comes before the completion token.
A right angle bracket (&#39;>&#39;).
bool isNull() const
Determine whether this is the empty selector.
Adjustment for KVC code pattern priorities when it doesn&#39;t look like the.
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:331
The "enum" keyword.
Definition: Type.h:4861
Cursor that represents the translation unit itself.
Definition: Index.h:2533
Declaration of a class template.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:129
This class is used for builtin types like &#39;int&#39;.
Definition: Type.h:2250
bool isVariadic() const
Definition: DeclObjC.h:456
The receiver is a class.
Definition: ExprObjC.h:1073
SourceRange getDefaultArgRange() const
Retrieve the source range that covers the entire default argument.
Definition: Decl.cpp:2556
ParsedType getRepAsType() const
Definition: DeclSpec.h:492
void GatherGlobalCodeCompletions(CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo, SmallVectorImpl< CodeCompletionResult > &Results)
Vertical whitespace (&#39;\n&#39; or &#39;\r\n&#39;, depending on the platform).
Represents a complete lambda introducer.
Definition: DeclSpec.h:2538
a linked list of methods with the same selector name but different signatures.
static std::string FormatFunctionParameter(const PrintingPolicy &Policy, const ParmVarDecl *Param, bool SuppressName=false, bool SuppressBlock=false, Optional< ArrayRef< QualType >> ObjCSubsts=None)
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:275
bool AnonymousTagLocations
When printing an anonymous tag name, also print the location of that entity (e.g., "enum <anonymous at t.h:10:5>").
static Qualifiers fromCVRMask(unsigned CVR)
Definition: Type.h:247
LLVM_READONLY char toUppercase(char c)
Converts the given ASCII character to its uppercase equivalent.
Definition: CharInfo.h:174
static enum CodeCompletionContext::Kind mapCodeCompletionContext(Sema &S, Sema::ParserCompletionContext PCC)
static void AddObjCPassingTypeChunk(QualType Type, unsigned ObjCDeclQuals, ASTContext &Context, const PrintingPolicy &Policy, CodeCompletionBuilder &Builder)
Add the parenthesized return or parameter type chunk to a code completion string. ...
MacroMap::const_iterator macro_iterator
static OpaquePtr make(QualType P)
Definition: Ownership.h:61
The top declaration context.
Definition: Decl.h:107
static void AddObjCImplementationResults(const LangOptions &LangOpts, ResultBuilder &Results, bool NeedAt)
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1942
static void AddTemplateParameterChunks(ASTContext &Context, const PrintingPolicy &Policy, const TemplateDecl *Template, CodeCompletionBuilder &Result, unsigned MaxParameters=0, unsigned Start=0, bool InDefaultArg=false)
Add template parameter chunks to the given code completion string.
This declaration is a function-local extern declaration of a variable or function.
Definition: DeclBase.h:175
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:974
const Scope * getFnParent() const
getFnParent - Return the closest scope that is a function body.
Definition: Scope.h:229
Code completion occurred on the right-hand side of a member access expression using the dot operator...
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4654
Code completion occurs within the condition of an if, while, switch, or for statement.
Definition: Sema.h:10223
SimplifiedTypeClass
A simplified classification of types used when determining "similar" types for code completion...
static bool isNamespaceScope(Scope *S)
Determine whether this scope denotes a namespace.
void AddPlaceholderChunk(const char *Placeholder)
Add a new placeholder chunk.
static std::string GetDefaultValueString(const ParmVarDecl *Param, const SourceManager &SM, const LangOptions &LangOpts)
Code completion occurred where a type name is expected.
__DEVICE__ int min(int __a, int __b)
Horizontal whitespace (&#39; &#39;).
SourceManager & SourceMgr
Definition: Sema.h:322
void CodeCompleteObjCImplementationDecl(Scope *S)
bool includeCodePatterns() const
Whether the code-completion consumer wants to see code patterns.
static const TST TST_struct
Definition: DeclSpec.h:294
DeclaratorContext getContext() const
Definition: DeclSpec.h:1866
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Lookup.h:572
QualType getType() const
Definition: Decl.h:648
A function.
Definition: Index.h:1733
A trivial tuple used to represent a source range.
ObjCMethodDecl * getMethod(Selector Sel, bool isInstance, bool AllowHidden=false) const
Definition: DeclObjC.cpp:85
ASTContext & Context
Definition: Sema.h:319
static void mergeCandidatesWithResults(Sema &SemaRef, SmallVectorImpl< ResultCandidate > &Results, OverloadCandidateSet &CandidateSet, SourceLocation Loc)
ObjCMethodDecl * getGetterMethodDecl() const
Definition: DeclObjC.h:941
This represents a decl that may have a name.
Definition: Decl.h:248
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
Definition: DeclObjC.cpp:1546
QualType getObjCObjectPointerType(QualType OIT) const
Return a ObjCObjectPointerType type for the given ObjCObjectType.
bool isTranslationUnit() const
Definition: DeclBase.h:1413
#define OBJC_AT_KEYWORD_NAME(NeedAt, Keyword)
Macro that optionally prepends an "@" to the string literal passed in via Keyword, depending on whether NeedAt is true or false.
friend bool operator==(const iterator &X, const iterator &Y)
llvm::DenseMap< const Stmt *, CFGBlock * > SMap
Definition: CFGStmtMap.cpp:22
bool isPropertyAccessor() const
Definition: DeclObjC.h:461
Priority for a code pattern.
An Objective-C @interface.
Definition: Index.h:1739
Selector getGetterName() const
Definition: DeclObjC.h:925
A C++ conversion function.
Definition: Index.h:1769
const Expr * getCond() const
Definition: Stmt.h:1092
The receiver is a superclass.
Definition: ExprObjC.h:1079
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:2971
void CodeCompleteAfterIf(Scope *S)
const LangOptions & getLangOpts() const
Definition: ASTContext.h:696
Wrapper for source info for block pointers.
Definition: TypeLoc.h:1284
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2520
base_class_range vbases()
Definition: DeclCXX.h:842
This class handles loading and caching of source files into memory.
Declaration of a template function.
Definition: DeclTemplate.h:968
Code completion occurs in a parenthesized expression, which might also be a type cast.
Definition: Sema.h:10232
void CodeCompleteInPreprocessorConditionalExclusion(Scope *S)
void CodeCompleteObjCProtocolDecl(Scope *S)
SourceLocation getLocation() const
Definition: DeclBase.h:419
const RawComment * getRawCommentForAnyRedecl(const Decl *D, const Decl **OriginalDecl=nullptr) const
Return the documentation comment attached to a given declaration.
Definition: ASTContext.cpp:381
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:3147
static QualType getParamType(Sema &SemaRef, ArrayRef< ResultCandidate > Candidates, unsigned N)
Get the type of the Nth parameter from a given set of overload candidates.
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:407
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:127
decl_iterator decls_end() const
Definition: DeclBase.h:1590
Priority for an enumeration constant inside a switch whose condition is of the enumeration type...
bool includeGlobals() const
Whether to include global (top-level) declaration results.
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
getCXXOperatorName - Get the name of the overloadable C++ operator corresponding to Op...