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