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