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