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