SemaCodeComplete.cpp revision d152d13efeaea574eeee9d2822717f452623ed1d
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/AST/ExprCXX.h" 17#include "clang/AST/ExprObjC.h" 18#include "clang/Lex/MacroInfo.h" 19#include "clang/Lex/Preprocessor.h" 20#include "llvm/ADT/SmallPtrSet.h" 21#include "llvm/ADT/StringExtras.h" 22#include <list> 23#include <map> 24#include <vector> 25 26using namespace clang; 27 28namespace { 29 /// \brief A container of code-completion results. 30 class ResultBuilder { 31 public: 32 /// \brief The type of a name-lookup filter, which can be provided to the 33 /// name-lookup routines to specify which declarations should be included in 34 /// the result set (when it returns true) and which declarations should be 35 /// filtered out (returns false). 36 typedef bool (ResultBuilder::*LookupFilter)(NamedDecl *) const; 37 38 typedef CodeCompleteConsumer::Result Result; 39 40 private: 41 /// \brief The actual results we have found. 42 std::vector<Result> Results; 43 44 /// \brief A record of all of the declarations we have found and placed 45 /// into the result set, used to ensure that no declaration ever gets into 46 /// the result set twice. 47 llvm::SmallPtrSet<Decl*, 16> AllDeclsFound; 48 49 typedef std::pair<NamedDecl *, unsigned> DeclIndexPair; 50 51 /// \brief An entry in the shadow map, which is optimized to store 52 /// a single (declaration, index) mapping (the common case) but 53 /// can also store a list of (declaration, index) mappings. 54 class ShadowMapEntry { 55 typedef llvm::SmallVector<DeclIndexPair, 4> DeclIndexPairVector; 56 57 /// \brief Contains either the solitary NamedDecl * or a vector 58 /// of (declaration, index) pairs. 59 llvm::PointerUnion<NamedDecl *, DeclIndexPairVector*> DeclOrVector; 60 61 /// \brief When the entry contains a single declaration, this is 62 /// the index associated with that entry. 63 unsigned SingleDeclIndex; 64 65 public: 66 ShadowMapEntry() : DeclOrVector(), SingleDeclIndex(0) { } 67 68 void Add(NamedDecl *ND, unsigned Index) { 69 if (DeclOrVector.isNull()) { 70 // 0 - > 1 elements: just set the single element information. 71 DeclOrVector = ND; 72 SingleDeclIndex = Index; 73 return; 74 } 75 76 if (NamedDecl *PrevND = DeclOrVector.dyn_cast<NamedDecl *>()) { 77 // 1 -> 2 elements: create the vector of results and push in the 78 // existing declaration. 79 DeclIndexPairVector *Vec = new DeclIndexPairVector; 80 Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex)); 81 DeclOrVector = Vec; 82 } 83 84 // Add the new element to the end of the vector. 85 DeclOrVector.get<DeclIndexPairVector*>()->push_back( 86 DeclIndexPair(ND, Index)); 87 } 88 89 void Destroy() { 90 if (DeclIndexPairVector *Vec 91 = DeclOrVector.dyn_cast<DeclIndexPairVector *>()) { 92 delete Vec; 93 DeclOrVector = ((NamedDecl *)0); 94 } 95 } 96 97 // Iteration. 98 class iterator; 99 iterator begin() const; 100 iterator end() const; 101 }; 102 103 /// \brief A mapping from declaration names to the declarations that have 104 /// this name within a particular scope and their index within the list of 105 /// results. 106 typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap; 107 108 /// \brief The semantic analysis object for which results are being 109 /// produced. 110 Sema &SemaRef; 111 112 /// \brief If non-NULL, a filter function used to remove any code-completion 113 /// results that are not desirable. 114 LookupFilter Filter; 115 116 /// \brief Whether we should allow declarations as 117 /// nested-name-specifiers that would otherwise be filtered out. 118 bool AllowNestedNameSpecifiers; 119 120 /// \brief A list of shadow maps, which is used to model name hiding at 121 /// different levels of, e.g., the inheritance hierarchy. 122 std::list<ShadowMap> ShadowMaps; 123 124 public: 125 explicit ResultBuilder(Sema &SemaRef, LookupFilter Filter = 0) 126 : SemaRef(SemaRef), Filter(Filter), AllowNestedNameSpecifiers(false) { } 127 128 /// \brief Set the filter used for code-completion results. 129 void setFilter(LookupFilter Filter) { 130 this->Filter = Filter; 131 } 132 133 typedef std::vector<Result>::iterator iterator; 134 iterator begin() { return Results.begin(); } 135 iterator end() { return Results.end(); } 136 137 Result *data() { return Results.empty()? 0 : &Results.front(); } 138 unsigned size() const { return Results.size(); } 139 bool empty() const { return Results.empty(); } 140 141 /// \brief Specify whether nested-name-specifiers are allowed. 142 void allowNestedNameSpecifiers(bool Allow = true) { 143 AllowNestedNameSpecifiers = Allow; 144 } 145 146 /// \brief Determine whether the given declaration is at all interesting 147 /// as a code-completion result. 148 /// 149 /// \param ND the declaration that we are inspecting. 150 /// 151 /// \param AsNestedNameSpecifier will be set true if this declaration is 152 /// only interesting when it is a nested-name-specifier. 153 bool isInterestingDecl(NamedDecl *ND, bool &AsNestedNameSpecifier) const; 154 155 /// \brief Check whether the result is hidden by the Hiding declaration. 156 /// 157 /// \returns true if the result is hidden and cannot be found, false if 158 /// the hidden result could still be found. When false, \p R may be 159 /// modified to describe how the result can be found (e.g., via extra 160 /// qualification). 161 bool CheckHiddenResult(Result &R, DeclContext *CurContext, 162 NamedDecl *Hiding); 163 164 /// \brief Add a new result to this result set (if it isn't already in one 165 /// of the shadow maps), or replace an existing result (for, e.g., a 166 /// redeclaration). 167 /// 168 /// \param CurContext the result to add (if it is unique). 169 /// 170 /// \param R the context in which this result will be named. 171 void MaybeAddResult(Result R, DeclContext *CurContext = 0); 172 173 /// \brief Add a new result to this result set, where we already know 174 /// the hiding declation (if any). 175 /// 176 /// \param R the result to add (if it is unique). 177 /// 178 /// \param CurContext the context in which this result will be named. 179 /// 180 /// \param Hiding the declaration that hides the result. 181 /// 182 /// \param InBaseClass whether the result was found in a base 183 /// class of the searched context. 184 void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding, 185 bool InBaseClass); 186 187 /// \brief Add a new non-declaration result to this result set. 188 void AddResult(Result R); 189 190 /// \brief Enter into a new scope. 191 void EnterNewScope(); 192 193 /// \brief Exit from the current scope. 194 void ExitScope(); 195 196 /// \brief Ignore this declaration, if it is seen again. 197 void Ignore(Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); } 198 199 /// \name Name lookup predicates 200 /// 201 /// These predicates can be passed to the name lookup functions to filter the 202 /// results of name lookup. All of the predicates have the same type, so that 203 /// 204 //@{ 205 bool IsOrdinaryName(NamedDecl *ND) const; 206 bool IsOrdinaryNonValueName(NamedDecl *ND) const; 207 bool IsNestedNameSpecifier(NamedDecl *ND) const; 208 bool IsEnum(NamedDecl *ND) const; 209 bool IsClassOrStruct(NamedDecl *ND) const; 210 bool IsUnion(NamedDecl *ND) const; 211 bool IsNamespace(NamedDecl *ND) const; 212 bool IsNamespaceOrAlias(NamedDecl *ND) const; 213 bool IsType(NamedDecl *ND) const; 214 bool IsMember(NamedDecl *ND) const; 215 bool IsObjCIvar(NamedDecl *ND) const; 216 //@} 217 }; 218} 219 220class ResultBuilder::ShadowMapEntry::iterator { 221 llvm::PointerUnion<NamedDecl*, const DeclIndexPair*> DeclOrIterator; 222 unsigned SingleDeclIndex; 223 224public: 225 typedef DeclIndexPair value_type; 226 typedef value_type reference; 227 typedef std::ptrdiff_t difference_type; 228 typedef std::input_iterator_tag iterator_category; 229 230 class pointer { 231 DeclIndexPair Value; 232 233 public: 234 pointer(const DeclIndexPair &Value) : Value(Value) { } 235 236 const DeclIndexPair *operator->() const { 237 return &Value; 238 } 239 }; 240 241 iterator() : DeclOrIterator((NamedDecl *)0), SingleDeclIndex(0) { } 242 243 iterator(NamedDecl *SingleDecl, unsigned Index) 244 : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) { } 245 246 iterator(const DeclIndexPair *Iterator) 247 : DeclOrIterator(Iterator), SingleDeclIndex(0) { } 248 249 iterator &operator++() { 250 if (DeclOrIterator.is<NamedDecl *>()) { 251 DeclOrIterator = (NamedDecl *)0; 252 SingleDeclIndex = 0; 253 return *this; 254 } 255 256 const DeclIndexPair *I = DeclOrIterator.get<const DeclIndexPair*>(); 257 ++I; 258 DeclOrIterator = I; 259 return *this; 260 } 261 262 iterator operator++(int) { 263 iterator tmp(*this); 264 ++(*this); 265 return tmp; 266 } 267 268 reference operator*() const { 269 if (NamedDecl *ND = DeclOrIterator.dyn_cast<NamedDecl *>()) 270 return reference(ND, SingleDeclIndex); 271 272 return *DeclOrIterator.get<const DeclIndexPair*>(); 273 } 274 275 pointer operator->() const { 276 return pointer(**this); 277 } 278 279 friend bool operator==(const iterator &X, const iterator &Y) { 280 return X.DeclOrIterator.getOpaqueValue() 281 == Y.DeclOrIterator.getOpaqueValue() && 282 X.SingleDeclIndex == Y.SingleDeclIndex; 283 } 284 285 friend bool operator!=(const iterator &X, const iterator &Y) { 286 return !(X == Y); 287 } 288}; 289 290ResultBuilder::ShadowMapEntry::iterator 291ResultBuilder::ShadowMapEntry::begin() const { 292 if (DeclOrVector.isNull()) 293 return iterator(); 294 295 if (NamedDecl *ND = DeclOrVector.dyn_cast<NamedDecl *>()) 296 return iterator(ND, SingleDeclIndex); 297 298 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin()); 299} 300 301ResultBuilder::ShadowMapEntry::iterator 302ResultBuilder::ShadowMapEntry::end() const { 303 if (DeclOrVector.is<NamedDecl *>() || DeclOrVector.isNull()) 304 return iterator(); 305 306 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end()); 307} 308 309/// \brief Compute the qualification required to get from the current context 310/// (\p CurContext) to the target context (\p TargetContext). 311/// 312/// \param Context the AST context in which the qualification will be used. 313/// 314/// \param CurContext the context where an entity is being named, which is 315/// typically based on the current scope. 316/// 317/// \param TargetContext the context in which the named entity actually 318/// resides. 319/// 320/// \returns a nested name specifier that refers into the target context, or 321/// NULL if no qualification is needed. 322static NestedNameSpecifier * 323getRequiredQualification(ASTContext &Context, 324 DeclContext *CurContext, 325 DeclContext *TargetContext) { 326 llvm::SmallVector<DeclContext *, 4> TargetParents; 327 328 for (DeclContext *CommonAncestor = TargetContext; 329 CommonAncestor && !CommonAncestor->Encloses(CurContext); 330 CommonAncestor = CommonAncestor->getLookupParent()) { 331 if (CommonAncestor->isTransparentContext() || 332 CommonAncestor->isFunctionOrMethod()) 333 continue; 334 335 TargetParents.push_back(CommonAncestor); 336 } 337 338 NestedNameSpecifier *Result = 0; 339 while (!TargetParents.empty()) { 340 DeclContext *Parent = TargetParents.back(); 341 TargetParents.pop_back(); 342 343 if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Parent)) 344 Result = NestedNameSpecifier::Create(Context, Result, Namespace); 345 else if (TagDecl *TD = dyn_cast<TagDecl>(Parent)) 346 Result = NestedNameSpecifier::Create(Context, Result, 347 false, 348 Context.getTypeDeclType(TD).getTypePtr()); 349 else 350 assert(Parent->isTranslationUnit()); 351 } 352 return Result; 353} 354 355bool ResultBuilder::isInterestingDecl(NamedDecl *ND, 356 bool &AsNestedNameSpecifier) const { 357 AsNestedNameSpecifier = false; 358 359 ND = ND->getUnderlyingDecl(); 360 unsigned IDNS = ND->getIdentifierNamespace(); 361 362 // Skip unnamed entities. 363 if (!ND->getDeclName()) 364 return false; 365 366 // Friend declarations and declarations introduced due to friends are never 367 // added as results. 368 if (isa<FriendDecl>(ND) || 369 (IDNS & (Decl::IDNS_OrdinaryFriend | Decl::IDNS_TagFriend))) 370 return false; 371 372 // Class template (partial) specializations are never added as results. 373 if (isa<ClassTemplateSpecializationDecl>(ND) || 374 isa<ClassTemplatePartialSpecializationDecl>(ND)) 375 return false; 376 377 // Using declarations themselves are never added as results. 378 if (isa<UsingDecl>(ND)) 379 return false; 380 381 // Some declarations have reserved names that we don't want to ever show. 382 if (const IdentifierInfo *Id = ND->getIdentifier()) { 383 // __va_list_tag is a freak of nature. Find it and skip it. 384 if (Id->isStr("__va_list_tag") || Id->isStr("__builtin_va_list")) 385 return false; 386 387 // Filter out names reserved for the implementation (C99 7.1.3, 388 // C++ [lib.global.names]). Users don't need to see those. 389 // 390 // FIXME: Add predicate for this. 391 if (Id->getLength() >= 2) { 392 const char *Name = Id->getNameStart(); 393 if (Name[0] == '_' && 394 (Name[1] == '_' || (Name[1] >= 'A' && Name[1] <= 'Z'))) 395 return false; 396 } 397 } 398 399 // C++ constructors are never found by name lookup. 400 if (isa<CXXConstructorDecl>(ND)) 401 return false; 402 403 // Filter out any unwanted results. 404 if (Filter && !(this->*Filter)(ND)) { 405 // Check whether it is interesting as a nested-name-specifier. 406 if (AllowNestedNameSpecifiers && SemaRef.getLangOptions().CPlusPlus && 407 IsNestedNameSpecifier(ND) && 408 (Filter != &ResultBuilder::IsMember || 409 (isa<CXXRecordDecl>(ND) && 410 cast<CXXRecordDecl>(ND)->isInjectedClassName()))) { 411 AsNestedNameSpecifier = true; 412 return true; 413 } 414 415 return false; 416 } 417 418 // ... then it must be interesting! 419 return true; 420} 421 422bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext, 423 NamedDecl *Hiding) { 424 // In C, there is no way to refer to a hidden name. 425 // FIXME: This isn't true; we can find a tag name hidden by an ordinary 426 // name if we introduce the tag type. 427 if (!SemaRef.getLangOptions().CPlusPlus) 428 return true; 429 430 DeclContext *HiddenCtx = R.Declaration->getDeclContext()->getLookupContext(); 431 432 // There is no way to qualify a name declared in a function or method. 433 if (HiddenCtx->isFunctionOrMethod()) 434 return true; 435 436 if (HiddenCtx == Hiding->getDeclContext()->getLookupContext()) 437 return true; 438 439 // We can refer to the result with the appropriate qualification. Do it. 440 R.Hidden = true; 441 R.QualifierIsInformative = false; 442 443 if (!R.Qualifier) 444 R.Qualifier = getRequiredQualification(SemaRef.Context, 445 CurContext, 446 R.Declaration->getDeclContext()); 447 return false; 448} 449 450void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) { 451 assert(!ShadowMaps.empty() && "Must enter into a results scope"); 452 453 if (R.Kind != Result::RK_Declaration) { 454 // For non-declaration results, just add the result. 455 Results.push_back(R); 456 return; 457 } 458 459 // Look through using declarations. 460 if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) { 461 MaybeAddResult(Result(Using->getTargetDecl(), R.Qualifier), CurContext); 462 return; 463 } 464 465 Decl *CanonDecl = R.Declaration->getCanonicalDecl(); 466 unsigned IDNS = CanonDecl->getIdentifierNamespace(); 467 468 bool AsNestedNameSpecifier = false; 469 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier)) 470 return; 471 472 ShadowMap &SMap = ShadowMaps.back(); 473 ShadowMapEntry::iterator I, IEnd; 474 ShadowMap::iterator NamePos = SMap.find(R.Declaration->getDeclName()); 475 if (NamePos != SMap.end()) { 476 I = NamePos->second.begin(); 477 IEnd = NamePos->second.end(); 478 } 479 480 for (; I != IEnd; ++I) { 481 NamedDecl *ND = I->first; 482 unsigned Index = I->second; 483 if (ND->getCanonicalDecl() == CanonDecl) { 484 // This is a redeclaration. Always pick the newer declaration. 485 Results[Index].Declaration = R.Declaration; 486 487 // We're done. 488 return; 489 } 490 } 491 492 // This is a new declaration in this scope. However, check whether this 493 // declaration name is hidden by a similarly-named declaration in an outer 494 // scope. 495 std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end(); 496 --SMEnd; 497 for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) { 498 ShadowMapEntry::iterator I, IEnd; 499 ShadowMap::iterator NamePos = SM->find(R.Declaration->getDeclName()); 500 if (NamePos != SM->end()) { 501 I = NamePos->second.begin(); 502 IEnd = NamePos->second.end(); 503 } 504 for (; I != IEnd; ++I) { 505 // A tag declaration does not hide a non-tag declaration. 506 if (I->first->getIdentifierNamespace() == Decl::IDNS_Tag && 507 (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary | 508 Decl::IDNS_ObjCProtocol))) 509 continue; 510 511 // Protocols are in distinct namespaces from everything else. 512 if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol) 513 || (IDNS & Decl::IDNS_ObjCProtocol)) && 514 I->first->getIdentifierNamespace() != IDNS) 515 continue; 516 517 // The newly-added result is hidden by an entry in the shadow map. 518 if (CheckHiddenResult(R, CurContext, I->first)) 519 return; 520 521 break; 522 } 523 } 524 525 // Make sure that any given declaration only shows up in the result set once. 526 if (!AllDeclsFound.insert(CanonDecl)) 527 return; 528 529 // If the filter is for nested-name-specifiers, then this result starts a 530 // nested-name-specifier. 531 if (AsNestedNameSpecifier) 532 R.StartsNestedNameSpecifier = true; 533 534 // If this result is supposed to have an informative qualifier, add one. 535 if (R.QualifierIsInformative && !R.Qualifier && 536 !R.StartsNestedNameSpecifier) { 537 DeclContext *Ctx = R.Declaration->getDeclContext(); 538 if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx)) 539 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, Namespace); 540 else if (TagDecl *Tag = dyn_cast<TagDecl>(Ctx)) 541 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, false, 542 SemaRef.Context.getTypeDeclType(Tag).getTypePtr()); 543 else 544 R.QualifierIsInformative = false; 545 } 546 547 // Insert this result into the set of results and into the current shadow 548 // map. 549 SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size()); 550 Results.push_back(R); 551} 552 553void ResultBuilder::AddResult(Result R, DeclContext *CurContext, 554 NamedDecl *Hiding, bool InBaseClass = false) { 555 if (R.Kind != Result::RK_Declaration) { 556 // For non-declaration results, just add the result. 557 Results.push_back(R); 558 return; 559 } 560 561 // Look through using declarations. 562 if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) { 563 AddResult(Result(Using->getTargetDecl(), R.Qualifier), CurContext, Hiding); 564 return; 565 } 566 567 bool AsNestedNameSpecifier = false; 568 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier)) 569 return; 570 571 if (Hiding && CheckHiddenResult(R, CurContext, Hiding)) 572 return; 573 574 // Make sure that any given declaration only shows up in the result set once. 575 if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl())) 576 return; 577 578 // If the filter is for nested-name-specifiers, then this result starts a 579 // nested-name-specifier. 580 if (AsNestedNameSpecifier) 581 R.StartsNestedNameSpecifier = true; 582 else if (Filter == &ResultBuilder::IsMember && !R.Qualifier && InBaseClass && 583 isa<CXXRecordDecl>(R.Declaration->getDeclContext() 584 ->getLookupContext())) 585 R.QualifierIsInformative = true; 586 587 // If this result is supposed to have an informative qualifier, add one. 588 if (R.QualifierIsInformative && !R.Qualifier && 589 !R.StartsNestedNameSpecifier) { 590 DeclContext *Ctx = R.Declaration->getDeclContext(); 591 if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx)) 592 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, Namespace); 593 else if (TagDecl *Tag = dyn_cast<TagDecl>(Ctx)) 594 R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, 0, false, 595 SemaRef.Context.getTypeDeclType(Tag).getTypePtr()); 596 else 597 R.QualifierIsInformative = false; 598 } 599 600 // Insert this result into the set of results. 601 Results.push_back(R); 602} 603 604void ResultBuilder::AddResult(Result R) { 605 assert(R.Kind != Result::RK_Declaration && 606 "Declaration results need more context"); 607 Results.push_back(R); 608} 609 610/// \brief Enter into a new scope. 611void ResultBuilder::EnterNewScope() { 612 ShadowMaps.push_back(ShadowMap()); 613} 614 615/// \brief Exit from the current scope. 616void ResultBuilder::ExitScope() { 617 for (ShadowMap::iterator E = ShadowMaps.back().begin(), 618 EEnd = ShadowMaps.back().end(); 619 E != EEnd; 620 ++E) 621 E->second.Destroy(); 622 623 ShadowMaps.pop_back(); 624} 625 626/// \brief Determines whether this given declaration will be found by 627/// ordinary name lookup. 628bool ResultBuilder::IsOrdinaryName(NamedDecl *ND) const { 629 unsigned IDNS = Decl::IDNS_Ordinary; 630 if (SemaRef.getLangOptions().CPlusPlus) 631 IDNS |= Decl::IDNS_Tag; 632 else if (SemaRef.getLangOptions().ObjC1 && isa<ObjCIvarDecl>(ND)) 633 return true; 634 635 return ND->getIdentifierNamespace() & IDNS; 636} 637 638/// \brief Determines whether this given declaration will be found by 639/// ordinary name lookup. 640bool ResultBuilder::IsOrdinaryNonValueName(NamedDecl *ND) const { 641 unsigned IDNS = Decl::IDNS_Ordinary; 642 if (SemaRef.getLangOptions().CPlusPlus) 643 IDNS |= Decl::IDNS_Tag; 644 645 return (ND->getIdentifierNamespace() & IDNS) && 646 !isa<ValueDecl>(ND) && !isa<FunctionTemplateDecl>(ND); 647} 648 649/// \brief Determines whether the given declaration is suitable as the 650/// start of a C++ nested-name-specifier, e.g., a class or namespace. 651bool ResultBuilder::IsNestedNameSpecifier(NamedDecl *ND) const { 652 // Allow us to find class templates, too. 653 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND)) 654 ND = ClassTemplate->getTemplatedDecl(); 655 656 return SemaRef.isAcceptableNestedNameSpecifier(ND); 657} 658 659/// \brief Determines whether the given declaration is an enumeration. 660bool ResultBuilder::IsEnum(NamedDecl *ND) const { 661 return isa<EnumDecl>(ND); 662} 663 664/// \brief Determines whether the given declaration is a class or struct. 665bool ResultBuilder::IsClassOrStruct(NamedDecl *ND) const { 666 // Allow us to find class templates, too. 667 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND)) 668 ND = ClassTemplate->getTemplatedDecl(); 669 670 if (RecordDecl *RD = dyn_cast<RecordDecl>(ND)) 671 return RD->getTagKind() == TagDecl::TK_class || 672 RD->getTagKind() == TagDecl::TK_struct; 673 674 return false; 675} 676 677/// \brief Determines whether the given declaration is a union. 678bool ResultBuilder::IsUnion(NamedDecl *ND) const { 679 // Allow us to find class templates, too. 680 if (ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND)) 681 ND = ClassTemplate->getTemplatedDecl(); 682 683 if (RecordDecl *RD = dyn_cast<RecordDecl>(ND)) 684 return RD->getTagKind() == TagDecl::TK_union; 685 686 return false; 687} 688 689/// \brief Determines whether the given declaration is a namespace. 690bool ResultBuilder::IsNamespace(NamedDecl *ND) const { 691 return isa<NamespaceDecl>(ND); 692} 693 694/// \brief Determines whether the given declaration is a namespace or 695/// namespace alias. 696bool ResultBuilder::IsNamespaceOrAlias(NamedDecl *ND) const { 697 return isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND); 698} 699 700/// \brief Determines whether the given declaration is a type. 701bool ResultBuilder::IsType(NamedDecl *ND) const { 702 return isa<TypeDecl>(ND); 703} 704 705/// \brief Determines which members of a class should be visible via 706/// "." or "->". Only value declarations, nested name specifiers, and 707/// using declarations thereof should show up. 708bool ResultBuilder::IsMember(NamedDecl *ND) const { 709 if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(ND)) 710 ND = Using->getTargetDecl(); 711 712 return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) || 713 isa<ObjCPropertyDecl>(ND); 714} 715 716/// \rief Determines whether the given declaration is an Objective-C 717/// instance variable. 718bool ResultBuilder::IsObjCIvar(NamedDecl *ND) const { 719 return isa<ObjCIvarDecl>(ND); 720} 721 722namespace { 723 /// \brief Visible declaration consumer that adds a code-completion result 724 /// for each visible declaration. 725 class CodeCompletionDeclConsumer : public VisibleDeclConsumer { 726 ResultBuilder &Results; 727 DeclContext *CurContext; 728 729 public: 730 CodeCompletionDeclConsumer(ResultBuilder &Results, DeclContext *CurContext) 731 : Results(Results), CurContext(CurContext) { } 732 733 virtual void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, bool InBaseClass) { 734 Results.AddResult(ND, CurContext, Hiding, InBaseClass); 735 } 736 }; 737} 738 739/// \brief Add type specifiers for the current language as keyword results. 740static void AddTypeSpecifierResults(const LangOptions &LangOpts, 741 ResultBuilder &Results) { 742 typedef CodeCompleteConsumer::Result Result; 743 Results.AddResult(Result("short")); 744 Results.AddResult(Result("long")); 745 Results.AddResult(Result("signed")); 746 Results.AddResult(Result("unsigned")); 747 Results.AddResult(Result("void")); 748 Results.AddResult(Result("char")); 749 Results.AddResult(Result("int")); 750 Results.AddResult(Result("float")); 751 Results.AddResult(Result("double")); 752 Results.AddResult(Result("enum")); 753 Results.AddResult(Result("struct")); 754 Results.AddResult(Result("union")); 755 Results.AddResult(Result("const")); 756 Results.AddResult(Result("volatile")); 757 758 if (LangOpts.C99) { 759 // C99-specific 760 Results.AddResult(Result("_Complex")); 761 Results.AddResult(Result("_Imaginary")); 762 Results.AddResult(Result("_Bool")); 763 Results.AddResult(Result("restrict")); 764 } 765 766 if (LangOpts.CPlusPlus) { 767 // C++-specific 768 Results.AddResult(Result("bool")); 769 Results.AddResult(Result("class")); 770 Results.AddResult(Result("wchar_t")); 771 772 // typename qualified-id 773 CodeCompletionString *Pattern = new CodeCompletionString; 774 Pattern->AddTypedTextChunk("typename"); 775 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 776 Pattern->AddPlaceholderChunk("qualified-id"); 777 Results.AddResult(Result(Pattern)); 778 779 if (LangOpts.CPlusPlus0x) { 780 Results.AddResult(Result("auto")); 781 Results.AddResult(Result("char16_t")); 782 Results.AddResult(Result("char32_t")); 783 Results.AddResult(Result("decltype")); 784 } 785 } 786 787 // GNU extensions 788 if (LangOpts.GNUMode) { 789 // FIXME: Enable when we actually support decimal floating point. 790 // Results.AddResult(Result("_Decimal32")); 791 // Results.AddResult(Result("_Decimal64")); 792 // Results.AddResult(Result("_Decimal128")); 793 794 CodeCompletionString *Pattern = new CodeCompletionString; 795 Pattern->AddTypedTextChunk("typeof"); 796 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 797 Pattern->AddPlaceholderChunk("expression-or-type"); 798 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 799 Results.AddResult(Result(Pattern)); 800 } 801} 802 803static void AddStorageSpecifiers(Action::CodeCompletionContext CCC, 804 const LangOptions &LangOpts, 805 ResultBuilder &Results) { 806 typedef CodeCompleteConsumer::Result Result; 807 // Note: we don't suggest either "auto" or "register", because both 808 // are pointless as storage specifiers. Elsewhere, we suggest "auto" 809 // in C++0x as a type specifier. 810 Results.AddResult(Result("extern")); 811 Results.AddResult(Result("static")); 812} 813 814static void AddFunctionSpecifiers(Action::CodeCompletionContext CCC, 815 const LangOptions &LangOpts, 816 ResultBuilder &Results) { 817 typedef CodeCompleteConsumer::Result Result; 818 switch (CCC) { 819 case Action::CCC_Class: 820 case Action::CCC_MemberTemplate: 821 if (LangOpts.CPlusPlus) { 822 Results.AddResult(Result("explicit")); 823 Results.AddResult(Result("friend")); 824 Results.AddResult(Result("mutable")); 825 Results.AddResult(Result("virtual")); 826 } 827 // Fall through 828 829 case Action::CCC_ObjCInterface: 830 case Action::CCC_ObjCImplementation: 831 case Action::CCC_Namespace: 832 case Action::CCC_Template: 833 if (LangOpts.CPlusPlus || LangOpts.C99) 834 Results.AddResult(Result("inline")); 835 break; 836 837 case Action::CCC_ObjCInstanceVariableList: 838 case Action::CCC_Expression: 839 case Action::CCC_Statement: 840 case Action::CCC_ForInit: 841 case Action::CCC_Condition: 842 break; 843 } 844} 845 846static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt); 847static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt); 848static void AddObjCVisibilityResults(const LangOptions &LangOpts, 849 ResultBuilder &Results, 850 bool NeedAt); 851static void AddObjCImplementationResults(const LangOptions &LangOpts, 852 ResultBuilder &Results, 853 bool NeedAt); 854static void AddObjCInterfaceResults(const LangOptions &LangOpts, 855 ResultBuilder &Results, 856 bool NeedAt); 857static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt); 858 859/// \brief Add language constructs that show up for "ordinary" names. 860static void AddOrdinaryNameResults(Action::CodeCompletionContext CCC, 861 Scope *S, 862 Sema &SemaRef, 863 ResultBuilder &Results) { 864 typedef CodeCompleteConsumer::Result Result; 865 switch (CCC) { 866 case Action::CCC_Namespace: 867 if (SemaRef.getLangOptions().CPlusPlus) { 868 // namespace <identifier> { } 869 CodeCompletionString *Pattern = new CodeCompletionString; 870 Pattern->AddTypedTextChunk("namespace"); 871 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 872 Pattern->AddPlaceholderChunk("identifier"); 873 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 874 Pattern->AddPlaceholderChunk("declarations"); 875 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 876 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 877 Results.AddResult(Result(Pattern)); 878 879 // namespace identifier = identifier ; 880 Pattern = new CodeCompletionString; 881 Pattern->AddTypedTextChunk("namespace"); 882 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 883 Pattern->AddPlaceholderChunk("identifier"); 884 Pattern->AddChunk(CodeCompletionString::CK_Equal); 885 Pattern->AddPlaceholderChunk("identifier"); 886 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 887 Results.AddResult(Result(Pattern)); 888 889 // Using directives 890 Pattern = new CodeCompletionString; 891 Pattern->AddTypedTextChunk("using"); 892 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 893 Pattern->AddTextChunk("namespace"); 894 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 895 Pattern->AddPlaceholderChunk("identifier"); 896 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 897 Results.AddResult(Result(Pattern)); 898 899 // asm(string-literal) 900 Pattern = new CodeCompletionString; 901 Pattern->AddTypedTextChunk("asm"); 902 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 903 Pattern->AddPlaceholderChunk("string-literal"); 904 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 905 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 906 Results.AddResult(Result(Pattern)); 907 908 // Explicit template instantiation 909 Pattern = new CodeCompletionString; 910 Pattern->AddTypedTextChunk("template"); 911 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 912 Pattern->AddPlaceholderChunk("declaration"); 913 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 914 Results.AddResult(Result(Pattern)); 915 } 916 917 if (SemaRef.getLangOptions().ObjC1) 918 AddObjCTopLevelResults(Results, true); 919 920 // Fall through 921 922 case Action::CCC_Class: 923 Results.AddResult(Result("typedef")); 924 if (SemaRef.getLangOptions().CPlusPlus) { 925 // Using declaration 926 CodeCompletionString *Pattern = new CodeCompletionString; 927 Pattern->AddTypedTextChunk("using"); 928 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 929 Pattern->AddPlaceholderChunk("qualified-id"); 930 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 931 Results.AddResult(Result(Pattern)); 932 933 // using typename qualified-id; (only in a dependent context) 934 if (SemaRef.CurContext->isDependentContext()) { 935 Pattern = new CodeCompletionString; 936 Pattern->AddTypedTextChunk("using"); 937 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 938 Pattern->AddTextChunk("typename"); 939 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 940 Pattern->AddPlaceholderChunk("qualified-id"); 941 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 942 Results.AddResult(Result(Pattern)); 943 } 944 945 if (CCC == Action::CCC_Class) { 946 // public: 947 Pattern = new CodeCompletionString; 948 Pattern->AddTypedTextChunk("public"); 949 Pattern->AddChunk(CodeCompletionString::CK_Colon); 950 Results.AddResult(Result(Pattern)); 951 952 // protected: 953 Pattern = new CodeCompletionString; 954 Pattern->AddTypedTextChunk("protected"); 955 Pattern->AddChunk(CodeCompletionString::CK_Colon); 956 Results.AddResult(Result(Pattern)); 957 958 // private: 959 Pattern = new CodeCompletionString; 960 Pattern->AddTypedTextChunk("private"); 961 Pattern->AddChunk(CodeCompletionString::CK_Colon); 962 Results.AddResult(Result(Pattern)); 963 } 964 } 965 // Fall through 966 967 case Action::CCC_Template: 968 case Action::CCC_MemberTemplate: 969 if (SemaRef.getLangOptions().CPlusPlus) { 970 // template < parameters > 971 CodeCompletionString *Pattern = new CodeCompletionString; 972 Pattern->AddTypedTextChunk("template"); 973 Pattern->AddChunk(CodeCompletionString::CK_LeftAngle); 974 Pattern->AddPlaceholderChunk("parameters"); 975 Pattern->AddChunk(CodeCompletionString::CK_RightAngle); 976 Results.AddResult(Result(Pattern)); 977 } 978 979 AddStorageSpecifiers(CCC, SemaRef.getLangOptions(), Results); 980 AddFunctionSpecifiers(CCC, SemaRef.getLangOptions(), Results); 981 break; 982 983 case Action::CCC_ObjCInterface: 984 AddObjCInterfaceResults(SemaRef.getLangOptions(), Results, true); 985 AddStorageSpecifiers(CCC, SemaRef.getLangOptions(), Results); 986 AddFunctionSpecifiers(CCC, SemaRef.getLangOptions(), Results); 987 break; 988 989 case Action::CCC_ObjCImplementation: 990 AddObjCImplementationResults(SemaRef.getLangOptions(), Results, true); 991 AddStorageSpecifiers(CCC, SemaRef.getLangOptions(), Results); 992 AddFunctionSpecifiers(CCC, SemaRef.getLangOptions(), Results); 993 break; 994 995 case Action::CCC_ObjCInstanceVariableList: 996 AddObjCVisibilityResults(SemaRef.getLangOptions(), Results, true); 997 break; 998 999 case Action::CCC_Statement: { 1000 Results.AddResult(Result("typedef")); 1001 1002 CodeCompletionString *Pattern = 0; 1003 if (SemaRef.getLangOptions().CPlusPlus) { 1004 Pattern = new CodeCompletionString; 1005 Pattern->AddTypedTextChunk("try"); 1006 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 1007 Pattern->AddPlaceholderChunk("statements"); 1008 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 1009 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 1010 Pattern->AddTextChunk("catch"); 1011 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1012 Pattern->AddPlaceholderChunk("declaration"); 1013 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1014 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 1015 Pattern->AddPlaceholderChunk("statements"); 1016 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 1017 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 1018 Results.AddResult(Result(Pattern)); 1019 } 1020 if (SemaRef.getLangOptions().ObjC1) 1021 AddObjCStatementResults(Results, true); 1022 1023 // if (condition) { statements } 1024 Pattern = new CodeCompletionString; 1025 Pattern->AddTypedTextChunk("if"); 1026 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1027 if (SemaRef.getLangOptions().CPlusPlus) 1028 Pattern->AddPlaceholderChunk("condition"); 1029 else 1030 Pattern->AddPlaceholderChunk("expression"); 1031 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1032 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 1033 Pattern->AddPlaceholderChunk("statements"); 1034 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 1035 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 1036 Results.AddResult(Result(Pattern)); 1037 1038 // switch (condition) { } 1039 Pattern = new CodeCompletionString; 1040 Pattern->AddTypedTextChunk("switch"); 1041 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1042 if (SemaRef.getLangOptions().CPlusPlus) 1043 Pattern->AddPlaceholderChunk("condition"); 1044 else 1045 Pattern->AddPlaceholderChunk("expression"); 1046 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1047 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 1048 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 1049 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 1050 Results.AddResult(Result(Pattern)); 1051 1052 // Switch-specific statements. 1053 if (!SemaRef.getSwitchStack().empty()) { 1054 // case expression: 1055 Pattern = new CodeCompletionString; 1056 Pattern->AddTypedTextChunk("case"); 1057 Pattern->AddPlaceholderChunk("expression"); 1058 Pattern->AddChunk(CodeCompletionString::CK_Colon); 1059 Results.AddResult(Result(Pattern)); 1060 1061 // default: 1062 Pattern = new CodeCompletionString; 1063 Pattern->AddTypedTextChunk("default"); 1064 Pattern->AddChunk(CodeCompletionString::CK_Colon); 1065 Results.AddResult(Result(Pattern)); 1066 } 1067 1068 /// while (condition) { statements } 1069 Pattern = new CodeCompletionString; 1070 Pattern->AddTypedTextChunk("while"); 1071 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1072 if (SemaRef.getLangOptions().CPlusPlus) 1073 Pattern->AddPlaceholderChunk("condition"); 1074 else 1075 Pattern->AddPlaceholderChunk("expression"); 1076 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1077 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 1078 Pattern->AddPlaceholderChunk("statements"); 1079 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 1080 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 1081 Results.AddResult(Result(Pattern)); 1082 1083 // do { statements } while ( expression ); 1084 Pattern = new CodeCompletionString; 1085 Pattern->AddTypedTextChunk("do"); 1086 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 1087 Pattern->AddPlaceholderChunk("statements"); 1088 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 1089 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 1090 Pattern->AddTextChunk("while"); 1091 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1092 Pattern->AddPlaceholderChunk("expression"); 1093 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1094 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 1095 Results.AddResult(Result(Pattern)); 1096 1097 // for ( for-init-statement ; condition ; expression ) { statements } 1098 Pattern = new CodeCompletionString; 1099 Pattern->AddTypedTextChunk("for"); 1100 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1101 if (SemaRef.getLangOptions().CPlusPlus || SemaRef.getLangOptions().C99) 1102 Pattern->AddPlaceholderChunk("init-statement"); 1103 else 1104 Pattern->AddPlaceholderChunk("init-expression"); 1105 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 1106 Pattern->AddPlaceholderChunk("condition"); 1107 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 1108 Pattern->AddPlaceholderChunk("inc-expression"); 1109 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1110 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 1111 Pattern->AddPlaceholderChunk("statements"); 1112 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 1113 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 1114 Results.AddResult(Result(Pattern)); 1115 1116 if (S->getContinueParent()) { 1117 // continue ; 1118 Pattern = new CodeCompletionString; 1119 Pattern->AddTypedTextChunk("continue"); 1120 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 1121 Results.AddResult(Result(Pattern)); 1122 } 1123 1124 if (S->getBreakParent()) { 1125 // break ; 1126 Pattern = new CodeCompletionString; 1127 Pattern->AddTypedTextChunk("break"); 1128 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 1129 Results.AddResult(Result(Pattern)); 1130 } 1131 1132 // "return expression ;" or "return ;", depending on whether we 1133 // know the function is void or not. 1134 bool isVoid = false; 1135 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext)) 1136 isVoid = Function->getResultType()->isVoidType(); 1137 else if (ObjCMethodDecl *Method 1138 = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext)) 1139 isVoid = Method->getResultType()->isVoidType(); 1140 else if (SemaRef.CurBlock && !SemaRef.CurBlock->ReturnType.isNull()) 1141 isVoid = SemaRef.CurBlock->ReturnType->isVoidType(); 1142 Pattern = new CodeCompletionString; 1143 Pattern->AddTypedTextChunk("return"); 1144 if (!isVoid) 1145 Pattern->AddPlaceholderChunk("expression"); 1146 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 1147 Results.AddResult(Result(Pattern)); 1148 1149 // goto identifier ; 1150 Pattern = new CodeCompletionString; 1151 Pattern->AddTypedTextChunk("goto"); 1152 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1153 Pattern->AddPlaceholderChunk("identifier"); 1154 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 1155 Results.AddResult(Result(Pattern)); 1156 1157 // Using directives 1158 Pattern = new CodeCompletionString; 1159 Pattern->AddTypedTextChunk("using"); 1160 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1161 Pattern->AddTextChunk("namespace"); 1162 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1163 Pattern->AddPlaceholderChunk("identifier"); 1164 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 1165 Results.AddResult(Result(Pattern)); 1166 } 1167 1168 // Fall through (for statement expressions). 1169 case Action::CCC_ForInit: 1170 case Action::CCC_Condition: 1171 AddStorageSpecifiers(CCC, SemaRef.getLangOptions(), Results); 1172 // Fall through: conditions and statements can have expressions. 1173 1174 case Action::CCC_Expression: { 1175 CodeCompletionString *Pattern = 0; 1176 if (SemaRef.getLangOptions().CPlusPlus) { 1177 // 'this', if we're in a non-static member function. 1178 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(SemaRef.CurContext)) 1179 if (!Method->isStatic()) 1180 Results.AddResult(Result("this")); 1181 1182 // true, false 1183 Results.AddResult(Result("true")); 1184 Results.AddResult(Result("false")); 1185 1186 // dynamic_cast < type-id > ( expression ) 1187 Pattern = new CodeCompletionString; 1188 Pattern->AddTypedTextChunk("dynamic_cast"); 1189 Pattern->AddChunk(CodeCompletionString::CK_LeftAngle); 1190 Pattern->AddPlaceholderChunk("type-id"); 1191 Pattern->AddChunk(CodeCompletionString::CK_RightAngle); 1192 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1193 Pattern->AddPlaceholderChunk("expression"); 1194 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1195 Results.AddResult(Result(Pattern)); 1196 1197 // static_cast < type-id > ( expression ) 1198 Pattern = new CodeCompletionString; 1199 Pattern->AddTypedTextChunk("static_cast"); 1200 Pattern->AddChunk(CodeCompletionString::CK_LeftAngle); 1201 Pattern->AddPlaceholderChunk("type-id"); 1202 Pattern->AddChunk(CodeCompletionString::CK_RightAngle); 1203 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1204 Pattern->AddPlaceholderChunk("expression"); 1205 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1206 Results.AddResult(Result(Pattern)); 1207 1208 // reinterpret_cast < type-id > ( expression ) 1209 Pattern = new CodeCompletionString; 1210 Pattern->AddTypedTextChunk("reinterpret_cast"); 1211 Pattern->AddChunk(CodeCompletionString::CK_LeftAngle); 1212 Pattern->AddPlaceholderChunk("type-id"); 1213 Pattern->AddChunk(CodeCompletionString::CK_RightAngle); 1214 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1215 Pattern->AddPlaceholderChunk("expression"); 1216 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1217 Results.AddResult(Result(Pattern)); 1218 1219 // const_cast < type-id > ( expression ) 1220 Pattern = new CodeCompletionString; 1221 Pattern->AddTypedTextChunk("const_cast"); 1222 Pattern->AddChunk(CodeCompletionString::CK_LeftAngle); 1223 Pattern->AddPlaceholderChunk("type-id"); 1224 Pattern->AddChunk(CodeCompletionString::CK_RightAngle); 1225 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1226 Pattern->AddPlaceholderChunk("expression"); 1227 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1228 Results.AddResult(Result(Pattern)); 1229 1230 // typeid ( expression-or-type ) 1231 Pattern = new CodeCompletionString; 1232 Pattern->AddTypedTextChunk("typeid"); 1233 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1234 Pattern->AddPlaceholderChunk("expression-or-type"); 1235 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1236 Results.AddResult(Result(Pattern)); 1237 1238 // new T ( ... ) 1239 Pattern = new CodeCompletionString; 1240 Pattern->AddTypedTextChunk("new"); 1241 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1242 Pattern->AddPlaceholderChunk("type-id"); 1243 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1244 Pattern->AddPlaceholderChunk("expressions"); 1245 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1246 Results.AddResult(Result(Pattern)); 1247 1248 // new T [ ] ( ... ) 1249 Pattern = new CodeCompletionString; 1250 Pattern->AddTypedTextChunk("new"); 1251 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1252 Pattern->AddPlaceholderChunk("type-id"); 1253 Pattern->AddChunk(CodeCompletionString::CK_LeftBracket); 1254 Pattern->AddPlaceholderChunk("size"); 1255 Pattern->AddChunk(CodeCompletionString::CK_RightBracket); 1256 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1257 Pattern->AddPlaceholderChunk("expressions"); 1258 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1259 Results.AddResult(Result(Pattern)); 1260 1261 // delete expression 1262 Pattern = new CodeCompletionString; 1263 Pattern->AddTypedTextChunk("delete"); 1264 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1265 Pattern->AddPlaceholderChunk("expression"); 1266 Results.AddResult(Result(Pattern)); 1267 1268 // delete [] expression 1269 Pattern = new CodeCompletionString; 1270 Pattern->AddTypedTextChunk("delete"); 1271 Pattern->AddChunk(CodeCompletionString::CK_LeftBracket); 1272 Pattern->AddChunk(CodeCompletionString::CK_RightBracket); 1273 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1274 Pattern->AddPlaceholderChunk("expression"); 1275 Results.AddResult(Result(Pattern)); 1276 1277 // throw expression 1278 Pattern = new CodeCompletionString; 1279 Pattern->AddTypedTextChunk("throw"); 1280 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1281 Pattern->AddPlaceholderChunk("expression"); 1282 Results.AddResult(Result(Pattern)); 1283 } 1284 1285 if (SemaRef.getLangOptions().ObjC1) { 1286 // Add "super", if we're in an Objective-C class with a superclass. 1287 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) 1288 if (Method->getClassInterface()->getSuperClass()) 1289 Results.AddResult(Result("super")); 1290 1291 AddObjCExpressionResults(Results, true); 1292 } 1293 1294 // sizeof expression 1295 Pattern = new CodeCompletionString; 1296 Pattern->AddTypedTextChunk("sizeof"); 1297 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 1298 Pattern->AddPlaceholderChunk("expression-or-type"); 1299 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 1300 Results.AddResult(Result(Pattern)); 1301 break; 1302 } 1303 } 1304 1305 AddTypeSpecifierResults(SemaRef.getLangOptions(), Results); 1306 1307 if (SemaRef.getLangOptions().CPlusPlus) 1308 Results.AddResult(Result("operator")); 1309} 1310 1311/// \brief If the given declaration has an associated type, add it as a result 1312/// type chunk. 1313static void AddResultTypeChunk(ASTContext &Context, 1314 NamedDecl *ND, 1315 CodeCompletionString *Result) { 1316 if (!ND) 1317 return; 1318 1319 // Determine the type of the declaration (if it has a type). 1320 QualType T; 1321 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) 1322 T = Function->getResultType(); 1323 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) 1324 T = Method->getResultType(); 1325 else if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) 1326 T = FunTmpl->getTemplatedDecl()->getResultType(); 1327 else if (EnumConstantDecl *Enumerator = dyn_cast<EnumConstantDecl>(ND)) 1328 T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext())); 1329 else if (isa<UnresolvedUsingValueDecl>(ND)) { 1330 /* Do nothing: ignore unresolved using declarations*/ 1331 } else if (ValueDecl *Value = dyn_cast<ValueDecl>(ND)) 1332 T = Value->getType(); 1333 else if (ObjCPropertyDecl *Property = dyn_cast<ObjCPropertyDecl>(ND)) 1334 T = Property->getType(); 1335 1336 if (T.isNull() || Context.hasSameType(T, Context.DependentTy)) 1337 return; 1338 1339 std::string TypeStr; 1340 T.getAsStringInternal(TypeStr, Context.PrintingPolicy); 1341 Result->AddResultTypeChunk(TypeStr); 1342} 1343 1344/// \brief Add function parameter chunks to the given code completion string. 1345static void AddFunctionParameterChunks(ASTContext &Context, 1346 FunctionDecl *Function, 1347 CodeCompletionString *Result) { 1348 typedef CodeCompletionString::Chunk Chunk; 1349 1350 CodeCompletionString *CCStr = Result; 1351 1352 for (unsigned P = 0, N = Function->getNumParams(); P != N; ++P) { 1353 ParmVarDecl *Param = Function->getParamDecl(P); 1354 1355 if (Param->hasDefaultArg()) { 1356 // When we see an optional default argument, put that argument and 1357 // the remaining default arguments into a new, optional string. 1358 CodeCompletionString *Opt = new CodeCompletionString; 1359 CCStr->AddOptionalChunk(std::auto_ptr<CodeCompletionString>(Opt)); 1360 CCStr = Opt; 1361 } 1362 1363 if (P != 0) 1364 CCStr->AddChunk(Chunk(CodeCompletionString::CK_Comma)); 1365 1366 // Format the placeholder string. 1367 std::string PlaceholderStr; 1368 if (Param->getIdentifier()) 1369 PlaceholderStr = Param->getIdentifier()->getName(); 1370 1371 Param->getType().getAsStringInternal(PlaceholderStr, 1372 Context.PrintingPolicy); 1373 1374 // Add the placeholder string. 1375 CCStr->AddPlaceholderChunk(PlaceholderStr); 1376 } 1377 1378 if (const FunctionProtoType *Proto 1379 = Function->getType()->getAs<FunctionProtoType>()) 1380 if (Proto->isVariadic()) 1381 CCStr->AddPlaceholderChunk(", ..."); 1382} 1383 1384/// \brief Add template parameter chunks to the given code completion string. 1385static void AddTemplateParameterChunks(ASTContext &Context, 1386 TemplateDecl *Template, 1387 CodeCompletionString *Result, 1388 unsigned MaxParameters = 0) { 1389 typedef CodeCompletionString::Chunk Chunk; 1390 1391 CodeCompletionString *CCStr = Result; 1392 bool FirstParameter = true; 1393 1394 TemplateParameterList *Params = Template->getTemplateParameters(); 1395 TemplateParameterList::iterator PEnd = Params->end(); 1396 if (MaxParameters) 1397 PEnd = Params->begin() + MaxParameters; 1398 for (TemplateParameterList::iterator P = Params->begin(); P != PEnd; ++P) { 1399 bool HasDefaultArg = false; 1400 std::string PlaceholderStr; 1401 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) { 1402 if (TTP->wasDeclaredWithTypename()) 1403 PlaceholderStr = "typename"; 1404 else 1405 PlaceholderStr = "class"; 1406 1407 if (TTP->getIdentifier()) { 1408 PlaceholderStr += ' '; 1409 PlaceholderStr += TTP->getIdentifier()->getName(); 1410 } 1411 1412 HasDefaultArg = TTP->hasDefaultArgument(); 1413 } else if (NonTypeTemplateParmDecl *NTTP 1414 = dyn_cast<NonTypeTemplateParmDecl>(*P)) { 1415 if (NTTP->getIdentifier()) 1416 PlaceholderStr = NTTP->getIdentifier()->getName(); 1417 NTTP->getType().getAsStringInternal(PlaceholderStr, 1418 Context.PrintingPolicy); 1419 HasDefaultArg = NTTP->hasDefaultArgument(); 1420 } else { 1421 assert(isa<TemplateTemplateParmDecl>(*P)); 1422 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P); 1423 1424 // Since putting the template argument list into the placeholder would 1425 // be very, very long, we just use an abbreviation. 1426 PlaceholderStr = "template<...> class"; 1427 if (TTP->getIdentifier()) { 1428 PlaceholderStr += ' '; 1429 PlaceholderStr += TTP->getIdentifier()->getName(); 1430 } 1431 1432 HasDefaultArg = TTP->hasDefaultArgument(); 1433 } 1434 1435 if (HasDefaultArg) { 1436 // When we see an optional default argument, put that argument and 1437 // the remaining default arguments into a new, optional string. 1438 CodeCompletionString *Opt = new CodeCompletionString; 1439 CCStr->AddOptionalChunk(std::auto_ptr<CodeCompletionString>(Opt)); 1440 CCStr = Opt; 1441 } 1442 1443 if (FirstParameter) 1444 FirstParameter = false; 1445 else 1446 CCStr->AddChunk(Chunk(CodeCompletionString::CK_Comma)); 1447 1448 // Add the placeholder string. 1449 CCStr->AddPlaceholderChunk(PlaceholderStr); 1450 } 1451} 1452 1453/// \brief Add a qualifier to the given code-completion string, if the 1454/// provided nested-name-specifier is non-NULL. 1455static void 1456AddQualifierToCompletionString(CodeCompletionString *Result, 1457 NestedNameSpecifier *Qualifier, 1458 bool QualifierIsInformative, 1459 ASTContext &Context) { 1460 if (!Qualifier) 1461 return; 1462 1463 std::string PrintedNNS; 1464 { 1465 llvm::raw_string_ostream OS(PrintedNNS); 1466 Qualifier->print(OS, Context.PrintingPolicy); 1467 } 1468 if (QualifierIsInformative) 1469 Result->AddInformativeChunk(PrintedNNS); 1470 else 1471 Result->AddTextChunk(PrintedNNS); 1472} 1473 1474static void AddFunctionTypeQualsToCompletionString(CodeCompletionString *Result, 1475 FunctionDecl *Function) { 1476 const FunctionProtoType *Proto 1477 = Function->getType()->getAs<FunctionProtoType>(); 1478 if (!Proto || !Proto->getTypeQuals()) 1479 return; 1480 1481 std::string QualsStr; 1482 if (Proto->getTypeQuals() & Qualifiers::Const) 1483 QualsStr += " const"; 1484 if (Proto->getTypeQuals() & Qualifiers::Volatile) 1485 QualsStr += " volatile"; 1486 if (Proto->getTypeQuals() & Qualifiers::Restrict) 1487 QualsStr += " restrict"; 1488 Result->AddInformativeChunk(QualsStr); 1489} 1490 1491/// \brief If possible, create a new code completion string for the given 1492/// result. 1493/// 1494/// \returns Either a new, heap-allocated code completion string describing 1495/// how to use this result, or NULL to indicate that the string or name of the 1496/// result is all that is needed. 1497CodeCompletionString * 1498CodeCompleteConsumer::Result::CreateCodeCompletionString(Sema &S) { 1499 typedef CodeCompletionString::Chunk Chunk; 1500 1501 if (Kind == RK_Pattern) 1502 return Pattern->Clone(); 1503 1504 CodeCompletionString *Result = new CodeCompletionString; 1505 1506 if (Kind == RK_Keyword) { 1507 Result->AddTypedTextChunk(Keyword); 1508 return Result; 1509 } 1510 1511 if (Kind == RK_Macro) { 1512 MacroInfo *MI = S.PP.getMacroInfo(Macro); 1513 assert(MI && "Not a macro?"); 1514 1515 Result->AddTypedTextChunk(Macro->getName()); 1516 1517 if (!MI->isFunctionLike()) 1518 return Result; 1519 1520 // Format a function-like macro with placeholders for the arguments. 1521 Result->AddChunk(Chunk(CodeCompletionString::CK_LeftParen)); 1522 for (MacroInfo::arg_iterator A = MI->arg_begin(), AEnd = MI->arg_end(); 1523 A != AEnd; ++A) { 1524 if (A != MI->arg_begin()) 1525 Result->AddChunk(Chunk(CodeCompletionString::CK_Comma)); 1526 1527 if (!MI->isVariadic() || A != AEnd - 1) { 1528 // Non-variadic argument. 1529 Result->AddPlaceholderChunk((*A)->getName()); 1530 continue; 1531 } 1532 1533 // Variadic argument; cope with the different between GNU and C99 1534 // variadic macros, providing a single placeholder for the rest of the 1535 // arguments. 1536 if ((*A)->isStr("__VA_ARGS__")) 1537 Result->AddPlaceholderChunk("..."); 1538 else { 1539 std::string Arg = (*A)->getName(); 1540 Arg += "..."; 1541 Result->AddPlaceholderChunk(Arg); 1542 } 1543 } 1544 Result->AddChunk(Chunk(CodeCompletionString::CK_RightParen)); 1545 return Result; 1546 } 1547 1548 assert(Kind == RK_Declaration && "Missed a macro kind?"); 1549 NamedDecl *ND = Declaration; 1550 1551 if (StartsNestedNameSpecifier) { 1552 Result->AddTypedTextChunk(ND->getNameAsString()); 1553 Result->AddTextChunk("::"); 1554 return Result; 1555 } 1556 1557 AddResultTypeChunk(S.Context, ND, Result); 1558 1559 if (FunctionDecl *Function = dyn_cast<FunctionDecl>(ND)) { 1560 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, 1561 S.Context); 1562 Result->AddTypedTextChunk(Function->getNameAsString()); 1563 Result->AddChunk(Chunk(CodeCompletionString::CK_LeftParen)); 1564 AddFunctionParameterChunks(S.Context, Function, Result); 1565 Result->AddChunk(Chunk(CodeCompletionString::CK_RightParen)); 1566 AddFunctionTypeQualsToCompletionString(Result, Function); 1567 return Result; 1568 } 1569 1570 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(ND)) { 1571 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, 1572 S.Context); 1573 FunctionDecl *Function = FunTmpl->getTemplatedDecl(); 1574 Result->AddTypedTextChunk(Function->getNameAsString()); 1575 1576 // Figure out which template parameters are deduced (or have default 1577 // arguments). 1578 llvm::SmallVector<bool, 16> Deduced; 1579 S.MarkDeducedTemplateParameters(FunTmpl, Deduced); 1580 unsigned LastDeducibleArgument; 1581 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0; 1582 --LastDeducibleArgument) { 1583 if (!Deduced[LastDeducibleArgument - 1]) { 1584 // C++0x: Figure out if the template argument has a default. If so, 1585 // the user doesn't need to type this argument. 1586 // FIXME: We need to abstract template parameters better! 1587 bool HasDefaultArg = false; 1588 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam( 1589 LastDeducibleArgument - 1); 1590 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) 1591 HasDefaultArg = TTP->hasDefaultArgument(); 1592 else if (NonTypeTemplateParmDecl *NTTP 1593 = dyn_cast<NonTypeTemplateParmDecl>(Param)) 1594 HasDefaultArg = NTTP->hasDefaultArgument(); 1595 else { 1596 assert(isa<TemplateTemplateParmDecl>(Param)); 1597 HasDefaultArg 1598 = cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument(); 1599 } 1600 1601 if (!HasDefaultArg) 1602 break; 1603 } 1604 } 1605 1606 if (LastDeducibleArgument) { 1607 // Some of the function template arguments cannot be deduced from a 1608 // function call, so we introduce an explicit template argument list 1609 // containing all of the arguments up to the first deducible argument. 1610 Result->AddChunk(Chunk(CodeCompletionString::CK_LeftAngle)); 1611 AddTemplateParameterChunks(S.Context, FunTmpl, Result, 1612 LastDeducibleArgument); 1613 Result->AddChunk(Chunk(CodeCompletionString::CK_RightAngle)); 1614 } 1615 1616 // Add the function parameters 1617 Result->AddChunk(Chunk(CodeCompletionString::CK_LeftParen)); 1618 AddFunctionParameterChunks(S.Context, Function, Result); 1619 Result->AddChunk(Chunk(CodeCompletionString::CK_RightParen)); 1620 AddFunctionTypeQualsToCompletionString(Result, Function); 1621 return Result; 1622 } 1623 1624 if (TemplateDecl *Template = dyn_cast<TemplateDecl>(ND)) { 1625 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, 1626 S.Context); 1627 Result->AddTypedTextChunk(Template->getNameAsString()); 1628 Result->AddChunk(Chunk(CodeCompletionString::CK_LeftAngle)); 1629 AddTemplateParameterChunks(S.Context, Template, Result); 1630 Result->AddChunk(Chunk(CodeCompletionString::CK_RightAngle)); 1631 return Result; 1632 } 1633 1634 if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(ND)) { 1635 Selector Sel = Method->getSelector(); 1636 if (Sel.isUnarySelector()) { 1637 Result->AddTypedTextChunk(Sel.getIdentifierInfoForSlot(0)->getName()); 1638 return Result; 1639 } 1640 1641 std::string SelName = Sel.getIdentifierInfoForSlot(0)->getName().str(); 1642 SelName += ':'; 1643 if (StartParameter == 0) 1644 Result->AddTypedTextChunk(SelName); 1645 else { 1646 Result->AddInformativeChunk(SelName); 1647 1648 // If there is only one parameter, and we're past it, add an empty 1649 // typed-text chunk since there is nothing to type. 1650 if (Method->param_size() == 1) 1651 Result->AddTypedTextChunk(""); 1652 } 1653 unsigned Idx = 0; 1654 for (ObjCMethodDecl::param_iterator P = Method->param_begin(), 1655 PEnd = Method->param_end(); 1656 P != PEnd; (void)++P, ++Idx) { 1657 if (Idx > 0) { 1658 std::string Keyword; 1659 if (Idx > StartParameter) 1660 Result->AddChunk(CodeCompletionString::CK_HorizontalSpace); 1661 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx)) 1662 Keyword += II->getName().str(); 1663 Keyword += ":"; 1664 if (Idx < StartParameter || AllParametersAreInformative) { 1665 Result->AddInformativeChunk(Keyword); 1666 } else if (Idx == StartParameter) 1667 Result->AddTypedTextChunk(Keyword); 1668 else 1669 Result->AddTextChunk(Keyword); 1670 } 1671 1672 // If we're before the starting parameter, skip the placeholder. 1673 if (Idx < StartParameter) 1674 continue; 1675 1676 std::string Arg; 1677 (*P)->getType().getAsStringInternal(Arg, S.Context.PrintingPolicy); 1678 Arg = "(" + Arg + ")"; 1679 if (IdentifierInfo *II = (*P)->getIdentifier()) 1680 Arg += II->getName().str(); 1681 if (AllParametersAreInformative) 1682 Result->AddInformativeChunk(Arg); 1683 else 1684 Result->AddPlaceholderChunk(Arg); 1685 } 1686 1687 if (Method->isVariadic()) { 1688 if (AllParametersAreInformative) 1689 Result->AddInformativeChunk(", ..."); 1690 else 1691 Result->AddPlaceholderChunk(", ..."); 1692 } 1693 1694 return Result; 1695 } 1696 1697 if (Qualifier) 1698 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, 1699 S.Context); 1700 1701 Result->AddTypedTextChunk(ND->getNameAsString()); 1702 return Result; 1703} 1704 1705CodeCompletionString * 1706CodeCompleteConsumer::OverloadCandidate::CreateSignatureString( 1707 unsigned CurrentArg, 1708 Sema &S) const { 1709 typedef CodeCompletionString::Chunk Chunk; 1710 1711 CodeCompletionString *Result = new CodeCompletionString; 1712 FunctionDecl *FDecl = getFunction(); 1713 AddResultTypeChunk(S.Context, FDecl, Result); 1714 const FunctionProtoType *Proto 1715 = dyn_cast<FunctionProtoType>(getFunctionType()); 1716 if (!FDecl && !Proto) { 1717 // Function without a prototype. Just give the return type and a 1718 // highlighted ellipsis. 1719 const FunctionType *FT = getFunctionType(); 1720 Result->AddTextChunk( 1721 FT->getResultType().getAsString(S.Context.PrintingPolicy)); 1722 Result->AddChunk(Chunk(CodeCompletionString::CK_LeftParen)); 1723 Result->AddChunk(Chunk(CodeCompletionString::CK_CurrentParameter, "...")); 1724 Result->AddChunk(Chunk(CodeCompletionString::CK_RightParen)); 1725 return Result; 1726 } 1727 1728 if (FDecl) 1729 Result->AddTextChunk(FDecl->getNameAsString()); 1730 else 1731 Result->AddTextChunk( 1732 Proto->getResultType().getAsString(S.Context.PrintingPolicy)); 1733 1734 Result->AddChunk(Chunk(CodeCompletionString::CK_LeftParen)); 1735 unsigned NumParams = FDecl? FDecl->getNumParams() : Proto->getNumArgs(); 1736 for (unsigned I = 0; I != NumParams; ++I) { 1737 if (I) 1738 Result->AddChunk(Chunk(CodeCompletionString::CK_Comma)); 1739 1740 std::string ArgString; 1741 QualType ArgType; 1742 1743 if (FDecl) { 1744 ArgString = FDecl->getParamDecl(I)->getNameAsString(); 1745 ArgType = FDecl->getParamDecl(I)->getOriginalType(); 1746 } else { 1747 ArgType = Proto->getArgType(I); 1748 } 1749 1750 ArgType.getAsStringInternal(ArgString, S.Context.PrintingPolicy); 1751 1752 if (I == CurrentArg) 1753 Result->AddChunk(Chunk(CodeCompletionString::CK_CurrentParameter, 1754 ArgString)); 1755 else 1756 Result->AddTextChunk(ArgString); 1757 } 1758 1759 if (Proto && Proto->isVariadic()) { 1760 Result->AddChunk(Chunk(CodeCompletionString::CK_Comma)); 1761 if (CurrentArg < NumParams) 1762 Result->AddTextChunk("..."); 1763 else 1764 Result->AddChunk(Chunk(CodeCompletionString::CK_CurrentParameter, "...")); 1765 } 1766 Result->AddChunk(Chunk(CodeCompletionString::CK_RightParen)); 1767 1768 return Result; 1769} 1770 1771namespace { 1772 struct SortCodeCompleteResult { 1773 typedef CodeCompleteConsumer::Result Result; 1774 1775 bool isEarlierDeclarationName(DeclarationName X, DeclarationName Y) const { 1776 Selector XSel = X.getObjCSelector(); 1777 Selector YSel = Y.getObjCSelector(); 1778 if (!XSel.isNull() && !YSel.isNull()) { 1779 // We are comparing two selectors. 1780 unsigned N = std::min(XSel.getNumArgs(), YSel.getNumArgs()); 1781 if (N == 0) 1782 ++N; 1783 for (unsigned I = 0; I != N; ++I) { 1784 IdentifierInfo *XId = XSel.getIdentifierInfoForSlot(I); 1785 IdentifierInfo *YId = YSel.getIdentifierInfoForSlot(I); 1786 if (!XId || !YId) 1787 return XId && !YId; 1788 1789 switch (XId->getName().compare_lower(YId->getName())) { 1790 case -1: return true; 1791 case 1: return false; 1792 default: break; 1793 } 1794 } 1795 1796 return XSel.getNumArgs() < YSel.getNumArgs(); 1797 } 1798 1799 // For non-selectors, order by kind. 1800 if (X.getNameKind() != Y.getNameKind()) 1801 return X.getNameKind() < Y.getNameKind(); 1802 1803 // Order identifiers by comparison of their lowercased names. 1804 if (IdentifierInfo *XId = X.getAsIdentifierInfo()) 1805 return XId->getName().compare_lower( 1806 Y.getAsIdentifierInfo()->getName()) < 0; 1807 1808 // Order overloaded operators by the order in which they appear 1809 // in our list of operators. 1810 if (OverloadedOperatorKind XOp = X.getCXXOverloadedOperator()) 1811 return XOp < Y.getCXXOverloadedOperator(); 1812 1813 // Order C++0x user-defined literal operators lexically by their 1814 // lowercased suffixes. 1815 if (IdentifierInfo *XLit = X.getCXXLiteralIdentifier()) 1816 return XLit->getName().compare_lower( 1817 Y.getCXXLiteralIdentifier()->getName()) < 0; 1818 1819 // The only stable ordering we have is to turn the name into a 1820 // string and then compare the lower-case strings. This is 1821 // inefficient, but thankfully does not happen too often. 1822 return llvm::StringRef(X.getAsString()).compare_lower( 1823 Y.getAsString()) < 0; 1824 } 1825 1826 /// \brief Retrieve the name that should be used to order a result. 1827 /// 1828 /// If the name needs to be constructed as a string, that string will be 1829 /// saved into Saved and the returned StringRef will refer to it. 1830 static llvm::StringRef getOrderedName(const Result &R, 1831 std::string &Saved) { 1832 switch (R.Kind) { 1833 case Result::RK_Keyword: 1834 return R.Keyword; 1835 1836 case Result::RK_Pattern: 1837 return R.Pattern->getTypedText(); 1838 1839 case Result::RK_Macro: 1840 return R.Macro->getName(); 1841 1842 case Result::RK_Declaration: 1843 // Handle declarations below. 1844 break; 1845 } 1846 1847 DeclarationName Name = R.Declaration->getDeclName(); 1848 1849 // If the name is a simple identifier (by far the common case), or a 1850 // zero-argument selector, just return a reference to that identifier. 1851 if (IdentifierInfo *Id = Name.getAsIdentifierInfo()) 1852 return Id->getName(); 1853 if (Name.isObjCZeroArgSelector()) 1854 if (IdentifierInfo *Id 1855 = Name.getObjCSelector().getIdentifierInfoForSlot(0)) 1856 return Id->getName(); 1857 1858 Saved = Name.getAsString(); 1859 return Saved; 1860 } 1861 1862 bool operator()(const Result &X, const Result &Y) const { 1863 std::string XSaved, YSaved; 1864 llvm::StringRef XStr = getOrderedName(X, XSaved); 1865 llvm::StringRef YStr = getOrderedName(Y, YSaved); 1866 int cmp = XStr.compare_lower(YStr); 1867 if (cmp) 1868 return cmp < 0; 1869 1870 // Non-hidden names precede hidden names. 1871 if (X.Hidden != Y.Hidden) 1872 return !X.Hidden; 1873 1874 // Non-nested-name-specifiers precede nested-name-specifiers. 1875 if (X.StartsNestedNameSpecifier != Y.StartsNestedNameSpecifier) 1876 return !X.StartsNestedNameSpecifier; 1877 1878 return false; 1879 } 1880 }; 1881} 1882 1883static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results) { 1884 Results.EnterNewScope(); 1885 for (Preprocessor::macro_iterator M = PP.macro_begin(), 1886 MEnd = PP.macro_end(); 1887 M != MEnd; ++M) 1888 Results.AddResult(M->first); 1889 Results.ExitScope(); 1890} 1891 1892static void HandleCodeCompleteResults(Sema *S, 1893 CodeCompleteConsumer *CodeCompleter, 1894 CodeCompleteConsumer::Result *Results, 1895 unsigned NumResults) { 1896 std::stable_sort(Results, Results + NumResults, SortCodeCompleteResult()); 1897 1898 if (CodeCompleter) 1899 CodeCompleter->ProcessCodeCompleteResults(*S, Results, NumResults); 1900 1901 for (unsigned I = 0; I != NumResults; ++I) 1902 Results[I].Destroy(); 1903} 1904 1905void Sema::CodeCompleteOrdinaryName(Scope *S, 1906 CodeCompletionContext CompletionContext) { 1907 typedef CodeCompleteConsumer::Result Result; 1908 ResultBuilder Results(*this); 1909 1910 // Determine how to filter results, e.g., so that the names of 1911 // values (functions, enumerators, function templates, etc.) are 1912 // only allowed where we can have an expression. 1913 switch (CompletionContext) { 1914 case CCC_Namespace: 1915 case CCC_Class: 1916 case CCC_ObjCInterface: 1917 case CCC_ObjCImplementation: 1918 case CCC_ObjCInstanceVariableList: 1919 case CCC_Template: 1920 case CCC_MemberTemplate: 1921 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName); 1922 break; 1923 1924 case CCC_Expression: 1925 case CCC_Statement: 1926 case CCC_ForInit: 1927 case CCC_Condition: 1928 Results.setFilter(&ResultBuilder::IsOrdinaryName); 1929 break; 1930 } 1931 1932 CodeCompletionDeclConsumer Consumer(Results, CurContext); 1933 LookupVisibleDecls(S, LookupOrdinaryName, Consumer); 1934 1935 Results.EnterNewScope(); 1936 AddOrdinaryNameResults(CompletionContext, S, *this, Results); 1937 Results.ExitScope(); 1938 1939 if (CodeCompleter->includeMacros()) 1940 AddMacroResults(PP, Results); 1941 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 1942} 1943 1944static void AddObjCProperties(ObjCContainerDecl *Container, 1945 bool AllowCategories, 1946 DeclContext *CurContext, 1947 ResultBuilder &Results) { 1948 typedef CodeCompleteConsumer::Result Result; 1949 1950 // Add properties in this container. 1951 for (ObjCContainerDecl::prop_iterator P = Container->prop_begin(), 1952 PEnd = Container->prop_end(); 1953 P != PEnd; 1954 ++P) 1955 Results.MaybeAddResult(Result(*P, 0), CurContext); 1956 1957 // Add properties in referenced protocols. 1958 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) { 1959 for (ObjCProtocolDecl::protocol_iterator P = Protocol->protocol_begin(), 1960 PEnd = Protocol->protocol_end(); 1961 P != PEnd; ++P) 1962 AddObjCProperties(*P, AllowCategories, CurContext, Results); 1963 } else if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)){ 1964 if (AllowCategories) { 1965 // Look through categories. 1966 for (ObjCCategoryDecl *Category = IFace->getCategoryList(); 1967 Category; Category = Category->getNextClassCategory()) 1968 AddObjCProperties(Category, AllowCategories, CurContext, Results); 1969 } 1970 1971 // Look through protocols. 1972 for (ObjCInterfaceDecl::protocol_iterator I = IFace->protocol_begin(), 1973 E = IFace->protocol_end(); 1974 I != E; ++I) 1975 AddObjCProperties(*I, AllowCategories, CurContext, Results); 1976 1977 // Look in the superclass. 1978 if (IFace->getSuperClass()) 1979 AddObjCProperties(IFace->getSuperClass(), AllowCategories, CurContext, 1980 Results); 1981 } else if (const ObjCCategoryDecl *Category 1982 = dyn_cast<ObjCCategoryDecl>(Container)) { 1983 // Look through protocols. 1984 for (ObjCInterfaceDecl::protocol_iterator P = Category->protocol_begin(), 1985 PEnd = Category->protocol_end(); 1986 P != PEnd; ++P) 1987 AddObjCProperties(*P, AllowCategories, CurContext, Results); 1988 } 1989} 1990 1991void Sema::CodeCompleteMemberReferenceExpr(Scope *S, ExprTy *BaseE, 1992 SourceLocation OpLoc, 1993 bool IsArrow) { 1994 if (!BaseE || !CodeCompleter) 1995 return; 1996 1997 typedef CodeCompleteConsumer::Result Result; 1998 1999 Expr *Base = static_cast<Expr *>(BaseE); 2000 QualType BaseType = Base->getType(); 2001 2002 if (IsArrow) { 2003 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) 2004 BaseType = Ptr->getPointeeType(); 2005 else if (BaseType->isObjCObjectPointerType()) 2006 /*Do nothing*/ ; 2007 else 2008 return; 2009 } 2010 2011 ResultBuilder Results(*this, &ResultBuilder::IsMember); 2012 Results.EnterNewScope(); 2013 if (const RecordType *Record = BaseType->getAs<RecordType>()) { 2014 // Access to a C/C++ class, struct, or union. 2015 Results.allowNestedNameSpecifiers(); 2016 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2017 LookupVisibleDecls(Record->getDecl(), LookupMemberName, Consumer); 2018 2019 if (getLangOptions().CPlusPlus) { 2020 if (!Results.empty()) { 2021 // The "template" keyword can follow "->" or "." in the grammar. 2022 // However, we only want to suggest the template keyword if something 2023 // is dependent. 2024 bool IsDependent = BaseType->isDependentType(); 2025 if (!IsDependent) { 2026 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent()) 2027 if (DeclContext *Ctx = (DeclContext *)DepScope->getEntity()) { 2028 IsDependent = Ctx->isDependentContext(); 2029 break; 2030 } 2031 } 2032 2033 if (IsDependent) 2034 Results.AddResult(Result("template")); 2035 } 2036 } 2037 } else if (!IsArrow && BaseType->getAsObjCInterfacePointerType()) { 2038 // Objective-C property reference. 2039 2040 // Add property results based on our interface. 2041 const ObjCObjectPointerType *ObjCPtr 2042 = BaseType->getAsObjCInterfacePointerType(); 2043 assert(ObjCPtr && "Non-NULL pointer guaranteed above!"); 2044 AddObjCProperties(ObjCPtr->getInterfaceDecl(), true, CurContext, Results); 2045 2046 // Add properties from the protocols in a qualified interface. 2047 for (ObjCObjectPointerType::qual_iterator I = ObjCPtr->qual_begin(), 2048 E = ObjCPtr->qual_end(); 2049 I != E; ++I) 2050 AddObjCProperties(*I, true, CurContext, Results); 2051 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) || 2052 (!IsArrow && BaseType->isObjCInterfaceType())) { 2053 // Objective-C instance variable access. 2054 ObjCInterfaceDecl *Class = 0; 2055 if (const ObjCObjectPointerType *ObjCPtr 2056 = BaseType->getAs<ObjCObjectPointerType>()) 2057 Class = ObjCPtr->getInterfaceDecl(); 2058 else 2059 Class = BaseType->getAs<ObjCInterfaceType>()->getDecl(); 2060 2061 // Add all ivars from this class and its superclasses. 2062 if (Class) { 2063 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2064 Results.setFilter(&ResultBuilder::IsObjCIvar); 2065 LookupVisibleDecls(Class, LookupMemberName, Consumer); 2066 } 2067 } 2068 2069 // FIXME: How do we cope with isa? 2070 2071 Results.ExitScope(); 2072 2073 // Add macros 2074 if (CodeCompleter->includeMacros()) 2075 AddMacroResults(PP, Results); 2076 2077 // Hand off the results found for code completion. 2078 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2079} 2080 2081void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) { 2082 if (!CodeCompleter) 2083 return; 2084 2085 typedef CodeCompleteConsumer::Result Result; 2086 ResultBuilder::LookupFilter Filter = 0; 2087 switch ((DeclSpec::TST)TagSpec) { 2088 case DeclSpec::TST_enum: 2089 Filter = &ResultBuilder::IsEnum; 2090 break; 2091 2092 case DeclSpec::TST_union: 2093 Filter = &ResultBuilder::IsUnion; 2094 break; 2095 2096 case DeclSpec::TST_struct: 2097 case DeclSpec::TST_class: 2098 Filter = &ResultBuilder::IsClassOrStruct; 2099 break; 2100 2101 default: 2102 assert(false && "Unknown type specifier kind in CodeCompleteTag"); 2103 return; 2104 } 2105 2106 ResultBuilder Results(*this, Filter); 2107 Results.allowNestedNameSpecifiers(); 2108 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2109 LookupVisibleDecls(S, LookupTagName, Consumer); 2110 2111 if (CodeCompleter->includeMacros()) 2112 AddMacroResults(PP, Results); 2113 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2114} 2115 2116void Sema::CodeCompleteCase(Scope *S) { 2117 if (getSwitchStack().empty() || !CodeCompleter) 2118 return; 2119 2120 SwitchStmt *Switch = getSwitchStack().back(); 2121 if (!Switch->getCond()->getType()->isEnumeralType()) 2122 return; 2123 2124 // Code-complete the cases of a switch statement over an enumeration type 2125 // by providing the list of 2126 EnumDecl *Enum = Switch->getCond()->getType()->getAs<EnumType>()->getDecl(); 2127 2128 // Determine which enumerators we have already seen in the switch statement. 2129 // FIXME: Ideally, we would also be able to look *past* the code-completion 2130 // token, in case we are code-completing in the middle of the switch and not 2131 // at the end. However, we aren't able to do so at the moment. 2132 llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen; 2133 NestedNameSpecifier *Qualifier = 0; 2134 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC; 2135 SC = SC->getNextSwitchCase()) { 2136 CaseStmt *Case = dyn_cast<CaseStmt>(SC); 2137 if (!Case) 2138 continue; 2139 2140 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts(); 2141 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal)) 2142 if (EnumConstantDecl *Enumerator 2143 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) { 2144 // We look into the AST of the case statement to determine which 2145 // enumerator was named. Alternatively, we could compute the value of 2146 // the integral constant expression, then compare it against the 2147 // values of each enumerator. However, value-based approach would not 2148 // work as well with C++ templates where enumerators declared within a 2149 // template are type- and value-dependent. 2150 EnumeratorsSeen.insert(Enumerator); 2151 2152 // If this is a qualified-id, keep track of the nested-name-specifier 2153 // so that we can reproduce it as part of code completion, e.g., 2154 // 2155 // switch (TagD.getKind()) { 2156 // case TagDecl::TK_enum: 2157 // break; 2158 // case XXX 2159 // 2160 // At the XXX, our completions are TagDecl::TK_union, 2161 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union, 2162 // TK_struct, and TK_class. 2163 Qualifier = DRE->getQualifier(); 2164 } 2165 } 2166 2167 if (getLangOptions().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) { 2168 // If there are no prior enumerators in C++, check whether we have to 2169 // qualify the names of the enumerators that we suggest, because they 2170 // may not be visible in this scope. 2171 Qualifier = getRequiredQualification(Context, CurContext, 2172 Enum->getDeclContext()); 2173 2174 // FIXME: Scoped enums need to start with "EnumDecl" as the context! 2175 } 2176 2177 // Add any enumerators that have not yet been mentioned. 2178 ResultBuilder Results(*this); 2179 Results.EnterNewScope(); 2180 for (EnumDecl::enumerator_iterator E = Enum->enumerator_begin(), 2181 EEnd = Enum->enumerator_end(); 2182 E != EEnd; ++E) { 2183 if (EnumeratorsSeen.count(*E)) 2184 continue; 2185 2186 Results.AddResult(CodeCompleteConsumer::Result(*E, Qualifier), 2187 CurContext, 0, false); 2188 } 2189 Results.ExitScope(); 2190 2191 if (CodeCompleter->includeMacros()) 2192 AddMacroResults(PP, Results); 2193 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2194} 2195 2196namespace { 2197 struct IsBetterOverloadCandidate { 2198 Sema &S; 2199 2200 public: 2201 explicit IsBetterOverloadCandidate(Sema &S) : S(S) { } 2202 2203 bool 2204 operator()(const OverloadCandidate &X, const OverloadCandidate &Y) const { 2205 return S.isBetterOverloadCandidate(X, Y); 2206 } 2207 }; 2208} 2209 2210void Sema::CodeCompleteCall(Scope *S, ExprTy *FnIn, 2211 ExprTy **ArgsIn, unsigned NumArgs) { 2212 if (!CodeCompleter) 2213 return; 2214 2215 // When we're code-completing for a call, we fall back to ordinary 2216 // name code-completion whenever we can't produce specific 2217 // results. We may want to revisit this strategy in the future, 2218 // e.g., by merging the two kinds of results. 2219 2220 Expr *Fn = (Expr *)FnIn; 2221 Expr **Args = (Expr **)ArgsIn; 2222 2223 // Ignore type-dependent call expressions entirely. 2224 if (Fn->isTypeDependent() || 2225 Expr::hasAnyTypeDependentArguments(Args, NumArgs)) { 2226 CodeCompleteOrdinaryName(S, CCC_Expression); 2227 return; 2228 } 2229 2230 // Build an overload candidate set based on the functions we find. 2231 OverloadCandidateSet CandidateSet; 2232 2233 // FIXME: What if we're calling something that isn't a function declaration? 2234 // FIXME: What if we're calling a pseudo-destructor? 2235 // FIXME: What if we're calling a member function? 2236 2237 Expr *NakedFn = Fn->IgnoreParenCasts(); 2238 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn)) 2239 AddOverloadedCallCandidates(ULE, Args, NumArgs, CandidateSet, 2240 /*PartialOverloading=*/ true); 2241 else if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(NakedFn)) { 2242 FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()); 2243 if (FDecl) 2244 AddOverloadCandidate(FDecl, Args, NumArgs, CandidateSet, 2245 false, false, /*PartialOverloading*/ true); 2246 } 2247 2248 // Sort the overload candidate set by placing the best overloads first. 2249 std::stable_sort(CandidateSet.begin(), CandidateSet.end(), 2250 IsBetterOverloadCandidate(*this)); 2251 2252 // Add the remaining viable overload candidates as code-completion reslults. 2253 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate; 2254 llvm::SmallVector<ResultCandidate, 8> Results; 2255 2256 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(), 2257 CandEnd = CandidateSet.end(); 2258 Cand != CandEnd; ++Cand) { 2259 if (Cand->Viable) 2260 Results.push_back(ResultCandidate(Cand->Function)); 2261 } 2262 2263 if (Results.empty()) 2264 CodeCompleteOrdinaryName(S, CCC_Expression); 2265 else 2266 CodeCompleter->ProcessOverloadCandidates(*this, NumArgs, Results.data(), 2267 Results.size()); 2268} 2269 2270void Sema::CodeCompleteQualifiedId(Scope *S, const CXXScopeSpec &SS, 2271 bool EnteringContext) { 2272 if (!SS.getScopeRep() || !CodeCompleter) 2273 return; 2274 2275 DeclContext *Ctx = computeDeclContext(SS, EnteringContext); 2276 if (!Ctx) 2277 return; 2278 2279 // Try to instantiate any non-dependent declaration contexts before 2280 // we look in them. 2281 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS)) 2282 return; 2283 2284 ResultBuilder Results(*this); 2285 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2286 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer); 2287 2288 // The "template" keyword can follow "::" in the grammar, but only 2289 // put it into the grammar if the nested-name-specifier is dependent. 2290 NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep(); 2291 if (!Results.empty() && NNS->isDependent()) 2292 Results.AddResult("template"); 2293 2294 if (CodeCompleter->includeMacros()) 2295 AddMacroResults(PP, Results); 2296 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2297} 2298 2299void Sema::CodeCompleteUsing(Scope *S) { 2300 if (!CodeCompleter) 2301 return; 2302 2303 ResultBuilder Results(*this, &ResultBuilder::IsNestedNameSpecifier); 2304 Results.EnterNewScope(); 2305 2306 // If we aren't in class scope, we could see the "namespace" keyword. 2307 if (!S->isClassScope()) 2308 Results.AddResult(CodeCompleteConsumer::Result("namespace")); 2309 2310 // After "using", we can see anything that would start a 2311 // nested-name-specifier. 2312 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2313 LookupVisibleDecls(S, LookupOrdinaryName, Consumer); 2314 Results.ExitScope(); 2315 2316 if (CodeCompleter->includeMacros()) 2317 AddMacroResults(PP, Results); 2318 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2319} 2320 2321void Sema::CodeCompleteUsingDirective(Scope *S) { 2322 if (!CodeCompleter) 2323 return; 2324 2325 // After "using namespace", we expect to see a namespace name or namespace 2326 // alias. 2327 ResultBuilder Results(*this, &ResultBuilder::IsNamespaceOrAlias); 2328 Results.EnterNewScope(); 2329 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2330 LookupVisibleDecls(S, LookupOrdinaryName, Consumer); 2331 Results.ExitScope(); 2332 if (CodeCompleter->includeMacros()) 2333 AddMacroResults(PP, Results); 2334 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2335} 2336 2337void Sema::CodeCompleteNamespaceDecl(Scope *S) { 2338 if (!CodeCompleter) 2339 return; 2340 2341 ResultBuilder Results(*this, &ResultBuilder::IsNamespace); 2342 DeclContext *Ctx = (DeclContext *)S->getEntity(); 2343 if (!S->getParent()) 2344 Ctx = Context.getTranslationUnitDecl(); 2345 2346 if (Ctx && Ctx->isFileContext()) { 2347 // We only want to see those namespaces that have already been defined 2348 // within this scope, because its likely that the user is creating an 2349 // extended namespace declaration. Keep track of the most recent 2350 // definition of each namespace. 2351 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest; 2352 for (DeclContext::specific_decl_iterator<NamespaceDecl> 2353 NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end()); 2354 NS != NSEnd; ++NS) 2355 OrigToLatest[NS->getOriginalNamespace()] = *NS; 2356 2357 // Add the most recent definition (or extended definition) of each 2358 // namespace to the list of results. 2359 Results.EnterNewScope(); 2360 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator 2361 NS = OrigToLatest.begin(), NSEnd = OrigToLatest.end(); 2362 NS != NSEnd; ++NS) 2363 Results.AddResult(CodeCompleteConsumer::Result(NS->second, 0), 2364 CurContext, 0, false); 2365 Results.ExitScope(); 2366 } 2367 2368 if (CodeCompleter->includeMacros()) 2369 AddMacroResults(PP, Results); 2370 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2371} 2372 2373void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) { 2374 if (!CodeCompleter) 2375 return; 2376 2377 // After "namespace", we expect to see a namespace or alias. 2378 ResultBuilder Results(*this, &ResultBuilder::IsNamespaceOrAlias); 2379 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2380 LookupVisibleDecls(S, LookupOrdinaryName, Consumer); 2381 if (CodeCompleter->includeMacros()) 2382 AddMacroResults(PP, Results); 2383 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2384} 2385 2386void Sema::CodeCompleteOperatorName(Scope *S) { 2387 if (!CodeCompleter) 2388 return; 2389 2390 typedef CodeCompleteConsumer::Result Result; 2391 ResultBuilder Results(*this, &ResultBuilder::IsType); 2392 Results.EnterNewScope(); 2393 2394 // Add the names of overloadable operators. 2395#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 2396 if (std::strcmp(Spelling, "?")) \ 2397 Results.AddResult(Result(Spelling)); 2398#include "clang/Basic/OperatorKinds.def" 2399 2400 // Add any type names visible from the current scope 2401 Results.allowNestedNameSpecifiers(); 2402 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2403 LookupVisibleDecls(S, LookupOrdinaryName, Consumer); 2404 2405 // Add any type specifiers 2406 AddTypeSpecifierResults(getLangOptions(), Results); 2407 Results.ExitScope(); 2408 2409 if (CodeCompleter->includeMacros()) 2410 AddMacroResults(PP, Results); 2411 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2412} 2413 2414// Macro that expands to @Keyword or Keyword, depending on whether NeedAt is 2415// true or false. 2416#define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) NeedAt? "@" #Keyword : #Keyword 2417static void AddObjCImplementationResults(const LangOptions &LangOpts, 2418 ResultBuilder &Results, 2419 bool NeedAt) { 2420 typedef CodeCompleteConsumer::Result Result; 2421 // Since we have an implementation, we can end it. 2422 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,end))); 2423 2424 CodeCompletionString *Pattern = 0; 2425 if (LangOpts.ObjC2) { 2426 // @dynamic 2427 Pattern = new CodeCompletionString; 2428 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,dynamic)); 2429 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2430 Pattern->AddPlaceholderChunk("property"); 2431 Results.AddResult(Result(Pattern)); 2432 2433 // @synthesize 2434 Pattern = new CodeCompletionString; 2435 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,synthesize)); 2436 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2437 Pattern->AddPlaceholderChunk("property"); 2438 Results.AddResult(Result(Pattern)); 2439 } 2440} 2441 2442static void AddObjCInterfaceResults(const LangOptions &LangOpts, 2443 ResultBuilder &Results, 2444 bool NeedAt) { 2445 typedef CodeCompleteConsumer::Result Result; 2446 2447 // Since we have an interface or protocol, we can end it. 2448 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,end))); 2449 2450 if (LangOpts.ObjC2) { 2451 // @property 2452 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,property))); 2453 2454 // @required 2455 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,required))); 2456 2457 // @optional 2458 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,optional))); 2459 } 2460} 2461 2462static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) { 2463 typedef CodeCompleteConsumer::Result Result; 2464 CodeCompletionString *Pattern = 0; 2465 2466 // @class name ; 2467 Pattern = new CodeCompletionString; 2468 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,class)); 2469 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2470 Pattern->AddPlaceholderChunk("identifier"); 2471 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 2472 Results.AddResult(Result(Pattern)); 2473 2474 // @interface name 2475 // FIXME: Could introduce the whole pattern, including superclasses and 2476 // such. 2477 Pattern = new CodeCompletionString; 2478 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,interface)); 2479 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2480 Pattern->AddPlaceholderChunk("class"); 2481 Results.AddResult(Result(Pattern)); 2482 2483 // @protocol name 2484 Pattern = new CodeCompletionString; 2485 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,protocol)); 2486 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2487 Pattern->AddPlaceholderChunk("protocol"); 2488 Results.AddResult(Result(Pattern)); 2489 2490 // @implementation name 2491 Pattern = new CodeCompletionString; 2492 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,implementation)); 2493 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2494 Pattern->AddPlaceholderChunk("class"); 2495 Results.AddResult(Result(Pattern)); 2496 2497 // @compatibility_alias name 2498 Pattern = new CodeCompletionString; 2499 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,compatibility_alias)); 2500 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2501 Pattern->AddPlaceholderChunk("alias"); 2502 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2503 Pattern->AddPlaceholderChunk("class"); 2504 Results.AddResult(Result(Pattern)); 2505} 2506 2507void Sema::CodeCompleteObjCAtDirective(Scope *S, DeclPtrTy ObjCImpDecl, 2508 bool InInterface) { 2509 typedef CodeCompleteConsumer::Result Result; 2510 ResultBuilder Results(*this); 2511 Results.EnterNewScope(); 2512 if (ObjCImpDecl) 2513 AddObjCImplementationResults(getLangOptions(), Results, false); 2514 else if (InInterface) 2515 AddObjCInterfaceResults(getLangOptions(), Results, false); 2516 else 2517 AddObjCTopLevelResults(Results, false); 2518 Results.ExitScope(); 2519 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2520} 2521 2522static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) { 2523 typedef CodeCompleteConsumer::Result Result; 2524 CodeCompletionString *Pattern = 0; 2525 2526 // @encode ( type-name ) 2527 Pattern = new CodeCompletionString; 2528 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,encode)); 2529 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 2530 Pattern->AddPlaceholderChunk("type-name"); 2531 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 2532 Results.AddResult(Result(Pattern)); 2533 2534 // @protocol ( protocol-name ) 2535 Pattern = new CodeCompletionString; 2536 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,protocol)); 2537 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 2538 Pattern->AddPlaceholderChunk("protocol-name"); 2539 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 2540 Results.AddResult(Result(Pattern)); 2541 2542 // @selector ( selector ) 2543 Pattern = new CodeCompletionString; 2544 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,selector)); 2545 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 2546 Pattern->AddPlaceholderChunk("selector"); 2547 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 2548 Results.AddResult(Result(Pattern)); 2549} 2550 2551static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) { 2552 typedef CodeCompleteConsumer::Result Result; 2553 CodeCompletionString *Pattern = 0; 2554 2555 // @try { statements } @catch ( declaration ) { statements } @finally 2556 // { statements } 2557 Pattern = new CodeCompletionString; 2558 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,try)); 2559 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 2560 Pattern->AddPlaceholderChunk("statements"); 2561 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 2562 Pattern->AddTextChunk("@catch"); 2563 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 2564 Pattern->AddPlaceholderChunk("parameter"); 2565 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 2566 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 2567 Pattern->AddPlaceholderChunk("statements"); 2568 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 2569 Pattern->AddTextChunk("@finally"); 2570 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 2571 Pattern->AddPlaceholderChunk("statements"); 2572 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 2573 Results.AddResult(Result(Pattern)); 2574 2575 // @throw 2576 Pattern = new CodeCompletionString; 2577 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,throw)); 2578 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2579 Pattern->AddPlaceholderChunk("expression"); 2580 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 2581 Results.AddResult(Result(Pattern)); 2582 2583 // @synchronized ( expression ) { statements } 2584 Pattern = new CodeCompletionString; 2585 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,synchronized)); 2586 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 2587 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 2588 Pattern->AddPlaceholderChunk("expression"); 2589 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 2590 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 2591 Pattern->AddPlaceholderChunk("statements"); 2592 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 2593 Results.AddResult(Result(Pattern)); 2594} 2595 2596static void AddObjCVisibilityResults(const LangOptions &LangOpts, 2597 ResultBuilder &Results, 2598 bool NeedAt) { 2599 typedef CodeCompleteConsumer::Result Result; 2600 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,private))); 2601 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,protected))); 2602 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,public))); 2603 if (LangOpts.ObjC2) 2604 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,package))); 2605} 2606 2607void Sema::CodeCompleteObjCAtVisibility(Scope *S) { 2608 ResultBuilder Results(*this); 2609 Results.EnterNewScope(); 2610 AddObjCVisibilityResults(getLangOptions(), Results, false); 2611 Results.ExitScope(); 2612 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2613} 2614 2615void Sema::CodeCompleteObjCAtStatement(Scope *S) { 2616 ResultBuilder Results(*this); 2617 Results.EnterNewScope(); 2618 AddObjCStatementResults(Results, false); 2619 AddObjCExpressionResults(Results, false); 2620 Results.ExitScope(); 2621 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2622} 2623 2624void Sema::CodeCompleteObjCAtExpression(Scope *S) { 2625 ResultBuilder Results(*this); 2626 Results.EnterNewScope(); 2627 AddObjCExpressionResults(Results, false); 2628 Results.ExitScope(); 2629 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2630} 2631 2632/// \brief Determine whether the addition of the given flag to an Objective-C 2633/// property's attributes will cause a conflict. 2634static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) { 2635 // Check if we've already added this flag. 2636 if (Attributes & NewFlag) 2637 return true; 2638 2639 Attributes |= NewFlag; 2640 2641 // Check for collisions with "readonly". 2642 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) && 2643 (Attributes & (ObjCDeclSpec::DQ_PR_readwrite | 2644 ObjCDeclSpec::DQ_PR_assign | 2645 ObjCDeclSpec::DQ_PR_copy | 2646 ObjCDeclSpec::DQ_PR_retain))) 2647 return true; 2648 2649 // Check for more than one of { assign, copy, retain }. 2650 unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign | 2651 ObjCDeclSpec::DQ_PR_copy | 2652 ObjCDeclSpec::DQ_PR_retain); 2653 if (AssignCopyRetMask && 2654 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign && 2655 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy && 2656 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain) 2657 return true; 2658 2659 return false; 2660} 2661 2662void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) { 2663 if (!CodeCompleter) 2664 return; 2665 2666 unsigned Attributes = ODS.getPropertyAttributes(); 2667 2668 typedef CodeCompleteConsumer::Result Result; 2669 ResultBuilder Results(*this); 2670 Results.EnterNewScope(); 2671 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly)) 2672 Results.AddResult(CodeCompleteConsumer::Result("readonly")); 2673 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign)) 2674 Results.AddResult(CodeCompleteConsumer::Result("assign")); 2675 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite)) 2676 Results.AddResult(CodeCompleteConsumer::Result("readwrite")); 2677 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain)) 2678 Results.AddResult(CodeCompleteConsumer::Result("retain")); 2679 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy)) 2680 Results.AddResult(CodeCompleteConsumer::Result("copy")); 2681 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic)) 2682 Results.AddResult(CodeCompleteConsumer::Result("nonatomic")); 2683 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) { 2684 CodeCompletionString *Setter = new CodeCompletionString; 2685 Setter->AddTypedTextChunk("setter"); 2686 Setter->AddTextChunk(" = "); 2687 Setter->AddPlaceholderChunk("method"); 2688 Results.AddResult(CodeCompleteConsumer::Result(Setter)); 2689 } 2690 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) { 2691 CodeCompletionString *Getter = new CodeCompletionString; 2692 Getter->AddTypedTextChunk("getter"); 2693 Getter->AddTextChunk(" = "); 2694 Getter->AddPlaceholderChunk("method"); 2695 Results.AddResult(CodeCompleteConsumer::Result(Getter)); 2696 } 2697 Results.ExitScope(); 2698 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2699} 2700 2701/// \brief Descripts the kind of Objective-C method that we want to find 2702/// via code completion. 2703enum ObjCMethodKind { 2704 MK_Any, //< Any kind of method, provided it means other specified criteria. 2705 MK_ZeroArgSelector, //< Zero-argument (unary) selector. 2706 MK_OneArgSelector //< One-argument selector. 2707}; 2708 2709static bool isAcceptableObjCMethod(ObjCMethodDecl *Method, 2710 ObjCMethodKind WantKind, 2711 IdentifierInfo **SelIdents, 2712 unsigned NumSelIdents) { 2713 Selector Sel = Method->getSelector(); 2714 if (NumSelIdents > Sel.getNumArgs()) 2715 return false; 2716 2717 switch (WantKind) { 2718 case MK_Any: break; 2719 case MK_ZeroArgSelector: return Sel.isUnarySelector(); 2720 case MK_OneArgSelector: return Sel.getNumArgs() == 1; 2721 } 2722 2723 for (unsigned I = 0; I != NumSelIdents; ++I) 2724 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I)) 2725 return false; 2726 2727 return true; 2728} 2729 2730/// \brief Add all of the Objective-C methods in the given Objective-C 2731/// container to the set of results. 2732/// 2733/// The container will be a class, protocol, category, or implementation of 2734/// any of the above. This mether will recurse to include methods from 2735/// the superclasses of classes along with their categories, protocols, and 2736/// implementations. 2737/// 2738/// \param Container the container in which we'll look to find methods. 2739/// 2740/// \param WantInstance whether to add instance methods (only); if false, this 2741/// routine will add factory methods (only). 2742/// 2743/// \param CurContext the context in which we're performing the lookup that 2744/// finds methods. 2745/// 2746/// \param Results the structure into which we'll add results. 2747static void AddObjCMethods(ObjCContainerDecl *Container, 2748 bool WantInstanceMethods, 2749 ObjCMethodKind WantKind, 2750 IdentifierInfo **SelIdents, 2751 unsigned NumSelIdents, 2752 DeclContext *CurContext, 2753 ResultBuilder &Results) { 2754 typedef CodeCompleteConsumer::Result Result; 2755 for (ObjCContainerDecl::method_iterator M = Container->meth_begin(), 2756 MEnd = Container->meth_end(); 2757 M != MEnd; ++M) { 2758 if ((*M)->isInstanceMethod() == WantInstanceMethods) { 2759 // Check whether the selector identifiers we've been given are a 2760 // subset of the identifiers for this particular method. 2761 if (!isAcceptableObjCMethod(*M, WantKind, SelIdents, NumSelIdents)) 2762 continue; 2763 2764 Result R = Result(*M, 0); 2765 R.StartParameter = NumSelIdents; 2766 R.AllParametersAreInformative = (WantKind != MK_Any); 2767 Results.MaybeAddResult(R, CurContext); 2768 } 2769 } 2770 2771 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container); 2772 if (!IFace) 2773 return; 2774 2775 // Add methods in protocols. 2776 const ObjCList<ObjCProtocolDecl> &Protocols= IFace->getReferencedProtocols(); 2777 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 2778 E = Protocols.end(); 2779 I != E; ++I) 2780 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, NumSelIdents, 2781 CurContext, Results); 2782 2783 // Add methods in categories. 2784 for (ObjCCategoryDecl *CatDecl = IFace->getCategoryList(); CatDecl; 2785 CatDecl = CatDecl->getNextClassCategory()) { 2786 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents, 2787 NumSelIdents, CurContext, Results); 2788 2789 // Add a categories protocol methods. 2790 const ObjCList<ObjCProtocolDecl> &Protocols 2791 = CatDecl->getReferencedProtocols(); 2792 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 2793 E = Protocols.end(); 2794 I != E; ++I) 2795 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, 2796 NumSelIdents, CurContext, Results); 2797 2798 // Add methods in category implementations. 2799 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation()) 2800 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, 2801 NumSelIdents, CurContext, Results); 2802 } 2803 2804 // Add methods in superclass. 2805 if (IFace->getSuperClass()) 2806 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind, 2807 SelIdents, NumSelIdents, CurContext, Results); 2808 2809 // Add methods in our implementation, if any. 2810 if (ObjCImplementationDecl *Impl = IFace->getImplementation()) 2811 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, 2812 NumSelIdents, CurContext, Results); 2813} 2814 2815 2816void Sema::CodeCompleteObjCPropertyGetter(Scope *S, DeclPtrTy ClassDecl, 2817 DeclPtrTy *Methods, 2818 unsigned NumMethods) { 2819 typedef CodeCompleteConsumer::Result Result; 2820 2821 // Try to find the interface where getters might live. 2822 ObjCInterfaceDecl *Class 2823 = dyn_cast_or_null<ObjCInterfaceDecl>(ClassDecl.getAs<Decl>()); 2824 if (!Class) { 2825 if (ObjCCategoryDecl *Category 2826 = dyn_cast_or_null<ObjCCategoryDecl>(ClassDecl.getAs<Decl>())) 2827 Class = Category->getClassInterface(); 2828 2829 if (!Class) 2830 return; 2831 } 2832 2833 // Find all of the potential getters. 2834 ResultBuilder Results(*this); 2835 Results.EnterNewScope(); 2836 2837 // FIXME: We need to do this because Objective-C methods don't get 2838 // pushed into DeclContexts early enough. Argh! 2839 for (unsigned I = 0; I != NumMethods; ++I) { 2840 if (ObjCMethodDecl *Method 2841 = dyn_cast_or_null<ObjCMethodDecl>(Methods[I].getAs<Decl>())) 2842 if (Method->isInstanceMethod() && 2843 isAcceptableObjCMethod(Method, MK_ZeroArgSelector, 0, 0)) { 2844 Result R = Result(Method, 0); 2845 R.AllParametersAreInformative = true; 2846 Results.MaybeAddResult(R, CurContext); 2847 } 2848 } 2849 2850 AddObjCMethods(Class, true, MK_ZeroArgSelector, 0, 0, CurContext, Results); 2851 Results.ExitScope(); 2852 HandleCodeCompleteResults(this, CodeCompleter,Results.data(),Results.size()); 2853} 2854 2855void Sema::CodeCompleteObjCPropertySetter(Scope *S, DeclPtrTy ObjCImplDecl, 2856 DeclPtrTy *Methods, 2857 unsigned NumMethods) { 2858 typedef CodeCompleteConsumer::Result Result; 2859 2860 // Try to find the interface where setters might live. 2861 ObjCInterfaceDecl *Class 2862 = dyn_cast_or_null<ObjCInterfaceDecl>(ObjCImplDecl.getAs<Decl>()); 2863 if (!Class) { 2864 if (ObjCCategoryDecl *Category 2865 = dyn_cast_or_null<ObjCCategoryDecl>(ObjCImplDecl.getAs<Decl>())) 2866 Class = Category->getClassInterface(); 2867 2868 if (!Class) 2869 return; 2870 } 2871 2872 // Find all of the potential getters. 2873 ResultBuilder Results(*this); 2874 Results.EnterNewScope(); 2875 2876 // FIXME: We need to do this because Objective-C methods don't get 2877 // pushed into DeclContexts early enough. Argh! 2878 for (unsigned I = 0; I != NumMethods; ++I) { 2879 if (ObjCMethodDecl *Method 2880 = dyn_cast_or_null<ObjCMethodDecl>(Methods[I].getAs<Decl>())) 2881 if (Method->isInstanceMethod() && 2882 isAcceptableObjCMethod(Method, MK_OneArgSelector, 0, 0)) { 2883 Result R = Result(Method, 0); 2884 R.AllParametersAreInformative = true; 2885 Results.MaybeAddResult(R, CurContext); 2886 } 2887 } 2888 2889 AddObjCMethods(Class, true, MK_OneArgSelector, 0, 0, CurContext, Results); 2890 2891 Results.ExitScope(); 2892 HandleCodeCompleteResults(this, CodeCompleter,Results.data(),Results.size()); 2893} 2894 2895void Sema::CodeCompleteObjCClassMessage(Scope *S, IdentifierInfo *FName, 2896 SourceLocation FNameLoc, 2897 IdentifierInfo **SelIdents, 2898 unsigned NumSelIdents) { 2899 typedef CodeCompleteConsumer::Result Result; 2900 ObjCInterfaceDecl *CDecl = 0; 2901 2902 if (FName->isStr("super")) { 2903 // We're sending a message to "super". 2904 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) { 2905 // Figure out which interface we're in. 2906 CDecl = CurMethod->getClassInterface(); 2907 if (!CDecl) 2908 return; 2909 2910 // Find the superclass of this class. 2911 CDecl = CDecl->getSuperClass(); 2912 if (!CDecl) 2913 return; 2914 2915 if (CurMethod->isInstanceMethod()) { 2916 // We are inside an instance method, which means that the message 2917 // send [super ...] is actually calling an instance method on the 2918 // current object. Build the super expression and handle this like 2919 // an instance method. 2920 QualType SuperTy = Context.getObjCInterfaceType(CDecl); 2921 SuperTy = Context.getObjCObjectPointerType(SuperTy); 2922 OwningExprResult Super 2923 = Owned(new (Context) ObjCSuperExpr(FNameLoc, SuperTy)); 2924 return CodeCompleteObjCInstanceMessage(S, (Expr *)Super.get(), 2925 SelIdents, NumSelIdents); 2926 } 2927 2928 // Okay, we're calling a factory method in our superclass. 2929 } 2930 } 2931 2932 // If the given name refers to an interface type, retrieve the 2933 // corresponding declaration. 2934 if (!CDecl) 2935 if (TypeTy *Ty = getTypeName(*FName, FNameLoc, S, 0, false)) { 2936 QualType T = GetTypeFromParser(Ty, 0); 2937 if (!T.isNull()) 2938 if (const ObjCInterfaceType *Interface = T->getAs<ObjCInterfaceType>()) 2939 CDecl = Interface->getDecl(); 2940 } 2941 2942 if (!CDecl && FName->isStr("super")) { 2943 // "super" may be the name of a variable, in which case we are 2944 // probably calling an instance method. 2945 CXXScopeSpec SS; 2946 UnqualifiedId id; 2947 id.setIdentifier(FName, FNameLoc); 2948 OwningExprResult Super = ActOnIdExpression(S, SS, id, false, false); 2949 return CodeCompleteObjCInstanceMessage(S, (Expr *)Super.get(), 2950 SelIdents, NumSelIdents); 2951 } 2952 2953 // Add all of the factory methods in this Objective-C class, its protocols, 2954 // superclasses, categories, implementation, etc. 2955 ResultBuilder Results(*this); 2956 Results.EnterNewScope(); 2957 AddObjCMethods(CDecl, false, MK_Any, SelIdents, NumSelIdents, CurContext, 2958 Results); 2959 Results.ExitScope(); 2960 2961 // This also suppresses remaining diagnostics. 2962 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 2963} 2964 2965void Sema::CodeCompleteObjCInstanceMessage(Scope *S, ExprTy *Receiver, 2966 IdentifierInfo **SelIdents, 2967 unsigned NumSelIdents) { 2968 typedef CodeCompleteConsumer::Result Result; 2969 2970 Expr *RecExpr = static_cast<Expr *>(Receiver); 2971 2972 // If necessary, apply function/array conversion to the receiver. 2973 // C99 6.7.5.3p[7,8]. 2974 DefaultFunctionArrayConversion(RecExpr); 2975 QualType ReceiverType = RecExpr->getType(); 2976 2977 if (ReceiverType->isObjCIdType() || ReceiverType->isBlockPointerType()) { 2978 // FIXME: We're messaging 'id'. Do we actually want to look up every method 2979 // in the universe? 2980 return; 2981 } 2982 2983 // Build the set of methods we can see. 2984 ResultBuilder Results(*this); 2985 Results.EnterNewScope(); 2986 2987 // Handle messages to Class. This really isn't a message to an instance 2988 // method, so we treat it the same way we would treat a message send to a 2989 // class method. 2990 if (ReceiverType->isObjCClassType() || 2991 ReceiverType->isObjCQualifiedClassType()) { 2992 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) { 2993 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface()) 2994 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents, NumSelIdents, 2995 CurContext, Results); 2996 } 2997 } 2998 // Handle messages to a qualified ID ("id<foo>"). 2999 else if (const ObjCObjectPointerType *QualID 3000 = ReceiverType->getAsObjCQualifiedIdType()) { 3001 // Search protocols for instance methods. 3002 for (ObjCObjectPointerType::qual_iterator I = QualID->qual_begin(), 3003 E = QualID->qual_end(); 3004 I != E; ++I) 3005 AddObjCMethods(*I, true, MK_Any, SelIdents, NumSelIdents, CurContext, 3006 Results); 3007 } 3008 // Handle messages to a pointer to interface type. 3009 else if (const ObjCObjectPointerType *IFacePtr 3010 = ReceiverType->getAsObjCInterfacePointerType()) { 3011 // Search the class, its superclasses, etc., for instance methods. 3012 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents, 3013 NumSelIdents, CurContext, Results); 3014 3015 // Search protocols for instance methods. 3016 for (ObjCObjectPointerType::qual_iterator I = IFacePtr->qual_begin(), 3017 E = IFacePtr->qual_end(); 3018 I != E; ++I) 3019 AddObjCMethods(*I, true, MK_Any, SelIdents, NumSelIdents, CurContext, 3020 Results); 3021 } 3022 3023 Results.ExitScope(); 3024 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3025} 3026 3027/// \brief Add all of the protocol declarations that we find in the given 3028/// (translation unit) context. 3029static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext, 3030 bool OnlyForwardDeclarations, 3031 ResultBuilder &Results) { 3032 typedef CodeCompleteConsumer::Result Result; 3033 3034 for (DeclContext::decl_iterator D = Ctx->decls_begin(), 3035 DEnd = Ctx->decls_end(); 3036 D != DEnd; ++D) { 3037 // Record any protocols we find. 3038 if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(*D)) 3039 if (!OnlyForwardDeclarations || Proto->isForwardDecl()) 3040 Results.AddResult(Result(Proto, 0), CurContext, 0, false); 3041 3042 // Record any forward-declared protocols we find. 3043 if (ObjCForwardProtocolDecl *Forward 3044 = dyn_cast<ObjCForwardProtocolDecl>(*D)) { 3045 for (ObjCForwardProtocolDecl::protocol_iterator 3046 P = Forward->protocol_begin(), 3047 PEnd = Forward->protocol_end(); 3048 P != PEnd; ++P) 3049 if (!OnlyForwardDeclarations || (*P)->isForwardDecl()) 3050 Results.AddResult(Result(*P, 0), CurContext, 0, false); 3051 } 3052 } 3053} 3054 3055void Sema::CodeCompleteObjCProtocolReferences(IdentifierLocPair *Protocols, 3056 unsigned NumProtocols) { 3057 ResultBuilder Results(*this); 3058 Results.EnterNewScope(); 3059 3060 // Tell the result set to ignore all of the protocols we have 3061 // already seen. 3062 for (unsigned I = 0; I != NumProtocols; ++I) 3063 if (ObjCProtocolDecl *Protocol = LookupProtocol(Protocols[I].first)) 3064 Results.Ignore(Protocol); 3065 3066 // Add all protocols. 3067 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false, 3068 Results); 3069 3070 Results.ExitScope(); 3071 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3072} 3073 3074void Sema::CodeCompleteObjCProtocolDecl(Scope *) { 3075 ResultBuilder Results(*this); 3076 Results.EnterNewScope(); 3077 3078 // Add all protocols. 3079 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true, 3080 Results); 3081 3082 Results.ExitScope(); 3083 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3084} 3085 3086/// \brief Add all of the Objective-C interface declarations that we find in 3087/// the given (translation unit) context. 3088static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext, 3089 bool OnlyForwardDeclarations, 3090 bool OnlyUnimplemented, 3091 ResultBuilder &Results) { 3092 typedef CodeCompleteConsumer::Result Result; 3093 3094 for (DeclContext::decl_iterator D = Ctx->decls_begin(), 3095 DEnd = Ctx->decls_end(); 3096 D != DEnd; ++D) { 3097 // Record any interfaces we find. 3098 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(*D)) 3099 if ((!OnlyForwardDeclarations || Class->isForwardDecl()) && 3100 (!OnlyUnimplemented || !Class->getImplementation())) 3101 Results.AddResult(Result(Class, 0), CurContext, 0, false); 3102 3103 // Record any forward-declared interfaces we find. 3104 if (ObjCClassDecl *Forward = dyn_cast<ObjCClassDecl>(*D)) { 3105 for (ObjCClassDecl::iterator C = Forward->begin(), CEnd = Forward->end(); 3106 C != CEnd; ++C) 3107 if ((!OnlyForwardDeclarations || C->getInterface()->isForwardDecl()) && 3108 (!OnlyUnimplemented || !C->getInterface()->getImplementation())) 3109 Results.AddResult(Result(C->getInterface(), 0), CurContext, 3110 0, false); 3111 } 3112 } 3113} 3114 3115void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) { 3116 ResultBuilder Results(*this); 3117 Results.EnterNewScope(); 3118 3119 // Add all classes. 3120 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, true, 3121 false, Results); 3122 3123 Results.ExitScope(); 3124 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3125} 3126 3127void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName) { 3128 ResultBuilder Results(*this); 3129 Results.EnterNewScope(); 3130 3131 // Make sure that we ignore the class we're currently defining. 3132 NamedDecl *CurClass 3133 = LookupSingleName(TUScope, ClassName, LookupOrdinaryName); 3134 if (CurClass && isa<ObjCInterfaceDecl>(CurClass)) 3135 Results.Ignore(CurClass); 3136 3137 // Add all classes. 3138 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false, 3139 false, Results); 3140 3141 Results.ExitScope(); 3142 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3143} 3144 3145void Sema::CodeCompleteObjCImplementationDecl(Scope *S) { 3146 ResultBuilder Results(*this); 3147 Results.EnterNewScope(); 3148 3149 // Add all unimplemented classes. 3150 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false, 3151 true, Results); 3152 3153 Results.ExitScope(); 3154 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3155} 3156 3157void Sema::CodeCompleteObjCInterfaceCategory(Scope *S, 3158 IdentifierInfo *ClassName) { 3159 typedef CodeCompleteConsumer::Result Result; 3160 3161 ResultBuilder Results(*this); 3162 3163 // Ignore any categories we find that have already been implemented by this 3164 // interface. 3165 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames; 3166 NamedDecl *CurClass 3167 = LookupSingleName(TUScope, ClassName, LookupOrdinaryName); 3168 if (ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)) 3169 for (ObjCCategoryDecl *Category = Class->getCategoryList(); Category; 3170 Category = Category->getNextClassCategory()) 3171 CategoryNames.insert(Category->getIdentifier()); 3172 3173 // Add all of the categories we know about. 3174 Results.EnterNewScope(); 3175 TranslationUnitDecl *TU = Context.getTranslationUnitDecl(); 3176 for (DeclContext::decl_iterator D = TU->decls_begin(), 3177 DEnd = TU->decls_end(); 3178 D != DEnd; ++D) 3179 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(*D)) 3180 if (CategoryNames.insert(Category->getIdentifier())) 3181 Results.AddResult(Result(Category, 0), CurContext, 0, false); 3182 Results.ExitScope(); 3183 3184 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3185} 3186 3187void Sema::CodeCompleteObjCImplementationCategory(Scope *S, 3188 IdentifierInfo *ClassName) { 3189 typedef CodeCompleteConsumer::Result Result; 3190 3191 // Find the corresponding interface. If we couldn't find the interface, the 3192 // program itself is ill-formed. However, we'll try to be helpful still by 3193 // providing the list of all of the categories we know about. 3194 NamedDecl *CurClass 3195 = LookupSingleName(TUScope, ClassName, LookupOrdinaryName); 3196 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass); 3197 if (!Class) 3198 return CodeCompleteObjCInterfaceCategory(S, ClassName); 3199 3200 ResultBuilder Results(*this); 3201 3202 // Add all of the categories that have have corresponding interface 3203 // declarations in this class and any of its superclasses, except for 3204 // already-implemented categories in the class itself. 3205 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames; 3206 Results.EnterNewScope(); 3207 bool IgnoreImplemented = true; 3208 while (Class) { 3209 for (ObjCCategoryDecl *Category = Class->getCategoryList(); Category; 3210 Category = Category->getNextClassCategory()) 3211 if ((!IgnoreImplemented || !Category->getImplementation()) && 3212 CategoryNames.insert(Category->getIdentifier())) 3213 Results.AddResult(Result(Category, 0), CurContext, 0, false); 3214 3215 Class = Class->getSuperClass(); 3216 IgnoreImplemented = false; 3217 } 3218 Results.ExitScope(); 3219 3220 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3221} 3222 3223void Sema::CodeCompleteObjCPropertyDefinition(Scope *S, DeclPtrTy ObjCImpDecl) { 3224 typedef CodeCompleteConsumer::Result Result; 3225 ResultBuilder Results(*this); 3226 3227 // Figure out where this @synthesize lives. 3228 ObjCContainerDecl *Container 3229 = dyn_cast_or_null<ObjCContainerDecl>(ObjCImpDecl.getAs<Decl>()); 3230 if (!Container || 3231 (!isa<ObjCImplementationDecl>(Container) && 3232 !isa<ObjCCategoryImplDecl>(Container))) 3233 return; 3234 3235 // Ignore any properties that have already been implemented. 3236 for (DeclContext::decl_iterator D = Container->decls_begin(), 3237 DEnd = Container->decls_end(); 3238 D != DEnd; ++D) 3239 if (ObjCPropertyImplDecl *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(*D)) 3240 Results.Ignore(PropertyImpl->getPropertyDecl()); 3241 3242 // Add any properties that we find. 3243 Results.EnterNewScope(); 3244 if (ObjCImplementationDecl *ClassImpl 3245 = dyn_cast<ObjCImplementationDecl>(Container)) 3246 AddObjCProperties(ClassImpl->getClassInterface(), false, CurContext, 3247 Results); 3248 else 3249 AddObjCProperties(cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(), 3250 false, CurContext, Results); 3251 Results.ExitScope(); 3252 3253 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3254} 3255 3256void Sema::CodeCompleteObjCPropertySynthesizeIvar(Scope *S, 3257 IdentifierInfo *PropertyName, 3258 DeclPtrTy ObjCImpDecl) { 3259 typedef CodeCompleteConsumer::Result Result; 3260 ResultBuilder Results(*this); 3261 3262 // Figure out where this @synthesize lives. 3263 ObjCContainerDecl *Container 3264 = dyn_cast_or_null<ObjCContainerDecl>(ObjCImpDecl.getAs<Decl>()); 3265 if (!Container || 3266 (!isa<ObjCImplementationDecl>(Container) && 3267 !isa<ObjCCategoryImplDecl>(Container))) 3268 return; 3269 3270 // Figure out which interface we're looking into. 3271 ObjCInterfaceDecl *Class = 0; 3272 if (ObjCImplementationDecl *ClassImpl 3273 = dyn_cast<ObjCImplementationDecl>(Container)) 3274 Class = ClassImpl->getClassInterface(); 3275 else 3276 Class = cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl() 3277 ->getClassInterface(); 3278 3279 // Add all of the instance variables in this class and its superclasses. 3280 Results.EnterNewScope(); 3281 for(; Class; Class = Class->getSuperClass()) { 3282 // FIXME: We could screen the type of each ivar for compatibility with 3283 // the property, but is that being too paternal? 3284 for (ObjCInterfaceDecl::ivar_iterator IVar = Class->ivar_begin(), 3285 IVarEnd = Class->ivar_end(); 3286 IVar != IVarEnd; ++IVar) 3287 Results.AddResult(Result(*IVar, 0), CurContext, 0, false); 3288 } 3289 Results.ExitScope(); 3290 3291 HandleCodeCompleteResults(this, CodeCompleter, Results.data(),Results.size()); 3292} 3293