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