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