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