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