clang  8.0.0svn
SemaCodeComplete.cpp
Go to the documentation of this file.
1 //===---------------- SemaCodeComplete.cpp - Code Completion ----*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the code-completion semantic actions.
11 //
12 //===----------------------------------------------------------------------===//
13 #include "clang/AST/DeclCXX.h"
14 #include "clang/AST/DeclObjC.h"
15 #include "clang/AST/ExprCXX.h"
16 #include "clang/AST/ExprObjC.h"
18 #include "clang/Basic/CharInfo.h"
19 #include "clang/Lex/HeaderSearch.h"
20 #include "clang/Lex/MacroInfo.h"
21 #include "clang/Lex/Preprocessor.h"
23 #include "clang/Sema/Lookup.h"
24 #include "clang/Sema/Overload.h"
25 #include "clang/Sema/Scope.h"
26 #include "clang/Sema/ScopeInfo.h"
28 #include "llvm/ADT/DenseSet.h"
29 #include "llvm/ADT/SmallBitVector.h"
30 #include "llvm/ADT/SmallPtrSet.h"
31 #include "llvm/ADT/SmallString.h"
32 #include "llvm/ADT/StringExtras.h"
33 #include "llvm/ADT/StringSwitch.h"
34 #include "llvm/ADT/Twine.h"
35 #include <list>
36 #include <map>
37 #include <vector>
38 
39 using namespace clang;
40 using namespace sema;
41 
42 namespace {
43  /// A container of code-completion results.
44  class ResultBuilder {
45  public:
46  /// The type of a name-lookup filter, which can be provided to the
47  /// name-lookup routines to specify which declarations should be included in
48  /// the result set (when it returns true) and which declarations should be
49  /// filtered out (returns false).
50  typedef bool (ResultBuilder::*LookupFilter)(const NamedDecl *) const;
51 
52  typedef CodeCompletionResult Result;
53 
54  private:
55  /// The actual results we have found.
56  std::vector<Result> Results;
57 
58  /// A record of all of the declarations we have found and placed
59  /// into the result set, used to ensure that no declaration ever gets into
60  /// the result set twice.
61  llvm::SmallPtrSet<const Decl*, 16> AllDeclsFound;
62 
63  typedef std::pair<const NamedDecl *, unsigned> DeclIndexPair;
64 
65  /// An entry in the shadow map, which is optimized to store
66  /// a single (declaration, index) mapping (the common case) but
67  /// can also store a list of (declaration, index) mappings.
68  class ShadowMapEntry {
69  typedef SmallVector<DeclIndexPair, 4> DeclIndexPairVector;
70 
71  /// Contains either the solitary NamedDecl * or a vector
72  /// of (declaration, index) pairs.
73  llvm::PointerUnion<const NamedDecl *, DeclIndexPairVector*> DeclOrVector;
74 
75  /// When the entry contains a single declaration, this is
76  /// the index associated with that entry.
77  unsigned SingleDeclIndex;
78 
79  public:
80  ShadowMapEntry() : DeclOrVector(), SingleDeclIndex(0) { }
81 
82  void Add(const NamedDecl *ND, unsigned Index) {
83  if (DeclOrVector.isNull()) {
84  // 0 - > 1 elements: just set the single element information.
85  DeclOrVector = ND;
86  SingleDeclIndex = Index;
87  return;
88  }
89 
90  if (const NamedDecl *PrevND =
91  DeclOrVector.dyn_cast<const NamedDecl *>()) {
92  // 1 -> 2 elements: create the vector of results and push in the
93  // existing declaration.
94  DeclIndexPairVector *Vec = new DeclIndexPairVector;
95  Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex));
96  DeclOrVector = Vec;
97  }
98 
99  // Add the new element to the end of the vector.
100  DeclOrVector.get<DeclIndexPairVector*>()->push_back(
101  DeclIndexPair(ND, Index));
102  }
103 
104  void Destroy() {
105  if (DeclIndexPairVector *Vec
106  = DeclOrVector.dyn_cast<DeclIndexPairVector *>()) {
107  delete Vec;
108  DeclOrVector = ((NamedDecl *)nullptr);
109  }
110  }
111 
112  // Iteration.
113  class iterator;
114  iterator begin() const;
115  iterator end() const;
116  };
117 
118  /// A mapping from declaration names to the declarations that have
119  /// this name within a particular scope and their index within the list of
120  /// results.
121  typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap;
122 
123  /// The semantic analysis object for which results are being
124  /// produced.
125  Sema &SemaRef;
126 
127  /// The allocator used to allocate new code-completion strings.
128  CodeCompletionAllocator &Allocator;
129 
130  CodeCompletionTUInfo &CCTUInfo;
131 
132  /// If non-NULL, a filter function used to remove any code-completion
133  /// results that are not desirable.
134  LookupFilter Filter;
135 
136  /// Whether we should allow declarations as
137  /// nested-name-specifiers that would otherwise be filtered out.
138  bool AllowNestedNameSpecifiers;
139 
140  /// If set, the type that we would prefer our resulting value
141  /// declarations to have.
142  ///
143  /// Closely matching the preferred type gives a boost to a result's
144  /// priority.
145  CanQualType PreferredType;
146 
147  /// A list of shadow maps, which is used to model name hiding at
148  /// different levels of, e.g., the inheritance hierarchy.
149  std::list<ShadowMap> ShadowMaps;
150 
151  /// If we're potentially referring to a C++ member function, the set
152  /// of qualifiers applied to the object type.
153  Qualifiers ObjectTypeQualifiers;
154 
155  /// Whether the \p ObjectTypeQualifiers field is active.
156  bool HasObjectTypeQualifiers;
157 
158  /// The selector that we prefer.
159  Selector PreferredSelector;
160 
161  /// The completion context in which we are gathering results.
162  CodeCompletionContext CompletionContext;
163 
164  /// If we are in an instance method definition, the \@implementation
165  /// object.
166  ObjCImplementationDecl *ObjCImplementation;
167 
168  void AdjustResultPriorityForDecl(Result &R);
169 
170  void MaybeAddConstructorResults(Result R);
171 
172  public:
173  explicit ResultBuilder(Sema &SemaRef, CodeCompletionAllocator &Allocator,
174  CodeCompletionTUInfo &CCTUInfo,
175  const CodeCompletionContext &CompletionContext,
176  LookupFilter Filter = nullptr)
177  : SemaRef(SemaRef), Allocator(Allocator), CCTUInfo(CCTUInfo),
178  Filter(Filter),
179  AllowNestedNameSpecifiers(false), HasObjectTypeQualifiers(false),
180  CompletionContext(CompletionContext),
181  ObjCImplementation(nullptr)
182  {
183  // If this is an Objective-C instance method definition, dig out the
184  // corresponding implementation.
185  switch (CompletionContext.getKind()) {
191  if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl())
192  if (Method->isInstanceMethod())
193  if (ObjCInterfaceDecl *Interface = Method->getClassInterface())
194  ObjCImplementation = Interface->getImplementation();
195  break;
196 
197  default:
198  break;
199  }
200  }
201 
202  /// Determine the priority for a reference to the given declaration.
203  unsigned getBasePriority(const NamedDecl *D);
204 
205  /// Whether we should include code patterns in the completion
206  /// results.
207  bool includeCodePatterns() const {
208  return SemaRef.CodeCompleter &&
210  }
211 
212  /// Set the filter used for code-completion results.
213  void setFilter(LookupFilter Filter) {
214  this->Filter = Filter;
215  }
216 
217  Result *data() { return Results.empty()? nullptr : &Results.front(); }
218  unsigned size() const { return Results.size(); }
219  bool empty() const { return Results.empty(); }
220 
221  /// 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) {
244  PreferredSelector = Sel;
245  }
246 
247  /// Retrieve the code-completion context for which results are
248  /// being collected.
249  const CodeCompletionContext &getCompletionContext() const {
250  return CompletionContext;
251  }
252 
253  /// Specify whether nested-name-specifiers are allowed.
254  void allowNestedNameSpecifiers(bool Allow = true) {
255  AllowNestedNameSpecifiers = Allow;
256  }
257 
258  /// Return the semantic analysis object for which we are collecting
259  /// code completion results.
260  Sema &getSema() const { return SemaRef; }
261 
262  /// Retrieve the allocator used to allocate code completion strings.
263  CodeCompletionAllocator &getAllocator() const { return Allocator; }
264 
265  CodeCompletionTUInfo &getCodeCompletionTUInfo() const { return CCTUInfo; }
266 
267  /// Determine whether the given declaration is at all interesting
268  /// as a code-completion result.
269  ///
270  /// \param ND the declaration that we are inspecting.
271  ///
272  /// \param AsNestedNameSpecifier will be set true if this declaration is
273  /// only interesting when it is a nested-name-specifier.
274  bool isInterestingDecl(const NamedDecl *ND,
275  bool &AsNestedNameSpecifier) const;
276 
277  /// Check whether the result is hidden by the Hiding declaration.
278  ///
279  /// \returns true if the result is hidden and cannot be found, false if
280  /// the hidden result could still be found. When false, \p R may be
281  /// modified to describe how the result can be found (e.g., via extra
282  /// qualification).
283  bool CheckHiddenResult(Result &R, DeclContext *CurContext,
284  const NamedDecl *Hiding);
285 
286  /// Add a new result to this result set (if it isn't already in one
287  /// of the shadow maps), or replace an existing result (for, e.g., a
288  /// redeclaration).
289  ///
290  /// \param R the result to add (if it is unique).
291  ///
292  /// \param CurContext the context in which this result will be named.
293  void MaybeAddResult(Result R, DeclContext *CurContext = nullptr);
294 
295  /// Add a new result to this result set, where we already know
296  /// the hiding declaration (if any).
297  ///
298  /// \param R the result to add (if it is unique).
299  ///
300  /// \param CurContext the context in which this result will be named.
301  ///
302  /// \param Hiding the declaration that hides the result.
303  ///
304  /// \param InBaseClass whether the result was found in a base
305  /// class of the searched context.
306  void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding,
307  bool InBaseClass);
308 
309  /// Add a new non-declaration result to this result set.
310  void AddResult(Result R);
311 
312  /// Enter into a new scope.
313  void EnterNewScope();
314 
315  /// Exit from the current scope.
316  void ExitScope();
317 
318  /// Ignore this declaration, if it is seen again.
319  void Ignore(const Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); }
320 
321  /// Add a visited context.
322  void addVisitedContext(DeclContext *Ctx) {
323  CompletionContext.addVisitedContext(Ctx);
324  }
325 
326  /// \name Name lookup predicates
327  ///
328  /// These predicates can be passed to the name lookup functions to filter the
329  /// results of name lookup. All of the predicates have the same type, so that
330  ///
331  //@{
332  bool IsOrdinaryName(const NamedDecl *ND) const;
333  bool IsOrdinaryNonTypeName(const NamedDecl *ND) const;
334  bool IsIntegralConstantValue(const NamedDecl *ND) const;
335  bool IsOrdinaryNonValueName(const NamedDecl *ND) const;
336  bool IsNestedNameSpecifier(const NamedDecl *ND) const;
337  bool IsEnum(const NamedDecl *ND) const;
338  bool IsClassOrStruct(const NamedDecl *ND) const;
339  bool IsUnion(const NamedDecl *ND) const;
340  bool IsNamespace(const NamedDecl *ND) const;
341  bool IsNamespaceOrAlias(const NamedDecl *ND) const;
342  bool IsType(const NamedDecl *ND) const;
343  bool IsMember(const NamedDecl *ND) const;
344  bool IsObjCIvar(const NamedDecl *ND) const;
345  bool IsObjCMessageReceiver(const NamedDecl *ND) const;
346  bool IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const;
347  bool IsObjCCollection(const NamedDecl *ND) const;
348  bool IsImpossibleToSatisfy(const NamedDecl *ND) const;
349  //@}
350  };
351 }
352 
354  llvm::PointerUnion<const NamedDecl *, const DeclIndexPair *> DeclOrIterator;
355  unsigned SingleDeclIndex;
356 
357 public:
358  typedef DeclIndexPair value_type;
359  typedef value_type reference;
361  typedef std::input_iterator_tag iterator_category;
362 
363  class pointer {
364  DeclIndexPair Value;
365 
366  public:
367  pointer(const DeclIndexPair &Value) : Value(Value) { }
368 
369  const DeclIndexPair *operator->() const {
370  return &Value;
371  }
372  };
373 
374  iterator() : DeclOrIterator((NamedDecl *)nullptr), SingleDeclIndex(0) {}
375 
376  iterator(const NamedDecl *SingleDecl, unsigned Index)
377  : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) { }
378 
379  iterator(const DeclIndexPair *Iterator)
380  : DeclOrIterator(Iterator), SingleDeclIndex(0) { }
381 
383  if (DeclOrIterator.is<const NamedDecl *>()) {
384  DeclOrIterator = (NamedDecl *)nullptr;
385  SingleDeclIndex = 0;
386  return *this;
387  }
388 
389  const DeclIndexPair *I = DeclOrIterator.get<const DeclIndexPair*>();
390  ++I;
391  DeclOrIterator = I;
392  return *this;
393  }
394 
395  /*iterator operator++(int) {
396  iterator tmp(*this);
397  ++(*this);
398  return tmp;
399  }*/
400 
401  reference operator*() const {
402  if (const NamedDecl *ND = DeclOrIterator.dyn_cast<const NamedDecl *>())
403  return reference(ND, SingleDeclIndex);
404 
405  return *DeclOrIterator.get<const DeclIndexPair*>();
406  }
407 
408  pointer operator->() const {
409  return pointer(**this);
410  }
411 
412  friend bool operator==(const iterator &X, const iterator &Y) {
413  return X.DeclOrIterator.getOpaqueValue()
414  == Y.DeclOrIterator.getOpaqueValue() &&
415  X.SingleDeclIndex == Y.SingleDeclIndex;
416  }
417 
418  friend bool operator!=(const iterator &X, const iterator &Y) {
419  return !(X == Y);
420  }
421 };
422 
424 ResultBuilder::ShadowMapEntry::begin() const {
425  if (DeclOrVector.isNull())
426  return iterator();
427 
428  if (const NamedDecl *ND = DeclOrVector.dyn_cast<const NamedDecl *>())
429  return iterator(ND, SingleDeclIndex);
430 
431  return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin());
432 }
433 
435 ResultBuilder::ShadowMapEntry::end() const {
436  if (DeclOrVector.is<const NamedDecl *>() || DeclOrVector.isNull())
437  return iterator();
438 
439  return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end());
440 }
441 
442 /// Compute the qualification required to get from the current context
443 /// (\p CurContext) to the target context (\p TargetContext).
444 ///
445 /// \param Context the AST context in which the qualification will be used.
446 ///
447 /// \param CurContext the context where an entity is being named, which is
448 /// typically based on the current scope.
449 ///
450 /// \param TargetContext the context in which the named entity actually
451 /// resides.
452 ///
453 /// \returns a nested name specifier that refers into the target context, or
454 /// NULL if no qualification is needed.
455 static NestedNameSpecifier *
457  const DeclContext *CurContext,
458  const DeclContext *TargetContext) {
460 
461  for (const DeclContext *CommonAncestor = TargetContext;
462  CommonAncestor && !CommonAncestor->Encloses(CurContext);
463  CommonAncestor = CommonAncestor->getLookupParent()) {
464  if (CommonAncestor->isTransparentContext() ||
465  CommonAncestor->isFunctionOrMethod())
466  continue;
467 
468  TargetParents.push_back(CommonAncestor);
469  }
470 
471  NestedNameSpecifier *Result = nullptr;
472  while (!TargetParents.empty()) {
473  const DeclContext *Parent = TargetParents.pop_back_val();
474 
475  if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Parent)) {
476  if (!Namespace->getIdentifier())
477  continue;
478 
479  Result = NestedNameSpecifier::Create(Context, Result, Namespace);
480  }
481  else if (const TagDecl *TD = dyn_cast<TagDecl>(Parent))
482  Result = NestedNameSpecifier::Create(Context, Result,
483  false,
484  Context.getTypeDeclType(TD).getTypePtr());
485  }
486  return Result;
487 }
488 
489 /// Determine whether \p Id is a name reserved for the implementation (C99
490 /// 7.1.3, C++ [lib.global.names]).
491 static bool isReservedName(const IdentifierInfo *Id,
492  bool doubleUnderscoreOnly = false) {
493  if (Id->getLength() < 2)
494  return false;
495  const char *Name = Id->getNameStart();
496  return Name[0] == '_' &&
497  (Name[1] == '_' || (Name[1] >= 'A' && Name[1] <= 'Z' &&
498  !doubleUnderscoreOnly));
499 }
500 
501 // Some declarations have reserved names that we don't want to ever show.
502 // Filter out names reserved for the implementation if they come from a
503 // system header.
504 static bool shouldIgnoreDueToReservedName(const NamedDecl *ND, Sema &SemaRef) {
505  const IdentifierInfo *Id = ND->getIdentifier();
506  if (!Id)
507  return false;
508 
509  // Ignore reserved names for compiler provided decls.
510  if (isReservedName(Id) && ND->getLocation().isInvalid())
511  return true;
512 
513  // For system headers ignore only double-underscore names.
514  // This allows for system headers providing private symbols with a single
515  // underscore.
516  if (isReservedName(Id, /*doubleUnderscoreOnly=*/true) &&
517  SemaRef.SourceMgr.isInSystemHeader(
518  SemaRef.SourceMgr.getSpellingLoc(ND->getLocation())))
519  return true;
520 
521  return false;
522 }
523 
524 bool ResultBuilder::isInterestingDecl(const NamedDecl *ND,
525  bool &AsNestedNameSpecifier) const {
526  AsNestedNameSpecifier = false;
527 
528  auto *Named = ND;
529  ND = ND->getUnderlyingDecl();
530 
531  // Skip unnamed entities.
532  if (!ND->getDeclName())
533  return false;
534 
535  // Friend declarations and declarations introduced due to friends are never
536  // added as results.
538  return false;
539 
540  // Class template (partial) specializations are never added as results.
541  if (isa<ClassTemplateSpecializationDecl>(ND) ||
542  isa<ClassTemplatePartialSpecializationDecl>(ND))
543  return false;
544 
545  // Using declarations themselves are never added as results.
546  if (isa<UsingDecl>(ND))
547  return false;
548 
549  if (shouldIgnoreDueToReservedName(ND, SemaRef))
550  return false;
551 
552  if (Filter == &ResultBuilder::IsNestedNameSpecifier ||
553  (isa<NamespaceDecl>(ND) &&
554  Filter != &ResultBuilder::IsNamespace &&
555  Filter != &ResultBuilder::IsNamespaceOrAlias &&
556  Filter != nullptr))
557  AsNestedNameSpecifier = true;
558 
559  // Filter out any unwanted results.
560  if (Filter && !(this->*Filter)(Named)) {
561  // Check whether it is interesting as a nested-name-specifier.
562  if (AllowNestedNameSpecifiers && SemaRef.getLangOpts().CPlusPlus &&
563  IsNestedNameSpecifier(ND) &&
564  (Filter != &ResultBuilder::IsMember ||
565  (isa<CXXRecordDecl>(ND) &&
566  cast<CXXRecordDecl>(ND)->isInjectedClassName()))) {
567  AsNestedNameSpecifier = true;
568  return true;
569  }
570 
571  return false;
572  }
573  // ... then it must be interesting!
574  return true;
575 }
576 
577 bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext,
578  const NamedDecl *Hiding) {
579  // In C, there is no way to refer to a hidden name.
580  // FIXME: This isn't true; we can find a tag name hidden by an ordinary
581  // name if we introduce the tag type.
582  if (!SemaRef.getLangOpts().CPlusPlus)
583  return true;
584 
585  const DeclContext *HiddenCtx =
586  R.Declaration->getDeclContext()->getRedeclContext();
587 
588  // There is no way to qualify a name declared in a function or method.
589  if (HiddenCtx->isFunctionOrMethod())
590  return true;
591 
592  if (HiddenCtx == Hiding->getDeclContext()->getRedeclContext())
593  return true;
594 
595  // We can refer to the result with the appropriate qualification. Do it.
596  R.Hidden = true;
597  R.QualifierIsInformative = false;
598 
599  if (!R.Qualifier)
600  R.Qualifier = getRequiredQualification(SemaRef.Context,
601  CurContext,
602  R.Declaration->getDeclContext());
603  return false;
604 }
605 
606 /// A simplified classification of types used to determine whether two
607 /// types are "similar enough" when adjusting priorities.
609  switch (T->getTypeClass()) {
610  case Type::Builtin:
611  switch (cast<BuiltinType>(T)->getKind()) {
612  case BuiltinType::Void:
613  return STC_Void;
614 
615  case BuiltinType::NullPtr:
616  return STC_Pointer;
617 
618  case BuiltinType::Overload:
619  case BuiltinType::Dependent:
620  return STC_Other;
621 
622  case BuiltinType::ObjCId:
623  case BuiltinType::ObjCClass:
624  case BuiltinType::ObjCSel:
625  return STC_ObjectiveC;
626 
627  default:
628  return STC_Arithmetic;
629  }
630 
631  case Type::Complex:
632  return STC_Arithmetic;
633 
634  case Type::Pointer:
635  return STC_Pointer;
636 
637  case Type::BlockPointer:
638  return STC_Block;
639 
640  case Type::LValueReference:
641  case Type::RValueReference:
643 
644  case Type::ConstantArray:
645  case Type::IncompleteArray:
646  case Type::VariableArray:
647  case Type::DependentSizedArray:
648  return STC_Array;
649 
650  case Type::DependentSizedExtVector:
651  case Type::Vector:
652  case Type::ExtVector:
653  return STC_Arithmetic;
654 
655  case Type::FunctionProto:
656  case Type::FunctionNoProto:
657  return STC_Function;
658 
659  case Type::Record:
660  return STC_Record;
661 
662  case Type::Enum:
663  return STC_Arithmetic;
664 
665  case Type::ObjCObject:
666  case Type::ObjCInterface:
667  case Type::ObjCObjectPointer:
668  return STC_ObjectiveC;
669 
670  default:
671  return STC_Other;
672  }
673 }
674 
675 /// Get the type that a given expression will have if this declaration
676 /// is used as an expression in its "typical" code-completion form.
678  ND = ND->getUnderlyingDecl();
679 
680  if (const TypeDecl *Type = dyn_cast<TypeDecl>(ND))
681  return C.getTypeDeclType(Type);
682  if (const ObjCInterfaceDecl *Iface = dyn_cast<ObjCInterfaceDecl>(ND))
683  return C.getObjCInterfaceType(Iface);
684 
685  QualType T;
686  if (const FunctionDecl *Function = ND->getAsFunction())
687  T = Function->getCallResultType();
688  else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND))
689  T = Method->getSendResultType();
690  else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND))
691  T = C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext()));
692  else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND))
693  T = Property->getType();
694  else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND))
695  T = Value->getType();
696  else
697  return QualType();
698 
699  // Dig through references, function pointers, and block pointers to
700  // get down to the likely type of an expression when the entity is
701  // used.
702  do {
703  if (const ReferenceType *Ref = T->getAs<ReferenceType>()) {
704  T = Ref->getPointeeType();
705  continue;
706  }
707 
708  if (const PointerType *Pointer = T->getAs<PointerType>()) {
709  if (Pointer->getPointeeType()->isFunctionType()) {
710  T = Pointer->getPointeeType();
711  continue;
712  }
713 
714  break;
715  }
716 
717  if (const BlockPointerType *Block = T->getAs<BlockPointerType>()) {
718  T = Block->getPointeeType();
719  continue;
720  }
721 
722  if (const FunctionType *Function = T->getAs<FunctionType>()) {
723  T = Function->getReturnType();
724  continue;
725  }
726 
727  break;
728  } while (true);
729 
730  return T;
731 }
732 
733 unsigned ResultBuilder::getBasePriority(const NamedDecl *ND) {
734  if (!ND)
735  return CCP_Unlikely;
736 
737  // Context-based decisions.
738  const DeclContext *LexicalDC = ND->getLexicalDeclContext();
739  if (LexicalDC->isFunctionOrMethod()) {
740  // _cmd is relatively rare
741  if (const ImplicitParamDecl *ImplicitParam =
742  dyn_cast<ImplicitParamDecl>(ND))
743  if (ImplicitParam->getIdentifier() &&
744  ImplicitParam->getIdentifier()->isStr("_cmd"))
745  return CCP_ObjC_cmd;
746 
747  return CCP_LocalDeclaration;
748  }
749 
750  const DeclContext *DC = ND->getDeclContext()->getRedeclContext();
751  if (DC->isRecord() || isa<ObjCContainerDecl>(DC)) {
752  // Explicit destructor calls are very rare.
753  if (isa<CXXDestructorDecl>(ND))
754  return CCP_Unlikely;
755  // Explicit operator and conversion function calls are also very rare.
756  auto DeclNameKind = ND->getDeclName().getNameKind();
757  if (DeclNameKind == DeclarationName::CXXOperatorName ||
758  DeclNameKind == DeclarationName::CXXLiteralOperatorName ||
760  return CCP_Unlikely;
761  return CCP_MemberDeclaration;
762  }
763 
764  // Content-based decisions.
765  if (isa<EnumConstantDecl>(ND))
766  return CCP_Constant;
767 
768  // Use CCP_Type for type declarations unless we're in a statement, Objective-C
769  // message receiver, or parenthesized expression context. There, it's as
770  // likely that the user will want to write a type as other declarations.
771  if ((isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) &&
772  !(CompletionContext.getKind() == CodeCompletionContext::CCC_Statement ||
773  CompletionContext.getKind()
775  CompletionContext.getKind()
777  return CCP_Type;
778 
779  return CCP_Declaration;
780 }
781 
782 void ResultBuilder::AdjustResultPriorityForDecl(Result &R) {
783  // If this is an Objective-C method declaration whose selector matches our
784  // preferred selector, give it a priority boost.
785  if (!PreferredSelector.isNull())
786  if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(R.Declaration))
787  if (PreferredSelector == Method->getSelector())
788  R.Priority += CCD_SelectorMatch;
789 
790  // If we have a preferred type, adjust the priority for results with exactly-
791  // matching or nearly-matching types.
792  if (!PreferredType.isNull()) {
793  QualType T = getDeclUsageType(SemaRef.Context, R.Declaration);
794  if (!T.isNull()) {
795  CanQualType TC = SemaRef.Context.getCanonicalType(T);
796  // Check for exactly-matching types (modulo qualifiers).
797  if (SemaRef.Context.hasSameUnqualifiedType(PreferredType, TC))
798  R.Priority /= CCF_ExactTypeMatch;
799  // Check for nearly-matching types, based on classification of each.
800  else if ((getSimplifiedTypeClass(PreferredType)
801  == getSimplifiedTypeClass(TC)) &&
802  !(PreferredType->isEnumeralType() && TC->isEnumeralType()))
803  R.Priority /= CCF_SimilarTypeMatch;
804  }
805  }
806 }
807 
808 void ResultBuilder::MaybeAddConstructorResults(Result R) {
809  if (!SemaRef.getLangOpts().CPlusPlus || !R.Declaration ||
810  !CompletionContext.wantConstructorResults())
811  return;
812 
813  ASTContext &Context = SemaRef.Context;
814  const NamedDecl *D = R.Declaration;
815  const CXXRecordDecl *Record = nullptr;
816  if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D))
817  Record = ClassTemplate->getTemplatedDecl();
818  else if ((Record = dyn_cast<CXXRecordDecl>(D))) {
819  // Skip specializations and partial specializations.
820  if (isa<ClassTemplateSpecializationDecl>(Record))
821  return;
822  } else {
823  // There are no constructors here.
824  return;
825  }
826 
827  Record = Record->getDefinition();
828  if (!Record)
829  return;
830 
831 
832  QualType RecordTy = Context.getTypeDeclType(Record);
833  DeclarationName ConstructorName
835  Context.getCanonicalType(RecordTy));
836  DeclContext::lookup_result Ctors = Record->lookup(ConstructorName);
837  for (DeclContext::lookup_iterator I = Ctors.begin(),
838  E = Ctors.end();
839  I != E; ++I) {
840  R.Declaration = *I;
841  R.CursorKind = getCursorKindForDecl(R.Declaration);
842  Results.push_back(R);
843  }
844 }
845 
846 static bool isConstructor(const Decl *ND) {
847  if (const auto *Tmpl = dyn_cast<FunctionTemplateDecl>(ND))
848  ND = Tmpl->getTemplatedDecl();
849  return isa<CXXConstructorDecl>(ND);
850 }
851 
852 void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) {
853  assert(!ShadowMaps.empty() && "Must enter into a results scope");
854 
855  if (R.Kind != Result::RK_Declaration) {
856  // For non-declaration results, just add the result.
857  Results.push_back(R);
858  return;
859  }
860 
861  // Look through using declarations.
862  if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
863  CodeCompletionResult Result(Using->getTargetDecl(),
864  getBasePriority(Using->getTargetDecl()),
865  R.Qualifier);
866  Result.ShadowDecl = Using;
867  MaybeAddResult(Result, CurContext);
868  return;
869  }
870 
871  const Decl *CanonDecl = R.Declaration->getCanonicalDecl();
872  unsigned IDNS = CanonDecl->getIdentifierNamespace();
873 
874  bool AsNestedNameSpecifier = false;
875  if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
876  return;
877 
878  // C++ constructors are never found by name lookup.
879  if (isConstructor(R.Declaration))
880  return;
881 
882  ShadowMap &SMap = ShadowMaps.back();
883  ShadowMapEntry::iterator I, IEnd;
884  ShadowMap::iterator NamePos = SMap.find(R.Declaration->getDeclName());
885  if (NamePos != SMap.end()) {
886  I = NamePos->second.begin();
887  IEnd = NamePos->second.end();
888  }
889 
890  for (; I != IEnd; ++I) {
891  const NamedDecl *ND = I->first;
892  unsigned Index = I->second;
893  if (ND->getCanonicalDecl() == CanonDecl) {
894  // This is a redeclaration. Always pick the newer declaration.
895  Results[Index].Declaration = R.Declaration;
896 
897  // We're done.
898  return;
899  }
900  }
901 
902  // This is a new declaration in this scope. However, check whether this
903  // declaration name is hidden by a similarly-named declaration in an outer
904  // scope.
905  std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end();
906  --SMEnd;
907  for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) {
908  ShadowMapEntry::iterator I, IEnd;
909  ShadowMap::iterator NamePos = SM->find(R.Declaration->getDeclName());
910  if (NamePos != SM->end()) {
911  I = NamePos->second.begin();
912  IEnd = NamePos->second.end();
913  }
914  for (; I != IEnd; ++I) {
915  // A tag declaration does not hide a non-tag declaration.
916  if (I->first->hasTagIdentifierNamespace() &&
919  continue;
920 
921  // Protocols are in distinct namespaces from everything else.
922  if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol)
923  || (IDNS & Decl::IDNS_ObjCProtocol)) &&
924  I->first->getIdentifierNamespace() != IDNS)
925  continue;
926 
927  // The newly-added result is hidden by an entry in the shadow map.
928  if (CheckHiddenResult(R, CurContext, I->first))
929  return;
930 
931  break;
932  }
933  }
934 
935  // Make sure that any given declaration only shows up in the result set once.
936  if (!AllDeclsFound.insert(CanonDecl).second)
937  return;
938 
939  // If the filter is for nested-name-specifiers, then this result starts a
940  // nested-name-specifier.
941  if (AsNestedNameSpecifier) {
942  R.StartsNestedNameSpecifier = true;
943  R.Priority = CCP_NestedNameSpecifier;
944  } else
945  AdjustResultPriorityForDecl(R);
946 
947  // If this result is supposed to have an informative qualifier, add one.
948  if (R.QualifierIsInformative && !R.Qualifier &&
949  !R.StartsNestedNameSpecifier) {
950  const DeclContext *Ctx = R.Declaration->getDeclContext();
951  if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
952  R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr,
953  Namespace);
954  else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
955  R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr,
956  false, SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
957  else
958  R.QualifierIsInformative = false;
959  }
960 
961  // Insert this result into the set of results and into the current shadow
962  // map.
963  SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
964  Results.push_back(R);
965 
966  if (!AsNestedNameSpecifier)
967  MaybeAddConstructorResults(R);
968 }
969 
970 void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
971  NamedDecl *Hiding, bool InBaseClass = false) {
972  if (R.Kind != Result::RK_Declaration) {
973  // For non-declaration results, just add the result.
974  Results.push_back(R);
975  return;
976  }
977 
978  // Look through using declarations.
979  if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
980  CodeCompletionResult Result(Using->getTargetDecl(),
981  getBasePriority(Using->getTargetDecl()),
982  R.Qualifier);
983  Result.ShadowDecl = Using;
984  AddResult(Result, CurContext, Hiding);
985  return;
986  }
987 
988  bool AsNestedNameSpecifier = false;
989  if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier))
990  return;
991 
992  // C++ constructors are never found by name lookup.
993  if (isConstructor(R.Declaration))
994  return;
995 
996  if (Hiding && CheckHiddenResult(R, CurContext, Hiding))
997  return;
998 
999  // Make sure that any given declaration only shows up in the result set once.
1000  if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()).second)
1001  return;
1002 
1003  // If the filter is for nested-name-specifiers, then this result starts a
1004  // nested-name-specifier.
1005  if (AsNestedNameSpecifier) {
1006  R.StartsNestedNameSpecifier = true;
1007  R.Priority = CCP_NestedNameSpecifier;
1008  } else if (Filter == &ResultBuilder::IsMember && !R.Qualifier &&
1009  InBaseClass &&
1010  isa<CXXRecordDecl>(
1011  R.Declaration->getDeclContext()->getRedeclContext()))
1012  R.QualifierIsInformative = true;
1013 
1014  // If this result is supposed to have an informative qualifier, add one.
1015  if (R.QualifierIsInformative && !R.Qualifier &&
1016  !R.StartsNestedNameSpecifier) {
1017  const DeclContext *Ctx = R.Declaration->getDeclContext();
1018  if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx))
1019  R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr,
1020  Namespace);
1021  else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
1022  R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr, false,
1023  SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
1024  else
1025  R.QualifierIsInformative = false;
1026  }
1027 
1028  // Adjust the priority if this result comes from a base class.
1029  if (InBaseClass)
1030  R.Priority += CCD_InBaseClass;
1031 
1032  AdjustResultPriorityForDecl(R);
1033 
1034  if (HasObjectTypeQualifiers)
1035  if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(R.Declaration))
1036  if (Method->isInstance()) {
1037  Qualifiers MethodQuals
1038  = Qualifiers::fromCVRMask(Method->getTypeQualifiers());
1039  if (ObjectTypeQualifiers == MethodQuals)
1040  R.Priority += CCD_ObjectQualifierMatch;
1041  else if (ObjectTypeQualifiers - MethodQuals) {
1042  // The method cannot be invoked, because doing so would drop
1043  // qualifiers.
1044  return;
1045  }
1046  }
1047 
1048  // Insert this result into the set of results.
1049  Results.push_back(R);
1050 
1051  if (!AsNestedNameSpecifier)
1052  MaybeAddConstructorResults(R);
1053 }
1054 
1055 void ResultBuilder::AddResult(Result R) {
1056  assert(R.Kind != Result::RK_Declaration &&
1057  "Declaration results need more context");
1058  Results.push_back(R);
1059 }
1060 
1061 /// Enter into a new scope.
1062 void ResultBuilder::EnterNewScope() { ShadowMaps.emplace_back(); }
1063 
1064 /// Exit from the current scope.
1065 void ResultBuilder::ExitScope() {
1066  for (ShadowMap::iterator E = ShadowMaps.back().begin(),
1067  EEnd = ShadowMaps.back().end();
1068  E != EEnd;
1069  ++E)
1070  E->second.Destroy();
1071 
1072  ShadowMaps.pop_back();
1073 }
1074 
1075 /// Determines whether this given declaration will be found by
1076 /// ordinary name lookup.
1077 bool ResultBuilder::IsOrdinaryName(const NamedDecl *ND) const {
1078  ND = ND->getUnderlyingDecl();
1079 
1080  // If name lookup finds a local extern declaration, then we are in a
1081  // context where it behaves like an ordinary name.
1082  unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1083  if (SemaRef.getLangOpts().CPlusPlus)
1085  else if (SemaRef.getLangOpts().ObjC1) {
1086  if (isa<ObjCIvarDecl>(ND))
1087  return true;
1088  }
1089 
1090  return ND->getIdentifierNamespace() & IDNS;
1091 }
1092 
1093 /// Determines whether this given declaration will be found by
1094 /// ordinary name lookup but is not a type name.
1095 bool ResultBuilder::IsOrdinaryNonTypeName(const NamedDecl *ND) const {
1096  ND = ND->getUnderlyingDecl();
1097  if (isa<TypeDecl>(ND))
1098  return false;
1099  // Objective-C interfaces names are not filtered by this method because they
1100  // can be used in a class property expression. We can still filter out
1101  // @class declarations though.
1102  if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND)) {
1103  if (!ID->getDefinition())
1104  return false;
1105  }
1106 
1107  unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1108  if (SemaRef.getLangOpts().CPlusPlus)
1110  else if (SemaRef.getLangOpts().ObjC1) {
1111  if (isa<ObjCIvarDecl>(ND))
1112  return true;
1113  }
1114 
1115  return ND->getIdentifierNamespace() & IDNS;
1116 }
1117 
1118 bool ResultBuilder::IsIntegralConstantValue(const NamedDecl *ND) const {
1119  if (!IsOrdinaryNonTypeName(ND))
1120  return 0;
1121 
1122  if (const ValueDecl *VD = dyn_cast<ValueDecl>(ND->getUnderlyingDecl()))
1123  if (VD->getType()->isIntegralOrEnumerationType())
1124  return true;
1125 
1126  return false;
1127 }
1128 
1129 /// Determines whether this given declaration will be found by
1130 /// ordinary name lookup.
1131 bool ResultBuilder::IsOrdinaryNonValueName(const NamedDecl *ND) const {
1132  ND = ND->getUnderlyingDecl();
1133 
1134  unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern;
1135  if (SemaRef.getLangOpts().CPlusPlus)
1137 
1138  return (ND->getIdentifierNamespace() & IDNS) &&
1139  !isa<ValueDecl>(ND) && !isa<FunctionTemplateDecl>(ND) &&
1140  !isa<ObjCPropertyDecl>(ND);
1141 }
1142 
1143 /// Determines whether the given declaration is suitable as the
1144 /// start of a C++ nested-name-specifier, e.g., a class or namespace.
1145 bool ResultBuilder::IsNestedNameSpecifier(const NamedDecl *ND) const {
1146  // Allow us to find class templates, too.
1147  if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1148  ND = ClassTemplate->getTemplatedDecl();
1149 
1150  return SemaRef.isAcceptableNestedNameSpecifier(ND);
1151 }
1152 
1153 /// Determines whether the given declaration is an enumeration.
1154 bool ResultBuilder::IsEnum(const NamedDecl *ND) const {
1155  return isa<EnumDecl>(ND);
1156 }
1157 
1158 /// Determines whether the given declaration is a class or struct.
1159 bool ResultBuilder::IsClassOrStruct(const NamedDecl *ND) const {
1160  // Allow us to find class templates, too.
1161  if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1162  ND = ClassTemplate->getTemplatedDecl();
1163 
1164  // For purposes of this check, interfaces match too.
1165  if (const RecordDecl *RD = dyn_cast<RecordDecl>(ND))
1166  return RD->getTagKind() == TTK_Class ||
1167  RD->getTagKind() == TTK_Struct ||
1168  RD->getTagKind() == TTK_Interface;
1169 
1170  return false;
1171 }
1172 
1173 /// Determines whether the given declaration is a union.
1174 bool ResultBuilder::IsUnion(const NamedDecl *ND) const {
1175  // Allow us to find class templates, too.
1176  if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND))
1177  ND = ClassTemplate->getTemplatedDecl();
1178 
1179  if (const RecordDecl *RD = dyn_cast<RecordDecl>(ND))
1180  return RD->getTagKind() == TTK_Union;
1181 
1182  return false;
1183 }
1184 
1185 /// Determines whether the given declaration is a namespace.
1186 bool ResultBuilder::IsNamespace(const NamedDecl *ND) const {
1187  return isa<NamespaceDecl>(ND);
1188 }
1189 
1190 /// Determines whether the given declaration is a namespace or
1191 /// namespace alias.
1192 bool ResultBuilder::IsNamespaceOrAlias(const NamedDecl *ND) const {
1193  return isa<NamespaceDecl>(ND->getUnderlyingDecl());
1194 }
1195 
1196 /// Determines whether the given declaration is a type.
1197 bool ResultBuilder::IsType(const NamedDecl *ND) const {
1198  ND = ND->getUnderlyingDecl();
1199  return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
1200 }
1201 
1202 /// Determines which members of a class should be visible via
1203 /// "." or "->". Only value declarations, nested name specifiers, and
1204 /// using declarations thereof should show up.
1205 bool ResultBuilder::IsMember(const NamedDecl *ND) const {
1206  ND = ND->getUnderlyingDecl();
1207  return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) ||
1208  isa<ObjCPropertyDecl>(ND);
1209 }
1210 
1212  T = C.getCanonicalType(T);
1213  switch (T->getTypeClass()) {
1214  case Type::ObjCObject:
1215  case Type::ObjCInterface:
1216  case Type::ObjCObjectPointer:
1217  return true;
1218 
1219  case Type::Builtin:
1220  switch (cast<BuiltinType>(T)->getKind()) {
1221  case BuiltinType::ObjCId:
1222  case BuiltinType::ObjCClass:
1223  case BuiltinType::ObjCSel:
1224  return true;
1225 
1226  default:
1227  break;
1228  }
1229  return false;
1230 
1231  default:
1232  break;
1233  }
1234 
1235  if (!C.getLangOpts().CPlusPlus)
1236  return false;
1237 
1238  // FIXME: We could perform more analysis here to determine whether a
1239  // particular class type has any conversions to Objective-C types. For now,
1240  // just accept all class types.
1241  return T->isDependentType() || T->isRecordType();
1242 }
1243 
1244 bool ResultBuilder::IsObjCMessageReceiver(const NamedDecl *ND) const {
1245  QualType T = getDeclUsageType(SemaRef.Context, ND);
1246  if (T.isNull())
1247  return false;
1248 
1249  T = SemaRef.Context.getBaseElementType(T);
1250  return isObjCReceiverType(SemaRef.Context, T);
1251 }
1252 
1253 bool ResultBuilder::IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const {
1254  if (IsObjCMessageReceiver(ND))
1255  return true;
1256 
1257  const VarDecl *Var = dyn_cast<VarDecl>(ND);
1258  if (!Var)
1259  return false;
1260 
1261  return Var->hasLocalStorage() && !Var->hasAttr<BlocksAttr>();
1262 }
1263 
1264 bool ResultBuilder::IsObjCCollection(const NamedDecl *ND) const {
1265  if ((SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryName(ND)) ||
1266  (!SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryNonTypeName(ND)))
1267  return false;
1268 
1269  QualType T = getDeclUsageType(SemaRef.Context, ND);
1270  if (T.isNull())
1271  return false;
1272 
1273  T = SemaRef.Context.getBaseElementType(T);
1274  return T->isObjCObjectType() || T->isObjCObjectPointerType() ||
1275  T->isObjCIdType() ||
1276  (SemaRef.getLangOpts().CPlusPlus && T->isRecordType());
1277 }
1278 
1279 bool ResultBuilder::IsImpossibleToSatisfy(const NamedDecl *ND) const {
1280  return false;
1281 }
1282 
1283 /// Determines whether the given declaration is an Objective-C
1284 /// instance variable.
1285 bool ResultBuilder::IsObjCIvar(const NamedDecl *ND) const {
1286  return isa<ObjCIvarDecl>(ND);
1287 }
1288 
1289 namespace {
1290  /// Visible declaration consumer that adds a code-completion result
1291  /// for each visible declaration.
1292  class CodeCompletionDeclConsumer : public VisibleDeclConsumer {
1293  ResultBuilder &Results;
1294  DeclContext *CurContext;
1295  std::vector<FixItHint> FixIts;
1296 
1297  public:
1298  CodeCompletionDeclConsumer(
1299  ResultBuilder &Results, DeclContext *CurContext,
1300  std::vector<FixItHint> FixIts = std::vector<FixItHint>())
1301  : Results(Results), CurContext(CurContext), FixIts(std::move(FixIts)) {}
1302 
1303  void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
1304  bool InBaseClass) override {
1305  bool Accessible = true;
1306  if (Ctx)
1307  Accessible = Results.getSema().IsSimplyAccessible(ND, Ctx);
1308  ResultBuilder::Result Result(ND, Results.getBasePriority(ND), nullptr,
1309  false, Accessible, FixIts);
1310  Results.AddResult(Result, CurContext, Hiding, InBaseClass);
1311  }
1312 
1313  void EnteredContext(DeclContext* Ctx) override {
1314  Results.addVisitedContext(Ctx);
1315  }
1316  };
1317 }
1318 
1319 /// Add type specifiers for the current language as keyword results.
1320 static void AddTypeSpecifierResults(const LangOptions &LangOpts,
1321  ResultBuilder &Results) {
1322  typedef CodeCompletionResult Result;
1323  Results.AddResult(Result("short", CCP_Type));
1324  Results.AddResult(Result("long", CCP_Type));
1325  Results.AddResult(Result("signed", CCP_Type));
1326  Results.AddResult(Result("unsigned", CCP_Type));
1327  Results.AddResult(Result("void", CCP_Type));
1328  Results.AddResult(Result("char", CCP_Type));
1329  Results.AddResult(Result("int", CCP_Type));
1330  Results.AddResult(Result("float", CCP_Type));
1331  Results.AddResult(Result("double", CCP_Type));
1332  Results.AddResult(Result("enum", CCP_Type));
1333  Results.AddResult(Result("struct", CCP_Type));
1334  Results.AddResult(Result("union", CCP_Type));
1335  Results.AddResult(Result("const", CCP_Type));
1336  Results.AddResult(Result("volatile", CCP_Type));
1337 
1338  if (LangOpts.C99) {
1339  // C99-specific
1340  Results.AddResult(Result("_Complex", CCP_Type));
1341  Results.AddResult(Result("_Imaginary", CCP_Type));
1342  Results.AddResult(Result("_Bool", CCP_Type));
1343  Results.AddResult(Result("restrict", CCP_Type));
1344  }
1345 
1346  CodeCompletionBuilder Builder(Results.getAllocator(),
1347  Results.getCodeCompletionTUInfo());
1348  if (LangOpts.CPlusPlus) {
1349  // C++-specific
1350  Results.AddResult(Result("bool", CCP_Type +
1351  (LangOpts.ObjC1? CCD_bool_in_ObjC : 0)));
1352  Results.AddResult(Result("class", CCP_Type));
1353  Results.AddResult(Result("wchar_t", CCP_Type));
1354 
1355  // typename qualified-id
1356  Builder.AddTypedTextChunk("typename");
1357  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1358  Builder.AddPlaceholderChunk("qualifier");
1359  Builder.AddTextChunk("::");
1360  Builder.AddPlaceholderChunk("name");
1361  Results.AddResult(Result(Builder.TakeString()));
1362 
1363  if (LangOpts.CPlusPlus11) {
1364  Results.AddResult(Result("auto", CCP_Type));
1365  Results.AddResult(Result("char16_t", CCP_Type));
1366  Results.AddResult(Result("char32_t", CCP_Type));
1367 
1368  Builder.AddTypedTextChunk("decltype");
1369  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1370  Builder.AddPlaceholderChunk("expression");
1371  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1372  Results.AddResult(Result(Builder.TakeString()));
1373  }
1374  } else
1375  Results.AddResult(Result("__auto_type", CCP_Type));
1376 
1377  // GNU keywords
1378  if (LangOpts.GNUKeywords) {
1379  // FIXME: Enable when we actually support decimal floating point.
1380  // Results.AddResult(Result("_Decimal32"));
1381  // Results.AddResult(Result("_Decimal64"));
1382  // Results.AddResult(Result("_Decimal128"));
1383 
1384  Builder.AddTypedTextChunk("typeof");
1385  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1386  Builder.AddPlaceholderChunk("expression");
1387  Results.AddResult(Result(Builder.TakeString()));
1388 
1389  Builder.AddTypedTextChunk("typeof");
1390  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1391  Builder.AddPlaceholderChunk("type");
1392  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1393  Results.AddResult(Result(Builder.TakeString()));
1394  }
1395 
1396  // Nullability
1397  Results.AddResult(Result("_Nonnull", CCP_Type));
1398  Results.AddResult(Result("_Null_unspecified", CCP_Type));
1399  Results.AddResult(Result("_Nullable", CCP_Type));
1400 }
1401 
1403  const LangOptions &LangOpts,
1404  ResultBuilder &Results) {
1405  typedef CodeCompletionResult Result;
1406  // Note: we don't suggest either "auto" or "register", because both
1407  // are pointless as storage specifiers. Elsewhere, we suggest "auto"
1408  // in C++0x as a type specifier.
1409  Results.AddResult(Result("extern"));
1410  Results.AddResult(Result("static"));
1411 
1412  if (LangOpts.CPlusPlus11) {
1413  CodeCompletionAllocator &Allocator = Results.getAllocator();
1414  CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1415 
1416  // alignas
1417  Builder.AddTypedTextChunk("alignas");
1418  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1419  Builder.AddPlaceholderChunk("expression");
1420  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1421  Results.AddResult(Result(Builder.TakeString()));
1422 
1423  Results.AddResult(Result("constexpr"));
1424  Results.AddResult(Result("thread_local"));
1425  }
1426 }
1427 
1429  const LangOptions &LangOpts,
1430  ResultBuilder &Results) {
1431  typedef CodeCompletionResult Result;
1432  switch (CCC) {
1433  case Sema::PCC_Class:
1435  if (LangOpts.CPlusPlus) {
1436  Results.AddResult(Result("explicit"));
1437  Results.AddResult(Result("friend"));
1438  Results.AddResult(Result("mutable"));
1439  Results.AddResult(Result("virtual"));
1440  }
1441  LLVM_FALLTHROUGH;
1442 
1445  case Sema::PCC_Namespace:
1446  case Sema::PCC_Template:
1447  if (LangOpts.CPlusPlus || LangOpts.C99)
1448  Results.AddResult(Result("inline"));
1449  break;
1450 
1452  case Sema::PCC_Expression:
1453  case Sema::PCC_Statement:
1454  case Sema::PCC_ForInit:
1455  case Sema::PCC_Condition:
1457  case Sema::PCC_Type:
1460  break;
1461  }
1462 }
1463 
1464 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt);
1465 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt);
1466 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
1467  ResultBuilder &Results,
1468  bool NeedAt);
1469 static void AddObjCImplementationResults(const LangOptions &LangOpts,
1470  ResultBuilder &Results,
1471  bool NeedAt);
1472 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
1473  ResultBuilder &Results,
1474  bool NeedAt);
1475 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt);
1476 
1477 static void AddTypedefResult(ResultBuilder &Results) {
1478  CodeCompletionBuilder Builder(Results.getAllocator(),
1479  Results.getCodeCompletionTUInfo());
1480  Builder.AddTypedTextChunk("typedef");
1481  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1482  Builder.AddPlaceholderChunk("type");
1483  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1484  Builder.AddPlaceholderChunk("name");
1485  Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1486 }
1487 
1489  const LangOptions &LangOpts) {
1490  switch (CCC) {
1491  case Sema::PCC_Namespace:
1492  case Sema::PCC_Class:
1494  case Sema::PCC_Template:
1496  case Sema::PCC_Statement:
1498  case Sema::PCC_Type:
1501  return true;
1502 
1503  case Sema::PCC_Expression:
1504  case Sema::PCC_Condition:
1505  return LangOpts.CPlusPlus;
1506 
1509  return false;
1510 
1511  case Sema::PCC_ForInit:
1512  return LangOpts.CPlusPlus || LangOpts.ObjC1 || LangOpts.C99;
1513  }
1514 
1515  llvm_unreachable("Invalid ParserCompletionContext!");
1516 }
1517 
1519  const Preprocessor &PP) {
1520  PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP);
1521  Policy.AnonymousTagLocations = false;
1522  Policy.SuppressStrongLifetime = true;
1523  Policy.SuppressUnwrittenScope = true;
1524  Policy.SuppressScope = true;
1525  return Policy;
1526 }
1527 
1528 /// Retrieve a printing policy suitable for code completion.
1530  return getCompletionPrintingPolicy(S.Context, S.PP);
1531 }
1532 
1533 /// Retrieve the string representation of the given type as a string
1534 /// that has the appropriate lifetime for code completion.
1535 ///
1536 /// This routine provides a fast path where we provide constant strings for
1537 /// common type names.
1538 static const char *GetCompletionTypeString(QualType T,
1539  ASTContext &Context,
1540  const PrintingPolicy &Policy,
1541  CodeCompletionAllocator &Allocator) {
1542  if (!T.getLocalQualifiers()) {
1543  // Built-in type names are constant strings.
1544  if (const BuiltinType *BT = dyn_cast<BuiltinType>(T))
1545  return BT->getNameAsCString(Policy);
1546 
1547  // Anonymous tag types are constant strings.
1548  if (const TagType *TagT = dyn_cast<TagType>(T))
1549  if (TagDecl *Tag = TagT->getDecl())
1550  if (!Tag->hasNameForLinkage()) {
1551  switch (Tag->getTagKind()) {
1552  case TTK_Struct: return "struct <anonymous>";
1553  case TTK_Interface: return "__interface <anonymous>";
1554  case TTK_Class: return "class <anonymous>";
1555  case TTK_Union: return "union <anonymous>";
1556  case TTK_Enum: return "enum <anonymous>";
1557  }
1558  }
1559  }
1560 
1561  // Slow path: format the type as a string.
1562  std::string Result;
1563  T.getAsStringInternal(Result, Policy);
1564  return Allocator.CopyString(Result);
1565 }
1566 
1567 /// Add a completion for "this", if we're in a member function.
1568 static void addThisCompletion(Sema &S, ResultBuilder &Results) {
1569  QualType ThisTy = S.getCurrentThisType();
1570  if (ThisTy.isNull())
1571  return;
1572 
1573  CodeCompletionAllocator &Allocator = Results.getAllocator();
1574  CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1576  Builder.AddResultTypeChunk(GetCompletionTypeString(ThisTy,
1577  S.Context,
1578  Policy,
1579  Allocator));
1580  Builder.AddTypedTextChunk("this");
1581  Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1582 }
1583 
1585  ResultBuilder &Results,
1586  const LangOptions &LangOpts) {
1587  if (!LangOpts.CPlusPlus11)
1588  return;
1589 
1590  Builder.AddTypedTextChunk("static_assert");
1592  Builder.AddPlaceholderChunk("expression");
1594  Builder.AddPlaceholderChunk("message");
1596  Results.AddResult(CodeCompletionResult(Builder.TakeString()));
1597 }
1598 
1599 /// Add language constructs that show up for "ordinary" names.
1601  Scope *S,
1602  Sema &SemaRef,
1603  ResultBuilder &Results) {
1604  CodeCompletionAllocator &Allocator = Results.getAllocator();
1605  CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
1606 
1607  typedef CodeCompletionResult Result;
1608  switch (CCC) {
1609  case Sema::PCC_Namespace:
1610  if (SemaRef.getLangOpts().CPlusPlus) {
1611  if (Results.includeCodePatterns()) {
1612  // namespace <identifier> { declarations }
1613  Builder.AddTypedTextChunk("namespace");
1614  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1615  Builder.AddPlaceholderChunk("identifier");
1616  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1617  Builder.AddPlaceholderChunk("declarations");
1618  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1619  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1620  Results.AddResult(Result(Builder.TakeString()));
1621  }
1622 
1623  // namespace identifier = identifier ;
1624  Builder.AddTypedTextChunk("namespace");
1625  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1626  Builder.AddPlaceholderChunk("name");
1627  Builder.AddChunk(CodeCompletionString::CK_Equal);
1628  Builder.AddPlaceholderChunk("namespace");
1629  Results.AddResult(Result(Builder.TakeString()));
1630 
1631  // Using directives
1632  Builder.AddTypedTextChunk("using");
1633  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1634  Builder.AddTextChunk("namespace");
1635  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1636  Builder.AddPlaceholderChunk("identifier");
1637  Results.AddResult(Result(Builder.TakeString()));
1638 
1639  // asm(string-literal)
1640  Builder.AddTypedTextChunk("asm");
1641  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1642  Builder.AddPlaceholderChunk("string-literal");
1643  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1644  Results.AddResult(Result(Builder.TakeString()));
1645 
1646  if (Results.includeCodePatterns()) {
1647  // Explicit template instantiation
1648  Builder.AddTypedTextChunk("template");
1649  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1650  Builder.AddPlaceholderChunk("declaration");
1651  Results.AddResult(Result(Builder.TakeString()));
1652  }
1653  }
1654 
1655  if (SemaRef.getLangOpts().ObjC1)
1656  AddObjCTopLevelResults(Results, true);
1657 
1658  AddTypedefResult(Results);
1659  LLVM_FALLTHROUGH;
1660 
1661  case Sema::PCC_Class:
1662  if (SemaRef.getLangOpts().CPlusPlus) {
1663  // Using declaration
1664  Builder.AddTypedTextChunk("using");
1665  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1666  Builder.AddPlaceholderChunk("qualifier");
1667  Builder.AddTextChunk("::");
1668  Builder.AddPlaceholderChunk("name");
1669  Results.AddResult(Result(Builder.TakeString()));
1670 
1671  // using typename qualifier::name (only in a dependent context)
1672  if (SemaRef.CurContext->isDependentContext()) {
1673  Builder.AddTypedTextChunk("using");
1674  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1675  Builder.AddTextChunk("typename");
1676  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1677  Builder.AddPlaceholderChunk("qualifier");
1678  Builder.AddTextChunk("::");
1679  Builder.AddPlaceholderChunk("name");
1680  Results.AddResult(Result(Builder.TakeString()));
1681  }
1682 
1683  AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts());
1684 
1685  if (CCC == Sema::PCC_Class) {
1686  AddTypedefResult(Results);
1687 
1688  bool IsNotInheritanceScope =
1690  // public:
1691  Builder.AddTypedTextChunk("public");
1692  if (IsNotInheritanceScope && Results.includeCodePatterns())
1693  Builder.AddChunk(CodeCompletionString::CK_Colon);
1694  Results.AddResult(Result(Builder.TakeString()));
1695 
1696  // protected:
1697  Builder.AddTypedTextChunk("protected");
1698  if (IsNotInheritanceScope && Results.includeCodePatterns())
1699  Builder.AddChunk(CodeCompletionString::CK_Colon);
1700  Results.AddResult(Result(Builder.TakeString()));
1701 
1702  // private:
1703  Builder.AddTypedTextChunk("private");
1704  if (IsNotInheritanceScope && Results.includeCodePatterns())
1705  Builder.AddChunk(CodeCompletionString::CK_Colon);
1706  Results.AddResult(Result(Builder.TakeString()));
1707  }
1708  }
1709  LLVM_FALLTHROUGH;
1710 
1711  case Sema::PCC_Template:
1713  if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) {
1714  // template < parameters >
1715  Builder.AddTypedTextChunk("template");
1716  Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1717  Builder.AddPlaceholderChunk("parameters");
1718  Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1719  Results.AddResult(Result(Builder.TakeString()));
1720  }
1721 
1722  AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1723  AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1724  break;
1725 
1727  AddObjCInterfaceResults(SemaRef.getLangOpts(), Results, true);
1728  AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1729  AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1730  break;
1731 
1733  AddObjCImplementationResults(SemaRef.getLangOpts(), Results, true);
1734  AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1735  AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1736  break;
1737 
1739  AddObjCVisibilityResults(SemaRef.getLangOpts(), Results, true);
1740  break;
1741 
1743  case Sema::PCC_Statement: {
1744  AddTypedefResult(Results);
1745 
1746  if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns() &&
1747  SemaRef.getLangOpts().CXXExceptions) {
1748  Builder.AddTypedTextChunk("try");
1749  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1750  Builder.AddPlaceholderChunk("statements");
1751  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1752  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1753  Builder.AddTextChunk("catch");
1754  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1755  Builder.AddPlaceholderChunk("declaration");
1756  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1757  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1758  Builder.AddPlaceholderChunk("statements");
1759  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1760  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1761  Results.AddResult(Result(Builder.TakeString()));
1762  }
1763  if (SemaRef.getLangOpts().ObjC1)
1764  AddObjCStatementResults(Results, true);
1765 
1766  if (Results.includeCodePatterns()) {
1767  // if (condition) { statements }
1768  Builder.AddTypedTextChunk("if");
1769  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1770  if (SemaRef.getLangOpts().CPlusPlus)
1771  Builder.AddPlaceholderChunk("condition");
1772  else
1773  Builder.AddPlaceholderChunk("expression");
1774  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1775  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1776  Builder.AddPlaceholderChunk("statements");
1777  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1778  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1779  Results.AddResult(Result(Builder.TakeString()));
1780 
1781  // switch (condition) { }
1782  Builder.AddTypedTextChunk("switch");
1783  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1784  if (SemaRef.getLangOpts().CPlusPlus)
1785  Builder.AddPlaceholderChunk("condition");
1786  else
1787  Builder.AddPlaceholderChunk("expression");
1788  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1789  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1790  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1791  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1792  Results.AddResult(Result(Builder.TakeString()));
1793  }
1794 
1795  // Switch-specific statements.
1796  if (!SemaRef.getCurFunction()->SwitchStack.empty()) {
1797  // case expression:
1798  Builder.AddTypedTextChunk("case");
1799  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1800  Builder.AddPlaceholderChunk("expression");
1801  Builder.AddChunk(CodeCompletionString::CK_Colon);
1802  Results.AddResult(Result(Builder.TakeString()));
1803 
1804  // default:
1805  Builder.AddTypedTextChunk("default");
1806  Builder.AddChunk(CodeCompletionString::CK_Colon);
1807  Results.AddResult(Result(Builder.TakeString()));
1808  }
1809 
1810  if (Results.includeCodePatterns()) {
1811  /// while (condition) { statements }
1812  Builder.AddTypedTextChunk("while");
1813  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1814  if (SemaRef.getLangOpts().CPlusPlus)
1815  Builder.AddPlaceholderChunk("condition");
1816  else
1817  Builder.AddPlaceholderChunk("expression");
1818  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1819  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1820  Builder.AddPlaceholderChunk("statements");
1821  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1822  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1823  Results.AddResult(Result(Builder.TakeString()));
1824 
1825  // do { statements } while ( expression );
1826  Builder.AddTypedTextChunk("do");
1827  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1828  Builder.AddPlaceholderChunk("statements");
1829  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1830  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1831  Builder.AddTextChunk("while");
1832  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1833  Builder.AddPlaceholderChunk("expression");
1834  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1835  Results.AddResult(Result(Builder.TakeString()));
1836 
1837  // for ( for-init-statement ; condition ; expression ) { statements }
1838  Builder.AddTypedTextChunk("for");
1839  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1840  if (SemaRef.getLangOpts().CPlusPlus || SemaRef.getLangOpts().C99)
1841  Builder.AddPlaceholderChunk("init-statement");
1842  else
1843  Builder.AddPlaceholderChunk("init-expression");
1844  Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1845  Builder.AddPlaceholderChunk("condition");
1846  Builder.AddChunk(CodeCompletionString::CK_SemiColon);
1847  Builder.AddPlaceholderChunk("inc-expression");
1848  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1849  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
1850  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1851  Builder.AddPlaceholderChunk("statements");
1852  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
1853  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
1854  Results.AddResult(Result(Builder.TakeString()));
1855  }
1856 
1857  if (S->getContinueParent()) {
1858  // continue ;
1859  Builder.AddTypedTextChunk("continue");
1860  Results.AddResult(Result(Builder.TakeString()));
1861  }
1862 
1863  if (S->getBreakParent()) {
1864  // break ;
1865  Builder.AddTypedTextChunk("break");
1866  Results.AddResult(Result(Builder.TakeString()));
1867  }
1868 
1869  // "return expression ;" or "return ;", depending on whether we
1870  // know the function is void or not.
1871  bool isVoid = false;
1872  if (FunctionDecl *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext))
1873  isVoid = Function->getReturnType()->isVoidType();
1874  else if (ObjCMethodDecl *Method
1875  = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext))
1876  isVoid = Method->getReturnType()->isVoidType();
1877  else if (SemaRef.getCurBlock() &&
1878  !SemaRef.getCurBlock()->ReturnType.isNull())
1879  isVoid = SemaRef.getCurBlock()->ReturnType->isVoidType();
1880  Builder.AddTypedTextChunk("return");
1881  if (!isVoid) {
1882  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1883  Builder.AddPlaceholderChunk("expression");
1884  }
1885  Results.AddResult(Result(Builder.TakeString()));
1886 
1887  // goto identifier ;
1888  Builder.AddTypedTextChunk("goto");
1889  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1890  Builder.AddPlaceholderChunk("label");
1891  Results.AddResult(Result(Builder.TakeString()));
1892 
1893  // Using directives
1894  Builder.AddTypedTextChunk("using");
1895  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1896  Builder.AddTextChunk("namespace");
1897  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1898  Builder.AddPlaceholderChunk("identifier");
1899  Results.AddResult(Result(Builder.TakeString()));
1900 
1901  AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts());
1902  }
1903  LLVM_FALLTHROUGH;
1904 
1905  // Fall through (for statement expressions).
1906  case Sema::PCC_ForInit:
1907  case Sema::PCC_Condition:
1908  AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
1909  // Fall through: conditions and statements can have expressions.
1910  LLVM_FALLTHROUGH;
1911 
1913  if (SemaRef.getLangOpts().ObjCAutoRefCount &&
1915  // (__bridge <type>)<expression>
1916  Builder.AddTypedTextChunk("__bridge");
1917  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1918  Builder.AddPlaceholderChunk("type");
1919  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1920  Builder.AddPlaceholderChunk("expression");
1921  Results.AddResult(Result(Builder.TakeString()));
1922 
1923  // (__bridge_transfer <Objective-C type>)<expression>
1924  Builder.AddTypedTextChunk("__bridge_transfer");
1925  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1926  Builder.AddPlaceholderChunk("Objective-C type");
1927  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1928  Builder.AddPlaceholderChunk("expression");
1929  Results.AddResult(Result(Builder.TakeString()));
1930 
1931  // (__bridge_retained <CF type>)<expression>
1932  Builder.AddTypedTextChunk("__bridge_retained");
1933  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
1934  Builder.AddPlaceholderChunk("CF type");
1935  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1936  Builder.AddPlaceholderChunk("expression");
1937  Results.AddResult(Result(Builder.TakeString()));
1938  }
1939  // Fall through
1940  LLVM_FALLTHROUGH;
1941 
1942  case Sema::PCC_Expression: {
1943  if (SemaRef.getLangOpts().CPlusPlus) {
1944  // 'this', if we're in a non-static member function.
1945  addThisCompletion(SemaRef, Results);
1946 
1947  // true
1948  Builder.AddResultTypeChunk("bool");
1949  Builder.AddTypedTextChunk("true");
1950  Results.AddResult(Result(Builder.TakeString()));
1951 
1952  // false
1953  Builder.AddResultTypeChunk("bool");
1954  Builder.AddTypedTextChunk("false");
1955  Results.AddResult(Result(Builder.TakeString()));
1956 
1957  if (SemaRef.getLangOpts().RTTI) {
1958  // dynamic_cast < type-id > ( expression )
1959  Builder.AddTypedTextChunk("dynamic_cast");
1960  Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1961  Builder.AddPlaceholderChunk("type");
1962  Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1963  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1964  Builder.AddPlaceholderChunk("expression");
1965  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1966  Results.AddResult(Result(Builder.TakeString()));
1967  }
1968 
1969  // static_cast < type-id > ( expression )
1970  Builder.AddTypedTextChunk("static_cast");
1971  Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1972  Builder.AddPlaceholderChunk("type");
1973  Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1974  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1975  Builder.AddPlaceholderChunk("expression");
1976  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1977  Results.AddResult(Result(Builder.TakeString()));
1978 
1979  // reinterpret_cast < type-id > ( expression )
1980  Builder.AddTypedTextChunk("reinterpret_cast");
1981  Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1982  Builder.AddPlaceholderChunk("type");
1983  Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1984  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1985  Builder.AddPlaceholderChunk("expression");
1986  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1987  Results.AddResult(Result(Builder.TakeString()));
1988 
1989  // const_cast < type-id > ( expression )
1990  Builder.AddTypedTextChunk("const_cast");
1991  Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
1992  Builder.AddPlaceholderChunk("type");
1993  Builder.AddChunk(CodeCompletionString::CK_RightAngle);
1994  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
1995  Builder.AddPlaceholderChunk("expression");
1996  Builder.AddChunk(CodeCompletionString::CK_RightParen);
1997  Results.AddResult(Result(Builder.TakeString()));
1998 
1999  if (SemaRef.getLangOpts().RTTI) {
2000  // typeid ( expression-or-type )
2001  Builder.AddResultTypeChunk("std::type_info");
2002  Builder.AddTypedTextChunk("typeid");
2003  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2004  Builder.AddPlaceholderChunk("expression-or-type");
2005  Builder.AddChunk(CodeCompletionString::CK_RightParen);
2006  Results.AddResult(Result(Builder.TakeString()));
2007  }
2008 
2009  // new T ( ... )
2010  Builder.AddTypedTextChunk("new");
2011  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2012  Builder.AddPlaceholderChunk("type");
2013  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2014  Builder.AddPlaceholderChunk("expressions");
2015  Builder.AddChunk(CodeCompletionString::CK_RightParen);
2016  Results.AddResult(Result(Builder.TakeString()));
2017 
2018  // new T [ ] ( ... )
2019  Builder.AddTypedTextChunk("new");
2020  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2021  Builder.AddPlaceholderChunk("type");
2022  Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
2023  Builder.AddPlaceholderChunk("size");
2024  Builder.AddChunk(CodeCompletionString::CK_RightBracket);
2025  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2026  Builder.AddPlaceholderChunk("expressions");
2027  Builder.AddChunk(CodeCompletionString::CK_RightParen);
2028  Results.AddResult(Result(Builder.TakeString()));
2029 
2030  // delete expression
2031  Builder.AddResultTypeChunk("void");
2032  Builder.AddTypedTextChunk("delete");
2033  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2034  Builder.AddPlaceholderChunk("expression");
2035  Results.AddResult(Result(Builder.TakeString()));
2036 
2037  // delete [] expression
2038  Builder.AddResultTypeChunk("void");
2039  Builder.AddTypedTextChunk("delete");
2040  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2041  Builder.AddChunk(CodeCompletionString::CK_LeftBracket);
2042  Builder.AddChunk(CodeCompletionString::CK_RightBracket);
2043  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2044  Builder.AddPlaceholderChunk("expression");
2045  Results.AddResult(Result(Builder.TakeString()));
2046 
2047  if (SemaRef.getLangOpts().CXXExceptions) {
2048  // throw expression
2049  Builder.AddResultTypeChunk("void");
2050  Builder.AddTypedTextChunk("throw");
2051  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
2052  Builder.AddPlaceholderChunk("expression");
2053  Results.AddResult(Result(Builder.TakeString()));
2054  }
2055 
2056  // FIXME: Rethrow?
2057 
2058  if (SemaRef.getLangOpts().CPlusPlus11) {
2059  // nullptr
2060  Builder.AddResultTypeChunk("std::nullptr_t");
2061  Builder.AddTypedTextChunk("nullptr");
2062  Results.AddResult(Result(Builder.TakeString()));
2063 
2064  // alignof
2065  Builder.AddResultTypeChunk("size_t");
2066  Builder.AddTypedTextChunk("alignof");
2067  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2068  Builder.AddPlaceholderChunk("type");
2069  Builder.AddChunk(CodeCompletionString::CK_RightParen);
2070  Results.AddResult(Result(Builder.TakeString()));
2071 
2072  // noexcept
2073  Builder.AddResultTypeChunk("bool");
2074  Builder.AddTypedTextChunk("noexcept");
2075  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2076  Builder.AddPlaceholderChunk("expression");
2077  Builder.AddChunk(CodeCompletionString::CK_RightParen);
2078  Results.AddResult(Result(Builder.TakeString()));
2079 
2080  // sizeof... expression
2081  Builder.AddResultTypeChunk("size_t");
2082  Builder.AddTypedTextChunk("sizeof...");
2083  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2084  Builder.AddPlaceholderChunk("parameter-pack");
2085  Builder.AddChunk(CodeCompletionString::CK_RightParen);
2086  Results.AddResult(Result(Builder.TakeString()));
2087  }
2088  }
2089 
2090  if (SemaRef.getLangOpts().ObjC1) {
2091  // Add "super", if we're in an Objective-C class with a superclass.
2092  if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) {
2093  // The interface can be NULL.
2094  if (ObjCInterfaceDecl *ID = Method->getClassInterface())
2095  if (ID->getSuperClass()) {
2096  std::string SuperType;
2097  SuperType = ID->getSuperClass()->getNameAsString();
2098  if (Method->isInstanceMethod())
2099  SuperType += " *";
2100 
2101  Builder.AddResultTypeChunk(Allocator.CopyString(SuperType));
2102  Builder.AddTypedTextChunk("super");
2103  Results.AddResult(Result(Builder.TakeString()));
2104  }
2105  }
2106 
2107  AddObjCExpressionResults(Results, true);
2108  }
2109 
2110  if (SemaRef.getLangOpts().C11) {
2111  // _Alignof
2112  Builder.AddResultTypeChunk("size_t");
2113  if (SemaRef.PP.isMacroDefined("alignof"))
2114  Builder.AddTypedTextChunk("alignof");
2115  else
2116  Builder.AddTypedTextChunk("_Alignof");
2117  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2118  Builder.AddPlaceholderChunk("type");
2119  Builder.AddChunk(CodeCompletionString::CK_RightParen);
2120  Results.AddResult(Result(Builder.TakeString()));
2121  }
2122 
2123  // sizeof expression
2124  Builder.AddResultTypeChunk("size_t");
2125  Builder.AddTypedTextChunk("sizeof");
2126  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
2127  Builder.AddPlaceholderChunk("expression-or-type");
2128  Builder.AddChunk(CodeCompletionString::CK_RightParen);
2129  Results.AddResult(Result(Builder.TakeString()));
2130  break;
2131  }
2132 
2133  case Sema::PCC_Type:
2135  break;
2136  }
2137 
2138  if (WantTypesInContext(CCC, SemaRef.getLangOpts()))
2139  AddTypeSpecifierResults(SemaRef.getLangOpts(), Results);
2140 
2141  if (SemaRef.getLangOpts().CPlusPlus && CCC != Sema::PCC_Type)
2142  Results.AddResult(Result("operator"));
2143 }
2144 
2145 /// If the given declaration has an associated type, add it as a result
2146 /// type chunk.
2147 static void AddResultTypeChunk(ASTContext &Context,
2148  const PrintingPolicy &Policy,
2149  const NamedDecl *ND,
2150  QualType BaseType,
2151  CodeCompletionBuilder &Result) {
2152  if (!ND)
2153  return;
2154 
2155  // Skip constructors and conversion functions, which have their return types
2156  // built into their names.
2157  if (isConstructor(ND) || isa<CXXConversionDecl>(ND))
2158  return;
2159 
2160  // Determine the type of the declaration (if it has a type).
2161  QualType T;
2162  if (const FunctionDecl *Function = ND->getAsFunction())
2163  T = Function->getReturnType();
2164  else if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2165  if (!BaseType.isNull())
2166  T = Method->getSendResultType(BaseType);
2167  else
2168  T = Method->getReturnType();
2169  } else if (const EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND)) {
2170  T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext()));
2172  } else if (isa<UnresolvedUsingValueDecl>(ND)) {
2173  /* Do nothing: ignore unresolved using declarations*/
2174  } else if (const ObjCIvarDecl *Ivar = dyn_cast<ObjCIvarDecl>(ND)) {
2175  if (!BaseType.isNull())
2176  T = Ivar->getUsageType(BaseType);
2177  else
2178  T = Ivar->getType();
2179  } else if (const ValueDecl *Value = dyn_cast<ValueDecl>(ND)) {
2180  T = Value->getType();
2181  } else if (const ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND)) {
2182  if (!BaseType.isNull())
2183  T = Property->getUsageType(BaseType);
2184  else
2185  T = Property->getType();
2186  }
2187 
2188  if (T.isNull() || Context.hasSameType(T, Context.DependentTy))
2189  return;
2190 
2191  Result.AddResultTypeChunk(GetCompletionTypeString(T, Context, Policy,
2192  Result.getAllocator()));
2193 }
2194 
2196  const NamedDecl *FunctionOrMethod,
2197  CodeCompletionBuilder &Result) {
2198  if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>())
2199  if (Sentinel->getSentinel() == 0) {
2200  if (PP.getLangOpts().ObjC1 && PP.isMacroDefined("nil"))
2201  Result.AddTextChunk(", nil");
2202  else if (PP.isMacroDefined("NULL"))
2203  Result.AddTextChunk(", NULL");
2204  else
2205  Result.AddTextChunk(", (void*)0");
2206  }
2207 }
2208 
2209 static std::string formatObjCParamQualifiers(unsigned ObjCQuals,
2210  QualType &Type) {
2211  std::string Result;
2212  if (ObjCQuals & Decl::OBJC_TQ_In)
2213  Result += "in ";
2214  else if (ObjCQuals & Decl::OBJC_TQ_Inout)
2215  Result += "inout ";
2216  else if (ObjCQuals & Decl::OBJC_TQ_Out)
2217  Result += "out ";
2218  if (ObjCQuals & Decl::OBJC_TQ_Bycopy)
2219  Result += "bycopy ";
2220  else if (ObjCQuals & Decl::OBJC_TQ_Byref)
2221  Result += "byref ";
2222  if (ObjCQuals & Decl::OBJC_TQ_Oneway)
2223  Result += "oneway ";
2224  if (ObjCQuals & Decl::OBJC_TQ_CSNullability) {
2225  if (auto nullability = AttributedType::stripOuterNullability(Type)) {
2226  switch (*nullability) {
2228  Result += "nonnull ";
2229  break;
2230 
2232  Result += "nullable ";
2233  break;
2234 
2236  Result += "null_unspecified ";
2237  break;
2238  }
2239  }
2240  }
2241  return Result;
2242 }
2243 
2244 /// Tries to find the most appropriate type location for an Objective-C
2245 /// block placeholder.
2246 ///
2247 /// This function ignores things like typedefs and qualifiers in order to
2248 /// present the most relevant and accurate block placeholders in code completion
2249 /// results.
2251  FunctionTypeLoc &Block,
2252  FunctionProtoTypeLoc &BlockProto,
2253  bool SuppressBlock = false) {
2254  if (!TSInfo)
2255  return;
2256  TypeLoc TL = TSInfo->getTypeLoc().getUnqualifiedLoc();
2257  while (true) {
2258  // Look through typedefs.
2259  if (!SuppressBlock) {
2260  if (TypedefTypeLoc TypedefTL = TL.getAs<TypedefTypeLoc>()) {
2261  if (TypeSourceInfo *InnerTSInfo =
2262  TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) {
2263  TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc();
2264  continue;
2265  }
2266  }
2267 
2268  // Look through qualified types
2269  if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>()) {
2270  TL = QualifiedTL.getUnqualifiedLoc();
2271  continue;
2272  }
2273 
2274  if (AttributedTypeLoc AttrTL = TL.getAs<AttributedTypeLoc>()) {
2275  TL = AttrTL.getModifiedLoc();
2276  continue;
2277  }
2278  }
2279 
2280  // Try to get the function prototype behind the block pointer type,
2281  // then we're done.
2282  if (BlockPointerTypeLoc BlockPtr = TL.getAs<BlockPointerTypeLoc>()) {
2283  TL = BlockPtr.getPointeeLoc().IgnoreParens();
2284  Block = TL.getAs<FunctionTypeLoc>();
2285  BlockProto = TL.getAs<FunctionProtoTypeLoc>();
2286  }
2287  break;
2288  }
2289 }
2290 
2291 static std::string
2293  FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
2294  bool SuppressBlockName = false,
2295  bool SuppressBlock = false,
2296  Optional<ArrayRef<QualType>> ObjCSubsts = None);
2297 
2298 static std::string FormatFunctionParameter(const PrintingPolicy &Policy,
2299  const ParmVarDecl *Param,
2300  bool SuppressName = false,
2301  bool SuppressBlock = false,
2302  Optional<ArrayRef<QualType>> ObjCSubsts = None) {
2303  bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext());
2304  if (Param->getType()->isDependentType() ||
2305  !Param->getType()->isBlockPointerType()) {
2306  // The argument for a dependent or non-block parameter is a placeholder
2307  // containing that parameter's type.
2308  std::string Result;
2309 
2310  if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName)
2311  Result = Param->getIdentifier()->getName();
2312 
2313  QualType Type = Param->getType();
2314  if (ObjCSubsts)
2315  Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts,
2317  if (ObjCMethodParam) {
2318  Result = "(" + formatObjCParamQualifiers(Param->getObjCDeclQualifier(),
2319  Type);
2320  Result += Type.getAsString(Policy) + ")";
2321  if (Param->getIdentifier() && !SuppressName)
2322  Result += Param->getIdentifier()->getName();
2323  } else {
2324  Type.getAsStringInternal(Result, Policy);
2325  }
2326  return Result;
2327  }
2328 
2329  // The argument for a block pointer parameter is a block literal with
2330  // the appropriate type.
2331  FunctionTypeLoc Block;
2332  FunctionProtoTypeLoc BlockProto;
2333  findTypeLocationForBlockDecl(Param->getTypeSourceInfo(), Block, BlockProto,
2334  SuppressBlock);
2335  // Try to retrieve the block type information from the property if this is a
2336  // parameter in a setter.
2337  if (!Block && ObjCMethodParam &&
2338  cast<ObjCMethodDecl>(Param->getDeclContext())->isPropertyAccessor()) {
2339  if (const auto *PD = cast<ObjCMethodDecl>(Param->getDeclContext())
2340  ->findPropertyDecl(/*CheckOverrides=*/false))
2341  findTypeLocationForBlockDecl(PD->getTypeSourceInfo(), Block, BlockProto,
2342  SuppressBlock);
2343  }
2344 
2345  if (!Block) {
2346  // We were unable to find a FunctionProtoTypeLoc with parameter names
2347  // for the block; just use the parameter type as a placeholder.
2348  std::string Result;
2349  if (!ObjCMethodParam && Param->getIdentifier())
2350  Result = Param->getIdentifier()->getName();
2351 
2352  QualType Type = Param->getType().getUnqualifiedType();
2353 
2354  if (ObjCMethodParam) {
2355  Result = Type.getAsString(Policy);
2356  std::string Quals =
2358  if (!Quals.empty())
2359  Result = "(" + Quals + " " + Result + ")";
2360  if (Result.back() != ')')
2361  Result += " ";
2362  if (Param->getIdentifier())
2363  Result += Param->getIdentifier()->getName();
2364  } else {
2365  Type.getAsStringInternal(Result, Policy);
2366  }
2367 
2368  return Result;
2369  }
2370 
2371  // We have the function prototype behind the block pointer type, as it was
2372  // written in the source.
2373  return formatBlockPlaceholder(Policy, Param, Block, BlockProto,
2374  /*SuppressBlockName=*/false, SuppressBlock,
2375  ObjCSubsts);
2376 }
2377 
2378 /// Returns a placeholder string that corresponds to an Objective-C block
2379 /// declaration.
2380 ///
2381 /// \param BlockDecl A declaration with an Objective-C block type.
2382 ///
2383 /// \param Block The most relevant type location for that block type.
2384 ///
2385 /// \param SuppressBlockName Determines whether or not the name of the block
2386 /// declaration is included in the resulting string.
2387 static std::string
2388 formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,
2389  FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto,
2390  bool SuppressBlockName, bool SuppressBlock,
2391  Optional<ArrayRef<QualType>> ObjCSubsts) {
2392  std::string Result;
2393  QualType ResultType = Block.getTypePtr()->getReturnType();
2394  if (ObjCSubsts)
2395  ResultType =
2396  ResultType.substObjCTypeArgs(BlockDecl->getASTContext(), *ObjCSubsts,
2398  if (!ResultType->isVoidType() || SuppressBlock)
2399  ResultType.getAsStringInternal(Result, Policy);
2400 
2401  // Format the parameter list.
2402  std::string Params;
2403  if (!BlockProto || Block.getNumParams() == 0) {
2404  if (BlockProto && BlockProto.getTypePtr()->isVariadic())
2405  Params = "(...)";
2406  else
2407  Params = "(void)";
2408  } else {
2409  Params += "(";
2410  for (unsigned I = 0, N = Block.getNumParams(); I != N; ++I) {
2411  if (I)
2412  Params += ", ";
2413  Params += FormatFunctionParameter(Policy, Block.getParam(I),
2414  /*SuppressName=*/false,
2415  /*SuppressBlock=*/true, ObjCSubsts);
2416 
2417  if (I == N - 1 && BlockProto.getTypePtr()->isVariadic())
2418  Params += ", ...";
2419  }
2420  Params += ")";
2421  }
2422 
2423  if (SuppressBlock) {
2424  // Format as a parameter.
2425  Result = Result + " (^";
2426  if (!SuppressBlockName && BlockDecl->getIdentifier())
2427  Result += BlockDecl->getIdentifier()->getName();
2428  Result += ")";
2429  Result += Params;
2430  } else {
2431  // Format as a block literal argument.
2432  Result = '^' + Result;
2433  Result += Params;
2434 
2435  if (!SuppressBlockName && BlockDecl->getIdentifier())
2436  Result += BlockDecl->getIdentifier()->getName();
2437  }
2438 
2439  return Result;
2440 }
2441 
2442 static std::string GetDefaultValueString(const ParmVarDecl *Param,
2443  const SourceManager &SM,
2444  const LangOptions &LangOpts) {
2445  const SourceRange SrcRange = Param->getDefaultArgRange();
2446  CharSourceRange CharSrcRange = CharSourceRange::getTokenRange(SrcRange);
2447  bool Invalid = CharSrcRange.isInvalid();
2448  if (Invalid)
2449  return "";
2450  StringRef srcText = Lexer::getSourceText(CharSrcRange, SM, LangOpts, &Invalid);
2451  if (Invalid)
2452  return "";
2453 
2454  if (srcText.empty() || srcText == "=") {
2455  // Lexer can't determine the value.
2456  // This happens if the code is incorrect (for example class is forward declared).
2457  return "";
2458  }
2459  std::string DefValue(srcText.str());
2460  // FIXME: remove this check if the Lexer::getSourceText value is fixed and
2461  // this value always has (or always does not have) '=' in front of it
2462  if (DefValue.at(0) != '=') {
2463  // If we don't have '=' in front of value.
2464  // Lexer returns built-in types values without '=' and user-defined types values with it.
2465  return " = " + DefValue;
2466  }
2467  return " " + DefValue;
2468 }
2469 
2470 /// Add function parameter chunks to the given code completion string.
2472  const PrintingPolicy &Policy,
2473  const FunctionDecl *Function,
2474  CodeCompletionBuilder &Result,
2475  unsigned Start = 0,
2476  bool InOptional = false) {
2477  bool FirstParameter = true;
2478 
2479  for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) {
2480  const ParmVarDecl *Param = Function->getParamDecl(P);
2481 
2482  if (Param->hasDefaultArg() && !InOptional) {
2483  // When we see an optional default argument, put that argument and
2484  // the remaining default arguments into a new, optional string.
2485  CodeCompletionBuilder Opt(Result.getAllocator(),
2486  Result.getCodeCompletionTUInfo());
2487  if (!FirstParameter)
2489  AddFunctionParameterChunks(PP, Policy, Function, Opt, P, true);
2490  Result.AddOptionalChunk(Opt.TakeString());
2491  break;
2492  }
2493 
2494  if (FirstParameter)
2495  FirstParameter = false;
2496  else
2498 
2499  InOptional = false;
2500 
2501  // Format the placeholder string.
2502  std::string PlaceholderStr = FormatFunctionParameter(Policy, Param);
2503  if (Param->hasDefaultArg())
2504  PlaceholderStr += GetDefaultValueString(Param, PP.getSourceManager(), PP.getLangOpts());
2505 
2506  if (Function->isVariadic() && P == N - 1)
2507  PlaceholderStr += ", ...";
2508 
2509  // Add the placeholder string.
2510  Result.AddPlaceholderChunk(
2511  Result.getAllocator().CopyString(PlaceholderStr));
2512  }
2513 
2514  if (const FunctionProtoType *Proto
2515  = Function->getType()->getAs<FunctionProtoType>())
2516  if (Proto->isVariadic()) {
2517  if (Proto->getNumParams() == 0)
2518  Result.AddPlaceholderChunk("...");
2519 
2520  MaybeAddSentinel(PP, Function, Result);
2521  }
2522 }
2523 
2524 /// Add template parameter chunks to the given code completion string.
2526  const PrintingPolicy &Policy,
2527  const TemplateDecl *Template,
2528  CodeCompletionBuilder &Result,
2529  unsigned MaxParameters = 0,
2530  unsigned Start = 0,
2531  bool InDefaultArg = false) {
2532  bool FirstParameter = true;
2533 
2534  // Prefer to take the template parameter names from the first declaration of
2535  // the template.
2536  Template = cast<TemplateDecl>(Template->getCanonicalDecl());
2537 
2538  TemplateParameterList *Params = Template->getTemplateParameters();
2539  TemplateParameterList::iterator PEnd = Params->end();
2540  if (MaxParameters)
2541  PEnd = Params->begin() + MaxParameters;
2542  for (TemplateParameterList::iterator P = Params->begin() + Start;
2543  P != PEnd; ++P) {
2544  bool HasDefaultArg = false;
2545  std::string PlaceholderStr;
2546  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) {
2547  if (TTP->wasDeclaredWithTypename())
2548  PlaceholderStr = "typename";
2549  else
2550  PlaceholderStr = "class";
2551 
2552  if (TTP->getIdentifier()) {
2553  PlaceholderStr += ' ';
2554  PlaceholderStr += TTP->getIdentifier()->getName();
2555  }
2556 
2557  HasDefaultArg = TTP->hasDefaultArgument();
2558  } else if (NonTypeTemplateParmDecl *NTTP
2559  = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
2560  if (NTTP->getIdentifier())
2561  PlaceholderStr = NTTP->getIdentifier()->getName();
2562  NTTP->getType().getAsStringInternal(PlaceholderStr, Policy);
2563  HasDefaultArg = NTTP->hasDefaultArgument();
2564  } else {
2565  assert(isa<TemplateTemplateParmDecl>(*P));
2566  TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
2567 
2568  // Since putting the template argument list into the placeholder would
2569  // be very, very long, we just use an abbreviation.
2570  PlaceholderStr = "template<...> class";
2571  if (TTP->getIdentifier()) {
2572  PlaceholderStr += ' ';
2573  PlaceholderStr += TTP->getIdentifier()->getName();
2574  }
2575 
2576  HasDefaultArg = TTP->hasDefaultArgument();
2577  }
2578 
2579  if (HasDefaultArg && !InDefaultArg) {
2580  // When we see an optional default argument, put that argument and
2581  // the remaining default arguments into a new, optional string.
2582  CodeCompletionBuilder Opt(Result.getAllocator(),
2583  Result.getCodeCompletionTUInfo());
2584  if (!FirstParameter)
2586  AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters,
2587  P - Params->begin(), true);
2588  Result.AddOptionalChunk(Opt.TakeString());
2589  break;
2590  }
2591 
2592  InDefaultArg = false;
2593 
2594  if (FirstParameter)
2595  FirstParameter = false;
2596  else
2598 
2599  // Add the placeholder string.
2600  Result.AddPlaceholderChunk(
2601  Result.getAllocator().CopyString(PlaceholderStr));
2602  }
2603 }
2604 
2605 /// Add a qualifier to the given code-completion string, if the
2606 /// provided nested-name-specifier is non-NULL.
2607 static void
2609  NestedNameSpecifier *Qualifier,
2610  bool QualifierIsInformative,
2611  ASTContext &Context,
2612  const PrintingPolicy &Policy) {
2613  if (!Qualifier)
2614  return;
2615 
2616  std::string PrintedNNS;
2617  {
2618  llvm::raw_string_ostream OS(PrintedNNS);
2619  Qualifier->print(OS, Policy);
2620  }
2621  if (QualifierIsInformative)
2622  Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS));
2623  else
2624  Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS));
2625 }
2626 
2627 static void
2629  const FunctionDecl *Function) {
2630  const FunctionProtoType *Proto
2631  = Function->getType()->getAs<FunctionProtoType>();
2632  if (!Proto || !Proto->getTypeQuals())
2633  return;
2634 
2635  // FIXME: Add ref-qualifier!
2636 
2637  // Handle single qualifiers without copying
2638  if (Proto->getTypeQuals() == Qualifiers::Const) {
2639  Result.AddInformativeChunk(" const");
2640  return;
2641  }
2642 
2643  if (Proto->getTypeQuals() == Qualifiers::Volatile) {
2644  Result.AddInformativeChunk(" volatile");
2645  return;
2646  }
2647 
2648  if (Proto->getTypeQuals() == Qualifiers::Restrict) {
2649  Result.AddInformativeChunk(" restrict");
2650  return;
2651  }
2652 
2653  // Handle multiple qualifiers.
2654  std::string QualsStr;
2655  if (Proto->isConst())
2656  QualsStr += " const";
2657  if (Proto->isVolatile())
2658  QualsStr += " volatile";
2659  if (Proto->isRestrict())
2660  QualsStr += " restrict";
2661  Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr));
2662 }
2663 
2664 /// Add the name of the given declaration
2665 static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy,
2666  const NamedDecl *ND,
2667  CodeCompletionBuilder &Result) {
2668  DeclarationName Name = ND->getDeclName();
2669  if (!Name)
2670  return;
2671 
2672  switch (Name.getNameKind()) {
2674  const char *OperatorName = nullptr;
2675  switch (Name.getCXXOverloadedOperator()) {
2676  case OO_None:
2677  case OO_Conditional:
2679  OperatorName = "operator";
2680  break;
2681 
2682 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
2683  case OO_##Name: OperatorName = "operator" Spelling; break;
2684 #define OVERLOADED_OPERATOR_MULTI(Name,Spelling,Unary,Binary,MemberOnly)
2685 #include "clang/Basic/OperatorKinds.def"
2686 
2687  case OO_New: OperatorName = "operator new"; break;
2688  case OO_Delete: OperatorName = "operator delete"; break;
2689  case OO_Array_New: OperatorName = "operator new[]"; break;
2690  case OO_Array_Delete: OperatorName = "operator delete[]"; break;
2691  case OO_Call: OperatorName = "operator()"; break;
2692  case OO_Subscript: OperatorName = "operator[]"; break;
2693  }
2694  Result.AddTypedTextChunk(OperatorName);
2695  break;
2696  }
2697 
2702  Result.AddTypedTextChunk(
2703  Result.getAllocator().CopyString(ND->getNameAsString()));
2704  break;
2705 
2711  break;
2712 
2714  CXXRecordDecl *Record = nullptr;
2715  QualType Ty = Name.getCXXNameType();
2716  if (const RecordType *RecordTy = Ty->getAs<RecordType>())
2717  Record = cast<CXXRecordDecl>(RecordTy->getDecl());
2718  else if (const InjectedClassNameType *InjectedTy
2719  = Ty->getAs<InjectedClassNameType>())
2720  Record = InjectedTy->getDecl();
2721  else {
2722  Result.AddTypedTextChunk(
2723  Result.getAllocator().CopyString(ND->getNameAsString()));
2724  break;
2725  }
2726 
2727  Result.AddTypedTextChunk(
2728  Result.getAllocator().CopyString(Record->getNameAsString()));
2729  if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) {
2731  AddTemplateParameterChunks(Context, Policy, Template, Result);
2733  }
2734  break;
2735  }
2736  }
2737 }
2738 
2740  const CodeCompletionContext &CCContext,
2741  CodeCompletionAllocator &Allocator,
2742  CodeCompletionTUInfo &CCTUInfo,
2743  bool IncludeBriefComments) {
2744  return CreateCodeCompletionString(S.Context, S.PP, CCContext, Allocator,
2745  CCTUInfo, IncludeBriefComments);
2746 }
2747 
2749  Preprocessor &PP, CodeCompletionAllocator &Allocator,
2750  CodeCompletionTUInfo &CCTUInfo) {
2751  assert(Kind == RK_Macro);
2752  CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
2753  const MacroInfo *MI = PP.getMacroInfo(Macro);
2754  Result.AddTypedTextChunk(Result.getAllocator().CopyString(Macro->getName()));
2755 
2756  if (!MI || !MI->isFunctionLike())
2757  return Result.TakeString();
2758 
2759  // Format a function-like macro with placeholders for the arguments.
2761  MacroInfo::param_iterator A = MI->param_begin(), AEnd = MI->param_end();
2762 
2763  // C99 variadic macros add __VA_ARGS__ at the end. Skip it.
2764  if (MI->isC99Varargs()) {
2765  --AEnd;
2766 
2767  if (A == AEnd) {
2768  Result.AddPlaceholderChunk("...");
2769  }
2770  }
2771 
2772  for (MacroInfo::param_iterator A = MI->param_begin(); A != AEnd; ++A) {
2773  if (A != MI->param_begin())
2775 
2776  if (MI->isVariadic() && (A + 1) == AEnd) {
2777  SmallString<32> Arg = (*A)->getName();
2778  if (MI->isC99Varargs())
2779  Arg += ", ...";
2780  else
2781  Arg += "...";
2782  Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
2783  break;
2784  }
2785 
2786  // Non-variadic macros are simple.
2787  Result.AddPlaceholderChunk(
2788  Result.getAllocator().CopyString((*A)->getName()));
2789  }
2791  return Result.TakeString();
2792 }
2793 
2794 /// If possible, create a new code completion string for the given
2795 /// result.
2796 ///
2797 /// \returns Either a new, heap-allocated code completion string describing
2798 /// how to use this result, or NULL to indicate that the string or name of the
2799 /// result is all that is needed.
2802  Preprocessor &PP,
2803  const CodeCompletionContext &CCContext,
2804  CodeCompletionAllocator &Allocator,
2805  CodeCompletionTUInfo &CCTUInfo,
2806  bool IncludeBriefComments) {
2807  if (Kind == RK_Macro)
2808  return CreateCodeCompletionStringForMacro(PP, Allocator, CCTUInfo);
2809 
2810  CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
2811 
2812  PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
2813  if (Kind == RK_Pattern) {
2814  Pattern->Priority = Priority;
2815  Pattern->Availability = Availability;
2816 
2817  if (Declaration) {
2818  Result.addParentContext(Declaration->getDeclContext());
2819  Pattern->ParentName = Result.getParentName();
2820  if (const RawComment *RC =
2821  getPatternCompletionComment(Ctx, Declaration)) {
2822  Result.addBriefComment(RC->getBriefText(Ctx));
2823  Pattern->BriefComment = Result.getBriefComment();
2824  }
2825  }
2826 
2827  return Pattern;
2828  }
2829 
2830  if (Kind == RK_Keyword) {
2831  Result.AddTypedTextChunk(Keyword);
2832  return Result.TakeString();
2833  }
2834  assert(Kind == RK_Declaration && "Missed a result kind?");
2835  const NamedDecl *ND = Declaration;
2836  Result.addParentContext(ND->getDeclContext());
2837 
2838  if (IncludeBriefComments) {
2839  // Add documentation comment, if it exists.
2840  if (const RawComment *RC = getCompletionComment(Ctx, Declaration)) {
2841  Result.addBriefComment(RC->getBriefText(Ctx));
2842  }
2843  }
2844 
2845  if (StartsNestedNameSpecifier) {
2846  Result.AddTypedTextChunk(
2847  Result.getAllocator().CopyString(ND->getNameAsString()));
2848  Result.AddTextChunk("::");
2849  return Result.TakeString();
2850  }
2851 
2852  for (const auto *I : ND->specific_attrs<AnnotateAttr>())
2853  Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation()));
2854 
2855  AddResultTypeChunk(Ctx, Policy, ND, CCContext.getBaseType(), Result);
2856 
2857  if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) {
2858  AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2859  Ctx, Policy);
2860  AddTypedNameChunk(Ctx, Policy, ND, Result);
2862  AddFunctionParameterChunks(PP, Policy, Function, Result);
2864  AddFunctionTypeQualsToCompletionString(Result, Function);
2865  return Result.TakeString();
2866  }
2867 
2868  if (const FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) {
2869  AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2870  Ctx, Policy);
2871  FunctionDecl *Function = FunTmpl->getTemplatedDecl();
2872  AddTypedNameChunk(Ctx, Policy, Function, Result);
2873 
2874  // Figure out which template parameters are deduced (or have default
2875  // arguments).
2876  llvm::SmallBitVector Deduced;
2877  Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced);
2878  unsigned LastDeducibleArgument;
2879  for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0;
2880  --LastDeducibleArgument) {
2881  if (!Deduced[LastDeducibleArgument - 1]) {
2882  // C++0x: Figure out if the template argument has a default. If so,
2883  // the user doesn't need to type this argument.
2884  // FIXME: We need to abstract template parameters better!
2885  bool HasDefaultArg = false;
2886  NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam(
2887  LastDeducibleArgument - 1);
2888  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
2889  HasDefaultArg = TTP->hasDefaultArgument();
2890  else if (NonTypeTemplateParmDecl *NTTP
2891  = dyn_cast<NonTypeTemplateParmDecl>(Param))
2892  HasDefaultArg = NTTP->hasDefaultArgument();
2893  else {
2894  assert(isa<TemplateTemplateParmDecl>(Param));
2895  HasDefaultArg
2896  = cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument();
2897  }
2898 
2899  if (!HasDefaultArg)
2900  break;
2901  }
2902  }
2903 
2904  if (LastDeducibleArgument) {
2905  // Some of the function template arguments cannot be deduced from a
2906  // function call, so we introduce an explicit template argument list
2907  // containing all of the arguments up to the first deducible argument.
2909  AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result,
2910  LastDeducibleArgument);
2912  }
2913 
2914  // Add the function parameters
2916  AddFunctionParameterChunks(PP, Policy, Function, Result);
2918  AddFunctionTypeQualsToCompletionString(Result, Function);
2919  return Result.TakeString();
2920  }
2921 
2922  if (const TemplateDecl *Template = dyn_cast<TemplateDecl>(ND)) {
2923  AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
2924  Ctx, Policy);
2925  Result.AddTypedTextChunk(
2926  Result.getAllocator().CopyString(Template->getNameAsString()));
2928  AddTemplateParameterChunks(Ctx, Policy, Template, Result);
2930  return Result.TakeString();
2931  }
2932 
2933  if (const ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) {
2934  Selector Sel = Method->getSelector();
2935  if (Sel.isUnarySelector()) {
2936  Result.AddTypedTextChunk(Result.getAllocator().CopyString(
2937  Sel.getNameForSlot(0)));
2938  return Result.TakeString();
2939  }
2940 
2941  std::string SelName = Sel.getNameForSlot(0).str();
2942  SelName += ':';
2943  if (StartParameter == 0)
2944  Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName));
2945  else {
2946  Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName));
2947 
2948  // If there is only one parameter, and we're past it, add an empty
2949  // typed-text chunk since there is nothing to type.
2950  if (Method->param_size() == 1)
2951  Result.AddTypedTextChunk("");
2952  }
2953  unsigned Idx = 0;
2954  for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(),
2955  PEnd = Method->param_end();
2956  P != PEnd; (void)++P, ++Idx) {
2957  if (Idx > 0) {
2958  std::string Keyword;
2959  if (Idx > StartParameter)
2961  if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx))
2962  Keyword += II->getName();
2963  Keyword += ":";
2964  if (Idx < StartParameter || AllParametersAreInformative)
2965  Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword));
2966  else
2967  Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword));
2968  }
2969 
2970  // If we're before the starting parameter, skip the placeholder.
2971  if (Idx < StartParameter)
2972  continue;
2973 
2974  std::string Arg;
2975  QualType ParamType = (*P)->getType();
2976  Optional<ArrayRef<QualType>> ObjCSubsts;
2977  if (!CCContext.getBaseType().isNull())
2978  ObjCSubsts = CCContext.getBaseType()->getObjCSubstitutions(Method);
2979 
2980  if (ParamType->isBlockPointerType() && !DeclaringEntity)
2981  Arg = FormatFunctionParameter(Policy, *P, true,
2982  /*SuppressBlock=*/false,
2983  ObjCSubsts);
2984  else {
2985  if (ObjCSubsts)
2986  ParamType = ParamType.substObjCTypeArgs(Ctx, *ObjCSubsts,
2988  Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier(),
2989  ParamType);
2990  Arg += ParamType.getAsString(Policy) + ")";
2991  if (IdentifierInfo *II = (*P)->getIdentifier())
2992  if (DeclaringEntity || AllParametersAreInformative)
2993  Arg += II->getName();
2994  }
2995 
2996  if (Method->isVariadic() && (P + 1) == PEnd)
2997  Arg += ", ...";
2998 
2999  if (DeclaringEntity)
3000  Result.AddTextChunk(Result.getAllocator().CopyString(Arg));
3001  else if (AllParametersAreInformative)
3002  Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg));
3003  else
3004  Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg));
3005  }
3006 
3007  if (Method->isVariadic()) {
3008  if (Method->param_size() == 0) {
3009  if (DeclaringEntity)
3010  Result.AddTextChunk(", ...");
3011  else if (AllParametersAreInformative)
3012  Result.AddInformativeChunk(", ...");
3013  else
3014  Result.AddPlaceholderChunk(", ...");
3015  }
3016 
3017  MaybeAddSentinel(PP, Method, Result);
3018  }
3019 
3020  return Result.TakeString();
3021  }
3022 
3023  if (Qualifier)
3024  AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative,
3025  Ctx, Policy);
3026 
3027  Result.AddTypedTextChunk(
3028  Result.getAllocator().CopyString(ND->getNameAsString()));
3029  return Result.TakeString();
3030 }
3031 
3033  const NamedDecl *ND) {
3034  if (!ND)
3035  return nullptr;
3036  if (auto *RC = Ctx.getRawCommentForAnyRedecl(ND))
3037  return RC;
3038 
3039  // Try to find comment from a property for ObjC methods.
3040  const ObjCMethodDecl *M = dyn_cast<ObjCMethodDecl>(ND);
3041  if (!M)
3042  return nullptr;
3043  const ObjCPropertyDecl *PDecl = M->findPropertyDecl();
3044  if (!PDecl)
3045  return nullptr;
3046 
3047  return Ctx.getRawCommentForAnyRedecl(PDecl);
3048 }
3049 
3051  const NamedDecl *ND) {
3052  const ObjCMethodDecl *M = dyn_cast_or_null<ObjCMethodDecl>(ND);
3053  if (!M || !M->isPropertyAccessor())
3054  return nullptr;
3055 
3056  // Provide code completion comment for self.GetterName where
3057  // GetterName is the getter method for a property with name
3058  // different from the property name (declared via a property
3059  // getter attribute.
3060  const ObjCPropertyDecl *PDecl = M->findPropertyDecl();
3061  if (!PDecl)
3062  return nullptr;
3063  if (PDecl->getGetterName() == M->getSelector() &&
3064  PDecl->getIdentifier() != M->getIdentifier()) {
3065  if (auto *RC = Ctx.getRawCommentForAnyRedecl(M))
3066  return RC;
3067  if (auto *RC = Ctx.getRawCommentForAnyRedecl(PDecl))
3068  return RC;
3069  }
3070  return nullptr;
3071 }
3072 
3074  const ASTContext &Ctx,
3076  unsigned ArgIndex) {
3077  auto FDecl = Result.getFunction();
3078  if (!FDecl)
3079  return nullptr;
3080  if (ArgIndex < FDecl->getNumParams())
3081  return Ctx.getRawCommentForAnyRedecl(FDecl->getParamDecl(ArgIndex));
3082  return nullptr;
3083 }
3084 
3085 /// Add function overload parameter chunks to the given code completion
3086 /// string.
3088  const PrintingPolicy &Policy,
3089  const FunctionDecl *Function,
3090  const FunctionProtoType *Prototype,
3091  CodeCompletionBuilder &Result,
3092  unsigned CurrentArg,
3093  unsigned Start = 0,
3094  bool InOptional = false) {
3095  bool FirstParameter = true;
3096  unsigned NumParams = Function ? Function->getNumParams()
3097  : Prototype->getNumParams();
3098 
3099  for (unsigned P = Start; P != NumParams; ++P) {
3100  if (Function && Function->getParamDecl(P)->hasDefaultArg() && !InOptional) {
3101  // When we see an optional default argument, put that argument and
3102  // the remaining default arguments into a new, optional string.
3103  CodeCompletionBuilder Opt(Result.getAllocator(),
3104  Result.getCodeCompletionTUInfo());
3105  if (!FirstParameter)
3107  // Optional sections are nested.
3108  AddOverloadParameterChunks(Context, Policy, Function, Prototype, Opt,
3109  CurrentArg, P, /*InOptional=*/true);
3110  Result.AddOptionalChunk(Opt.TakeString());
3111  return;
3112  }
3113 
3114  if (FirstParameter)
3115  FirstParameter = false;
3116  else
3118 
3119  InOptional = false;
3120 
3121  // Format the placeholder string.
3122  std::string Placeholder;
3123  if (Function) {
3124  const ParmVarDecl *Param = Function->getParamDecl(P);
3125  Placeholder = FormatFunctionParameter(Policy, Param);
3126  if (Param->hasDefaultArg())
3127  Placeholder += GetDefaultValueString(Param, Context.getSourceManager(), Context.getLangOpts());
3128  } else {
3129  Placeholder = Prototype->getParamType(P).getAsString(Policy);
3130  }
3131 
3132  if (P == CurrentArg)
3133  Result.AddCurrentParameterChunk(
3134  Result.getAllocator().CopyString(Placeholder));
3135  else
3136  Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Placeholder));
3137  }
3138 
3139  if (Prototype && Prototype->isVariadic()) {
3140  CodeCompletionBuilder Opt(Result.getAllocator(),
3141  Result.getCodeCompletionTUInfo());
3142  if (!FirstParameter)
3144 
3145  if (CurrentArg < NumParams)
3146  Opt.AddPlaceholderChunk("...");
3147  else
3148  Opt.AddCurrentParameterChunk("...");
3149 
3150  Result.AddOptionalChunk(Opt.TakeString());
3151  }
3152 }
3153 
3156  unsigned CurrentArg, Sema &S,
3157  CodeCompletionAllocator &Allocator,
3158  CodeCompletionTUInfo &CCTUInfo,
3159  bool IncludeBriefComments) const {
3161 
3162  // FIXME: Set priority, availability appropriately.
3163  CodeCompletionBuilder Result(Allocator,CCTUInfo, 1, CXAvailability_Available);
3164  FunctionDecl *FDecl = getFunction();
3165  const FunctionProtoType *Proto
3166  = dyn_cast<FunctionProtoType>(getFunctionType());
3167  if (!FDecl && !Proto) {
3168  // Function without a prototype. Just give the return type and a
3169  // highlighted ellipsis.
3170  const FunctionType *FT = getFunctionType();
3171  Result.AddResultTypeChunk(Result.getAllocator().CopyString(
3172  FT->getReturnType().getAsString(Policy)));
3176  return Result.TakeString();
3177  }
3178 
3179  if (FDecl) {
3180  if (IncludeBriefComments) {
3181  if (auto RC = getParameterComment(S.getASTContext(), *this, CurrentArg))
3182  Result.addBriefComment(RC->getBriefText(S.getASTContext()));
3183  }
3184  AddResultTypeChunk(S.Context, Policy, FDecl, QualType(), Result);
3185  Result.AddTextChunk(
3186  Result.getAllocator().CopyString(FDecl->getNameAsString()));
3187  } else {
3188  Result.AddResultTypeChunk(
3189  Result.getAllocator().CopyString(
3190  Proto->getReturnType().getAsString(Policy)));
3191  }
3192 
3194  AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result,
3195  CurrentArg);
3196  Result.AddChunk(CodeCompletionString::CK_RightParen);
3197 
3198  return Result.TakeString();
3199 }
3200 
3201 unsigned clang::getMacroUsagePriority(StringRef MacroName,
3202  const LangOptions &LangOpts,
3203  bool PreferredTypeIsPointer) {
3204  unsigned Priority = CCP_Macro;
3205 
3206  // Treat the "nil", "Nil" and "NULL" macros as null pointer constants.
3207  if (MacroName.equals("nil") || MacroName.equals("NULL") ||
3208  MacroName.equals("Nil")) {
3209  Priority = CCP_Constant;
3210  if (PreferredTypeIsPointer)
3211  Priority = Priority / CCF_SimilarTypeMatch;
3212  }
3213  // Treat "YES", "NO", "true", and "false" as constants.
3214  else if (MacroName.equals("YES") || MacroName.equals("NO") ||
3215  MacroName.equals("true") || MacroName.equals("false"))
3216  Priority = CCP_Constant;
3217  // Treat "bool" as a type.
3218  else if (MacroName.equals("bool"))
3219  Priority = CCP_Type + (LangOpts.ObjC1? CCD_bool_in_ObjC : 0);
3220 
3221 
3222  return Priority;
3223 }
3224 
3226  if (!D)
3227  return CXCursor_UnexposedDecl;
3228 
3229  switch (D->getKind()) {
3230  case Decl::Enum: return CXCursor_EnumDecl;
3231  case Decl::EnumConstant: return CXCursor_EnumConstantDecl;
3232  case Decl::Field: return CXCursor_FieldDecl;
3233  case Decl::Function:
3234  return CXCursor_FunctionDecl;
3235  case Decl::ObjCCategory: return CXCursor_ObjCCategoryDecl;
3236  case Decl::ObjCCategoryImpl: return CXCursor_ObjCCategoryImplDecl;
3237  case Decl::ObjCImplementation: return CXCursor_ObjCImplementationDecl;
3238 
3239  case Decl::ObjCInterface: return CXCursor_ObjCInterfaceDecl;
3240  case Decl::ObjCIvar: return CXCursor_ObjCIvarDecl;
3241  case Decl::ObjCMethod:
3242  return cast<ObjCMethodDecl>(D)->isInstanceMethod()
3244  case Decl::CXXMethod: return CXCursor_CXXMethod;
3245  case Decl::CXXConstructor: return CXCursor_Constructor;
3246  case Decl::CXXDestructor: return CXCursor_Destructor;
3247  case Decl::CXXConversion: return CXCursor_ConversionFunction;
3248  case Decl::ObjCProperty: return CXCursor_ObjCPropertyDecl;
3249  case Decl::ObjCProtocol: return CXCursor_ObjCProtocolDecl;
3250  case Decl::ParmVar: return CXCursor_ParmDecl;
3251  case Decl::Typedef: return CXCursor_TypedefDecl;
3252  case Decl::TypeAlias: return CXCursor_TypeAliasDecl;
3253  case Decl::TypeAliasTemplate: return CXCursor_TypeAliasTemplateDecl;
3254  case Decl::Var: return CXCursor_VarDecl;
3255  case Decl::Namespace: return CXCursor_Namespace;
3256  case Decl::NamespaceAlias: return CXCursor_NamespaceAlias;
3257  case Decl::TemplateTypeParm: return CXCursor_TemplateTypeParameter;
3258  case Decl::NonTypeTemplateParm:return CXCursor_NonTypeTemplateParameter;
3259  case Decl::TemplateTemplateParm:return CXCursor_TemplateTemplateParameter;
3260  case Decl::FunctionTemplate: return CXCursor_FunctionTemplate;
3261  case Decl::ClassTemplate: return CXCursor_ClassTemplate;
3262  case Decl::AccessSpec: return CXCursor_CXXAccessSpecifier;
3263  case Decl::ClassTemplatePartialSpecialization:
3265  case Decl::UsingDirective: return CXCursor_UsingDirective;
3266  case Decl::StaticAssert: return CXCursor_StaticAssert;
3267  case Decl::Friend: return CXCursor_FriendDecl;
3268  case Decl::TranslationUnit: return CXCursor_TranslationUnit;
3269 
3270  case Decl::Using:
3271  case Decl::UnresolvedUsingValue:
3272  case Decl::UnresolvedUsingTypename:
3274 
3275  case Decl::ObjCPropertyImpl:
3276  switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) {
3278  return CXCursor_ObjCDynamicDecl;
3279 
3282  }
3283 
3284  case Decl::Import:
3286 
3287  case Decl::ObjCTypeParam: return CXCursor_TemplateTypeParameter;
3288 
3289  default:
3290  if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
3291  switch (TD->getTagKind()) {
3292  case TTK_Interface: // fall through
3293  case TTK_Struct: return CXCursor_StructDecl;
3294  case TTK_Class: return CXCursor_ClassDecl;
3295  case TTK_Union: return CXCursor_UnionDecl;
3296  case TTK_Enum: return CXCursor_EnumDecl;
3297  }
3298  }
3299  }
3300 
3301  return CXCursor_UnexposedDecl;
3302 }
3303 
3304 static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results,
3305  bool IncludeUndefined,
3306  bool TargetTypeIsPointer = false) {
3307  typedef CodeCompletionResult Result;
3308 
3309  Results.EnterNewScope();
3310 
3312  MEnd = PP.macro_end();
3313  M != MEnd; ++M) {
3314  auto MD = PP.getMacroDefinition(M->first);
3315  if (IncludeUndefined || MD) {
3316  if (MacroInfo *MI = MD.getMacroInfo())
3317  if (MI->isUsedForHeaderGuard())
3318  continue;
3319 
3320  Results.AddResult(Result(M->first,
3321  getMacroUsagePriority(M->first->getName(),
3322  PP.getLangOpts(),
3323  TargetTypeIsPointer)));
3324  }
3325  }
3326 
3327  Results.ExitScope();
3328 
3329 }
3330 
3331 static void AddPrettyFunctionResults(const LangOptions &LangOpts,
3332  ResultBuilder &Results) {
3333  typedef CodeCompletionResult Result;
3334 
3335  Results.EnterNewScope();
3336 
3337  Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant));
3338  Results.AddResult(Result("__FUNCTION__", CCP_Constant));
3339  if (LangOpts.C99 || LangOpts.CPlusPlus11)
3340  Results.AddResult(Result("__func__", CCP_Constant));
3341  Results.ExitScope();
3342 }
3343 
3345  CodeCompleteConsumer *CodeCompleter,
3346  CodeCompletionContext Context,
3347  CodeCompletionResult *Results,
3348  unsigned NumResults) {
3349  if (CodeCompleter)
3350  CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults);
3351 }
3352 
3355  switch (PCC) {
3356  case Sema::PCC_Namespace:
3358 
3359  case Sema::PCC_Class:
3361 
3364 
3367 
3370 
3371  case Sema::PCC_Template:
3373  if (S.CurContext->isFileContext())
3375  if (S.CurContext->isRecord())
3378 
3381 
3382  case Sema::PCC_ForInit:
3383  if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 ||
3384  S.getLangOpts().ObjC1)
3386  else
3388 
3389  case Sema::PCC_Expression:
3390  case Sema::PCC_Condition:
3392 
3393  case Sema::PCC_Statement:
3395 
3396  case Sema::PCC_Type:
3398 
3401 
3404  }
3405 
3406  llvm_unreachable("Invalid ParserCompletionContext!");
3407 }
3408 
3409 /// If we're in a C++ virtual member function, add completion results
3410 /// that invoke the functions we override, since it's common to invoke the
3411 /// overridden function as well as adding new functionality.
3412 ///
3413 /// \param S The semantic analysis object for which we are generating results.
3414 ///
3415 /// \param InContext This context in which the nested-name-specifier preceding
3416 /// the code-completion point
3417 static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext,
3418  ResultBuilder &Results) {
3419  // Look through blocks.
3420  DeclContext *CurContext = S.CurContext;
3421  while (isa<BlockDecl>(CurContext))
3422  CurContext = CurContext->getParent();
3423 
3424 
3425  CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext);
3426  if (!Method || !Method->isVirtual())
3427  return;
3428 
3429  // We need to have names for all of the parameters, if we're going to
3430  // generate a forwarding call.
3431  for (auto P : Method->parameters())
3432  if (!P->getDeclName())
3433  return;
3434 
3436  for (const CXXMethodDecl *Overridden : Method->overridden_methods()) {
3437  CodeCompletionBuilder Builder(Results.getAllocator(),
3438  Results.getCodeCompletionTUInfo());
3439  if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl())
3440  continue;
3441 
3442  // If we need a nested-name-specifier, add one now.
3443  if (!InContext) {
3444  NestedNameSpecifier *NNS
3445  = getRequiredQualification(S.Context, CurContext,
3446  Overridden->getDeclContext());
3447  if (NNS) {
3448  std::string Str;
3449  llvm::raw_string_ostream OS(Str);
3450  NNS->print(OS, Policy);
3451  Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str()));
3452  }
3453  } else if (!InContext->Equals(Overridden->getDeclContext()))
3454  continue;
3455 
3456  Builder.AddTypedTextChunk(Results.getAllocator().CopyString(
3457  Overridden->getNameAsString()));
3458  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
3459  bool FirstParam = true;
3460  for (auto P : Method->parameters()) {
3461  if (FirstParam)
3462  FirstParam = false;
3463  else
3464  Builder.AddChunk(CodeCompletionString::CK_Comma);
3465 
3466  Builder.AddPlaceholderChunk(
3467  Results.getAllocator().CopyString(P->getIdentifier()->getName()));
3468  }
3469  Builder.AddChunk(CodeCompletionString::CK_RightParen);
3470  Results.AddResult(CodeCompletionResult(Builder.TakeString(),
3474  Overridden));
3475  Results.Ignore(Overridden);
3476  }
3477 }
3478 
3480  ModuleIdPath Path) {
3481  typedef CodeCompletionResult Result;
3482  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3483  CodeCompleter->getCodeCompletionTUInfo(),
3485  Results.EnterNewScope();
3486 
3487  CodeCompletionAllocator &Allocator = Results.getAllocator();
3488  CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo());
3489  typedef CodeCompletionResult Result;
3490  if (Path.empty()) {
3491  // Enumerate all top-level modules.
3492  SmallVector<Module *, 8> Modules;
3493  PP.getHeaderSearchInfo().collectAllModules(Modules);
3494  for (unsigned I = 0, N = Modules.size(); I != N; ++I) {
3495  Builder.AddTypedTextChunk(
3496  Builder.getAllocator().CopyString(Modules[I]->Name));
3497  Results.AddResult(Result(Builder.TakeString(),
3500  Modules[I]->isAvailable()
3503  }
3504  } else if (getLangOpts().Modules) {
3505  // Load the named module.
3506  Module *Mod = PP.getModuleLoader().loadModule(ImportLoc, Path,
3508  /*IsInclusionDirective=*/false);
3509  // Enumerate submodules.
3510  if (Mod) {
3511  for (Module::submodule_iterator Sub = Mod->submodule_begin(),
3512  SubEnd = Mod->submodule_end();
3513  Sub != SubEnd; ++Sub) {
3514 
3515  Builder.AddTypedTextChunk(
3516  Builder.getAllocator().CopyString((*Sub)->Name));
3517  Results.AddResult(Result(Builder.TakeString(),
3520  (*Sub)->isAvailable()
3523  }
3524  }
3525  }
3526  Results.ExitScope();
3527  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3528  Results.data(),Results.size());
3529 }
3530 
3532  ParserCompletionContext CompletionContext) {
3533  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3534  CodeCompleter->getCodeCompletionTUInfo(),
3535  mapCodeCompletionContext(*this, CompletionContext));
3536  Results.EnterNewScope();
3537 
3538  // Determine how to filter results, e.g., so that the names of
3539  // values (functions, enumerators, function templates, etc.) are
3540  // only allowed where we can have an expression.
3541  switch (CompletionContext) {
3542  case PCC_Namespace:
3543  case PCC_Class:
3544  case PCC_ObjCInterface:
3545  case PCC_ObjCImplementation:
3546  case PCC_ObjCInstanceVariableList:
3547  case PCC_Template:
3548  case PCC_MemberTemplate:
3549  case PCC_Type:
3550  case PCC_LocalDeclarationSpecifiers:
3551  Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName);
3552  break;
3553 
3554  case PCC_Statement:
3555  case PCC_ParenthesizedExpression:
3556  case PCC_Expression:
3557  case PCC_ForInit:
3558  case PCC_Condition:
3559  if (WantTypesInContext(CompletionContext, getLangOpts()))
3560  Results.setFilter(&ResultBuilder::IsOrdinaryName);
3561  else
3562  Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3563 
3564  if (getLangOpts().CPlusPlus)
3565  MaybeAddOverrideCalls(*this, /*InContext=*/nullptr, Results);
3566  break;
3567 
3568  case PCC_RecoveryInFunction:
3569  // Unfiltered
3570  break;
3571  }
3572 
3573  // If we are in a C++ non-static member function, check the qualifiers on
3574  // the member function to filter/prioritize the results list.
3575  if (CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext))
3576  if (CurMethod->isInstance())
3577  Results.setObjectTypeQualifiers(
3578  Qualifiers::fromCVRMask(CurMethod->getTypeQualifiers()));
3579 
3580  CodeCompletionDeclConsumer Consumer(Results, CurContext);
3581  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3582  CodeCompleter->includeGlobals(),
3583  CodeCompleter->loadExternal());
3584 
3585  AddOrdinaryNameResults(CompletionContext, S, *this, Results);
3586  Results.ExitScope();
3587 
3588  switch (CompletionContext) {
3589  case PCC_ParenthesizedExpression:
3590  case PCC_Expression:
3591  case PCC_Statement:
3592  case PCC_RecoveryInFunction:
3593  if (S->getFnParent())
3594  AddPrettyFunctionResults(getLangOpts(), Results);
3595  break;
3596 
3597  case PCC_Namespace:
3598  case PCC_Class:
3599  case PCC_ObjCInterface:
3600  case PCC_ObjCImplementation:
3601  case PCC_ObjCInstanceVariableList:
3602  case PCC_Template:
3603  case PCC_MemberTemplate:
3604  case PCC_ForInit:
3605  case PCC_Condition:
3606  case PCC_Type:
3607  case PCC_LocalDeclarationSpecifiers:
3608  break;
3609  }
3610 
3611  if (CodeCompleter->includeMacros())
3612  AddMacroResults(PP, Results, false);
3613 
3614  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3615  Results.data(),Results.size());
3616 }
3617 
3618 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S,
3619  ParsedType Receiver,
3620  ArrayRef<IdentifierInfo *> SelIdents,
3621  bool AtArgumentExpression,
3622  bool IsSuper,
3623  ResultBuilder &Results);
3624 
3626  bool AllowNonIdentifiers,
3627  bool AllowNestedNameSpecifiers) {
3628  typedef CodeCompletionResult Result;
3629  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
3630  CodeCompleter->getCodeCompletionTUInfo(),
3631  AllowNestedNameSpecifiers
3634  Results.EnterNewScope();
3635 
3636  // Type qualifiers can come after names.
3637  Results.AddResult(Result("const"));
3638  Results.AddResult(Result("volatile"));
3639  if (getLangOpts().C99)
3640  Results.AddResult(Result("restrict"));
3641 
3642  if (getLangOpts().CPlusPlus) {
3643  if (getLangOpts().CPlusPlus11 &&
3646  Results.AddResult("final");
3647 
3648  if (AllowNonIdentifiers) {
3649  Results.AddResult(Result("operator"));
3650  }
3651 
3652  // Add nested-name-specifiers.
3653  if (AllowNestedNameSpecifiers) {
3654  Results.allowNestedNameSpecifiers();
3655  Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy);
3656  CodeCompletionDeclConsumer Consumer(Results, CurContext);
3657  LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
3658  CodeCompleter->includeGlobals(),
3659  CodeCompleter->loadExternal());
3660  Results.setFilter(nullptr);
3661  }
3662  }
3663  Results.ExitScope();
3664 
3665  // If we're in a context where we might have an expression (rather than a
3666  // declaration), and what we've seen so far is an Objective-C type that could
3667  // be a receiver of a class message, this may be a class message send with
3668  // the initial opening bracket '[' missing. Add appropriate completions.
3669  if (AllowNonIdentifiers && !AllowNestedNameSpecifiers &&
3674  !DS.isTypeAltiVecVector() &&
3675  S &&
3676  (S->getFlags() & Scope::DeclScope) != 0 &&
3679  Scope::AtCatchScope)) == 0) {
3680  ParsedType T = DS.getRepAsType();
3681  if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType())
3682  AddClassMessageCompletions(*this, S, T, None, false, false, Results);
3683  }
3684 
3685  // Note that we intentionally suppress macro results here, since we do not
3686  // encourage using macros to produce the names of entities.
3687 
3688  HandleCodeCompleteResults(this, CodeCompleter,
3689  Results.getCompletionContext(),
3690  Results.data(), Results.size());
3691 }
3692 
3695  : PreferredType(PreferredType), IntegralConstantExpression(false),
3696  ObjCCollection(false) { }
3697 
3702 };
3703 
3704 /// Perform code-completion in an expression context when we know what
3705 /// type we're looking for.
3707  const CodeCompleteExpressionData &Data) {
3708  ResultBuilder Results(
3709  *this, CodeCompleter->getAllocator(),
3710  CodeCompleter->getCodeCompletionTUInfo(),
3712  Data.PreferredType));
3713  if (Data.ObjCCollection)
3714  Results.setFilter(&ResultBuilder::IsObjCCollection);
3715  else if (Data.IntegralConstantExpression)
3716  Results.setFilter(&ResultBuilder::IsIntegralConstantValue);
3717  else if (WantTypesInContext(PCC_Expression, getLangOpts()))
3718  Results.setFilter(&ResultBuilder::IsOrdinaryName);
3719  else
3720  Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName);
3721 
3722  if (!Data.PreferredType.isNull())
3723  Results.setPreferredType(Data.PreferredType.getNonReferenceType());
3724 
3725  // Ignore any declarations that we were told that we don't care about.
3726  for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I)
3727  Results.Ignore(Data.IgnoreDecls[I]);
3728 
3729  CodeCompletionDeclConsumer Consumer(Results, CurContext);
3730  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
3731  CodeCompleter->includeGlobals(),
3732  CodeCompleter->loadExternal());
3733 
3734  Results.EnterNewScope();
3735  AddOrdinaryNameResults(PCC_Expression, S, *this, Results);
3736  Results.ExitScope();
3737 
3738  bool PreferredTypeIsPointer = false;
3739  if (!Data.PreferredType.isNull())
3740  PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType()
3742  || Data.PreferredType->isBlockPointerType();
3743 
3744  if (S->getFnParent() &&
3745  !Data.ObjCCollection &&
3747  AddPrettyFunctionResults(getLangOpts(), Results);
3748 
3749  if (CodeCompleter->includeMacros())
3750  AddMacroResults(PP, Results, false, PreferredTypeIsPointer);
3751  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
3752  Results.data(), Results.size());
3753 }
3754 
3756  if (E.isInvalid())
3757  CodeCompleteOrdinaryName(S, PCC_RecoveryInFunction);
3758  else if (getLangOpts().ObjC1)
3759  CodeCompleteObjCInstanceMessage(S, E.get(), None, false);
3760 }
3761 
3762 /// The set of properties that have already been added, referenced by
3763 /// property name.
3764 typedef llvm::SmallPtrSet<IdentifierInfo*, 16> AddedPropertiesSet;
3765 
3766 /// Retrieve the container definition, if any?
3768  if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) {
3769  if (Interface->hasDefinition())
3770  return Interface->getDefinition();
3771 
3772  return Interface;
3773  }
3774 
3775  if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3776  if (Protocol->hasDefinition())
3777  return Protocol->getDefinition();
3778 
3779  return Protocol;
3780  }
3781  return Container;
3782 }
3783 
3784 /// Adds a block invocation code completion result for the given block
3785 /// declaration \p BD.
3786 static void AddObjCBlockCall(ASTContext &Context, const PrintingPolicy &Policy,
3787  CodeCompletionBuilder &Builder,
3788  const NamedDecl *BD,
3789  const FunctionTypeLoc &BlockLoc,
3790  const FunctionProtoTypeLoc &BlockProtoLoc) {
3791  Builder.AddResultTypeChunk(
3792  GetCompletionTypeString(BlockLoc.getReturnLoc().getType(), Context,
3793  Policy, Builder.getAllocator()));
3794 
3795  AddTypedNameChunk(Context, Policy, BD, Builder);
3797 
3798  if (BlockProtoLoc && BlockProtoLoc.getTypePtr()->isVariadic()) {
3799  Builder.AddPlaceholderChunk("...");
3800  } else {
3801  for (unsigned I = 0, N = BlockLoc.getNumParams(); I != N; ++I) {
3802  if (I)
3804 
3805  // Format the placeholder string.
3806  std::string PlaceholderStr =
3807  FormatFunctionParameter(Policy, BlockLoc.getParam(I));
3808 
3809  if (I == N - 1 && BlockProtoLoc &&
3810  BlockProtoLoc.getTypePtr()->isVariadic())
3811  PlaceholderStr += ", ...";
3812 
3813  // Add the placeholder string.
3814  Builder.AddPlaceholderChunk(
3815  Builder.getAllocator().CopyString(PlaceholderStr));
3816  }
3817  }
3818 
3820 }
3821 
3822 static void AddObjCProperties(
3823  const CodeCompletionContext &CCContext, ObjCContainerDecl *Container,
3824  bool AllowCategories, bool AllowNullaryMethods, DeclContext *CurContext,
3825  AddedPropertiesSet &AddedProperties, ResultBuilder &Results,
3826  bool IsBaseExprStatement = false, bool IsClassProperty = false) {
3827  typedef CodeCompletionResult Result;
3828 
3829  // Retrieve the definition.
3830  Container = getContainerDef(Container);
3831 
3832  // Add properties in this container.
3833  const auto AddProperty = [&](const ObjCPropertyDecl *P) {
3834  if (!AddedProperties.insert(P->getIdentifier()).second)
3835  return;
3836 
3837  // FIXME: Provide block invocation completion for non-statement
3838  // expressions.
3839  if (!P->getType().getTypePtr()->isBlockPointerType() ||
3840  !IsBaseExprStatement) {
3841  Results.MaybeAddResult(Result(P, Results.getBasePriority(P), nullptr),
3842  CurContext);
3843  return;
3844  }
3845 
3846  // Block setter and invocation completion is provided only when we are able
3847  // to find the FunctionProtoTypeLoc with parameter names for the block.
3848  FunctionTypeLoc BlockLoc;
3849  FunctionProtoTypeLoc BlockProtoLoc;
3850  findTypeLocationForBlockDecl(P->getTypeSourceInfo(), BlockLoc,
3851  BlockProtoLoc);
3852  if (!BlockLoc) {
3853  Results.MaybeAddResult(Result(P, Results.getBasePriority(P), nullptr),
3854  CurContext);
3855  return;
3856  }
3857 
3858  // The default completion result for block properties should be the block
3859  // invocation completion when the base expression is a statement.
3860  CodeCompletionBuilder Builder(Results.getAllocator(),
3861  Results.getCodeCompletionTUInfo());
3862  AddObjCBlockCall(Container->getASTContext(),
3863  getCompletionPrintingPolicy(Results.getSema()), Builder, P,
3864  BlockLoc, BlockProtoLoc);
3865  Results.MaybeAddResult(
3866  Result(Builder.TakeString(), P, Results.getBasePriority(P)),
3867  CurContext);
3868 
3869  // Provide additional block setter completion iff the base expression is a
3870  // statement and the block property is mutable.
3871  if (!P->isReadOnly()) {
3872  CodeCompletionBuilder Builder(Results.getAllocator(),
3873  Results.getCodeCompletionTUInfo());
3874  AddResultTypeChunk(Container->getASTContext(),
3875  getCompletionPrintingPolicy(Results.getSema()), P,
3876  CCContext.getBaseType(), Builder);
3877  Builder.AddTypedTextChunk(
3878  Results.getAllocator().CopyString(P->getName()));
3879  Builder.AddChunk(CodeCompletionString::CK_Equal);
3880 
3881  std::string PlaceholderStr = formatBlockPlaceholder(
3882  getCompletionPrintingPolicy(Results.getSema()), P, BlockLoc,
3883  BlockProtoLoc, /*SuppressBlockName=*/true);
3884  // Add the placeholder string.
3885  Builder.AddPlaceholderChunk(
3886  Builder.getAllocator().CopyString(PlaceholderStr));
3887 
3888  // When completing blocks properties that return void the default
3889  // property completion result should show up before the setter,
3890  // otherwise the setter completion should show up before the default
3891  // property completion, as we normally want to use the result of the
3892  // call.
3893  Results.MaybeAddResult(
3894  Result(Builder.TakeString(), P,
3895  Results.getBasePriority(P) +
3896  (BlockLoc.getTypePtr()->getReturnType()->isVoidType()
3899  CurContext);
3900  }
3901  };
3902 
3903  if (IsClassProperty) {
3904  for (const auto *P : Container->class_properties())
3905  AddProperty(P);
3906  } else {
3907  for (const auto *P : Container->instance_properties())
3908  AddProperty(P);
3909  }
3910 
3911  // Add nullary methods or implicit class properties
3912  if (AllowNullaryMethods) {
3913  ASTContext &Context = Container->getASTContext();
3914  PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema());
3915  // Adds a method result
3916  const auto AddMethod = [&](const ObjCMethodDecl *M) {
3917  IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0);
3918  if (!Name)
3919  return;
3920  if (!AddedProperties.insert(Name).second)
3921  return;
3922  CodeCompletionBuilder Builder(Results.getAllocator(),
3923  Results.getCodeCompletionTUInfo());
3924  AddResultTypeChunk(Context, Policy, M, CCContext.getBaseType(), Builder);
3925  Builder.AddTypedTextChunk(
3926  Results.getAllocator().CopyString(Name->getName()));
3927  Results.MaybeAddResult(
3928  Result(Builder.TakeString(), M,
3930  CurContext);
3931  };
3932 
3933  if (IsClassProperty) {
3934  for (const auto *M : Container->methods()) {
3935  // Gather the class method that can be used as implicit property
3936  // getters. Methods with arguments or methods that return void aren't
3937  // added to the results as they can't be used as a getter.
3938  if (!M->getSelector().isUnarySelector() ||
3939  M->getReturnType()->isVoidType() || M->isInstanceMethod())
3940  continue;
3941  AddMethod(M);
3942  }
3943  } else {
3944  for (auto *M : Container->methods()) {
3945  if (M->getSelector().isUnarySelector())
3946  AddMethod(M);
3947  }
3948  }
3949  }
3950 
3951  // Add properties in referenced protocols.
3952  if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
3953  for (auto *P : Protocol->protocols())
3954  AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3955  CurContext, AddedProperties, Results,
3956  IsBaseExprStatement, IsClassProperty);
3957  } else if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)){
3958  if (AllowCategories) {
3959  // Look through categories.
3960  for (auto *Cat : IFace->known_categories())
3961  AddObjCProperties(CCContext, Cat, AllowCategories, AllowNullaryMethods,
3962  CurContext, AddedProperties, Results,
3963  IsBaseExprStatement, IsClassProperty);
3964  }
3965 
3966  // Look through protocols.
3967  for (auto *I : IFace->all_referenced_protocols())
3968  AddObjCProperties(CCContext, I, AllowCategories, AllowNullaryMethods,
3969  CurContext, AddedProperties, Results,
3970  IsBaseExprStatement, IsClassProperty);
3971 
3972  // Look in the superclass.
3973  if (IFace->getSuperClass())
3974  AddObjCProperties(CCContext, IFace->getSuperClass(), AllowCategories,
3975  AllowNullaryMethods, CurContext, AddedProperties,
3976  Results, IsBaseExprStatement, IsClassProperty);
3977  } else if (const ObjCCategoryDecl *Category
3978  = dyn_cast<ObjCCategoryDecl>(Container)) {
3979  // Look through protocols.
3980  for (auto *P : Category->protocols())
3981  AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods,
3982  CurContext, AddedProperties, Results,
3983  IsBaseExprStatement, IsClassProperty);
3984  }
3985 }
3986 
3988  ResultBuilder &Results, Scope *S,
3989  QualType BaseType,
3990  RecordDecl *RD,
3991  Optional<FixItHint> AccessOpFixIt) {
3992  // Indicate that we are performing a member access, and the cv-qualifiers
3993  // for the base object type.
3994  Results.setObjectTypeQualifiers(BaseType.getQualifiers());
3995 
3996  // Access to a C/C++ class, struct, or union.
3997  Results.allowNestedNameSpecifiers();
3998  std::vector<FixItHint> FixIts;
3999  if (AccessOpFixIt)
4000  FixIts.emplace_back(AccessOpFixIt.getValue());
4001  CodeCompletionDeclConsumer Consumer(Results, SemaRef.CurContext, std::move(FixIts));
4002  SemaRef.LookupVisibleDecls(RD, Sema::LookupMemberName, Consumer,
4003  SemaRef.CodeCompleter->includeGlobals(),
4004  /*IncludeDependentBases=*/true,
4005  SemaRef.CodeCompleter->loadExternal());
4006 
4007  if (SemaRef.getLangOpts().CPlusPlus) {
4008  if (!Results.empty()) {
4009  // The "template" keyword can follow "->" or "." in the grammar.
4010  // However, we only want to suggest the template keyword if something
4011  // is dependent.
4012  bool IsDependent = BaseType->isDependentType();
4013  if (!IsDependent) {
4014  for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent())
4015  if (DeclContext *Ctx = DepScope->getEntity()) {
4016  IsDependent = Ctx->isDependentContext();
4017  break;
4018  }
4019  }
4020 
4021  if (IsDependent)
4022  Results.AddResult(CodeCompletionResult("template"));
4023  }
4024  }
4025 }
4026 
4028  Expr *OtherOpBase,
4029  SourceLocation OpLoc, bool IsArrow,
4030  bool IsBaseExprStatement) {
4031  if (!Base || !CodeCompleter)
4032  return;
4033 
4034  ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
4035  if (ConvertedBase.isInvalid())
4036  return;
4037  QualType ConvertedBaseType = ConvertedBase.get()->getType();
4038 
4039  enum CodeCompletionContext::Kind contextKind;
4040 
4041  if (IsArrow) {
4042  if (const PointerType *Ptr = ConvertedBaseType->getAs<PointerType>())
4043  ConvertedBaseType = Ptr->getPointeeType();
4044  }
4045 
4046  if (IsArrow) {
4048  } else {
4049  if (ConvertedBaseType->isObjCObjectPointerType() ||
4050  ConvertedBaseType->isObjCObjectOrInterfaceType()) {
4052  } else {
4054  }
4055  }
4056 
4057  CodeCompletionContext CCContext(contextKind, ConvertedBaseType);
4058  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4059  CodeCompleter->getCodeCompletionTUInfo(), CCContext,
4060  &ResultBuilder::IsMember);
4061 
4062  auto DoCompletion = [&](Expr *Base, bool IsArrow, Optional<FixItHint> AccessOpFixIt) -> bool {
4063  if (!Base)
4064  return false;
4065 
4066  ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow);
4067  if (ConvertedBase.isInvalid())
4068  return false;
4069  Base = ConvertedBase.get();
4070 
4071  QualType BaseType = Base->getType();
4072 
4073  if (IsArrow) {
4074  if (const PointerType *Ptr = BaseType->getAs<PointerType>())
4075  BaseType = Ptr->getPointeeType();
4076  else if (BaseType->isObjCObjectPointerType())
4077  /*Do nothing*/;
4078  else
4079  return false;
4080  }
4081 
4082  if (const RecordType *Record = BaseType->getAs<RecordType>()) {
4083  AddRecordMembersCompletionResults(*this, Results, S, BaseType,
4084  Record->getDecl(),
4085  std::move(AccessOpFixIt));
4086  } else if (const auto *TST =
4087  BaseType->getAs<TemplateSpecializationType>()) {
4088  TemplateName TN = TST->getTemplateName();
4089  if (const auto *TD =
4090  dyn_cast_or_null<ClassTemplateDecl>(TN.getAsTemplateDecl())) {
4091  CXXRecordDecl *RD = TD->getTemplatedDecl();
4092  AddRecordMembersCompletionResults(*this, Results, S, BaseType, RD,
4093  std::move(AccessOpFixIt));
4094  }
4095  } else if (const auto *ICNT = BaseType->getAs<InjectedClassNameType>()) {
4096  if (auto *RD = ICNT->getDecl())
4097  AddRecordMembersCompletionResults(*this, Results, S, BaseType, RD,
4098  std::move(AccessOpFixIt));
4099  } else if (!IsArrow && BaseType->isObjCObjectPointerType()) {
4100  // Objective-C property reference.
4101  AddedPropertiesSet AddedProperties;
4102 
4103  if (const ObjCObjectPointerType *ObjCPtr =
4104  BaseType->getAsObjCInterfacePointerType()) {
4105  // Add property results based on our interface.
4106  assert(ObjCPtr && "Non-NULL pointer guaranteed above!");
4107  AddObjCProperties(CCContext, ObjCPtr->getInterfaceDecl(), true,
4108  /*AllowNullaryMethods=*/true, CurContext,
4109  AddedProperties, Results, IsBaseExprStatement);
4110  }
4111 
4112  // Add properties from the protocols in a qualified interface.
4113  for (auto *I : BaseType->getAs<ObjCObjectPointerType>()->quals())
4114  AddObjCProperties(CCContext, I, true, /*AllowNullaryMethods=*/true,
4115  CurContext, AddedProperties, Results,
4116  IsBaseExprStatement);
4117  } else if ((IsArrow && BaseType->isObjCObjectPointerType()) ||
4118  (!IsArrow && BaseType->isObjCObjectType())) {
4119  // Objective-C instance variable access.
4120  ObjCInterfaceDecl *Class = nullptr;
4121  if (const ObjCObjectPointerType *ObjCPtr =
4122  BaseType->getAs<ObjCObjectPointerType>())
4123  Class = ObjCPtr->getInterfaceDecl();
4124  else
4125  Class = BaseType->getAs<ObjCObjectType>()->getInterface();
4126 
4127  // Add all ivars from this class and its superclasses.
4128  if (Class) {
4129  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4130  Results.setFilter(&ResultBuilder::IsObjCIvar);
4132  Class, LookupMemberName, Consumer, CodeCompleter->includeGlobals(),
4133  /*IncludeDependentBases=*/false, CodeCompleter->loadExternal());
4134  }
4135  }
4136 
4137  // FIXME: How do we cope with isa?
4138  return true;
4139  };
4140 
4141  Results.EnterNewScope();
4142 
4143  bool CompletionSucceded = DoCompletion(Base, IsArrow, None);
4144  if (CodeCompleter->includeFixIts()) {
4145  const CharSourceRange OpRange =
4146  CharSourceRange::getTokenRange(OpLoc, OpLoc);
4147  CompletionSucceded |= DoCompletion(
4148  OtherOpBase, !IsArrow,
4149  FixItHint::CreateReplacement(OpRange, IsArrow ? "." : "->"));
4150  }
4151 
4152  Results.ExitScope();
4153 
4154  if (!CompletionSucceded)
4155  return;
4156 
4157  // Hand off the results found for code completion.
4158  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4159  Results.data(), Results.size());
4160 }
4161 
4163  IdentifierInfo &ClassName,
4164  SourceLocation ClassNameLoc,
4165  bool IsBaseExprStatement) {
4166  IdentifierInfo *ClassNamePtr = &ClassName;
4167  ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(ClassNamePtr, ClassNameLoc);
4168  if (!IFace)
4169  return;
4170  CodeCompletionContext CCContext(
4172  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4173  CodeCompleter->getCodeCompletionTUInfo(), CCContext,
4174  &ResultBuilder::IsMember);
4175  Results.EnterNewScope();
4176  AddedPropertiesSet AddedProperties;
4177  AddObjCProperties(CCContext, IFace, true,
4178  /*AllowNullaryMethods=*/true, CurContext, AddedProperties,
4179  Results, IsBaseExprStatement,
4180  /*IsClassProperty=*/true);
4181  Results.ExitScope();
4182  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4183  Results.data(), Results.size());
4184 }
4185 
4186 void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) {
4187  if (!CodeCompleter)
4188  return;
4189 
4190  ResultBuilder::LookupFilter Filter = nullptr;
4193  switch ((DeclSpec::TST)TagSpec) {
4194  case DeclSpec::TST_enum:
4195  Filter = &ResultBuilder::IsEnum;
4196  ContextKind = CodeCompletionContext::CCC_EnumTag;
4197  break;
4198 
4199  case DeclSpec::TST_union:
4200  Filter = &ResultBuilder::IsUnion;
4202  break;
4203 
4204  case DeclSpec::TST_struct:
4205  case DeclSpec::TST_class:
4207  Filter = &ResultBuilder::IsClassOrStruct;
4209  break;
4210 
4211  default:
4212  llvm_unreachable("Unknown type specifier kind in CodeCompleteTag");
4213  }
4214 
4215  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4216  CodeCompleter->getCodeCompletionTUInfo(), ContextKind);
4217  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4218 
4219  // First pass: look for tags.
4220  Results.setFilter(Filter);
4221  LookupVisibleDecls(S, LookupTagName, Consumer,
4222  CodeCompleter->includeGlobals(),
4223  CodeCompleter->loadExternal());
4224 
4225  if (CodeCompleter->includeGlobals()) {
4226  // Second pass: look for nested name specifiers.
4227  Results.setFilter(&ResultBuilder::IsNestedNameSpecifier);
4228  LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer,
4229  CodeCompleter->includeGlobals(),
4230  CodeCompleter->loadExternal());
4231  }
4232 
4233  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4234  Results.data(),Results.size());
4235 }
4236 
4237 static void AddTypeQualifierResults(DeclSpec &DS, ResultBuilder &Results,
4238  const LangOptions &LangOpts) {
4239  if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const))
4240  Results.AddResult("const");
4242  Results.AddResult("volatile");
4243  if (LangOpts.C99 && !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict))
4244  Results.AddResult("restrict");
4245  if (LangOpts.C11 && !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic))
4246  Results.AddResult("_Atomic");
4247  if (LangOpts.MSVCCompat && !(DS.getTypeQualifiers() & DeclSpec::TQ_unaligned))
4248  Results.AddResult("__unaligned");
4249 }
4250 
4252  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4253  CodeCompleter->getCodeCompletionTUInfo(),
4255  Results.EnterNewScope();
4256  AddTypeQualifierResults(DS, Results, LangOpts);
4257  Results.ExitScope();
4258  HandleCodeCompleteResults(this, CodeCompleter,
4259  Results.getCompletionContext(),
4260  Results.data(), Results.size());
4261 }
4262 
4264  const VirtSpecifiers *VS) {
4265  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4266  CodeCompleter->getCodeCompletionTUInfo(),
4268  Results.EnterNewScope();
4269  AddTypeQualifierResults(DS, Results, LangOpts);
4270  if (LangOpts.CPlusPlus11) {
4271  Results.AddResult("noexcept");
4273  !D.isCtorOrDtor() && !D.isStaticMember()) {
4274  if (!VS || !VS->isFinalSpecified())
4275  Results.AddResult("final");
4276  if (!VS || !VS->isOverrideSpecified())
4277  Results.AddResult("override");
4278  }
4279  }
4280  Results.ExitScope();
4281  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4282  Results.data(), Results.size());
4283 }
4284 
4286  CodeCompleteExpression(S, QualType(getASTContext().getSizeType()));
4287 }
4288 
4290  if (getCurFunction()->SwitchStack.empty() || !CodeCompleter)
4291  return;
4292 
4293  SwitchStmt *Switch = getCurFunction()->SwitchStack.back().getPointer();
4294  QualType type = Switch->getCond()->IgnoreImplicit()->getType();
4295  if (!type->isEnumeralType()) {
4296  CodeCompleteExpressionData Data(type);
4297  Data.IntegralConstantExpression = true;
4298  CodeCompleteExpression(S, Data);
4299  return;
4300  }
4301 
4302  // Code-complete the cases of a switch statement over an enumeration type
4303  // by providing the list of
4304  EnumDecl *Enum = type->castAs<EnumType>()->getDecl();
4305  if (EnumDecl *Def = Enum->getDefinition())
4306  Enum = Def;
4307 
4308  // Determine which enumerators we have already seen in the switch statement.
4309  // FIXME: Ideally, we would also be able to look *past* the code-completion
4310  // token, in case we are code-completing in the middle of the switch and not
4311  // at the end. However, we aren't able to do so at the moment.
4312  llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen;
4313  NestedNameSpecifier *Qualifier = nullptr;
4314  for (SwitchCase *SC = Switch->getSwitchCaseList(); SC;
4315  SC = SC->getNextSwitchCase()) {
4316  CaseStmt *Case = dyn_cast<CaseStmt>(SC);
4317  if (!Case)
4318  continue;
4319 
4320  Expr *CaseVal = Case->getLHS()->IgnoreParenCasts();
4321  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal))
4322  if (EnumConstantDecl *Enumerator
4323  = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
4324  // We look into the AST of the case statement to determine which
4325  // enumerator was named. Alternatively, we could compute the value of
4326  // the integral constant expression, then compare it against the
4327  // values of each enumerator. However, value-based approach would not
4328  // work as well with C++ templates where enumerators declared within a
4329  // template are type- and value-dependent.
4330  EnumeratorsSeen.insert(Enumerator);
4331 
4332  // If this is a qualified-id, keep track of the nested-name-specifier
4333  // so that we can reproduce it as part of code completion, e.g.,
4334  //
4335  // switch (TagD.getKind()) {
4336  // case TagDecl::TK_enum:
4337  // break;
4338  // case XXX
4339  //
4340  // At the XXX, our completions are TagDecl::TK_union,
4341  // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union,
4342  // TK_struct, and TK_class.
4343  Qualifier = DRE->getQualifier();
4344  }
4345  }
4346 
4347  if (getLangOpts().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) {
4348  // If there are no prior enumerators in C++, check whether we have to
4349  // qualify the names of the enumerators that we suggest, because they
4350  // may not be visible in this scope.
4351  Qualifier = getRequiredQualification(Context, CurContext, Enum);
4352  }
4353 
4354  // Add any enumerators that have not yet been mentioned.
4355  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4356  CodeCompleter->getCodeCompletionTUInfo(),
4358  Results.EnterNewScope();
4359  for (auto *E : Enum->enumerators()) {
4360  if (EnumeratorsSeen.count(E))
4361  continue;
4362 
4363  CodeCompletionResult R(E, CCP_EnumInCase, Qualifier);
4364  Results.AddResult(R, CurContext, nullptr, false);
4365  }
4366  Results.ExitScope();
4367 
4368  if (CodeCompleter->includeMacros()) {
4369  AddMacroResults(PP, Results, false);
4370  }
4371  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4372  Results.data(), Results.size());
4373 }
4374 
4375 static bool anyNullArguments(ArrayRef<Expr *> Args) {
4376  if (Args.size() && !Args.data())
4377  return true;
4378 
4379  for (unsigned I = 0; I != Args.size(); ++I)
4380  if (!Args[I])
4381  return true;
4382 
4383  return false;
4384 }
4385 
4387 
4388 static void mergeCandidatesWithResults(Sema &SemaRef,
4390  OverloadCandidateSet &CandidateSet,
4391  SourceLocation Loc) {
4392  if (!CandidateSet.empty()) {
4393  // Sort the overload candidate set by placing the best overloads first.
4394  std::stable_sort(
4395  CandidateSet.begin(), CandidateSet.end(),
4396  [&](const OverloadCandidate &X, const OverloadCandidate &Y) {
4397  return isBetterOverloadCandidate(SemaRef, X, Y, Loc,
4398  CandidateSet.getKind());
4399  });
4400 
4401  // Add the remaining viable overload candidates as code-completion results.
4402  for (auto &Candidate : CandidateSet) {
4403  if (Candidate.Function && Candidate.Function->isDeleted())
4404  continue;
4405  if (Candidate.Viable)
4406  Results.push_back(ResultCandidate(Candidate.Function));
4407  }
4408  }
4409 }
4410 
4411 /// Get the type of the Nth parameter from a given set of overload
4412 /// candidates.
4413 static QualType getParamType(Sema &SemaRef,
4414  ArrayRef<ResultCandidate> Candidates,
4415  unsigned N) {
4416 
4417  // Given the overloads 'Candidates' for a function call matching all arguments
4418  // up to N, return the type of the Nth parameter if it is the same for all
4419  // overload candidates.
4420  QualType ParamType;
4421  for (auto &Candidate : Candidates) {
4422  if (auto FType = Candidate.getFunctionType())
4423  if (auto Proto = dyn_cast<FunctionProtoType>(FType))
4424  if (N < Proto->getNumParams()) {
4425  if (ParamType.isNull())
4426  ParamType = Proto->getParamType(N);
4427  else if (!SemaRef.Context.hasSameUnqualifiedType(
4428  ParamType.getNonReferenceType(),
4429  Proto->getParamType(N).getNonReferenceType()))
4430  // Otherwise return a default-constructed QualType.
4431  return QualType();
4432  }
4433  }
4434 
4435  return ParamType;
4436 }
4437 
4438 static void CodeCompleteOverloadResults(Sema &SemaRef, Scope *S,
4440  unsigned CurrentArg,
4441  bool CompleteExpressionWithCurrentArg = true) {
4442  QualType ParamType;
4443  if (CompleteExpressionWithCurrentArg)
4444  ParamType = getParamType(SemaRef, Candidates, CurrentArg);
4445 
4446  if (ParamType.isNull())
4448  else
4449  SemaRef.CodeCompleteExpression(S, ParamType);
4450 
4451  if (!Candidates.empty())
4452  SemaRef.CodeCompleter->ProcessOverloadCandidates(SemaRef, CurrentArg,
4453  Candidates.data(),
4454  Candidates.size());
4455 }
4456 
4458  if (!CodeCompleter)
4459  return;
4460 
4461  // When we're code-completing for a call, we fall back to ordinary
4462  // name code-completion whenever we can't produce specific
4463  // results. We may want to revisit this strategy in the future,
4464  // e.g., by merging the two kinds of results.
4465 
4466  // FIXME: Provide support for variadic template functions.
4467 
4468  // Ignore type-dependent call expressions entirely.
4469  if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args) ||
4471  CodeCompleteOrdinaryName(S, PCC_Expression);
4472  return;
4473  }
4474 
4475  // Build an overload candidate set based on the functions we find.
4476  SourceLocation Loc = Fn->getExprLoc();
4478 
4480 
4481  Expr *NakedFn = Fn->IgnoreParenCasts();
4482  if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn))
4483  AddOverloadedCallCandidates(ULE, Args, CandidateSet,
4484  /*PartialOverloading=*/true);
4485  else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) {
4486  TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
4487  if (UME->hasExplicitTemplateArgs()) {
4488  UME->copyTemplateArgumentsInto(TemplateArgsBuffer);
4489  TemplateArgs = &TemplateArgsBuffer;
4490  }
4491 
4492  // Add the base as first argument (use a nullptr if the base is implicit).
4493  SmallVector<Expr *, 12> ArgExprs(
4494  1, UME->isImplicitAccess() ? nullptr : UME->getBase());
4495  ArgExprs.append(Args.begin(), Args.end());
4496  UnresolvedSet<8> Decls;
4497  Decls.append(UME->decls_begin(), UME->decls_end());
4498  const bool FirstArgumentIsBase = !UME->isImplicitAccess() && UME->getBase();
4499  AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs,
4500  /*SuppressUsedConversions=*/false,
4501  /*PartialOverloading=*/true,
4502  FirstArgumentIsBase);
4503  } else {
4504  FunctionDecl *FD = nullptr;
4505  if (auto MCE = dyn_cast<MemberExpr>(NakedFn))
4506  FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl());
4507  else if (auto DRE = dyn_cast<DeclRefExpr>(NakedFn))
4508  FD = dyn_cast<FunctionDecl>(DRE->getDecl());
4509  if (FD) { // We check whether it's a resolved function declaration.
4510  if (!getLangOpts().CPlusPlus ||
4511  !FD->getType()->getAs<FunctionProtoType>())
4512  Results.push_back(ResultCandidate(FD));
4513  else
4514  AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()),
4515  Args, CandidateSet,
4516  /*SuppressUsedConversions=*/false,
4517  /*PartialOverloading=*/true);
4518 
4519  } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) {
4520  // If expression's type is CXXRecordDecl, it may overload the function
4521  // call operator, so we check if it does and add them as candidates.
4522  // A complete type is needed to lookup for member function call operators.
4523  if (isCompleteType(Loc, NakedFn->getType())) {
4524  DeclarationName OpName = Context.DeclarationNames
4525  .getCXXOperatorName(OO_Call);
4526  LookupResult R(*this, OpName, Loc, LookupOrdinaryName);
4527  LookupQualifiedName(R, DC);
4528  R.suppressDiagnostics();
4529  SmallVector<Expr *, 12> ArgExprs(1, NakedFn);
4530  ArgExprs.append(Args.begin(), Args.end());
4531  AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet,
4532  /*ExplicitArgs=*/nullptr,
4533  /*SuppressUsedConversions=*/false,
4534  /*PartialOverloading=*/true);
4535  }
4536  } else {
4537  // Lastly we check whether expression's type is function pointer or
4538  // function.
4539  QualType T = NakedFn->getType();
4540  if (!T->getPointeeType().isNull())
4541  T = T->getPointeeType();
4542 
4543  if (auto FP = T->getAs<FunctionProtoType>()) {
4544  if (!TooManyArguments(FP->getNumParams(), Args.size(),
4545  /*PartialOverloading=*/true) ||
4546  FP->isVariadic())
4547  Results.push_back(ResultCandidate(FP));
4548  } else if (auto FT = T->getAs<FunctionType>())
4549  // No prototype and declaration, it may be a K & R style function.
4550  Results.push_back(ResultCandidate(FT));
4551  }
4552  }
4553 
4554  mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4555  CodeCompleteOverloadResults(*this, S, Results, Args.size(),
4556  !CandidateSet.empty());
4557 }
4558 
4560  ArrayRef<Expr *> Args) {
4561  if (!CodeCompleter)
4562  return;
4563 
4564  // A complete type is needed to lookup for constructors.
4565  CXXRecordDecl *RD =
4566  isCompleteType(Loc, Type) ? Type->getAsCXXRecordDecl() : nullptr;
4567  if (!RD) {
4568  CodeCompleteExpression(S, Type);
4569  return;
4570  }
4571 
4572  // FIXME: Provide support for member initializers.
4573  // FIXME: Provide support for variadic template constructors.
4574 
4576 
4577  for (auto C : LookupConstructors(RD)) {
4578  if (auto FD = dyn_cast<FunctionDecl>(C)) {
4579  AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()),
4580  Args, CandidateSet,
4581  /*SuppressUsedConversions=*/false,
4582  /*PartialOverloading=*/true);
4583  } else if (auto FTD = dyn_cast<FunctionTemplateDecl>(C)) {
4584  AddTemplateOverloadCandidate(FTD,
4585  DeclAccessPair::make(FTD, C->getAccess()),
4586  /*ExplicitTemplateArgs=*/nullptr,
4587  Args, CandidateSet,
4588  /*SuppressUsedConversions=*/false,
4589  /*PartialOverloading=*/true);
4590  }
4591  }
4592 
4594  mergeCandidatesWithResults(*this, Results, CandidateSet, Loc);
4595  CodeCompleteOverloadResults(*this, S, Results, Args.size());
4596 }
4597 
4599  ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D);
4600  if (!VD) {
4601  CodeCompleteOrdinaryName(S, PCC_Expression);
4602  return;
4603  }
4604 
4605  CodeCompleteExpression(S, VD->getType());
4606 }
4607 
4609  QualType ResultType;
4610  if (isa<BlockDecl>(CurContext)) {
4611  if (BlockScopeInfo *BSI = getCurBlock())
4612  ResultType = BSI->ReturnType;
4613  } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext))
4614  ResultType = Function->getReturnType();
4615  else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext))
4616  ResultType = Method->getReturnType();
4617 
4618  if (ResultType.isNull())
4619  CodeCompleteOrdinaryName(S, PCC_Expression);
4620  else
4621  CodeCompleteExpression(S, ResultType);
4622 }
4623 
4625  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4626  CodeCompleter->getCodeCompletionTUInfo(),
4627  mapCodeCompletionContext(*this, PCC_Statement));
4628  Results.setFilter(&ResultBuilder::IsOrdinaryName);
4629  Results.EnterNewScope();
4630 
4631  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4632  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4633  CodeCompleter->includeGlobals(),
4634  CodeCompleter->loadExternal());
4635 
4636  AddOrdinaryNameResults(PCC_Statement, S, *this, Results);
4637 
4638  // "else" block
4639  CodeCompletionBuilder Builder(Results.getAllocator(),
4640  Results.getCodeCompletionTUInfo());
4641  Builder.AddTypedTextChunk("else");
4642  if (Results.includeCodePatterns()) {
4643  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4644  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4645  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4646  Builder.AddPlaceholderChunk("statements");
4647  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4648  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4649  }
4650  Results.AddResult(Builder.TakeString());
4651 
4652  // "else if" block
4653  Builder.AddTypedTextChunk("else");
4654  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4655  Builder.AddTextChunk("if");
4656  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4657  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4658  if (getLangOpts().CPlusPlus)
4659  Builder.AddPlaceholderChunk("condition");
4660  else
4661  Builder.AddPlaceholderChunk("expression");
4662  Builder.AddChunk(CodeCompletionString::CK_RightParen);
4663  if (Results.includeCodePatterns()) {
4664  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
4665  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
4666  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4667  Builder.AddPlaceholderChunk("statements");
4668  Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
4669  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
4670  }
4671  Results.AddResult(Builder.TakeString());
4672 
4673  Results.ExitScope();
4674 
4675  if (S->getFnParent())
4676  AddPrettyFunctionResults(getLangOpts(), Results);
4677 
4678  if (CodeCompleter->includeMacros())
4679  AddMacroResults(PP, Results, false);
4680 
4681  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4682  Results.data(),Results.size());
4683 }
4684 
4686  if (LHS)
4687  CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType());
4688  else
4689  CodeCompleteOrdinaryName(S, PCC_Expression);
4690 }
4691 
4693  bool EnteringContext) {
4694  if (SS.isEmpty() || !CodeCompleter)
4695  return;
4696 
4697  // We want to keep the scope specifier even if it's invalid (e.g. the scope
4698  // "a::b::" is not corresponding to any context/namespace in the AST), since
4699  // it can be useful for global code completion which have information about
4700  // contexts/symbols that are not in the AST.
4701  if (SS.isInvalid()) {
4703  CC.setCXXScopeSpecifier(SS);
4704  HandleCodeCompleteResults(this, CodeCompleter, CC, nullptr, 0);
4705  return;
4706  }
4707  // Always pretend to enter a context to ensure that a dependent type
4708  // resolves to a dependent record.
4709  DeclContext *Ctx = computeDeclContext(SS, /*EnteringContext=*/true);
4710  if (!Ctx)
4711  return;
4712 
4713  // Try to instantiate any non-dependent declaration contexts before
4714  // we look in them.
4715  if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
4716  return;
4717 
4718  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4719  CodeCompleter->getCodeCompletionTUInfo(),
4721  Results.EnterNewScope();
4722 
4723  // The "template" keyword can follow "::" in the grammar, but only
4724  // put it into the grammar if the nested-name-specifier is dependent.
4725  NestedNameSpecifier *NNS = SS.getScopeRep();
4726  if (!Results.empty() && NNS->isDependent())
4727  Results.AddResult("template");
4728 
4729  // Add calls to overridden virtual functions, if there are any.
4730  //
4731  // FIXME: This isn't wonderful, because we don't know whether we're actually
4732  // in a context that permits expressions. This is a general issue with
4733  // qualified-id completions.
4734  if (!EnteringContext)
4735  MaybeAddOverrideCalls(*this, Ctx, Results);
4736  Results.ExitScope();
4737 
4738  if (CodeCompleter->includeNamespaceLevelDecls() ||
4739  (!Ctx->isNamespace() && !Ctx->isTranslationUnit())) {
4740  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4741  LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer,
4742  /*IncludeGlobalScope=*/true,
4743  /*IncludeDependentBases=*/true,
4744  CodeCompleter->loadExternal());
4745  }
4746 
4747  auto CC = Results.getCompletionContext();
4748  CC.setCXXScopeSpecifier(SS);
4749 
4750  HandleCodeCompleteResults(this, CodeCompleter, CC, Results.data(),
4751  Results.size());
4752 }
4753 
4755  if (!CodeCompleter)
4756  return;
4757 
4758  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4759  CodeCompleter->getCodeCompletionTUInfo(),
4761  &ResultBuilder::IsNestedNameSpecifier);
4762  Results.EnterNewScope();
4763 
4764  // If we aren't in class scope, we could see the "namespace" keyword.
4765  if (!S->isClassScope())
4766  Results.AddResult(CodeCompletionResult("namespace"));
4767 
4768  // After "using", we can see anything that would start a
4769  // nested-name-specifier.
4770  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4771  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4772  CodeCompleter->includeGlobals(),
4773  CodeCompleter->loadExternal());
4774  Results.ExitScope();
4775 
4776  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4777  Results.data(), Results.size());
4778 }
4779 
4781  if (!CodeCompleter)
4782  return;
4783 
4784  // After "using namespace", we expect to see a namespace name or namespace
4785  // alias.
4786  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4787  CodeCompleter->getCodeCompletionTUInfo(),
4789  &ResultBuilder::IsNamespaceOrAlias);
4790  Results.EnterNewScope();
4791  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4792  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4793  CodeCompleter->includeGlobals(),
4794  CodeCompleter->loadExternal());
4795  Results.ExitScope();
4796  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4797  Results.data(), Results.size());
4798 }
4799 
4801  if (!CodeCompleter)
4802  return;
4803 
4804  DeclContext *Ctx = S->getEntity();
4805  if (!S->getParent())
4806  Ctx = Context.getTranslationUnitDecl();
4807 
4808  bool SuppressedGlobalResults
4809  = Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx);
4810 
4811  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4812  CodeCompleter->getCodeCompletionTUInfo(),
4813  SuppressedGlobalResults
4816  &ResultBuilder::IsNamespace);
4817 
4818  if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) {
4819  // We only want to see those namespaces that have already been defined
4820  // within this scope, because its likely that the user is creating an
4821  // extended namespace declaration. Keep track of the most recent
4822  // definition of each namespace.
4823  std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest;
4825  NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end());
4826  NS != NSEnd; ++NS)
4827  OrigToLatest[NS->getOriginalNamespace()] = *NS;
4828 
4829  // Add the most recent definition (or extended definition) of each
4830  // namespace to the list of results.
4831  Results.EnterNewScope();
4832  for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator
4833  NS = OrigToLatest.begin(),
4834  NSEnd = OrigToLatest.end();
4835  NS != NSEnd; ++NS)
4836  Results.AddResult(CodeCompletionResult(
4837  NS->second, Results.getBasePriority(NS->second),
4838  nullptr),
4839  CurContext, nullptr, false);
4840  Results.ExitScope();
4841  }
4842 
4843  HandleCodeCompleteResults(this, CodeCompleter,
4844  Results.getCompletionContext(),
4845  Results.data(),Results.size());
4846 }
4847 
4849  if (!CodeCompleter)
4850  return;
4851 
4852  // After "namespace", we expect to see a namespace or alias.
4853  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4854  CodeCompleter->getCodeCompletionTUInfo(),
4856  &ResultBuilder::IsNamespaceOrAlias);
4857  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4858  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4859  CodeCompleter->includeGlobals(),
4860  CodeCompleter->loadExternal());
4861  HandleCodeCompleteResults(this, CodeCompleter,
4862  Results.getCompletionContext(),
4863  Results.data(),Results.size());
4864 }
4865 
4867  if (!CodeCompleter)
4868  return;
4869 
4870  typedef CodeCompletionResult Result;
4871  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4872  CodeCompleter->getCodeCompletionTUInfo(),
4874  &ResultBuilder::IsType);
4875  Results.EnterNewScope();
4876 
4877  // Add the names of overloadable operators.
4878 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
4879  if (std::strcmp(Spelling, "?")) \
4880  Results.AddResult(Result(Spelling));
4881 #include "clang/Basic/OperatorKinds.def"
4882 
4883  // Add any type names visible from the current scope
4884  Results.allowNestedNameSpecifiers();
4885  CodeCompletionDeclConsumer Consumer(Results, CurContext);
4886  LookupVisibleDecls(S, LookupOrdinaryName, Consumer,
4887  CodeCompleter->includeGlobals(),
4888  CodeCompleter->loadExternal());
4889 
4890  // Add any type specifiers
4891  AddTypeSpecifierResults(getLangOpts(), Results);
4892  Results.ExitScope();
4893 
4894  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
4895  Results.data(), Results.size());
4896 }
4897 
4899  Decl *ConstructorD,
4900  ArrayRef <CXXCtorInitializer *> Initializers) {
4901  if (!ConstructorD)
4902  return;
4903 
4904  AdjustDeclIfTemplate(ConstructorD);
4905 
4906  CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(ConstructorD);
4907  if (!Constructor)
4908  return;
4909 
4910  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
4911  CodeCompleter->getCodeCompletionTUInfo(),
4913  Results.EnterNewScope();
4914 
4915  // Fill in any already-initialized fields or base classes.
4916  llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields;
4917  llvm::SmallPtrSet<CanQualType, 4> InitializedBases;
4918  for (unsigned I = 0, E = Initializers.size(); I != E; ++I) {
4919  if (Initializers[I]->isBaseInitializer())
4920  InitializedBases.insert(
4921  Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0)));
4922  else
4923  InitializedFields.insert(cast<FieldDecl>(
4924  Initializers[I]->getAnyMember()));
4925  }
4926 
4927  // Add completions for base classes.
4928  CodeCompletionBuilder Builder(Results.getAllocator(),
4929  Results.getCodeCompletionTUInfo());
4931  bool SawLastInitializer = Initializers.empty();
4932  CXXRecordDecl *ClassDecl = Constructor->getParent();
4933  for (const auto &Base : ClassDecl->bases()) {
4934  if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4935  .second) {
4936  SawLastInitializer
4937  = !Initializers.empty() &&
4938  Initializers.back()->isBaseInitializer() &&
4939  Context.hasSameUnqualifiedType(Base.getType(),
4940  QualType(Initializers.back()->getBaseClass(), 0));
4941  continue;
4942  }
4943 
4944  Builder.AddTypedTextChunk(
4945  Results.getAllocator().CopyString(
4946  Base.getType().getAsString(Policy)));
4947  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4948  Builder.AddPlaceholderChunk("args");
4949  Builder.AddChunk(CodeCompletionString::CK_RightParen);
4950  Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4951  SawLastInitializer? CCP_NextInitializer
4953  SawLastInitializer = false;
4954  }
4955 
4956  // Add completions for virtual base classes.
4957  for (const auto &Base : ClassDecl->vbases()) {
4958  if (!InitializedBases.insert(Context.getCanonicalType(Base.getType()))
4959  .second) {
4960  SawLastInitializer
4961  = !Initializers.empty() &&
4962  Initializers.back()->isBaseInitializer() &&
4963  Context.hasSameUnqualifiedType(Base.getType(),
4964  QualType(Initializers.back()->getBaseClass(), 0));
4965  continue;
4966  }
4967 
4968  Builder.AddTypedTextChunk(
4969  Builder.getAllocator().CopyString(
4970  Base.getType().getAsString(Policy)));
4971  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4972  Builder.AddPlaceholderChunk("args");
4973  Builder.AddChunk(CodeCompletionString::CK_RightParen);
4974  Results.AddResult(CodeCompletionResult(Builder.TakeString(),
4975  SawLastInitializer? CCP_NextInitializer
4977  SawLastInitializer = false;
4978  }
4979 
4980  // Add completions for members.
4981  for (auto *Field : ClassDecl->fields()) {
4982  if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))
4983  .second) {
4984  SawLastInitializer
4985  = !Initializers.empty() &&
4986  Initializers.back()->isAnyMemberInitializer() &&
4987  Initializers.back()->getAnyMember() == Field;
4988  continue;
4989  }
4990 
4991  if (!Field->getDeclName())
4992  continue;
4993 
4994  Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(
4995  Field->getIdentifier()->getName()));
4996  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
4997  Builder.AddPlaceholderChunk("args");
4998  Builder.AddChunk(CodeCompletionString::CK_RightParen);
4999  Results.AddResult(CodeCompletionResult(Builder.TakeString(),
5000  SawLastInitializer? CCP_NextInitializer
5004  Field));
5005  SawLastInitializer = false;
5006  }
5007  Results.ExitScope();
5008 
5009  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5010  Results.data(), Results.size());
5011 }
5012 
5013 /// Determine whether this scope denotes a namespace.
5014 static bool isNamespaceScope(Scope *S) {
5015  DeclContext *DC = S->getEntity();
5016  if (!DC)
5017  return false;
5018 
5019  return DC->isFileContext();
5020 }
5021 
5023  bool AfterAmpersand) {
5024  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5025  CodeCompleter->getCodeCompletionTUInfo(),
5027  Results.EnterNewScope();
5028 
5029  // Note what has already been captured.
5030  llvm::SmallPtrSet<IdentifierInfo *, 4> Known;
5031  bool IncludedThis = false;
5032  for (const auto &C : Intro.Captures) {
5033  if (C.Kind == LCK_This) {
5034  IncludedThis = true;
5035  continue;
5036  }
5037 
5038  Known.insert(C.Id);
5039  }
5040 
5041  // Look for other capturable variables.
5042  for (; S && !isNamespaceScope(S); S = S->getParent()) {
5043  for (const auto *D : S->decls()) {
5044  const auto *Var = dyn_cast<VarDecl>(D);
5045  if (!Var ||
5046  !Var->hasLocalStorage() ||
5047  Var->hasAttr<BlocksAttr>())
5048  continue;
5049 
5050  if (Known.insert(Var->getIdentifier()).second)
5051  Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration),
5052  CurContext, nullptr, false);
5053  }
5054  }
5055 
5056  // Add 'this', if it would be valid.
5057  if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy)
5058  addThisCompletion(*this, Results);
5059 
5060  Results.ExitScope();
5061 
5062  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5063  Results.data(), Results.size());
5064 }
5065 
5066 /// Macro that optionally prepends an "@" to the string literal passed in via
5067 /// Keyword, depending on whether NeedAt is true or false.
5068 #define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) ((NeedAt)? "@" Keyword : Keyword)
5069 
5070 static void AddObjCImplementationResults(const LangOptions &LangOpts,
5071  ResultBuilder &Results,
5072  bool NeedAt) {
5073  typedef CodeCompletionResult Result;
5074  // Since we have an implementation, we can end it.
5075  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
5076 
5077  CodeCompletionBuilder Builder(Results.getAllocator(),
5078  Results.getCodeCompletionTUInfo());
5079  if (LangOpts.ObjC2) {
5080  // @dynamic
5081  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"dynamic"));
5082  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5083  Builder.AddPlaceholderChunk("property");
5084  Results.AddResult(Result(Builder.TakeString()));
5085 
5086  // @synthesize
5087  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synthesize"));
5088  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5089  Builder.AddPlaceholderChunk("property");
5090  Results.AddResult(Result(Builder.TakeString()));
5091  }
5092 }
5093 
5094 static void AddObjCInterfaceResults(const LangOptions &LangOpts,
5095  ResultBuilder &Results,
5096  bool NeedAt) {
5097  typedef CodeCompletionResult Result;
5098 
5099  // Since we have an interface or protocol, we can end it.
5100  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"end")));
5101 
5102  if (LangOpts.ObjC2) {
5103  // @property
5104  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"property")));
5105 
5106  // @required
5107  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"required")));
5108 
5109  // @optional
5110  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"optional")));
5111  }
5112 }
5113 
5114 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) {
5115  typedef CodeCompletionResult Result;
5116  CodeCompletionBuilder Builder(Results.getAllocator(),
5117  Results.getCodeCompletionTUInfo());
5118 
5119  // @class name ;
5120  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"class"));
5121  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5122  Builder.AddPlaceholderChunk("name");
5123  Results.AddResult(Result(Builder.TakeString()));
5124 
5125  if (Results.includeCodePatterns()) {
5126  // @interface name
5127  // FIXME: Could introduce the whole pattern, including superclasses and
5128  // such.
5129  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"interface"));
5130  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5131  Builder.AddPlaceholderChunk("class");
5132  Results.AddResult(Result(Builder.TakeString()));
5133 
5134  // @protocol name
5135  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
5136  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5137  Builder.AddPlaceholderChunk("protocol");
5138  Results.AddResult(Result(Builder.TakeString()));
5139 
5140  // @implementation name
5141  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"implementation"));
5142  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5143  Builder.AddPlaceholderChunk("class");
5144  Results.AddResult(Result(Builder.TakeString()));
5145  }
5146 
5147  // @compatibility_alias name
5148  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"compatibility_alias"));
5149  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5150  Builder.AddPlaceholderChunk("alias");
5151  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5152  Builder.AddPlaceholderChunk("class");
5153  Results.AddResult(Result(Builder.TakeString()));
5154 
5155  if (Results.getSema().getLangOpts().Modules) {
5156  // @import name
5157  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import"));
5158  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5159  Builder.AddPlaceholderChunk("module");
5160  Results.AddResult(Result(Builder.TakeString()));
5161  }
5162 }
5163 
5165  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5166  CodeCompleter->getCodeCompletionTUInfo(),
5168  Results.EnterNewScope();
5169  if (isa<ObjCImplDecl>(CurContext))
5170  AddObjCImplementationResults(getLangOpts(), Results, false);
5171  else if (CurContext->isObjCContainer())
5172  AddObjCInterfaceResults(getLangOpts(), Results, false);
5173  else
5174  AddObjCTopLevelResults(Results, false);
5175  Results.ExitScope();
5176  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5177  Results.data(), Results.size());
5178 }
5179 
5180 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) {
5181  typedef CodeCompletionResult Result;
5182  CodeCompletionBuilder Builder(Results.getAllocator(),
5183  Results.getCodeCompletionTUInfo());
5184 
5185  // @encode ( type-name )
5186  const char *EncodeType = "char[]";
5187  if (Results.getSema().getLangOpts().CPlusPlus ||
5188  Results.getSema().getLangOpts().ConstStrings)
5189  EncodeType = "const char[]";
5190  Builder.AddResultTypeChunk(EncodeType);
5191  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"encode"));
5192  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5193  Builder.AddPlaceholderChunk("type-name");
5194  Builder.AddChunk(CodeCompletionString::CK_RightParen);
5195  Results.AddResult(Result(Builder.TakeString()));
5196 
5197  // @protocol ( protocol-name )
5198  Builder.AddResultTypeChunk("Protocol *");
5199  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"protocol"));
5200  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5201  Builder.AddPlaceholderChunk("protocol-name");
5202  Builder.AddChunk(CodeCompletionString::CK_RightParen);
5203  Results.AddResult(Result(Builder.TakeString()));
5204 
5205  // @selector ( selector )
5206  Builder.AddResultTypeChunk("SEL");
5207  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"selector"));
5208  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5209  Builder.AddPlaceholderChunk("selector");
5210  Builder.AddChunk(CodeCompletionString::CK_RightParen);
5211  Results.AddResult(Result(Builder.TakeString()));
5212 
5213  // @"string"
5214  Builder.AddResultTypeChunk("NSString *");
5215  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"\""));
5216  Builder.AddPlaceholderChunk("string");
5217  Builder.AddTextChunk("\"");
5218  Results.AddResult(Result(Builder.TakeString()));
5219 
5220  // @[objects, ...]
5221  Builder.AddResultTypeChunk("NSArray *");
5222  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"["));
5223  Builder.AddPlaceholderChunk("objects, ...");
5224  Builder.AddChunk(CodeCompletionString::CK_RightBracket);
5225  Results.AddResult(Result(Builder.TakeString()));
5226 
5227  // @{key : object, ...}
5228  Builder.AddResultTypeChunk("NSDictionary *");
5229  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"{"));
5230  Builder.AddPlaceholderChunk("key");
5231  Builder.AddChunk(CodeCompletionString::CK_Colon);
5232  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5233  Builder.AddPlaceholderChunk("object, ...");
5234  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5235  Results.AddResult(Result(Builder.TakeString()));
5236 
5237  // @(expression)
5238  Builder.AddResultTypeChunk("id");
5239  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "("));
5240  Builder.AddPlaceholderChunk("expression");
5241  Builder.AddChunk(CodeCompletionString::CK_RightParen);
5242  Results.AddResult(Result(Builder.TakeString()));
5243 }
5244 
5245 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) {
5246  typedef CodeCompletionResult Result;
5247  CodeCompletionBuilder Builder(Results.getAllocator(),
5248  Results.getCodeCompletionTUInfo());
5249 
5250  if (Results.includeCodePatterns()) {
5251  // @try { statements } @catch ( declaration ) { statements } @finally
5252  // { statements }
5253  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"try"));
5254  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5255  Builder.AddPlaceholderChunk("statements");
5256  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5257  Builder.AddTextChunk("@catch");
5258  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5259  Builder.AddPlaceholderChunk("parameter");
5260  Builder.AddChunk(CodeCompletionString::CK_RightParen);
5261  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5262  Builder.AddPlaceholderChunk("statements");
5263  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5264  Builder.AddTextChunk("@finally");
5265  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5266  Builder.AddPlaceholderChunk("statements");
5267  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5268  Results.AddResult(Result(Builder.TakeString()));
5269  }
5270 
5271  // @throw
5272  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"throw"));
5273  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5274  Builder.AddPlaceholderChunk("expression");
5275  Results.AddResult(Result(Builder.TakeString()));
5276 
5277  if (Results.includeCodePatterns()) {
5278  // @synchronized ( expression ) { statements }
5279  Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,"synchronized"));
5280  Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
5281  Builder.AddChunk(CodeCompletionString::CK_LeftParen);
5282  Builder.AddPlaceholderChunk("expression");
5283  Builder.AddChunk(CodeCompletionString::CK_RightParen);
5284  Builder.AddChunk(CodeCompletionString::CK_LeftBrace);
5285  Builder.AddPlaceholderChunk("statements");
5286  Builder.AddChunk(CodeCompletionString::CK_RightBrace);
5287  Results.AddResult(Result(Builder.TakeString()));
5288  }
5289 }
5290 
5291 static void AddObjCVisibilityResults(const LangOptions &LangOpts,
5292  ResultBuilder &Results,
5293  bool NeedAt) {
5294  typedef CodeCompletionResult Result;
5295  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"private")));
5296  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"protected")));
5297  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"public")));
5298  if (LangOpts.ObjC2)
5299  Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,"package")));
5300 }
5301 
5303  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5304  CodeCompleter->getCodeCompletionTUInfo(),
5306  Results.EnterNewScope();
5307  AddObjCVisibilityResults(getLangOpts(), Results, false);
5308  Results.ExitScope();
5309  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5310  Results.data(), Results.size());
5311 }
5312 
5314  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5315  CodeCompleter->getCodeCompletionTUInfo(),
5317  Results.EnterNewScope();
5318  AddObjCStatementResults(Results, false);
5319  AddObjCExpressionResults(Results, false);
5320  Results.ExitScope();
5321  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5322  Results.data(), Results.size());
5323 }
5324 
5326  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5327  CodeCompleter->getCodeCompletionTUInfo(),
5329  Results.EnterNewScope();
5330  AddObjCExpressionResults(Results, false);
5331  Results.ExitScope();
5332  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5333  Results.data(), Results.size());
5334 }
5335 
5336 /// Determine whether the addition of the given flag to an Objective-C
5337 /// property's attributes will cause a conflict.
5338 static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) {
5339  // Check if we've already added this flag.
5340  if (Attributes & NewFlag)
5341  return true;
5342 
5343  Attributes |= NewFlag;
5344 
5345  // Check for collisions with "readonly".
5346  if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) &&
5347  (Attributes & ObjCDeclSpec::DQ_PR_readwrite))
5348  return true;
5349 
5350  // Check for more than one of { assign, copy, retain, strong, weak }.
5351  unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign |
5357  if (AssignCopyRetMask &&
5358  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign &&
5359  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_unsafe_unretained &&
5360  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy &&
5361  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain &&
5362  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_strong &&
5363  AssignCopyRetMask != ObjCDeclSpec::DQ_PR_weak)
5364  return true;
5365 
5366  return false;
5367 }
5368 
5370  if (!CodeCompleter)
5371  return;
5372 
5373  unsigned Attributes = ODS.getPropertyAttributes();
5374 
5375  ResultBuilder Results(*this, CodeCompleter->getAllocator(),
5376  CodeCompleter->getCodeCompletionTUInfo(),
5378  Results.EnterNewScope();
5380  Results.AddResult(CodeCompletionResult("readonly"));
5382  Results.AddResult(CodeCompletionResult("assign"));
5383  if (!ObjCPropertyFlagConflicts(Attributes,
5385  Results.AddResult(CodeCompletionResult("unsafe_unretained"));
5387  Results.AddResult(CodeCompletionResult("readwrite"));
5389  Results.AddResult(CodeCompletionResult("retain"));
5391  Results.AddResult(CodeCompletionResult("strong"));
5393  Results.AddResult(CodeCompletionResult("copy"));
5395  Results.AddResult(CodeCompletionResult("nonatomic"));
5397  Results.AddResult(CodeCompletionResult("atomic"));
5398 
5399  // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC.
5400  if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC)
5402  Results.AddResult(CodeCompletionResult("weak"));
5403 
5405  CodeCompletionBuilder Setter(Results.getAllocator(),
5406  Results.getCodeCompletionTUInfo());
5407  Setter.AddTypedTextChunk("setter");
5408  Setter.AddTextChunk("=");
5409  Setter.AddPlaceholderChunk("method");
5410  Results.AddResult(CodeCompletionResult(Setter.TakeString()));
5411  }
5413  CodeCompletionBuilder Getter(Results.getAllocator(),
5414  Results.getCodeCompletionTUInfo());
5415  Getter.AddTypedTextChunk("getter");
5416  Getter.AddTextChunk("=");
5417  Getter.AddPlaceholderChunk("method");
5418  Results.AddResult(CodeCompletionResult(Getter.TakeString()));
5419  }
5421  Results.AddResult(CodeCompletionResult("nonnull"));
5422  Results.AddResult(CodeCompletionResult("nullable"));
5423  Results.AddResult(CodeCompletionResult("null_unspecified"));
5424  Results.AddResult(CodeCompletionResult("null_resettable"));
5425  }
5426  Results.ExitScope();
5427  HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(),
5428  Results.data(), Results.size());
5429 }
5430 
5431 /// Describes the kind of Objective-C method that we want to find
5432 /// via code completion.
5434  MK_Any, ///< Any kind of method, provided it means other specified criteria.
5435  MK_ZeroArgSelector, ///< Zero-argument (unary) selector.
5436  MK_OneArgSelector ///< One-argument selector.
5437 };
5438 
5440  ObjCMethodKind WantKind,
5441  ArrayRef<IdentifierInfo *> SelIdents,
5442  bool AllowSameLength = true) {
5443  unsigned NumSelIdents = SelIdents.size();
5444  if (NumSelIdents > Sel.getNumArgs())
5445  return false;
5446 
5447  switch (WantKind) {
5448  case MK_Any: break;
5449  case MK_ZeroArgSelector: return Sel.isUnarySelector();
5450  case MK_OneArgSelector: return Sel.getNumArgs() == 1;
5451  }
5452 
5453  if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs())
5454  return false;
5455 
5456  for (unsigned I = 0; I != NumSelIdents; ++I)
5457  if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I))
5458  return false;
5459 
5460  return true;
5461 }
5462 
5464  ObjCMethodKind WantKind,
5465  ArrayRef<IdentifierInfo *> SelIdents,
5466  bool AllowSameLength = true) {
5467  return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents,
5468  AllowSameLength);
5469 }
5470 
5471 namespace {
5472  /// A set of selectors, which is used to avoid introducing multiple
5473  /// completions with the same selector into the result set.
5474  typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet;
5475 }
5476 
5477 /// Add all of the Objective-C methods in the given Objective-C
5478 /// container to the set of results.
5479 ///
5480 /// The container will be a class, protocol, category, or implementation of
5481 /// any of the above. This mether will recurse to include methods from
5482 /// the superclasses of classes along with their categories, protocols, and
5483 /// implementations.
5484 ///
5485 /// \param Container the container in which we'll look to find methods.
5486 ///
5487 /// \param WantInstanceMethods Whether to add instance methods (only); if
5488 /// false, this routine will add factory methods (only).
5489 ///
5490 /// \param CurContext the context in which we're performing the lookup that
5491 /// finds methods.
5492 ///
5493 /// \param AllowSameLength Whether we allow a method to be added to the list
5494 /// when it has the same number of parameters as we have selector identifiers.
5495 ///
5496 /// \param Results the structure into which we'll add results.
5497 static void AddObjCMethods(ObjCContainerDecl *Container,
5498  bool WantInstanceMethods, ObjCMethodKind WantKind,
5499  ArrayRef<IdentifierInfo *> SelIdents,
5500  DeclContext *CurContext,
5501  VisitedSelectorSet &Selectors, bool AllowSameLength,
5502  ResultBuilder &Results, bool InOriginalClass = true,
5503  bool IsRootClass = false) {
5504  typedef CodeCompletionResult Result;
5505  Container = getContainerDef(Container);
5506  ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container);
5507  IsRootClass = IsRootClass || (IFace && !IFace->getSuperClass());
5508  for (auto *M : Container->methods()) {
5509  // The instance methods on the root class can be messaged via the
5510  // metaclass.
5511  if (M->isInstanceMethod() == WantInstanceMethods ||
5512  (IsRootClass && !WantInstanceMethods)) {
5513  // Check whether the selector identifiers we've been given are a
5514  // subset of the identifiers for this particular method.
5515  if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength))
5516  continue;
5517 
5518  if (!Selectors.insert(M->getSelector()).second)
5519  continue;
5520 
5521  Result R = Result(M, Results.getBasePriority(M), nullptr);
5522  R.StartParameter = SelIdents.size();
5523  R.AllParametersAreInformative = (WantKind != MK_Any);
5524  if (!InOriginalClass)
5525  R.Priority += CCD_InBaseClass;
5526  Results.MaybeAddResult(R, CurContext);
5527  }
5528  }
5529 
5530  // Visit the protocols of protocols.
5531  if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
5532  if (Protocol->hasDefinition()) {
5533  const ObjCList<ObjCProtocolDecl> &Protocols
5534  = Protocol->getReferencedProtocols();
5535  for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(),
5536  E = Protocols.end();
5537  I != E; ++I)
5538  AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5539  Selectors, AllowSameLength, Results, false, IsRootClass);
5540  }
5541  }
5542 
5543  if (!IFace || !IFace->hasDefinition())
5544  return;
5545 
5546  // Add methods in protocols.
5547  for (auto *I : IFace->protocols())
5548  AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents, CurContext,
5549  Selectors, AllowSameLength, Results, false, IsRootClass);
5550 
5551  // Add methods in categories.
5552  for (auto *CatDecl : IFace->known_categories()) {
5553  AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents,
5554  CurContext, Selectors, AllowSameLength, Results,
5555  InOriginalClass, IsRootClass);
5556 
5557  // Add a categories pr