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