contrib/llvm/tools/clang/lib/Sema/SemaCodeComplete.cpp

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