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