SemaCodeComplete.cpp revision bed047d6d8212b07caa84c04cd21bedabd95cd4f
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 "Sema.h" 14#include "Lookup.h" 15#include "clang/Sema/CodeCompleteConsumer.h" 16#include "clang/Sema/ExternalSemaSource.h" 17#include "clang/AST/ExprCXX.h" 18#include "clang/AST/ExprObjC.h" 19#include "clang/Lex/MacroInfo.h" 20#include "clang/Lex/Preprocessor.h" 21#include "llvm/ADT/SmallPtrSet.h" 22#include "llvm/ADT/StringExtras.h" 23#include "llvm/ADT/StringSwitch.h" 24#include <list> 25#include <map> 26#include <vector> 27 28using namespace clang; 29 30namespace { 31 /// \brief A container of code-completion results. 32 class ResultBuilder { 33 public: 34 /// \brief The type of a name-lookup filter, which can be provided to the 35 /// name-lookup routines to specify which declarations should be included in 36 /// the result set (when it returns true) and which declarations should be 37 /// filtered out (returns false). 38 typedef bool (ResultBuilder::*LookupFilter)(NamedDecl *) const; 39 40 typedef CodeCompleteConsumer::Result Result; 41 42 private: 43 /// \brief The actual results we have found. 44 std::vector<Result> Results; 45 46 /// \brief A record of all of the declarations we have found and placed 47 /// into the result set, used to ensure that no declaration ever gets into 48 /// the result set twice. 49 llvm::SmallPtrSet<Decl*, 16> AllDeclsFound; 50 51 typedef std::pair<NamedDecl *, unsigned> DeclIndexPair; 52 53 /// \brief An entry in the shadow map, which is optimized to store 54 /// a single (declaration, index) mapping (the common case) but 55 /// can also store a list of (declaration, index) mappings. 56 class ShadowMapEntry { 57 typedef llvm::SmallVector<DeclIndexPair, 4> DeclIndexPairVector; 58 59 /// \brief Contains either the solitary NamedDecl * or a vector 60 /// of (declaration, index) pairs. 61 llvm::PointerUnion<NamedDecl *, DeclIndexPairVector*> DeclOrVector; 62 63 /// \brief When the entry contains a single declaration, this is 64 /// the index associated with that entry. 65 unsigned SingleDeclIndex; 66 67 public: 68 ShadowMapEntry() : DeclOrVector(), SingleDeclIndex(0) { } 69 70 void Add(NamedDecl *ND, unsigned Index) { 71 if (DeclOrVector.isNull()) { 72 // 0 - > 1 elements: just set the single element information. 73 DeclOrVector = ND; 74 SingleDeclIndex = Index; 75 return; 76 } 77 78 if (NamedDecl *PrevND = DeclOrVector.dyn_cast<NamedDecl *>()) { 79 // 1 -> 2 elements: create the vector of results and push in the 80 // existing declaration. 81 DeclIndexPairVector *Vec = new DeclIndexPairVector; 82 Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex)); 83 DeclOrVector = Vec; 84 } 85 86 // Add the new element to the end of the vector. 87 DeclOrVector.get<DeclIndexPairVector*>()->push_back( 88 DeclIndexPair(ND, Index)); 89 } 90 91 void Destroy() { 92 if (DeclIndexPairVector *Vec 93 = DeclOrVector.dyn_cast<DeclIndexPairVector *>()) { 94 delete Vec; 95 DeclOrVector = ((NamedDecl *)0); 96 } 97 } 98 99 // Iteration. 100 class iterator; 101 iterator begin() const; 102 iterator end() const; 103 }; 104 105 /// \brief A mapping from declaration names to the declarations that have 106 /// this name within a particular scope and their index within the list of 107 /// results. 108 typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap; 109 110 /// \brief The semantic analysis object for which results are being 111 /// produced. 112 Sema &SemaRef; 113 114 /// \brief If non-NULL, a filter function used to remove any code-completion 115 /// results that are not desirable. 116 LookupFilter Filter; 117 118 /// \brief Whether we should allow declarations as 119 /// nested-name-specifiers that would otherwise be filtered out. 120 bool AllowNestedNameSpecifiers; 121 122 /// \brief If set, the type that we would prefer our resulting value 123 /// declarations to have. 124 /// 125 /// Closely matching the preferred type gives a boost to a result's 126 /// priority. 127 CanQualType PreferredType; 128 129 /// \brief A list of shadow maps, which is used to model name hiding at 130 /// different levels of, e.g., the inheritance hierarchy. 131 std::list<ShadowMap> ShadowMaps; 132 133 void AdjustResultPriorityForPreferredType(Result &R); 134 135 public: 136 explicit ResultBuilder(Sema &SemaRef, LookupFilter Filter = 0) 137 : SemaRef(SemaRef), Filter(Filter), AllowNestedNameSpecifiers(false) { } 138 139 /// \brief Whether we should include code patterns in the completion 140 /// results. 141 bool includeCodePatterns() const { 142 return SemaRef.CodeCompleter && 143 SemaRef.CodeCompleter->includeCodePatterns(); 144 } 145 146 /// \brief Set the filter used for code-completion results. 147 void setFilter(LookupFilter Filter) { 148 this->Filter = Filter; 149 } 150 151 typedef std::vector<Result>::iterator iterator; 152 iterator begin() { return Results.begin(); } 153 iterator end() { return Results.end(); } 154 155 Result *data() { return Results.empty()? 0 : &Results.front(); } 156 unsigned size() const { return Results.size(); } 157 bool empty() const { return Results.empty(); } 158 159 /// \brief Specify the preferred type. 160 void setPreferredType(QualType T) { 161 PreferredType = SemaRef.Context.getCanonicalType(T); 162 } 163 164 /// \brief Specify whether nested-name-specifiers are allowed. 165 void allowNestedNameSpecifiers(bool Allow = true) { 166 AllowNestedNameSpecifiers = Allow; 167 } 168 169 /// \brief Determine whether the given declaration is at all interesting 170 /// as a code-completion result. 171 /// 172 /// \param ND the declaration that we are inspecting. 173 /// 174 /// \param AsNestedNameSpecifier will be set true if this declaration is 175 /// only interesting when it is a nested-name-specifier. 176 bool isInterestingDecl(NamedDecl *ND, bool &AsNestedNameSpecifier) const; 177 178 /// \brief Check whether the result is hidden by the Hiding declaration. 179 /// 180 /// \returns true if the result is hidden and cannot be found, false if 181 /// the hidden result could still be found. When false, \p R may be 182 /// modified to describe how the result can be found (e.g., via extra 183 /// qualification). 184 bool CheckHiddenResult(Result &R, DeclContext *CurContext, 185 NamedDecl *Hiding); 186 187 /// \brief Add a new result to this result set (if it isn't already in one 188 /// of the shadow maps), or replace an existing result (for, e.g., a 189 /// redeclaration). 190 /// 191 /// \param CurContext the result to add (if it is unique). 192 /// 193 /// \param R the context in which this result will be named. 194 void MaybeAddResult(Result R, DeclContext *CurContext = 0); 195 196 /// \brief Add a new result to this result set, where we already know 197 /// the hiding declation (if any). 198 /// 199 /// \param R the result to add (if it is unique). 200 /// 201 /// \param CurContext the context in which this result will be named. 202 /// 203 /// \param Hiding the declaration that hides the result. 204 /// 205 /// \param InBaseClass whether the result was found in a base 206 /// class of the searched context. 207 void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding, 208 bool InBaseClass); 209 210 /// \brief Add a new non-declaration result to this result set. 211 void AddResult(Result R); 212 213 /// \brief Enter into a new scope. 214 void EnterNewScope(); 215 216 /// \brief Exit from the current scope. 217 void ExitScope(); 218 219 /// \brief Ignore this declaration, if it is seen again. 220 void Ignore(Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); } 221 222 /// \name Name lookup predicates 223 /// 224 /// These predicates can be passed to the name lookup functions to filter the 225 /// results of name lookup. All of the predicates have the same type, so that 226 /// 227 //@{ 228 bool IsOrdinaryName(NamedDecl *ND) const; 229 bool IsOrdinaryNonTypeName(NamedDecl *ND) const; 230 bool IsIntegralConstantValue(NamedDecl *ND) const; 231 bool IsOrdinaryNonValueName(NamedDecl *ND) const; 232 bool IsNestedNameSpecifier(NamedDecl *ND) const; 233 bool IsEnum(NamedDecl *ND) const; 234 bool IsClassOrStruct(NamedDecl *ND) const; 235 bool IsUnion(NamedDecl *ND) const; 236 bool IsNamespace(NamedDecl *ND) const; 237 bool IsNamespaceOrAlias(NamedDecl *ND) const; 238 bool IsType(NamedDecl *ND) const; 239 bool IsMember(NamedDecl *ND) const; 240 bool IsObjCIvar(NamedDecl *ND) const; 241 bool IsObjCMessageReceiver(NamedDecl *ND) const; 242 //@} 243 }; 244} 245 246class ResultBuilder::ShadowMapEntry::iterator { 247 llvm::PointerUnion<NamedDecl*, const DeclIndexPair*> DeclOrIterator; 248 unsigned SingleDeclIndex; 249 250public: 251 typedef DeclIndexPair value_type; 252 typedef value_type reference; 253 typedef std::ptrdiff_t difference_type; 254 typedef std::input_iterator_tag iterator_category; 255 256 class pointer { 257 DeclIndexPair Value; 258 259 public: 260 pointer(const DeclIndexPair &Value) : Value(Value) { } 261 262 const DeclIndexPair *operator->() const { 263 return &Value; 264 } 265 }; 266 267 iterator() : DeclOrIterator((NamedDecl *)0), SingleDeclIndex(0) { } 268 269 iterator(NamedDecl *SingleDecl, unsigned Index) 270 : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) { } 271 272 iterator(const DeclIndexPair *Iterator) 273 : DeclOrIterator(Iterator), SingleDeclIndex(0) { } 274 275 iterator &operator++() { 276 if (DeclOrIterator.is<NamedDecl *>()) { 277 DeclOrIterator = (NamedDecl *)0; 278 SingleDeclIndex = 0; 279 return *this; 280 } 281 282 const DeclIndexPair *I = DeclOrIterator.get<const DeclIndexPair*>(); 283 ++I; 284 DeclOrIterator = I; 285 return *this; 286 } 287 288 iterator operator++(int) { 289 iterator tmp(*this); 290 ++(*this); 291 return tmp; 292 } 293 294 reference operator*() const { 295 if (NamedDecl *ND = DeclOrIterator.dyn_cast<NamedDecl *>()) 296 return reference(ND, SingleDeclIndex); 297 298 return *DeclOrIterator.get<const DeclIndexPair*>(); 299 } 300 301 pointer operator->() const { 302 return pointer(**this); 303 } 304 305 friend bool operator==(const iterator &X, const iterator &Y) { 306 return X.DeclOrIterator.getOpaqueValue() 307 == Y.DeclOrIterator.getOpaqueValue() && 308 X.SingleDeclIndex == Y.SingleDeclIndex; 309 } 310 311 friend bool operator!=(const iterator &X, const iterator &Y) { 312 return !(X == Y); 313 } 314}; 315 316ResultBuilder::ShadowMapEntry::iterator 317ResultBuilder::ShadowMapEntry::begin() const { 318 if (DeclOrVector.isNull()) 319 return iterator(); 320 321 if (NamedDecl *ND = DeclOrVector.dyn_cast<NamedDecl *>()) 322 return iterator(ND, SingleDeclIndex); 323 324 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin()); 325} 326 327ResultBuilder::ShadowMapEntry::iterator 328ResultBuilder::ShadowMapEntry::end() const { 329 if (DeclOrVector.is<NamedDecl *>() || DeclOrVector.isNull()) 330 return iterator(); 331 332 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end()); 333} 334 335/// \brief Compute the qualification required to get from the current context 336/// (\p CurContext) to the target context (\p TargetContext). 337/// 338/// \param Context the AST context in which the qualification will be used. 339/// 340/// \param CurContext the context where an entity is being named, which is 341/// typically based on the current scope. 342/// 343/// \param TargetContext the context in which the named entity actually 344/// resides. 345/// 346/// \returns a nested name specifier that refers into the target context, or 347/// NULL if no qualification is needed. 348static NestedNameSpecifier * 349getRequiredQualification(ASTContext &Context, 350 DeclContext *CurContext, 351 DeclContext *TargetContext) { 352 llvm::SmallVector<DeclContext *, 4> TargetParents; 353 354 for (DeclContext *CommonAncestor = TargetContext; 355 CommonAncestor && !CommonAncestor->Encloses(CurContext); 356 CommonAncestor = CommonAncestor->getLookupParent()) { 357 if (CommonAncestor->isTransparentContext() || 358 CommonAncestor->isFunctionOrMethod()) 359 continue; 360 361 TargetParents.push_back(CommonAncestor); 362 } 363 364 NestedNameSpecifier *Result = 0; 365 while (!TargetParents.empty()) { 366 DeclContext *Parent = TargetParents.back(); 367 TargetParents.pop_back(); 368 369 if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Parent)) 370 Result = NestedNameSpecifier::Create(Context, Result, Namespace); 371 else if (TagDecl *TD = dyn_cast<TagDecl>(Parent)) 372 Result = NestedNameSpecifier::Create(Context, Result, 373 false, 374 Context.getTypeDeclType(TD).getTypePtr()); 375 } 376 return Result; 377} 378 379bool ResultBuilder::isInterestingDecl(NamedDecl *ND, 380 bool &AsNestedNameSpecifier) const { 381 AsNestedNameSpecifier = false; 382 383 ND = ND->getUnderlyingDecl(); 384 unsigned IDNS = ND->getIdentifierNamespace(); 385 386 // Skip unnamed entities. 387 if (!ND->getDeclName()) 388 return false; 389 390 // Friend declarations and declarations introduced due to friends are never 391 // added as results. 392 if (IDNS & (Decl::IDNS_OrdinaryFriend | Decl::IDNS_TagFriend)) 393 return false; 394 395 // Class template (partial) specializations are never added as results. 396 if (isa<ClassTemplateSpecializationDecl>(ND) || 397 isa<ClassTemplatePartialSpecializationDecl>(ND)) 398 return false; 399 400 // Using declarations themselves are never added as results. 401 if (isa<UsingDecl>(ND)) 402 return false; 403 404 // Some declarations have reserved names that we don't want to ever show. 405 if (const IdentifierInfo *Id = ND->getIdentifier()) { 406 // __va_list_tag is a freak of nature. Find it and skip it. 407 if (Id->isStr("__va_list_tag") || Id->isStr("__builtin_va_list")) 408 return false; 409 410 // Filter out names reserved for the implementation (C99 7.1.3, 411 // C++ [lib.global.names]) if they come from a system header. 412 // 413 // FIXME: Add predicate for this. 414 if (Id->getLength() >= 2) { 415 const char *Name = Id->getNameStart(); 416 if (Name[0] == '_' && 417 (Name[1] == '_' || (Name[1] >= 'A' && Name[1] <= 'Z')) && 418 (ND->getLocation().isInvalid() || 419 SemaRef.SourceMgr.isInSystemHeader( 420 SemaRef.SourceMgr.getSpellingLoc(ND->getLocation())))) 421 return false; 422 } 423 } 424 425 // C++ constructors are never found by name lookup. 426 if (isa<CXXConstructorDecl>(ND)) 427 return false; 428 429 // Filter out any unwanted results. 430 if (Filter && !(this->*Filter)(ND)) { 431 // Check whether it is interesting as a nested-name-specifier. 432 if (AllowNestedNameSpecifiers && SemaRef.getLangOptions().CPlusPlus && 433 IsNestedNameSpecifier(ND) && 434 (Filter != &ResultBuilder::IsMember || 435 (isa<CXXRecordDecl>(ND) && 436 cast<CXXRecordDecl>(ND)->isInjectedClassName()))) { 437 AsNestedNameSpecifier = true; 438 return true; 439 } 440 441 return false; 442 } 443 444 if (Filter == &ResultBuilder::IsNestedNameSpecifier) 445 AsNestedNameSpecifier = true; 446 447 // ... then it must be interesting! 448 return true; 449} 450 451bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext, 452 NamedDecl *Hiding) { 453 // In C, there is no way to refer to a hidden name. 454 // FIXME: This isn't true; we can find a tag name hidden by an ordinary 455 // name if we introduce the tag type. 456 if (!SemaRef.getLangOptions().CPlusPlus) 457 return true; 458 459 DeclContext *HiddenCtx = R.Declaration->getDeclContext()->getLookupContext(); 460 461 // There is no way to qualify a name declared in a function or method. 462 if (HiddenCtx->isFunctionOrMethod()) 463 return true; 464 465 if (HiddenCtx == Hiding->getDeclContext()->getLookupContext()) 466 return true; 467 468 // We can refer to the result with the appropriate qualification. Do it. 469 R.Hidden = true; 470 R.QualifierIsInformative = false; 471 472 if (!R.Qualifier) 473 R.Qualifier = getRequiredQualification(SemaRef.Context, 474 CurContext, 475 R.Declaration->getDeclContext()); 476 return false; 477} 478 479enum SimplifiedTypeClass { 480 STC_Arithmetic, 481 STC_Array, 482 STC_Block, 483 STC_Function, 484 STC_ObjectiveC, 485 STC_Other, 486 STC_Pointer, 487 STC_Record, 488 STC_Void 489}; 490 491/// \brief A simplified classification of types used to determine whether two 492/// types are "similar enough" when adjusting priorities. 493static SimplifiedTypeClass getSimplifiedTypeClass(CanQualType T) { 494 switch (T->getTypeClass()) { 495 case Type::Builtin: 496 switch (cast<BuiltinType>(T)->getKind()) { 497 case BuiltinType::Void: 498 return STC_Void; 499 500 case BuiltinType::NullPtr: 501 return STC_Pointer; 502 503 case BuiltinType::Overload: 504 case BuiltinType::Dependent: 505 case BuiltinType::UndeducedAuto: 506 return STC_Other; 507 508 case BuiltinType::ObjCId: 509 case BuiltinType::ObjCClass: 510 case BuiltinType::ObjCSel: 511 return STC_ObjectiveC; 512 513 default: 514 return STC_Arithmetic; 515 } 516 return STC_Other; 517 518 case Type::Complex: 519 return STC_Arithmetic; 520 521 case Type::Pointer: 522 return STC_Pointer; 523 524 case Type::BlockPointer: 525 return STC_Block; 526 527 case Type::LValueReference: 528 case Type::RValueReference: 529 return getSimplifiedTypeClass(T->getAs<ReferenceType>()->getPointeeType()); 530 531 case Type::ConstantArray: 532 case Type::IncompleteArray: 533 case Type::VariableArray: 534 case Type::DependentSizedArray: 535 return STC_Array; 536 537 case Type::DependentSizedExtVector: 538 case Type::Vector: 539 case Type::ExtVector: 540 return STC_Arithmetic; 541 542 case Type::FunctionProto: 543 case Type::FunctionNoProto: 544 return STC_Function; 545 546 case Type::Record: 547 return STC_Record; 548 549 case Type::Enum: 550 return STC_Arithmetic; 551 552 case Type::ObjCObject: 553 case Type::ObjCInterface: 554 case Type::ObjCObjectPointer: 555 return STC_ObjectiveC; 556 557 default: 558 return STC_Other; 559 } 560} 561 562/// \brief Get the type that a given expression will have if this declaration 563/// is used as an expression in its "typical" code-completion form. 564static QualType getDeclUsageType(ASTContext &C, NamedDecl *ND) { 565 ND = cast<NamedDecl>(ND->getUnderlyingDecl()); 566 567 if (TypeDecl *Type = dyn_cast<TypeDecl>(ND)) 568 return C.getTypeDeclType(Type); 569 if (ObjCInterfaceDecl *Iface = dyn_cast<ObjCInterfaceDecl>(ND)) 570 return C.getObjCInterfaceType(Iface); 571 572 QualType T; 573 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) 574 T = Function->getCallResultType(); 575 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) 576 T = Method->getSendResultType(); 577 else if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) 578 T = FunTmpl->getTemplatedDecl()->getCallResultType(); 579 else if (EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND)) 580 T = C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext())); 581 else if (ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND)) 582 T = Property->getType(); 583 else if (ValueDecl *Value = dyn_cast<ValueDecl>(ND)) 584 T = Value->getType(); 585 else 586 return QualType(); 587 588 return T.getNonReferenceType(); 589} 590 591void ResultBuilder::AdjustResultPriorityForPreferredType(Result &R) { 592 QualType T = getDeclUsageType(SemaRef.Context, R.Declaration); 593 if (T.isNull()) 594 return; 595 596 CanQualType TC = SemaRef.Context.getCanonicalType(T); 597 // Check for exactly-matching types (modulo qualifiers). 598 if (SemaRef.Context.hasSameUnqualifiedType(PreferredType, TC)) 599 R.Priority /= CCF_ExactTypeMatch; 600 // Check for nearly-matching types, based on classification of each. 601 else if ((getSimplifiedTypeClass(PreferredType) 602 == getSimplifiedTypeClass(TC)) && 603 !(PreferredType->isEnumeralType() && TC->isEnumeralType())) 604 R.Priority /= CCF_SimilarTypeMatch; 605} 606 607void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) { 608 assert(!ShadowMaps.empty() && "Must enter into a results scope"); 609 610 if (R.Kind != Result::RK_Declaration) { 611 // For non-declaration results, just add the result. 612 Results.push_back(R); 613 return; 614 } 615 616 // Look through using declarations. 617 if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) { 618 MaybeAddResult(Result(Using->getTargetDecl(), R.Qualifier), CurContext); 619 return; 620 } 621 622 Decl *CanonDecl = R.Declaration->getCanonicalDecl(); 623 unsigned IDNS = CanonDecl->getIdentifierNamespace(); 624 625 bool AsNestedNameSpecifier = false; 626 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier)) 627 return; 628 629 ShadowMap &SMap = ShadowMaps.back(); 630 ShadowMapEntry::iterator I, IEnd; 631 ShadowMap::iterator NamePos = SMap.find(R.Declaration->getDeclName()); 632 if (NamePos != SMap.end()) { 633 I = NamePos->second.begin(); 634 IEnd = NamePos->second.end(); 635 } 636 637 for (; I != IEnd; ++I) { 638 NamedDecl *ND = I->first; 639 unsigned Index = I->second; 640 if (ND->getCanonicalDecl() == CanonDecl) { 641 // This is a redeclaration. Always pick the newer declaration. 642 Results[Index].Declaration = R.Declaration; 643 644 // We're done. 645 return; 646 } 647 } 648 649 // This is a new declaration in this scope. However, check whether this 650 // declaration name is hidden by a similarly-named declaration in an outer 651 // scope. 652 std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end(); 653 --SMEnd; 654 for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) { 655 ShadowMapEntry::iterator I, IEnd; 656 ShadowMap::iterator NamePos = SM->find(R.Declaration->getDeclName()); 657 if (NamePos != SM->end()) { 658 I = NamePos->second.begin(); 659 IEnd = NamePos->second.end(); 660 } 661 for (; I != IEnd; ++I) { 662 // A tag declaration does not hide a non-tag declaration. 663 if (I->first->hasTagIdentifierNamespace() && 664 (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary | 665 Decl::IDNS_ObjCProtocol))) 666 continue; 667 668 // Protocols are in distinct namespaces from everything else. 669 if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol) 670 || (IDNS & Decl::IDNS_ObjCProtocol)) && 671 I->first->getIdentifierNamespace() != IDNS) 672 continue; 673 674 // The newly-added result is hidden by an entry in the shadow map. 675 if (CheckHiddenResult(R, CurContext, I->first)) 676 return; 677 678 break; 679 } 680 } 681 682 // Make sure that any given declaration only shows up in the result set once. 683 if (!AllDeclsFound.insert(CanonDecl)) 684 return; 685 686 // If the filter is for nested-name-specifiers, then this result starts a 687 // nested-name-specifier. 688 if (AsNestedNameSpecifier) { 689 R.StartsNestedNameSpecifier = true; 690 R.Priority = CCP_NestedNameSpecifier; 691 } else if (!PreferredType.isNull()) 692 AdjustResultPriorityForPreferredType(R); 693 694 // If this result is supposed to have an informative qualifier, add one. 695 if (R.QualifierIsInformative && !R.Qualifier && 696 !R.StartsNestedNameSpecifier) { 697 DeclContext *Ctx = R.Declaration->getDeclContext(); 698 if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx)) 699 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, Namespace); 700 else if (TagDecl *Tag = dyn_cast<TagDecl>(Ctx)) 701 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, false, 702 SemaRef.Context.getTypeDeclType(Tag).getTypePtr()); 703 else 704 R.QualifierIsInformative = false; 705 } 706 707 // Insert this result into the set of results and into the current shadow 708 // map. 709 SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size()); 710 Results.push_back(R); 711} 712 713void ResultBuilder::AddResult(Result R, DeclContext *CurContext, 714 NamedDecl *Hiding, bool InBaseClass = false) { 715 if (R.Kind != Result::RK_Declaration) { 716 // For non-declaration results, just add the result. 717 Results.push_back(R); 718 return; 719 } 720 721 // Look through using declarations. 722 if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) { 723 AddResult(Result(Using->getTargetDecl(), R.Qualifier), CurContext, Hiding); 724 return; 725 } 726 727 bool AsNestedNameSpecifier = false; 728 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier)) 729 return; 730 731 if (Hiding && CheckHiddenResult(R, CurContext, Hiding)) 732 return; 733 734 // Make sure that any given declaration only shows up in the result set once. 735 if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl())) 736 return; 737 738 // If the filter is for nested-name-specifiers, then this result starts a 739 // nested-name-specifier. 740 if (AsNestedNameSpecifier) { 741 R.StartsNestedNameSpecifier = true; 742 R.Priority = CCP_NestedNameSpecifier; 743 } 744 else if (Filter == &ResultBuilder::IsMember && !R.Qualifier && InBaseClass && 745 isa<CXXRecordDecl>(R.Declaration->getDeclContext() 746 ->getLookupContext())) 747 R.QualifierIsInformative = true; 748 749 // If this result is supposed to have an informative qualifier, add one. 750 if (R.QualifierIsInformative && !R.Qualifier && 751 !R.StartsNestedNameSpecifier) { 752 DeclContext *Ctx = R.Declaration->getDeclContext(); 753 if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx)) 754 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, Namespace); 755 else if (TagDecl *Tag = dyn_cast<TagDecl>(Ctx)) 756 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, false, 757 SemaRef.Context.getTypeDeclType(Tag).getTypePtr()); 758 else 759 R.QualifierIsInformative = false; 760 } 761 762 // Adjust the priority if this result comes from a base class. 763 if (InBaseClass) 764 R.Priority += CCD_InBaseClass; 765 766 if (!PreferredType.isNull()) 767 AdjustResultPriorityForPreferredType(R); 768 769 // Insert this result into the set of results. 770 Results.push_back(R); 771} 772 773void ResultBuilder::AddResult(Result R) { 774 assert(R.Kind != Result::RK_Declaration && 775 "Declaration results need more context"); 776 Results.push_back(R); 777} 778 779/// \brief Enter into a new scope. 780void ResultBuilder::EnterNewScope() { 781 ShadowMaps.push_back(ShadowMap()); 782} 783 784/// \brief Exit from the current scope. 785void ResultBuilder::ExitScope() { 786 for (ShadowMap::iterator E = ShadowMaps.back().begin(), 787 EEnd = ShadowMaps.back().end(); 788 E != EEnd; 789 ++E) 790 E->second.Destroy(); 791 792 ShadowMaps.pop_back(); 793} 794 795/// \brief Determines whether this given declaration will be found by 796/// ordinary name lookup. 797bool ResultBuilder::IsOrdinaryName(NamedDecl *ND) const { 798 ND = cast<NamedDecl>(ND->getUnderlyingDecl()); 799 800 unsigned IDNS = Decl::IDNS_Ordinary; 801 if (SemaRef.getLangOptions().CPlusPlus) 802 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member; 803 else if (SemaRef.getLangOptions().ObjC1 && isa<ObjCIvarDecl>(ND)) 804 return true; 805 806 return ND->getIdentifierNamespace() & IDNS; 807} 808 809/// \brief Determines whether this given declaration will be found by 810/// ordinary name lookup but is not a type name. 811bool ResultBuilder::IsOrdinaryNonTypeName(NamedDecl *ND) const { 812 ND = cast<NamedDecl>(ND->getUnderlyingDecl()); 813 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) 814 return false; 815 816 unsigned IDNS = Decl::IDNS_Ordinary; 817 if (SemaRef.getLangOptions().CPlusPlus) 818 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member; 819 else if (SemaRef.getLangOptions().ObjC1 && isa<ObjCIvarDecl>(ND)) 820 return true; 821 822 return ND->getIdentifierNamespace() & IDNS; 823} 824 825bool ResultBuilder::IsIntegralConstantValue(NamedDecl *ND) const { 826 if (!IsOrdinaryNonTypeName(ND)) 827 return 0; 828 829 if (ValueDecl *VD = dyn_cast<ValueDecl>(ND->getUnderlyingDecl())) 830 if (VD->getType()->isIntegralOrEnumerationType()) 831 return true; 832 833 return false; 834} 835 836/// \brief Determines whether this given declaration will be found by 837/// ordinary name lookup. 838bool ResultBuilder::IsOrdinaryNonValueName(NamedDecl *ND) const { 839 ND = cast<NamedDecl>(ND->getUnderlyingDecl()); 840 841 unsigned IDNS = Decl::IDNS_Ordinary; 842 if (SemaRef.getLangOptions().CPlusPlus) 843 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace; 844 845 return (ND->getIdentifierNamespace() & IDNS) && 846 !isa<ValueDecl>(ND) && !isa<FunctionTemplateDecl>(ND) && 847 !isa<ObjCPropertyDecl>(ND); 848} 849 850/// \brief Determines whether the given declaration is suitable as the 851/// start of a C++ nested-name-specifier, e.g., a class or namespace. 852bool ResultBuilder::IsNestedNameSpecifier(NamedDecl *ND) const { 853 // Allow us to find class templates, too. 854 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND)) 855 ND = ClassTemplate->getTemplatedDecl(); 856 857 return SemaRef.isAcceptableNestedNameSpecifier(ND); 858} 859 860/// \brief Determines whether the given declaration is an enumeration. 861bool ResultBuilder::IsEnum(NamedDecl *ND) const { 862 return isa<EnumDecl>(ND); 863} 864 865/// \brief Determines whether the given declaration is a class or struct. 866bool ResultBuilder::IsClassOrStruct(NamedDecl *ND) const { 867 // Allow us to find class templates, too. 868 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND)) 869 ND = ClassTemplate->getTemplatedDecl(); 870 871 if (RecordDecl *RD = dyn_cast<RecordDecl>(ND)) 872 return RD->getTagKind() == TTK_Class || 873 RD->getTagKind() == TTK_Struct; 874 875 return false; 876} 877 878/// \brief Determines whether the given declaration is a union. 879bool ResultBuilder::IsUnion(NamedDecl *ND) const { 880 // Allow us to find class templates, too. 881 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND)) 882 ND = ClassTemplate->getTemplatedDecl(); 883 884 if (RecordDecl *RD = dyn_cast<RecordDecl>(ND)) 885 return RD->getTagKind() == TTK_Union; 886 887 return false; 888} 889 890/// \brief Determines whether the given declaration is a namespace. 891bool ResultBuilder::IsNamespace(NamedDecl *ND) const { 892 return isa<NamespaceDecl>(ND); 893} 894 895/// \brief Determines whether the given declaration is a namespace or 896/// namespace alias. 897bool ResultBuilder::IsNamespaceOrAlias(NamedDecl *ND) const { 898 return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND); 899} 900 901/// \brief Determines whether the given declaration is a type. 902bool ResultBuilder::IsType(NamedDecl *ND) const { 903 return isa<TypeDecl>(ND); 904} 905 906/// \brief Determines which members of a class should be visible via 907/// "." or "->". Only value declarations, nested name specifiers, and 908/// using declarations thereof should show up. 909bool ResultBuilder::IsMember(NamedDecl *ND) const { 910 if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(ND)) 911 ND = Using->getTargetDecl(); 912 913 return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) || 914 isa<ObjCPropertyDecl>(ND); 915} 916 917static bool isObjCReceiverType(ASTContext &C, QualType T) { 918 T = C.getCanonicalType(T); 919 switch (T->getTypeClass()) { 920 case Type::ObjCObject: 921 case Type::ObjCInterface: 922 case Type::ObjCObjectPointer: 923 return true; 924 925 case Type::Builtin: 926 switch (cast<BuiltinType>(T)->getKind()) { 927 case BuiltinType::ObjCId: 928 case BuiltinType::ObjCClass: 929 case BuiltinType::ObjCSel: 930 return true; 931 932 default: 933 break; 934 } 935 return false; 936 937 default: 938 break; 939 } 940 941 if (!C.getLangOptions().CPlusPlus) 942 return false; 943 944 // FIXME: We could perform more analysis here to determine whether a 945 // particular class type has any conversions to Objective-C types. For now, 946 // just accept all class types. 947 return T->isDependentType() || T->isRecordType(); 948} 949 950bool ResultBuilder::IsObjCMessageReceiver(NamedDecl *ND) const { 951 QualType T = getDeclUsageType(SemaRef.Context, ND); 952 if (T.isNull()) 953 return false; 954 955 T = SemaRef.Context.getBaseElementType(T); 956 return isObjCReceiverType(SemaRef.Context, T); 957} 958 959 960/// \rief Determines whether the given declaration is an Objective-C 961/// instance variable. 962bool ResultBuilder::IsObjCIvar(NamedDecl *ND) const { 963 return isa<ObjCIvarDecl>(ND); 964} 965 966namespace { 967 /// \brief Visible declaration consumer that adds a code-completion result 968 /// for each visible declaration. 969 class CodeCompletionDeclConsumer : public VisibleDeclConsumer { 970 ResultBuilder &Results; 971 DeclContext *CurContext; 972 973 public: 974 CodeCompletionDeclConsumer(ResultBuilder &Results, DeclContext *CurContext) 975 : Results(Results), CurContext(CurContext) { } 976 977 virtual void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, bool InBaseClass) { 978 Results.AddResult(ND, CurContext, Hiding, InBaseClass); 979 } 980 }; 981} 982 983/// \brief Add type specifiers for the current language as keyword results. 984static void AddTypeSpecifierResults(const LangOptions &LangOpts, 985 ResultBuilder &Results) { 986 typedef CodeCompleteConsumer::Result Result; 987 Results.AddResult(Result("short", CCP_Type)); 988 Results.AddResult(Result("long", CCP_Type)); 989 Results.AddResult(Result("signed", CCP_Type)); 990 Results.AddResult(Result("unsigned", CCP_Type)); 991 Results.AddResult(Result("void", CCP_Type)); 992 Results.AddResult(Result("char", CCP_Type)); 993 Results.AddResult(Result("int", CCP_Type)); 994 Results.AddResult(Result("float", CCP_Type)); 995 Results.AddResult(Result("double", CCP_Type)); 996 Results.AddResult(Result("enum", CCP_Type)); 997 Results.AddResult(Result("struct", CCP_Type)); 998 Results.AddResult(Result("union", CCP_Type)); 999 Results.AddResult(Result("const", CCP_Type)); 1000 Results.AddResult(Result("volatile", CCP_Type)); 1001 1002 if (LangOpts.C99) { 1003 // C99-specific 1004 Results.AddResult(Result("_Complex", CCP_Type)); 1005 Results.AddResult(Result("_Imaginary", CCP_Type)); 1006 Results.AddResult(Result("_Bool", CCP_Type)); 1007 Results.AddResult(Result("restrict", CCP_Type)); 1008 } 1009 1010 if (LangOpts.CPlusPlus) { 1011 // C++-specific 1012 Results.AddResult(Result("bool", CCP_Type)); 1013 Results.AddResult(Result("class", CCP_Type)); 1014 Results.AddResult(Result("wchar_t", CCP_Type)); 1015 1016 // typename qualified-id 1017 CodeCompletionString *Pattern = new CodeCompletionString; 1018 Pattern->AddTypedTextChunk("typename"); 1019 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1020 Pattern->AddPlaceholderChunk("qualifier"); 1021 Pattern->AddTextChunk("::"); 1022 Pattern->AddPlaceholderChunk("name"); 1023 Results.AddResult(Result(Pattern)); 1024 1025 if (LangOpts.CPlusPlus0x) { 1026 Results.AddResult(Result("auto", CCP_Type)); 1027 Results.AddResult(Result("char16_t", CCP_Type)); 1028 Results.AddResult(Result("char32_t", CCP_Type)); 1029 1030 CodeCompletionString *Pattern = new CodeCompletionString; 1031 Pattern->AddTypedTextChunk("decltype"); 1032 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1033 Pattern->AddPlaceholderChunk("expression"); 1034 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1035 Results.AddResult(Result(Pattern)); 1036 } 1037 } 1038 1039 // GNU extensions 1040 if (LangOpts.GNUMode) { 1041 // FIXME: Enable when we actually support decimal floating point. 1042 // Results.AddResult(Result("_Decimal32")); 1043 // Results.AddResult(Result("_Decimal64")); 1044 // Results.AddResult(Result("_Decimal128")); 1045 1046 CodeCompletionString *Pattern = new CodeCompletionString; 1047 Pattern->AddTypedTextChunk("typeof"); 1048 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1049 Pattern->AddPlaceholderChunk("expression"); 1050 Results.AddResult(Result(Pattern)); 1051 1052 Pattern = new CodeCompletionString; 1053 Pattern->AddTypedTextChunk("typeof"); 1054 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1055 Pattern->AddPlaceholderChunk("type"); 1056 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1057 Results.AddResult(Result(Pattern)); 1058 } 1059} 1060 1061static void AddStorageSpecifiers(Action::CodeCompletionContext CCC, 1062 const LangOptions &LangOpts, 1063 ResultBuilder &Results) { 1064 typedef CodeCompleteConsumer::Result Result; 1065 // Note: we don't suggest either "auto" or "register", because both 1066 // are pointless as storage specifiers. Elsewhere, we suggest "auto" 1067 // in C++0x as a type specifier. 1068 Results.AddResult(Result("extern")); 1069 Results.AddResult(Result("static")); 1070} 1071 1072static void AddFunctionSpecifiers(Action::CodeCompletionContext CCC, 1073 const LangOptions &LangOpts, 1074 ResultBuilder &Results) { 1075 typedef CodeCompleteConsumer::Result Result; 1076 switch (CCC) { 1077 case Action::CCC_Class: 1078 case Action::CCC_MemberTemplate: 1079 if (LangOpts.CPlusPlus) { 1080 Results.AddResult(Result("explicit")); 1081 Results.AddResult(Result("friend")); 1082 Results.AddResult(Result("mutable")); 1083 Results.AddResult(Result("virtual")); 1084 } 1085 // Fall through 1086 1087 case Action::CCC_ObjCInterface: 1088 case Action::CCC_ObjCImplementation: 1089 case Action::CCC_Namespace: 1090 case Action::CCC_Template: 1091 if (LangOpts.CPlusPlus || LangOpts.C99) 1092 Results.AddResult(Result("inline")); 1093 break; 1094 1095 case Action::CCC_ObjCInstanceVariableList: 1096 case Action::CCC_Expression: 1097 case Action::CCC_Statement: 1098 case Action::CCC_ForInit: 1099 case Action::CCC_Condition: 1100 case Action::CCC_RecoveryInFunction: 1101 break; 1102 } 1103} 1104 1105static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt); 1106static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt); 1107static void AddObjCVisibilityResults(const LangOptions &LangOpts, 1108 ResultBuilder &Results, 1109 bool NeedAt); 1110static void AddObjCImplementationResults(const LangOptions &LangOpts, 1111 ResultBuilder &Results, 1112 bool NeedAt); 1113static void AddObjCInterfaceResults(const LangOptions &LangOpts, 1114 ResultBuilder &Results, 1115 bool NeedAt); 1116static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt); 1117 1118static void AddTypedefResult(ResultBuilder &Results) { 1119 CodeCompletionString *Pattern = new CodeCompletionString; 1120 Pattern->AddTypedTextChunk("typedef"); 1121 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1122 Pattern->AddPlaceholderChunk("type"); 1123 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1124 Pattern->AddPlaceholderChunk("name"); 1125 Results.AddResult(CodeCompleteConsumer::Result(Pattern)); 1126} 1127 1128static bool WantTypesInContext(Action::CodeCompletionContext CCC, 1129 const LangOptions &LangOpts) { 1130 if (LangOpts.CPlusPlus) 1131 return true; 1132 1133 switch (CCC) { 1134 case Action::CCC_Namespace: 1135 case Action::CCC_Class: 1136 case Action::CCC_ObjCInstanceVariableList: 1137 case Action::CCC_Template: 1138 case Action::CCC_MemberTemplate: 1139 case Action::CCC_Statement: 1140 case Action::CCC_RecoveryInFunction: 1141 return true; 1142 1143 case Action::CCC_ObjCInterface: 1144 case Action::CCC_ObjCImplementation: 1145 case Action::CCC_Expression: 1146 case Action::CCC_Condition: 1147 return false; 1148 1149 case Action::CCC_ForInit: 1150 return LangOpts.ObjC1 || LangOpts.C99; 1151 } 1152 1153 return false; 1154} 1155 1156/// \brief Add language constructs that show up for "ordinary" names. 1157static void AddOrdinaryNameResults(Action::CodeCompletionContext CCC, 1158 Scope *S, 1159 Sema &SemaRef, 1160 ResultBuilder &Results) { 1161 typedef CodeCompleteConsumer::Result Result; 1162 switch (CCC) { 1163 case Action::CCC_Namespace: 1164 if (SemaRef.getLangOptions().CPlusPlus) { 1165 CodeCompletionString *Pattern = 0; 1166 1167 if (Results.includeCodePatterns()) { 1168 // namespace <identifier> { declarations } 1169 CodeCompletionString *Pattern = new CodeCompletionString; 1170 Pattern->AddTypedTextChunk("namespace"); 1171 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1172 Pattern->AddPlaceholderChunk("identifier"); 1173 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 1174 Pattern->AddPlaceholderChunk("declarations"); 1175 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 1176 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 1177 Results.AddResult(Result(Pattern)); 1178 } 1179 1180 // namespace identifier = identifier ; 1181 Pattern = new CodeCompletionString; 1182 Pattern->AddTypedTextChunk("namespace"); 1183 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1184 Pattern->AddPlaceholderChunk("name"); 1185 Pattern->AddChunk(CodeCompletionString::CK_Equal); 1186 Pattern->AddPlaceholderChunk("namespace"); 1187 Results.AddResult(Result(Pattern)); 1188 1189 // Using directives 1190 Pattern = new CodeCompletionString; 1191 Pattern->AddTypedTextChunk("using"); 1192 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1193 Pattern->AddTextChunk("namespace"); 1194 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1195 Pattern->AddPlaceholderChunk("identifier"); 1196 Results.AddResult(Result(Pattern)); 1197 1198 // asm(string-literal) 1199 Pattern = new CodeCompletionString; 1200 Pattern->AddTypedTextChunk("asm"); 1201 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1202 Pattern->AddPlaceholderChunk("string-literal"); 1203 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1204 Results.AddResult(Result(Pattern)); 1205 1206 if (Results.includeCodePatterns()) { 1207 // Explicit template instantiation 1208 Pattern = new CodeCompletionString; 1209 Pattern->AddTypedTextChunk("template"); 1210 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1211 Pattern->AddPlaceholderChunk("declaration"); 1212 Results.AddResult(Result(Pattern)); 1213 } 1214 } 1215 1216 if (SemaRef.getLangOptions().ObjC1) 1217 AddObjCTopLevelResults(Results, true); 1218 1219 AddTypedefResult(Results); 1220 // Fall through 1221 1222 case Action::CCC_Class: 1223 if (SemaRef.getLangOptions().CPlusPlus) { 1224 // Using declaration 1225 CodeCompletionString *Pattern = new CodeCompletionString; 1226 Pattern->AddTypedTextChunk("using"); 1227 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1228 Pattern->AddPlaceholderChunk("qualifier"); 1229 Pattern->AddTextChunk("::"); 1230 Pattern->AddPlaceholderChunk("name"); 1231 Results.AddResult(Result(Pattern)); 1232 1233 // using typename qualifier::name (only in a dependent context) 1234 if (SemaRef.CurContext->isDependentContext()) { 1235 Pattern = new CodeCompletionString; 1236 Pattern->AddTypedTextChunk("using"); 1237 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1238 Pattern->AddTextChunk("typename"); 1239 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1240 Pattern->AddPlaceholderChunk("qualifier"); 1241 Pattern->AddTextChunk("::"); 1242 Pattern->AddPlaceholderChunk("name"); 1243 Results.AddResult(Result(Pattern)); 1244 } 1245 1246 if (CCC == Action::CCC_Class) { 1247 AddTypedefResult(Results); 1248 1249 // public: 1250 Pattern = new CodeCompletionString; 1251 Pattern->AddTypedTextChunk("public"); 1252 Pattern->AddChunk(CodeCompletionString::CK_Colon); 1253 Results.AddResult(Result(Pattern)); 1254 1255 // protected: 1256 Pattern = new CodeCompletionString; 1257 Pattern->AddTypedTextChunk("protected"); 1258 Pattern->AddChunk(CodeCompletionString::CK_Colon); 1259 Results.AddResult(Result(Pattern)); 1260 1261 // private: 1262 Pattern = new CodeCompletionString; 1263 Pattern->AddTypedTextChunk("private"); 1264 Pattern->AddChunk(CodeCompletionString::CK_Colon); 1265 Results.AddResult(Result(Pattern)); 1266 } 1267 } 1268 // Fall through 1269 1270 case Action::CCC_Template: 1271 case Action::CCC_MemberTemplate: 1272 if (SemaRef.getLangOptions().CPlusPlus && Results.includeCodePatterns()) { 1273 // template < parameters > 1274 CodeCompletionString *Pattern = new CodeCompletionString; 1275 Pattern->AddTypedTextChunk("template"); 1276 Pattern->AddChunk(CodeCompletionString::CK_LeftAngle); 1277 Pattern->AddPlaceholderChunk("parameters"); 1278 Pattern->AddChunk(CodeCompletionString::CK_RightAngle); 1279 Results.AddResult(Result(Pattern)); 1280 } 1281 1282 AddStorageSpecifiers(CCC, SemaRef.getLangOptions(), Results); 1283 AddFunctionSpecifiers(CCC, SemaRef.getLangOptions(), Results); 1284 break; 1285 1286 case Action::CCC_ObjCInterface: 1287 AddObjCInterfaceResults(SemaRef.getLangOptions(), Results, true); 1288 AddStorageSpecifiers(CCC, SemaRef.getLangOptions(), Results); 1289 AddFunctionSpecifiers(CCC, SemaRef.getLangOptions(), Results); 1290 break; 1291 1292 case Action::CCC_ObjCImplementation: 1293 AddObjCImplementationResults(SemaRef.getLangOptions(), Results, true); 1294 AddStorageSpecifiers(CCC, SemaRef.getLangOptions(), Results); 1295 AddFunctionSpecifiers(CCC, SemaRef.getLangOptions(), Results); 1296 break; 1297 1298 case Action::CCC_ObjCInstanceVariableList: 1299 AddObjCVisibilityResults(SemaRef.getLangOptions(), Results, true); 1300 break; 1301 1302 case Action::CCC_RecoveryInFunction: 1303 case Action::CCC_Statement: { 1304 AddTypedefResult(Results); 1305 1306 CodeCompletionString *Pattern = 0; 1307 if (SemaRef.getLangOptions().CPlusPlus && Results.includeCodePatterns()) { 1308 Pattern = new CodeCompletionString; 1309 Pattern->AddTypedTextChunk("try"); 1310 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 1311 Pattern->AddPlaceholderChunk("statements"); 1312 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 1313 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 1314 Pattern->AddTextChunk("catch"); 1315 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1316 Pattern->AddPlaceholderChunk("declaration"); 1317 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1318 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 1319 Pattern->AddPlaceholderChunk("statements"); 1320 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 1321 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 1322 Results.AddResult(Result(Pattern)); 1323 } 1324 if (SemaRef.getLangOptions().ObjC1) 1325 AddObjCStatementResults(Results, true); 1326 1327 if (Results.includeCodePatterns()) { 1328 // if (condition) { statements } 1329 Pattern = new CodeCompletionString; 1330 Pattern->AddTypedTextChunk("if"); 1331 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1332 if (SemaRef.getLangOptions().CPlusPlus) 1333 Pattern->AddPlaceholderChunk("condition"); 1334 else 1335 Pattern->AddPlaceholderChunk("expression"); 1336 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1337 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 1338 Pattern->AddPlaceholderChunk("statements"); 1339 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 1340 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 1341 Results.AddResult(Result(Pattern)); 1342 1343 // switch (condition) { } 1344 Pattern = new CodeCompletionString; 1345 Pattern->AddTypedTextChunk("switch"); 1346 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1347 if (SemaRef.getLangOptions().CPlusPlus) 1348 Pattern->AddPlaceholderChunk("condition"); 1349 else 1350 Pattern->AddPlaceholderChunk("expression"); 1351 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1352 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 1353 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 1354 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 1355 Results.AddResult(Result(Pattern)); 1356 } 1357 1358 // Switch-specific statements. 1359 if (!SemaRef.getSwitchStack().empty()) { 1360 // case expression: 1361 Pattern = new CodeCompletionString; 1362 Pattern->AddTypedTextChunk("case"); 1363 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1364 Pattern->AddPlaceholderChunk("expression"); 1365 Pattern->AddChunk(CodeCompletionString::CK_Colon); 1366 Results.AddResult(Result(Pattern)); 1367 1368 // default: 1369 Pattern = new CodeCompletionString; 1370 Pattern->AddTypedTextChunk("default"); 1371 Pattern->AddChunk(CodeCompletionString::CK_Colon); 1372 Results.AddResult(Result(Pattern)); 1373 } 1374 1375 if (Results.includeCodePatterns()) { 1376 /// while (condition) { statements } 1377 Pattern = new CodeCompletionString; 1378 Pattern->AddTypedTextChunk("while"); 1379 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1380 if (SemaRef.getLangOptions().CPlusPlus) 1381 Pattern->AddPlaceholderChunk("condition"); 1382 else 1383 Pattern->AddPlaceholderChunk("expression"); 1384 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1385 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 1386 Pattern->AddPlaceholderChunk("statements"); 1387 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 1388 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 1389 Results.AddResult(Result(Pattern)); 1390 1391 // do { statements } while ( expression ); 1392 Pattern = new CodeCompletionString; 1393 Pattern->AddTypedTextChunk("do"); 1394 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 1395 Pattern->AddPlaceholderChunk("statements"); 1396 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 1397 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 1398 Pattern->AddTextChunk("while"); 1399 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1400 Pattern->AddPlaceholderChunk("expression"); 1401 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1402 Results.AddResult(Result(Pattern)); 1403 1404 // for ( for-init-statement ; condition ; expression ) { statements } 1405 Pattern = new CodeCompletionString; 1406 Pattern->AddTypedTextChunk("for"); 1407 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1408 if (SemaRef.getLangOptions().CPlusPlus || SemaRef.getLangOptions().C99) 1409 Pattern->AddPlaceholderChunk("init-statement"); 1410 else 1411 Pattern->AddPlaceholderChunk("init-expression"); 1412 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 1413 Pattern->AddPlaceholderChunk("condition"); 1414 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 1415 Pattern->AddPlaceholderChunk("inc-expression"); 1416 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1417 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 1418 Pattern->AddPlaceholderChunk("statements"); 1419 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 1420 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 1421 Results.AddResult(Result(Pattern)); 1422 } 1423 1424 if (S->getContinueParent()) { 1425 // continue ; 1426 Pattern = new CodeCompletionString; 1427 Pattern->AddTypedTextChunk("continue"); 1428 Results.AddResult(Result(Pattern)); 1429 } 1430 1431 if (S->getBreakParent()) { 1432 // break ; 1433 Pattern = new CodeCompletionString; 1434 Pattern->AddTypedTextChunk("break"); 1435 Results.AddResult(Result(Pattern)); 1436 } 1437 1438 // "return expression ;" or "return ;", depending on whether we 1439 // know the function is void or not. 1440 bool isVoid = false; 1441 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext)) 1442 isVoid = Function->getResultType()->isVoidType(); 1443 else if (ObjCMethodDecl *Method 1444 = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext)) 1445 isVoid = Method->getResultType()->isVoidType(); 1446 else if (SemaRef.getCurBlock() && 1447 !SemaRef.getCurBlock()->ReturnType.isNull()) 1448 isVoid = SemaRef.getCurBlock()->ReturnType->isVoidType(); 1449 Pattern = new CodeCompletionString; 1450 Pattern->AddTypedTextChunk("return"); 1451 if (!isVoid) { 1452 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1453 Pattern->AddPlaceholderChunk("expression"); 1454 } 1455 Results.AddResult(Result(Pattern)); 1456 1457 // goto identifier ; 1458 Pattern = new CodeCompletionString; 1459 Pattern->AddTypedTextChunk("goto"); 1460 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1461 Pattern->AddPlaceholderChunk("label"); 1462 Results.AddResult(Result(Pattern)); 1463 1464 // Using directives 1465 Pattern = new CodeCompletionString; 1466 Pattern->AddTypedTextChunk("using"); 1467 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1468 Pattern->AddTextChunk("namespace"); 1469 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1470 Pattern->AddPlaceholderChunk("identifier"); 1471 Results.AddResult(Result(Pattern)); 1472 } 1473 1474 // Fall through (for statement expressions). 1475 case Action::CCC_ForInit: 1476 case Action::CCC_Condition: 1477 AddStorageSpecifiers(CCC, SemaRef.getLangOptions(), Results); 1478 // Fall through: conditions and statements can have expressions. 1479 1480 case Action::CCC_Expression: { 1481 CodeCompletionString *Pattern = 0; 1482 if (SemaRef.getLangOptions().CPlusPlus) { 1483 // 'this', if we're in a non-static member function. 1484 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(SemaRef.CurContext)) 1485 if (!Method->isStatic()) 1486 Results.AddResult(Result("this")); 1487 1488 // true, false 1489 Results.AddResult(Result("true")); 1490 Results.AddResult(Result("false")); 1491 1492 // dynamic_cast < type-id > ( expression ) 1493 Pattern = new CodeCompletionString; 1494 Pattern->AddTypedTextChunk("dynamic_cast"); 1495 Pattern->AddChunk(CodeCompletionString::CK_LeftAngle); 1496 Pattern->AddPlaceholderChunk("type"); 1497 Pattern->AddChunk(CodeCompletionString::CK_RightAngle); 1498 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1499 Pattern->AddPlaceholderChunk("expression"); 1500 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1501 Results.AddResult(Result(Pattern)); 1502 1503 // static_cast < type-id > ( expression ) 1504 Pattern = new CodeCompletionString; 1505 Pattern->AddTypedTextChunk("static_cast"); 1506 Pattern->AddChunk(CodeCompletionString::CK_LeftAngle); 1507 Pattern->AddPlaceholderChunk("type"); 1508 Pattern->AddChunk(CodeCompletionString::CK_RightAngle); 1509 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1510 Pattern->AddPlaceholderChunk("expression"); 1511 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1512 Results.AddResult(Result(Pattern)); 1513 1514 // reinterpret_cast < type-id > ( expression ) 1515 Pattern = new CodeCompletionString; 1516 Pattern->AddTypedTextChunk("reinterpret_cast"); 1517 Pattern->AddChunk(CodeCompletionString::CK_LeftAngle); 1518 Pattern->AddPlaceholderChunk("type"); 1519 Pattern->AddChunk(CodeCompletionString::CK_RightAngle); 1520 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1521 Pattern->AddPlaceholderChunk("expression"); 1522 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1523 Results.AddResult(Result(Pattern)); 1524 1525 // const_cast < type-id > ( expression ) 1526 Pattern = new CodeCompletionString; 1527 Pattern->AddTypedTextChunk("const_cast"); 1528 Pattern->AddChunk(CodeCompletionString::CK_LeftAngle); 1529 Pattern->AddPlaceholderChunk("type"); 1530 Pattern->AddChunk(CodeCompletionString::CK_RightAngle); 1531 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1532 Pattern->AddPlaceholderChunk("expression"); 1533 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1534 Results.AddResult(Result(Pattern)); 1535 1536 // typeid ( expression-or-type ) 1537 Pattern = new CodeCompletionString; 1538 Pattern->AddTypedTextChunk("typeid"); 1539 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1540 Pattern->AddPlaceholderChunk("expression-or-type"); 1541 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1542 Results.AddResult(Result(Pattern)); 1543 1544 // new T ( ... ) 1545 Pattern = new CodeCompletionString; 1546 Pattern->AddTypedTextChunk("new"); 1547 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1548 Pattern->AddPlaceholderChunk("type"); 1549 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1550 Pattern->AddPlaceholderChunk("expressions"); 1551 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1552 Results.AddResult(Result(Pattern)); 1553 1554 // new T [ ] ( ... ) 1555 Pattern = new CodeCompletionString; 1556 Pattern->AddTypedTextChunk("new"); 1557 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1558 Pattern->AddPlaceholderChunk("type"); 1559 Pattern->AddChunk(CodeCompletionString::CK_LeftBracket); 1560 Pattern->AddPlaceholderChunk("size"); 1561 Pattern->AddChunk(CodeCompletionString::CK_RightBracket); 1562 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1563 Pattern->AddPlaceholderChunk("expressions"); 1564 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1565 Results.AddResult(Result(Pattern)); 1566 1567 // delete expression 1568 Pattern = new CodeCompletionString; 1569 Pattern->AddTypedTextChunk("delete"); 1570 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1571 Pattern->AddPlaceholderChunk("expression"); 1572 Results.AddResult(Result(Pattern)); 1573 1574 // delete [] expression 1575 Pattern = new CodeCompletionString; 1576 Pattern->AddTypedTextChunk("delete"); 1577 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1578 Pattern->AddChunk(CodeCompletionString::CK_LeftBracket); 1579 Pattern->AddChunk(CodeCompletionString::CK_RightBracket); 1580 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1581 Pattern->AddPlaceholderChunk("expression"); 1582 Results.AddResult(Result(Pattern)); 1583 1584 // throw expression 1585 Pattern = new CodeCompletionString; 1586 Pattern->AddTypedTextChunk("throw"); 1587 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1588 Pattern->AddPlaceholderChunk("expression"); 1589 Results.AddResult(Result(Pattern)); 1590 1591 // FIXME: Rethrow? 1592 } 1593 1594 if (SemaRef.getLangOptions().ObjC1) { 1595 // Add "super", if we're in an Objective-C class with a superclass. 1596 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) { 1597 // The interface can be NULL. 1598 if (ObjCInterfaceDecl *ID = Method->getClassInterface()) 1599 if (ID->getSuperClass()) 1600 Results.AddResult(Result("super")); 1601 } 1602 1603 AddObjCExpressionResults(Results, true); 1604 } 1605 1606 // sizeof expression 1607 Pattern = new CodeCompletionString; 1608 Pattern->AddTypedTextChunk("sizeof"); 1609 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1610 Pattern->AddPlaceholderChunk("expression-or-type"); 1611 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1612 Results.AddResult(Result(Pattern)); 1613 break; 1614 } 1615 } 1616 1617 if (WantTypesInContext(CCC, SemaRef.getLangOptions())) 1618 AddTypeSpecifierResults(SemaRef.getLangOptions(), Results); 1619 1620 if (SemaRef.getLangOptions().CPlusPlus) 1621 Results.AddResult(Result("operator")); 1622} 1623 1624/// \brief If the given declaration has an associated type, add it as a result 1625/// type chunk. 1626static void AddResultTypeChunk(ASTContext &Context, 1627 NamedDecl *ND, 1628 CodeCompletionString *Result) { 1629 if (!ND) 1630 return; 1631 1632 // Determine the type of the declaration (if it has a type). 1633 QualType T; 1634 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) 1635 T = Function->getResultType(); 1636 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) 1637 T = Method->getResultType(); 1638 else if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) 1639 T = FunTmpl->getTemplatedDecl()->getResultType(); 1640 else if (EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND)) 1641 T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext())); 1642 else if (isa<UnresolvedUsingValueDecl>(ND)) { 1643 /* Do nothing: ignore unresolved using declarations*/ 1644 } else if (ValueDecl *Value = dyn_cast<ValueDecl>(ND)) 1645 T = Value->getType(); 1646 else if (ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND)) 1647 T = Property->getType(); 1648 1649 if (T.isNull() || Context.hasSameType(T, Context.DependentTy)) 1650 return; 1651 1652 PrintingPolicy Policy(Context.PrintingPolicy); 1653 Policy.AnonymousTagLocations = false; 1654 1655 std::string TypeStr; 1656 T.getAsStringInternal(TypeStr, Policy); 1657 Result->AddResultTypeChunk(TypeStr); 1658} 1659 1660/// \brief Add function parameter chunks to the given code completion string. 1661static void AddFunctionParameterChunks(ASTContext &Context, 1662 FunctionDecl *Function, 1663 CodeCompletionString *Result) { 1664 typedef CodeCompletionString::Chunk Chunk; 1665 1666 CodeCompletionString *CCStr = Result; 1667 1668 for (unsigned P = 0, N = Function->getNumParams(); P != N; ++P) { 1669 ParmVarDecl *Param = Function->getParamDecl(P); 1670 1671 if (Param->hasDefaultArg()) { 1672 // When we see an optional default argument, put that argument and 1673 // the remaining default arguments into a new, optional string. 1674 CodeCompletionString *Opt = new CodeCompletionString; 1675 CCStr->AddOptionalChunk(std::auto_ptr<CodeCompletionString>(Opt)); 1676 CCStr = Opt; 1677 } 1678 1679 if (P != 0) 1680 CCStr->AddChunk(Chunk(CodeCompletionString::CK_Comma)); 1681 1682 // Format the placeholder string. 1683 std::string PlaceholderStr; 1684 if (Param->getIdentifier()) 1685 PlaceholderStr = Param->getIdentifier()->getName(); 1686 1687 Param->getType().getAsStringInternal(PlaceholderStr, 1688 Context.PrintingPolicy); 1689 1690 // Add the placeholder string. 1691 CCStr->AddPlaceholderChunk(PlaceholderStr); 1692 } 1693 1694 if (const FunctionProtoType *Proto 1695 = Function->getType()->getAs<FunctionProtoType>()) 1696 if (Proto->isVariadic()) 1697 CCStr->AddPlaceholderChunk(", ..."); 1698} 1699 1700/// \brief Add template parameter chunks to the given code completion string. 1701static void AddTemplateParameterChunks(ASTContext &Context, 1702 TemplateDecl *Template, 1703 CodeCompletionString *Result, 1704 unsigned MaxParameters = 0) { 1705 typedef CodeCompletionString::Chunk Chunk; 1706 1707 CodeCompletionString *CCStr = Result; 1708 bool FirstParameter = true; 1709 1710 TemplateParameterList *Params = Template->getTemplateParameters(); 1711 TemplateParameterList::iterator PEnd = Params->end(); 1712 if (MaxParameters) 1713 PEnd = Params->begin() + MaxParameters; 1714 for (TemplateParameterList::iterator P = Params->begin(); P != PEnd; ++P) { 1715 bool HasDefaultArg = false; 1716 std::string PlaceholderStr; 1717 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) { 1718 if (TTP->wasDeclaredWithTypename()) 1719 PlaceholderStr = "typename"; 1720 else 1721 PlaceholderStr = "class"; 1722 1723 if (TTP->getIdentifier()) { 1724 PlaceholderStr += ' '; 1725 PlaceholderStr += TTP->getIdentifier()->getName(); 1726 } 1727 1728 HasDefaultArg = TTP->hasDefaultArgument(); 1729 } else if (NonTypeTemplateParmDecl *NTTP 1730 = dyn_cast<NonTypeTemplateParmDecl>(*P)) { 1731 if (NTTP->getIdentifier()) 1732 PlaceholderStr = NTTP->getIdentifier()->getName(); 1733 NTTP->getType().getAsStringInternal(PlaceholderStr, 1734 Context.PrintingPolicy); 1735 HasDefaultArg = NTTP->hasDefaultArgument(); 1736 } else { 1737 assert(isa<TemplateTemplateParmDecl>(*P)); 1738 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P); 1739 1740 // Since putting the template argument list into the placeholder would 1741 // be very, very long, we just use an abbreviation. 1742 PlaceholderStr = "template<...> class"; 1743 if (TTP->getIdentifier()) { 1744 PlaceholderStr += ' '; 1745 PlaceholderStr += TTP->getIdentifier()->getName(); 1746 } 1747 1748 HasDefaultArg = TTP->hasDefaultArgument(); 1749 } 1750 1751 if (HasDefaultArg) { 1752 // When we see an optional default argument, put that argument and 1753 // the remaining default arguments into a new, optional string. 1754 CodeCompletionString *Opt = new CodeCompletionString; 1755 CCStr->AddOptionalChunk(std::auto_ptr<CodeCompletionString>(Opt)); 1756 CCStr = Opt; 1757 } 1758 1759 if (FirstParameter) 1760 FirstParameter = false; 1761 else 1762 CCStr->AddChunk(Chunk(CodeCompletionString::CK_Comma)); 1763 1764 // Add the placeholder string. 1765 CCStr->AddPlaceholderChunk(PlaceholderStr); 1766 } 1767} 1768 1769/// \brief Add a qualifier to the given code-completion string, if the 1770/// provided nested-name-specifier is non-NULL. 1771static void 1772AddQualifierToCompletionString(CodeCompletionString *Result, 1773 NestedNameSpecifier *Qualifier, 1774 bool QualifierIsInformative, 1775 ASTContext &Context) { 1776 if (!Qualifier) 1777 return; 1778 1779 std::string PrintedNNS; 1780 { 1781 llvm::raw_string_ostream OS(PrintedNNS); 1782 Qualifier->print(OS, Context.PrintingPolicy); 1783 } 1784 if (QualifierIsInformative) 1785 Result->AddInformativeChunk(PrintedNNS); 1786 else 1787 Result->AddTextChunk(PrintedNNS); 1788} 1789 1790static void AddFunctionTypeQualsToCompletionString(CodeCompletionString *Result, 1791 FunctionDecl *Function) { 1792 const FunctionProtoType *Proto 1793 = Function->getType()->getAs<FunctionProtoType>(); 1794 if (!Proto || !Proto->getTypeQuals()) 1795 return; 1796 1797 std::string QualsStr; 1798 if (Proto->getTypeQuals() & Qualifiers::Const) 1799 QualsStr += " const"; 1800 if (Proto->getTypeQuals() & Qualifiers::Volatile) 1801 QualsStr += " volatile"; 1802 if (Proto->getTypeQuals() & Qualifiers::Restrict) 1803 QualsStr += " restrict"; 1804 Result->AddInformativeChunk(QualsStr); 1805} 1806 1807/// \brief If possible, create a new code completion string for the given 1808/// result. 1809/// 1810/// \returns Either a new, heap-allocated code completion string describing 1811/// how to use this result, or NULL to indicate that the string or name of the 1812/// result is all that is needed. 1813CodeCompletionString * 1814CodeCompleteConsumer::Result::CreateCodeCompletionString(Sema &S) { 1815 typedef CodeCompletionString::Chunk Chunk; 1816 1817 if (Kind == RK_Pattern) 1818 return Pattern->Clone(); 1819 1820 CodeCompletionString *Result = new CodeCompletionString; 1821 1822 if (Kind == RK_Keyword) { 1823 Result->AddTypedTextChunk(Keyword); 1824 return Result; 1825 } 1826 1827 if (Kind == RK_Macro) { 1828 MacroInfo *MI = S.PP.getMacroInfo(Macro); 1829 assert(MI && "Not a macro?"); 1830 1831 Result->AddTypedTextChunk(Macro->getName()); 1832 1833 if (!MI->isFunctionLike()) 1834 return Result; 1835 1836 // Format a function-like macro with placeholders for the arguments. 1837 Result->AddChunk(Chunk(CodeCompletionString::CK_LeftParen)); 1838 for (MacroInfo::arg_iterator A = MI->arg_begin(), AEnd = MI->arg_end(); 1839 A != AEnd; ++A) { 1840 if (A != MI->arg_begin()) 1841 Result->AddChunk(Chunk(CodeCompletionString::CK_Comma)); 1842 1843 if (!MI->isVariadic() || A != AEnd - 1) { 1844 // Non-variadic argument. 1845 Result->AddPlaceholderChunk((*A)->getName()); 1846 continue; 1847 } 1848 1849 // Variadic argument; cope with the different between GNU and C99 1850 // variadic macros, providing a single placeholder for the rest of the 1851 // arguments. 1852 if ((*A)->isStr("__VA_ARGS__")) 1853 Result->AddPlaceholderChunk("..."); 1854 else { 1855 std::string Arg = (*A)->getName(); 1856 Arg += "..."; 1857 Result->AddPlaceholderChunk(Arg); 1858 } 1859 } 1860 Result->AddChunk(Chunk(CodeCompletionString::CK_RightParen)); 1861 return Result; 1862 } 1863 1864 assert(Kind == RK_Declaration && "Missed a result kind?"); 1865 NamedDecl *ND = Declaration; 1866 1867 if (StartsNestedNameSpecifier) { 1868 Result->AddTypedTextChunk(ND->getNameAsString()); 1869 Result->AddTextChunk("::"); 1870 return Result; 1871 } 1872 1873 AddResultTypeChunk(S.Context, ND, Result); 1874 1875 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) { 1876 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, 1877 S.Context); 1878 Result->AddTypedTextChunk(Function->getNameAsString()); 1879 Result->AddChunk(Chunk(CodeCompletionString::CK_LeftParen)); 1880 AddFunctionParameterChunks(S.Context, Function, Result); 1881 Result->AddChunk(Chunk(CodeCompletionString::CK_RightParen)); 1882 AddFunctionTypeQualsToCompletionString(Result, Function); 1883 return Result; 1884 } 1885 1886 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) { 1887 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, 1888 S.Context); 1889 FunctionDecl *Function = FunTmpl->getTemplatedDecl(); 1890 Result->AddTypedTextChunk(Function->getNameAsString()); 1891 1892 // Figure out which template parameters are deduced (or have default 1893 // arguments). 1894 llvm::SmallVector<bool, 16> Deduced; 1895 S.MarkDeducedTemplateParameters(FunTmpl, Deduced); 1896 unsigned LastDeducibleArgument; 1897 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0; 1898 --LastDeducibleArgument) { 1899 if (!Deduced[LastDeducibleArgument - 1]) { 1900 // C++0x: Figure out if the template argument has a default. If so, 1901 // the user doesn't need to type this argument. 1902 // FIXME: We need to abstract template parameters better! 1903 bool HasDefaultArg = false; 1904 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam( 1905 LastDeducibleArgument - 1); 1906 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) 1907 HasDefaultArg = TTP->hasDefaultArgument(); 1908 else if (NonTypeTemplateParmDecl *NTTP 1909 = dyn_cast<NonTypeTemplateParmDecl>(Param)) 1910 HasDefaultArg = NTTP->hasDefaultArgument(); 1911 else { 1912 assert(isa<TemplateTemplateParmDecl>(Param)); 1913 HasDefaultArg 1914 = cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument(); 1915 } 1916 1917 if (!HasDefaultArg) 1918 break; 1919 } 1920 } 1921 1922 if (LastDeducibleArgument) { 1923 // Some of the function template arguments cannot be deduced from a 1924 // function call, so we introduce an explicit template argument list 1925 // containing all of the arguments up to the first deducible argument. 1926 Result->AddChunk(Chunk(CodeCompletionString::CK_LeftAngle)); 1927 AddTemplateParameterChunks(S.Context, FunTmpl, Result, 1928 LastDeducibleArgument); 1929 Result->AddChunk(Chunk(CodeCompletionString::CK_RightAngle)); 1930 } 1931 1932 // Add the function parameters 1933 Result->AddChunk(Chunk(CodeCompletionString::CK_LeftParen)); 1934 AddFunctionParameterChunks(S.Context, Function, Result); 1935 Result->AddChunk(Chunk(CodeCompletionString::CK_RightParen)); 1936 AddFunctionTypeQualsToCompletionString(Result, Function); 1937 return Result; 1938 } 1939 1940 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(ND)) { 1941 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, 1942 S.Context); 1943 Result->AddTypedTextChunk(Template->getNameAsString()); 1944 Result->AddChunk(Chunk(CodeCompletionString::CK_LeftAngle)); 1945 AddTemplateParameterChunks(S.Context, Template, Result); 1946 Result->AddChunk(Chunk(CodeCompletionString::CK_RightAngle)); 1947 return Result; 1948 } 1949 1950 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) { 1951 Selector Sel = Method->getSelector(); 1952 if (Sel.isUnarySelector()) { 1953 Result->AddTypedTextChunk(Sel.getIdentifierInfoForSlot(0)->getName()); 1954 return Result; 1955 } 1956 1957 std::string SelName = Sel.getIdentifierInfoForSlot(0)->getName().str(); 1958 SelName += ':'; 1959 if (StartParameter == 0) 1960 Result->AddTypedTextChunk(SelName); 1961 else { 1962 Result->AddInformativeChunk(SelName); 1963 1964 // If there is only one parameter, and we're past it, add an empty 1965 // typed-text chunk since there is nothing to type. 1966 if (Method->param_size() == 1) 1967 Result->AddTypedTextChunk(""); 1968 } 1969 unsigned Idx = 0; 1970 for (ObjCMethodDecl::param_iterator P = Method->param_begin(), 1971 PEnd = Method->param_end(); 1972 P != PEnd; (void)++P, ++Idx) { 1973 if (Idx > 0) { 1974 std::string Keyword; 1975 if (Idx > StartParameter) 1976 Result->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1977 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx)) 1978 Keyword += II->getName().str(); 1979 Keyword += ":"; 1980 if (Idx < StartParameter || AllParametersAreInformative) 1981 Result->AddInformativeChunk(Keyword); 1982 else if (Idx == StartParameter) 1983 Result->AddTypedTextChunk(Keyword); 1984 else 1985 Result->AddTextChunk(Keyword); 1986 } 1987 1988 // If we're before the starting parameter, skip the placeholder. 1989 if (Idx < StartParameter) 1990 continue; 1991 1992 std::string Arg; 1993 (*P)->getType().getAsStringInternal(Arg, S.Context.PrintingPolicy); 1994 Arg = "(" + Arg + ")"; 1995 if (IdentifierInfo *II = (*P)->getIdentifier()) 1996 Arg += II->getName().str(); 1997 if (DeclaringEntity) 1998 Result->AddTextChunk(Arg); 1999 else if (AllParametersAreInformative) 2000 Result->AddInformativeChunk(Arg); 2001 else 2002 Result->AddPlaceholderChunk(Arg); 2003 } 2004 2005 if (Method->isVariadic()) { 2006 if (DeclaringEntity) 2007 Result->AddTextChunk(", ..."); 2008 else if (AllParametersAreInformative) 2009 Result->AddInformativeChunk(", ..."); 2010 else 2011 Result->AddPlaceholderChunk(", ..."); 2012 } 2013 2014 return Result; 2015 } 2016 2017 if (Qualifier) 2018 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, 2019 S.Context); 2020 2021 Result->AddTypedTextChunk(ND->getNameAsString()); 2022 return Result; 2023} 2024 2025CodeCompletionString * 2026CodeCompleteConsumer::OverloadCandidate::CreateSignatureString( 2027 unsigned CurrentArg, 2028 Sema &S) const { 2029 typedef CodeCompletionString::Chunk Chunk; 2030 2031 CodeCompletionString *Result = new CodeCompletionString; 2032 FunctionDecl *FDecl = getFunction(); 2033 AddResultTypeChunk(S.Context, FDecl, Result); 2034 const FunctionProtoType *Proto 2035 = dyn_cast<FunctionProtoType>(getFunctionType()); 2036 if (!FDecl && !Proto) { 2037 // Function without a prototype. Just give the return type and a 2038 // highlighted ellipsis. 2039 const FunctionType *FT = getFunctionType(); 2040 Result->AddTextChunk( 2041 FT->getResultType().getAsString(S.Context.PrintingPolicy)); 2042 Result->AddChunk(Chunk(CodeCompletionString::CK_LeftParen)); 2043 Result->AddChunk(Chunk(CodeCompletionString::CK_CurrentParameter, "...")); 2044 Result->AddChunk(Chunk(CodeCompletionString::CK_RightParen)); 2045 return Result; 2046 } 2047 2048 if (FDecl) 2049 Result->AddTextChunk(FDecl->getNameAsString()); 2050 else 2051 Result->AddTextChunk( 2052 Proto->getResultType().getAsString(S.Context.PrintingPolicy)); 2053 2054 Result->AddChunk(Chunk(CodeCompletionString::CK_LeftParen)); 2055 unsigned NumParams = FDecl? FDecl->getNumParams() : Proto->getNumArgs(); 2056 for (unsigned I = 0; I != NumParams; ++I) { 2057 if (I) 2058 Result->AddChunk(Chunk(CodeCompletionString::CK_Comma)); 2059 2060 std::string ArgString; 2061 QualType ArgType; 2062 2063 if (FDecl) { 2064 ArgString = FDecl->getParamDecl(I)->getNameAsString(); 2065 ArgType = FDecl->getParamDecl(I)->getOriginalType(); 2066 } else { 2067 ArgType = Proto->getArgType(I); 2068 } 2069 2070 ArgType.getAsStringInternal(ArgString, S.Context.PrintingPolicy); 2071 2072 if (I == CurrentArg) 2073 Result->AddChunk(Chunk(CodeCompletionString::CK_CurrentParameter, 2074 ArgString)); 2075 else 2076 Result->AddTextChunk(ArgString); 2077 } 2078 2079 if (Proto && Proto->isVariadic()) { 2080 Result->AddChunk(Chunk(CodeCompletionString::CK_Comma)); 2081 if (CurrentArg < NumParams) 2082 Result->AddTextChunk("..."); 2083 else 2084 Result->AddChunk(Chunk(CodeCompletionString::CK_CurrentParameter, "...")); 2085 } 2086 Result->AddChunk(Chunk(CodeCompletionString::CK_RightParen)); 2087 2088 return Result; 2089} 2090 2091namespace { 2092 struct SortCodeCompleteResult { 2093 typedef CodeCompleteConsumer::Result Result; 2094 2095 bool isEarlierDeclarationName(DeclarationName X, DeclarationName Y) const { 2096 Selector XSel = X.getObjCSelector(); 2097 Selector YSel = Y.getObjCSelector(); 2098 if (!XSel.isNull() && !YSel.isNull()) { 2099 // We are comparing two selectors. 2100 unsigned N = std::min(XSel.getNumArgs(), YSel.getNumArgs()); 2101 if (N == 0) 2102 ++N; 2103 for (unsigned I = 0; I != N; ++I) { 2104 IdentifierInfo *XId = XSel.getIdentifierInfoForSlot(I); 2105 IdentifierInfo *YId = YSel.getIdentifierInfoForSlot(I); 2106 if (!XId || !YId) 2107 return XId && !YId; 2108 2109 switch (XId->getName().compare_lower(YId->getName())) { 2110 case -1: return true; 2111 case 1: return false; 2112 default: break; 2113 } 2114 } 2115 2116 return XSel.getNumArgs() < YSel.getNumArgs(); 2117 } 2118 2119 // For non-selectors, order by kind. 2120 if (X.getNameKind() != Y.getNameKind()) 2121 return X.getNameKind() < Y.getNameKind(); 2122 2123 // Order identifiers by comparison of their lowercased names. 2124 if (IdentifierInfo *XId = X.getAsIdentifierInfo()) 2125 return XId->getName().compare_lower( 2126 Y.getAsIdentifierInfo()->getName()) < 0; 2127 2128 // Order overloaded operators by the order in which they appear 2129 // in our list of operators. 2130 if (OverloadedOperatorKind XOp = X.getCXXOverloadedOperator()) 2131 return XOp < Y.getCXXOverloadedOperator(); 2132 2133 // Order C++0x user-defined literal operators lexically by their 2134 // lowercased suffixes. 2135 if (IdentifierInfo *XLit = X.getCXXLiteralIdentifier()) 2136 return XLit->getName().compare_lower( 2137 Y.getCXXLiteralIdentifier()->getName()) < 0; 2138 2139 // The only stable ordering we have is to turn the name into a 2140 // string and then compare the lower-case strings. This is 2141 // inefficient, but thankfully does not happen too often. 2142 return llvm::StringRef(X.getAsString()).compare_lower( 2143 Y.getAsString()) < 0; 2144 } 2145 2146 /// \brief Retrieve the name that should be used to order a result. 2147 /// 2148 /// If the name needs to be constructed as a string, that string will be 2149 /// saved into Saved and the returned StringRef will refer to it. 2150 static llvm::StringRef getOrderedName(const Result &R, 2151 std::string &Saved) { 2152 switch (R.Kind) { 2153 case Result::RK_Keyword: 2154 return R.Keyword; 2155 2156 case Result::RK_Pattern: 2157 return R.Pattern->getTypedText(); 2158 2159 case Result::RK_Macro: 2160 return R.Macro->getName(); 2161 2162 case Result::RK_Declaration: 2163 // Handle declarations below. 2164 break; 2165 } 2166 2167 DeclarationName Name = R.Declaration->getDeclName(); 2168 2169 // If the name is a simple identifier (by far the common case), or a 2170 // zero-argument selector, just return a reference to that identifier. 2171 if (IdentifierInfo *Id = Name.getAsIdentifierInfo()) 2172 return Id->getName(); 2173 if (Name.isObjCZeroArgSelector()) 2174 if (IdentifierInfo *Id 2175 = Name.getObjCSelector().getIdentifierInfoForSlot(0)) 2176 return Id->getName(); 2177 2178 Saved = Name.getAsString(); 2179 return Saved; 2180 } 2181 2182 bool operator()(const Result &X, const Result &Y) const { 2183 std::string XSaved, YSaved; 2184 llvm::StringRef XStr = getOrderedName(X, XSaved); 2185 llvm::StringRef YStr = getOrderedName(Y, YSaved); 2186 int cmp = XStr.compare_lower(YStr); 2187 if (cmp) 2188 return cmp < 0; 2189 2190 // Non-hidden names precede hidden names. 2191 if (X.Hidden != Y.Hidden) 2192 return !X.Hidden; 2193 2194 // Non-nested-name-specifiers precede nested-name-specifiers. 2195 if (X.StartsNestedNameSpecifier != Y.StartsNestedNameSpecifier) 2196 return !X.StartsNestedNameSpecifier; 2197 2198 return false; 2199 } 2200 }; 2201} 2202 2203static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results, 2204 bool TargetTypeIsPointer = false) { 2205 typedef CodeCompleteConsumer::Result Result; 2206 2207 Results.EnterNewScope(); 2208 for (Preprocessor::macro_iterator M = PP.macro_begin(), 2209 MEnd = PP.macro_end(); 2210 M != MEnd; ++M) { 2211 unsigned Priority = CCP_Macro; 2212 2213 // Treat the "nil" and "NULL" macros as null pointer constants. 2214 if (M->first->isStr("nil") || M->first->isStr("NULL")) { 2215 Priority = CCP_Constant; 2216 if (TargetTypeIsPointer) 2217 Priority = Priority / CCF_SimilarTypeMatch; 2218 } 2219 2220 Results.AddResult(Result(M->first, Priority)); 2221 } 2222 Results.ExitScope(); 2223} 2224 2225static void HandleCodeCompleteResults(Sema *S, 2226 CodeCompleteConsumer *CodeCompleter, 2227 CodeCompleteConsumer::Result *Results, 2228 unsigned NumResults) { 2229 std::stable_sort(Results, Results + NumResults, SortCodeCompleteResult()); 2230 2231 if (CodeCompleter) 2232 CodeCompleter->ProcessCodeCompleteResults(*S, Results, NumResults); 2233 2234 for (unsigned I = 0; I != NumResults; ++I) 2235 Results[I].Destroy(); 2236} 2237 2238void Sema::CodeCompleteOrdinaryName(Scope *S, 2239 CodeCompletionContext CompletionContext) { 2240 typedef CodeCompleteConsumer::Result Result; 2241 ResultBuilder Results(*this); 2242 2243 // Determine how to filter results, e.g., so that the names of 2244 // values (functions, enumerators, function templates, etc.) are 2245 // only allowed where we can have an expression. 2246 switch (CompletionContext) { 2247 case CCC_Namespace: 2248 case CCC_Class: 2249 case CCC_ObjCInterface: 2250 case CCC_ObjCImplementation: 2251 case CCC_ObjCInstanceVariableList: 2252 case CCC_Template: 2253 case CCC_MemberTemplate: 2254 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName); 2255 break; 2256 2257 case CCC_Expression: 2258 case CCC_Statement: 2259 case CCC_ForInit: 2260 case CCC_Condition: 2261 if (WantTypesInContext(CompletionContext, getLangOptions())) 2262 Results.setFilter(&ResultBuilder::IsOrdinaryName); 2263 else 2264 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName); 2265 break; 2266 2267 case CCC_RecoveryInFunction: 2268 // Unfiltered 2269 break; 2270 } 2271 2272 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2273 LookupVisibleDecls(S, LookupOrdinaryName, Consumer); 2274 2275 Results.EnterNewScope(); 2276 AddOrdinaryNameResults(CompletionContext, S, *this, Results); 2277 Results.ExitScope(); 2278 2279 if (CodeCompleter->includeMacros()) 2280 AddMacroResults(PP, Results); 2281 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2282} 2283 2284/// \brief Perform code-completion in an expression context when we know what 2285/// type we're looking for. 2286/// 2287/// \param IntegralConstantExpression Only permit integral constant 2288/// expressions. 2289void Sema::CodeCompleteExpression(Scope *S, QualType T, 2290 bool IntegralConstantExpression) { 2291 typedef CodeCompleteConsumer::Result Result; 2292 ResultBuilder Results(*this); 2293 2294 if (IntegralConstantExpression) 2295 Results.setFilter(&ResultBuilder::IsIntegralConstantValue); 2296 else if (WantTypesInContext(CCC_Expression, getLangOptions())) 2297 Results.setFilter(&ResultBuilder::IsOrdinaryName); 2298 else 2299 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName); 2300 Results.setPreferredType(T.getNonReferenceType()); 2301 2302 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2303 LookupVisibleDecls(S, LookupOrdinaryName, Consumer); 2304 2305 Results.EnterNewScope(); 2306 AddOrdinaryNameResults(CCC_Expression, S, *this, Results); 2307 Results.ExitScope(); 2308 2309 bool PreferredTypeIsPointer = false; 2310 if (!T.isNull()) 2311 PreferredTypeIsPointer = T->isAnyPointerType() || 2312 T->isMemberPointerType() || T->isBlockPointerType(); 2313 2314 if (CodeCompleter->includeMacros()) 2315 AddMacroResults(PP, Results, PreferredTypeIsPointer); 2316 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2317} 2318 2319 2320static void AddObjCProperties(ObjCContainerDecl *Container, 2321 bool AllowCategories, 2322 DeclContext *CurContext, 2323 ResultBuilder &Results) { 2324 typedef CodeCompleteConsumer::Result Result; 2325 2326 // Add properties in this container. 2327 for (ObjCContainerDecl::prop_iterator P = Container->prop_begin(), 2328 PEnd = Container->prop_end(); 2329 P != PEnd; 2330 ++P) 2331 Results.MaybeAddResult(Result(*P, 0), CurContext); 2332 2333 // Add properties in referenced protocols. 2334 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) { 2335 for (ObjCProtocolDecl::protocol_iterator P = Protocol->protocol_begin(), 2336 PEnd = Protocol->protocol_end(); 2337 P != PEnd; ++P) 2338 AddObjCProperties(*P, AllowCategories, CurContext, Results); 2339 } else if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)){ 2340 if (AllowCategories) { 2341 // Look through categories. 2342 for (ObjCCategoryDecl *Category = IFace->getCategoryList(); 2343 Category; Category = Category->getNextClassCategory()) 2344 AddObjCProperties(Category, AllowCategories, CurContext, Results); 2345 } 2346 2347 // Look through protocols. 2348 for (ObjCInterfaceDecl::protocol_iterator I = IFace->protocol_begin(), 2349 E = IFace->protocol_end(); 2350 I != E; ++I) 2351 AddObjCProperties(*I, AllowCategories, CurContext, Results); 2352 2353 // Look in the superclass. 2354 if (IFace->getSuperClass()) 2355 AddObjCProperties(IFace->getSuperClass(), AllowCategories, CurContext, 2356 Results); 2357 } else if (const ObjCCategoryDecl *Category 2358 = dyn_cast<ObjCCategoryDecl>(Container)) { 2359 // Look through protocols. 2360 for (ObjCInterfaceDecl::protocol_iterator P = Category->protocol_begin(), 2361 PEnd = Category->protocol_end(); 2362 P != PEnd; ++P) 2363 AddObjCProperties(*P, AllowCategories, CurContext, Results); 2364 } 2365} 2366 2367void Sema::CodeCompleteMemberReferenceExpr(Scope *S, ExprTy *BaseE, 2368 SourceLocation OpLoc, 2369 bool IsArrow) { 2370 if (!BaseE || !CodeCompleter) 2371 return; 2372 2373 typedef CodeCompleteConsumer::Result Result; 2374 2375 Expr *Base = static_cast<Expr *>(BaseE); 2376 QualType BaseType = Base->getType(); 2377 2378 if (IsArrow) { 2379 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) 2380 BaseType = Ptr->getPointeeType(); 2381 else if (BaseType->isObjCObjectPointerType()) 2382 /*Do nothing*/ ; 2383 else 2384 return; 2385 } 2386 2387 ResultBuilder Results(*this, &ResultBuilder::IsMember); 2388 Results.EnterNewScope(); 2389 if (const RecordType *Record = BaseType->getAs<RecordType>()) { 2390 // Access to a C/C++ class, struct, or union. 2391 Results.allowNestedNameSpecifiers(); 2392 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2393 LookupVisibleDecls(Record->getDecl(), LookupMemberName, Consumer); 2394 2395 if (getLangOptions().CPlusPlus) { 2396 if (!Results.empty()) { 2397 // The "template" keyword can follow "->" or "." in the grammar. 2398 // However, we only want to suggest the template keyword if something 2399 // is dependent. 2400 bool IsDependent = BaseType->isDependentType(); 2401 if (!IsDependent) { 2402 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent()) 2403 if (DeclContext *Ctx = (DeclContext *)DepScope->getEntity()) { 2404 IsDependent = Ctx->isDependentContext(); 2405 break; 2406 } 2407 } 2408 2409 if (IsDependent) 2410 Results.AddResult(Result("template")); 2411 } 2412 } 2413 } else if (!IsArrow && BaseType->getAsObjCInterfacePointerType()) { 2414 // Objective-C property reference. 2415 2416 // Add property results based on our interface. 2417 const ObjCObjectPointerType *ObjCPtr 2418 = BaseType->getAsObjCInterfacePointerType(); 2419 assert(ObjCPtr && "Non-NULL pointer guaranteed above!"); 2420 AddObjCProperties(ObjCPtr->getInterfaceDecl(), true, CurContext, Results); 2421 2422 // Add properties from the protocols in a qualified interface. 2423 for (ObjCObjectPointerType::qual_iterator I = ObjCPtr->qual_begin(), 2424 E = ObjCPtr->qual_end(); 2425 I != E; ++I) 2426 AddObjCProperties(*I, true, CurContext, Results); 2427 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) || 2428 (!IsArrow && BaseType->isObjCObjectType())) { 2429 // Objective-C instance variable access. 2430 ObjCInterfaceDecl *Class = 0; 2431 if (const ObjCObjectPointerType *ObjCPtr 2432 = BaseType->getAs<ObjCObjectPointerType>()) 2433 Class = ObjCPtr->getInterfaceDecl(); 2434 else 2435 Class = BaseType->getAs<ObjCObjectType>()->getInterface(); 2436 2437 // Add all ivars from this class and its superclasses. 2438 if (Class) { 2439 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2440 Results.setFilter(&ResultBuilder::IsObjCIvar); 2441 LookupVisibleDecls(Class, LookupMemberName, Consumer); 2442 } 2443 } 2444 2445 // FIXME: How do we cope with isa? 2446 2447 Results.ExitScope(); 2448 2449 // Hand off the results found for code completion. 2450 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2451} 2452 2453void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) { 2454 if (!CodeCompleter) 2455 return; 2456 2457 typedef CodeCompleteConsumer::Result Result; 2458 ResultBuilder::LookupFilter Filter = 0; 2459 switch ((DeclSpec::TST)TagSpec) { 2460 case DeclSpec::TST_enum: 2461 Filter = &ResultBuilder::IsEnum; 2462 break; 2463 2464 case DeclSpec::TST_union: 2465 Filter = &ResultBuilder::IsUnion; 2466 break; 2467 2468 case DeclSpec::TST_struct: 2469 case DeclSpec::TST_class: 2470 Filter = &ResultBuilder::IsClassOrStruct; 2471 break; 2472 2473 default: 2474 assert(false && "Unknown type specifier kind in CodeCompleteTag"); 2475 return; 2476 } 2477 2478 ResultBuilder Results(*this); 2479 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2480 2481 // First pass: look for tags. 2482 Results.setFilter(Filter); 2483 LookupVisibleDecls(S, LookupTagName, Consumer); 2484 2485 // Second pass: look for nested name specifiers. 2486 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier); 2487 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer); 2488 2489 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2490} 2491 2492void Sema::CodeCompleteCase(Scope *S) { 2493 if (getSwitchStack().empty() || !CodeCompleter) 2494 return; 2495 2496 SwitchStmt *Switch = getSwitchStack().back(); 2497 if (!Switch->getCond()->getType()->isEnumeralType()) { 2498 CodeCompleteExpression(S, Switch->getCond()->getType(), true); 2499 return; 2500 } 2501 2502 // Code-complete the cases of a switch statement over an enumeration type 2503 // by providing the list of 2504 EnumDecl *Enum = Switch->getCond()->getType()->getAs<EnumType>()->getDecl(); 2505 2506 // Determine which enumerators we have already seen in the switch statement. 2507 // FIXME: Ideally, we would also be able to look *past* the code-completion 2508 // token, in case we are code-completing in the middle of the switch and not 2509 // at the end. However, we aren't able to do so at the moment. 2510 llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen; 2511 NestedNameSpecifier *Qualifier = 0; 2512 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC; 2513 SC = SC->getNextSwitchCase()) { 2514 CaseStmt *Case = dyn_cast<CaseStmt>(SC); 2515 if (!Case) 2516 continue; 2517 2518 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts(); 2519 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal)) 2520 if (EnumConstantDecl *Enumerator 2521 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) { 2522 // We look into the AST of the case statement to determine which 2523 // enumerator was named. Alternatively, we could compute the value of 2524 // the integral constant expression, then compare it against the 2525 // values of each enumerator. However, value-based approach would not 2526 // work as well with C++ templates where enumerators declared within a 2527 // template are type- and value-dependent. 2528 EnumeratorsSeen.insert(Enumerator); 2529 2530 // If this is a qualified-id, keep track of the nested-name-specifier 2531 // so that we can reproduce it as part of code completion, e.g., 2532 // 2533 // switch (TagD.getKind()) { 2534 // case TagDecl::TK_enum: 2535 // break; 2536 // case XXX 2537 // 2538 // At the XXX, our completions are TagDecl::TK_union, 2539 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union, 2540 // TK_struct, and TK_class. 2541 Qualifier = DRE->getQualifier(); 2542 } 2543 } 2544 2545 if (getLangOptions().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) { 2546 // If there are no prior enumerators in C++, check whether we have to 2547 // qualify the names of the enumerators that we suggest, because they 2548 // may not be visible in this scope. 2549 Qualifier = getRequiredQualification(Context, CurContext, 2550 Enum->getDeclContext()); 2551 2552 // FIXME: Scoped enums need to start with "EnumDecl" as the context! 2553 } 2554 2555 // Add any enumerators that have not yet been mentioned. 2556 ResultBuilder Results(*this); 2557 Results.EnterNewScope(); 2558 for (EnumDecl::enumerator_iterator E = Enum->enumerator_begin(), 2559 EEnd = Enum->enumerator_end(); 2560 E != EEnd; ++E) { 2561 if (EnumeratorsSeen.count(*E)) 2562 continue; 2563 2564 Results.AddResult(CodeCompleteConsumer::Result(*E, Qualifier), 2565 CurContext, 0, false); 2566 } 2567 Results.ExitScope(); 2568 2569 if (CodeCompleter->includeMacros()) 2570 AddMacroResults(PP, Results); 2571 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2572} 2573 2574namespace { 2575 struct IsBetterOverloadCandidate { 2576 Sema &S; 2577 SourceLocation Loc; 2578 2579 public: 2580 explicit IsBetterOverloadCandidate(Sema &S, SourceLocation Loc) 2581 : S(S), Loc(Loc) { } 2582 2583 bool 2584 operator()(const OverloadCandidate &X, const OverloadCandidate &Y) const { 2585 return S.isBetterOverloadCandidate(X, Y, Loc); 2586 } 2587 }; 2588} 2589 2590static bool anyNullArguments(Expr **Args, unsigned NumArgs) { 2591 if (NumArgs && !Args) 2592 return true; 2593 2594 for (unsigned I = 0; I != NumArgs; ++I) 2595 if (!Args[I]) 2596 return true; 2597 2598 return false; 2599} 2600 2601void Sema::CodeCompleteCall(Scope *S, ExprTy *FnIn, 2602 ExprTy **ArgsIn, unsigned NumArgs) { 2603 if (!CodeCompleter) 2604 return; 2605 2606 // When we're code-completing for a call, we fall back to ordinary 2607 // name code-completion whenever we can't produce specific 2608 // results. We may want to revisit this strategy in the future, 2609 // e.g., by merging the two kinds of results. 2610 2611 Expr *Fn = (Expr *)FnIn; 2612 Expr **Args = (Expr **)ArgsIn; 2613 2614 // Ignore type-dependent call expressions entirely. 2615 if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args, NumArgs) || 2616 Expr::hasAnyTypeDependentArguments(Args, NumArgs)) { 2617 CodeCompleteOrdinaryName(S, CCC_Expression); 2618 return; 2619 } 2620 2621 // Build an overload candidate set based on the functions we find. 2622 SourceLocation Loc = Fn->getExprLoc(); 2623 OverloadCandidateSet CandidateSet(Loc); 2624 2625 // FIXME: What if we're calling something that isn't a function declaration? 2626 // FIXME: What if we're calling a pseudo-destructor? 2627 // FIXME: What if we're calling a member function? 2628 2629 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate; 2630 llvm::SmallVector<ResultCandidate, 8> Results; 2631 2632 Expr *NakedFn = Fn->IgnoreParenCasts(); 2633 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn)) 2634 AddOverloadedCallCandidates(ULE, Args, NumArgs, CandidateSet, 2635 /*PartialOverloading=*/ true); 2636 else if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(NakedFn)) { 2637 FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()); 2638 if (FDecl) { 2639 if (!getLangOptions().CPlusPlus || 2640 !FDecl->getType()->getAs<FunctionProtoType>()) 2641 Results.push_back(ResultCandidate(FDecl)); 2642 else 2643 // FIXME: access? 2644 AddOverloadCandidate(FDecl, DeclAccessPair::make(FDecl, AS_none), 2645 Args, NumArgs, CandidateSet, 2646 false, /*PartialOverloading*/true); 2647 } 2648 } 2649 2650 QualType ParamType; 2651 2652 if (!CandidateSet.empty()) { 2653 // Sort the overload candidate set by placing the best overloads first. 2654 std::stable_sort(CandidateSet.begin(), CandidateSet.end(), 2655 IsBetterOverloadCandidate(*this, Loc)); 2656 2657 // Add the remaining viable overload candidates as code-completion reslults. 2658 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(), 2659 CandEnd = CandidateSet.end(); 2660 Cand != CandEnd; ++Cand) { 2661 if (Cand->Viable) 2662 Results.push_back(ResultCandidate(Cand->Function)); 2663 } 2664 2665 // From the viable candidates, try to determine the type of this parameter. 2666 for (unsigned I = 0, N = Results.size(); I != N; ++I) { 2667 if (const FunctionType *FType = Results[I].getFunctionType()) 2668 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FType)) 2669 if (NumArgs < Proto->getNumArgs()) { 2670 if (ParamType.isNull()) 2671 ParamType = Proto->getArgType(NumArgs); 2672 else if (!Context.hasSameUnqualifiedType( 2673 ParamType.getNonReferenceType(), 2674 Proto->getArgType(NumArgs).getNonReferenceType())) { 2675 ParamType = QualType(); 2676 break; 2677 } 2678 } 2679 } 2680 } else { 2681 // Try to determine the parameter type from the type of the expression 2682 // being called. 2683 QualType FunctionType = Fn->getType(); 2684 if (const PointerType *Ptr = FunctionType->getAs<PointerType>()) 2685 FunctionType = Ptr->getPointeeType(); 2686 else if (const BlockPointerType *BlockPtr 2687 = FunctionType->getAs<BlockPointerType>()) 2688 FunctionType = BlockPtr->getPointeeType(); 2689 else if (const MemberPointerType *MemPtr 2690 = FunctionType->getAs<MemberPointerType>()) 2691 FunctionType = MemPtr->getPointeeType(); 2692 2693 if (const FunctionProtoType *Proto 2694 = FunctionType->getAs<FunctionProtoType>()) { 2695 if (NumArgs < Proto->getNumArgs()) 2696 ParamType = Proto->getArgType(NumArgs); 2697 } 2698 } 2699 2700 if (ParamType.isNull()) 2701 CodeCompleteOrdinaryName(S, CCC_Expression); 2702 else 2703 CodeCompleteExpression(S, ParamType); 2704 2705 if (!Results.empty()) 2706 CodeCompleter->ProcessOverloadCandidates(*this, NumArgs, Results.data(), 2707 Results.size()); 2708} 2709 2710void Sema::CodeCompleteInitializer(Scope *S, DeclPtrTy D) { 2711 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D.getAs<Decl>()); 2712 if (!VD) { 2713 CodeCompleteOrdinaryName(S, CCC_Expression); 2714 return; 2715 } 2716 2717 CodeCompleteExpression(S, VD->getType()); 2718} 2719 2720void Sema::CodeCompleteReturn(Scope *S) { 2721 QualType ResultType; 2722 if (isa<BlockDecl>(CurContext)) { 2723 if (BlockScopeInfo *BSI = getCurBlock()) 2724 ResultType = BSI->ReturnType; 2725 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext)) 2726 ResultType = Function->getResultType(); 2727 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext)) 2728 ResultType = Method->getResultType(); 2729 2730 if (ResultType.isNull()) 2731 CodeCompleteOrdinaryName(S, CCC_Expression); 2732 else 2733 CodeCompleteExpression(S, ResultType); 2734} 2735 2736void Sema::CodeCompleteAssignmentRHS(Scope *S, ExprTy *LHS) { 2737 if (LHS) 2738 CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType()); 2739 else 2740 CodeCompleteOrdinaryName(S, CCC_Expression); 2741} 2742 2743void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, 2744 bool EnteringContext) { 2745 if (!SS.getScopeRep() || !CodeCompleter) 2746 return; 2747 2748 DeclContext *Ctx = computeDeclContext(SS, EnteringContext); 2749 if (!Ctx) 2750 return; 2751 2752 // Try to instantiate any non-dependent declaration contexts before 2753 // we look in them. 2754 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx)) 2755 return; 2756 2757 ResultBuilder Results(*this); 2758 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2759 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer); 2760 2761 // The "template" keyword can follow "::" in the grammar, but only 2762 // put it into the grammar if the nested-name-specifier is dependent. 2763 NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep(); 2764 if (!Results.empty() && NNS->isDependent()) 2765 Results.AddResult("template"); 2766 2767 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2768} 2769 2770void Sema::CodeCompleteUsing(Scope *S) { 2771 if (!CodeCompleter) 2772 return; 2773 2774 ResultBuilder Results(*this, &ResultBuilder::IsNestedNameSpecifier); 2775 Results.EnterNewScope(); 2776 2777 // If we aren't in class scope, we could see the "namespace" keyword. 2778 if (!S->isClassScope()) 2779 Results.AddResult(CodeCompleteConsumer::Result("namespace")); 2780 2781 // After "using", we can see anything that would start a 2782 // nested-name-specifier. 2783 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2784 LookupVisibleDecls(S, LookupOrdinaryName, Consumer); 2785 Results.ExitScope(); 2786 2787 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2788} 2789 2790void Sema::CodeCompleteUsingDirective(Scope *S) { 2791 if (!CodeCompleter) 2792 return; 2793 2794 // After "using namespace", we expect to see a namespace name or namespace 2795 // alias. 2796 ResultBuilder Results(*this, &ResultBuilder::IsNamespaceOrAlias); 2797 Results.EnterNewScope(); 2798 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2799 LookupVisibleDecls(S, LookupOrdinaryName, Consumer); 2800 Results.ExitScope(); 2801 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2802} 2803 2804void Sema::CodeCompleteNamespaceDecl(Scope *S) { 2805 if (!CodeCompleter) 2806 return; 2807 2808 ResultBuilder Results(*this, &ResultBuilder::IsNamespace); 2809 DeclContext *Ctx = (DeclContext *)S->getEntity(); 2810 if (!S->getParent()) 2811 Ctx = Context.getTranslationUnitDecl(); 2812 2813 if (Ctx && Ctx->isFileContext()) { 2814 // We only want to see those namespaces that have already been defined 2815 // within this scope, because its likely that the user is creating an 2816 // extended namespace declaration. Keep track of the most recent 2817 // definition of each namespace. 2818 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest; 2819 for (DeclContext::specific_decl_iterator<NamespaceDecl> 2820 NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end()); 2821 NS != NSEnd; ++NS) 2822 OrigToLatest[NS->getOriginalNamespace()] = *NS; 2823 2824 // Add the most recent definition (or extended definition) of each 2825 // namespace to the list of results. 2826 Results.EnterNewScope(); 2827 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator 2828 NS = OrigToLatest.begin(), NSEnd = OrigToLatest.end(); 2829 NS != NSEnd; ++NS) 2830 Results.AddResult(CodeCompleteConsumer::Result(NS->second, 0), 2831 CurContext, 0, false); 2832 Results.ExitScope(); 2833 } 2834 2835 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2836} 2837 2838void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) { 2839 if (!CodeCompleter) 2840 return; 2841 2842 // After "namespace", we expect to see a namespace or alias. 2843 ResultBuilder Results(*this, &ResultBuilder::IsNamespaceOrAlias); 2844 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2845 LookupVisibleDecls(S, LookupOrdinaryName, Consumer); 2846 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2847} 2848 2849void Sema::CodeCompleteOperatorName(Scope *S) { 2850 if (!CodeCompleter) 2851 return; 2852 2853 typedef CodeCompleteConsumer::Result Result; 2854 ResultBuilder Results(*this, &ResultBuilder::IsType); 2855 Results.EnterNewScope(); 2856 2857 // Add the names of overloadable operators. 2858#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 2859 if (std::strcmp(Spelling, "?")) \ 2860 Results.AddResult(Result(Spelling)); 2861#include "clang/Basic/OperatorKinds.def" 2862 2863 // Add any type names visible from the current scope 2864 Results.allowNestedNameSpecifiers(); 2865 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2866 LookupVisibleDecls(S, LookupOrdinaryName, Consumer); 2867 2868 // Add any type specifiers 2869 AddTypeSpecifierResults(getLangOptions(), Results); 2870 Results.ExitScope(); 2871 2872 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2873} 2874 2875// Macro that expands to @Keyword or Keyword, depending on whether NeedAt is 2876// true or false. 2877#define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) NeedAt? "@" #Keyword : #Keyword 2878static void AddObjCImplementationResults(const LangOptions &LangOpts, 2879 ResultBuilder &Results, 2880 bool NeedAt) { 2881 typedef CodeCompleteConsumer::Result Result; 2882 // Since we have an implementation, we can end it. 2883 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,end))); 2884 2885 CodeCompletionString *Pattern = 0; 2886 if (LangOpts.ObjC2) { 2887 // @dynamic 2888 Pattern = new CodeCompletionString; 2889 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,dynamic)); 2890 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2891 Pattern->AddPlaceholderChunk("property"); 2892 Results.AddResult(Result(Pattern)); 2893 2894 // @synthesize 2895 Pattern = new CodeCompletionString; 2896 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,synthesize)); 2897 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2898 Pattern->AddPlaceholderChunk("property"); 2899 Results.AddResult(Result(Pattern)); 2900 } 2901} 2902 2903static void AddObjCInterfaceResults(const LangOptions &LangOpts, 2904 ResultBuilder &Results, 2905 bool NeedAt) { 2906 typedef CodeCompleteConsumer::Result Result; 2907 2908 // Since we have an interface or protocol, we can end it. 2909 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,end))); 2910 2911 if (LangOpts.ObjC2) { 2912 // @property 2913 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,property))); 2914 2915 // @required 2916 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,required))); 2917 2918 // @optional 2919 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,optional))); 2920 } 2921} 2922 2923static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) { 2924 typedef CodeCompleteConsumer::Result Result; 2925 CodeCompletionString *Pattern = 0; 2926 2927 // @class name ; 2928 Pattern = new CodeCompletionString; 2929 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,class)); 2930 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2931 Pattern->AddPlaceholderChunk("name"); 2932 Results.AddResult(Result(Pattern)); 2933 2934 if (Results.includeCodePatterns()) { 2935 // @interface name 2936 // FIXME: Could introduce the whole pattern, including superclasses and 2937 // such. 2938 Pattern = new CodeCompletionString; 2939 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,interface)); 2940 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2941 Pattern->AddPlaceholderChunk("class"); 2942 Results.AddResult(Result(Pattern)); 2943 2944 // @protocol name 2945 Pattern = new CodeCompletionString; 2946 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,protocol)); 2947 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2948 Pattern->AddPlaceholderChunk("protocol"); 2949 Results.AddResult(Result(Pattern)); 2950 2951 // @implementation name 2952 Pattern = new CodeCompletionString; 2953 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,implementation)); 2954 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2955 Pattern->AddPlaceholderChunk("class"); 2956 Results.AddResult(Result(Pattern)); 2957 } 2958 2959 // @compatibility_alias name 2960 Pattern = new CodeCompletionString; 2961 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,compatibility_alias)); 2962 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2963 Pattern->AddPlaceholderChunk("alias"); 2964 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2965 Pattern->AddPlaceholderChunk("class"); 2966 Results.AddResult(Result(Pattern)); 2967} 2968 2969void Sema::CodeCompleteObjCAtDirective(Scope *S, DeclPtrTy ObjCImpDecl, 2970 bool InInterface) { 2971 typedef CodeCompleteConsumer::Result Result; 2972 ResultBuilder Results(*this); 2973 Results.EnterNewScope(); 2974 if (ObjCImpDecl) 2975 AddObjCImplementationResults(getLangOptions(), Results, false); 2976 else if (InInterface) 2977 AddObjCInterfaceResults(getLangOptions(), Results, false); 2978 else 2979 AddObjCTopLevelResults(Results, false); 2980 Results.ExitScope(); 2981 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2982} 2983 2984static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) { 2985 typedef CodeCompleteConsumer::Result Result; 2986 CodeCompletionString *Pattern = 0; 2987 2988 // @encode ( type-name ) 2989 Pattern = new CodeCompletionString; 2990 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,encode)); 2991 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 2992 Pattern->AddPlaceholderChunk("type-name"); 2993 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 2994 Results.AddResult(Result(Pattern)); 2995 2996 // @protocol ( protocol-name ) 2997 Pattern = new CodeCompletionString; 2998 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,protocol)); 2999 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 3000 Pattern->AddPlaceholderChunk("protocol-name"); 3001 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 3002 Results.AddResult(Result(Pattern)); 3003 3004 // @selector ( selector ) 3005 Pattern = new CodeCompletionString; 3006 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,selector)); 3007 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 3008 Pattern->AddPlaceholderChunk("selector"); 3009 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 3010 Results.AddResult(Result(Pattern)); 3011} 3012 3013static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) { 3014 typedef CodeCompleteConsumer::Result Result; 3015 CodeCompletionString *Pattern = 0; 3016 3017 if (Results.includeCodePatterns()) { 3018 // @try { statements } @catch ( declaration ) { statements } @finally 3019 // { statements } 3020 Pattern = new CodeCompletionString; 3021 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,try)); 3022 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 3023 Pattern->AddPlaceholderChunk("statements"); 3024 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 3025 Pattern->AddTextChunk("@catch"); 3026 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 3027 Pattern->AddPlaceholderChunk("parameter"); 3028 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 3029 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 3030 Pattern->AddPlaceholderChunk("statements"); 3031 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 3032 Pattern->AddTextChunk("@finally"); 3033 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 3034 Pattern->AddPlaceholderChunk("statements"); 3035 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 3036 Results.AddResult(Result(Pattern)); 3037 } 3038 3039 // @throw 3040 Pattern = new CodeCompletionString; 3041 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,throw)); 3042 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 3043 Pattern->AddPlaceholderChunk("expression"); 3044 Results.AddResult(Result(Pattern)); 3045 3046 if (Results.includeCodePatterns()) { 3047 // @synchronized ( expression ) { statements } 3048 Pattern = new CodeCompletionString; 3049 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,synchronized)); 3050 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 3051 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 3052 Pattern->AddPlaceholderChunk("expression"); 3053 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 3054 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 3055 Pattern->AddPlaceholderChunk("statements"); 3056 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 3057 Results.AddResult(Result(Pattern)); 3058 } 3059} 3060 3061static void AddObjCVisibilityResults(const LangOptions &LangOpts, 3062 ResultBuilder &Results, 3063 bool NeedAt) { 3064 typedef CodeCompleteConsumer::Result Result; 3065 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,private))); 3066 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,protected))); 3067 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,public))); 3068 if (LangOpts.ObjC2) 3069 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,package))); 3070} 3071 3072void Sema::CodeCompleteObjCAtVisibility(Scope *S) { 3073 ResultBuilder Results(*this); 3074 Results.EnterNewScope(); 3075 AddObjCVisibilityResults(getLangOptions(), Results, false); 3076 Results.ExitScope(); 3077 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3078} 3079 3080void Sema::CodeCompleteObjCAtStatement(Scope *S) { 3081 ResultBuilder Results(*this); 3082 Results.EnterNewScope(); 3083 AddObjCStatementResults(Results, false); 3084 AddObjCExpressionResults(Results, false); 3085 Results.ExitScope(); 3086 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3087} 3088 3089void Sema::CodeCompleteObjCAtExpression(Scope *S) { 3090 ResultBuilder Results(*this); 3091 Results.EnterNewScope(); 3092 AddObjCExpressionResults(Results, false); 3093 Results.ExitScope(); 3094 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3095} 3096 3097/// \brief Determine whether the addition of the given flag to an Objective-C 3098/// property's attributes will cause a conflict. 3099static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) { 3100 // Check if we've already added this flag. 3101 if (Attributes & NewFlag) 3102 return true; 3103 3104 Attributes |= NewFlag; 3105 3106 // Check for collisions with "readonly". 3107 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) && 3108 (Attributes & (ObjCDeclSpec::DQ_PR_readwrite | 3109 ObjCDeclSpec::DQ_PR_assign | 3110 ObjCDeclSpec::DQ_PR_copy | 3111 ObjCDeclSpec::DQ_PR_retain))) 3112 return true; 3113 3114 // Check for more than one of { assign, copy, retain }. 3115 unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign | 3116 ObjCDeclSpec::DQ_PR_copy | 3117 ObjCDeclSpec::DQ_PR_retain); 3118 if (AssignCopyRetMask && 3119 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign && 3120 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy && 3121 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain) 3122 return true; 3123 3124 return false; 3125} 3126 3127void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) { 3128 if (!CodeCompleter) 3129 return; 3130 3131 unsigned Attributes = ODS.getPropertyAttributes(); 3132 3133 typedef CodeCompleteConsumer::Result Result; 3134 ResultBuilder Results(*this); 3135 Results.EnterNewScope(); 3136 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly)) 3137 Results.AddResult(CodeCompleteConsumer::Result("readonly")); 3138 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign)) 3139 Results.AddResult(CodeCompleteConsumer::Result("assign")); 3140 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite)) 3141 Results.AddResult(CodeCompleteConsumer::Result("readwrite")); 3142 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain)) 3143 Results.AddResult(CodeCompleteConsumer::Result("retain")); 3144 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy)) 3145 Results.AddResult(CodeCompleteConsumer::Result("copy")); 3146 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic)) 3147 Results.AddResult(CodeCompleteConsumer::Result("nonatomic")); 3148 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) { 3149 CodeCompletionString *Setter = new CodeCompletionString; 3150 Setter->AddTypedTextChunk("setter"); 3151 Setter->AddTextChunk(" = "); 3152 Setter->AddPlaceholderChunk("method"); 3153 Results.AddResult(CodeCompleteConsumer::Result(Setter)); 3154 } 3155 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) { 3156 CodeCompletionString *Getter = new CodeCompletionString; 3157 Getter->AddTypedTextChunk("getter"); 3158 Getter->AddTextChunk(" = "); 3159 Getter->AddPlaceholderChunk("method"); 3160 Results.AddResult(CodeCompleteConsumer::Result(Getter)); 3161 } 3162 Results.ExitScope(); 3163 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3164} 3165 3166/// \brief Descripts the kind of Objective-C method that we want to find 3167/// via code completion. 3168enum ObjCMethodKind { 3169 MK_Any, //< Any kind of method, provided it means other specified criteria. 3170 MK_ZeroArgSelector, //< Zero-argument (unary) selector. 3171 MK_OneArgSelector //< One-argument selector. 3172}; 3173 3174static bool isAcceptableObjCMethod(ObjCMethodDecl *Method, 3175 ObjCMethodKind WantKind, 3176 IdentifierInfo **SelIdents, 3177 unsigned NumSelIdents) { 3178 Selector Sel = Method->getSelector(); 3179 if (NumSelIdents > Sel.getNumArgs()) 3180 return false; 3181 3182 switch (WantKind) { 3183 case MK_Any: break; 3184 case MK_ZeroArgSelector: return Sel.isUnarySelector(); 3185 case MK_OneArgSelector: return Sel.getNumArgs() == 1; 3186 } 3187 3188 for (unsigned I = 0; I != NumSelIdents; ++I) 3189 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I)) 3190 return false; 3191 3192 return true; 3193} 3194 3195/// \brief Add all of the Objective-C methods in the given Objective-C 3196/// container to the set of results. 3197/// 3198/// The container will be a class, protocol, category, or implementation of 3199/// any of the above. This mether will recurse to include methods from 3200/// the superclasses of classes along with their categories, protocols, and 3201/// implementations. 3202/// 3203/// \param Container the container in which we'll look to find methods. 3204/// 3205/// \param WantInstance whether to add instance methods (only); if false, this 3206/// routine will add factory methods (only). 3207/// 3208/// \param CurContext the context in which we're performing the lookup that 3209/// finds methods. 3210/// 3211/// \param Results the structure into which we'll add results. 3212static void AddObjCMethods(ObjCContainerDecl *Container, 3213 bool WantInstanceMethods, 3214 ObjCMethodKind WantKind, 3215 IdentifierInfo **SelIdents, 3216 unsigned NumSelIdents, 3217 DeclContext *CurContext, 3218 ResultBuilder &Results) { 3219 typedef CodeCompleteConsumer::Result Result; 3220 for (ObjCContainerDecl::method_iterator M = Container->meth_begin(), 3221 MEnd = Container->meth_end(); 3222 M != MEnd; ++M) { 3223 if ((*M)->isInstanceMethod() == WantInstanceMethods) { 3224 // Check whether the selector identifiers we've been given are a 3225 // subset of the identifiers for this particular method. 3226 if (!isAcceptableObjCMethod(*M, WantKind, SelIdents, NumSelIdents)) 3227 continue; 3228 3229 Result R = Result(*M, 0); 3230 R.StartParameter = NumSelIdents; 3231 R.AllParametersAreInformative = (WantKind != MK_Any); 3232 Results.MaybeAddResult(R, CurContext); 3233 } 3234 } 3235 3236 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container); 3237 if (!IFace) 3238 return; 3239 3240 // Add methods in protocols. 3241 const ObjCList<ObjCProtocolDecl> &Protocols= IFace->getReferencedProtocols(); 3242 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 3243 E = Protocols.end(); 3244 I != E; ++I) 3245 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, NumSelIdents, 3246 CurContext, Results); 3247 3248 // Add methods in categories. 3249 for (ObjCCategoryDecl *CatDecl = IFace->getCategoryList(); CatDecl; 3250 CatDecl = CatDecl->getNextClassCategory()) { 3251 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents, 3252 NumSelIdents, CurContext, Results); 3253 3254 // Add a categories protocol methods. 3255 const ObjCList<ObjCProtocolDecl> &Protocols 3256 = CatDecl->getReferencedProtocols(); 3257 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 3258 E = Protocols.end(); 3259 I != E; ++I) 3260 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, 3261 NumSelIdents, CurContext, Results); 3262 3263 // Add methods in category implementations. 3264 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation()) 3265 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, 3266 NumSelIdents, CurContext, Results); 3267 } 3268 3269 // Add methods in superclass. 3270 if (IFace->getSuperClass()) 3271 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind, 3272 SelIdents, NumSelIdents, CurContext, Results); 3273 3274 // Add methods in our implementation, if any. 3275 if (ObjCImplementationDecl *Impl = IFace->getImplementation()) 3276 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, 3277 NumSelIdents, CurContext, Results); 3278} 3279 3280 3281void Sema::CodeCompleteObjCPropertyGetter(Scope *S, DeclPtrTy ClassDecl, 3282 DeclPtrTy *Methods, 3283 unsigned NumMethods) { 3284 typedef CodeCompleteConsumer::Result Result; 3285 3286 // Try to find the interface where getters might live. 3287 ObjCInterfaceDecl *Class 3288 = dyn_cast_or_null<ObjCInterfaceDecl>(ClassDecl.getAs<Decl>()); 3289 if (!Class) { 3290 if (ObjCCategoryDecl *Category 3291 = dyn_cast_or_null<ObjCCategoryDecl>(ClassDecl.getAs<Decl>())) 3292 Class = Category->getClassInterface(); 3293 3294 if (!Class) 3295 return; 3296 } 3297 3298 // Find all of the potential getters. 3299 ResultBuilder Results(*this); 3300 Results.EnterNewScope(); 3301 3302 // FIXME: We need to do this because Objective-C methods don't get 3303 // pushed into DeclContexts early enough. Argh! 3304 for (unsigned I = 0; I != NumMethods; ++I) { 3305 if (ObjCMethodDecl *Method 3306 = dyn_cast_or_null<ObjCMethodDecl>(Methods[I].getAs<Decl>())) 3307 if (Method->isInstanceMethod() && 3308 isAcceptableObjCMethod(Method, MK_ZeroArgSelector, 0, 0)) { 3309 Result R = Result(Method, 0); 3310 R.AllParametersAreInformative = true; 3311 Results.MaybeAddResult(R, CurContext); 3312 } 3313 } 3314 3315 AddObjCMethods(Class, true, MK_ZeroArgSelector, 0, 0, CurContext, Results); 3316 Results.ExitScope(); 3317 HandleCodeCompleteResults(this, CodeCompleter,Results.data(),Results.size()); 3318} 3319 3320void Sema::CodeCompleteObjCPropertySetter(Scope *S, DeclPtrTy ObjCImplDecl, 3321 DeclPtrTy *Methods, 3322 unsigned NumMethods) { 3323 typedef CodeCompleteConsumer::Result Result; 3324 3325 // Try to find the interface where setters might live. 3326 ObjCInterfaceDecl *Class 3327 = dyn_cast_or_null<ObjCInterfaceDecl>(ObjCImplDecl.getAs<Decl>()); 3328 if (!Class) { 3329 if (ObjCCategoryDecl *Category 3330 = dyn_cast_or_null<ObjCCategoryDecl>(ObjCImplDecl.getAs<Decl>())) 3331 Class = Category->getClassInterface(); 3332 3333 if (!Class) 3334 return; 3335 } 3336 3337 // Find all of the potential getters. 3338 ResultBuilder Results(*this); 3339 Results.EnterNewScope(); 3340 3341 // FIXME: We need to do this because Objective-C methods don't get 3342 // pushed into DeclContexts early enough. Argh! 3343 for (unsigned I = 0; I != NumMethods; ++I) { 3344 if (ObjCMethodDecl *Method 3345 = dyn_cast_or_null<ObjCMethodDecl>(Methods[I].getAs<Decl>())) 3346 if (Method->isInstanceMethod() && 3347 isAcceptableObjCMethod(Method, MK_OneArgSelector, 0, 0)) { 3348 Result R = Result(Method, 0); 3349 R.AllParametersAreInformative = true; 3350 Results.MaybeAddResult(R, CurContext); 3351 } 3352 } 3353 3354 AddObjCMethods(Class, true, MK_OneArgSelector, 0, 0, CurContext, Results); 3355 3356 Results.ExitScope(); 3357 HandleCodeCompleteResults(this, CodeCompleter,Results.data(),Results.size()); 3358} 3359 3360/// \brief When we have an expression with type "id", we may assume 3361/// that it has some more-specific class type based on knowledge of 3362/// common uses of Objective-C. This routine returns that class type, 3363/// or NULL if no better result could be determined. 3364static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) { 3365 ObjCMessageExpr *Msg = dyn_cast<ObjCMessageExpr>(E); 3366 if (!Msg) 3367 return 0; 3368 3369 Selector Sel = Msg->getSelector(); 3370 if (Sel.isNull()) 3371 return 0; 3372 3373 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0); 3374 if (!Id) 3375 return 0; 3376 3377 ObjCMethodDecl *Method = Msg->getMethodDecl(); 3378 if (!Method) 3379 return 0; 3380 3381 // Determine the class that we're sending the message to. 3382 ObjCInterfaceDecl *IFace = 0; 3383 switch (Msg->getReceiverKind()) { 3384 case ObjCMessageExpr::Class: 3385 if (const ObjCObjectType *ObjType 3386 = Msg->getClassReceiver()->getAs<ObjCObjectType>()) 3387 IFace = ObjType->getInterface(); 3388 break; 3389 3390 case ObjCMessageExpr::Instance: { 3391 QualType T = Msg->getInstanceReceiver()->getType(); 3392 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>()) 3393 IFace = Ptr->getInterfaceDecl(); 3394 break; 3395 } 3396 3397 case ObjCMessageExpr::SuperInstance: 3398 case ObjCMessageExpr::SuperClass: 3399 break; 3400 } 3401 3402 if (!IFace) 3403 return 0; 3404 3405 ObjCInterfaceDecl *Super = IFace->getSuperClass(); 3406 if (Method->isInstanceMethod()) 3407 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName()) 3408 .Case("retain", IFace) 3409 .Case("autorelease", IFace) 3410 .Case("copy", IFace) 3411 .Case("copyWithZone", IFace) 3412 .Case("mutableCopy", IFace) 3413 .Case("mutableCopyWithZone", IFace) 3414 .Case("awakeFromCoder", IFace) 3415 .Case("replacementObjectFromCoder", IFace) 3416 .Case("class", IFace) 3417 .Case("classForCoder", IFace) 3418 .Case("superclass", Super) 3419 .Default(0); 3420 3421 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName()) 3422 .Case("new", IFace) 3423 .Case("alloc", IFace) 3424 .Case("allocWithZone", IFace) 3425 .Case("class", IFace) 3426 .Case("superclass", Super) 3427 .Default(0); 3428} 3429 3430void Sema::CodeCompleteObjCMessageReceiver(Scope *S) { 3431 typedef CodeCompleteConsumer::Result Result; 3432 ResultBuilder Results(*this); 3433 3434 // Find anything that looks like it could be a message receiver. 3435 Results.setFilter(&ResultBuilder::IsObjCMessageReceiver); 3436 CodeCompletionDeclConsumer Consumer(Results, CurContext); 3437 Results.EnterNewScope(); 3438 LookupVisibleDecls(S, LookupOrdinaryName, Consumer); 3439 3440 // If we are in an Objective-C method inside a class that has a superclass, 3441 // add "super" as an option. 3442 if (ObjCMethodDecl *Method = getCurMethodDecl()) 3443 if (ObjCInterfaceDecl *Iface = Method->getClassInterface()) 3444 if (Iface->getSuperClass()) 3445 Results.AddResult(Result("super")); 3446 3447 Results.ExitScope(); 3448 3449 if (CodeCompleter->includeMacros()) 3450 AddMacroResults(PP, Results); 3451 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3452 3453} 3454 3455void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc, 3456 IdentifierInfo **SelIdents, 3457 unsigned NumSelIdents) { 3458 ObjCInterfaceDecl *CDecl = 0; 3459 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) { 3460 // Figure out which interface we're in. 3461 CDecl = CurMethod->getClassInterface(); 3462 if (!CDecl) 3463 return; 3464 3465 // Find the superclass of this class. 3466 CDecl = CDecl->getSuperClass(); 3467 if (!CDecl) 3468 return; 3469 3470 if (CurMethod->isInstanceMethod()) { 3471 // We are inside an instance method, which means that the message 3472 // send [super ...] is actually calling an instance method on the 3473 // current object. Build the super expression and handle this like 3474 // an instance method. 3475 QualType SuperTy = Context.getObjCInterfaceType(CDecl); 3476 SuperTy = Context.getObjCObjectPointerType(SuperTy); 3477 OwningExprResult Super 3478 = Owned(new (Context) ObjCSuperExpr(SuperLoc, SuperTy)); 3479 return CodeCompleteObjCInstanceMessage(S, (Expr *)Super.get(), 3480 SelIdents, NumSelIdents); 3481 } 3482 3483 // Fall through to send to the superclass in CDecl. 3484 } else { 3485 // "super" may be the name of a type or variable. Figure out which 3486 // it is. 3487 IdentifierInfo *Super = &Context.Idents.get("super"); 3488 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc, 3489 LookupOrdinaryName); 3490 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) { 3491 // "super" names an interface. Use it. 3492 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) { 3493 if (const ObjCObjectType *Iface 3494 = Context.getTypeDeclType(TD)->getAs<ObjCObjectType>()) 3495 CDecl = Iface->getInterface(); 3496 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) { 3497 // "super" names an unresolved type; we can't be more specific. 3498 } else { 3499 // Assume that "super" names some kind of value and parse that way. 3500 CXXScopeSpec SS; 3501 UnqualifiedId id; 3502 id.setIdentifier(Super, SuperLoc); 3503 OwningExprResult SuperExpr = ActOnIdExpression(S, SS, id, false, false); 3504 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(), 3505 SelIdents, NumSelIdents); 3506 } 3507 3508 // Fall through 3509 } 3510 3511 TypeTy *Receiver = 0; 3512 if (CDecl) 3513 Receiver = Context.getObjCInterfaceType(CDecl).getAsOpaquePtr(); 3514 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents, 3515 NumSelIdents); 3516} 3517 3518void Sema::CodeCompleteObjCClassMessage(Scope *S, TypeTy *Receiver, 3519 IdentifierInfo **SelIdents, 3520 unsigned NumSelIdents) { 3521 typedef CodeCompleteConsumer::Result Result; 3522 ObjCInterfaceDecl *CDecl = 0; 3523 3524 // If the given name refers to an interface type, retrieve the 3525 // corresponding declaration. 3526 if (Receiver) { 3527 QualType T = GetTypeFromParser(Receiver, 0); 3528 if (!T.isNull()) 3529 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>()) 3530 CDecl = Interface->getInterface(); 3531 } 3532 3533 // Add all of the factory methods in this Objective-C class, its protocols, 3534 // superclasses, categories, implementation, etc. 3535 ResultBuilder Results(*this); 3536 Results.EnterNewScope(); 3537 3538 if (CDecl) 3539 AddObjCMethods(CDecl, false, MK_Any, SelIdents, NumSelIdents, CurContext, 3540 Results); 3541 else { 3542 // We're messaging "id" as a type; provide all class/factory methods. 3543 3544 // If we have an external source, load the entire class method 3545 // pool from the PCH file. 3546 if (ExternalSource) { 3547 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors(); 3548 I != N; ++I) { 3549 Selector Sel = ExternalSource->GetExternalSelector(I); 3550 if (Sel.isNull() || MethodPool.count(Sel)) 3551 continue; 3552 3553 ReadMethodPool(Sel); 3554 } 3555 } 3556 3557 for (GlobalMethodPool::iterator M = MethodPool.begin(), 3558 MEnd = MethodPool.end(); 3559 M != MEnd; ++M) { 3560 for (ObjCMethodList *MethList = &M->second.second; 3561 MethList && MethList->Method; 3562 MethList = MethList->Next) { 3563 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents, 3564 NumSelIdents)) 3565 continue; 3566 3567 Result R(MethList->Method, 0); 3568 R.StartParameter = NumSelIdents; 3569 R.AllParametersAreInformative = false; 3570 Results.MaybeAddResult(R, CurContext); 3571 } 3572 } 3573 } 3574 3575 Results.ExitScope(); 3576 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3577} 3578 3579void Sema::CodeCompleteObjCInstanceMessage(Scope *S, ExprTy *Receiver, 3580 IdentifierInfo **SelIdents, 3581 unsigned NumSelIdents) { 3582 typedef CodeCompleteConsumer::Result Result; 3583 3584 Expr *RecExpr = static_cast<Expr *>(Receiver); 3585 3586 // If necessary, apply function/array conversion to the receiver. 3587 // C99 6.7.5.3p[7,8]. 3588 DefaultFunctionArrayLvalueConversion(RecExpr); 3589 QualType ReceiverType = RecExpr->getType(); 3590 3591 // Build the set of methods we can see. 3592 ResultBuilder Results(*this); 3593 Results.EnterNewScope(); 3594 3595 // If we're messaging an expression with type "id" or "Class", check 3596 // whether we know something special about the receiver that allows 3597 // us to assume a more-specific receiver type. 3598 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) 3599 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) 3600 ReceiverType = Context.getObjCObjectPointerType( 3601 Context.getObjCInterfaceType(IFace)); 3602 3603 // Handle messages to Class. This really isn't a message to an instance 3604 // method, so we treat it the same way we would treat a message send to a 3605 // class method. 3606 if (ReceiverType->isObjCClassType() || 3607 ReceiverType->isObjCQualifiedClassType()) { 3608 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) { 3609 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface()) 3610 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents, NumSelIdents, 3611 CurContext, Results); 3612 } 3613 } 3614 // Handle messages to a qualified ID ("id<foo>"). 3615 else if (const ObjCObjectPointerType *QualID 3616 = ReceiverType->getAsObjCQualifiedIdType()) { 3617 // Search protocols for instance methods. 3618 for (ObjCObjectPointerType::qual_iterator I = QualID->qual_begin(), 3619 E = QualID->qual_end(); 3620 I != E; ++I) 3621 AddObjCMethods(*I, true, MK_Any, SelIdents, NumSelIdents, CurContext, 3622 Results); 3623 } 3624 // Handle messages to a pointer to interface type. 3625 else if (const ObjCObjectPointerType *IFacePtr 3626 = ReceiverType->getAsObjCInterfacePointerType()) { 3627 // Search the class, its superclasses, etc., for instance methods. 3628 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents, 3629 NumSelIdents, CurContext, Results); 3630 3631 // Search protocols for instance methods. 3632 for (ObjCObjectPointerType::qual_iterator I = IFacePtr->qual_begin(), 3633 E = IFacePtr->qual_end(); 3634 I != E; ++I) 3635 AddObjCMethods(*I, true, MK_Any, SelIdents, NumSelIdents, CurContext, 3636 Results); 3637 } 3638 // Handle messages to "id". 3639 else if (ReceiverType->isObjCIdType()) { 3640 // We're messaging "id", so provide all instance methods we know 3641 // about as code-completion results. 3642 3643 // If we have an external source, load the entire class method 3644 // pool from the PCH file. 3645 if (ExternalSource) { 3646 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors(); 3647 I != N; ++I) { 3648 Selector Sel = ExternalSource->GetExternalSelector(I); 3649 if (Sel.isNull() || MethodPool.count(Sel)) 3650 continue; 3651 3652 ReadMethodPool(Sel); 3653 } 3654 } 3655 3656 for (GlobalMethodPool::iterator M = MethodPool.begin(), 3657 MEnd = MethodPool.end(); 3658 M != MEnd; ++M) { 3659 for (ObjCMethodList *MethList = &M->second.first; 3660 MethList && MethList->Method; 3661 MethList = MethList->Next) { 3662 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents, 3663 NumSelIdents)) 3664 continue; 3665 3666 Result R(MethList->Method, 0); 3667 R.StartParameter = NumSelIdents; 3668 R.AllParametersAreInformative = false; 3669 Results.MaybeAddResult(R, CurContext); 3670 } 3671 } 3672 } 3673 3674 Results.ExitScope(); 3675 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3676} 3677 3678/// \brief Add all of the protocol declarations that we find in the given 3679/// (translation unit) context. 3680static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext, 3681 bool OnlyForwardDeclarations, 3682 ResultBuilder &Results) { 3683 typedef CodeCompleteConsumer::Result Result; 3684 3685 for (DeclContext::decl_iterator D = Ctx->decls_begin(), 3686 DEnd = Ctx->decls_end(); 3687 D != DEnd; ++D) { 3688 // Record any protocols we find. 3689 if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(*D)) 3690 if (!OnlyForwardDeclarations || Proto->isForwardDecl()) 3691 Results.AddResult(Result(Proto, 0), CurContext, 0, false); 3692 3693 // Record any forward-declared protocols we find. 3694 if (ObjCForwardProtocolDecl *Forward 3695 = dyn_cast<ObjCForwardProtocolDecl>(*D)) { 3696 for (ObjCForwardProtocolDecl::protocol_iterator 3697 P = Forward->protocol_begin(), 3698 PEnd = Forward->protocol_end(); 3699 P != PEnd; ++P) 3700 if (!OnlyForwardDeclarations || (*P)->isForwardDecl()) 3701 Results.AddResult(Result(*P, 0), CurContext, 0, false); 3702 } 3703 } 3704} 3705 3706void Sema::CodeCompleteObjCProtocolReferences(IdentifierLocPair *Protocols, 3707 unsigned NumProtocols) { 3708 ResultBuilder Results(*this); 3709 Results.EnterNewScope(); 3710 3711 // Tell the result set to ignore all of the protocols we have 3712 // already seen. 3713 for (unsigned I = 0; I != NumProtocols; ++I) 3714 if (ObjCProtocolDecl *Protocol = LookupProtocol(Protocols[I].first, 3715 Protocols[I].second)) 3716 Results.Ignore(Protocol); 3717 3718 // Add all protocols. 3719 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false, 3720 Results); 3721 3722 Results.ExitScope(); 3723 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3724} 3725 3726void Sema::CodeCompleteObjCProtocolDecl(Scope *) { 3727 ResultBuilder Results(*this); 3728 Results.EnterNewScope(); 3729 3730 // Add all protocols. 3731 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true, 3732 Results); 3733 3734 Results.ExitScope(); 3735 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3736} 3737 3738/// \brief Add all of the Objective-C interface declarations that we find in 3739/// the given (translation unit) context. 3740static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext, 3741 bool OnlyForwardDeclarations, 3742 bool OnlyUnimplemented, 3743 ResultBuilder &Results) { 3744 typedef CodeCompleteConsumer::Result Result; 3745 3746 for (DeclContext::decl_iterator D = Ctx->decls_begin(), 3747 DEnd = Ctx->decls_end(); 3748 D != DEnd; ++D) { 3749 // Record any interfaces we find. 3750 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(*D)) 3751 if ((!OnlyForwardDeclarations || Class->isForwardDecl()) && 3752 (!OnlyUnimplemented || !Class->getImplementation())) 3753 Results.AddResult(Result(Class, 0), CurContext, 0, false); 3754 3755 // Record any forward-declared interfaces we find. 3756 if (ObjCClassDecl *Forward = dyn_cast<ObjCClassDecl>(*D)) { 3757 for (ObjCClassDecl::iterator C = Forward->begin(), CEnd = Forward->end(); 3758 C != CEnd; ++C) 3759 if ((!OnlyForwardDeclarations || C->getInterface()->isForwardDecl()) && 3760 (!OnlyUnimplemented || !C->getInterface()->getImplementation())) 3761 Results.AddResult(Result(C->getInterface(), 0), CurContext, 3762 0, false); 3763 } 3764 } 3765} 3766 3767void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) { 3768 ResultBuilder Results(*this); 3769 Results.EnterNewScope(); 3770 3771 // Add all classes. 3772 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, true, 3773 false, Results); 3774 3775 Results.ExitScope(); 3776 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3777} 3778 3779void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName, 3780 SourceLocation ClassNameLoc) { 3781 ResultBuilder Results(*this); 3782 Results.EnterNewScope(); 3783 3784 // Make sure that we ignore the class we're currently defining. 3785 NamedDecl *CurClass 3786 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName); 3787 if (CurClass && isa<ObjCInterfaceDecl>(CurClass)) 3788 Results.Ignore(CurClass); 3789 3790 // Add all classes. 3791 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false, 3792 false, Results); 3793 3794 Results.ExitScope(); 3795 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3796} 3797 3798void Sema::CodeCompleteObjCImplementationDecl(Scope *S) { 3799 ResultBuilder Results(*this); 3800 Results.EnterNewScope(); 3801 3802 // Add all unimplemented classes. 3803 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false, 3804 true, Results); 3805 3806 Results.ExitScope(); 3807 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3808} 3809 3810void Sema::CodeCompleteObjCInterfaceCategory(Scope *S, 3811 IdentifierInfo *ClassName, 3812 SourceLocation ClassNameLoc) { 3813 typedef CodeCompleteConsumer::Result Result; 3814 3815 ResultBuilder Results(*this); 3816 3817 // Ignore any categories we find that have already been implemented by this 3818 // interface. 3819 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames; 3820 NamedDecl *CurClass 3821 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName); 3822 if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)) 3823 for (ObjCCategoryDecl *Category = Class->getCategoryList(); Category; 3824 Category = Category->getNextClassCategory()) 3825 CategoryNames.insert(Category->getIdentifier()); 3826 3827 // Add all of the categories we know about. 3828 Results.EnterNewScope(); 3829 TranslationUnitDecl *TU = Context.getTranslationUnitDecl(); 3830 for (DeclContext::decl_iterator D = TU->decls_begin(), 3831 DEnd = TU->decls_end(); 3832 D != DEnd; ++D) 3833 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(*D)) 3834 if (CategoryNames.insert(Category->getIdentifier())) 3835 Results.AddResult(Result(Category, 0), CurContext, 0, false); 3836 Results.ExitScope(); 3837 3838 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3839} 3840 3841void Sema::CodeCompleteObjCImplementationCategory(Scope *S, 3842 IdentifierInfo *ClassName, 3843 SourceLocation ClassNameLoc) { 3844 typedef CodeCompleteConsumer::Result Result; 3845 3846 // Find the corresponding interface. If we couldn't find the interface, the 3847 // program itself is ill-formed. However, we'll try to be helpful still by 3848 // providing the list of all of the categories we know about. 3849 NamedDecl *CurClass 3850 = LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName); 3851 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass); 3852 if (!Class) 3853 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc); 3854 3855 ResultBuilder Results(*this); 3856 3857 // Add all of the categories that have have corresponding interface 3858 // declarations in this class and any of its superclasses, except for 3859 // already-implemented categories in the class itself. 3860 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames; 3861 Results.EnterNewScope(); 3862 bool IgnoreImplemented = true; 3863 while (Class) { 3864 for (ObjCCategoryDecl *Category = Class->getCategoryList(); Category; 3865 Category = Category->getNextClassCategory()) 3866 if ((!IgnoreImplemented || !Category->getImplementation()) && 3867 CategoryNames.insert(Category->getIdentifier())) 3868 Results.AddResult(Result(Category, 0), CurContext, 0, false); 3869 3870 Class = Class->getSuperClass(); 3871 IgnoreImplemented = false; 3872 } 3873 Results.ExitScope(); 3874 3875 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3876} 3877 3878void Sema::CodeCompleteObjCPropertyDefinition(Scope *S, DeclPtrTy ObjCImpDecl) { 3879 typedef CodeCompleteConsumer::Result Result; 3880 ResultBuilder Results(*this); 3881 3882 // Figure out where this @synthesize lives. 3883 ObjCContainerDecl *Container 3884 = dyn_cast_or_null<ObjCContainerDecl>(ObjCImpDecl.getAs<Decl>()); 3885 if (!Container || 3886 (!isa<ObjCImplementationDecl>(Container) && 3887 !isa<ObjCCategoryImplDecl>(Container))) 3888 return; 3889 3890 // Ignore any properties that have already been implemented. 3891 for (DeclContext::decl_iterator D = Container->decls_begin(), 3892 DEnd = Container->decls_end(); 3893 D != DEnd; ++D) 3894 if (ObjCPropertyImplDecl *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(*D)) 3895 Results.Ignore(PropertyImpl->getPropertyDecl()); 3896 3897 // Add any properties that we find. 3898 Results.EnterNewScope(); 3899 if (ObjCImplementationDecl *ClassImpl 3900 = dyn_cast<ObjCImplementationDecl>(Container)) 3901 AddObjCProperties(ClassImpl->getClassInterface(), false, CurContext, 3902 Results); 3903 else 3904 AddObjCProperties(cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(), 3905 false, CurContext, Results); 3906 Results.ExitScope(); 3907 3908 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3909} 3910 3911void Sema::CodeCompleteObjCPropertySynthesizeIvar(Scope *S, 3912 IdentifierInfo *PropertyName, 3913 DeclPtrTy ObjCImpDecl) { 3914 typedef CodeCompleteConsumer::Result Result; 3915 ResultBuilder Results(*this); 3916 3917 // Figure out where this @synthesize lives. 3918 ObjCContainerDecl *Container 3919 = dyn_cast_or_null<ObjCContainerDecl>(ObjCImpDecl.getAs<Decl>()); 3920 if (!Container || 3921 (!isa<ObjCImplementationDecl>(Container) && 3922 !isa<ObjCCategoryImplDecl>(Container))) 3923 return; 3924 3925 // Figure out which interface we're looking into. 3926 ObjCInterfaceDecl *Class = 0; 3927 if (ObjCImplementationDecl *ClassImpl 3928 = dyn_cast<ObjCImplementationDecl>(Container)) 3929 Class = ClassImpl->getClassInterface(); 3930 else 3931 Class = cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl() 3932 ->getClassInterface(); 3933 3934 // Add all of the instance variables in this class and its superclasses. 3935 Results.EnterNewScope(); 3936 for(; Class; Class = Class->getSuperClass()) { 3937 // FIXME: We could screen the type of each ivar for compatibility with 3938 // the property, but is that being too paternal? 3939 for (ObjCInterfaceDecl::ivar_iterator IVar = Class->ivar_begin(), 3940 IVarEnd = Class->ivar_end(); 3941 IVar != IVarEnd; ++IVar) 3942 Results.AddResult(Result(*IVar, 0), CurContext, 0, false); 3943 } 3944 Results.ExitScope(); 3945 3946 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3947} 3948 3949typedef llvm::DenseMap<Selector, ObjCMethodDecl *> KnownMethodsMap; 3950 3951/// \brief Find all of the methods that reside in the given container 3952/// (and its superclasses, protocols, etc.) that meet the given 3953/// criteria. Insert those methods into the map of known methods, 3954/// indexed by selector so they can be easily found. 3955static void FindImplementableMethods(ASTContext &Context, 3956 ObjCContainerDecl *Container, 3957 bool WantInstanceMethods, 3958 QualType ReturnType, 3959 bool IsInImplementation, 3960 KnownMethodsMap &KnownMethods) { 3961 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) { 3962 // Recurse into protocols. 3963 const ObjCList<ObjCProtocolDecl> &Protocols 3964 = IFace->getReferencedProtocols(); 3965 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 3966 E = Protocols.end(); 3967 I != E; ++I) 3968 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType, 3969 IsInImplementation, KnownMethods); 3970 3971 // If we're not in the implementation of a class, also visit the 3972 // superclass. 3973 if (!IsInImplementation && IFace->getSuperClass()) 3974 FindImplementableMethods(Context, IFace->getSuperClass(), 3975 WantInstanceMethods, ReturnType, 3976 IsInImplementation, KnownMethods); 3977 3978 // Add methods from any class extensions (but not from categories; 3979 // those should go into category implementations). 3980 for (const ObjCCategoryDecl *Cat = IFace->getFirstClassExtension(); Cat; 3981 Cat = Cat->getNextClassExtension()) 3982 FindImplementableMethods(Context, const_cast<ObjCCategoryDecl*>(Cat), 3983 WantInstanceMethods, ReturnType, 3984 IsInImplementation, KnownMethods); 3985 } 3986 3987 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) { 3988 // Recurse into protocols. 3989 const ObjCList<ObjCProtocolDecl> &Protocols 3990 = Category->getReferencedProtocols(); 3991 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 3992 E = Protocols.end(); 3993 I != E; ++I) 3994 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType, 3995 IsInImplementation, KnownMethods); 3996 } 3997 3998 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) { 3999 // Recurse into protocols. 4000 const ObjCList<ObjCProtocolDecl> &Protocols 4001 = Protocol->getReferencedProtocols(); 4002 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 4003 E = Protocols.end(); 4004 I != E; ++I) 4005 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType, 4006 IsInImplementation, KnownMethods); 4007 } 4008 4009 // Add methods in this container. This operation occurs last because 4010 // we want the methods from this container to override any methods 4011 // we've previously seen with the same selector. 4012 for (ObjCContainerDecl::method_iterator M = Container->meth_begin(), 4013 MEnd = Container->meth_end(); 4014 M != MEnd; ++M) { 4015 if ((*M)->isInstanceMethod() == WantInstanceMethods) { 4016 if (!ReturnType.isNull() && 4017 !Context.hasSameUnqualifiedType(ReturnType, (*M)->getResultType())) 4018 continue; 4019 4020 KnownMethods[(*M)->getSelector()] = *M; 4021 } 4022 } 4023} 4024 4025void Sema::CodeCompleteObjCMethodDecl(Scope *S, 4026 bool IsInstanceMethod, 4027 TypeTy *ReturnTy, 4028 DeclPtrTy IDecl) { 4029 // Determine the return type of the method we're declaring, if 4030 // provided. 4031 QualType ReturnType = GetTypeFromParser(ReturnTy); 4032 4033 // Determine where we should start searching for methods, and where we 4034 ObjCContainerDecl *SearchDecl = 0, *CurrentDecl = 0; 4035 bool IsInImplementation = false; 4036 if (Decl *D = IDecl.getAs<Decl>()) { 4037 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) { 4038 SearchDecl = Impl->getClassInterface(); 4039 CurrentDecl = Impl; 4040 IsInImplementation = true; 4041 } else if (ObjCCategoryImplDecl *CatImpl 4042 = dyn_cast<ObjCCategoryImplDecl>(D)) { 4043 SearchDecl = CatImpl->getCategoryDecl(); 4044 CurrentDecl = CatImpl; 4045 IsInImplementation = true; 4046 } else { 4047 SearchDecl = dyn_cast<ObjCContainerDecl>(D); 4048 CurrentDecl = SearchDecl; 4049 } 4050 } 4051 4052 if (!SearchDecl && S) { 4053 if (DeclContext *DC = static_cast<DeclContext *>(S->getEntity())) { 4054 SearchDecl = dyn_cast<ObjCContainerDecl>(DC); 4055 CurrentDecl = SearchDecl; 4056 } 4057 } 4058 4059 if (!SearchDecl || !CurrentDecl) { 4060 HandleCodeCompleteResults(this, CodeCompleter, 0, 0); 4061 return; 4062 } 4063 4064 // Find all of the methods that we could declare/implement here. 4065 KnownMethodsMap KnownMethods; 4066 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod, 4067 ReturnType, IsInImplementation, KnownMethods); 4068 4069 // Erase any methods that have already been declared or 4070 // implemented here. 4071 for (ObjCContainerDecl::method_iterator M = CurrentDecl->meth_begin(), 4072 MEnd = CurrentDecl->meth_end(); 4073 M != MEnd; ++M) { 4074 if ((*M)->isInstanceMethod() != IsInstanceMethod) 4075 continue; 4076 4077 KnownMethodsMap::iterator Pos = KnownMethods.find((*M)->getSelector()); 4078 if (Pos != KnownMethods.end()) 4079 KnownMethods.erase(Pos); 4080 } 4081 4082 // Add declarations or definitions for each of the known methods. 4083 typedef CodeCompleteConsumer::Result Result; 4084 ResultBuilder Results(*this); 4085 Results.EnterNewScope(); 4086 PrintingPolicy Policy(Context.PrintingPolicy); 4087 Policy.AnonymousTagLocations = false; 4088 for (KnownMethodsMap::iterator M = KnownMethods.begin(), 4089 MEnd = KnownMethods.end(); 4090 M != MEnd; ++M) { 4091 ObjCMethodDecl *Method = M->second; 4092 CodeCompletionString *Pattern = new CodeCompletionString; 4093 4094 // If the result type was not already provided, add it to the 4095 // pattern as (type). 4096 if (ReturnType.isNull()) { 4097 std::string TypeStr; 4098 Method->getResultType().getAsStringInternal(TypeStr, Policy); 4099 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 4100 Pattern->AddTextChunk(TypeStr); 4101 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 4102 } 4103 4104 Selector Sel = Method->getSelector(); 4105 4106 // Add the first part of the selector to the pattern. 4107 Pattern->AddTypedTextChunk(Sel.getIdentifierInfoForSlot(0)->getName()); 4108 4109 // Add parameters to the pattern. 4110 unsigned I = 0; 4111 for (ObjCMethodDecl::param_iterator P = Method->param_begin(), 4112 PEnd = Method->param_end(); 4113 P != PEnd; (void)++P, ++I) { 4114 // Add the part of the selector name. 4115 if (I == 0) 4116 Pattern->AddChunk(CodeCompletionString::CK_Colon); 4117 else if (I < Sel.getNumArgs()) { 4118 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 4119 Pattern->AddTextChunk(Sel.getIdentifierInfoForSlot(1)->getName()); 4120 Pattern->AddChunk(CodeCompletionString::CK_Colon); 4121 } else 4122 break; 4123 4124 // Add the parameter type. 4125 std::string TypeStr; 4126 (*P)->getOriginalType().getAsStringInternal(TypeStr, Policy); 4127 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 4128 Pattern->AddTextChunk(TypeStr); 4129 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 4130 4131 if (IdentifierInfo *Id = (*P)->getIdentifier()) 4132 Pattern->AddTextChunk(Id->getName()); 4133 } 4134 4135 if (Method->isVariadic()) { 4136 if (Method->param_size() > 0) 4137 Pattern->AddChunk(CodeCompletionString::CK_Comma); 4138 Pattern->AddTextChunk("..."); 4139 } 4140 4141 if (IsInImplementation && Results.includeCodePatterns()) { 4142 // We will be defining the method here, so add a compound statement. 4143 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 4144 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 4145 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 4146 if (!Method->getResultType()->isVoidType()) { 4147 // If the result type is not void, add a return clause. 4148 Pattern->AddTextChunk("return"); 4149 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 4150 Pattern->AddPlaceholderChunk("expression"); 4151 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 4152 } else 4153 Pattern->AddPlaceholderChunk("statements"); 4154 4155 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 4156 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 4157 } 4158 4159 Results.AddResult(Result(Pattern)); 4160 } 4161 4162 Results.ExitScope(); 4163 4164 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 4165} 4166 4167void Sema::CodeCompleteObjCMethodDeclSelector(Scope *S, 4168 bool IsInstanceMethod, 4169 bool AtParameterName, 4170 TypeTy *ReturnTy, 4171 IdentifierInfo **SelIdents, 4172 unsigned NumSelIdents) { 4173 // If we have an external source, load the entire class method 4174 // pool from the PCH file. 4175 if (ExternalSource) { 4176 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors(); 4177 I != N; ++I) { 4178 Selector Sel = ExternalSource->GetExternalSelector(I); 4179 if (Sel.isNull() || MethodPool.count(Sel)) 4180 continue; 4181 4182 ReadMethodPool(Sel); 4183 } 4184 } 4185 4186 // Build the set of methods we can see. 4187 typedef CodeCompleteConsumer::Result Result; 4188 ResultBuilder Results(*this); 4189 4190 if (ReturnTy) 4191 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType()); 4192 4193 Results.EnterNewScope(); 4194 for (GlobalMethodPool::iterator M = MethodPool.begin(), 4195 MEnd = MethodPool.end(); 4196 M != MEnd; ++M) { 4197 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first : 4198 &M->second.second; 4199 MethList && MethList->Method; 4200 MethList = MethList->Next) { 4201 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents, 4202 NumSelIdents)) 4203 continue; 4204 4205 if (AtParameterName) { 4206 // Suggest parameter names we've seen before. 4207 if (NumSelIdents && NumSelIdents <= MethList->Method->param_size()) { 4208 ParmVarDecl *Param = MethList->Method->param_begin()[NumSelIdents-1]; 4209 if (Param->getIdentifier()) { 4210 CodeCompletionString *Pattern = new CodeCompletionString; 4211 Pattern->AddTypedTextChunk(Param->getIdentifier()->getName()); 4212 Results.AddResult(Pattern); 4213 } 4214 } 4215 4216 continue; 4217 } 4218 4219 Result R(MethList->Method, 0); 4220 R.StartParameter = NumSelIdents; 4221 R.AllParametersAreInformative = false; 4222 R.DeclaringEntity = true; 4223 Results.MaybeAddResult(R, CurContext); 4224 } 4225 } 4226 4227 Results.ExitScope(); 4228 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 4229} 4230