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