clang  3.9.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 
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 
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.
530  if (ND->getFriendObjectKind() == Decl::FOK_Undeclared)
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();
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) {
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() &&
894  (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary |
895  Decl::IDNS_LocalExtern | Decl::IDNS_ObjCProtocol)))
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)
1060  IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
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)
1078  IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member;
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)
1105  IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace;
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  }
1338 
1339  // GNU extensions
1340  if (LangOpts.GNUMode) {
1341  // FIXME: Enable when we actually support decimal floating point.
1342  // Results.AddResult(Result("_Decimal32"));
1343  // Results.AddResult(Result("_Decimal64"));
1344  // Results.AddResult(Result("_Decimal128"));
1345 
1346  Builder.AddTypedTextChunk("typeof");
1348  Builder.AddPlaceholderChunk("expression");
1349  Results.AddResult(Result(Builder.TakeString()));
1350 
1351  Builder.AddTypedTextChunk("typeof");
1353  Builder.AddPlaceholderChunk("type");
1355  Results.AddResult(Result(Builder.TakeString()));
1356  }
1357 
1358  // Nullability
1359  Results.AddResult(Result("_Nonnull", CCP_Type));
1360  Results.AddResult(Result("_Null_unspecified", CCP_Type));
1361  Results.AddResult(Result("_Nullable", CCP_Type));
1362 }
1363 
1365  const LangOptions &LangOpts,
1366  ResultBuilder &Results) {
1367  typedef CodeCompletionResult Result;
1368  // Note: we don't suggest either "auto" or "register", because both
1369  // are pointless as storage specifiers. Elsewhere, we suggest "auto"
1370  // in C++0x as a type specifier.
1371  Results.AddResult(Result("extern"));
1372  Results.AddResult(Result("static"));
1373 }
1374 
1376  const LangOptions &LangOpts,
1377  ResultBuilder &Results) {
1378  typedef CodeCompletionResult Result;
1379  switch (CCC) {
1380  case Sema::PCC_Class:
1382  if (LangOpts.CPlusPlus) {
1383  Results.AddResult(Result("explicit"));
1384  Results.AddResult(Result("friend"));
1385  Results.AddResult(Result("mutable"));
1386  Results.AddResult(Result("virtual"));
1387  }
1388  // Fall through
1389 
1392  case Sema::PCC_Namespace:
1393  case Sema::PCC_Template:
1394  if (LangOpts.CPlusPlus || LangOpts.C99)
1395  Results.AddResult(Result("inline"));
1396  break;
1397 
1399  case Sema::PCC_Expression:
1400  case Sema::PCC_Statement:
1401  case Sema::PCC_ForInit:
1402  case Sema::PCC_Condition:
1404  case Sema::PCC_Type:
1407  break;
1408  }
1409 }
1410 
1411 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt);
1412 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt);
1413 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
1414  ResultBuilder &Results,
1415  bool NeedAt);
1416 static void AddObjCImplementationResults(const LangOptions &LangOpts,
1417  ResultBuilder &Results,
1418  bool NeedAt);
1419 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
1420  ResultBuilder &Results,
1421  bool NeedAt);
1422 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt);
1423 
1424 static void AddTypedefResult(ResultBuilder &Results) {
1425  CodeCompletionBuilder Builder(Results.getAllocator(),
1426  Results.getCodeCompletionTUInfo());
1427  Builder.AddTypedTextChunk("typedef");
1429  Builder.AddPlaceholderChunk("type");
1431  Builder.AddPlaceholderChunk("name");
1432  Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1433 }
1434 
1436  const LangOptions &LangOpts) {
1437  switch (CCC) {
1438  case Sema::PCC_Namespace:
1439  case Sema::PCC_Class:
1441  case Sema::PCC_Template:
1443  case Sema::PCC_Statement:
1445  case Sema::PCC_Type:
1448  return true;
1449 
1450  case Sema::PCC_Expression:
1451  case Sema::PCC_Condition:
1452  return LangOpts.CPlusPlus;
1453 
1456  return false;
1457 
1458  case Sema::PCC_ForInit:
1459  return LangOpts.CPlusPlus || LangOpts.ObjC1 || LangOpts.C99;
1460  }
1461 
1462  llvm_unreachable("Invalid ParserCompletionContext!");
1463 }
1464 
1466  const Preprocessor &PP) {
1467  PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP);
1468  Policy.AnonymousTagLocations = false;
1469  Policy.SuppressStrongLifetime = true;
1470  Policy.SuppressUnwrittenScope = true;
1471  return Policy;
1472 }
1473 
1474 /// \brief Retrieve a printing policy suitable for code completion.
1476  return getCompletionPrintingPolicy(S.Context, S.PP);
1477 }
1478 
1479 /// \brief Retrieve the string representation of the given type as a string
1480 /// that has the appropriate lifetime for code completion.
1481 ///
1482 /// This routine provides a fast path where we provide constant strings for
1483 /// common type names.
1484 static const char *GetCompletionTypeString(QualType T,
1485  ASTContext &Context,
1486  const PrintingPolicy &Policy,
1487  CodeCompletionAllocator &Allocator) {
1488  if (!T.getLocalQualifiers()) {
1489  // Built-in type names are constant strings.
1490  if (const BuiltinType *BT = dyn_cast<BuiltinType>(T))
1491  return BT->getNameAsCString(Policy);
1492 
1493  // Anonymous tag types are constant strings.
1494  if (const TagType *TagT = dyn_cast<TagType>(T))
1495  if (TagDecl *Tag = TagT->getDecl())
1496  if (!Tag->hasNameForLinkage()) {
1497  switch (Tag->getTagKind()) {
1498  case TTK_Struct: return "struct <anonymous>";
1499  case TTK_Interface: return "__interface <anonymous>";
1500  case TTK_Class: return "class <anonymous>";
1501  case TTK_Union: return "union <anonymous>";
1502  case TTK_Enum: return "enum <anonymous>";
1503  }
1504  }
1505  }
1506 
1507  // Slow path: format the type as a string.
1508  std::string Result;
1509  T.getAsStringInternal(Result, Policy);
1510  return Allocator.CopyString(Result);
1511 }
1512 
1513 /// \brief Add a completion for "this", if we're in a member function.
1514 static void addThisCompletion(Sema &S, ResultBuilder &Results) {
1515  QualType ThisTy = S.getCurrentThisType();
1516  if (ThisTy.isNull())
1517  return;
1518 
1519  CodeCompletionAllocator &Allocator = Results.getAllocator();
1520  CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1522  Builder.AddResultTypeChunk(GetCompletionTypeString(ThisTy,
1523  S.Context,
1524  Policy,
1525  Allocator));
1526  Builder.AddTypedTextChunk("this");
1527  Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1528 }
1529 
1530 /// \brief Add language constructs that show up for "ordinary" names.
1532  Scope *S,
1533  Sema &SemaRef,
1534  ResultBuilder &Results) {
1535  CodeCompletionAllocator &Allocator = Results.getAllocator();
1536  CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1537 
1538  typedef CodeCompletionResult Result;
1539  switch (CCC) {
1540  case Sema::PCC_Namespace:
1541  if (SemaRef.getLangOpts().CPlusPlus) {
1542  if (Results.includeCodePatterns()) {
1543  // namespace <identifier> { declarations }
1544  Builder.AddTypedTextChunk("namespace");
1546  Builder.AddPlaceholderChunk("identifier");
1548  Builder.AddPlaceholderChunk("declarations");
1551  Results.AddResult(Result(Builder.TakeString()));
1552  }
1553 
1554  // namespace identifier = identifier ;
1555  Builder.AddTypedTextChunk("namespace");
1557  Builder.AddPlaceholderChunk("name");
1559  Builder.AddPlaceholderChunk("namespace");
1560  Results.AddResult(Result(Builder.TakeString()));
1561 
1562  // Using directives
1563  Builder.AddTypedTextChunk("using");
1565  Builder.AddTextChunk("namespace");
1567  Builder.AddPlaceholderChunk("identifier");
1568  Results.AddResult(Result(Builder.TakeString()));
1569 
1570  // asm(string-literal)
1571  Builder.AddTypedTextChunk("asm");
1573  Builder.AddPlaceholderChunk("string-literal");
1575  Results.AddResult(Result(Builder.TakeString()));
1576 
1577  if (Results.includeCodePatterns()) {
1578  // Explicit template instantiation
1579  Builder.AddTypedTextChunk("template");
1581  Builder.AddPlaceholderChunk("declaration");
1582  Results.AddResult(Result(Builder.TakeString()));
1583  }
1584  }
1585 
1586  if (SemaRef.getLangOpts().ObjC1)
1587  AddObjCTopLevelResults(Results, true);
1588 
1589  AddTypedefResult(Results);
1590  // Fall through
1591 
1592  case Sema::PCC_Class:
1593  if (SemaRef.getLangOpts().CPlusPlus) {
1594  // Using declaration
1595  Builder.AddTypedTextChunk("using");
1597  Builder.AddPlaceholderChunk("qualifier");
1598  Builder.AddTextChunk("::");
1599  Builder.AddPlaceholderChunk("name");
1600  Results.AddResult(Result(Builder.TakeString()));
1601 
1602  // using typename qualifier::name (only in a dependent context)
1603  if (SemaRef.CurContext->isDependentContext()) {
1604  Builder.AddTypedTextChunk("using");
1606  Builder.AddTextChunk("typename");
1608  Builder.AddPlaceholderChunk("qualifier");
1609  Builder.AddTextChunk("::");
1610  Builder.AddPlaceholderChunk("name");
1611  Results.AddResult(Result(Builder.TakeString()));
1612  }
1613 
1614  if (CCC == Sema::PCC_Class) {
1615  AddTypedefResult(Results);
1616 
1617  // public:
1618  Builder.AddTypedTextChunk("public");
1619  if (Results.includeCodePatterns())
1621  Results.AddResult(Result(Builder.TakeString()));
1622 
1623  // protected:
1624  Builder.AddTypedTextChunk("protected");
1625  if (Results.includeCodePatterns())
1627  Results.AddResult(Result(Builder.TakeString()));
1628 
1629  // private:
1630  Builder.AddTypedTextChunk("private");
1631  if (Results.includeCodePatterns())
1633  Results.AddResult(Result(Builder.TakeString()));
1634  }
1635  }
1636  // Fall through
1637 
1638  case Sema::PCC_Template:
1640  if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) {
1641  // template < parameters >
1642  Builder.AddTypedTextChunk("template");
1644  Builder.AddPlaceholderChunk("parameters");
1646  Results.AddResult(Result(Builder.TakeString()));
1647  }
1648 
1649  AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1650  AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1651  break;
1652 
1654  AddObjCInterfaceResults(SemaRef.getLangOpts(), Results, true);
1655  AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1656  AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1657  break;
1658 
1660  AddObjCImplementationResults(SemaRef.getLangOpts(), Results, true);
1661  AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1662  AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1663  break;
1664 
1666  AddObjCVisibilityResults(SemaRef.getLangOpts(), Results, true);
1667  break;
1668 
1670  case Sema::PCC_Statement: {
1671  AddTypedefResult(Results);
1672 
1673  if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns() &&
1674  SemaRef.getLangOpts().CXXExceptions) {
1675  Builder.AddTypedTextChunk("try");
1677  Builder.AddPlaceholderChunk("statements");
1680  Builder.AddTextChunk("catch");
1682  Builder.AddPlaceholderChunk("declaration");
1685  Builder.AddPlaceholderChunk("statements");
1688  Results.AddResult(Result(Builder.TakeString()));
1689  }
1690  if (SemaRef.getLangOpts().ObjC1)
1691  AddObjCStatementResults(Results, true);
1692 
1693  if (Results.includeCodePatterns()) {
1694  // if (condition) { statements }
1695  Builder.AddTypedTextChunk("if");
1697  if (SemaRef.getLangOpts().CPlusPlus)
1698  Builder.AddPlaceholderChunk("condition");
1699  else
1700  Builder.AddPlaceholderChunk("expression");
1703  Builder.AddPlaceholderChunk("statements");
1706  Results.AddResult(Result(Builder.TakeString()));
1707 
1708  // switch (condition) { }
1709  Builder.AddTypedTextChunk("switch");
1711  if (SemaRef.getLangOpts().CPlusPlus)
1712  Builder.AddPlaceholderChunk("condition");
1713  else
1714  Builder.AddPlaceholderChunk("expression");
1719  Results.AddResult(Result(Builder.TakeString()));
1720  }
1721 
1722  // Switch-specific statements.
1723  if (!SemaRef.getCurFunction()->SwitchStack.empty()) {
1724  // case expression:
1725  Builder.AddTypedTextChunk("case");
1727  Builder.AddPlaceholderChunk("expression");
1729  Results.AddResult(Result(Builder.TakeString()));
1730 
1731  // default:
1732  Builder.AddTypedTextChunk("default");
1734  Results.AddResult(Result(Builder.TakeString()));
1735  }
1736 
1737  if (Results.includeCodePatterns()) {
1738  /// while (condition) { statements }
1739  Builder.AddTypedTextChunk("while");
1741  if (SemaRef.getLangOpts().CPlusPlus)
1742  Builder.AddPlaceholderChunk("condition");
1743  else
1744  Builder.AddPlaceholderChunk("expression");
1747  Builder.AddPlaceholderChunk("statements");
1750  Results.AddResult(Result(Builder.TakeString()));
1751 
1752  // do { statements } while ( expression );
1753  Builder.AddTypedTextChunk("do");
1755  Builder.AddPlaceholderChunk("statements");
1758  Builder.AddTextChunk("while");
1760  Builder.AddPlaceholderChunk("expression");
1762  Results.AddResult(Result(Builder.TakeString()));
1763 
1764  // for ( for-init-statement ; condition ; expression ) { statements }
1765  Builder.AddTypedTextChunk("for");
1767  if (SemaRef.getLangOpts().CPlusPlus || SemaRef.getLangOpts().C99)
1768  Builder.AddPlaceholderChunk("init-statement");
1769  else
1770  Builder.AddPlaceholderChunk("init-expression");
1772  Builder.AddPlaceholderChunk("condition");
1774  Builder.AddPlaceholderChunk("inc-expression");
1778  Builder.AddPlaceholderChunk("statements");
1781  Results.AddResult(Result(Builder.TakeString()));
1782  }
1783 
1784  if (S->getContinueParent()) {
1785  // continue ;
1786  Builder.AddTypedTextChunk("continue");
1787  Results.AddResult(Result(Builder.TakeString()));
1788  }
1789 
1790  if (S->getBreakParent()) {
1791  // break ;
1792  Builder.AddTypedTextChunk("break");
1793  Results.AddResult(Result(Builder.TakeString()));
1794  }
1795 
1796  // "return expression ;" or "return ;", depending on whether we
1797  // know the function is void or not.
1798  bool isVoid = false;
1799  if (FunctionDecl *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext))
1800  isVoid = Function->getReturnType()->isVoidType();
1801  else if (ObjCMethodDecl *Method
1802  = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext))
1803  isVoid = Method->getReturnType()->isVoidType();
1804  else if (SemaRef.getCurBlock() &&
1805  !SemaRef.getCurBlock()->ReturnType.isNull())
1806  isVoid = SemaRef.getCurBlock()->ReturnType->isVoidType();
1807  Builder.AddTypedTextChunk("return");
1808  if (!isVoid) {
1810  Builder.AddPlaceholderChunk("expression");
1811  }
1812  Results.AddResult(Result(Builder.TakeString()));
1813 
1814  // goto identifier ;
1815  Builder.AddTypedTextChunk("goto");
1817  Builder.AddPlaceholderChunk("label");
1818  Results.AddResult(Result(Builder.TakeString()));
1819 
1820  // Using directives
1821  Builder.AddTypedTextChunk("using");
1823  Builder.AddTextChunk("namespace");
1825  Builder.AddPlaceholderChunk("identifier");
1826  Results.AddResult(Result(Builder.TakeString()));
1827  }
1828 
1829  // Fall through (for statement expressions).
1830  case Sema::PCC_ForInit:
1831  case Sema::PCC_Condition:
1832  AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1833  // Fall through: conditions and statements can have expressions.
1834 
1836  if (SemaRef.getLangOpts().ObjCAutoRefCount &&
1838  // (__bridge <type>)<expression>
1839  Builder.AddTypedTextChunk("__bridge");
1841  Builder.AddPlaceholderChunk("type");
1843  Builder.AddPlaceholderChunk("expression");
1844  Results.AddResult(Result(Builder.TakeString()));
1845 
1846  // (__bridge_transfer <Objective-C type>)<expression>
1847  Builder.AddTypedTextChunk("__bridge_transfer");
1849  Builder.AddPlaceholderChunk("Objective-C type");
1851  Builder.AddPlaceholderChunk("expression");
1852  Results.AddResult(Result(Builder.TakeString()));
1853 
1854  // (__bridge_retained <CF type>)<expression>
1855  Builder.AddTypedTextChunk("__bridge_retained");
1857  Builder.AddPlaceholderChunk("CF type");
1859  Builder.AddPlaceholderChunk("expression");
1860  Results.AddResult(Result(Builder.TakeString()));
1861  }
1862  // Fall through
1863 
1864  case Sema::PCC_Expression: {
1865  if (SemaRef.getLangOpts().CPlusPlus) {
1866  // 'this', if we're in a non-static member function.
1867  addThisCompletion(SemaRef, Results);
1868 
1869  // true
1870  Builder.AddResultTypeChunk("bool");
1871  Builder.AddTypedTextChunk("true");
1872  Results.AddResult(Result(Builder.TakeString()));
1873 
1874  // false
1875  Builder.AddResultTypeChunk("bool");
1876  Builder.AddTypedTextChunk("false");
1877  Results.AddResult(Result(Builder.TakeString()));
1878 
1879  if (SemaRef.getLangOpts().RTTI) {
1880  // dynamic_cast < type-id > ( expression )
1881  Builder.AddTypedTextChunk("dynamic_cast");
1883  Builder.AddPlaceholderChunk("type");
1886  Builder.AddPlaceholderChunk("expression");
1888  Results.AddResult(Result(Builder.TakeString()));
1889  }
1890 
1891  // static_cast < type-id > ( expression )
1892  Builder.AddTypedTextChunk("static_cast");
1894  Builder.AddPlaceholderChunk("type");
1897  Builder.AddPlaceholderChunk("expression");
1899  Results.AddResult(Result(Builder.TakeString()));
1900 
1901  // reinterpret_cast < type-id > ( expression )
1902  Builder.AddTypedTextChunk("reinterpret_cast");
1904  Builder.AddPlaceholderChunk("type");
1907  Builder.AddPlaceholderChunk("expression");
1909  Results.AddResult(Result(Builder.TakeString()));
1910 
1911  // const_cast < type-id > ( expression )
1912  Builder.AddTypedTextChunk("const_cast");
1914  Builder.AddPlaceholderChunk("type");
1917  Builder.AddPlaceholderChunk("expression");
1919  Results.AddResult(Result(Builder.TakeString()));
1920 
1921  if (SemaRef.getLangOpts().RTTI) {
1922  // typeid ( expression-or-type )
1923  Builder.AddResultTypeChunk("std::type_info");
1924  Builder.AddTypedTextChunk("typeid");
1926  Builder.AddPlaceholderChunk("expression-or-type");
1928  Results.AddResult(Result(Builder.TakeString()));
1929  }
1930 
1931  // new T ( ... )
1932  Builder.AddTypedTextChunk("new");
1934  Builder.AddPlaceholderChunk("type");
1936  Builder.AddPlaceholderChunk("expressions");
1938  Results.AddResult(Result(Builder.TakeString()));
1939 
1940  // new T [ ] ( ... )
1941  Builder.AddTypedTextChunk("new");
1943  Builder.AddPlaceholderChunk("type");
1945  Builder.AddPlaceholderChunk("size");
1948  Builder.AddPlaceholderChunk("expressions");
1950  Results.AddResult(Result(Builder.TakeString()));
1951 
1952  // delete expression
1953  Builder.AddResultTypeChunk("void");
1954  Builder.AddTypedTextChunk("delete");
1956  Builder.AddPlaceholderChunk("expression");
1957  Results.AddResult(Result(Builder.TakeString()));
1958 
1959  // delete [] expression
1960  Builder.AddResultTypeChunk("void");
1961  Builder.AddTypedTextChunk("delete");
1966  Builder.AddPlaceholderChunk("expression");
1967  Results.AddResult(Result(Builder.TakeString()));
1968 
1969  if (SemaRef.getLangOpts().CXXExceptions) {
1970  // throw expression
1971  Builder.AddResultTypeChunk("void");
1972  Builder.AddTypedTextChunk("throw");
1974  Builder.AddPlaceholderChunk("expression");
1975  Results.AddResult(Result(Builder.TakeString()));
1976  }
1977 
1978  // FIXME: Rethrow?
1979 
1980  if (SemaRef.getLangOpts().CPlusPlus11) {
1981  // nullptr
1982  Builder.AddResultTypeChunk("std::nullptr_t");
1983  Builder.AddTypedTextChunk("nullptr");
1984  Results.AddResult(Result(Builder.TakeString()));
1985 
1986  // alignof
1987  Builder.AddResultTypeChunk("size_t");
1988  Builder.AddTypedTextChunk("alignof");
1990  Builder.AddPlaceholderChunk("type");
1992  Results.AddResult(Result(Builder.TakeString()));
1993 
1994  // noexcept
1995  Builder.AddResultTypeChunk("bool");
1996  Builder.AddTypedTextChunk("noexcept");
1998  Builder.AddPlaceholderChunk("expression");
2000  Results.AddResult(Result(Builder.TakeString()));
2001 
2002  // sizeof... expression
2003  Builder.AddResultTypeChunk("size_t");
2004  Builder.AddTypedTextChunk("sizeof...");
2006  Builder.AddPlaceholderChunk("parameter-pack");
2008  Results.AddResult(Result(Builder.TakeString()));
2009  }
2010  }
2011 
2012  if (SemaRef.getLangOpts().ObjC1) {
2013  // Add "super", if we're in an Objective-C class with a superclass.
2014  if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
2015  // The interface can be NULL.
2016  if (ObjCInterfaceDecl *ID = Method->getClassInterface())
2017  if (ID->getSuperClass()) {
2018  std::string SuperType;
2019  SuperType = ID->getSuperClass()->getNameAsString();
2020  if (Method->isInstanceMethod())
2021  SuperType += " *";
2022 
2023  Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
2024  Builder.AddTypedTextChunk("super");
2025  Results.AddResult(Result(Builder.TakeString()));
2026  }
2027  }
2028 
2029  AddObjCExpressionResults(Results, true);
2030  }
2031 
2032  if (SemaRef.getLangOpts().C11) {
2033  // _Alignof
2034  Builder.AddResultTypeChunk("size_t");
2035  if (SemaRef.PP.isMacroDefined("alignof"))
2036  Builder.AddTypedTextChunk("alignof");
2037  else
2038  Builder.AddTypedTextChunk("_Alignof");
2040  Builder.AddPlaceholderChunk("type");
2042  Results.AddResult(Result(Builder.TakeString()));
2043  }
2044 
2045  // sizeof expression
2046  Builder.AddResultTypeChunk("size_t");
2047  Builder.AddTypedTextChunk("sizeof");
2049  Builder.AddPlaceholderChunk("expression-or-type");
2051  Results.AddResult(Result(Builder.TakeString()));
2052  break;
2053  }
2054 
2055  case Sema::PCC_Type:
2057  break;
2058  }
2059 
2060  if (WantTypesInContext(CCC, SemaRef.getLangOpts()))
2061  AddTypeSpecifierResults(SemaRef.getLangOpts(), Results);
2062 
2063  if (SemaRef.getLangOpts().CPlusPlus && CCC != Sema::PCC_Type)
2064  Results.AddResult(Result("operator"));
2065 }
2066 
2067 /// \brief If the given declaration has an associated type, add it as a result
2068 /// type chunk.
2069 static void AddResultTypeChunk(ASTContext &Context,
2070  const PrintingPolicy &Policy,
2071  const NamedDecl *ND,
2072  QualType BaseType,
2073  CodeCompletionBuilder &Result) {
2074  if (!ND)
2075  return;
2076 
2077  // Skip constructors and conversion functions, which have their return types
2078  // built into their names.
2079  if (isa<CXXConstructorDecl>(ND) || isa<CXXConversionDecl>(ND))
2080  return;
2081 
2082  // Determine the type of the declaration (if it has a type).
2083  QualType T;
2084  if (const FunctionDecl *Function = ND->getAsFunction())
2085  T = Function->getReturnType();
2086  else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2087  if (!BaseType.isNull())
2088  T = Method->getSendResultType(BaseType);
2089  else
2090  T = Method->getReturnType();
2091  } else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
2092  T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
2093  else if (isa<UnresolvedUsingValueDecl>(ND)) {
2094  /* Do nothing: ignore unresolved using declarations*/
2095  } else if (const ObjCIvarDecl *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
2096  if (!BaseType.isNull())
2097  T = Ivar->getUsageType(BaseType);
2098  else
2099  T = Ivar->getType();
2100  } else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND)) {
2101  T = Value->getType();
2102  } else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND)) {
2103  if (!BaseType.isNull())
2104  T = Property->getUsageType(BaseType);
2105  else
2106  T = Property->getType();
2107  }
2108 
2109  if (T.isNull() || Context.hasSameType(T, Context.DependentTy))
2110  return;
2111 
2112  Result.AddResultTypeChunk(GetCompletionTypeString(T, Context, Policy,
2113  Result.getAllocator()));
2114 }
2115 
2117  const NamedDecl *FunctionOrMethod,
2118  CodeCompletionBuilder &Result) {
2119  if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>())
2120  if (Sentinel->getSentinel() == 0) {
2121  if (PP.getLangOpts().ObjC1 && PP.isMacroDefined("nil"))
2122  Result.AddTextChunk(", nil");
2123  else if (PP.isMacroDefined("NULL"))
2124  Result.AddTextChunk(", NULL");
2125  else
2126  Result.AddTextChunk(", (void*)0");
2127  }
2128 }
2129 
2130 static std::string formatObjCParamQualifiers(unsigned ObjCQuals,
2131  QualType &Type) {
2132  std::string Result;
2133  if (ObjCQuals & Decl::OBJC_TQ_In)
2134  Result += "in ";
2135  else if (ObjCQuals & Decl::OBJC_TQ_Inout)
2136  Result += "inout ";
2137  else if (ObjCQuals & Decl::OBJC_TQ_Out)
2138  Result += "out ";
2139  if (ObjCQuals & Decl::OBJC_TQ_Bycopy)
2140  Result += "bycopy ";
2141  else if (ObjCQuals & Decl::OBJC_TQ_Byref)
2142  Result += "byref ";
2143  if (ObjCQuals & Decl::OBJC_TQ_Oneway)
2144  Result += "oneway ";
2145  if (ObjCQuals & Decl::OBJC_TQ_CSNullability) {
2146  if (auto nullability = AttributedType::stripOuterNullability(Type)) {
2147  switch (*nullability) {
2149  Result += "nonnull ";
2150  break;
2151 
2153  Result += "nullable ";
2154  break;
2155 
2157  Result += "null_unspecified ";
2158  break;
2159  }
2160  }
2161  }
2162  return Result;
2163 }
2164 
2165 static std::string FormatFunctionParameter(const PrintingPolicy &Policy,
2166  const ParmVarDecl *Param,
2167  bool SuppressName = false,
2168  bool SuppressBlock = false,
2169  Optional<ArrayRef<QualType>> ObjCSubsts = None) {
2170  bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
2171  if (Param->getType()->isDependentType() ||
2172  !Param->getType()->isBlockPointerType()) {
2173  // The argument for a dependent or non-block parameter is a placeholder
2174  // containing that parameter's type.
2175  std::string Result;
2176 
2177  if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
2178  Result = Param->getIdentifier()->getName();
2179 
2180  QualType Type = Param->getType();
2181  if (ObjCSubsts)
2182  Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts,
2184  if (ObjCMethodParam) {
2185  Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(),
2186  Type);
2187  Result += Type.getAsString(Policy) + ")";
2188  if (Param->getIdentifier() && !SuppressName)
2189  Result += Param->getIdentifier()->getName();
2190  } else {
2191  Type.getAsStringInternal(Result, Policy);
2192  }
2193  return Result;
2194  }
2195 
2196  // The argument for a block pointer parameter is a block literal with
2197  // the appropriate type.
2198  FunctionTypeLoc Block;
2199  FunctionProtoTypeLoc BlockProto;
2200  TypeLoc TL;
2201  if (TypeSourceInfo *TSInfo = Param->getTypeSourceInfo()) {
2202  TL = TSInfo->getTypeLoc().getUnqualifiedLoc();
2203  while (true) {
2204  // Look through typedefs.
2205  if (!SuppressBlock) {
2206  if (TypedefTypeLoc TypedefTL = TL.getAs<TypedefTypeLoc>()) {
2207  if (TypeSourceInfo *InnerTSInfo =
2208  TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) {
2209  TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc();
2210  continue;
2211  }
2212  }
2213 
2214  // Look through qualified types
2215  if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>()) {
2216  TL = QualifiedTL.getUnqualifiedLoc();
2217  continue;
2218  }
2219 
2220  if (AttributedTypeLoc AttrTL = TL.getAs<AttributedTypeLoc>()) {
2221  TL = AttrTL.getModifiedLoc();
2222  continue;
2223  }
2224  }
2225 
2226  // Try to get the function prototype behind the block pointer type,
2227  // then we're done.
2228  if (BlockPointerTypeLoc BlockPtr = TL.getAs<BlockPointerTypeLoc>()) {
2229  TL = BlockPtr.getPointeeLoc().IgnoreParens();
2230  Block = TL.getAs<FunctionTypeLoc>();
2231  BlockProto = TL.getAs<FunctionProtoTypeLoc>();
2232  }
2233  break;
2234  }
2235  }
2236 
2237  if (!Block) {
2238  // We were unable to find a FunctionProtoTypeLoc with parameter names
2239  // for the block; just use the parameter type as a placeholder.
2240  std::string Result;
2241  if (!ObjCMethodParam && Param->getIdentifier())
2242  Result = Param->getIdentifier()->getName();
2243 
2244  QualType Type = Param->getType().getUnqualifiedType();
2245 
2246  if (ObjCMethodParam) {
2247  Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(),
2248  Type);
2249  Result += Type.getAsString(Policy) + Result + ")";
2250  if (Param->getIdentifier())
2251  Result += Param->getIdentifier()->getName();
2252  } else {
2253  Type.getAsStringInternal(Result, Policy);
2254  }
2255 
2256  return Result;
2257  }
2258 
2259  // We have the function prototype behind the block pointer type, as it was
2260  // written in the source.
2261  std::string Result;
2262  QualType ResultType = Block.getTypePtr()->getReturnType();
2263  if (ObjCSubsts)
2264  ResultType = ResultType.substObjCTypeArgs(Param->getASTContext(),
2265  *ObjCSubsts,
2267  if (!ResultType->isVoidType() || SuppressBlock)
2268  ResultType.getAsStringInternal(Result, Policy);
2269 
2270  // Format the parameter list.
2271  std::string Params;
2272  if (!BlockProto || Block.getNumParams() == 0) {
2273  if (BlockProto && BlockProto.getTypePtr()->isVariadic())
2274  Params = "(...)";
2275  else
2276  Params = "(void)";
2277  } else {
2278  Params += "(";
2279  for (unsigned I = 0, N = Block.getNumParams(); I != N; ++I) {
2280  if (I)
2281  Params += ", ";
2282  Params += FormatFunctionParameter(Policy, Block.getParam(I),
2283  /*SuppressName=*/false,
2284  /*SuppressBlock=*/true,
2285  ObjCSubsts);
2286 
2287  if (I == N - 1 && BlockProto.getTypePtr()->isVariadic())
2288  Params += ", ...";
2289  }
2290  Params += ")";
2291  }
2292 
2293  if (SuppressBlock) {
2294  // Format as a parameter.
2295  Result = Result + " (^";
2296  if (Param->getIdentifier())
2297  Result += Param->getIdentifier()->getName();
2298  Result += ")";
2299  Result += Params;
2300  } else {
2301  // Format as a block literal argument.
2302  Result = '^' + Result;
2303  Result += Params;
2304 
2305  if (Param->getIdentifier())
2306  Result += Param->getIdentifier()->getName();
2307  }
2308 
2309  return Result;
2310 }
2311 
2312 /// \brief Add function parameter chunks to the given code completion string.
2314  const PrintingPolicy &Policy,
2315  const FunctionDecl *Function,
2316  CodeCompletionBuilder &Result,
2317  unsigned Start = 0,
2318  bool InOptional = false) {
2319  bool FirstParameter = true;
2320 
2321  for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) {
2322  const ParmVarDecl *Param = Function->getParamDecl(P);
2323 
2324  if (Param->hasDefaultArg() && !InOptional) {
2325  // When we see an optional default argument, put that argument and
2326  // the remaining default arguments into a new, optional string.
2327  CodeCompletionBuilder Opt(Result.getAllocator(),
2328  Result.getCodeCompletionTUInfo());
2329  if (!FirstParameter)
2331  AddFunctionParameterChunks(PP, Policy, Function, Opt, P, true);
2332  Result.AddOptionalChunk(Opt.TakeString());
2333  break;
2334  }
2335 
2336  if (FirstParameter)
2337  FirstParameter = false;
2338  else
2340 
2341  InOptional = false;
2342 
2343  // Format the placeholder string.
2344  std::string PlaceholderStr = FormatFunctionParameter(Policy, Param);
2345 
2346  if (Function->isVariadic() && P == N - 1)
2347  PlaceholderStr += ", ...";
2348 
2349  // Add the placeholder string.
2350  Result.AddPlaceholderChunk(
2351  Result.getAllocator().CopyString(PlaceholderStr));
2352  }
2353 
2354  if (const FunctionProtoType *Proto
2355  = Function->getType()->getAs<FunctionProtoType>())
2356  if (Proto->isVariadic()) {
2357  if (Proto->getNumParams() == 0)
2358  Result.AddPlaceholderChunk("...");
2359 
2360  MaybeAddSentinel(PP, Function, Result);
2361  }
2362 }
2363 
2364 /// \brief Add template parameter chunks to the given code completion string.
2366  const PrintingPolicy &Policy,
2367  const TemplateDecl *Template,
2368  CodeCompletionBuilder &Result,
2369  unsigned MaxParameters = 0,
2370  unsigned Start = 0,
2371  bool InDefaultArg = false) {
2372  bool FirstParameter = true;
2373 
2374  // Prefer to take the template parameter names from the first declaration of
2375  // the template.
2376  Template = cast<TemplateDecl>(Template->getCanonicalDecl());
2377 
2378  TemplateParameterList *Params = Template->getTemplateParameters();
2379  TemplateParameterList::iterator PEnd = Params->end();
2380  if (MaxParameters)
2381  PEnd = Params->begin() + MaxParameters;
2382  for (TemplateParameterList::iterator P = Params->begin() + Start;
2383  P != PEnd; ++P) {
2384  bool HasDefaultArg = false;
2385  std::string PlaceholderStr;
2386  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
2387  if (TTP->wasDeclaredWithTypename())
2388  PlaceholderStr = "typename";
2389  else
2390  PlaceholderStr = "class";
2391 
2392  if (TTP->getIdentifier()) {
2393  PlaceholderStr += ' ';
2394  PlaceholderStr += TTP->getIdentifier()->getName();
2395  }
2396 
2397  HasDefaultArg = TTP->hasDefaultArgument();
2398  } else if (NonTypeTemplateParmDecl *NTTP
2399  = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
2400  if (NTTP->getIdentifier())
2401  PlaceholderStr = NTTP->getIdentifier()->getName();
2402  NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
2403  HasDefaultArg = NTTP->hasDefaultArgument();
2404  } else {
2405  assert(isa<TemplateTemplateParmDecl>(*P));
2406  TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
2407 
2408  // Since putting the template argument list into the placeholder would
2409  // be very, very long, we just use an abbreviation.
2410  PlaceholderStr = "template<...> class";
2411  if (TTP->getIdentifier()) {
2412  PlaceholderStr += ' ';
2413  PlaceholderStr += TTP->getIdentifier()->getName();
2414  }
2415 
2416  HasDefaultArg = TTP->hasDefaultArgument();
2417  }
2418 
2419  if (HasDefaultArg && !InDefaultArg) {
2420  // When we see an optional default argument, put that argument and
2421  // the remaining default arguments into a new, optional string.
2422  CodeCompletionBuilder Opt(Result.getAllocator(),
2423  Result.getCodeCompletionTUInfo());
2424  if (!FirstParameter)
2426  AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
2427  P - Params->begin(), true);
2428  Result.AddOptionalChunk(Opt.TakeString());
2429  break;
2430  }
2431 
2432  InDefaultArg = false;
2433 
2434  if (FirstParameter)
2435  FirstParameter = false;
2436  else
2438 
2439  // Add the placeholder string.
2440  Result.AddPlaceholderChunk(
2441  Result.getAllocator().CopyString(PlaceholderStr));
2442  }
2443 }
2444 
2445 /// \brief Add a qualifier to the given code-completion string, if the
2446 /// provided nested-name-specifier is non-NULL.
2447 static void
2449  NestedNameSpecifier *Qualifier,
2450  bool QualifierIsInformative,
2451  ASTContext &Context,
2452  const PrintingPolicy &Policy) {
2453  if (!Qualifier)
2454  return;
2455 
2456  std::string PrintedNNS;
2457  {
2458  llvm::raw_string_ostream OS(PrintedNNS);
2459  Qualifier->print(OS, Policy);
2460  }
2461  if (QualifierIsInformative)
2462  Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS));
2463  else
2464  Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS));
2465 }
2466 
2467 static void
2469  const FunctionDecl *Function) {
2470  const FunctionProtoType *Proto
2471  = Function->getType()->getAs<FunctionProtoType>();
2472  if (!Proto || !Proto->getTypeQuals())
2473  return;
2474 
2475  // FIXME: Add ref-qualifier!
2476 
2477  // Handle single qualifiers without copying
2478  if (Proto->getTypeQuals() == Qualifiers::Const) {
2479  Result.AddInformativeChunk(" const");
2480  return;
2481  }
2482 
2483  if (Proto->getTypeQuals() == Qualifiers::Volatile) {
2484  Result.AddInformativeChunk(" volatile");
2485  return;
2486  }
2487 
2488  if (Proto->getTypeQuals() == Qualifiers::Restrict) {
2489  Result.AddInformativeChunk(" restrict");
2490  return;
2491  }
2492 
2493  // Handle multiple qualifiers.
2494  std::string QualsStr;
2495  if (Proto->isConst())
2496  QualsStr += " const";
2497  if (Proto->isVolatile())
2498  QualsStr += " volatile";
2499  if (Proto->isRestrict())
2500  QualsStr += " restrict";
2501  Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
2502 }
2503 
2504 /// \brief Add the name of the given declaration
2505 static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy,
2506  const NamedDecl *ND,
2507  CodeCompletionBuilder &Result) {
2509  if (!Name)
2510  return;
2511 
2512  switch (Name.getNameKind()) {
2514  const char *OperatorName = nullptr;
2515  switch (Name.getCXXOverloadedOperator()) {
2516  case OO_None:
2517  case OO_Conditional:
2519  OperatorName = "operator";
2520  break;
2521 
2522 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2523  case OO_##Name: OperatorName = "operator" Spelling; break;
2524 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2525 #include "clang/Basic/OperatorKinds.def"
2526 
2527  case OO_New: OperatorName = "operator new"; break;
2528  case OO_Delete: OperatorName = "operator delete"; break;
2529  case OO_Array_New: OperatorName = "operator new[]"; break;
2530  case OO_Array_Delete: OperatorName = "operator delete[]"; break;
2531  case OO_Call: OperatorName = "operator()"; break;
2532  case OO_Subscript: OperatorName = "operator[]"; break;
2533  }
2534  Result.AddTypedTextChunk(OperatorName);
2535  break;
2536  }
2537 
2542  Result.AddTypedTextChunk(
2543  Result.getAllocator().CopyString(ND->getNameAsString()));
2544  break;
2545 
2550  break;
2551 
2553  CXXRecordDecl *Record = nullptr;
2554  QualType Ty = Name.getCXXNameType();
2555  if (const RecordType *RecordTy = Ty->getAs<RecordType>())
2556  Record = cast<CXXRecordDecl>(RecordTy->getDecl());
2557  else if (const InjectedClassNameType *InjectedTy
2558  = Ty->getAs<InjectedClassNameType>())
2559  Record = InjectedTy->getDecl();
2560  else {
2561  Result.AddTypedTextChunk(
2562  Result.getAllocator().CopyString(ND->getNameAsString()));
2563  break;
2564  }
2565 
2566  Result.AddTypedTextChunk(
2567  Result.getAllocator().CopyString(Record->getNameAsString()));
2568  if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) {
2570  AddTemplateParameterChunks(Context, Policy, Template, Result);
2572  }
2573  break;
2574  }
2575  }
2576 }
2577 
2579  const CodeCompletionContext &CCContext,
2580  CodeCompletionAllocator &Allocator,
2581  CodeCompletionTUInfo &CCTUInfo,
2582  bool IncludeBriefComments) {
2583  return CreateCodeCompletionString(S.Context, S.PP, CCContext, Allocator,
2584  CCTUInfo, IncludeBriefComments);
2585 }
2586 
2587 /// \brief If possible, create a new code completion string for the given
2588 /// result.
2589 ///
2590 /// \returns Either a new, heap-allocated code completion string describing
2591 /// how to use this result, or NULL to indicate that the string or name of the
2592 /// result is all that is needed.
2595  Preprocessor &PP,
2596  const CodeCompletionContext &CCContext,
2597  CodeCompletionAllocator &Allocator,
2598  CodeCompletionTUInfo &CCTUInfo,
2599  bool IncludeBriefComments) {
2600  CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
2601 
2602  PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
2603  if (Kind == RK_Pattern) {
2604  Pattern->Priority = Priority;
2605  Pattern->Availability = Availability;
2606 
2607  if (Declaration) {
2608  Result.addParentContext(Declaration->getDeclContext());
2609  Pattern->ParentName = Result.getParentName();
2610  // Provide code completion comment for self.GetterName where
2611  // GetterName is the getter method for a property with name
2612  // different from the property name (declared via a property
2613  // getter attribute.
2614  const NamedDecl *ND = Declaration;
2615  if (const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(ND))
2616  if (M->isPropertyAccessor())
2617  if (const ObjCPropertyDecl *PDecl = M->findPropertyDecl())
2618  if (PDecl->getGetterName() == M->getSelector() &&
2619  PDecl->getIdentifier() != M->getIdentifier()) {
2620  if (const RawComment *RC =
2621  Ctx.getRawCommentForAnyRedecl(M)) {
2622  Result.addBriefComment(RC->getBriefText(Ctx));
2623  Pattern->BriefComment = Result.getBriefComment();
2624  }
2625  else if (const RawComment *RC =
2626  Ctx.getRawCommentForAnyRedecl(PDecl)) {
2627  Result.addBriefComment(RC->getBriefText(Ctx));
2628  Pattern->BriefComment = Result.getBriefComment();
2629  }
2630  }
2631  }
2632 
2633  return Pattern;
2634  }
2635 
2636  if (Kind == RK_Keyword) {
2637  Result.AddTypedTextChunk(Keyword);
2638  return Result.TakeString();
2639  }
2640 
2641  if (Kind == RK_Macro) {
2642  const MacroInfo *MI = PP.getMacroInfo(Macro);
2643  Result.AddTypedTextChunk(
2644  Result.getAllocator().CopyString(Macro->getName()));
2645 
2646  if (!MI || !MI->isFunctionLike())
2647  return Result.TakeString();
2648 
2649  // Format a function-like macro with placeholders for the arguments.
2651  MacroInfo::arg_iterator A = MI->arg_begin(), AEnd = MI->arg_end();
2652 
2653  // C99 variadic macros add __VA_ARGS__ at the end. Skip it.
2654  if (MI->isC99Varargs()) {
2655  --AEnd;
2656 
2657  if (A == AEnd) {
2658  Result.AddPlaceholderChunk("...");
2659  }
2660  }
2661 
2662  for (MacroInfo::arg_iterator A = MI->arg_begin(); A != AEnd; ++A) {
2663  if (A != MI->arg_begin())
2665 
2666  if (MI->isVariadic() && (A+1) == AEnd) {
2667  SmallString<32> Arg = (*A)->getName();
2668  if (MI->isC99Varargs())
2669  Arg += ", ...";
2670  else
2671  Arg += "...";
2672  Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2673  break;
2674  }
2675 
2676  // Non-variadic macros are simple.
2677  Result.AddPlaceholderChunk(
2678  Result.getAllocator().CopyString((*A)->getName()));
2679  }
2681  return Result.TakeString();
2682  }
2683 
2684  assert(Kind == RK_Declaration && "Missed a result kind?");
2685  const NamedDecl *ND = Declaration;
2686  Result.addParentContext(ND->getDeclContext());
2687 
2688  if (IncludeBriefComments) {
2689  // Add documentation comment, if it exists.
2690  if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(ND)) {
2691  Result.addBriefComment(RC->getBriefText(Ctx));
2692  }
2693  else if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(ND))
2694  if (OMD->isPropertyAccessor())
2695  if (const ObjCPropertyDecl *PDecl = OMD->findPropertyDecl())
2696  if (const RawComment *RC = Ctx.getRawCommentForAnyRedecl(PDecl))
2697  Result.addBriefComment(RC->getBriefText(Ctx));
2698  }
2699 
2700  if (StartsNestedNameSpecifier) {
2701  Result.AddTypedTextChunk(
2702  Result.getAllocator().CopyString(ND->getNameAsString()));
2703  Result.AddTextChunk("::");
2704  return Result.TakeString();
2705  }
2706 
2707  for (const auto *I : ND->specific_attrs<AnnotateAttr>())
2708  Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation()));
2709 
2710  AddResultTypeChunk(Ctx, Policy, ND, CCContext.getBaseType(), Result);
2711 
2712  if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) {
2713  AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2714  Ctx, Policy);
2715  AddTypedNameChunk(Ctx, Policy, ND, Result);
2717  AddFunctionParameterChunks(PP, Policy, Function, Result);
2719  AddFunctionTypeQualsToCompletionString(Result, Function);
2720  return Result.TakeString();
2721  }
2722 
2723  if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) {
2724  AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2725  Ctx, Policy);
2726  FunctionDecl *Function = FunTmpl->getTemplatedDecl();
2727  AddTypedNameChunk(Ctx, Policy, Function, Result);
2728 
2729  // Figure out which template parameters are deduced (or have default
2730  // arguments).
2731  llvm::SmallBitVector Deduced;
2732  Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced);
2733  unsigned LastDeducibleArgument;
2734  for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
2735  --LastDeducibleArgument) {
2736  if (!Deduced[LastDeducibleArgument - 1]) {
2737  // C++0x: Figure out if the template argument has a default. If so,
2738  // the user doesn't need to type this argument.
2739  // FIXME: We need to abstract template parameters better!
2740  bool HasDefaultArg = false;
2741  NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
2742  LastDeducibleArgument - 1);
2743  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
2744  HasDefaultArg = TTP->hasDefaultArgument();
2745  else if (NonTypeTemplateParmDecl *NTTP
2746  = dyn_cast<NonTypeTemplateParmDecl>(Param))
2747  HasDefaultArg = NTTP->hasDefaultArgument();
2748  else {
2749  assert(isa<TemplateTemplateParmDecl>(Param));
2750  HasDefaultArg
2751  = cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
2752  }
2753 
2754  if (!HasDefaultArg)
2755  break;
2756  }
2757  }
2758 
2759  if (LastDeducibleArgument) {
2760  // Some of the function template arguments cannot be deduced from a
2761  // function call, so we introduce an explicit template argument list
2762  // containing all of the arguments up to the first deducible argument.
2764  AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result,
2765  LastDeducibleArgument);
2767  }
2768 
2769  // Add the function parameters
2771  AddFunctionParameterChunks(PP, Policy, Function, Result);
2773  AddFunctionTypeQualsToCompletionString(Result, Function);
2774  return Result.TakeString();
2775  }
2776 
2777  if (const TemplateDecl *Template = dyn_cast<TemplateDecl>(ND)) {
2778  AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2779  Ctx, Policy);
2780  Result.AddTypedTextChunk(
2781  Result.getAllocator().CopyString(Template->getNameAsString()));
2783  AddTemplateParameterChunks(Ctx, Policy, Template, Result);
2785  return Result.TakeString();
2786  }
2787 
2788  if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2789  Selector Sel = Method->getSelector();
2790  if (Sel.isUnarySelector()) {
2791  Result.AddTypedTextChunk(Result.getAllocator().CopyString(
2792  Sel.getNameForSlot(0)));
2793  return Result.TakeString();
2794  }
2795 
2796  std::string SelName = Sel.getNameForSlot(0).str();
2797  SelName += ':';
2798  if (StartParameter == 0)
2799  Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
2800  else {
2801  Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName));
2802 
2803  // If there is only one parameter, and we're past it, add an empty
2804  // typed-text chunk since there is nothing to type.
2805  if (Method->param_size() == 1)
2806  Result.AddTypedTextChunk("");
2807  }
2808  unsigned Idx = 0;
2809  for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(),
2810  PEnd = Method->param_end();
2811  P != PEnd; (void)++P, ++Idx) {
2812  if (Idx > 0) {
2813  std::string Keyword;
2814  if (Idx > StartParameter)
2816  if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx))
2817  Keyword += II->getName();
2818  Keyword += ":";
2819  if (Idx < StartParameter || AllParametersAreInformative)
2820  Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword));
2821  else
2822  Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword));
2823  }
2824 
2825  // If we're before the starting parameter, skip the placeholder.
2826  if (Idx < StartParameter)
2827  continue;
2828 
2829  std::string Arg;
2830  QualType ParamType = (*P)->getType();
2831  Optional<ArrayRef<QualType>> ObjCSubsts;
2832  if (!CCContext.getBaseType().isNull())
2833  ObjCSubsts = CCContext.getBaseType()->getObjCSubstitutions(Method);
2834 
2835  if (ParamType->isBlockPointerType() && !DeclaringEntity)
2836  Arg = FormatFunctionParameter(Policy, *P, true,
2837  /*SuppressBlock=*/false,
2838  ObjCSubsts);
2839  else {
2840  if (ObjCSubsts)
2841  ParamType = ParamType.substObjCTypeArgs(Ctx, *ObjCSubsts,
2843  Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier(),
2844  ParamType);
2845  Arg += ParamType.getAsString(Policy) + ")";
2846  if (IdentifierInfo *II = (*P)->getIdentifier())
2847  if (DeclaringEntity || AllParametersAreInformative)
2848  Arg += II->getName();
2849  }
2850 
2851  if (Method->isVariadic() && (P + 1) == PEnd)
2852  Arg += ", ...";
2853 
2854  if (DeclaringEntity)
2855  Result.AddTextChunk(Result.getAllocator().CopyString(Arg));
2856  else if (AllParametersAreInformative)
2857  Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg));
2858  else
2859  Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2860  }
2861 
2862  if (Method->isVariadic()) {
2863  if (Method->param_size() == 0) {
2864  if (DeclaringEntity)
2865  Result.AddTextChunk(", ...");
2866  else if (AllParametersAreInformative)
2867  Result.AddInformativeChunk(", ...");
2868  else
2869  Result.AddPlaceholderChunk(", ...");
2870  }
2871 
2872  MaybeAddSentinel(PP, Method, Result);
2873  }
2874 
2875  return Result.TakeString();
2876  }
2877 
2878  if (Qualifier)
2879  AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2880  Ctx, Policy);
2881 
2882  Result.AddTypedTextChunk(
2883  Result.getAllocator().CopyString(ND->getNameAsString()));
2884  return Result.TakeString();
2885 }
2886 
2887 /// \brief Add function overload parameter chunks to the given code completion
2888 /// string.
2890  const PrintingPolicy &Policy,
2891  const FunctionDecl *Function,
2892  const FunctionProtoType *Prototype,
2893  CodeCompletionBuilder &Result,
2894  unsigned CurrentArg,
2895  unsigned Start = 0,
2896  bool InOptional = false) {
2897  bool FirstParameter = true;
2898  unsigned NumParams = Function ? Function->getNumParams()
2899  : Prototype->getNumParams();
2900 
2901  for (unsigned P = Start; P != NumParams; ++P) {
2902  if (Function && Function->getParamDecl(P)->hasDefaultArg() && !InOptional) {
2903  // When we see an optional default argument, put that argument and
2904  // the remaining default arguments into a new, optional string.
2905  CodeCompletionBuilder Opt(Result.getAllocator(),
2906  Result.getCodeCompletionTUInfo());
2907  if (!FirstParameter)
2909  // Optional sections are nested.
2910  AddOverloadParameterChunks(Context, Policy, Function, Prototype, Opt,
2911  CurrentArg, P, /*InOptional=*/true);
2912  Result.AddOptionalChunk(Opt.TakeString());
2913  return;
2914  }
2915 
2916  if (FirstParameter)
2917  FirstParameter = false;
2918  else
2920 
2921  InOptional = false;
2922 
2923  // Format the placeholder string.
2924  std::string Placeholder;
2925  if (Function)
2926  Placeholder = FormatFunctionParameter(Policy, Function->getParamDecl(P));
2927  else
2928  Placeholder = Prototype->getParamType(P).getAsString(Policy);
2929 
2930  if (P == CurrentArg)
2931  Result.AddCurrentParameterChunk(
2932  Result.getAllocator().CopyString(Placeholder));
2933  else
2934  Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Placeholder));
2935  }
2936 
2937  if (Prototype && Prototype->isVariadic()) {
2938  CodeCompletionBuilder Opt(Result.getAllocator(),
2939  Result.getCodeCompletionTUInfo());
2940  if (!FirstParameter)
2942 
2943  if (CurrentArg < NumParams)
2944  Opt.AddPlaceholderChunk("...");
2945  else
2946  Opt.AddCurrentParameterChunk("...");
2947 
2948  Result.AddOptionalChunk(Opt.TakeString());
2949  }
2950 }
2951 
2954  unsigned CurrentArg, Sema &S,
2955  CodeCompletionAllocator &Allocator,
2956  CodeCompletionTUInfo &CCTUInfo,
2957  bool IncludeBriefComments) const {
2959 
2960  // FIXME: Set priority, availability appropriately.
2961  CodeCompletionBuilder Result(Allocator,CCTUInfo, 1, CXAvailability_Available);
2962  FunctionDecl *FDecl = getFunction();
2963  const FunctionProtoType *Proto
2964  = dyn_cast<FunctionProtoType>(getFunctionType());
2965  if (!FDecl && !Proto) {
2966  // Function without a prototype. Just give the return type and a
2967  // highlighted ellipsis.
2968  const FunctionType *FT = getFunctionType();
2969  Result.AddResultTypeChunk(Result.getAllocator().CopyString(
2970  FT->getReturnType().getAsString(Policy)));
2974  return Result.TakeString();
2975  }
2976 
2977  if (FDecl) {
2978  if (IncludeBriefComments && CurrentArg < FDecl->getNumParams())
2979  if (auto RC = S.getASTContext().getRawCommentForAnyRedecl(
2980  FDecl->getParamDecl(CurrentArg)))
2981  Result.addBriefComment(RC->getBriefText(S.getASTContext()));
2982  AddResultTypeChunk(S.Context, Policy, FDecl, QualType(), Result);
2983  Result.AddTextChunk(
2984  Result.getAllocator().CopyString(FDecl->getNameAsString()));
2985  } else {
2986  Result.AddResultTypeChunk(
2987  Result.getAllocator().CopyString(
2988  Proto->getReturnType().getAsString(Policy)));
2989  }
2990 
2992  AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result,
2993  CurrentArg);
2994  Result.AddChunk(CodeCompletionString::CK_RightParen);
2995 
2996  return Result.TakeString();
2997 }
2998 
2999 unsigned clang::getMacroUsagePriority(StringRef MacroName,
3000  const LangOptions &LangOpts,
3001  bool PreferredTypeIsPointer) {
3002  unsigned Priority = CCP_Macro;
3003 
3004  // Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
3005  if (MacroName.equals("nil") || MacroName.equals("NULL") ||
3006  MacroName.equals("Nil")) {
3007  Priority = CCP_Constant;
3008  if (PreferredTypeIsPointer)
3009  Priority = Priority / CCF_SimilarTypeMatch;
3010  }
3011  // Treat "YES", "NO", "true", and "false" as constants.
3012  else if (MacroName.equals("YES") || MacroName.equals("NO") ||
3013  MacroName.equals("true") || MacroName.equals("false"))
3014  Priority = CCP_Constant;
3015  // Treat "bool" as a type.
3016  else if (MacroName.equals("bool"))
3017  Priority = CCP_Type + (LangOpts.ObjC1? CCD_bool_in_ObjC : 0);
3018 
3019 
3020  return Priority;
3021 }
3022 
3024  if (!D)
3025  return CXCursor_UnexposedDecl;
3026 
3027  switch (D->getKind()) {
3028  case Decl::Enum: return CXCursor_EnumDecl;
3029  case Decl::EnumConstant: return CXCursor_EnumConstantDecl;
3030  case Decl::Field: return CXCursor_FieldDecl;
3031  case Decl::Function:
3032  return CXCursor_FunctionDecl;
3033  case Decl::ObjCCategory: return CXCursor_ObjCCategoryDecl;
3034  case Decl::ObjCCategoryImpl: return CXCursor_ObjCCategoryImplDecl;
3035  case Decl::ObjCImplementation: return CXCursor_ObjCImplementationDecl;
3036 
3037  case Decl::ObjCInterface: return CXCursor_ObjCInterfaceDecl;
3038  case Decl::ObjCIvar: return CXCursor_ObjCIvarDecl;
3039  case Decl::ObjCMethod:
3040  return cast<ObjCMethodDecl>(D)->isInstanceMethod()
3042  case Decl::CXXMethod: return CXCursor_CXXMethod;
3043  case Decl::CXXConstructor: return CXCursor_Constructor;
3044  case Decl::CXXDestructor: return CXCursor_Destructor;
3045  case Decl::CXXConversion: return CXCursor_ConversionFunction;
3046  case Decl::ObjCProperty: return CXCursor_ObjCPropertyDecl;
3047  case Decl::ObjCProtocol: return CXCursor_ObjCProtocolDecl;
3048  case Decl::ParmVar: return CXCursor_ParmDecl;
3049  case Decl::Typedef: return CXCursor_TypedefDecl;
3051  case Decl::TypeAliasTemplate: return CXCursor_TypeAliasTemplateDecl;
3052  case Decl::Var: return CXCursor_VarDecl;
3053  case Decl::Namespace: return CXCursor_Namespace;
3054  case Decl::NamespaceAlias: return CXCursor_NamespaceAlias;
3055  case Decl::TemplateTypeParm: return CXCursor_TemplateTypeParameter;
3056  case Decl::NonTypeTemplateParm:return CXCursor_NonTypeTemplateParameter;
3057  case Decl::TemplateTemplateParm:return CXCursor_TemplateTemplateParameter;
3058  case Decl::FunctionTemplate: return CXCursor_FunctionTemplate;
3059  case Decl::ClassTemplate: return CXCursor_ClassTemplate;
3060  case Decl::AccessSpec: return CXCursor_CXXAccessSpecifier;
3061  case Decl::ClassTemplatePartialSpecialization:
3063  case Decl::UsingDirective: return CXCursor_UsingDirective;
3064  case Decl::StaticAssert: return CXCursor_StaticAssert;
3065  case Decl::TranslationUnit: return CXCursor_TranslationUnit;
3066 
3067  case Decl::Using:
3068  case Decl::UnresolvedUsingValue:
3069  case Decl::UnresolvedUsingTypename:
3071 
3072  case Decl::ObjCPropertyImpl:
3073  switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
3075  return CXCursor_ObjCDynamicDecl;
3076 
3079  }
3080 
3081  case Decl::Import:
3083 
3084  case Decl::ObjCTypeParam: return CXCursor_TemplateTypeParameter;
3085 
3086  default:
3087  if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
3088  switch (TD->getTagKind()) {
3089  case TTK_Interface: // fall through
3090  case TTK_Struct: return CXCursor_StructDecl;
3091  case TTK_Class: return CXCursor_ClassDecl;
3092  case TTK_Union: return CXCursor_UnionDecl;
3093  case TTK_Enum: return CXCursor_EnumDecl;
3094  }
3095  }
3096  }
3097 
3098  return CXCursor_UnexposedDecl;
3099 }
3100 
3101 static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results,
3102  bool IncludeUndefined,
3103  bool TargetTypeIsPointer = false) {
3104  typedef CodeCompletionResult Result;
3105 
3106  Results.EnterNewScope();
3107 
3109  MEnd = PP.macro_end();
3110  M != MEnd; ++M) {
3111  auto MD = PP.getMacroDefinition(M->first);
3112  if (IncludeUndefined || MD) {
3113  if (MacroInfo *MI = MD.getMacroInfo())
3114  if (MI->isUsedForHeaderGuard())
3115  continue;
3116 
3117  Results.AddResult(Result(M->first,
3118  getMacroUsagePriority(M->first->getName(),
3119  PP.getLangOpts(),
3120  TargetTypeIsPointer)));
3121  }
3122  }
3123 
3124  Results.ExitScope();
3125 
3126 }
3127 
3128 static void AddPrettyFunctionResults(const LangOptions &LangOpts,
3129  ResultBuilder &Results) {
3130  typedef CodeCompletionResult Result;
3131 
3132  Results.EnterNewScope();
3133 
3134  Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant));
3135  Results.AddResult(Result("__FUNCTION__", CCP_Constant));
3136  if (LangOpts.C99 || LangOpts.CPlusPlus11)
3137  Results.AddResult(Result("__func__", CCP_Constant));
3138  Results.ExitScope();
3139 }
3140 
3142  CodeCompleteConsumer *CodeCompleter,
3143  CodeCompletionContext Context,
3144  CodeCompletionResult *Results,
3145  unsigned NumResults) {
3146  if (CodeCompleter)
3147  CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults);
3148 }
3149 
3152  switch (PCC) {
3153  case Sema::PCC_Namespace:
3155 
3156  case Sema::PCC_Class:
3158 
3161 
3164 
3167 
3168  case Sema::PCC_Template:
3170  if (S.CurContext->isFileContext())
3172  if (S.CurContext->isRecord())
3175 
3178 
3179  case Sema::PCC_ForInit:
3180  if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 ||
3181  S.getLangOpts().ObjC1)
3183  else
3185 
3186  case Sema::PCC_Expression:
3187  case Sema::PCC_Condition:
3189 
3190  case Sema::PCC_Statement:
3192 
3193  case Sema::PCC_Type:
3195 
3198 
3201  }
3202 
3203  llvm_unreachable("Invalid ParserCompletionContext!");
3204 }
3205 
3206 /// \brief If we're in a C++ virtual member function, add completion results
3207 /// that invoke the functions we override, since it's common to invoke the
3208 /// overridden function as well as adding new functionality.
3209 ///
3210 /// \param S The semantic analysis object for which we are generating results.
3211 ///
3212 /// \param InContext This context in which the nested-name-specifier preceding
3213 /// the code-completion point
3214 static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
3215  ResultBuilder &Results) {
3216  // Look through blocks.
3217  DeclContext *CurContext = S.CurContext;
3218  while (isa<BlockDecl>(CurContext))
3219  CurContext = CurContext->getParent();
3220 
3221 
3222  CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
3223  if (!Method || !Method->isVirtual())
3224  return;
3225 
3226  // We need to have names for all of the parameters, if we're going to
3227  // generate a forwarding call.
3228  for (auto P : Method->parameters())
3229  if (!P->getDeclName())
3230  return;
3231 
3234  MEnd = Method->end_overridden_methods();
3235  M != MEnd; ++M) {
3236  CodeCompletionBuilder Builder(Results.getAllocator(),
3237  Results.getCodeCompletionTUInfo());
3238  const CXXMethodDecl *Overridden = *M;
3239  if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
3240  continue;
3241 
3242  // If we need a nested-name-specifier, add one now.
3243  if (!InContext) {
3244  NestedNameSpecifier *NNS
3245  = getRequiredQualification(S.Context, CurContext,
3246  Overridden->getDeclContext());
3247  if (NNS) {
3248  std::string Str;
3249  llvm::raw_string_ostream OS(Str);
3250  NNS->print(OS, Policy);
3251  Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
3252  }
3253  } else if (!InContext->Equals(Overridden->getDeclContext()))
3254  continue;
3255 
3256  Builder.AddTypedTextChunk(Results.getAllocator().CopyString(
3257  Overridden->getNameAsString()));
3259  bool FirstParam = true;
3260  for (auto P : Method->parameters()) {
3261  if (FirstParam)
3262  FirstParam = false;
3263  else
3265 
3266  Builder.AddPlaceholderChunk(
3267  Results.getAllocator().CopyString(P->getIdentifier()->getName()));
3268  }
3270  Results.AddResult(CodeCompletionResult(Builder.TakeString(),
3274  Overridden));
3275  Results.Ignore(Overridden);
3276  }
3277 }
3278 
3280  ModuleIdPath Path) {
3281  typedef CodeCompletionResult Result;
3282  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3283  CodeCompleter->getCodeCompletionTUInfo(),
3285  Results.EnterNewScope();
3286 
3287  CodeCompletionAllocator &Allocator = Results.getAllocator();
3288  CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
3289  typedef CodeCompletionResult Result;
3290  if (Path.empty()) {
3291  // Enumerate all top-level modules.
3292  SmallVector<Module *, 8> Modules;
3293  PP.getHeaderSearchInfo().collectAllModules(Modules);
3294  for (unsigned I = 0, N = Modules.size(); I != N; ++I) {
3295  Builder.AddTypedTextChunk(
3296  Builder.getAllocator().CopyString(Modules[I]->Name));
3297  Results.AddResult(Result(Builder.TakeString(),
3298  CCP_Declaration,
3300  Modules[I]->isAvailable()
3303  }
3304  } else if (getLangOpts().Modules) {
3305  // Load the named module.
3306  Module *Mod = PP.getModuleLoader().loadModule(ImportLoc, Path,
3308  /*IsInclusionDirective=*/false);
3309  // Enumerate submodules.
3310  if (Mod) {
3311  for (Module::submodule_iterator Sub = Mod->submodule_begin(),
3312  SubEnd = Mod->submodule_end();
3313  Sub != SubEnd; ++Sub) {
3314 
3315  Builder.AddTypedTextChunk(
3316  Builder.getAllocator().CopyString((*Sub)->Name));
3317  Results.AddResult(Result(Builder.TakeString(),
3318  CCP_Declaration,
3320  (*Sub)->isAvailable()
3323  }
3324  }
3325  }
3326  Results.ExitScope();
3327  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3328  Results.data(),Results.size());
3329 }
3330 
3332  ParserCompletionContext CompletionContext) {
3333  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3334  CodeCompleter->getCodeCompletionTUInfo(),
3335  mapCodeCompletionContext(*this, CompletionContext));
3336  Results.EnterNewScope();
3337 
3338  // Determine how to filter results, e.g., so that the names of
3339  // values (functions, enumerators, function templates, etc.) are
3340  // only allowed where we can have an expression.
3341  switch (CompletionContext) {
3342  case PCC_Namespace:
3343  case PCC_Class:
3344  case PCC_ObjCInterface:
3345  case PCC_ObjCImplementation:
3346  case PCC_ObjCInstanceVariableList:
3347  case PCC_Template:
3348  case PCC_MemberTemplate:
3349  case PCC_Type:
3350  case PCC_LocalDeclarationSpecifiers:
3351  Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
3352  break;
3353 
3354  case PCC_Statement:
3355  case PCC_ParenthesizedExpression:
3356  case PCC_Expression:
3357  case PCC_ForInit:
3358  case PCC_Condition:
3359  if (WantTypesInContext(CompletionContext, getLangOpts()))
3360  Results.setFilter(&ResultBuilder::IsOrdinaryName);
3361  else
3362  Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3363 
3364  if (getLangOpts().CPlusPlus)
3365  MaybeAddOverrideCalls(*this, /*InContext=*/nullptr, Results);
3366  break;
3367 
3368  case PCC_RecoveryInFunction:
3369  // Unfiltered
3370  break;
3371  }
3372 
3373  // If we are in a C++ non-static member function, check the qualifiers on
3374  // the member function to filter/prioritize the results list.
3375  if (CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext))
3376  if (CurMethod->isInstance())
3377  Results.setObjectTypeQualifiers(
3378  Qualifiers::fromCVRMask(CurMethod->getTypeQualifiers()));
3379 
3380  CodeCompletionDeclConsumer Consumer(Results, CurContext);
3381  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3382  CodeCompleter->includeGlobals());
3383 
3384  AddOrdinaryNameResults(CompletionContext, S, *this, Results);
3385  Results.ExitScope();
3386 
3387  switch (CompletionContext) {
3388  case PCC_ParenthesizedExpression:
3389  case PCC_Expression:
3390  case PCC_Statement:
3391  case PCC_RecoveryInFunction:
3392  if (S->getFnParent())
3393  AddPrettyFunctionResults(getLangOpts(), Results);
3394  break;
3395 
3396  case PCC_Namespace:
3397  case PCC_Class:
3398  case PCC_ObjCInterface:
3399  case PCC_ObjCImplementation:
3400  case PCC_ObjCInstanceVariableList:
3401  case PCC_Template:
3402  case PCC_MemberTemplate:
3403  case PCC_ForInit:
3404  case PCC_Condition:
3405  case PCC_Type:
3406  case PCC_LocalDeclarationSpecifiers:
3407  break;
3408  }
3409 
3410  if (CodeCompleter->includeMacros())
3411  AddMacroResults(PP, Results, false);
3412 
3413  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3414  Results.data(),Results.size());
3415 }
3416 
3417 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
3418  ParsedType Receiver,
3419  ArrayRef<IdentifierInfo *> SelIdents,
3420  bool AtArgumentExpression,
3421  bool IsSuper,
3422  ResultBuilder &Results);
3423 
3425  bool AllowNonIdentifiers,
3426  bool AllowNestedNameSpecifiers) {
3427  typedef CodeCompletionResult Result;
3428  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3429  CodeCompleter->getCodeCompletionTUInfo(),
3430  AllowNestedNameSpecifiers
3433  Results.EnterNewScope();
3434 
3435  // Type qualifiers can come after names.
3436  Results.AddResult(Result("const"));
3437  Results.AddResult(Result("volatile"));
3438  if (getLangOpts().C99)
3439  Results.AddResult(Result("restrict"));
3440 
3441  if (getLangOpts().CPlusPlus) {
3442  if (AllowNonIdentifiers) {
3443  Results.AddResult(Result("operator"));
3444  }
3445 
3446  // Add nested-name-specifiers.
3447  if (AllowNestedNameSpecifiers) {
3448  Results.allowNestedNameSpecifiers();
3449  Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
3450  CodeCompletionDeclConsumer Consumer(Results, CurContext);
3451  LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
3452  CodeCompleter->includeGlobals());
3453  Results.setFilter(nullptr);
3454  }
3455  }
3456  Results.ExitScope();
3457 
3458  // If we're in a context where we might have an expression (rather than a
3459  // declaration), and what we've seen so far is an Objective-C type that could
3460  // be a receiver of a class message, this may be a class message send with
3461  // the initial opening bracket '[' missing. Add appropriate completions.
3462  if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
3467  !DS.isTypeAltiVecVector() &&
3468  S &&
3469  (S->getFlags() & Scope::DeclScope) != 0 &&
3472  Scope::AtCatchScope)) == 0) {
3473  ParsedType T = DS.getRepAsType();
3474  if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
3475  AddClassMessageCompletions(*this, S, T, None, false, false, Results);
3476  }
3477 
3478  // Note that we intentionally suppress macro results here, since we do not
3479  // encourage using macros to produce the names of entities.
3480 
3481  HandleCodeCompleteResults(this, CodeCompleter,
3482  Results.getCompletionContext(),
3483  Results.data(), Results.size());
3484 }
3485 
3488  : PreferredType(PreferredType), IntegralConstantExpression(false),
3489  ObjCCollection(false) { }
3490 
3495 };
3496 
3497 /// \brief Perform code-completion in an expression context when we know what
3498 /// type we're looking for.
3500  const CodeCompleteExpressionData &Data) {
3501  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3502  CodeCompleter->getCodeCompletionTUInfo(),
3504  if (Data.ObjCCollection)
3505  Results.setFilter(&ResultBuilder::IsObjCCollection);
3506  else if (Data.IntegralConstantExpression)
3507  Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
3508  else if (WantTypesInContext(PCC_Expression, getLangOpts()))
3509  Results.setFilter(&ResultBuilder::IsOrdinaryName);
3510  else
3511  Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3512 
3513  if (!Data.PreferredType.isNull())
3514  Results.setPreferredType(Data.PreferredType.getNonReferenceType());
3515 
3516  // Ignore any declarations that we were told that we don't care about.
3517  for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
3518  Results.Ignore(Data.IgnoreDecls[I]);
3519 
3520  CodeCompletionDeclConsumer Consumer(Results, CurContext);
3521  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3522  CodeCompleter->includeGlobals());
3523 
3524  Results.EnterNewScope();
3525  AddOrdinaryNameResults(PCC_Expression, S, *this, Results);
3526  Results.ExitScope();
3527 
3528  bool PreferredTypeIsPointer = false;
3529  if (!Data.PreferredType.isNull())
3530  PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType()
3532  || Data.PreferredType->isBlockPointerType();
3533 
3534  if (S->getFnParent() &&
3535  !Data.ObjCCollection &&
3537  AddPrettyFunctionResults(getLangOpts(), Results);
3538 
3539  if (CodeCompleter->includeMacros())
3540  AddMacroResults(PP, Results, false, PreferredTypeIsPointer);
3541  HandleCodeCompleteResults(this, CodeCompleter,
3543  Data.PreferredType),
3544  Results.data(),Results.size());
3545 }
3546 
3548  if (E.isInvalid())
3549  CodeCompleteOrdinaryName(S, PCC_RecoveryInFunction);
3550  else if (getLangOpts().ObjC1)
3551  CodeCompleteObjCInstanceMessage(S, E.get(), None, false);
3552 }
3553 
3554 /// \brief The set of properties that have already been added, referenced by
3555 /// property name.
3556 typedef llvm::SmallPtrSet<IdentifierInfo*, 16> AddedPropertiesSet;
3557 
3558 /// \brief Retrieve the container definition, if any?
3560  if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
3561  if (Interface->hasDefinition())
3562  return Interface->getDefinition();
3563 
3564  return Interface;
3565  }
3566 
3567  if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3568  if (Protocol->hasDefinition())
3569  return Protocol->getDefinition();
3570 
3571  return Protocol;
3572  }
3573  return Container;
3574 }
3575 
3576 static void AddObjCProperties(const CodeCompletionContext &CCContext,
3577  ObjCContainerDecl *Container,
3578  bool AllowCategories,
3579  bool AllowNullaryMethods,
3580  DeclContext *CurContext,
3581  AddedPropertiesSet &AddedProperties,
3582  ResultBuilder &Results) {
3583  typedef CodeCompletionResult Result;
3584 
3585  // Retrieve the definition.
3586  Container = getContainerDef(Container);
3587 
3588  // Add properties in this container.
3589  for (const auto *P : Container->instance_properties())
3590  if (AddedProperties.insert(P->getIdentifier()).second)
3591  Results.MaybeAddResult(Result(P, Results.getBasePriority(P), nullptr),
3592  CurContext);
3593 
3594  // Add nullary methods
3595  if (AllowNullaryMethods) {
3596  ASTContext &Context = Container->getASTContext();
3597  PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
3598  for (auto *M : Container->methods()) {
3599  if (M->getSelector().isUnarySelector())
3600  if (IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0))
3601  if (AddedProperties.insert(Name).second) {
3602  CodeCompletionBuilder Builder(Results.getAllocator(),
3603  Results.getCodeCompletionTUInfo());
3604  AddResultTypeChunk(Context, Policy, M, CCContext.getBaseType(),
3605  Builder);
3606  Builder.AddTypedTextChunk(
3607  Results.getAllocator().CopyString(Name->getName()));
3608 
3609  Results.MaybeAddResult(Result(Builder.TakeString(), M,
3611  CurContext);
3612  }
3613  }
3614  }
3615 
3616 
3617  // Add properties in referenced protocols.
3618  if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3619  for (auto *P : Protocol->protocols())
3620  AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3621  CurContext, AddedProperties, Results);
3622  } else if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)){
3623  if (AllowCategories) {
3624  // Look through categories.
3625  for (auto *Cat : IFace->known_categories())
3626  AddObjCProperties(CCContext, Cat, AllowCategories, AllowNullaryMethods,
3627  CurContext, AddedProperties, Results);
3628  }
3629 
3630  // Look through protocols.
3631  for (auto *I : IFace->all_referenced_protocols())
3632  AddObjCProperties(CCContext, I, AllowCategories, AllowNullaryMethods,
3633  CurContext, AddedProperties, Results);
3634 
3635  // Look in the superclass.
3636  if (IFace->getSuperClass())
3637  AddObjCProperties(CCContext, IFace->getSuperClass(), AllowCategories,
3638  AllowNullaryMethods, CurContext,
3639  AddedProperties, Results);
3640  } else if (const ObjCCategoryDecl *Category
3641  = dyn_cast<ObjCCategoryDecl>(Container)) {
3642  // Look through protocols.
3643  for (auto *P : Category->protocols())
3644  AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3645  CurContext, AddedProperties, Results);
3646  }
3647 }
3648 
3650  SourceLocation OpLoc,
3651  bool IsArrow) {
3652  if (!Base || !CodeCompleter)
3653  return;
3654 
3655  ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
3656  if (ConvertedBase.isInvalid())
3657  return;
3658  Base = ConvertedBase.get();
3659 
3660  typedef CodeCompletionResult Result;
3661 
3662  QualType BaseType = Base->getType();
3663 
3664  if (IsArrow) {
3665  if (const PointerType *Ptr = BaseType->getAs<PointerType>())
3666  BaseType = Ptr->getPointeeType();
3667  else if (BaseType->isObjCObjectPointerType())
3668  /*Do nothing*/ ;
3669  else
3670  return;
3671  }
3672 
3673  enum CodeCompletionContext::Kind contextKind;
3674 
3675  if (IsArrow) {
3677  }
3678  else {
3679  if (BaseType->isObjCObjectPointerType() ||
3680  BaseType->isObjCObjectOrInterfaceType()) {
3682  }
3683  else {
3685  }
3686  }
3687 
3688  CodeCompletionContext CCContext(contextKind, BaseType);
3689  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3690  CodeCompleter->getCodeCompletionTUInfo(),
3691  CCContext,
3692  &ResultBuilder::IsMember);
3693  Results.EnterNewScope();
3694  if (const RecordType *Record = BaseType->getAs<RecordType>()) {
3695  // Indicate that we are performing a member access, and the cv-qualifiers
3696  // for the base object type.
3697  Results.setObjectTypeQualifiers(BaseType.getQualifiers());
3698 
3699  // Access to a C/C++ class, struct, or union.
3700  Results.allowNestedNameSpecifiers();
3701  CodeCompletionDeclConsumer Consumer(Results, CurContext);
3702  LookupVisibleDecls(Record->getDecl(), LookupMemberName, Consumer,
3703  CodeCompleter->includeGlobals());
3704 
3705  if (getLangOpts().CPlusPlus) {
3706  if (!Results.empty()) {
3707  // The "template" keyword can follow "->" or "." in the grammar.
3708  // However, we only want to suggest the template keyword if something
3709  // is dependent.
3710  bool IsDependent = BaseType->isDependentType();
3711  if (!IsDependent) {
3712  for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
3713  if (DeclContext *Ctx = DepScope->getEntity()) {
3714  IsDependent = Ctx->isDependentContext();
3715  break;
3716  }
3717  }
3718 
3719  if (IsDependent)
3720  Results.AddResult(Result("template"));
3721  }
3722  }
3723  } else if (!IsArrow && BaseType->getAsObjCInterfacePointerType()) {
3724  // Objective-C property reference.
3725  AddedPropertiesSet AddedProperties;
3726 
3727  // Add property results based on our interface.
3728  const ObjCObjectPointerType *ObjCPtr
3729  = BaseType->getAsObjCInterfacePointerType();
3730  assert(ObjCPtr && "Non-NULL pointer guaranteed above!");
3731  AddObjCProperties(CCContext, ObjCPtr->getInterfaceDecl(), true,
3732  /*AllowNullaryMethods=*/true, CurContext,
3733  AddedProperties, Results);
3734 
3735  // Add properties from the protocols in a qualified interface.
3736  for (auto *I : ObjCPtr->quals())
3737  AddObjCProperties(CCContext, I, true, /*AllowNullaryMethods=*/true,
3738  CurContext, AddedProperties, Results);
3739  } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
3740  (!IsArrow && BaseType->isObjCObjectType())) {
3741  // Objective-C instance variable access.
3742  ObjCInterfaceDecl *Class = nullptr;
3743  if (const ObjCObjectPointerType *ObjCPtr
3744  = BaseType->getAs<ObjCObjectPointerType>())
3745  Class = ObjCPtr->getInterfaceDecl();
3746  else
3747  Class = BaseType->getAs<ObjCObjectType>()->getInterface();
3748 
3749  // Add all ivars from this class and its superclasses.
3750  if (Class) {
3751  CodeCompletionDeclConsumer Consumer(Results, CurContext);
3752  Results.setFilter(&ResultBuilder::IsObjCIvar);
3753  LookupVisibleDecls(Class, LookupMemberName, Consumer,
3754  CodeCompleter->includeGlobals());
3755  }
3756  }
3757 
3758  // FIXME: How do we cope with isa?
3759 
3760  Results.ExitScope();
3761 
3762  // Hand off the results found for code completion.
3763  HandleCodeCompleteResults(this, CodeCompleter,
3764  Results.getCompletionContext(),
3765  Results.data(),Results.size());
3766 }
3767 
3768 void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
3769  if (!CodeCompleter)
3770  return;
3771 
3772  ResultBuilder::LookupFilter Filter = nullptr;
3775  switch ((DeclSpec::TST)TagSpec) {
3776  case DeclSpec::TST_enum:
3777  Filter = &ResultBuilder::IsEnum;
3778  ContextKind = CodeCompletionContext::CCC_EnumTag;
3779  break;
3780 
3781  case DeclSpec::TST_union:
3782  Filter = &ResultBuilder::IsUnion;
3784  break;
3785 
3786  case DeclSpec::TST_struct:
3787  case DeclSpec::TST_class:
3789  Filter = &ResultBuilder::IsClassOrStruct;
3791  break;
3792 
3793  default:
3794  llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
3795  }
3796 
3797  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3798  CodeCompleter->getCodeCompletionTUInfo(), ContextKind);
3799  CodeCompletionDeclConsumer Consumer(Results, CurContext);
3800 
3801  // First pass: look for tags.
3802  Results.setFilter(Filter);
3803  LookupVisibleDecls(S, LookupTagName, Consumer,
3804  CodeCompleter->includeGlobals());
3805 
3806  if (CodeCompleter->includeGlobals()) {
3807  // Second pass: look for nested name specifiers.
3808  Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
3809  LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer);
3810  }
3811 
3812  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3813  Results.data(),Results.size());
3814 }
3815 
3817  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3818  CodeCompleter->getCodeCompletionTUInfo(),
3820  Results.EnterNewScope();
3821  if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
3822  Results.AddResult("const");
3824  Results.AddResult("volatile");
3825  if (getLangOpts().C99 &&
3827  Results.AddResult("restrict");
3828  if (getLangOpts().C11 &&
3830  Results.AddResult("_Atomic");
3831  if (getLangOpts().MSVCCompat &&
3833  Results.AddResult("__unaligned");
3834  Results.ExitScope();
3835  HandleCodeCompleteResults(this, CodeCompleter,
3836  Results.getCompletionContext(),
3837  Results.data(), Results.size());
3838 }
3839 
3841  CodeCompleteExpression(S, QualType(getASTContext().getSizeType()));
3842 }
3843 
3845  if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
3846  return;
3847 
3848  SwitchStmt *Switch = getCurFunction()->SwitchStack.back();
3849  QualType type = Switch->getCond()->IgnoreImplicit()->getType();
3850  if (!type->isEnumeralType()) {
3851  CodeCompleteExpressionData Data(type);
3852  Data.IntegralConstantExpression = true;
3853  CodeCompleteExpression(S, Data);
3854  return;
3855  }
3856 
3857  // Code-complete the cases of a switch statement over an enumeration type
3858  // by providing the list of
3859  EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
3860  if (EnumDecl *Def = Enum->getDefinition())
3861  Enum = Def;
3862 
3863  // Determine which enumerators we have already seen in the switch statement.
3864  // FIXME: Ideally, we would also be able to look *past* the code-completion
3865  // token, in case we are code-completing in the middle of the switch and not
3866  // at the end. However, we aren't able to do so at the moment.
3867  llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen;
3868  NestedNameSpecifier *Qualifier = nullptr;
3869  for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
3870  SC = SC->getNextSwitchCase()) {
3871  CaseStmt *Case = dyn_cast<CaseStmt>(SC);
3872  if (!Case)
3873  continue;
3874 
3875  Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
3876  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal))
3877  if (EnumConstantDecl *Enumerator
3878  = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
3879  // We look into the AST of the case statement to determine which
3880  // enumerator was named. Alternatively, we could compute the value of
3881  // the integral constant expression, then compare it against the
3882  // values of each enumerator. However, value-based approach would not
3883  // work as well with C++ templates where enumerators declared within a
3884  // template are type- and value-dependent.
3885  EnumeratorsSeen.insert(Enumerator);
3886 
3887  // If this is a qualified-id, keep track of the nested-name-specifier
3888  // so that we can reproduce it as part of code completion, e.g.,
3889  //
3890  // switch (TagD.getKind()) {
3891  // case TagDecl::TK_enum:
3892  // break;
3893  // case XXX
3894  //
3895  // At the XXX, our completions are TagDecl::TK_union,
3896  // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
3897  // TK_struct, and TK_class.
3898  Qualifier = DRE->getQualifier();
3899  }
3900  }
3901 
3902  if (getLangOpts().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) {
3903  // If there are no prior enumerators in C++, check whether we have to
3904  // qualify the names of the enumerators that we suggest, because they
3905  // may not be visible in this scope.
3906  Qualifier = getRequiredQualification(Context, CurContext, Enum);
3907  }
3908 
3909  // Add any enumerators that have not yet been mentioned.
3910  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3911  CodeCompleter->getCodeCompletionTUInfo(),
3913  Results.EnterNewScope();
3914  for (auto *E : Enum->enumerators()) {
3915  if (EnumeratorsSeen.count(E))
3916  continue;
3917 
3918  CodeCompletionResult R(E, CCP_EnumInCase, Qualifier);
3919  Results.AddResult(R, CurContext, nullptr, false);
3920  }
3921  Results.ExitScope();
3922 
3923  //We need to make sure we're setting the right context,
3924  //so only say we include macros if the code completer says we do
3926  if (CodeCompleter->includeMacros()) {
3927  AddMacroResults(PP, Results, false);
3929  }
3930 
3931  HandleCodeCompleteResults(this, CodeCompleter,
3932  kind,
3933  Results.data(),Results.size());
3934 }
3935 
3936 static bool anyNullArguments(ArrayRef<Expr *> Args) {
3937  if (Args.size() && !Args.data())
3938  return true;
3939 
3940  for (unsigned I = 0; I != Args.size(); ++I)
3941  if (!Args[I])
3942  return true;
3943 
3944  return false;
3945 }
3946 
3948 
3949 static void mergeCandidatesWithResults(Sema &SemaRef,
3951  OverloadCandidateSet &CandidateSet,
3952  SourceLocation Loc) {
3953  if (!CandidateSet.empty()) {
3954  // Sort the overload candidate set by placing the best overloads first.
3955  std::stable_sort(
3956  CandidateSet.begin(), CandidateSet.end(),
3957  [&](const OverloadCandidate &X, const OverloadCandidate &Y) {
3958  return isBetterOverloadCandidate(SemaRef, X, Y, Loc);
3959  });
3960 
3961  // Add the remaining viable overload candidates as code-completion results.
3962  for (auto &Candidate : CandidateSet)
3963  if (Candidate.Viable)
3964  Results.push_back(ResultCandidate(Candidate.Function));
3965  }
3966 }
3967 
3968 /// \brief Get the type of the Nth parameter from a given set of overload
3969 /// candidates.
3970 static QualType getParamType(Sema &SemaRef,
3971  ArrayRef<ResultCandidate> Candidates,
3972  unsigned N) {
3973 
3974  // Given the overloads 'Candidates' for a function call matching all arguments
3975  // up to N, return the type of the Nth parameter if it is the same for all
3976  // overload candidates.
3977  QualType ParamType;
3978  for (auto &Candidate : Candidates) {
3979  if (auto FType = Candidate.getFunctionType())
3980  if (auto Proto = dyn_cast<FunctionProtoType>(FType))
3981  if (N < Proto->getNumParams()) {
3982  if (ParamType.isNull())
3983  ParamType = Proto->getParamType(N);
3984  else if (!SemaRef.Context.hasSameUnqualifiedType(
3985  ParamType.getNonReferenceType(),
3986  Proto->getParamType(N).getNonReferenceType()))
3987  // Otherwise return a default-constructed QualType.
3988  return QualType();
3989  }
3990  }
3991 
3992  return ParamType;
3993 }
3994 
3995 static void CodeCompleteOverloadResults(Sema &SemaRef, Scope *S,
3997  unsigned CurrentArg,
3998  bool CompleteExpressionWithCurrentArg = true) {
3999  QualType ParamType;
4000  if (CompleteExpressionWithCurrentArg)
4001  ParamType = getParamType(SemaRef, Candidates, CurrentArg);
4002 
4003  if (ParamType.isNull())
4005  else
4006  SemaRef.CodeCompleteExpression(S, ParamType);
4007 
4008  if (!Candidates.empty())
4009  SemaRef.CodeCompleter->ProcessOverloadCandidates(SemaRef, CurrentArg,
4010  Candidates.data(),
4011  Candidates.size());
4012 }
4013 
4015  if (!CodeCompleter)
4016  return;
4017 
4018  // When we're code-completing for a call, we fall back to ordinary
4019  // name code-completion whenever we can't produce specific
4020  // results. We may want to revisit this strategy in the future,
4021  // e.g., by merging the two kinds of results.
4022 
4023  // FIXME: Provide support for variadic template functions.
4024 
4025  // Ignore type-dependent call expressions entirely.
4026  if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args) ||
4028  CodeCompleteOrdinaryName(S, PCC_Expression);
4029  return;
4030  }
4031 
4032  // Build an overload candidate set based on the functions we find.
4033  SourceLocation Loc = Fn->getExprLoc();
4035 
4037 
4038  Expr *NakedFn = Fn->IgnoreParenCasts();
4039  if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
4040  AddOverloadedCallCandidates(ULE, Args, CandidateSet,
4041  /*PartialOverloading=*/true);
4042  else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) {
4043  TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
4044  if (UME->hasExplicitTemplateArgs()) {
4045  UME->copyTemplateArgumentsInto(TemplateArgsBuffer);
4046  TemplateArgs = &TemplateArgsBuffer;
4047  }
4048  SmallVector<Expr *, 12> ArgExprs(1, UME->getBase());
4049  ArgExprs.append(Args.begin(), Args.end());
4050  UnresolvedSet<8> Decls;
4051  Decls.append(UME->decls_begin(), UME->decls_end());
4052  AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs,
4053  /*SuppressUsedConversions=*/false,
4054  /*PartialOverloading=*/true);
4055  } else {
4056  FunctionDecl *FD = nullptr;
4057  if (auto MCE = dyn_cast<MemberExpr>(NakedFn))
4058  FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl());
4059  else if (auto DRE = dyn_cast<DeclRefExpr>(NakedFn))
4060  FD = dyn_cast<FunctionDecl>(DRE->getDecl());
4061  if (FD) { // We check whether it's a resolved function declaration.
4062  if (!getLangOpts().CPlusPlus ||
4063  !FD->getType()->getAs<FunctionProtoType>())
4064  Results.push_back(ResultCandidate(FD));
4065  else
4066  AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()),
4067  Args, CandidateSet,
4068  /*SuppressUsedConversions=*/false,
4069  /*PartialOverloading=*/true);
4070 
4071  } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) {
4072  // If expression's type is CXXRecordDecl, it may overload the function
4073  // call operator, so we check if it does and add them as candidates.
4074  // A complete type is needed to lookup for member function call operators.
4075  if (isCompleteType(Loc, NakedFn->getType())) {
4076  DeclarationName OpName = Context.DeclarationNames
4077  .getCXXOperatorName(OO_Call);
4078  LookupResult R(*this, OpName, Loc, LookupOrdinaryName);
4079  LookupQualifiedName(R, DC);
4080  R.suppressDiagnostics();
4081  SmallVector<Expr *, 12> ArgExprs(1, NakedFn);
4082  ArgExprs.append(Args.begin(), Args.end());
4083  AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet,
4084  /*ExplicitArgs=*/nullptr,
4085  /*SuppressUsedConversions=*/false,
4086  /*PartialOverloading=*/true);
4087  }
4088  } else {
4089  // Lastly we check whether expression's type is function pointer or
4090  // function.
4091  QualType T = NakedFn->getType();
4092  if (!T->getPointeeType().isNull())
4093  T = T->getPointeeType();
4094 
4095  if (auto FP = T->getAs<FunctionProtoType>()) {
4096  if (!TooManyArguments(FP->getNumParams(), Args.size(),
4097  /*PartialOverloading=*/true) ||
4098  FP->isVariadic())
4099  Results.push_back(ResultCandidate(FP));
4100  } else if (auto FT = T->getAs<FunctionType>())
4101  // No prototype and declaration, it may be a K & R style function.
4102  Results.push_back(ResultCandidate(FT));
4103  }
4104  }
4105 
4106  mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4107  CodeCompleteOverloadResults(*this, S, Results, Args.size(),
4108  !CandidateSet.empty());
4109 }
4110 
4112  ArrayRef<Expr *> Args) {
4113  if (!CodeCompleter)
4114  return;
4115 
4116  // A complete type is needed to lookup for constructors.
4117  if (!isCompleteType(Loc, Type))
4118  return;
4119 
4120  CXXRecordDecl *RD = Type->getAsCXXRecordDecl();
4121  if (!RD) {
4122  CodeCompleteExpression(S, Type);
4123  return;
4124  }
4125 
4126  // FIXME: Provide support for member initializers.
4127  // FIXME: Provide support for variadic template constructors.
4128 
4130 
4131  for (auto C : LookupConstructors(RD)) {
4132  if (auto FD = dyn_cast<FunctionDecl>(C)) {
4133  AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()),
4134  Args, CandidateSet,
4135  /*SuppressUsedConversions=*/false,
4136  /*PartialOverloading=*/true);
4137  } else if (auto FTD = dyn_cast<FunctionTemplateDecl>(C)) {
4138  AddTemplateOverloadCandidate(FTD,
4139  DeclAccessPair::make(FTD, C->getAccess()),
4140  /*ExplicitTemplateArgs=*/nullptr,
4141  Args, CandidateSet,
4142  /*SuppressUsedConversions=*/false,
4143  /*PartialOverloading=*/true);
4144  }
4145  }
4146 
4148  mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4149  CodeCompleteOverloadResults(*this, S, Results, Args.size());
4150 }
4151 
4153  ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
4154  if (!VD) {
4155  CodeCompleteOrdinaryName(S, PCC_Expression);
4156  return;
4157  }
4158 
4159  CodeCompleteExpression(S, VD->getType());
4160 }
4161 
4163  QualType ResultType;
4164  if (isa<BlockDecl>(CurContext)) {
4165  if (BlockScopeInfo *BSI = getCurBlock())
4166  ResultType = BSI->ReturnType;
4167  } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext))
4168  ResultType = Function->getReturnType();
4169  else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext))
4170  ResultType = Method->getReturnType();
4171 
4172  if (ResultType.isNull())
4173  CodeCompleteOrdinaryName(S, PCC_Expression);
4174  else
4175  CodeCompleteExpression(S, ResultType);
4176 }
4177 
4179  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4180  CodeCompleter->getCodeCompletionTUInfo(),
4181  mapCodeCompletionContext(*this, PCC_Statement));
4182  Results.setFilter(&ResultBuilder::IsOrdinaryName);
4183  Results.EnterNewScope();
4184 
4185  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4186  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4187  CodeCompleter->includeGlobals());
4188 
4189  AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
4190 
4191  // "else" block
4192  CodeCompletionBuilder Builder(Results.getAllocator(),
4193  Results.getCodeCompletionTUInfo());
4194  Builder.AddTypedTextChunk("else");
4195  if (Results.includeCodePatterns()) {
4199  Builder.AddPlaceholderChunk("statements");
4202  }
4203  Results.AddResult(Builder.TakeString());
4204 
4205  // "else if" block
4206  Builder.AddTypedTextChunk("else");
4208  Builder.AddTextChunk("if");
4211  if (getLangOpts().CPlusPlus)
4212  Builder.AddPlaceholderChunk("condition");
4213  else
4214  Builder.AddPlaceholderChunk("expression");
4216  if (Results.includeCodePatterns()) {
4220  Builder.AddPlaceholderChunk("statements");
4223  }
4224  Results.AddResult(Builder.TakeString());
4225 
4226  Results.ExitScope();
4227 
4228  if (S->getFnParent())
4229  AddPrettyFunctionResults(getLangOpts(), Results);
4230 
4231  if (CodeCompleter->includeMacros())
4232  AddMacroResults(PP, Results, false);
4233 
4234  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4235  Results.data(),Results.size());
4236 }
4237 
4239  if (LHS)
4240  CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType());
4241  else
4242  CodeCompleteOrdinaryName(S, PCC_Expression);
4243 }
4244 
4246  bool EnteringContext) {
4247  if (!SS.getScopeRep() || !CodeCompleter)
4248  return;
4249 
4250  DeclContext *Ctx = computeDeclContext(SS, EnteringContext);
4251  if (!Ctx)
4252  return;
4253 
4254  // Try to instantiate any non-dependent declaration contexts before
4255  // we look in them.
4256  if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
4257  return;
4258 
4259  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4260  CodeCompleter->getCodeCompletionTUInfo(),
4262  Results.EnterNewScope();
4263 
4264  // The "template" keyword can follow "::" in the grammar, but only
4265  // put it into the grammar if the nested-name-specifier is dependent.
4266  NestedNameSpecifier *NNS = SS.getScopeRep();
4267  if (!Results.empty() && NNS->isDependent())
4268  Results.AddResult("template");
4269 
4270  // Add calls to overridden virtual functions, if there are any.
4271  //
4272  // FIXME: This isn't wonderful, because we don't know whether we're actually
4273  // in a context that permits expressions. This is a general issue with
4274  // qualified-id completions.
4275  if (!EnteringContext)
4276  MaybeAddOverrideCalls(*this, Ctx, Results);
4277  Results.ExitScope();
4278 
4279  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4280  LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer);
4281 
4282  HandleCodeCompleteResults(this, CodeCompleter,
4283  Results.getCompletionContext(),
4284  Results.data(),Results.size());
4285 }
4286 
4288  if (!CodeCompleter)
4289  return;
4290 
4291  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4292  CodeCompleter->getCodeCompletionTUInfo(),
4294  &ResultBuilder::IsNestedNameSpecifier);
4295  Results.EnterNewScope();
4296 
4297  // If we aren't in class scope, we could see the "namespace" keyword.
4298  if (!S->isClassScope())
4299  Results.AddResult(CodeCompletionResult("namespace"));
4300 
4301  // After "using", we can see anything that would start a
4302  // nested-name-specifier.
4303  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4304  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4305  CodeCompleter->includeGlobals());
4306  Results.ExitScope();
4307 
4308  HandleCodeCompleteResults(this, CodeCompleter,
4310  Results.data(),Results.size());
4311 }
4312 
4314  if (!CodeCompleter)
4315  return;
4316 
4317  // After "using namespace", we expect to see a namespace name or namespace
4318  // alias.
4319  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4320  CodeCompleter->getCodeCompletionTUInfo(),
4322  &ResultBuilder::IsNamespaceOrAlias);
4323  Results.EnterNewScope();
4324  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4325  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4326  CodeCompleter->includeGlobals());
4327  Results.ExitScope();
4328  HandleCodeCompleteResults(this, CodeCompleter,
4330  Results.data(),Results.size());
4331 }
4332 
4334  if (!CodeCompleter)
4335  return;
4336 
4337  DeclContext *Ctx = S->getEntity();
4338  if (!S->getParent())
4339  Ctx = Context.getTranslationUnitDecl();
4340 
4341  bool SuppressedGlobalResults
4342  = Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
4343 
4344  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4345  CodeCompleter->getCodeCompletionTUInfo(),
4346  SuppressedGlobalResults
4349  &ResultBuilder::IsNamespace);
4350 
4351  if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
4352  // We only want to see those namespaces that have already been defined
4353  // within this scope, because its likely that the user is creating an
4354  // extended namespace declaration. Keep track of the most recent
4355  // definition of each namespace.
4356  std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
4358  NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end());
4359  NS != NSEnd; ++NS)
4360  OrigToLatest[NS->getOriginalNamespace()] = *NS;
4361 
4362  // Add the most recent definition (or extended definition) of each
4363  // namespace to the list of results.
4364  Results.EnterNewScope();
4366  NS = OrigToLatest.begin(),
4367  NSEnd = OrigToLatest.end();
4368  NS != NSEnd; ++NS)
4369  Results.AddResult(CodeCompletionResult(
4370  NS->second, Results.getBasePriority(NS->second),
4371  nullptr),
4372  CurContext, nullptr, false);
4373  Results.ExitScope();
4374  }
4375 
4376  HandleCodeCompleteResults(this, CodeCompleter,
4377  Results.getCompletionContext(),
4378  Results.data(),Results.size());
4379 }
4380 
4382  if (!CodeCompleter)
4383  return;
4384 
4385  // After "namespace", we expect to see a namespace or alias.
4386  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4387  CodeCompleter->getCodeCompletionTUInfo(),
4389  &ResultBuilder::IsNamespaceOrAlias);
4390  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4391  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4392  CodeCompleter->includeGlobals());
4393  HandleCodeCompleteResults(this, CodeCompleter,
4394  Results.getCompletionContext(),
4395  Results.data(),Results.size());
4396 }
4397 
4399  if (!CodeCompleter)
4400  return;
4401 
4402  typedef CodeCompletionResult Result;
4403  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4404  CodeCompleter->getCodeCompletionTUInfo(),
4406  &ResultBuilder::IsType);
4407  Results.EnterNewScope();
4408 
4409  // Add the names of overloadable operators.
4410 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4411  if (std::strcmp(Spelling, "?")) \
4412  Results.AddResult(Result(Spelling));
4413 #include "clang/Basic/OperatorKinds.def"
4414 
4415  // Add any type names visible from the current scope
4416  Results.allowNestedNameSpecifiers();
4417  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4418  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4419  CodeCompleter->includeGlobals());
4420 
4421  // Add any type specifiers
4422  AddTypeSpecifierResults(getLangOpts(), Results);
4423  Results.ExitScope();
4424 
4425  HandleCodeCompleteResults(this, CodeCompleter,
4427  Results.data(),Results.size());
4428 }
4429 
4431  Decl *ConstructorD,
4432  ArrayRef <CXXCtorInitializer *> Initializers) {
4433  if (!ConstructorD)
4434  return;
4435 
4436  AdjustDeclIfTemplate(ConstructorD);
4437 
4438  CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ConstructorD);
4439  if (!Constructor)
4440  return;
4441 
4442  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4443  CodeCompleter->getCodeCompletionTUInfo(),
4445  Results.EnterNewScope();
4446 
4447  // Fill in any already-initialized fields or base classes.
4448  llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
4449  llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
4450  for (unsigned I = 0, E = Initializers.size(); I != E; ++I) {
4451  if (Initializers[I]->isBaseInitializer())
4452  InitializedBases.insert(
4453  Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0)));
4454  else
4455  InitializedFields.insert(cast<FieldDecl>(
4456  Initializers[I]->getAnyMember()));
4457  }
4458 
4459  // Add completions for base classes.
4460  CodeCompletionBuilder Builder(Results.getAllocator(),
4461  Results.getCodeCompletionTUInfo());
4463  bool SawLastInitializer = Initializers.empty();
4464  CXXRecordDecl *ClassDecl = Constructor->getParent();
4465  for (const auto &Base : ClassDecl->bases()) {
4466  if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4467  .second) {
4468  SawLastInitializer
4469  = !Initializers.empty() &&
4470  Initializers.back()->isBaseInitializer() &&
4471  Context.hasSameUnqualifiedType(Base.getType(),
4472  QualType(Initializers.back()->getBaseClass(), 0));
4473  continue;
4474  }
4475 
4476  Builder.AddTypedTextChunk(
4477  Results.getAllocator().CopyString(
4478  Base.getType().getAsString(Policy)));
4480  Builder.AddPlaceholderChunk("args");
4482  Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4483  SawLastInitializer? CCP_NextInitializer
4485  SawLastInitializer = false;
4486  }
4487 
4488  // Add completions for virtual base classes.
4489  for (const auto &Base : ClassDecl->vbases()) {
4490  if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4491  .second) {
4492  SawLastInitializer
4493  = !Initializers.empty() &&
4494  Initializers.back()->isBaseInitializer() &&
4495  Context.hasSameUnqualifiedType(Base.getType(),
4496  QualType(Initializers.back()->getBaseClass(), 0));
4497  continue;
4498  }
4499 
4500  Builder.AddTypedTextChunk(
4501  Builder.getAllocator().CopyString(
4502  Base.getType().getAsString(Policy)));
4504  Builder.AddPlaceholderChunk("args");
4506  Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4507  SawLastInitializer? CCP_NextInitializer
4509  SawLastInitializer = false;
4510  }
4511 
4512  // Add completions for members.
4513  for (auto *Field : ClassDecl->fields()) {
4514  if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))
4515  .second) {
4516  SawLastInitializer
4517  = !Initializers.empty() &&
4518  Initializers.back()->isAnyMemberInitializer() &&
4519  Initializers.back()->getAnyMember() == Field;
4520  continue;
4521  }
4522 
4523  if (!Field->getDeclName())
4524  continue;
4525 
4526  Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
4527  Field->getIdentifier()->getName()));
4529  Builder.AddPlaceholderChunk("args");
4531  Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4532  SawLastInitializer? CCP_NextInitializer
4536  Field));
4537  SawLastInitializer = false;
4538  }
4539  Results.ExitScope();
4540 
4541  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4542  Results.data(), Results.size());
4543 }
4544 
4545 /// \brief Determine whether this scope denotes a namespace.
4546 static bool isNamespaceScope(Scope *S) {
4547  DeclContext *DC = S->getEntity();
4548  if (!DC)
4549  return false;
4550 
4551  return DC->isFileContext();
4552 }
4553 
4555  bool AfterAmpersand) {
4556  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4557  CodeCompleter->getCodeCompletionTUInfo(),
4559  Results.EnterNewScope();
4560 
4561  // Note what has already been captured.
4562  llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
4563  bool IncludedThis = false;
4564  for (const auto &C : Intro.Captures) {
4565  if (C.Kind == LCK_This) {
4566  IncludedThis = true;
4567  continue;
4568  }
4569 
4570  Known.insert(C.Id);
4571  }
4572 
4573  // Look for other capturable variables.
4574  for (; S && !isNamespaceScope(S); S = S->getParent()) {
4575  for (const auto *D : S->decls()) {
4576  const auto *Var = dyn_cast<VarDecl>(D);
4577  if (!Var ||
4578  !Var->hasLocalStorage() ||
4579  Var->hasAttr<BlocksAttr>())
4580  continue;
4581 
4582  if (Known.insert(Var->getIdentifier()).second)
4583  Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration),
4584  CurContext, nullptr, false);
4585  }
4586  }
4587 
4588  // Add 'this', if it would be valid.
4589  if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy)
4590  addThisCompletion(*this, Results);
4591 
4592  Results.ExitScope();
4593 
4594  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4595  Results.data(), Results.size());
4596 }
4597 
4598 /// Macro that optionally prepends an "@" to the string literal passed in via
4599 /// Keyword, depending on whether NeedAt is true or false.
4600 #define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) ((NeedAt)? "@" Keyword : Keyword)
4601 
4602 static void AddObjCImplementationResults(const LangOptions &LangOpts,
4603  ResultBuilder &Results,
4604  bool NeedAt) {
4605  typedef CodeCompletionResult Result;
4606  // Since we have an implementation, we can end it.
4607  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
4608 
4609  CodeCompletionBuilder Builder(Results.getAllocator(),
4610  Results.getCodeCompletionTUInfo());
4611  if (LangOpts.ObjC2) {
4612  // @dynamic
4613  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"dynamic"));
4615  Builder.AddPlaceholderChunk("property");
4616  Results.AddResult(Result(Builder.TakeString()));
4617 
4618  // @synthesize
4619  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synthesize"));
4621  Builder.AddPlaceholderChunk("property");
4622  Results.AddResult(Result(Builder.TakeString()));
4623  }
4624 }
4625 
4626 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
4627  ResultBuilder &Results,
4628  bool NeedAt) {
4629  typedef CodeCompletionResult Result;
4630 
4631  // Since we have an interface or protocol, we can end it.
4632  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
4633 
4634  if (LangOpts.ObjC2) {
4635  // @property
4636  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"property")));
4637 
4638  // @required
4639  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"required")));
4640 
4641  // @optional
4642  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"optional")));
4643  }
4644 }
4645 
4646 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
4647  typedef CodeCompletionResult Result;
4648  CodeCompletionBuilder Builder(Results.getAllocator(),
4649  Results.getCodeCompletionTUInfo());
4650 
4651  // @class name ;
4652  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"class"));
4654  Builder.AddPlaceholderChunk("name");
4655  Results.AddResult(Result(Builder.TakeString()));
4656 
4657  if (Results.includeCodePatterns()) {
4658  // @interface name
4659  // FIXME: Could introduce the whole pattern, including superclasses and
4660  // such.
4661  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"interface"));
4663  Builder.AddPlaceholderChunk("class");
4664  Results.AddResult(Result(Builder.TakeString()));
4665 
4666  // @protocol name
4667  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
4669  Builder.AddPlaceholderChunk("protocol");
4670  Results.AddResult(Result(Builder.TakeString()));
4671 
4672  // @implementation name
4673  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"implementation"));
4675  Builder.AddPlaceholderChunk("class");
4676  Results.AddResult(Result(Builder.TakeString()));
4677  }
4678 
4679  // @compatibility_alias name
4680  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"compatibility_alias"));
4682  Builder.AddPlaceholderChunk("alias");
4684  Builder.AddPlaceholderChunk("class");
4685  Results.AddResult(Result(Builder.TakeString()));
4686 
4687  if (Results.getSema().getLangOpts().Modules) {
4688  // @import name
4689  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import"));
4691  Builder.AddPlaceholderChunk("module");
4692  Results.AddResult(Result(Builder.TakeString()));
4693  }
4694 }
4695 
4697  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4698  CodeCompleter->getCodeCompletionTUInfo(),
4700  Results.EnterNewScope();
4701  if (isa<ObjCImplDecl>(CurContext))
4702  AddObjCImplementationResults(getLangOpts(), Results, false);
4703  else if (CurContext->isObjCContainer())
4704  AddObjCInterfaceResults(getLangOpts(), Results, false);
4705  else
4706  AddObjCTopLevelResults(Results, false);
4707  Results.ExitScope();
4708  HandleCodeCompleteResults(this, CodeCompleter,
4710  Results.data(),Results.size());
4711 }
4712 
4713 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
4714  typedef CodeCompletionResult Result;
4715  CodeCompletionBuilder Builder(Results.getAllocator(),
4716  Results.getCodeCompletionTUInfo());
4717 
4718  // @encode ( type-name )
4719  const char *EncodeType = "char[]";
4720  if (Results.getSema().getLangOpts().CPlusPlus ||
4721  Results.getSema().getLangOpts().ConstStrings)
4722  EncodeType = "const char[]";
4723  Builder.AddResultTypeChunk(EncodeType);
4724  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"encode"));
4726  Builder.AddPlaceholderChunk("type-name");
4728  Results.AddResult(Result(Builder.TakeString()));
4729 
4730  // @protocol ( protocol-name )
4731  Builder.AddResultTypeChunk("Protocol *");
4732  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
4734  Builder.AddPlaceholderChunk("protocol-name");
4736  Results.AddResult(Result(Builder.TakeString()));
4737 
4738  // @selector ( selector )
4739  Builder.AddResultTypeChunk("SEL");
4740  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"selector"));
4742  Builder.AddPlaceholderChunk("selector");
4744  Results.AddResult(Result(Builder.TakeString()));
4745 
4746  // @"string"
4747  Builder.AddResultTypeChunk("NSString *");
4748  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"\""));
4749  Builder.AddPlaceholderChunk("string");
4750  Builder.AddTextChunk("\"");
4751  Results.AddResult(Result(Builder.TakeString()));
4752 
4753  // @[objects, ...]
4754  Builder.AddResultTypeChunk("NSArray *");
4755  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"["));
4756  Builder.AddPlaceholderChunk("objects, ...");
4758  Results.AddResult(Result(Builder.TakeString()));
4759 
4760  // @{key : object, ...}
4761  Builder.AddResultTypeChunk("NSDictionary *");
4762  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"{"));
4763  Builder.AddPlaceholderChunk("key");
4766  Builder.AddPlaceholderChunk("object, ...");
4768  Results.AddResult(Result(Builder.TakeString()));
4769 
4770  // @(expression)
4771  Builder.AddResultTypeChunk("id");
4772  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "("));
4773  Builder.AddPlaceholderChunk("expression");
4775  Results.AddResult(Result(Builder.TakeString()));
4776 }
4777 
4778 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
4779  typedef CodeCompletionResult Result;
4780  CodeCompletionBuilder Builder(Results.getAllocator(),
4781  Results.getCodeCompletionTUInfo());
4782 
4783  if (Results.includeCodePatterns()) {
4784  // @try { statements } @catch ( declaration ) { statements } @finally
4785  // { statements }
4786  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"try"));
4788  Builder.AddPlaceholderChunk("statements");
4790  Builder.AddTextChunk("@catch");
4792  Builder.AddPlaceholderChunk("parameter");
4795  Builder.AddPlaceholderChunk("statements");
4797  Builder.AddTextChunk("@finally");
4799  Builder.AddPlaceholderChunk("statements");
4801  Results.AddResult(Result(Builder.TakeString()));
4802  }
4803 
4804  // @throw
4805  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"throw"));
4807  Builder.AddPlaceholderChunk("expression");
4808  Results.AddResult(Result(Builder.TakeString()));
4809 
4810  if (Results.includeCodePatterns()) {
4811  // @synchronized ( expression ) { statements }
4812  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synchronized"));
4815  Builder.AddPlaceholderChunk("expression");
4818  Builder.AddPlaceholderChunk("statements");
4820  Results.AddResult(Result(Builder.TakeString()));
4821  }
4822 }
4823 
4824 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
4825  ResultBuilder &Results,
4826  bool NeedAt) {
4827  typedef CodeCompletionResult Result;
4828  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"private")));
4829  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"protected")));
4830  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"public")));
4831  if (LangOpts.ObjC2)
4832  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"package")));
4833 }
4834 
4836  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4837  CodeCompleter->getCodeCompletionTUInfo(),
4839  Results.EnterNewScope();
4840  AddObjCVisibilityResults(getLangOpts(), Results, false);
4841  Results.ExitScope();
4842  HandleCodeCompleteResults(this, CodeCompleter,
4844  Results.data(),Results.size());
4845 }
4846 
4848  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4849  CodeCompleter->getCodeCompletionTUInfo(),
4851  Results.EnterNewScope();
4852  AddObjCStatementResults(Results, false);
4853  AddObjCExpressionResults(Results, false);
4854  Results.ExitScope();
4855  HandleCodeCompleteResults(this, CodeCompleter,
4857  Results.data(),Results.size());
4858 }
4859 
4861  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4862  CodeCompleter->getCodeCompletionTUInfo(),
4864  Results.EnterNewScope();
4865  AddObjCExpressionResults(Results, false);
4866  Results.ExitScope();
4867  HandleCodeCompleteResults(this, CodeCompleter,
4869  Results.data(),Results.size());
4870 }
4871 
4872 /// \brief Determine whether the addition of the given flag to an Objective-C
4873 /// property's attributes will cause a conflict.
4874 static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
4875  // Check if we've already added this flag.
4876  if (Attributes & NewFlag)
4877  return true;
4878 
4879  Attributes |= NewFlag;
4880 
4881  // Check for collisions with "readonly".
4882  if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
4883  (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
4884  return true;
4885 
4886  // Check for more than one of { assign, copy, retain, strong, weak }.
4887  unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign |
4893  if (AssignCopyRetMask &&
4894  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
4895  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
4896  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
4897  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
4898  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong &&
4899  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_weak)
4900  return true;
4901 
4902  return false;
4903 }
4904 
4906  if (!CodeCompleter)
4907  return;
4908 
4909  unsigned Attributes = ODS.getPropertyAttributes();
4910 
4911  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4912  CodeCompleter->getCodeCompletionTUInfo(),
4914  Results.EnterNewScope();
4916  Results.AddResult(CodeCompletionResult("readonly"));
4918  Results.AddResult(CodeCompletionResult("assign"));
4919  if (!ObjCPropertyFlagConflicts(Attributes,
4921  Results.AddResult(CodeCompletionResult("unsafe_unretained"));
4923  Results.AddResult(CodeCompletionResult("readwrite"));
4925  Results.AddResult(CodeCompletionResult("retain"));
4927  Results.AddResult(CodeCompletionResult("strong"));
4929  Results.AddResult(CodeCompletionResult("copy"));
4931  Results.AddResult(CodeCompletionResult("nonatomic"));
4933  Results.AddResult(CodeCompletionResult("atomic"));
4934 
4935  // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC.
4936  if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC)
4938  Results.AddResult(CodeCompletionResult("weak"));
4939 
4941  CodeCompletionBuilder Setter(Results.getAllocator(),
4942  Results.getCodeCompletionTUInfo());
4943  Setter.AddTypedTextChunk("setter");
4944  Setter.AddTextChunk("=");
4945  Setter.AddPlaceholderChunk("method");
4946  Results.AddResult(CodeCompletionResult(Setter.TakeString()));
4947  }
4949  CodeCompletionBuilder Getter(Results.getAllocator(),
4950  Results.getCodeCompletionTUInfo());
4951  Getter.AddTypedTextChunk("getter");
4952  Getter.AddTextChunk("=");
4953  Getter.AddPlaceholderChunk("method");
4954  Results.AddResult(CodeCompletionResult(Getter.TakeString()));
4955  }
4957  Results.AddResult(CodeCompletionResult("nonnull"));
4958  Results.AddResult(CodeCompletionResult("nullable"));
4959  Results.AddResult(CodeCompletionResult("null_unspecified"));
4960  Results.AddResult(CodeCompletionResult("null_resettable"));
4961  }
4962  Results.ExitScope();
4963  HandleCodeCompleteResults(this, CodeCompleter,
4965  Results.data(),Results.size());
4966 }
4967 
4968 /// \brief Describes the kind of Objective-C method that we want to find
4969 /// via code completion.
4971  MK_Any, ///< Any kind of method, provided it means other specified criteria.
4972  MK_ZeroArgSelector, ///< Zero-argument (unary) selector.
4973  MK_OneArgSelector ///< One-argument selector.
4974 };
4975 
4977  ObjCMethodKind WantKind,
4978  ArrayRef<IdentifierInfo *> SelIdents,
4979  bool AllowSameLength = true) {
4980  unsigned NumSelIdents = SelIdents.size();
4981  if (NumSelIdents > Sel.getNumArgs())
4982  return false;
4983 
4984  switch (WantKind) {
4985  case MK_Any: break;
4986  case MK_ZeroArgSelector: return Sel.isUnarySelector();
4987  case MK_OneArgSelector: return Sel.getNumArgs() == 1;
4988  }
4989 
4990  if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
4991  return false;
4992 
4993  for (unsigned I = 0; I != NumSelIdents; ++I)
4994  if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
4995  return false;
4996 
4997  return true;
4998 }
4999 
5001  ObjCMethodKind WantKind,
5002  ArrayRef<IdentifierInfo *> SelIdents,
5003  bool AllowSameLength = true) {
5004  return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
5005  AllowSameLength);
5006 }
5007 
5008 namespace {
5009  /// \brief A set of selectors, which is used to avoid introducing multiple
5010  /// completions with the same selector into the result set.
5011  typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
5012 }
5013 
5014 /// \brief Add all of the Objective-C methods in the given Objective-C
5015 /// container to the set of results.
5016 ///
5017 /// The container will be a class, protocol, category, or implementation of
5018 /// any of the above. This mether will recurse to include methods from
5019 /// the superclasses of classes along with their categories, protocols, and
5020 /// implementations.
5021 ///
5022 /// \param Container the container in which we'll look to find methods.
5023 ///
5024 /// \param WantInstanceMethods Whether to add instance methods (only); if
5025 /// false, this routine will add factory methods (only).
5026 ///
5027 /// \param CurContext the context in which we're performing the lookup that
5028 /// finds methods.
5029 ///
5030 /// \param AllowSameLength Whether we allow a method to be added to the list
5031 /// when it has the same number of parameters as we have selector identifiers.
5032 ///
5033 /// \param Results the structure into which we'll add results.
5034 static void AddObjCMethods(ObjCContainerDecl *Container,
5035  bool WantInstanceMethods,
5036  ObjCMethodKind WantKind,
5037  ArrayRef<IdentifierInfo *> SelIdents,
5038  DeclContext *CurContext,
5039  VisitedSelectorSet &Selectors,
5040  bool AllowSameLength,
5041  ResultBuilder &Results,
5042  bool InOriginalClass = true) {
5043  typedef CodeCompletionResult Result;
5044  Container = getContainerDef(Container);
5045  ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
5046  bool isRootClass = IFace && !IFace->getSuperClass();
5047  for (auto *M : Container->methods()) {
5048  // The instance methods on the root class can be messaged via the
5049  // metaclass.
5050  if (M->isInstanceMethod() == WantInstanceMethods ||
5051  (isRootClass && !WantInstanceMethods)) {
5052  // Check whether the selector identifiers we've been given are a
5053  // subset of the identifiers for this particular method.
5054  if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength))
5055  continue;
5056 
5057  if (!Selectors.insert(M->getSelector()).second)
5058  continue;
5059 
5060  Result R = Result(M, Results.getBasePriority(M), nullptr);
5061  R.StartParameter = SelIdents.size();
5062  R.AllParametersAreInformative = (WantKind != MK_Any);
5063  if (!InOriginalClass)
5064  R.Priority += CCD_InBaseClass;
5065  Results.MaybeAddResult(R, CurContext);
5066  }
5067  }
5068 
5069  // Visit the protocols of protocols.
5070  if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
5071  if (Protocol->hasDefinition()) {
5072  const ObjCList<ObjCProtocolDecl> &Protocols
5073  = Protocol->getReferencedProtocols();
5074  for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5075  E = Protocols.end();
5076  I != E; ++I)
5077  AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents,
5078  CurContext, Selectors, AllowSameLength, Results, false);
5079  }
5080  }
5081 
5082  if (!IFace || !IFace->hasDefinition())
5083  return;
5084 
5085  // Add methods in protocols.
5086  for (auto *I : IFace->protocols())
5087  AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents,
5088  CurContext, Selectors, AllowSameLength, Results, false);
5089 
5090  // Add methods in categories.
5091  for (auto *CatDecl : IFace->known_categories()) {
5092  AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
5093  CurContext, Selectors, AllowSameLength,
5094  Results, InOriginalClass);
5095 
5096  // Add a categories protocol methods.
5097  const ObjCList<ObjCProtocolDecl> &Protocols
5098  = CatDecl->getReferencedProtocols();
5099  for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5100  E = Protocols.end();
5101  I != E; ++I)
5102  AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents,
5103  CurContext, Selectors, AllowSameLength,
5104  Results, false);
5105 
5106  // Add methods in category implementations.
5107  if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation())
5108  AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents,
5109  CurContext, Selectors, AllowSameLength,
5110  Results, InOriginalClass);
5111  }
5112 
5113  // Add methods in superclass.
5114  if (IFace->getSuperClass())
5115  AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind,
5116  SelIdents, CurContext, Selectors,
5117  AllowSameLength, Results, false);
5118 
5119  // Add methods in our implementation, if any.
5120  if (ObjCImplementationDecl *Impl = IFace->getImplementation())
5121  AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents,
5122  CurContext, Selectors, AllowSameLength,
5123  Results, InOriginalClass);
5124 }
5125 
5126 
5128  // Try to find the interface where getters might live.
5129  ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5130  if (!Class) {
5132  = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5133  Class = Category->getClassInterface();
5134 
5135  if (!Class)
5136  return;
5137  }
5138 
5139  // Find all of the potential getters.
5140  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5141  CodeCompleter->getCodeCompletionTUInfo(),
5143  Results.EnterNewScope();
5144 
5145  VisitedSelectorSet Selectors;
5146  AddObjCMethods(Class, true, MK_ZeroArgSelector, None, CurContext, Selectors,
5147  /*AllowSameLength=*/true, Results);
5148  Results.ExitScope();
5149  HandleCodeCompleteResults(this, CodeCompleter,
5151  Results.data(),Results.size());
5152 }
5153 
5155  // Try to find the interface where setters might live.
5156  ObjCInterfaceDecl *Class
5157  = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext);
5158  if (!Class) {
5160  = dyn_cast_or_null<ObjCCategoryDecl>(CurContext))
5161  Class = Category->getClassInterface();
5162 
5163  if (!Class)
5164  return;
5165  }
5166 
5167  // Find all of the potential getters.
5168  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5169  CodeCompleter->getCodeCompletionTUInfo(),
5171  Results.EnterNewScope();
5172 
5173  VisitedSelectorSet Selectors;
5174  AddObjCMethods(Class, true, MK_OneArgSelector, None, CurContext,
5175  Selectors, /*AllowSameLength=*/true, Results);
5176 
5177  Results.ExitScope();
5178  HandleCodeCompleteResults(this, CodeCompleter,
5180  Results.data(),Results.size());
5181 }
5182 
5184  bool IsParameter) {
5185  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5186  CodeCompleter->getCodeCompletionTUInfo(),
5188  Results.EnterNewScope();
5189 
5190  // Add context-sensitive, Objective-C parameter-passing keywords.
5191  bool AddedInOut = false;
5192  if ((DS.getObjCDeclQualifier() &
5194  Results.AddResult("in");
5195  Results.AddResult("inout");
5196  AddedInOut = true;
5197  }
5198  if ((DS.getObjCDeclQualifier() &
5200  Results.AddResult("out");
5201  if (!AddedInOut)
5202  Results.AddResult("inout");
5203  }
5204  if ((DS.getObjCDeclQualifier() &
5206  ObjCDeclSpec::DQ_Oneway)) == 0) {
5207  Results.AddResult("bycopy");
5208  Results.AddResult("byref");
5209  Results.AddResult("oneway");
5210  }
5212  Results.AddResult("nonnull");
5213  Results.AddResult("nullable");
5214  Results.AddResult("null_unspecified");
5215  }
5216 
5217  // If we're completing the return type of an Objective-C method and the
5218  // identifier IBAction refers to a macro, provide a completion item for
5219  // an action, e.g.,
5220  // IBAction)<#selector#>:(id)sender
5221  if (DS.getObjCDeclQualifier() == 0 && !IsParameter &&
5222  PP.isMacroDefined("IBAction")) {
5223  CodeCompletionBuilder Builder(Results.getAllocator(),
5224  Results.getCodeCompletionTUInfo(),
5226  Builder.AddTypedTextChunk("IBAction");
5228  Builder.AddPlaceholderChunk("selector");
5231  Builder.AddTextChunk("id");
5233  Builder.AddTextChunk("sender");
5234  Results.AddResult(CodeCompletionResult(Builder.TakeString()));
5235  }
5236 
5237  // If we're completing the return type, provide 'instancetype'.
5238  if (!IsParameter) {
5239  Results.AddResult(CodeCompletionResult("instancetype"));
5240  }
5241 
5242  // Add various builtin type names and specifiers.
5243  AddOrdinaryNameResults(PCC_Type, S, *this, Results);
5244  Results.ExitScope();
5245 
5246  // Add the various type names
5247  Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
5248  CodeCompletionDeclConsumer Consumer(Results, CurContext);
5249  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5250  CodeCompleter->includeGlobals());
5251 
5252  if (CodeCompleter->includeMacros())
5253  AddMacroResults(PP, Results, false);
5254 
5255  HandleCodeCompleteResults(this, CodeCompleter,
5257  Results.data(), Results.size());
5258 }
5259 
5260 /// \brief When we have an expression with type "id", we may assume
5261 /// that it has some more-specific class type based on knowledge of
5262 /// common uses of Objective-C. This routine returns that class type,
5263 /// or NULL if no better result could be determined.
5265  ObjCMessageExpr *Msg = dyn_cast_or_null<ObjCMessageExpr>(E);
5266  if (!Msg)
5267  return nullptr;
5268 
5269  Selector Sel = Msg->getSelector();
5270  if (Sel.isNull())
5271  return nullptr;
5272 
5274  if (!Id)
5275  return nullptr;
5276 
5277  ObjCMethodDecl *Method = Msg->getMethodDecl();
5278  if (!Method)
5279  return nullptr;
5280 
5281  // Determine the class that we're sending the message to.
5282  ObjCInterfaceDecl *IFace = nullptr;
5283  switch (Msg->getReceiverKind()) {
5285  if (const ObjCObjectType *ObjType
5286  = Msg->getClassReceiver()->getAs<ObjCObjectType>())
5287  IFace = ObjType->getInterface();
5288  break;
5289 
5291  QualType T = Msg->getInstanceReceiver()->getType();
5292  if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>())
5293  IFace = Ptr->getInterfaceDecl();
5294  break;
5295  }
5296 
5299  break;
5300  }
5301 
5302  if (!IFace)
5303  return nullptr;
5304 
5305  ObjCInterfaceDecl *Super = IFace->getSuperClass();
5306  if (Method->isInstanceMethod())
5307  return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5308  .Case("retain", IFace)
5309  .Case("strong", IFace)
5310  .Case("autorelease", IFace)
5311  .Case("copy", IFace)
5312  .Case("copyWithZone", IFace)
5313  .Case("mutableCopy", IFace)
5314  .Case("mutableCopyWithZone", IFace)
5315  .Case("awakeFromCoder", IFace)
5316  .Case("replacementObjectFromCoder", IFace)
5317  .Case("class", IFace)
5318  .Case("classForCoder", IFace)
5319  .Case("superclass", Super)
5320  .Default(nullptr);
5321 
5322  return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName())
5323  .Case("new", IFace)
5324  .Case("alloc", IFace)
5325  .Case("allocWithZone", IFace)
5326  .Case("class", IFace)
5327  .Case("superclass", Super)
5328  .Default(nullptr);
5329 }
5330 
5331 // Add a special completion for a message send to "super", which fills in the
5332 // most likely case of forwarding all of our arguments to the superclass
5333 // function.
5334 ///
5335 /// \param S The semantic analysis object.
5336 ///
5337 /// \param NeedSuperKeyword Whether we need to prefix this completion with
5338 /// the "super" keyword. Otherwise, we just need to provide the arguments.
5339 ///
5340 /// \param SelIdents The identifiers in the selector that have already been
5341 /// provided as arguments for a send to "super".
5342 ///
5343 /// \param Results The set of results to augment.
5344 ///
5345 /// \returns the Objective-C method declaration that would be invoked by
5346 /// this "super" completion. If NULL, no completion was added.
5348  Sema &S, bool NeedSuperKeyword,
5349  ArrayRef<IdentifierInfo *> SelIdents,
5350  ResultBuilder &Results) {
5351  ObjCMethodDecl *CurMethod = S.getCurMethodDecl();
5352  if (!CurMethod)
5353  return nullptr;
5354 
5355  ObjCInterfaceDecl *Class = CurMethod->getClassInterface();
5356  if (!Class)
5357  return nullptr;
5358 
5359  // Try to find a superclass method with the same selector.
5360  ObjCMethodDecl *SuperMethod = nullptr;
5361  while ((Class = Class->getSuperClass()) && !SuperMethod) {
5362  // Check in the class
5363  SuperMethod = Class->getMethod(CurMethod->getSelector(),
5364  CurMethod->isInstanceMethod());
5365 
5366  // Check in categories or class extensions.
5367  if (!SuperMethod) {
5368  for (const auto *Cat : Class->known_categories()) {
5369  if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(),
5370  CurMethod->isInstanceMethod())))
5371  break;
5372  }
5373  }
5374  }
5375 
5376  if (!SuperMethod)
5377  return nullptr;
5378 
5379  // Check whether the superclass method has the same signature.
5380  if (CurMethod->param_size() != SuperMethod->param_size() ||
5381  CurMethod->isVariadic() != SuperMethod->isVariadic())
5382  return nullptr;
5383 
5384  for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(),
5385  CurPEnd = CurMethod->param_end(),
5386  SuperP = SuperMethod->param_begin();
5387  CurP != CurPEnd; ++CurP, ++SuperP) {
5388  // Make sure the parameter types are compatible.
5389  if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(),
5390  (*SuperP)->getType()))
5391  return nullptr;
5392 
5393  // Make sure we have a parameter name to forward!
5394  if (!(*CurP)->getIdentifier())
5395  return nullptr;
5396  }
5397 
5398  // We have a superclass method. Now, form the send-to-super completion.
5399  CodeCompletionBuilder Builder(Results.getAllocator(),
5400  Results.getCodeCompletionTUInfo());
5401 
5402  // Give this completion a return type.
5404  Results.getCompletionContext().getBaseType(),
5405  Builder);
5406 
5407  // If we need the "super" keyword, add it (plus some spacing).
5408  if (NeedSuperKeyword) {
5409  Builder.AddTypedTextChunk("super");
5411  }
5412 
5413  Selector Sel = CurMethod->getSelector();
5414  if (Sel.isUnarySelector()) {
5415  if (NeedSuperKeyword)
5416  Builder.AddTextChunk(Builder.getAllocator().CopyString(
5417  Sel.getNameForSlot(0)));
5418  else
5419  Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
5420  Sel.getNameForSlot(0)));
5421  } else {
5422  ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin();
5423  for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) {
5424  if (I > SelIdents.size())
5426 
5427  if (I < SelIdents.size())
5428  Builder.AddInformativeChunk(
5429  Builder.getAllocator().CopyString(
5430  Sel.getNameForSlot(I) + ":"));
5431  else if (NeedSuperKeyword || I > SelIdents.size()) {
5432  Builder.AddTextChunk(
5433  Builder.getAllocator().CopyString(
5434  Sel.getNameForSlot(I) + ":"));
5435  Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5436  (*CurP)->getIdentifier()->getName()));
5437  } else {
5438  Builder.AddTypedTextChunk(
5439  Builder.getAllocator().CopyString(
5440  Sel.getNameForSlot(I) + ":"));
5441  Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString(
5442  (*CurP)->getIdentifier()->getName()));
5443  }
5444  }
5445  }
5446 
5447  Results.AddResult(CodeCompletionResult(Builder.TakeString(), SuperMethod,
5449  return SuperMethod;
5450 }
5451 
5453  typedef CodeCompletionResult Result;
5454  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5455  CodeCompleter->getCodeCompletionTUInfo(),
5457  getLangOpts().CPlusPlus11
5458  ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture
5459  : &ResultBuilder::IsObjCMessageReceiver);
5460 
5461  CodeCompletionDeclConsumer Consumer(Results, CurContext);
5462  Results.EnterNewScope();
5463  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
5464  CodeCompleter->includeGlobals());
5465 
5466  // If we are in an Objective-C method inside a class that has a superclass,
5467  // add "super" as an option.
5468  if (ObjCMethodDecl *Method = getCurMethodDecl())
5469  if (ObjCInterfaceDecl *Iface = Method->getClassInterface())
5470  if (Iface->getSuperClass()) {
5471  Results.AddResult(Result("super"));
5472 
5473  AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, None, Results);
5474  }
5475 
5476  if (getLangOpts().CPlusPlus11)
5477  addThisCompletion(*this, Results);
5478 
5479  Results.ExitScope();
5480 
5481  if (CodeCompleter->includeMacros())
5482  AddMacroResults(PP, Results, false);
5483  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5484  Results.data(), Results.size());
5485 
5486 }
5487 
5489  ArrayRef<IdentifierInfo *> SelIdents,
5490  bool AtArgumentExpression) {
5491  ObjCInterfaceDecl *CDecl = nullptr;
5492  if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5493  // Figure out which interface we're in.
5494  CDecl = CurMethod->getClassInterface();
5495  if (!CDecl)
5496  return;
5497 
5498  // Find the superclass of this class.
5499  CDecl = CDecl->getSuperClass();
5500  if (!CDecl)
5501  return;
5502 
5503  if (CurMethod->isInstanceMethod()) {
5504  // We are inside an instance method, which means that the message
5505  // send [super ...] is actually calling an instance method on the
5506  // current object.
5507  return CodeCompleteObjCInstanceMessage(S, nullptr, SelIdents,
5508  AtArgumentExpression,
5509  CDecl);
5510  }
5511 
5512  // Fall through to send to the superclass in CDecl.
5513  } else {
5514  // "super" may be the name of a type or variable. Figure out which
5515  // it is.
5516  IdentifierInfo *Super = getSuperIdentifier();
5517  NamedDecl *ND = LookupSingleName(S, Super, SuperLoc,
5518  LookupOrdinaryName);
5519  if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) {
5520  // "super" names an interface. Use it.
5521  } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) {
5522  if (const ObjCObjectType *Iface
5523  = Context.getTypeDeclType(TD)->getAs<ObjCObjectType>())
5524  CDecl = Iface->getInterface();
5525  } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) {
5526  // "super" names an unresolved type; we can't be more specific.
5527  } else {
5528  // Assume that "super" names some kind of value and parse that way.
5529  CXXScopeSpec SS;
5530  SourceLocation TemplateKWLoc;
5531  UnqualifiedId id;
5532  id.setIdentifier(Super, SuperLoc);
5533  ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id,
5534  false, false);
5535  return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(),
5536  SelIdents,
5537  AtArgumentExpression);
5538  }
5539 
5540  // Fall through
5541  }
5542 
5543  ParsedType Receiver;
5544  if (CDecl)
5545  Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl));
5546  return CodeCompleteObjCClassMessage(S, Receiver, SelIdents,
5547  AtArgumentExpression,
5548  /*IsSuper=*/true);
5549 }
5550 
5551 /// \brief Given a set of code-completion results for the argument of a message
5552 /// send, determine the preferred type (if any) for that argument expression.
5553 static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
5554  unsigned NumSelIdents) {
5555  typedef CodeCompletionResult Result;
5556  ASTContext &Context = Results.getSema().Context;
5557 
5558  QualType PreferredType;
5559  unsigned BestPriority = CCP_Unlikely * 2;
5560  Result *ResultsData = Results.data();
5561  for (unsigned I = 0, N = Results.size(); I != N; ++I) {
5562  Result &R = ResultsData[I];
5563  if (R.Kind == Result::RK_Declaration &&
5564  isa<ObjCMethodDecl>(R.Declaration)) {
5565  if (R.Priority <= BestPriority) {
5566  const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
5567  if (NumSelIdents <= Method->param_size()) {
5568  QualType MyPreferredType = Method->parameters()[NumSelIdents - 1]
5569  ->getType();
5570  if (R.Priority < BestPriority || PreferredType.isNull()) {
5571  BestPriority = R.Priority;
5572  PreferredType = MyPreferredType;
5573  } else if (!Context.hasSameUnqualifiedType(PreferredType,
5574  MyPreferredType)) {
5575  PreferredType = QualType();
5576  }
5577  }
5578  }
5579  }
5580  }
5581 
5582  return PreferredType;
5583 }
5584 
5585 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
5586  ParsedType Receiver,
5587  ArrayRef<IdentifierInfo *> SelIdents,
5588  bool AtArgumentExpression,
5589  bool IsSuper,
5590  ResultBuilder &Results) {
5591  typedef CodeCompletionResult Result;
5592  ObjCInterfaceDecl *CDecl = nullptr;
5593 
5594  // If the given name refers to an interface type, retrieve the
5595  // corresponding declaration.
5596  if (Receiver) {
5597  QualType T = SemaRef.GetTypeFromParser(Receiver, nullptr);
5598  if (!T.isNull())
5599  if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>())
5600  CDecl = Interface->getInterface();
5601  }
5602 
5603  // Add all of the factory methods in this Objective-C class, its protocols,
5604  // superclasses, categories, implementation, etc.
5605  Results.EnterNewScope();
5606 
5607  // If this is a send-to-super, try to add the special "super" send
5608  // completion.
5609  if (IsSuper) {
5610  if (ObjCMethodDecl *SuperMethod
5611  = AddSuperSendCompletion(SemaRef, false, SelIdents, Results))
5612  Results.Ignore(SuperMethod);
5613  }
5614 
5615  // If we're inside an Objective-C method definition, prefer its selector to
5616  // others.
5617  if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl())
5618  Results.setPreferredSelector(CurMethod->getSelector());
5619 
5620  VisitedSelectorSet Selectors;
5621  if (CDecl)
5622  AddObjCMethods(CDecl, false, MK_Any, SelIdents,
5623  SemaRef.CurContext, Selectors, AtArgumentExpression,
5624  Results);
5625  else {
5626  // We're messaging "id" as a type; provide all class/factory methods.
5627 
5628  // If we have an external source, load the entire class method
5629  // pool from the AST file.
5630  if (SemaRef.getExternalSource()) {
5631  for (uint32_t I = 0,
5632  N = SemaRef.getExternalSource()->GetNumExternalSelectors();
5633  I != N; ++I) {
5634  Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(I);
5635  if (Sel.isNull() || SemaRef.MethodPool.count(Sel))
5636  continue;
5637 
5638  SemaRef.ReadMethodPool(Sel);
5639  }
5640  }
5641 
5642  for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(),
5643  MEnd = SemaRef.MethodPool.end();
5644  M != MEnd; ++M) {
5645  for (ObjCMethodList *MethList = &M->second.second;
5646  MethList && MethList->getMethod();
5647  MethList = MethList->getNext()) {
5648  if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
5649  continue;
5650 
5651  Result R(MethList->getMethod(),
5652  Results.getBasePriority(MethList->getMethod()), nullptr);
5653  R.StartParameter = SelIdents.size();
5654  R.AllParametersAreInformative = false;
5655  Results.MaybeAddResult(R, SemaRef.CurContext);
5656  }
5657  }
5658  }
5659 
5660  Results.ExitScope();
5661 }
5662 
5664  ArrayRef<IdentifierInfo *> SelIdents,
5665  bool AtArgumentExpression,
5666  bool IsSuper) {
5667 
5668  QualType T = this->GetTypeFromParser(Receiver);
5669 
5670  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5671  CodeCompleter->getCodeCompletionTUInfo(),
5673  T, SelIdents));
5674 
5675  AddClassMessageCompletions(*this, S, Receiver, SelIdents,
5676  AtArgumentExpression, IsSuper, Results);
5677 
5678  // If we're actually at the argument expression (rather than prior to the
5679  // selector), we're actually performing code completion for an expression.
5680  // Determine whether we have a single, best method. If so, we can
5681  // code-complete the expression using the corresponding parameter type as
5682  // our preferred type, improving completion results.
5683  if (AtArgumentExpression) {
5684  QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
5685  SelIdents.size());
5686  if (PreferredType.isNull())
5687  CodeCompleteOrdinaryName(S, PCC_Expression);
5688  else
5689  CodeCompleteExpression(S, PreferredType);
5690  return;
5691  }
5692 
5693  HandleCodeCompleteResults(this, CodeCompleter,
5694  Results.getCompletionContext(),
5695  Results.data(), Results.size());
5696 }
5697 
5699  ArrayRef<IdentifierInfo *> SelIdents,
5700  bool AtArgumentExpression,
5701  ObjCInterfaceDecl *Super) {
5702  typedef CodeCompletionResult Result;
5703 
5704  Expr *RecExpr = static_cast<Expr *>(Receiver);
5705 
5706  // If necessary, apply function/array conversion to the receiver.
5707  // C99 6.7.5.3p[7,8].
5708  if (RecExpr) {
5709  ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr);
5710  if (Conv.isInvalid()) // conversion failed. bail.
5711  return;
5712  RecExpr = Conv.get();
5713  }
5714  QualType ReceiverType = RecExpr? RecExpr->getType()
5715  : Super? Context.getObjCObjectPointerType(
5716  Context.getObjCInterfaceType(Super))
5717  : Context.getObjCIdType();
5718 
5719  // If we're messaging an expression with type "id" or "Class", check
5720  // whether we know something special about the receiver that allows
5721  // us to assume a more-specific receiver type.
5722  if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) {
5723  if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) {
5724  if (ReceiverType->isObjCClassType())
5725  return CodeCompleteObjCClassMessage(S,
5726  ParsedType::make(Context.getObjCInterfaceType(IFace)),
5727  SelIdents,
5728  AtArgumentExpression, Super);
5729 
5730  ReceiverType = Context.getObjCObjectPointerType(
5731  Context.getObjCInterfaceType(IFace));
5732  }
5733  } else if (RecExpr && getLangOpts().CPlusPlus) {
5734  ExprResult Conv = PerformContextuallyConvertToObjCPointer(RecExpr);
5735  if (Conv.isUsable()) {
5736  RecExpr = Conv.get();
5737  ReceiverType = RecExpr->getType();
5738  }
5739  }
5740 
5741  // Build the set of methods we can see.
5742  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5743  CodeCompleter->getCodeCompletionTUInfo(),
5745  ReceiverType, SelIdents));
5746 
5747  Results.EnterNewScope();
5748 
5749  // If this is a send-to-super, try to add the special "super" send
5750  // completion.
5751  if (Super) {
5752  if (ObjCMethodDecl *SuperMethod
5753  = AddSuperSendCompletion(*this, false, SelIdents, Results))
5754  Results.Ignore(SuperMethod);
5755  }
5756 
5757  // If we're inside an Objective-C method definition, prefer its selector to
5758  // others.
5759  if (ObjCMethodDecl *CurMethod = getCurMethodDecl())
5760  Results.setPreferredSelector(CurMethod->getSelector());
5761 
5762  // Keep track of the selectors we've already added.
5763  VisitedSelectorSet Selectors;
5764 
5765  // Handle messages to Class. This really isn't a message to an instance
5766  // method, so we treat it the same way we would treat a message send to a
5767  // class method.
5768  if (ReceiverType->isObjCClassType() ||
5769  ReceiverType->isObjCQualifiedClassType()) {
5770  if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) {
5771  if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface())
5772  AddObjCMethods(ClassDecl, false, MK_Any, SelIdents,
5773  CurContext, Selectors, AtArgumentExpression, Results);
5774  }
5775  }
5776  // Handle messages to a qualified ID ("id<foo>").
5777  else if (const ObjCObjectPointerType *QualID
5778  = ReceiverType->getAsObjCQualifiedIdType()) {
5779  // Search protocols for instance methods.
5780  for (auto *I : QualID->quals())
5781  AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
5782  Selectors, AtArgumentExpression, Results);
5783  }
5784  // Handle messages to a pointer to interface type.
5785  else if (const ObjCObjectPointerType *IFacePtr
5786  = ReceiverType->getAsObjCInterfacePointerType()) {
5787  // Search the class, its superclasses, etc., for instance methods.
5788  AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents,
5789  CurContext, Selectors, AtArgumentExpression,
5790  Results);
5791 
5792  // Search protocols for instance methods.
5793  for (auto *I : IFacePtr->quals())
5794  AddObjCMethods(I, true, MK_Any, SelIdents, CurContext,
5795  Selectors, AtArgumentExpression, Results);
5796  }
5797  // Handle messages to "id".
5798  else if (ReceiverType->isObjCIdType()) {
5799  // We're messaging "id", so provide all instance methods we know
5800  // about as code-completion results.
5801 
5802  // If we have an external source, load the entire class method
5803  // pool from the AST file.
5804  if (ExternalSource) {
5805  for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
5806  I != N; ++I) {
5807  Selector Sel = ExternalSource->GetExternalSelector(I);
5808  if (Sel.isNull() || MethodPool.count(Sel))
5809  continue;
5810 
5811  ReadMethodPool(Sel);
5812  }
5813  }
5814 
5815  for (GlobalMethodPool::iterator M = MethodPool.begin(),
5816  MEnd = MethodPool.end();
5817  M != MEnd; ++M) {
5818  for (ObjCMethodList *MethList = &M->second.first;
5819  MethList && MethList->getMethod();
5820  MethList = MethList->getNext()) {
5821  if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
5822  continue;
5823 
5824  if (!Selectors.insert(MethList->getMethod()->getSelector()).second)
5825  continue;
5826 
5827  Result R(MethList->getMethod(),
5828  Results.getBasePriority(MethList->getMethod()), nullptr);
5829  R.StartParameter = SelIdents.size();
5830  R.AllParametersAreInformative = false;
5831  Results.MaybeAddResult(R, CurContext);
5832  }
5833  }
5834  }
5835  Results.ExitScope();
5836 
5837 
5838  // If we're actually at the argument expression (rather than prior to the
5839  // selector), we're actually performing code completion for an expression.
5840  // Determine whether we have a single, best method. If so, we can
5841  // code-complete the expression using the corresponding parameter type as
5842  // our preferred type, improving completion results.
5843  if (AtArgumentExpression) {
5844  QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results,
5845  SelIdents.size());
5846  if (PreferredType.isNull())
5847  CodeCompleteOrdinaryName(S, PCC_Expression);
5848  else
5849  CodeCompleteExpression(S, PreferredType);
5850  return;
5851  }
5852 
5853  HandleCodeCompleteResults(this, CodeCompleter,
5854  Results.getCompletionContext(),
5855  Results.data(),Results.size());
5856 }
5857 
5859  DeclGroupPtrTy IterationVar) {
5861  Data.ObjCCollection = true;
5862 
5863  if (IterationVar.getAsOpaquePtr()) {
5864  DeclGroupRef DG = IterationVar.get();
5865  for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) {
5866  if (*I)
5867  Data.IgnoreDecls.push_back(*I);
5868  }
5869  }
5870 
5871  CodeCompleteExpression(S, Data);
5872 }
5873 
5875  ArrayRef<IdentifierInfo *> SelIdents) {
5876  // If we have an external source, load the entire class method
5877  // pool from the AST file.
5878  if (ExternalSource) {
5879  for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
5880  I != N; ++I) {
5881  Selector Sel = ExternalSource->GetExternalSelector(I);
5882  if (Sel.isNull() || MethodPool.count(Sel))
5883  continue;
5884 
5885  ReadMethodPool(Sel);
5886  }
5887  }
5888 
5889  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5890  CodeCompleter->getCodeCompletionTUInfo(),
5892  Results.EnterNewScope();
5893  for (GlobalMethodPool::iterator M = MethodPool.begin(),
5894  MEnd = MethodPool.end();
5895  M != MEnd; ++M) {
5896 
5897  Selector Sel = M->first;
5898  if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents))
5899  continue;
5900 
5901  CodeCompletionBuilder Builder(Results.getAllocator(),
5902  Results.getCodeCompletionTUInfo());
5903  if (Sel.isUnarySelector()) {
5904  Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
5905  Sel.getNameForSlot(0)));
5906  Results.AddResult(Builder.TakeString());
5907  continue;
5908  }
5909 
5910  std::string Accumulator;
5911  for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) {
5912  if (I == SelIdents.size()) {
5913  if (!Accumulator.empty()) {
5914  Builder.AddInformativeChunk(Builder.getAllocator().CopyString(
5915  Accumulator));
5916  Accumulator.clear();
5917  }
5918  }
5919 
5920  Accumulator += Sel.getNameForSlot(I);
5921  Accumulator += ':';
5922  }
5923  Builder.AddTypedTextChunk(Builder.getAllocator().CopyString( Accumulator));
5924  Results.AddResult(Builder.TakeString());
5925  }
5926  Results.ExitScope();
5927 
5928  HandleCodeCompleteResults(this, CodeCompleter,
5930  Results.data(), Results.size());
5931 }
5932 
5933 /// \brief Add all of the protocol declarations that we find in the given
5934 /// (translation unit) context.
5935 static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext,
5936  bool OnlyForwardDeclarations,
5937  ResultBuilder &Results) {
5938  typedef CodeCompletionResult Result;
5939 
5940  for (const auto *D : Ctx->decls()) {
5941  // Record any protocols we find.
5942  if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(D))
5943  if (!OnlyForwardDeclarations || !Proto->hasDefinition())
5944  Results.AddResult(Result(Proto, Results.getBasePriority(Proto),nullptr),
5945  CurContext, nullptr, false);
5946  }
5947 }
5948 
5950  ArrayRef<IdentifierLocPair> Protocols) {
5951  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5952  CodeCompleter->getCodeCompletionTUInfo(),
5954 
5955  if (CodeCompleter && CodeCompleter->includeGlobals()) {
5956  Results.EnterNewScope();
5957 
5958  // Tell the result set to ignore all of the protocols we have
5959  // already seen.
5960  // FIXME: This doesn't work when caching code-completion results.
5961  for (const IdentifierLocPair &Pair : Protocols)
5962  if (ObjCProtocolDecl *Protocol = LookupProtocol(Pair.first,
5963  Pair.second))
5964  Results.Ignore(Protocol);
5965 
5966  // Add all protocols.
5967  AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false,
5968  Results);
5969 
5970  Results.ExitScope();
5971  }
5972 
5973  HandleCodeCompleteResults(this, CodeCompleter,
5975  Results.data(),Results.size());
5976 }
5977 
5979  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5980  CodeCompleter->getCodeCompletionTUInfo(),
5982 
5983  if (CodeCompleter && CodeCompleter->includeGlobals()) {
5984  Results.EnterNewScope();
5985 
5986  // Add all protocols.
5987  AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true,
5988  Results);
5989 
5990  Results.ExitScope();
5991  }
5992 
5993  HandleCodeCompleteResults(this, CodeCompleter,
5995  Results.data(),Results.size());
5996 }
5997 
5998 /// \brief Add all of the Objective-C interface declarations that we find in
5999 /// the given (translation unit) context.
6000 static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext,
6001  bool OnlyForwardDeclarations,
6002  bool OnlyUnimplemented,
6003  ResultBuilder &Results) {
6004  typedef CodeCompletionResult Result;
6005 
6006  for (const auto *D : Ctx->decls()) {
6007  // Record any interfaces we find.
6008  if (const auto *Class = dyn_cast<ObjCInterfaceDecl>(D))
6009  if ((!OnlyForwardDeclarations || !Class->hasDefinition()) &&
6010  (!OnlyUnimplemented || !Class->getImplementation()))
6011  Results.AddResult(Result(Class, Results.getBasePriority(Class),nullptr),
6012  CurContext, nullptr, false);
6013  }
6014 }
6015 
6017  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6018  CodeCompleter->getCodeCompletionTUInfo(),
6020  Results.EnterNewScope();
6021 
6022  if (CodeCompleter->includeGlobals()) {
6023  // Add all classes.
6024  AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6025  false, Results);
6026  }
6027 
6028  Results.ExitScope();
6029 
6030  HandleCodeCompleteResults(this, CodeCompleter,
6032  Results.data(),Results.size());
6033 }
6034 
6036  SourceLocation ClassNameLoc) {
6037  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6038  CodeCompleter->getCodeCompletionTUInfo(),
6040  Results.EnterNewScope();
6041 
6042  // Make sure that we ignore the class we're currently defining.
6043  NamedDecl *CurClass
6044  = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6045  if (CurClass && isa<ObjCInterfaceDecl>(CurClass))
6046  Results.Ignore(CurClass);
6047 
6048  if (CodeCompleter->includeGlobals()) {
6049  // Add all classes.
6050  AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6051  false, Results);
6052  }
6053 
6054  Results.ExitScope();
6055 
6056  HandleCodeCompleteResults(this, CodeCompleter,
6058  Results.data(),Results.size());
6059 }
6060 
6062  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6063  CodeCompleter->getCodeCompletionTUInfo(),
6065  Results.EnterNewScope();
6066 
6067  if (CodeCompleter->includeGlobals()) {
6068  // Add all unimplemented classes.
6069  AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false,
6070  true, Results);
6071  }
6072 
6073  Results.ExitScope();
6074 
6075  HandleCodeCompleteResults(this, CodeCompleter,
6077  Results.data(),Results.size());
6078 }
6079 
6081  IdentifierInfo *ClassName,
6082  SourceLocation ClassNameLoc) {
6083  typedef CodeCompletionResult Result;
6084 
6085  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6086  CodeCompleter->getCodeCompletionTUInfo(),
6088 
6089  // Ignore any categories we find that have already been implemented by this
6090  // interface.
6091  llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6092  NamedDecl *CurClass
6093  = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6094  if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)){
6095  for (const auto *Cat : Class->visible_categories())
6096  CategoryNames.insert(Cat->getIdentifier());
6097  }
6098 
6099  // Add all of the categories we know about.
6100  Results.EnterNewScope();
6102  for (const auto *D : TU->decls())
6103  if (const auto *Category = dyn_cast<ObjCCategoryDecl>(D))
6104  if (CategoryNames.insert(Category->getIdentifier()).second)
6105  Results.AddResult(Result(Category, Results.getBasePriority(Category),
6106  nullptr),
6107  CurContext, nullptr, false);
6108  Results.ExitScope();
6109 
6110  HandleCodeCompleteResults(this, CodeCompleter,
6112  Results.data(),Results.size());
6113 }
6114 
6116  IdentifierInfo *ClassName,
6117  SourceLocation ClassNameLoc) {
6118  typedef CodeCompletionResult Result;
6119 
6120  // Find the corresponding interface. If we couldn't find the interface, the
6121  // program itself is ill-formed. However, we'll try to be helpful still by
6122  // providing the list of all of the categories we know about.
6123  NamedDecl *CurClass
6124  = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName);
6125  ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass);
6126  if (!Class)
6127  return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc);
6128 
6129  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6130  CodeCompleter->getCodeCompletionTUInfo(),
6132 
6133  // Add all of the categories that have have corresponding interface
6134  // declarations in this class and any of its superclasses, except for
6135  // already-implemented categories in the class itself.
6136  llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames;
6137  Results.EnterNewScope();
6138  bool IgnoreImplemented = true;
6139  while (Class) {
6140  for (const auto *Cat : Class->visible_categories()) {
6141  if ((!IgnoreImplemented || !Cat->getImplementation()) &&
6142  CategoryNames.insert(Cat->getIdentifier()).second)
6143  Results.AddResult(Result(Cat, Results.getBasePriority(Cat), nullptr),
6144  CurContext, nullptr, false);
6145  }
6146 
6147  Class = Class->getSuperClass();
6148  IgnoreImplemented = false;
6149  }
6150  Results.ExitScope();
6151 
6152  HandleCodeCompleteResults(this, CodeCompleter,
6154  Results.data(),Results.size());
6155 }
6156 
6159  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6160  CodeCompleter->getCodeCompletionTUInfo(),
6161  CCContext);
6162 
6163  // Figure out where this @synthesize lives.
6164  ObjCContainerDecl *Container
6165  = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6166  if (!Container ||
6167  (!isa<ObjCImplementationDecl>(Container) &&
6168  !isa<ObjCCategoryImplDecl>(Container)))
6169  return;
6170 
6171  // Ignore any properties that have already been implemented.
6172  Container = getContainerDef(Container);
6173  for (const auto *D : Container->decls())
6174  if (const auto *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(D))
6175  Results.Ignore(PropertyImpl->getPropertyDecl());
6176 
6177  // Add any properties that we find.
6178  AddedPropertiesSet AddedProperties;
6179  Results.EnterNewScope();
6180  if (ObjCImplementationDecl *ClassImpl
6181  = dyn_cast<ObjCImplementationDecl>(Container))
6182  AddObjCProperties(CCContext, ClassImpl->getClassInterface(), false,
6183  /*AllowNullaryMethods=*/false, CurContext,
6184  AddedProperties, Results);
6185  else
6186  AddObjCProperties(CCContext,
6187  cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(),
6188  false, /*AllowNullaryMethods=*/false, CurContext,
6189  AddedProperties, Results);
6190  Results.ExitScope();
6191 
6192  HandleCodeCompleteResults(this, CodeCompleter,
6194  Results.data(),Results.size());
6195 }
6196 
6198  IdentifierInfo *PropertyName) {
6199  typedef CodeCompletionResult Result;
6200  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
6201  CodeCompleter->getCodeCompletionTUInfo(),
6203 
6204  // Figure out where this @synthesize lives.
6205  ObjCContainerDecl *Container
6206  = dyn_cast_or_null<ObjCContainerDecl>(CurContext);
6207  if (!Container ||
6208  (!isa<ObjCImplementationDecl>(Container) &&
6209  !isa<ObjCCategoryImplDecl>(Container)))
6210  return;
6211 
6212  // Figure out which interface we're looking into.
6213  ObjCInterfaceDecl *Class = nullptr;
6214  if (ObjCImplementationDecl *ClassImpl
6215  = dyn_cast<ObjCImplementationDecl>(Container))
6216  Class = ClassImpl->getClassInterface();
6217  else
6218  Class = cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl()
6219  ->getClassInterface();
6220 
6221  // Determine the type of the property we're synthesizing.
6222  QualType PropertyType = Context.getObjCIdType();
6223  if (Class) {
6226  PropertyType
6227  = Property->getType().getNonReferenceType().getUnqualifiedType();
6228 
6229  // Give preference to ivars
6230  Results.setPreferredType(PropertyType);
6231  }
6232  }
6233 
6234  // Add all of the instance variables in this class and its superclasses.
6235  Results.EnterNewScope();
6236  bool SawSimilarlyNamedIvar = false;
6237  std::string NameWithPrefix;
6238  NameWithPrefix += '_';
6239  NameWithPrefix += PropertyName->getName();
6240  std::string NameWithSuffix = PropertyName->getName().str();
6241  NameWithSuffix += '_';
6242  for(; Class; Class = Class->getSuperClass()) {
6243  for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
6244  Ivar = Ivar->getNextIvar()) {
6245  Results.AddResult(Result(Ivar, Results.getBasePriority(Ivar), nullptr),
6246  CurContext, nullptr, false);
6247 
6248  // Determine whether we've seen an ivar with a name similar to the
6249  // property.
6250  if ((PropertyName == Ivar->getIdentifier() ||
6251  NameWithPrefix == Ivar->getName() ||
6252  NameWithSuffix == Ivar->getName())) {
6253  SawSimilarlyNamedIvar = true;
6254 
6255  // Reduce the priority of this result by one, to give it a slight
6256  // advantage over other results whose names don't match so closely.
6257  if (Results.size() &&
6258  Results.data()[Results.size() - 1].Kind
6260  Results.data()[Results.size() - 1].Declaration == Ivar)
6261  Results.data()[Results.size() - 1].Priority--;
6262  }
6263  }
6264  }
6265 
6266  if (!SawSimilarlyNamedIvar) {
6267  // Create ivar result _propName, that the user can use to synthesize
6268  // an ivar of the appropriate type.
6269  unsigned Priority = CCP_MemberDeclaration + 1;
6270  typedef CodeCompletionResult Result;
6271  CodeCompletionAllocator &Allocator = Results.getAllocator();
6272  CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(),
6273  Priority,CXAvailability_Available);
6274 
6276  Builder.AddResultTypeChunk(GetCompletionTypeString(PropertyType, Context,
6277  Policy, Allocator));
6278  Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix));
6279  Results.AddResult(Result(Builder.TakeString(), Priority,
6281  }
6282 
6283  Results.ExitScope();
6284 
6285  HandleCodeCompleteResults(this, CodeCompleter,
6287  Results.data(),Results.size());
6288 }
6289 
6290 // Mapping from selectors to the methods that implement that selector, along
6291 // with the "in original class" flag.
6292 typedef llvm::DenseMap<
6293  Selector, llvm::PointerIntPair<ObjCMethodDecl *, 1, bool> > KnownMethodsMap;
6294 
6295 /// \brief Find all of the methods that reside in the given container
6296 /// (and its superclasses, protocols, etc.) that meet the given
6297 /// criteria. Insert those methods into the map of known methods,
6298 /// indexed by selector so they can be easily found.
6300  ObjCContainerDecl *Container,
6301  bool WantInstanceMethods,
6302  QualType ReturnType,
6303  KnownMethodsMap &KnownMethods,
6304  bool InOriginalClass = true) {
6305  if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) {
6306  // Make sure we have a definition; that's what we'll walk.
6307  if (!IFace->hasDefinition())
6308  return;
6309 
6310  IFace = IFace->getDefinition();
6311  Container = IFace;
6312 
6313  const ObjCList<ObjCProtocolDecl> &Protocols
6314  = IFace->getReferencedProtocols();
6315  for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6316  E = Protocols.end();
6317  I != E; ++I)
6318  FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6319  KnownMethods, InOriginalClass);
6320 
6321  // Add methods from any class extensions and categories.
6322  for (auto *Cat : IFace->visible_categories()) {
6323  FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType,
6324  KnownMethods, false);
6325  }
6326 
6327  // Visit the superclass.
6328  if (IFace->getSuperClass())
6329  FindImplementableMethods(Context, IFace->getSuperClass(),
6330  WantInstanceMethods, ReturnType,
6331  KnownMethods, false);
6332  }
6333 
6334  if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) {
6335  // Recurse into protocols.
6336  const ObjCList<ObjCProtocolDecl> &Protocols
6337  = Category->getReferencedProtocols();
6338  for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6339  E = Protocols.end();
6340  I != E; ++I)
6341  FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6342  KnownMethods, InOriginalClass);
6343 
6344  // If this category is the original class, jump to the interface.
6345  if (InOriginalClass && Category->getClassInterface())
6346  FindImplementableMethods(Context, Category->getClassInterface(),
6347  WantInstanceMethods, ReturnType, KnownMethods,
6348  false);
6349  }
6350 
6351  if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
6352  // Make sure we have a definition; that's what we'll walk.
6353  if (!Protocol->hasDefinition())
6354  return;
6355  Protocol = Protocol->getDefinition();
6356  Container = Protocol;
6357 
6358  // Recurse into protocols.
6359  const ObjCList<ObjCProtocolDecl> &Protocols
6360  = Protocol->getReferencedProtocols();
6361  for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
6362  E = Protocols.end();
6363  I != E; ++I)
6364  FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType,
6365  KnownMethods, false);
6366  }
6367 
6368  // Add methods in this container. This operation occurs last because
6369  // we want the methods from this container to override any methods
6370  // we've previously seen with the same selector.
6371  for (auto *M : Container->methods()) {
6372  if (M->isInstanceMethod() == WantInstanceMethods) {
6373  if (!ReturnType.isNull() &&
6374  !Context.hasSameUnqualifiedType(ReturnType, M->getReturnType()))
6375  continue;
6376 
6377  KnownMethods[M->getSelector()] =
6378  KnownMethodsMap::mapped_type(M, InOriginalClass);
6379  }
6380  }
6381 }
6382 
6383 /// \brief Add the parenthesized return or parameter type chunk to a code
6384 /// completion string.
6386  unsigned ObjCDeclQuals,
6387  ASTContext &Context,
6388  const PrintingPolicy &Policy,
6391  std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals, Type);
6392  if (!Quals.empty())
6393  Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals));
6394  Builder.AddTextChunk(GetCompletionTypeString(Type, Context, Policy,
6395  Builder.getAllocator()));
6397 }
6398 
6399 /// \brief Determine whether the given class is or inherits from a class by
6400 /// the given name.
6402  StringRef Name) {
6403  if (!Class)
6404  return false;
6405 
6406  if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name)
6407  return true;
6408 
6409  return InheritsFromClassNamed(Class->getSuperClass(), Name);
6410 }
6411 
6412 /// \brief Add code completions for Objective-C Key-Value Coding (KVC) and
6413 /// Key-Value Observing (KVO).
6415  bool IsInstanceMethod,
6416  QualType ReturnType,
6417  ASTContext &Context,
6418  VisitedSelectorSet &KnownSelectors,
6419  ResultBuilder &Results) {
6420  IdentifierInfo *PropName = Property->getIdentifier();
6421  if (!PropName || PropName->getLength() == 0)
6422  return;
6423 
6424  PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
6425 
6426  // Builder that will create each code completion.
6427  typedef CodeCompletionResult Result;
6428  CodeCompletionAllocator &Allocator = Results.getAllocator();
6429  CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
6430 
6431  // The selector table.
6432  SelectorTable &Selectors = Context.Selectors;
6433 
6434  // The property name, copied into the code completion allocation region
6435  // on demand.
6436  struct KeyHolder {
6438  StringRef Key;
6439  const char *CopiedKey;
6440 
6441  KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key)
6442  : Allocator(Allocator), Key(Key), CopiedKey(nullptr) {}
6443 
6444  operator const char *() {
6445  if (CopiedKey)
6446  return CopiedKey;
6447 
6448  return CopiedKey = Allocator.CopyString(Key);
6449  }
6450  } Key(Allocator, PropName->getName());
6451 
6452  // The uppercased name of the property name.
6453  std::string UpperKey = PropName->getName();
6454  if (!UpperKey.empty())
6455  UpperKey[0] = toUppercase(UpperKey[0]);
6456 
6457  bool ReturnTypeMatchesProperty = ReturnType.isNull() ||
6458  Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(),
6459  Property->getType());
6460  bool ReturnTypeMatchesVoid
6461  = ReturnType.isNull() || ReturnType->isVoidType();
6462 
6463  // Add the normal accessor -(type)key.
6464  if (IsInstanceMethod &&
6465  KnownSelectors.insert(Selectors.getNullarySelector(PropName)).second &&
6466  ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) {
6467  if (ReturnType.isNull())
6468  AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6469  Context, Policy, Builder);
6470 
6471  Builder.AddTypedTextChunk(Key);
6472  Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6474  }
6475 
6476  // If we have an integral or boolean property (or the user has provided
6477  // an integral or boolean return type), add the accessor -(type)isKey.
6478  if (IsInstanceMethod &&
6479  ((!ReturnType.isNull() &&
6480  (ReturnType->isIntegerType() || ReturnType->isBooleanType())) ||
6481  (ReturnType.isNull() &&
6482  (Property->getType()->isIntegerType() ||
6483  Property->getType()->isBooleanType())))) {
6484  std::string SelectorName = (Twine("is") + UpperKey).str();
6485  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6486  if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6487  .second) {
6488  if (ReturnType.isNull()) {
6490  Builder.AddTextChunk("BOOL");
6492  }
6493 
6494  Builder.AddTypedTextChunk(
6495  Allocator.CopyString(SelectorId->getName()));
6496  Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6498  }
6499  }
6500 
6501  // Add the normal mutator.
6502  if (IsInstanceMethod && ReturnTypeMatchesVoid &&
6503  !Property->getSetterMethodDecl()) {
6504  std::string SelectorName = (Twine("set") + UpperKey).str();
6505  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6506  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6507  if (ReturnType.isNull()) {
6509  Builder.AddTextChunk("void");
6511  }
6512 
6513  Builder.AddTypedTextChunk(
6514  Allocator.CopyString(SelectorId->getName()));
6515  Builder.AddTypedTextChunk(":");
6516  AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0,
6517  Context, Policy, Builder);
6518  Builder.AddTextChunk(Key);
6519  Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
6521  }
6522  }
6523 
6524  // Indexed and unordered accessors
6525  unsigned IndexedGetterPriority = CCP_CodePattern;
6526  unsigned IndexedSetterPriority = CCP_CodePattern;
6527  unsigned UnorderedGetterPriority = CCP_CodePattern;
6528  unsigned UnorderedSetterPriority = CCP_CodePattern;
6529  if (const ObjCObjectPointerType *ObjCPointer
6530  = Property->getType()->getAs<ObjCObjectPointerType>()) {
6531  if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) {
6532  // If this interface type is not provably derived from a known
6533  // collection, penalize the corresponding completions.
6534  if (!InheritsFromClassNamed(IFace, "NSMutableArray")) {
6535  IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6536  if (!InheritsFromClassNamed(IFace, "NSArray"))
6537  IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6538  }
6539 
6540  if (!InheritsFromClassNamed(IFace, "NSMutableSet")) {
6541  UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6542  if (!InheritsFromClassNamed(IFace, "NSSet"))
6543  UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6544  }
6545  }
6546  } else {
6547  IndexedGetterPriority += CCD_ProbablyNotObjCCollection;
6548  IndexedSetterPriority += CCD_ProbablyNotObjCCollection;
6549  UnorderedGetterPriority += CCD_ProbablyNotObjCCollection;
6550  UnorderedSetterPriority += CCD_ProbablyNotObjCCollection;
6551  }
6552 
6553  // Add -(NSUInteger)countOf<key>
6554  if (IsInstanceMethod &&
6555  (ReturnType.isNull() || ReturnType->isIntegerType())) {
6556  std::string SelectorName = (Twine("countOf") + UpperKey).str();
6557  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6558  if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6559  .second) {
6560  if (ReturnType.isNull()) {
6562  Builder.AddTextChunk("NSUInteger");
6564  }
6565 
6566  Builder.AddTypedTextChunk(
6567  Allocator.CopyString(SelectorId->getName()));
6568  Results.AddResult(Result(Builder.TakeString(),
6569  std::min(IndexedGetterPriority,
6570  UnorderedGetterPriority),
6572  }
6573  }
6574 
6575  // Indexed getters
6576  // Add -(id)objectInKeyAtIndex:(NSUInteger)index
6577  if (IsInstanceMethod &&
6578  (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
6579  std::string SelectorName
6580  = (Twine("objectIn") + UpperKey + "AtIndex").str();
6581  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6582  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6583  if (ReturnType.isNull()) {
6585  Builder.AddTextChunk("id");
6587  }
6588 
6589  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6591  Builder.AddTextChunk("NSUInteger");
6593  Builder.AddTextChunk("index");
6594  Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6596  }
6597  }
6598 
6599  // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes
6600  if (IsInstanceMethod &&
6601  (ReturnType.isNull() ||
6602  (ReturnType->isObjCObjectPointerType() &&
6603  ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6604  ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6605  ->getName() == "NSArray"))) {
6606  std::string SelectorName
6607  = (Twine(Property->getName()) + "AtIndexes").str();
6608  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6609  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6610  if (ReturnType.isNull()) {
6612  Builder.AddTextChunk("NSArray *");
6614  }
6615 
6616  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6618  Builder.AddTextChunk("NSIndexSet *");
6620  Builder.AddTextChunk("indexes");
6621  Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6623  }
6624  }
6625 
6626  // Add -(void)getKey:(type **)buffer range:(NSRange)inRange
6627  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6628  std::string SelectorName = (Twine("get") + UpperKey).str();
6629  IdentifierInfo *SelectorIds[2] = {
6630  &Context.Idents.get(SelectorName),
6631  &Context.Idents.get("range")
6632  };
6633 
6634  if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6635  if (ReturnType.isNull()) {
6637  Builder.AddTextChunk("void");
6639  }
6640 
6641  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6643  Builder.AddPlaceholderChunk("object-type");
6644  Builder.AddTextChunk(" **");
6646  Builder.AddTextChunk("buffer");
6648  Builder.AddTypedTextChunk("range:");
6650  Builder.AddTextChunk("NSRange");
6652  Builder.AddTextChunk("inRange");
6653  Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority,
6655  }
6656  }
6657 
6658  // Mutable indexed accessors
6659 
6660  // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index
6661  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6662  std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str();
6663  IdentifierInfo *SelectorIds[2] = {
6664  &Context.Idents.get("insertObject"),
6665  &Context.Idents.get(SelectorName)
6666  };
6667 
6668  if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6669  if (ReturnType.isNull()) {
6671  Builder.AddTextChunk("void");
6673  }
6674 
6675  Builder.AddTypedTextChunk("insertObject:");
6677  Builder.AddPlaceholderChunk("object-type");
6678  Builder.AddTextChunk(" *");
6680  Builder.AddTextChunk("object");
6682  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6684  Builder.AddPlaceholderChunk("NSUInteger");
6686  Builder.AddTextChunk("index");
6687  Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6689  }
6690  }
6691 
6692  // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes
6693  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6694  std::string SelectorName = (Twine("insert") + UpperKey).str();
6695  IdentifierInfo *SelectorIds[2] = {
6696  &Context.Idents.get(SelectorName),
6697  &Context.Idents.get("atIndexes")
6698  };
6699 
6700  if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6701  if (ReturnType.isNull()) {
6703  Builder.AddTextChunk("void");
6705  }
6706 
6707  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6709  Builder.AddTextChunk("NSArray *");
6711  Builder.AddTextChunk("array");
6713  Builder.AddTypedTextChunk("atIndexes:");
6715  Builder.AddPlaceholderChunk("NSIndexSet *");
6717  Builder.AddTextChunk("indexes");
6718  Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6720  }
6721  }
6722 
6723  // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index
6724  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6725  std::string SelectorName
6726  = (Twine("removeObjectFrom") + UpperKey + "AtIndex").str();
6727  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6728  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6729  if (ReturnType.isNull()) {
6731  Builder.AddTextChunk("void");
6733  }
6734 
6735  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6737  Builder.AddTextChunk("NSUInteger");
6739  Builder.AddTextChunk("index");
6740  Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6742  }
6743  }
6744 
6745  // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes
6746  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6747  std::string SelectorName
6748  = (Twine("remove") + UpperKey + "AtIndexes").str();
6749  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6750  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6751  if (ReturnType.isNull()) {
6753  Builder.AddTextChunk("void");
6755  }
6756 
6757  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6759  Builder.AddTextChunk("NSIndexSet *");
6761  Builder.AddTextChunk("indexes");
6762  Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6764  }
6765  }
6766 
6767  // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object
6768  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6769  std::string SelectorName
6770  = (Twine("replaceObjectIn") + UpperKey + "AtIndex").str();
6771  IdentifierInfo *SelectorIds[2] = {
6772  &Context.Idents.get(SelectorName),
6773  &Context.Idents.get("withObject")
6774  };
6775 
6776  if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6777  if (ReturnType.isNull()) {
6779  Builder.AddTextChunk("void");
6781  }
6782 
6783  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6785  Builder.AddPlaceholderChunk("NSUInteger");
6787  Builder.AddTextChunk("index");
6789  Builder.AddTypedTextChunk("withObject:");
6791  Builder.AddTextChunk("id");
6793  Builder.AddTextChunk("object");
6794  Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6796  }
6797  }
6798 
6799  // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array
6800  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6801  std::string SelectorName1
6802  = (Twine("replace") + UpperKey + "AtIndexes").str();
6803  std::string SelectorName2 = (Twine("with") + UpperKey).str();
6804  IdentifierInfo *SelectorIds[2] = {
6805  &Context.Idents.get(SelectorName1),
6806  &Context.Idents.get(SelectorName2)
6807  };
6808 
6809  if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) {
6810  if (ReturnType.isNull()) {
6812  Builder.AddTextChunk("void");
6814  }
6815 
6816  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":"));
6818  Builder.AddPlaceholderChunk("NSIndexSet *");
6820  Builder.AddTextChunk("indexes");
6822  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":"));
6824  Builder.AddTextChunk("NSArray *");
6826  Builder.AddTextChunk("array");
6827  Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority,
6829  }
6830  }
6831 
6832  // Unordered getters
6833  // - (NSEnumerator *)enumeratorOfKey
6834  if (IsInstanceMethod &&
6835  (ReturnType.isNull() ||
6836  (ReturnType->isObjCObjectPointerType() &&
6837  ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
6838  ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
6839  ->getName() == "NSEnumerator"))) {
6840  std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str();
6841  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6842  if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
6843  .second) {
6844  if (ReturnType.isNull()) {
6846  Builder.AddTextChunk("NSEnumerator *");
6848  }
6849 
6850  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
6851  Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
6853  }
6854  }
6855 
6856  // - (type *)memberOfKey:(type *)object
6857  if (IsInstanceMethod &&
6858  (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) {
6859  std::string SelectorName = (Twine("memberOf") + UpperKey).str();
6860  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6861  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6862  if (ReturnType.isNull()) {
6864  Builder.AddPlaceholderChunk("object-type");
6865  Builder.AddTextChunk(" *");
6867  }
6868 
6869  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6871  if (ReturnType.isNull()) {
6872  Builder.AddPlaceholderChunk("object-type");
6873  Builder.AddTextChunk(" *");
6874  } else {
6875  Builder.AddTextChunk(GetCompletionTypeString(ReturnType, Context,
6876  Policy,
6877  Builder.getAllocator()));
6878  }
6880  Builder.AddTextChunk("object");
6881  Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority,
6883  }
6884  }
6885 
6886  // Mutable unordered accessors
6887  // - (void)addKeyObject:(type *)object
6888  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6889  std::string SelectorName
6890  = (Twine("add") + UpperKey + Twine("Object")).str();
6891  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6892  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6893  if (ReturnType.isNull()) {
6895  Builder.AddTextChunk("void");
6897  }
6898 
6899  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6901  Builder.AddPlaceholderChunk("object-type");
6902  Builder.AddTextChunk(" *");
6904  Builder.AddTextChunk("object");
6905  Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6907  }
6908  }
6909 
6910  // - (void)addKey:(NSSet *)objects
6911  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6912  std::string SelectorName = (Twine("add") + UpperKey).str();
6913  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6914  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6915  if (ReturnType.isNull()) {
6917  Builder.AddTextChunk("void");
6919  }
6920 
6921  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6923  Builder.AddTextChunk("NSSet *");
6925  Builder.AddTextChunk("objects");
6926  Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6928  }
6929  }
6930 
6931  // - (void)removeKeyObject:(type *)object
6932  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6933  std::string SelectorName
6934  = (Twine("remove") + UpperKey + Twine("Object")).str();
6935  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6936  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6937  if (ReturnType.isNull()) {
6939  Builder.AddTextChunk("void");
6941  }
6942 
6943  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6945  Builder.AddPlaceholderChunk("object-type");
6946  Builder.AddTextChunk(" *");
6948  Builder.AddTextChunk("object");
6949  Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6951  }
6952  }
6953 
6954  // - (void)removeKey:(NSSet *)objects
6955  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6956  std::string SelectorName = (Twine("remove") + UpperKey).str();
6957  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6958  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6959  if (ReturnType.isNull()) {
6961  Builder.AddTextChunk("void");
6963  }
6964 
6965  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6967  Builder.AddTextChunk("NSSet *");
6969  Builder.AddTextChunk("objects");
6970  Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6972  }
6973  }
6974 
6975  // - (void)intersectKey:(NSSet *)objects
6976  if (IsInstanceMethod && ReturnTypeMatchesVoid) {
6977  std::string SelectorName = (Twine("intersect") + UpperKey).str();
6978  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
6979  if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) {
6980  if (ReturnType.isNull()) {
6982  Builder.AddTextChunk("void");
6984  }
6985 
6986  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":"));
6988  Builder.AddTextChunk("NSSet *");
6990  Builder.AddTextChunk("objects");
6991  Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority,
6993  }
6994  }
6995 
6996  // Key-Value Observing
6997  // + (NSSet *)keyPathsForValuesAffectingKey
6998  if (!IsInstanceMethod &&
6999  (ReturnType.isNull() ||
7000  (ReturnType->isObjCObjectPointerType() &&
7001  ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() &&
7002  ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl()
7003  ->getName() == "NSSet"))) {
7004  std::string SelectorName
7005  = (Twine("keyPathsForValuesAffecting") + UpperKey).str();
7006  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7007  if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7008  .second) {
7009  if (ReturnType.isNull()) {
7011  Builder.AddTextChunk("NSSet *");
7013  }
7014 
7015  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7016  Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7018  }
7019  }
7020 
7021  // + (BOOL)automaticallyNotifiesObserversForKey
7022  if (!IsInstanceMethod &&
7023  (ReturnType.isNull() ||
7024  ReturnType->isIntegerType() ||
7025  ReturnType->isBooleanType())) {
7026  std::string SelectorName
7027  = (Twine("automaticallyNotifiesObserversOf") + UpperKey).str();
7028  IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName);
7029  if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId))
7030  .second) {
7031  if (ReturnType.isNull()) {
7033  Builder.AddTextChunk("BOOL");
7035  }
7036 
7037  Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName));
7038  Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern,
7040  }
7041  }
7042 }
7043 
7045  bool IsInstanceMethod,
7046  ParsedType ReturnTy) {
7047  // Determine the return type of the method we're declaring, if
7048  // provided.
7049  QualType ReturnType = GetTypeFromParser(ReturnTy);
7050  Decl *IDecl = nullptr;
7051  if (CurContext->isObjCContainer()) {
7052  ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext);
7053  IDecl = cast<Decl>(OCD);
7054  }
7055  // Determine where we should start searching for methods.
7056  ObjCContainerDecl *SearchDecl = nullptr;
7057  bool IsInImplementation = false;
7058  if (Decl *D = IDecl) {
7059  if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) {
7060  SearchDecl = Impl->getClassInterface();
7061  IsInImplementation = true;
7062  } else if (ObjCCategoryImplDecl *CatImpl
7063  = dyn_cast<ObjCCategoryImplDecl>(D)) {
7064  SearchDecl = CatImpl->getCategoryDecl();
7065  IsInImplementation = true;
7066  } else
7067  SearchDecl = dyn_cast<ObjCContainerDecl>(D);
7068  }
7069 
7070  if (!SearchDecl && S) {
7071  if (DeclContext *DC = S->getEntity())
7072  SearchDecl = dyn_cast<ObjCContainerDecl>(DC);
7073  }
7074 
7075  if (!SearchDecl) {
7076  HandleCodeCompleteResults(this, CodeCompleter,
7078  nullptr, 0);
7079  return;
7080  }
7081 
7082  // Find all of the methods that we could declare/implement here.
7083  KnownMethodsMap KnownMethods;
7084  FindImplementableMethods(Context, SearchDecl, IsInstanceMethod,
7085  ReturnType, KnownMethods);
7086 
7087  // Add declarations or definitions for each of the known methods.
7088  typedef CodeCompletionResult Result;
7089  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7090  CodeCompleter->getCodeCompletionTUInfo(),
7092  Results.EnterNewScope();
7094  for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7095  MEnd = KnownMethods.end();
7096  M != MEnd; ++M) {
7097  ObjCMethodDecl *Method = M->second.getPointer();
7098  CodeCompletionBuilder Builder(Results.getAllocator(),
7099  Results.getCodeCompletionTUInfo());
7100 
7101  // If the result type was not already provided, add it to the
7102  // pattern as (type).
7103  if (ReturnType.isNull()) {
7104  QualType ResTy = Method->getSendResultType().stripObjCKindOfType(Context);
7107  Method->getObjCDeclQualifier(), Context, Policy,
7108  Builder);
7109  }
7110 
7111  Selector Sel = Method->getSelector();
7112 
7113  // Add the first part of the selector to the pattern.
7114  Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7115  Sel.getNameForSlot(0)));
7116 
7117  // Add parameters to the pattern.
7118  unsigned I = 0;
7119  for (ObjCMethodDecl::param_iterator P = Method->param_begin(),
7120  PEnd = Method->param_end();
7121  P != PEnd; (void)++P, ++I) {
7122  // Add the part of the selector name.
7123  if (I == 0)
7124  Builder.AddTypedTextChunk(":");
7125  else if (I < Sel.getNumArgs()) {
7127  Builder.AddTypedTextChunk(
7128  Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":"));
7129  } else
7130  break;
7131 
7132  // Add the parameter type.
7133  QualType ParamType;
7134  if ((*P)->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
7135  ParamType = (*P)->getType();
7136  else
7137  ParamType = (*P)->getOriginalType();
7138  ParamType = ParamType.substObjCTypeArgs(Context, {},
7141  AddObjCPassingTypeChunk(ParamType,
7142  (*P)->getObjCDeclQualifier(),
7143  Context, Policy,
7144  Builder);
7145 
7146  if (IdentifierInfo *Id = (*P)->getIdentifier())
7147  Builder.AddTextChunk(Builder.getAllocator().CopyString( Id->getName()));
7148  }
7149 
7150  if (Method->isVariadic()) {
7151  if (Method->param_size() > 0)
7153  Builder.AddTextChunk("...");
7154  }
7155 
7156  if (IsInImplementation && Results.includeCodePatterns()) {
7157  // We will be defining the method here, so add a compound statement.
7161  if (!Method->getReturnType()->isVoidType()) {
7162  // If the result type is not void, add a return clause.
7163  Builder.AddTextChunk("return");
7165  Builder.AddPlaceholderChunk("expression");
7167  } else
7168  Builder.AddPlaceholderChunk("statements");
7169 
7172  }
7173 
7174  unsigned Priority = CCP_CodePattern;
7175  if (!M->second.getInt())
7176  Priority += CCD_InBaseClass;
7177 
7178  Results.AddResult(Result(Builder.TakeString(), Method, Priority));
7179  }
7180 
7181  // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
7182  // the properties in this class and its categories.
7183  if (Context.getLangOpts().ObjC2) {
7185  Containers.push_back(SearchDecl);
7186 
7187  VisitedSelectorSet KnownSelectors;
7188  for (KnownMethodsMap::iterator M = KnownMethods.begin(),
7189  MEnd = KnownMethods.end();
7190  M != MEnd; ++M)
7191  KnownSelectors.insert(M->first);
7192 
7193 
7194  ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl);
7195  if (!IFace)
7196  if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl))
7197  IFace = Category->getClassInterface();
7198 
7199  if (IFace)
7200  for (auto *Cat : IFace->visible_categories())
7201  Containers.push_back(Cat);
7202 
7203  for (unsigned I = 0, N = Containers.size(); I != N; ++I)
7204  for (auto *P : Containers[I]->instance_properties())
7205  AddObjCKeyValueCompletions(P, IsInstanceMethod, ReturnType, Context,
7206  KnownSelectors, Results);
7207  }
7208 
7209  Results.ExitScope();
7210 
7211  HandleCodeCompleteResults(this, CodeCompleter,
7213  Results.data(),Results.size());
7214 }
7215 
7217  bool IsInstanceMethod,
7218  bool AtParameterName,
7219  ParsedType ReturnTy,
7220  ArrayRef<IdentifierInfo *> SelIdents) {
7221  // If we have an external source, load the entire class method
7222  // pool from the AST file.
7223  if (ExternalSource) {
7224  for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors();
7225  I != N; ++I) {
7226  Selector Sel = ExternalSource->GetExternalSelector(I);
7227  if (Sel.isNull() || MethodPool.count(Sel))
7228  continue;
7229 
7230  ReadMethodPool(Sel);
7231  }
7232  }
7233 
7234  // Build the set of methods we can see.
7235  typedef CodeCompletionResult Result;
7236  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7237  CodeCompleter->getCodeCompletionTUInfo(),
7239 
7240  if (ReturnTy)
7241  Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType());
7242 
7243  Results.EnterNewScope();
7244  for (GlobalMethodPool::iterator M = MethodPool.begin(),
7245  MEnd = MethodPool.end();
7246  M != MEnd; ++M) {
7247  for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first :
7248  &M->second.second;
7249  MethList && MethList->getMethod();
7250  MethList = MethList->getNext()) {
7251  if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents))
7252  continue;
7253 
7254  if (AtParameterName) {
7255  // Suggest parameter names we've seen before.
7256  unsigned NumSelIdents = SelIdents.size();
7257  if (NumSelIdents &&
7258  NumSelIdents <= MethList->getMethod()->param_size()) {
7259  ParmVarDecl *Param =
7260  MethList->getMethod()->parameters()[NumSelIdents - 1];
7261  if (Param->getIdentifier()) {
7262  CodeCompletionBuilder Builder(Results.getAllocator(),
7263  Results.getCodeCompletionTUInfo());
7264  Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7265  Param->getIdentifier()->getName()));
7266  Results.AddResult(Builder.TakeString());
7267  }
7268  }
7269 
7270  continue;
7271  }
7272 
7273  Result R(MethList->getMethod(),
7274  Results.getBasePriority(MethList->getMethod()), nullptr);
7275  R.StartParameter = SelIdents.size();
7276  R.AllParametersAreInformative = false;
7277  R.DeclaringEntity = true;
7278  Results.MaybeAddResult(R, CurContext);
7279  }
7280  }
7281 
7282  Results.ExitScope();
7283  HandleCodeCompleteResults(this, CodeCompleter,
7285  Results.data(),Results.size());
7286 }
7287 
7289  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7290  CodeCompleter->getCodeCompletionTUInfo(),
7292  Results.EnterNewScope();
7293 
7294  // #if <condition>
7295  CodeCompletionBuilder Builder(Results.getAllocator(),
7296  Results.getCodeCompletionTUInfo());
7297  Builder.AddTypedTextChunk("if");
7299  Builder.AddPlaceholderChunk("condition");
7300  Results.AddResult(Builder.TakeString());
7301 
7302  // #ifdef <macro>
7303  Builder.AddTypedTextChunk("ifdef");
7305  Builder.AddPlaceholderChunk("macro");
7306  Results.AddResult(Builder.TakeString());
7307 
7308  // #ifndef <macro>
7309  Builder.AddTypedTextChunk("ifndef");
7311  Builder.AddPlaceholderChunk("macro");
7312  Results.AddResult(Builder.TakeString());
7313 
7314  if (InConditional) {
7315  // #elif <condition>
7316  Builder.AddTypedTextChunk("elif");
7318  Builder.AddPlaceholderChunk("condition");
7319  Results.AddResult(Builder.TakeString());
7320 
7321  // #else
7322  Builder.AddTypedTextChunk("else");
7323  Results.AddResult(Builder.TakeString());
7324 
7325  // #endif
7326  Builder.AddTypedTextChunk("endif");
7327  Results.AddResult(Builder.TakeString());
7328  }
7329 
7330  // #include "header"
7331  Builder.AddTypedTextChunk("include");
7333  Builder.AddTextChunk("\"");
7334  Builder.AddPlaceholderChunk("header");
7335  Builder.AddTextChunk("\"");
7336  Results.AddResult(Builder.TakeString());
7337 
7338  // #include <header>
7339  Builder.AddTypedTextChunk("include");
7341  Builder.AddTextChunk("<");
7342  Builder.AddPlaceholderChunk("header");
7343  Builder.AddTextChunk(">");
7344  Results.AddResult(Builder.TakeString());
7345 
7346  // #define <macro>
7347  Builder.AddTypedTextChunk("define");
7349  Builder.AddPlaceholderChunk("macro");
7350  Results.AddResult(Builder.TakeString());
7351 
7352  // #define <macro>(<args>)
7353  Builder.AddTypedTextChunk("define");
7355  Builder.AddPlaceholderChunk("macro");
7357  Builder.AddPlaceholderChunk("args");
7359  Results.AddResult(Builder.TakeString());
7360 
7361  // #undef <macro>
7362  Builder.AddTypedTextChunk("undef");
7364  Builder.AddPlaceholderChunk("macro");
7365  Results.AddResult(Builder.TakeString());
7366 
7367  // #line <number>
7368  Builder.AddTypedTextChunk("line");
7370  Builder.AddPlaceholderChunk("number");
7371  Results.AddResult(Builder.TakeString());
7372 
7373  // #line <number> "filename"
7374  Builder.AddTypedTextChunk("line");
7376  Builder.AddPlaceholderChunk("number");
7378  Builder.AddTextChunk("\"");
7379  Builder.AddPlaceholderChunk("filename");
7380  Builder.AddTextChunk("\"");
7381  Results.AddResult(Builder.TakeString());
7382 
7383  // #error <message>
7384  Builder.AddTypedTextChunk("error");
7386  Builder.AddPlaceholderChunk("message");
7387  Results.AddResult(Builder.TakeString());
7388 
7389  // #pragma <arguments>
7390  Builder.AddTypedTextChunk("pragma");
7392  Builder.AddPlaceholderChunk("arguments");
7393  Results.AddResult(Builder.TakeString());
7394 
7395  if (getLangOpts().ObjC1) {
7396  // #import "header"
7397  Builder.AddTypedTextChunk("import");
7399  Builder.AddTextChunk("\"");
7400  Builder.AddPlaceholderChunk("header");
7401  Builder.AddTextChunk("\"");
7402  Results.AddResult(Builder.TakeString());
7403 
7404  // #import <header>
7405  Builder.AddTypedTextChunk("import");
7407  Builder.AddTextChunk("<");
7408  Builder.AddPlaceholderChunk("header");
7409  Builder.AddTextChunk(">");
7410  Results.AddResult(Builder.TakeString());
7411  }
7412 
7413  // #include_next "header"
7414  Builder.AddTypedTextChunk("include_next");
7416  Builder.AddTextChunk("\"");
7417  Builder.AddPlaceholderChunk("header");
7418  Builder.AddTextChunk("\"");
7419  Results.AddResult(Builder.TakeString());
7420 
7421  // #include_next <header>
7422  Builder.AddTypedTextChunk("include_next");
7424  Builder.AddTextChunk("<");
7425  Builder.AddPlaceholderChunk("header");
7426  Builder.AddTextChunk(">");
7427  Results.AddResult(Builder.TakeString());
7428 
7429  // #warning <message>
7430  Builder.AddTypedTextChunk("warning");
7432  Builder.AddPlaceholderChunk("message");
7433  Results.AddResult(Builder.TakeString());
7434 
7435  // Note: #ident and #sccs are such crazy anachronisms that we don't provide
7436  // completions for them. And __include_macros is a Clang-internal extension
7437  // that we don't want to encourage anyone to use.
7438 
7439  // FIXME: we don't support #assert or #unassert, so don't suggest them.
7440  Results.ExitScope();
7441 
7442  HandleCodeCompleteResults(this, CodeCompleter,
7444  Results.data(), Results.size());
7445 }
7446 
7448  CodeCompleteOrdinaryName(S,
7451 }
7452 
7454  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7455  CodeCompleter->getCodeCompletionTUInfo(),
7458  if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) {
7459  // Add just the names of macros, not their arguments.
7460  CodeCompletionBuilder Builder(Results.getAllocator(),
7461  Results.getCodeCompletionTUInfo());
7462  Results.EnterNewScope();
7463  for (Preprocessor::macro_iterator M = PP.macro_begin(),
7464  MEnd = PP.macro_end();
7465  M != MEnd; ++M) {
7466  Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
7467  M->first->getName()));
7468  Results.AddResult(CodeCompletionResult(Builder.TakeString(),
7471  }
7472  Results.ExitScope();
7473  } else if (IsDefinition) {
7474  // FIXME: Can we detect when the user just wrote an include guard above?
7475  }
7476 
7477  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
7478  Results.data(), Results.size());
7479 }
7480 
7482  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
7483  CodeCompleter->getCodeCompletionTUInfo(),
7485 
7486  if (!CodeCompleter || CodeCompleter->includeMacros())
7487  AddMacroResults(PP, Results, true);
7488 
7489  // defined (<macro>)
7490  Results.EnterNewScope();
7491  CodeCompletionBuilder Builder(Results.getAllocator(),
7492  Results.getCodeCompletionTUInfo());
7493  Builder.AddTypedTextChunk("defined");
7496  Builder.AddPlaceholderChunk("macro");
7498  Results.AddResult(Builder.TakeString());
7499  Results.ExitScope();
7500 
7501  HandleCodeCompleteResults(this, CodeCompleter,
7503  Results.data(), Results.size());
7504 }
7505 
7507  IdentifierInfo *Macro,
7509  unsigned Argument) {
7510  // FIXME: In the future, we could provide "overload" results, much like we
7511  // do for function calls.
7512 
7513  // Now just ignore this. There will be another code-completion callback
7514  // for the expanded tokens.
7515 }
7516 
7518  HandleCodeCompleteResults(this, CodeCompleter,
7520  nullptr, 0);
7521 }
7522 
7524  CodeCompletionTUInfo &CCTUInfo,
7526  ResultBuilder Builder(*this, Allocator, CCTUInfo,
7528  if (!CodeCompleter || CodeCompleter->includeGlobals()) {
7529  CodeCompletionDeclConsumer Consumer(Builder,
7530  Context.getTranslationUnitDecl());
7531  LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName,
7532  Consumer);
7533  }
7534 
7535  if (!CodeCompleter || CodeCompleter->includeMacros())
7536  AddMacroResults(PP, Builder, true);
7537 
7538  Results.clear();
7539  Results.insert(Results.end(),
7540  Builder.data(), Builder.data() + Builder.size());
7541 }
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:1625
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:1440
static void AddPrettyFunctionResults(const LangOptions &LangOpts, ResultBuilder &Results)
bool isObjCObjectOrInterfaceType() const
Definition: Type.h:5560
const SwitchCase * getNextSwitchCase() const
Definition: Stmt.h:664
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:5278
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1561
bool isVariadic() const
Definition: Type.h:3366
void CodeCompleteObjCPropertySynthesizeIvar(Scope *S, IdentifierInfo *PropertyName)
A C++ alias declaration.
Definition: Index.h:1637
The receiver is an object instance.
Definition: ExprObjC.h:1005
iterator begin() const
Definition: DeclBase.h:1103
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:1631
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:2179
A (possibly-)qualified type.
Definition: Type.h:598
Any kind of method, provided it means other specified criteria.
bool isObjCContainer() const
Definition: DeclBase.h:1251
This is a scope that corresponds to the parameters within a function prototype.
Definition: Scope.h:80
base_class_range bases()
Definition: DeclCXX.h:718
bool isInvalid() const
Definition: Ownership.h:160
A static_assert or _Static_assert node.
Definition: Index.h:2385
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.cpp:1071
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...
Priority for a send-to-super completion.
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:5506
Code completion occurs within a class, struct, or union.
Definition: Sema.h:9181
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:1583
Divide by this factor when a code-completion result's type exactly matches the type we expect...
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:1062
CodeCompleteConsumer::OverloadCandidate ResultCandidate
submodule_iterator submodule_begin()
Definition: Basic/Module.h:474
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 AddObjCMethods(ObjCContainerDecl *Container, bool WantInstanceMethods, ObjCMethodKind WantKind, ArrayRef< IdentifierInfo * > SelIdents, DeclContext *CurContext, VisitedSelectorSet &Selectors, bool AllowSameLength, ResultBuilder &Results, bool InOriginalClass=true)
Add all of the Objective-C methods in the given Objective-C container to the set of results...
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:2414
The selector of the given message exactly matches the selector of the current method, which might imply that some kind of delegation is occurring.
Code completion where an Objective-C class message is expected.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:1453
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:2879
static bool isObjCReceiverType(ASTContext &C, QualType T)
EnumConstantDecl - An instance of this object exists for each enum constant that is defined...
Definition: Decl.h:2481
An Objective-C method being used as a property.
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
Definition: ScopeInfo.h:536
void CodeCompleteAssignmentRHS(Scope *S, Expr *LHS)
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:218
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:5539
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)
void AddChunk(CodeCompletionString::ChunkKind CK, const char *Text="")
Add a new chunk.
Captures information about "declaration specifiers" specific to Objective-C.
Definition: DeclSpec.h:776
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:1065
bool isEnumeralType() const
Definition: Type.h:5542
An access specifier.
Definition: Index.h:1643
Defines the clang::MacroInfo and clang::MacroDirective classes.
std::string getAsString() const
Definition: Type.h:924
void CodeCompleteNaturalLanguage()
PtrTy get() const
Definition: Ownership.h:164
The base class of the type hierarchy.
Definition: Type.h:1281
bool isObjCQualifiedClassType() const
Definition: Type.h:5573
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:922
unsigned getLength() const
Efficiently return the length of this identifier info.
An unspecified code-completion context.
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:471
std::pair< IdentifierInfo *, SourceLocation > IdentifierLocPair
A simple pair of identifier info and location.
Wrapper for source info for typedefs.
Definition: TypeLoc.h:620
A C++ non-type template parameter.
Definition: Index.h:1621
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: Decl.h:1434
An Objective-C @interface for a category.
Definition: Index.h:1589
void CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, bool EnteringContext)
bool isBooleanType() const
Definition: Type.h:5743
A container of type source information.
Definition: Decl.h:62
macro_iterator macro_begin(bool IncludeExternalMacros=true) const
Priority for a type.
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:5488
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)
MacroMap::const_iterator macro_iterator
Definition: Preprocessor.h:909
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2187
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: Sema/Lookup.h:742
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:768
visible_categories_range visible_categories() const
Definition: DeclObjC.h:1559
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:148
static void LookupVisibleDecls(DeclContext *Ctx, LookupResult &Result, bool QualifiedNameLookup, bool InBaseClass, VisibleDeclConsumer &Consumer, VisibleDeclsRecord &Visited)
Wrapper of type source information for a type with non-trivial direct qualifiers. ...
Definition: TypeLoc.h:247
A C++ using directive.
Definition: Index.h:1633
static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt)
The "union" keyword.
Definition: Type.h:4348
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:4346
An Objective-C @synthesize definition.
Definition: Index.h:1639
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:387
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:724
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:49
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:1455
Code completion occurs within an Objective-C implementation or category implementation.
Definition: Sema.h:9187
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
Definition: Type.h:949
The entity is not available; any use of it will be an error.
Definition: Index.h:138
unsigned param_size() const
Definition: DeclObjC.h:348
iterator begin() const
Definition: Type.h:4235
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1377
A C++ class method.
Definition: Index.h:1607
Defines the clang::Expr interface and subclasses for C++ expressions.
bool isVoidType() const
Definition: Type.h:5680
QualType getType() const
Definition: DeclObjC.h:781
The collection of all-type qualifiers we support.
Definition: Type.h:117
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:3271
void CodeCompleteConstructor(Scope *S, QualType Type, SourceLocation Loc, ArrayRef< Expr * > Args)
Priority for a constant value (e.g., enumerator).
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3253
static void AddTypedefResult(ResultBuilder &Results)
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:1655
This table allows us to fully hide how we implement multi-keyword caching.
void CodeCompleteObjCInterfaceDecl(Scope *S)
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4549
Priority for the next initialization in a constructor initializer list.
Represents a class type in Objective C.
Definition: Type.h:4727
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:92
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1067
A "string" used to describe how code completion can be performed for an entity.
Adjustment for KVC code pattern priorities when it doesn't look like the.
TSS getTypeSpecSign() const
Definition: DeclSpec.h:478
sema::BlockScopeInfo * getCurBlock()
Retrieve the current block, if any.
Definition: Sema.cpp:1185
static const TST TST_class
Definition: DeclSpec.h:292
bool isAnyPointerType() const
Definition: Type.h:5485
The result is a C++ non-static member function whose qualifiers exactly match the object type on whic...
An Objective-C @protocol declaration.
Definition: Index.h:1591
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:1306
Code completion occurs following one or more template headers within a class.
Definition: Sema.h:9196
CXXMethodDecl * getCanonicalDecl() override
Definition: DeclCXX.h:1804
const MacroInfo * getMacroInfo(const IdentifierInfo *II) const
Definition: Preprocessor.h:858
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:678
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:690
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:1982
A C++ template template parameter.
Definition: Index.h:1623
void CodeCompleteCase(Scope *S)
An Objective-C instance method.
Definition: Index.h:1597
method_range methods() const
Definition: DeclObjC.h:964
int Category
Definition: Format.cpp:1197
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:1613
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:1199
Divide by this factor when a code-completion result's type is similar to the type we expect (e...
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2007
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: Basic/Module.h:47
Code completion occurs where only a type is permitted.
Definition: Sema.h:9213
IdentifierTable & Idents
Definition: ASTContext.h:459
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:9179
Values of this type can be null.
An Objective-C @property declaration.
Definition: Index.h:1593
static bool shouldIgnoreDueToReservedName(const NamedDecl *ND, Sema &SemaRef)
static ObjCContainerDecl * getContainerDef(ObjCContainerDecl *Container)
Retrieve the container definition, if any?
void CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro, bool AfterAmpersand)
The result is in a base class.
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:9211
static bool isAcceptableObjCSelector(Selector Sel, ObjCMethodKind WantKind, ArrayRef< IdentifierInfo * > SelIdents, bool AllowSameLength=true)
static void AddObjCProperties(const CodeCompletionContext &CCContext, ObjCContainerDecl *Container, bool AllowCategories, bool AllowNullaryMethods, DeclContext *CurContext, AddedPropertiesSet &AddedProperties, ResultBuilder &Results)
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:884
Represents the results of name lookup.
Definition: Sema/Lookup.h:30
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:901
const LangOptions & getLangOpts() const
Definition: ASTContext.h:604
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
Definition: Sema.cpp:945
A convenient class for passing around template argument information.
Definition: TemplateBase.h:523
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:9193
void CodeCompleteBracketDeclarator(Scope *S)
QualType getReturnType() const
Definition: Type.h:3009
Wrapper for source info for functions.
Definition: TypeLoc.h:1255
void CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base, SourceLocation OpLoc, bool IsArrow)
void CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS)
static std::string formatObjCParamQualifiers(unsigned ObjCQuals, QualType &Type)
Code completion occurs within an expression.
Definition: Sema.h:9198
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:1838
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:3382
GlobalMethodPool MethodPool
Method Pool - allows efficient lookup when typechecking messages to "id".
Definition: Sema.h:1000
TypeDecl - Represents a declaration of a type.
Definition: Decl.h:2569
void CodeCompleteModuleImport(SourceLocation ImportLoc, ModuleIdPath Path)
Selector getSelector() const
Definition: ExprObjC.cpp:306
An enumerator constant.
Definition: Index.h:1579
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:6588
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:2326
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:2448
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: Basic/Module.h:476
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...
Priority for a nested-name-specifier.
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:1533
CodeCompletionTUInfo & getCodeCompletionTUInfo() const
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:1968
static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results, bool IncludeUndefined, bool TargetTypeIsPointer=false)
Preprocessor & PP
Definition: Sema.h:298
iterator end() const
QualType getBaseType() const
Retrieve the type of the base object in a member-access expression.
Represents an ObjC class declaration.
Definition: DeclObjC.h:1091
bool isVariadic() const
Definition: MacroInfo.h:204
ObjCMethodDecl * getMethod() const
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1206
detail::InMemoryDirectory::const_iterator I
unsigned getNumParams() const
Definition: TypeLoc.h:1301
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:1593
QualType getType() const
Definition: Decl.h:599
CXCursorKind
Describes the kind of entity that a cursor refers to.
Definition: Index.h:1553
const UnresolvedSetImpl & asUnresolvedSet() const
Definition: Sema/Lookup.h:315
std::vector< Module * >::iterator submodule_iterator
Definition: Basic/Module.h:471
Code completion occurs within a sequence of declaration specifiers within a function, method, or block.
Definition: Sema.h:9219
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)
const ParmVarDecl *const * param_const_iterator
Definition: DeclObjC.h:349
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:263
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:479
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:1283
QualType getParamType(unsigned i) const
Definition: Type.h:3272
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3073
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...
ObjCPropertyAttributeKind getPropertyAttributes() const
Definition: DeclSpec.h:828
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:462
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:2345
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:1828
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:415
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:540
iterator(const DeclIndexPair *Iterator)
llvm::SpecificBumpPtrAllocator< StateNode > Allocator
Code completion occurred where a protocol name is expected.
IdentifierInfo *const * arg_iterator
Arguments - The list of arguments for a function-like macro.
Definition: MacroInfo.h:175
const ObjCMethodDecl * getMethodDecl() const
Definition: ExprObjC.h:1251
CXCursorKind getCursorKindForDecl(const Decl *D)
Determine the libclang cursor kind associated with the given declaration.
Priority for an enumeration constant inside a switch whose condition is of the enumeration type...
Retains information about a block that is currently being parsed.
Definition: ScopeInfo.h:597
Type source information for an attributed type.
Definition: TypeLoc.h:724
static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class, StringRef Name)
Determine whether the given class is or inherits from a class by the given name.
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:590
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.
unsigned getNumArgs() const
static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context, const Preprocessor &PP)
bool isObjCClassType() const
Definition: Type.h:5583
A C++ class.
Definition: Index.h:1570
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:981
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:1780
static bool WantTypesInContext(Sema::ParserCompletionContext CCC, const LangOptions &LangOpts)
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:886
Code completion occurs within an Objective-C interface, protocol, or category.
Definition: Sema.h:9184
Defines the clang::Preprocessor interface.
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2011
#define bool
Definition: stdbool.h:31
void CodeCompleteObjCAtVisibility(Scope *S)
An Objective-C @implementation for a category.
Definition: Index.h:1603
void CodeCompleteObjCImplementationCategory(Scope *S, IdentifierInfo *ClassName, SourceLocation ClassNameLoc)
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:115
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
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:5578
Code completion occurs within a statement, which may also be an expression or a declaration.
Definition: Sema.h:9201
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:1629
const SwitchCase * getSwitchCaseList() const
Definition: Stmt.h:996
static Optional< NullabilityKind > stripOuterNullability(QualType &T)
Strip off the top-level nullability annotation on the given type, if it's there.
Definition: Type.cpp:3619
QualType stripObjCKindOfType(const ASTContext &ctx) const
Strip Objective-C "__kindof" types from the given type.
Definition: Type.cpp:1253
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:1774
bool isInstanceMethod() const
Definition: DeclObjC.h:414
Code completion in a parenthesized expression, which means that we may also have types here in C and ...
bool isFunctionOrMethod() const
Definition: DeclBase.h:1263
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1214
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:1613
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...
arg_iterator arg_end() const
Definition: MacroInfo.h:178
A C or C++ struct.
Definition: Index.h:1566
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:9190
void CodeCompleteNamespaceDecl(Scope *S)
const char * CopyString(const Twine &String)
Copy the given string into this allocator.
const SourceManager & SM
Definition: Format.cpp:1184
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:671
void CodeCompleteInitializer(Scope *S, Decl *D)
bool isC99Varargs() const
Definition: MacroInfo.h:202
A C++ destructor.
Definition: Index.h:1615
void CodeCompleteObjCPropertySetter(Scope *S)
const char * getBriefComment() const
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:473
static bool anyNullArguments(ArrayRef< Expr * > Args)
static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt)
Priority for a code pattern.
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
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
void Destroy()
Definition: CGCleanup.h:306
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)
Code completion occurred within a class, struct, or union.
void CodeCompleteObjCAtDirective(Scope *S)
#define false
Definition: stdbool.h:33
The "struct" keyword.
Definition: Type.h:4344
SelectorTable & Selectors
Definition: ASTContext.h:460
Kind
A C++ template type parameter.
Definition: Index.h:1619
OverloadCandidate - A single candidate in an overload set (C++ 13.3).
Definition: Overload.h:593
Encodes a location in the source.
enumerator_range enumerators() const
Definition: Decl.h:3109
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:2742
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:3733
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5259
const TemplateArgument * iterator
Definition: Type.h:4233
method_iterator begin_overridden_methods() const
Definition: DeclCXX.cpp:1650
Priority for the Objective-C "_cmd" implicit parameter.
OverloadedOperatorKind getCXXOverloadedOperator() const
getCXXOverloadedOperator - If this name is the name of an overloadable operator in C++ (e...
Expr * getLHS()
Definition: Stmt.h:714
static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt)
const std::string ID
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2727
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:817
ASTContext & getASTContext() const
Definition: Sema.h:1069
macro_iterator macro_end(bool IncludeExternalMacros=true) const
static const TST TST_union
Definition: DeclSpec.h:289
bool isVariadic() const
Definition: DeclObjC.h:416
const Expr * getCond() const
Definition: Stmt.h:994
ParsedType getRepAsType() const
Definition: DeclSpec.h:487
TSC getTypeSpecComplex() const
Definition: DeclSpec.h:477
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:1605
bool isRestrict() const
Definition: Type.h:3021
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1736
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:1577
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:1989
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:2171
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
static void CodeCompleteOverloadResults(Sema &SemaRef, Scope *S, MutableArrayRef< ResultCandidate > Candidates, unsigned CurrentArg, bool CompleteExpressionWithCurrentArg=true)
CodeCompleteConsumer * CodeCompleter
Code-completion consumer.
Definition: Sema.h:308
The entity is available.
Definition: Index.h:129
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:699
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:165
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:5849
SimplifiedTypeClass getSimplifiedTypeClass(CanQualType T)
Determine the simplified type class of the given canonical type.
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1407
void addParentContext(const DeclContext *DC)
Add the parent context information to this code completion.
bool isFileContext() const
Definition: DeclBase.h:1279
PtrTy get() const
Definition: Ownership.h:75
static void AddObjCVisibilityResults(const LangOptions &LangOpts, ResultBuilder &Results, bool NeedAt)
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1188
ObjCMethodKind
Describes the kind of Objective-C method that we want to find via code completion.
A C++ using declaration.
Definition: Index.h:1635
OverloadCandidateSet - A set of overload candidates, used in C++ overload resolution (C++ 13...
Definition: Overload.h:701
llvm::SmallPtrSet< IdentifierInfo *, 16 > AddedPropertiesSet
The set of properties that have already been added, referenced by property name.
A C++ namespace.
Definition: Index.h:1609
unsigned TypeAlias
Whether this template specialization type is a substituted type alias.
Definition: Type.h:4171
__PTRDIFF_TYPE__ ptrdiff_t
A signed integer type that is the result of subtracting two pointers.
Definition: opencl-c.h:61
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:193
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:4294
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1302
A C++ class template.
Definition: Index.h:1627
Priority for a preprocessor macro.
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:1882
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: DeclSpec.h:820
bool isMacroDefined(StringRef Id)
Definition: Preprocessor.h:793
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:126
if(T->getSizeExpr()) TRY_TO(TraverseStmt(T-> getSizeExpr()))
An Objective-C instance variable.
Definition: Index.h:1595
Represents a template argument.
Definition: TemplateBase.h:40
ParserCompletionContext
Describes the context in which code completion occurs.
Definition: Sema.h:9177
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:2344
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:1135
Priority for a non-type declaration.
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:330
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:1585
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1983
A C or C++ union.
Definition: Index.h:1568
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:1056
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...
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:3013
detail::InMemoryDirectory::const_iterator E
Adjustment to the "bool" type in Objective-C, where the typedef "BOOL" is preferred.
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:1966
static void HandleCodeCompleteResults(Sema *S, CodeCompleteConsumer *CodeCompleter, CodeCompletionContext Context, CodeCompletionResult *Results, unsigned NumResults)
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:1473
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: Basic/Module.h:210
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:5432
void CodeCompleteUsingDirective(Scope *S)
bool isFunctionLike() const
Definition: MacroInfo.h:196
Represents a pointer to an Objective C object.
Definition: Type.h:4991
SwitchStmt - This represents a 'switch' stmt.
Definition: Stmt.h:957
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:34
Pointer to a block type.
Definition: Type.h:2286
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:333
bool isObjCObjectType() const
Definition: Type.h:5557
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2461
Not an overloaded operator.
Definition: OperatorKinds.h:23
void AddInformativeChunk(const char *Text)
Add a new informative chunk.
ObjCMethodDecl * getGetterMethodDecl() const
Definition: DeclObjC.h:860
Priority for a member declaration found from the current method or member function.
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3707
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5818
ExternalSemaSource * getExternalSource() const
Definition: Sema.h:1072
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy.
Definition: Sema.h:1912
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:3378
A reference to a member of a struct, union, or class that occurs in some non-expression context...
Definition: Index.h:1683
ObjCInterfaceDecl * getInterfaceDecl() const
If this pointer points to an Objective @interface type, gets the declaration for that interface...
Definition: Type.h:5046
ObjCMethodDecl * getSetterMethodDecl() const
Definition: DeclObjC.h:863
A module import declaration.
Definition: Index.h:2380
instprop_range instance_properties() const
Definition: DeclObjC.h:934
void CodeCompleteObjCSelector(Scope *S, ArrayRef< IdentifierInfo * > SelIdents)
CanQualType DependentTy
Definition: ASTContext.h:909
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:1564
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:2319
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1534
An Objective-C @dynamic definition.
Definition: Index.h:1641
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1528
void * getAsOpaquePtr() const
Definition: Ownership.h:85
void CodeCompleteObjCAtStatement(Scope *S)
ObjCImplementationDecl * getImplementation() const
Definition: DeclObjC.cpp:1481
protocol_range protocols() const
Definition: DeclObjC.h:1278
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:379
The "class" keyword.
Definition: Type.h:4350
Capturing the *this object by reference.
Definition: Lambda.h:35
An Objective-C class method.
Definition: Index.h:1599
void CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS, bool IsParameter)
static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)
Definition: SemaType.cpp:2533
friend bool operator!=(const iterator &X, const iterator &Y)
bool isUsable() const
Definition: Ownership.h:161
QualType getPointeeType() const
Definition: Type.h:2340
This is a scope that can contain a declaration.
Definition: Scope.h:58
An enumeration.
Definition: Index.h:1572
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:12171
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:9204
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5339
Represents a C++ struct/union/class.
Definition: DeclCXX.h:263
BoundNodesTreeBuilder *const Builder
An Objective-C @implementation.
Definition: Index.h:1601
CodeCompleteExpressionData(QualType PreferredType=QualType())
bool isObjCObjectPointerType() const
Definition: Type.h:5554
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.
The parameter type of a method or function.
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1849
bool isClassScope() const
isClassScope - Return true if this scope is a class/struct/union scope.
Definition: Scope.h:326
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:311
The "enum" keyword.
Definition: Type.h:4352
Cursor that represents the translation unit itself.
Definition: Index.h:2336
qual_range quals() const
Definition: Type.h:5113
Declaration of a class template.
Priority for a declaration that is in the local scope.
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:43
This class is used for builtin types like 'int'.
Definition: Type.h:2039
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:353
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:1330
Represents a complete lambda introducer.
Definition: DeclSpec.h:2324
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:2606
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:212
QualType getSendResultType() const
Determine the type of an expression that sends a message to this function.
Definition: DeclObjC.cpp:1090
bool isRecord() const
Definition: DeclBase.h:1287
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:55
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:480
unsigned getParsedSpecifiers() const
Return a bitmask of which flavors of specifiers this DeclSpec includes.
Definition: DeclSpec.cpp:363
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.
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:932
Code completion occurred on the right-hand side of a member access expression using the dot operator...
Code completion occurs within the condition of an if, while, switch, or for statement.
Definition: Sema.h:9207
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.
Code completion occurred where a type name is expected.
SourceManager & SourceMgr
Definition: Sema.h:302
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: Sema/Lookup.h:566
A function.
Definition: Index.h:1581
arg_iterator arg_begin() const
Definition: MacroInfo.h:177
static LLVM_READONLY char toUppercase(char c)
Converts the given ASCII character to its uppercase equivalent.
Definition: CharInfo.h:174
UnqualTypeLoc getUnqualifiedLoc() const
Skips past any qualifiers, if this is qualified.
Definition: TypeLoc.h:297
ASTContext & Context
Definition: Sema.h:299
static void mergeCandidatesWithResults(Sema &SemaRef, SmallVectorImpl< ResultCandidate > &Results, OverloadCandidateSet &CandidateSet, SourceLocation Loc)
bool isVolatile() const
Definition: Type.h:3020
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:1521
#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:3082
friend bool operator==(const iterator &X, const iterator &Y)
Priority for a result that isn't likely to be what the user wants, but is included for completeness...
llvm::DenseMap< const Stmt *, CFGBlock * > SMap
Definition: CFGStmtMap.cpp:22
An Objective-C @interface.
Definition: Index.h:1587
A C++ conversion function.
Definition: Index.h:1617
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:665
The receiver is a superclass.
Definition: ExprObjC.h:1007
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
Definition: Type.cpp:1505
void CodeCompleteAfterIf(Scope *S)
Wrapper for source info for block pointers.
Definition: TypeLoc.h:1147
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:2380
base_class_range vbases()
Definition: DeclCXX.h:735
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:838
Code completion occurs in a parenthesized expression, which might also be a type cast.
Definition: Sema.h:9216
void CodeCompleteInPreprocessorConditionalExclusion(Scope *S)
void CodeCompleteObjCProtocolDecl(Scope *S)
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:2835
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:5702
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:1478
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:97
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:5286
bool isConst() const
Definition: Type.h:3019
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
getCXXOperatorName - Get the name of the overloadable C++ operator corresponding to Op...