SemaCodeComplete.cpp revision 5a9c0bca4504eeda45a3fd0ae1c244b2994f38b2
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) const { 2370 typedef CodeCompletionString::Chunk Chunk; 2371 2372 CodeCompletionString *Result = new CodeCompletionString; 2373 FunctionDecl *FDecl = getFunction(); 2374 AddResultTypeChunk(S.Context, FDecl, Result); 2375 const FunctionProtoType *Proto 2376 = dyn_cast<FunctionProtoType>(getFunctionType()); 2377 if (!FDecl && !Proto) { 2378 // Function without a prototype. Just give the return type and a 2379 // highlighted ellipsis. 2380 const FunctionType *FT = getFunctionType(); 2381 Result->AddTextChunk( 2382 FT->getResultType().getAsString(S.Context.PrintingPolicy)); 2383 Result->AddChunk(Chunk(CodeCompletionString::CK_LeftParen)); 2384 Result->AddChunk(Chunk(CodeCompletionString::CK_CurrentParameter, "...")); 2385 Result->AddChunk(Chunk(CodeCompletionString::CK_RightParen)); 2386 return Result; 2387 } 2388 2389 if (FDecl) 2390 Result->AddTextChunk(FDecl->getNameAsString()); 2391 else 2392 Result->AddTextChunk( 2393 Proto->getResultType().getAsString(S.Context.PrintingPolicy)); 2394 2395 Result->AddChunk(Chunk(CodeCompletionString::CK_LeftParen)); 2396 unsigned NumParams = FDecl? FDecl->getNumParams() : Proto->getNumArgs(); 2397 for (unsigned I = 0; I != NumParams; ++I) { 2398 if (I) 2399 Result->AddChunk(Chunk(CodeCompletionString::CK_Comma)); 2400 2401 std::string ArgString; 2402 QualType ArgType; 2403 2404 if (FDecl) { 2405 ArgString = FDecl->getParamDecl(I)->getNameAsString(); 2406 ArgType = FDecl->getParamDecl(I)->getOriginalType(); 2407 } else { 2408 ArgType = Proto->getArgType(I); 2409 } 2410 2411 ArgType.getAsStringInternal(ArgString, S.Context.PrintingPolicy); 2412 2413 if (I == CurrentArg) 2414 Result->AddChunk(Chunk(CodeCompletionString::CK_CurrentParameter, 2415 ArgString)); 2416 else 2417 Result->AddTextChunk(ArgString); 2418 } 2419 2420 if (Proto && Proto->isVariadic()) { 2421 Result->AddChunk(Chunk(CodeCompletionString::CK_Comma)); 2422 if (CurrentArg < NumParams) 2423 Result->AddTextChunk("..."); 2424 else 2425 Result->AddChunk(Chunk(CodeCompletionString::CK_CurrentParameter, "...")); 2426 } 2427 Result->AddChunk(Chunk(CodeCompletionString::CK_RightParen)); 2428 2429 return Result; 2430} 2431 2432unsigned clang::getMacroUsagePriority(llvm::StringRef MacroName, 2433 const LangOptions &LangOpts, 2434 bool PreferredTypeIsPointer) { 2435 unsigned Priority = CCP_Macro; 2436 2437 // Treat the "nil", "Nil" and "NULL" macros as null pointer constants. 2438 if (MacroName.equals("nil") || MacroName.equals("NULL") || 2439 MacroName.equals("Nil")) { 2440 Priority = CCP_Constant; 2441 if (PreferredTypeIsPointer) 2442 Priority = Priority / CCF_SimilarTypeMatch; 2443 } 2444 // Treat "YES", "NO", "true", and "false" as constants. 2445 else if (MacroName.equals("YES") || MacroName.equals("NO") || 2446 MacroName.equals("true") || MacroName.equals("false")) 2447 Priority = CCP_Constant; 2448 // Treat "bool" as a type. 2449 else if (MacroName.equals("bool")) 2450 Priority = CCP_Type + (LangOpts.ObjC1? CCD_bool_in_ObjC : 0); 2451 2452 2453 return Priority; 2454} 2455 2456CXCursorKind clang::getCursorKindForDecl(Decl *D) { 2457 if (!D) 2458 return CXCursor_UnexposedDecl; 2459 2460 switch (D->getKind()) { 2461 case Decl::Enum: return CXCursor_EnumDecl; 2462 case Decl::EnumConstant: return CXCursor_EnumConstantDecl; 2463 case Decl::Field: return CXCursor_FieldDecl; 2464 case Decl::Function: 2465 return CXCursor_FunctionDecl; 2466 case Decl::ObjCCategory: return CXCursor_ObjCCategoryDecl; 2467 case Decl::ObjCCategoryImpl: return CXCursor_ObjCCategoryImplDecl; 2468 case Decl::ObjCClass: 2469 // FIXME 2470 return CXCursor_UnexposedDecl; 2471 case Decl::ObjCForwardProtocol: 2472 // FIXME 2473 return CXCursor_UnexposedDecl; 2474 case Decl::ObjCImplementation: return CXCursor_ObjCImplementationDecl; 2475 case Decl::ObjCInterface: return CXCursor_ObjCInterfaceDecl; 2476 case Decl::ObjCIvar: return CXCursor_ObjCIvarDecl; 2477 case Decl::ObjCMethod: 2478 return cast<ObjCMethodDecl>(D)->isInstanceMethod() 2479 ? CXCursor_ObjCInstanceMethodDecl : CXCursor_ObjCClassMethodDecl; 2480 case Decl::CXXMethod: return CXCursor_CXXMethod; 2481 case Decl::CXXConstructor: return CXCursor_Constructor; 2482 case Decl::CXXDestructor: return CXCursor_Destructor; 2483 case Decl::CXXConversion: return CXCursor_ConversionFunction; 2484 case Decl::ObjCProperty: return CXCursor_ObjCPropertyDecl; 2485 case Decl::ObjCProtocol: return CXCursor_ObjCProtocolDecl; 2486 case Decl::ParmVar: return CXCursor_ParmDecl; 2487 case Decl::Typedef: return CXCursor_TypedefDecl; 2488 case Decl::Var: return CXCursor_VarDecl; 2489 case Decl::Namespace: return CXCursor_Namespace; 2490 case Decl::NamespaceAlias: return CXCursor_NamespaceAlias; 2491 case Decl::TemplateTypeParm: return CXCursor_TemplateTypeParameter; 2492 case Decl::NonTypeTemplateParm:return CXCursor_NonTypeTemplateParameter; 2493 case Decl::TemplateTemplateParm:return CXCursor_TemplateTemplateParameter; 2494 case Decl::FunctionTemplate: return CXCursor_FunctionTemplate; 2495 case Decl::ClassTemplate: return CXCursor_ClassTemplate; 2496 case Decl::ClassTemplatePartialSpecialization: 2497 return CXCursor_ClassTemplatePartialSpecialization; 2498 case Decl::UsingDirective: return CXCursor_UsingDirective; 2499 2500 case Decl::Using: 2501 case Decl::UnresolvedUsingValue: 2502 case Decl::UnresolvedUsingTypename: 2503 return CXCursor_UsingDeclaration; 2504 2505 default: 2506 if (TagDecl *TD = dyn_cast<TagDecl>(D)) { 2507 switch (TD->getTagKind()) { 2508 case TTK_Struct: return CXCursor_StructDecl; 2509 case TTK_Class: return CXCursor_ClassDecl; 2510 case TTK_Union: return CXCursor_UnionDecl; 2511 case TTK_Enum: return CXCursor_EnumDecl; 2512 } 2513 } 2514 } 2515 2516 return CXCursor_UnexposedDecl; 2517} 2518 2519static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results, 2520 bool TargetTypeIsPointer = false) { 2521 typedef CodeCompletionResult Result; 2522 2523 Results.EnterNewScope(); 2524 for (Preprocessor::macro_iterator M = PP.macro_begin(), 2525 MEnd = PP.macro_end(); 2526 M != MEnd; ++M) { 2527 Results.AddResult(Result(M->first, 2528 getMacroUsagePriority(M->first->getName(), 2529 PP.getLangOptions(), 2530 TargetTypeIsPointer))); 2531 } 2532 Results.ExitScope(); 2533} 2534 2535static void AddPrettyFunctionResults(const LangOptions &LangOpts, 2536 ResultBuilder &Results) { 2537 typedef CodeCompletionResult Result; 2538 2539 Results.EnterNewScope(); 2540 Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant)); 2541 Results.AddResult(Result("__FUNCTION__", CCP_Constant)); 2542 if (LangOpts.C99 || LangOpts.CPlusPlus0x) 2543 Results.AddResult(Result("__func__", CCP_Constant)); 2544 Results.ExitScope(); 2545} 2546 2547static void HandleCodeCompleteResults(Sema *S, 2548 CodeCompleteConsumer *CodeCompleter, 2549 CodeCompletionContext Context, 2550 CodeCompletionResult *Results, 2551 unsigned NumResults) { 2552 if (CodeCompleter) 2553 CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults); 2554 2555 for (unsigned I = 0; I != NumResults; ++I) 2556 Results[I].Destroy(); 2557} 2558 2559static enum CodeCompletionContext::Kind mapCodeCompletionContext(Sema &S, 2560 Sema::ParserCompletionContext PCC) { 2561 switch (PCC) { 2562 case Sema::PCC_Namespace: 2563 return CodeCompletionContext::CCC_TopLevel; 2564 2565 case Sema::PCC_Class: 2566 return CodeCompletionContext::CCC_ClassStructUnion; 2567 2568 case Sema::PCC_ObjCInterface: 2569 return CodeCompletionContext::CCC_ObjCInterface; 2570 2571 case Sema::PCC_ObjCImplementation: 2572 return CodeCompletionContext::CCC_ObjCImplementation; 2573 2574 case Sema::PCC_ObjCInstanceVariableList: 2575 return CodeCompletionContext::CCC_ObjCIvarList; 2576 2577 case Sema::PCC_Template: 2578 case Sema::PCC_MemberTemplate: 2579 if (S.CurContext->isFileContext()) 2580 return CodeCompletionContext::CCC_TopLevel; 2581 else if (S.CurContext->isRecord()) 2582 return CodeCompletionContext::CCC_ClassStructUnion; 2583 else 2584 return CodeCompletionContext::CCC_Other; 2585 2586 case Sema::PCC_RecoveryInFunction: 2587 return CodeCompletionContext::CCC_Recovery; 2588 2589 case Sema::PCC_Expression: 2590 case Sema::PCC_ForInit: 2591 case Sema::PCC_Condition: 2592 return CodeCompletionContext::CCC_Expression; 2593 2594 case Sema::PCC_Statement: 2595 return CodeCompletionContext::CCC_Statement; 2596 2597 case Sema::PCC_Type: 2598 return CodeCompletionContext::CCC_Type; 2599 2600 case Sema::PCC_ParenthesizedExpression: 2601 return CodeCompletionContext::CCC_ParenthesizedExpression; 2602 } 2603 2604 return CodeCompletionContext::CCC_Other; 2605} 2606 2607/// \brief If we're in a C++ virtual member function, add completion results 2608/// that invoke the functions we override, since it's common to invoke the 2609/// overridden function as well as adding new functionality. 2610/// 2611/// \param S The semantic analysis object for which we are generating results. 2612/// 2613/// \param InContext This context in which the nested-name-specifier preceding 2614/// the code-completion point 2615static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext, 2616 ResultBuilder &Results) { 2617 // Look through blocks. 2618 DeclContext *CurContext = S.CurContext; 2619 while (isa<BlockDecl>(CurContext)) 2620 CurContext = CurContext->getParent(); 2621 2622 2623 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext); 2624 if (!Method || !Method->isVirtual()) 2625 return; 2626 2627 // We need to have names for all of the parameters, if we're going to 2628 // generate a forwarding call. 2629 for (CXXMethodDecl::param_iterator P = Method->param_begin(), 2630 PEnd = Method->param_end(); 2631 P != PEnd; 2632 ++P) { 2633 if (!(*P)->getDeclName()) 2634 return; 2635 } 2636 2637 for (CXXMethodDecl::method_iterator M = Method->begin_overridden_methods(), 2638 MEnd = Method->end_overridden_methods(); 2639 M != MEnd; ++M) { 2640 CodeCompletionString *Pattern = new CodeCompletionString; 2641 CXXMethodDecl *Overridden = const_cast<CXXMethodDecl *>(*M); 2642 if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl()) 2643 continue; 2644 2645 // If we need a nested-name-specifier, add one now. 2646 if (!InContext) { 2647 NestedNameSpecifier *NNS 2648 = getRequiredQualification(S.Context, CurContext, 2649 Overridden->getDeclContext()); 2650 if (NNS) { 2651 std::string Str; 2652 llvm::raw_string_ostream OS(Str); 2653 NNS->print(OS, S.Context.PrintingPolicy); 2654 Pattern->AddTextChunk(OS.str()); 2655 } 2656 } else if (!InContext->Equals(Overridden->getDeclContext())) 2657 continue; 2658 2659 Pattern->AddTypedTextChunk(Overridden->getNameAsString()); 2660 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 2661 bool FirstParam = true; 2662 for (CXXMethodDecl::param_iterator P = Method->param_begin(), 2663 PEnd = Method->param_end(); 2664 P != PEnd; ++P) { 2665 if (FirstParam) 2666 FirstParam = false; 2667 else 2668 Pattern->AddChunk(CodeCompletionString::CK_Comma); 2669 2670 Pattern->AddPlaceholderChunk((*P)->getIdentifier()->getName()); 2671 } 2672 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 2673 Results.AddResult(CodeCompletionResult(Pattern, 2674 CCP_SuperCompletion, 2675 CXCursor_CXXMethod)); 2676 Results.Ignore(Overridden); 2677 } 2678} 2679 2680void Sema::CodeCompleteOrdinaryName(Scope *S, 2681 ParserCompletionContext CompletionContext) { 2682 typedef CodeCompletionResult Result; 2683 ResultBuilder Results(*this, 2684 mapCodeCompletionContext(*this, CompletionContext)); 2685 Results.EnterNewScope(); 2686 2687 // Determine how to filter results, e.g., so that the names of 2688 // values (functions, enumerators, function templates, etc.) are 2689 // only allowed where we can have an expression. 2690 switch (CompletionContext) { 2691 case PCC_Namespace: 2692 case PCC_Class: 2693 case PCC_ObjCInterface: 2694 case PCC_ObjCImplementation: 2695 case PCC_ObjCInstanceVariableList: 2696 case PCC_Template: 2697 case PCC_MemberTemplate: 2698 case PCC_Type: 2699 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName); 2700 break; 2701 2702 case PCC_Statement: 2703 case PCC_ParenthesizedExpression: 2704 case PCC_Expression: 2705 case PCC_ForInit: 2706 case PCC_Condition: 2707 if (WantTypesInContext(CompletionContext, getLangOptions())) 2708 Results.setFilter(&ResultBuilder::IsOrdinaryName); 2709 else 2710 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName); 2711 2712 if (getLangOptions().CPlusPlus) 2713 MaybeAddOverrideCalls(*this, /*InContext=*/0, Results); 2714 break; 2715 2716 case PCC_RecoveryInFunction: 2717 // Unfiltered 2718 break; 2719 } 2720 2721 // If we are in a C++ non-static member function, check the qualifiers on 2722 // the member function to filter/prioritize the results list. 2723 if (CXXMethodDecl *CurMethod = dyn_cast<CXXMethodDecl>(CurContext)) 2724 if (CurMethod->isInstance()) 2725 Results.setObjectTypeQualifiers( 2726 Qualifiers::fromCVRMask(CurMethod->getTypeQualifiers())); 2727 2728 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2729 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 2730 CodeCompleter->includeGlobals()); 2731 2732 AddOrdinaryNameResults(CompletionContext, S, *this, Results); 2733 Results.ExitScope(); 2734 2735 switch (CompletionContext) { 2736 case PCC_ParenthesizedExpression: 2737 case PCC_Expression: 2738 case PCC_Statement: 2739 case PCC_RecoveryInFunction: 2740 if (S->getFnParent()) 2741 AddPrettyFunctionResults(PP.getLangOptions(), Results); 2742 break; 2743 2744 case PCC_Namespace: 2745 case PCC_Class: 2746 case PCC_ObjCInterface: 2747 case PCC_ObjCImplementation: 2748 case PCC_ObjCInstanceVariableList: 2749 case PCC_Template: 2750 case PCC_MemberTemplate: 2751 case PCC_ForInit: 2752 case PCC_Condition: 2753 case PCC_Type: 2754 break; 2755 } 2756 2757 if (CodeCompleter->includeMacros()) 2758 AddMacroResults(PP, Results); 2759 2760 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 2761 Results.data(),Results.size()); 2762} 2763 2764static void AddClassMessageCompletions(Sema &SemaRef, Scope *S, 2765 ParsedType Receiver, 2766 IdentifierInfo **SelIdents, 2767 unsigned NumSelIdents, 2768 bool AtArgumentExpression, 2769 bool IsSuper, 2770 ResultBuilder &Results); 2771 2772void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS, 2773 bool AllowNonIdentifiers, 2774 bool AllowNestedNameSpecifiers) { 2775 typedef CodeCompletionResult Result; 2776 ResultBuilder Results(*this, 2777 AllowNestedNameSpecifiers 2778 ? CodeCompletionContext::CCC_PotentiallyQualifiedName 2779 : CodeCompletionContext::CCC_Name); 2780 Results.EnterNewScope(); 2781 2782 // Type qualifiers can come after names. 2783 Results.AddResult(Result("const")); 2784 Results.AddResult(Result("volatile")); 2785 if (getLangOptions().C99) 2786 Results.AddResult(Result("restrict")); 2787 2788 if (getLangOptions().CPlusPlus) { 2789 if (AllowNonIdentifiers) { 2790 Results.AddResult(Result("operator")); 2791 } 2792 2793 // Add nested-name-specifiers. 2794 if (AllowNestedNameSpecifiers) { 2795 Results.allowNestedNameSpecifiers(); 2796 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy); 2797 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2798 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer, 2799 CodeCompleter->includeGlobals()); 2800 Results.setFilter(0); 2801 } 2802 } 2803 Results.ExitScope(); 2804 2805 // If we're in a context where we might have an expression (rather than a 2806 // declaration), and what we've seen so far is an Objective-C type that could 2807 // be a receiver of a class message, this may be a class message send with 2808 // the initial opening bracket '[' missing. Add appropriate completions. 2809 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers && 2810 DS.getTypeSpecType() == DeclSpec::TST_typename && 2811 DS.getStorageClassSpecAsWritten() == DeclSpec::SCS_unspecified && 2812 !DS.isThreadSpecified() && !DS.isExternInLinkageSpec() && 2813 DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified && 2814 DS.getTypeSpecSign() == DeclSpec::TSS_unspecified && 2815 DS.getTypeQualifiers() == 0 && 2816 S && 2817 (S->getFlags() & Scope::DeclScope) != 0 && 2818 (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope | 2819 Scope::FunctionPrototypeScope | 2820 Scope::AtCatchScope)) == 0) { 2821 ParsedType T = DS.getRepAsType(); 2822 if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType()) 2823 AddClassMessageCompletions(*this, S, T, 0, 0, false, false, Results); 2824 } 2825 2826 // Note that we intentionally suppress macro results here, since we do not 2827 // encourage using macros to produce the names of entities. 2828 2829 HandleCodeCompleteResults(this, CodeCompleter, 2830 Results.getCompletionContext(), 2831 Results.data(), Results.size()); 2832} 2833 2834struct Sema::CodeCompleteExpressionData { 2835 CodeCompleteExpressionData(QualType PreferredType = QualType()) 2836 : PreferredType(PreferredType), IntegralConstantExpression(false), 2837 ObjCCollection(false) { } 2838 2839 QualType PreferredType; 2840 bool IntegralConstantExpression; 2841 bool ObjCCollection; 2842 llvm::SmallVector<Decl *, 4> IgnoreDecls; 2843}; 2844 2845/// \brief Perform code-completion in an expression context when we know what 2846/// type we're looking for. 2847/// 2848/// \param IntegralConstantExpression Only permit integral constant 2849/// expressions. 2850void Sema::CodeCompleteExpression(Scope *S, 2851 const CodeCompleteExpressionData &Data) { 2852 typedef CodeCompletionResult Result; 2853 ResultBuilder Results(*this, CodeCompletionContext::CCC_Expression); 2854 if (Data.ObjCCollection) 2855 Results.setFilter(&ResultBuilder::IsObjCCollection); 2856 else if (Data.IntegralConstantExpression) 2857 Results.setFilter(&ResultBuilder::IsIntegralConstantValue); 2858 else if (WantTypesInContext(PCC_Expression, getLangOptions())) 2859 Results.setFilter(&ResultBuilder::IsOrdinaryName); 2860 else 2861 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName); 2862 2863 if (!Data.PreferredType.isNull()) 2864 Results.setPreferredType(Data.PreferredType.getNonReferenceType()); 2865 2866 // Ignore any declarations that we were told that we don't care about. 2867 for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I) 2868 Results.Ignore(Data.IgnoreDecls[I]); 2869 2870 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2871 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 2872 CodeCompleter->includeGlobals()); 2873 2874 Results.EnterNewScope(); 2875 AddOrdinaryNameResults(PCC_Expression, S, *this, Results); 2876 Results.ExitScope(); 2877 2878 bool PreferredTypeIsPointer = false; 2879 if (!Data.PreferredType.isNull()) 2880 PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType() 2881 || Data.PreferredType->isMemberPointerType() 2882 || Data.PreferredType->isBlockPointerType(); 2883 2884 if (S->getFnParent() && 2885 !Data.ObjCCollection && 2886 !Data.IntegralConstantExpression) 2887 AddPrettyFunctionResults(PP.getLangOptions(), Results); 2888 2889 if (CodeCompleter->includeMacros()) 2890 AddMacroResults(PP, Results, PreferredTypeIsPointer); 2891 HandleCodeCompleteResults(this, CodeCompleter, 2892 CodeCompletionContext(CodeCompletionContext::CCC_Expression, 2893 Data.PreferredType), 2894 Results.data(),Results.size()); 2895} 2896 2897void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E) { 2898 if (E.isInvalid()) 2899 CodeCompleteOrdinaryName(S, PCC_RecoveryInFunction); 2900 else if (getLangOptions().ObjC1) 2901 CodeCompleteObjCInstanceMessage(S, E.take(), 0, 0, false); 2902} 2903 2904static void AddObjCProperties(ObjCContainerDecl *Container, 2905 bool AllowCategories, 2906 DeclContext *CurContext, 2907 ResultBuilder &Results) { 2908 typedef CodeCompletionResult Result; 2909 2910 // Add properties in this container. 2911 for (ObjCContainerDecl::prop_iterator P = Container->prop_begin(), 2912 PEnd = Container->prop_end(); 2913 P != PEnd; 2914 ++P) 2915 Results.MaybeAddResult(Result(*P, 0), CurContext); 2916 2917 // Add properties in referenced protocols. 2918 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) { 2919 for (ObjCProtocolDecl::protocol_iterator P = Protocol->protocol_begin(), 2920 PEnd = Protocol->protocol_end(); 2921 P != PEnd; ++P) 2922 AddObjCProperties(*P, AllowCategories, CurContext, Results); 2923 } else if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)){ 2924 if (AllowCategories) { 2925 // Look through categories. 2926 for (ObjCCategoryDecl *Category = IFace->getCategoryList(); 2927 Category; Category = Category->getNextClassCategory()) 2928 AddObjCProperties(Category, AllowCategories, CurContext, Results); 2929 } 2930 2931 // Look through protocols. 2932 for (ObjCInterfaceDecl::all_protocol_iterator 2933 I = IFace->all_referenced_protocol_begin(), 2934 E = IFace->all_referenced_protocol_end(); I != E; ++I) 2935 AddObjCProperties(*I, AllowCategories, CurContext, Results); 2936 2937 // Look in the superclass. 2938 if (IFace->getSuperClass()) 2939 AddObjCProperties(IFace->getSuperClass(), AllowCategories, CurContext, 2940 Results); 2941 } else if (const ObjCCategoryDecl *Category 2942 = dyn_cast<ObjCCategoryDecl>(Container)) { 2943 // Look through protocols. 2944 for (ObjCCategoryDecl::protocol_iterator P = Category->protocol_begin(), 2945 PEnd = Category->protocol_end(); 2946 P != PEnd; ++P) 2947 AddObjCProperties(*P, AllowCategories, CurContext, Results); 2948 } 2949} 2950 2951void Sema::CodeCompleteMemberReferenceExpr(Scope *S, ExprTy *BaseE, 2952 SourceLocation OpLoc, 2953 bool IsArrow) { 2954 if (!BaseE || !CodeCompleter) 2955 return; 2956 2957 typedef CodeCompletionResult Result; 2958 2959 Expr *Base = static_cast<Expr *>(BaseE); 2960 QualType BaseType = Base->getType(); 2961 2962 if (IsArrow) { 2963 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) 2964 BaseType = Ptr->getPointeeType(); 2965 else if (BaseType->isObjCObjectPointerType()) 2966 /*Do nothing*/ ; 2967 else 2968 return; 2969 } 2970 2971 ResultBuilder Results(*this, 2972 CodeCompletionContext(CodeCompletionContext::CCC_MemberAccess, 2973 BaseType), 2974 &ResultBuilder::IsMember); 2975 Results.EnterNewScope(); 2976 if (const RecordType *Record = BaseType->getAs<RecordType>()) { 2977 // Indicate that we are performing a member access, and the cv-qualifiers 2978 // for the base object type. 2979 Results.setObjectTypeQualifiers(BaseType.getQualifiers()); 2980 2981 // Access to a C/C++ class, struct, or union. 2982 Results.allowNestedNameSpecifiers(); 2983 CodeCompletionDeclConsumer Consumer(Results, CurContext); 2984 LookupVisibleDecls(Record->getDecl(), LookupMemberName, Consumer, 2985 CodeCompleter->includeGlobals()); 2986 2987 if (getLangOptions().CPlusPlus) { 2988 if (!Results.empty()) { 2989 // The "template" keyword can follow "->" or "." in the grammar. 2990 // However, we only want to suggest the template keyword if something 2991 // is dependent. 2992 bool IsDependent = BaseType->isDependentType(); 2993 if (!IsDependent) { 2994 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent()) 2995 if (DeclContext *Ctx = (DeclContext *)DepScope->getEntity()) { 2996 IsDependent = Ctx->isDependentContext(); 2997 break; 2998 } 2999 } 3000 3001 if (IsDependent) 3002 Results.AddResult(Result("template")); 3003 } 3004 } 3005 } else if (!IsArrow && BaseType->getAsObjCInterfacePointerType()) { 3006 // Objective-C property reference. 3007 3008 // Add property results based on our interface. 3009 const ObjCObjectPointerType *ObjCPtr 3010 = BaseType->getAsObjCInterfacePointerType(); 3011 assert(ObjCPtr && "Non-NULL pointer guaranteed above!"); 3012 AddObjCProperties(ObjCPtr->getInterfaceDecl(), true, CurContext, Results); 3013 3014 // Add properties from the protocols in a qualified interface. 3015 for (ObjCObjectPointerType::qual_iterator I = ObjCPtr->qual_begin(), 3016 E = ObjCPtr->qual_end(); 3017 I != E; ++I) 3018 AddObjCProperties(*I, true, CurContext, Results); 3019 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) || 3020 (!IsArrow && BaseType->isObjCObjectType())) { 3021 // Objective-C instance variable access. 3022 ObjCInterfaceDecl *Class = 0; 3023 if (const ObjCObjectPointerType *ObjCPtr 3024 = BaseType->getAs<ObjCObjectPointerType>()) 3025 Class = ObjCPtr->getInterfaceDecl(); 3026 else 3027 Class = BaseType->getAs<ObjCObjectType>()->getInterface(); 3028 3029 // Add all ivars from this class and its superclasses. 3030 if (Class) { 3031 CodeCompletionDeclConsumer Consumer(Results, CurContext); 3032 Results.setFilter(&ResultBuilder::IsObjCIvar); 3033 LookupVisibleDecls(Class, LookupMemberName, Consumer, 3034 CodeCompleter->includeGlobals()); 3035 } 3036 } 3037 3038 // FIXME: How do we cope with isa? 3039 3040 Results.ExitScope(); 3041 3042 // Hand off the results found for code completion. 3043 HandleCodeCompleteResults(this, CodeCompleter, 3044 Results.getCompletionContext(), 3045 Results.data(),Results.size()); 3046} 3047 3048void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) { 3049 if (!CodeCompleter) 3050 return; 3051 3052 typedef CodeCompletionResult Result; 3053 ResultBuilder::LookupFilter Filter = 0; 3054 enum CodeCompletionContext::Kind ContextKind 3055 = CodeCompletionContext::CCC_Other; 3056 switch ((DeclSpec::TST)TagSpec) { 3057 case DeclSpec::TST_enum: 3058 Filter = &ResultBuilder::IsEnum; 3059 ContextKind = CodeCompletionContext::CCC_EnumTag; 3060 break; 3061 3062 case DeclSpec::TST_union: 3063 Filter = &ResultBuilder::IsUnion; 3064 ContextKind = CodeCompletionContext::CCC_UnionTag; 3065 break; 3066 3067 case DeclSpec::TST_struct: 3068 case DeclSpec::TST_class: 3069 Filter = &ResultBuilder::IsClassOrStruct; 3070 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag; 3071 break; 3072 3073 default: 3074 assert(false && "Unknown type specifier kind in CodeCompleteTag"); 3075 return; 3076 } 3077 3078 ResultBuilder Results(*this, ContextKind); 3079 CodeCompletionDeclConsumer Consumer(Results, CurContext); 3080 3081 // First pass: look for tags. 3082 Results.setFilter(Filter); 3083 LookupVisibleDecls(S, LookupTagName, Consumer, 3084 CodeCompleter->includeGlobals()); 3085 3086 if (CodeCompleter->includeGlobals()) { 3087 // Second pass: look for nested name specifiers. 3088 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier); 3089 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer); 3090 } 3091 3092 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 3093 Results.data(),Results.size()); 3094} 3095 3096void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) { 3097 ResultBuilder Results(*this, CodeCompletionContext::CCC_TypeQualifiers); 3098 Results.EnterNewScope(); 3099 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const)) 3100 Results.AddResult("const"); 3101 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile)) 3102 Results.AddResult("volatile"); 3103 if (getLangOptions().C99 && 3104 !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict)) 3105 Results.AddResult("restrict"); 3106 Results.ExitScope(); 3107 HandleCodeCompleteResults(this, CodeCompleter, 3108 Results.getCompletionContext(), 3109 Results.data(), Results.size()); 3110} 3111 3112void Sema::CodeCompleteCase(Scope *S) { 3113 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter) 3114 return; 3115 3116 SwitchStmt *Switch = getCurFunction()->SwitchStack.back(); 3117 if (!Switch->getCond()->getType()->isEnumeralType()) { 3118 CodeCompleteExpressionData Data(Switch->getCond()->getType()); 3119 Data.IntegralConstantExpression = true; 3120 CodeCompleteExpression(S, Data); 3121 return; 3122 } 3123 3124 // Code-complete the cases of a switch statement over an enumeration type 3125 // by providing the list of 3126 EnumDecl *Enum = Switch->getCond()->getType()->getAs<EnumType>()->getDecl(); 3127 3128 // Determine which enumerators we have already seen in the switch statement. 3129 // FIXME: Ideally, we would also be able to look *past* the code-completion 3130 // token, in case we are code-completing in the middle of the switch and not 3131 // at the end. However, we aren't able to do so at the moment. 3132 llvm::SmallPtrSet<EnumConstantDecl *, 8> EnumeratorsSeen; 3133 NestedNameSpecifier *Qualifier = 0; 3134 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC; 3135 SC = SC->getNextSwitchCase()) { 3136 CaseStmt *Case = dyn_cast<CaseStmt>(SC); 3137 if (!Case) 3138 continue; 3139 3140 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts(); 3141 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CaseVal)) 3142 if (EnumConstantDecl *Enumerator 3143 = dyn_cast<EnumConstantDecl>(DRE->getDecl())) { 3144 // We look into the AST of the case statement to determine which 3145 // enumerator was named. Alternatively, we could compute the value of 3146 // the integral constant expression, then compare it against the 3147 // values of each enumerator. However, value-based approach would not 3148 // work as well with C++ templates where enumerators declared within a 3149 // template are type- and value-dependent. 3150 EnumeratorsSeen.insert(Enumerator); 3151 3152 // If this is a qualified-id, keep track of the nested-name-specifier 3153 // so that we can reproduce it as part of code completion, e.g., 3154 // 3155 // switch (TagD.getKind()) { 3156 // case TagDecl::TK_enum: 3157 // break; 3158 // case XXX 3159 // 3160 // At the XXX, our completions are TagDecl::TK_union, 3161 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union, 3162 // TK_struct, and TK_class. 3163 Qualifier = DRE->getQualifier(); 3164 } 3165 } 3166 3167 if (getLangOptions().CPlusPlus && !Qualifier && EnumeratorsSeen.empty()) { 3168 // If there are no prior enumerators in C++, check whether we have to 3169 // qualify the names of the enumerators that we suggest, because they 3170 // may not be visible in this scope. 3171 Qualifier = getRequiredQualification(Context, CurContext, 3172 Enum->getDeclContext()); 3173 3174 // FIXME: Scoped enums need to start with "EnumDecl" as the context! 3175 } 3176 3177 // Add any enumerators that have not yet been mentioned. 3178 ResultBuilder Results(*this, CodeCompletionContext::CCC_Expression); 3179 Results.EnterNewScope(); 3180 for (EnumDecl::enumerator_iterator E = Enum->enumerator_begin(), 3181 EEnd = Enum->enumerator_end(); 3182 E != EEnd; ++E) { 3183 if (EnumeratorsSeen.count(*E)) 3184 continue; 3185 3186 Results.AddResult(CodeCompletionResult(*E, Qualifier), 3187 CurContext, 0, false); 3188 } 3189 Results.ExitScope(); 3190 3191 if (CodeCompleter->includeMacros()) 3192 AddMacroResults(PP, Results); 3193 HandleCodeCompleteResults(this, CodeCompleter, 3194 CodeCompletionContext::CCC_Expression, 3195 Results.data(),Results.size()); 3196} 3197 3198namespace { 3199 struct IsBetterOverloadCandidate { 3200 Sema &S; 3201 SourceLocation Loc; 3202 3203 public: 3204 explicit IsBetterOverloadCandidate(Sema &S, SourceLocation Loc) 3205 : S(S), Loc(Loc) { } 3206 3207 bool 3208 operator()(const OverloadCandidate &X, const OverloadCandidate &Y) const { 3209 return isBetterOverloadCandidate(S, X, Y, Loc); 3210 } 3211 }; 3212} 3213 3214static bool anyNullArguments(Expr **Args, unsigned NumArgs) { 3215 if (NumArgs && !Args) 3216 return true; 3217 3218 for (unsigned I = 0; I != NumArgs; ++I) 3219 if (!Args[I]) 3220 return true; 3221 3222 return false; 3223} 3224 3225void Sema::CodeCompleteCall(Scope *S, ExprTy *FnIn, 3226 ExprTy **ArgsIn, unsigned NumArgs) { 3227 if (!CodeCompleter) 3228 return; 3229 3230 // When we're code-completing for a call, we fall back to ordinary 3231 // name code-completion whenever we can't produce specific 3232 // results. We may want to revisit this strategy in the future, 3233 // e.g., by merging the two kinds of results. 3234 3235 Expr *Fn = (Expr *)FnIn; 3236 Expr **Args = (Expr **)ArgsIn; 3237 3238 // Ignore type-dependent call expressions entirely. 3239 if (!Fn || Fn->isTypeDependent() || anyNullArguments(Args, NumArgs) || 3240 Expr::hasAnyTypeDependentArguments(Args, NumArgs)) { 3241 CodeCompleteOrdinaryName(S, PCC_Expression); 3242 return; 3243 } 3244 3245 // Build an overload candidate set based on the functions we find. 3246 SourceLocation Loc = Fn->getExprLoc(); 3247 OverloadCandidateSet CandidateSet(Loc); 3248 3249 // FIXME: What if we're calling something that isn't a function declaration? 3250 // FIXME: What if we're calling a pseudo-destructor? 3251 // FIXME: What if we're calling a member function? 3252 3253 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate; 3254 llvm::SmallVector<ResultCandidate, 8> Results; 3255 3256 Expr *NakedFn = Fn->IgnoreParenCasts(); 3257 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn)) 3258 AddOverloadedCallCandidates(ULE, Args, NumArgs, CandidateSet, 3259 /*PartialOverloading=*/ true); 3260 else if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(NakedFn)) { 3261 FunctionDecl *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl()); 3262 if (FDecl) { 3263 if (!getLangOptions().CPlusPlus || 3264 !FDecl->getType()->getAs<FunctionProtoType>()) 3265 Results.push_back(ResultCandidate(FDecl)); 3266 else 3267 // FIXME: access? 3268 AddOverloadCandidate(FDecl, DeclAccessPair::make(FDecl, AS_none), 3269 Args, NumArgs, CandidateSet, 3270 false, /*PartialOverloading*/true); 3271 } 3272 } 3273 3274 QualType ParamType; 3275 3276 if (!CandidateSet.empty()) { 3277 // Sort the overload candidate set by placing the best overloads first. 3278 std::stable_sort(CandidateSet.begin(), CandidateSet.end(), 3279 IsBetterOverloadCandidate(*this, Loc)); 3280 3281 // Add the remaining viable overload candidates as code-completion reslults. 3282 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(), 3283 CandEnd = CandidateSet.end(); 3284 Cand != CandEnd; ++Cand) { 3285 if (Cand->Viable) 3286 Results.push_back(ResultCandidate(Cand->Function)); 3287 } 3288 3289 // From the viable candidates, try to determine the type of this parameter. 3290 for (unsigned I = 0, N = Results.size(); I != N; ++I) { 3291 if (const FunctionType *FType = Results[I].getFunctionType()) 3292 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FType)) 3293 if (NumArgs < Proto->getNumArgs()) { 3294 if (ParamType.isNull()) 3295 ParamType = Proto->getArgType(NumArgs); 3296 else if (!Context.hasSameUnqualifiedType( 3297 ParamType.getNonReferenceType(), 3298 Proto->getArgType(NumArgs).getNonReferenceType())) { 3299 ParamType = QualType(); 3300 break; 3301 } 3302 } 3303 } 3304 } else { 3305 // Try to determine the parameter type from the type of the expression 3306 // being called. 3307 QualType FunctionType = Fn->getType(); 3308 if (const PointerType *Ptr = FunctionType->getAs<PointerType>()) 3309 FunctionType = Ptr->getPointeeType(); 3310 else if (const BlockPointerType *BlockPtr 3311 = FunctionType->getAs<BlockPointerType>()) 3312 FunctionType = BlockPtr->getPointeeType(); 3313 else if (const MemberPointerType *MemPtr 3314 = FunctionType->getAs<MemberPointerType>()) 3315 FunctionType = MemPtr->getPointeeType(); 3316 3317 if (const FunctionProtoType *Proto 3318 = FunctionType->getAs<FunctionProtoType>()) { 3319 if (NumArgs < Proto->getNumArgs()) 3320 ParamType = Proto->getArgType(NumArgs); 3321 } 3322 } 3323 3324 if (ParamType.isNull()) 3325 CodeCompleteOrdinaryName(S, PCC_Expression); 3326 else 3327 CodeCompleteExpression(S, ParamType); 3328 3329 if (!Results.empty()) 3330 CodeCompleter->ProcessOverloadCandidates(*this, NumArgs, Results.data(), 3331 Results.size()); 3332} 3333 3334void Sema::CodeCompleteInitializer(Scope *S, Decl *D) { 3335 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D); 3336 if (!VD) { 3337 CodeCompleteOrdinaryName(S, PCC_Expression); 3338 return; 3339 } 3340 3341 CodeCompleteExpression(S, VD->getType()); 3342} 3343 3344void Sema::CodeCompleteReturn(Scope *S) { 3345 QualType ResultType; 3346 if (isa<BlockDecl>(CurContext)) { 3347 if (BlockScopeInfo *BSI = getCurBlock()) 3348 ResultType = BSI->ReturnType; 3349 } else if (FunctionDecl *Function = dyn_cast<FunctionDecl>(CurContext)) 3350 ResultType = Function->getResultType(); 3351 else if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(CurContext)) 3352 ResultType = Method->getResultType(); 3353 3354 if (ResultType.isNull()) 3355 CodeCompleteOrdinaryName(S, PCC_Expression); 3356 else 3357 CodeCompleteExpression(S, ResultType); 3358} 3359 3360void Sema::CodeCompleteAssignmentRHS(Scope *S, ExprTy *LHS) { 3361 if (LHS) 3362 CodeCompleteExpression(S, static_cast<Expr *>(LHS)->getType()); 3363 else 3364 CodeCompleteOrdinaryName(S, PCC_Expression); 3365} 3366 3367void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, 3368 bool EnteringContext) { 3369 if (!SS.getScopeRep() || !CodeCompleter) 3370 return; 3371 3372 DeclContext *Ctx = computeDeclContext(SS, EnteringContext); 3373 if (!Ctx) 3374 return; 3375 3376 // Try to instantiate any non-dependent declaration contexts before 3377 // we look in them. 3378 if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx)) 3379 return; 3380 3381 ResultBuilder Results(*this, CodeCompletionContext::CCC_Name); 3382 Results.EnterNewScope(); 3383 3384 // The "template" keyword can follow "::" in the grammar, but only 3385 // put it into the grammar if the nested-name-specifier is dependent. 3386 NestedNameSpecifier *NNS = (NestedNameSpecifier *)SS.getScopeRep(); 3387 if (!Results.empty() && NNS->isDependent()) 3388 Results.AddResult("template"); 3389 3390 // Add calls to overridden virtual functions, if there are any. 3391 // 3392 // FIXME: This isn't wonderful, because we don't know whether we're actually 3393 // in a context that permits expressions. This is a general issue with 3394 // qualified-id completions. 3395 if (!EnteringContext) 3396 MaybeAddOverrideCalls(*this, Ctx, Results); 3397 Results.ExitScope(); 3398 3399 CodeCompletionDeclConsumer Consumer(Results, CurContext); 3400 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer); 3401 3402 HandleCodeCompleteResults(this, CodeCompleter, 3403 CodeCompletionContext::CCC_Name, 3404 Results.data(),Results.size()); 3405} 3406 3407void Sema::CodeCompleteUsing(Scope *S) { 3408 if (!CodeCompleter) 3409 return; 3410 3411 ResultBuilder Results(*this, 3412 CodeCompletionContext::CCC_PotentiallyQualifiedName, 3413 &ResultBuilder::IsNestedNameSpecifier); 3414 Results.EnterNewScope(); 3415 3416 // If we aren't in class scope, we could see the "namespace" keyword. 3417 if (!S->isClassScope()) 3418 Results.AddResult(CodeCompletionResult("namespace")); 3419 3420 // After "using", we can see anything that would start a 3421 // nested-name-specifier. 3422 CodeCompletionDeclConsumer Consumer(Results, CurContext); 3423 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 3424 CodeCompleter->includeGlobals()); 3425 Results.ExitScope(); 3426 3427 HandleCodeCompleteResults(this, CodeCompleter, 3428 CodeCompletionContext::CCC_PotentiallyQualifiedName, 3429 Results.data(),Results.size()); 3430} 3431 3432void Sema::CodeCompleteUsingDirective(Scope *S) { 3433 if (!CodeCompleter) 3434 return; 3435 3436 // After "using namespace", we expect to see a namespace name or namespace 3437 // alias. 3438 ResultBuilder Results(*this, CodeCompletionContext::CCC_Namespace, 3439 &ResultBuilder::IsNamespaceOrAlias); 3440 Results.EnterNewScope(); 3441 CodeCompletionDeclConsumer Consumer(Results, CurContext); 3442 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 3443 CodeCompleter->includeGlobals()); 3444 Results.ExitScope(); 3445 HandleCodeCompleteResults(this, CodeCompleter, 3446 CodeCompletionContext::CCC_Namespace, 3447 Results.data(),Results.size()); 3448} 3449 3450void Sema::CodeCompleteNamespaceDecl(Scope *S) { 3451 if (!CodeCompleter) 3452 return; 3453 3454 DeclContext *Ctx = (DeclContext *)S->getEntity(); 3455 if (!S->getParent()) 3456 Ctx = Context.getTranslationUnitDecl(); 3457 3458 bool SuppressedGlobalResults 3459 = Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx); 3460 3461 ResultBuilder Results(*this, 3462 SuppressedGlobalResults 3463 ? CodeCompletionContext::CCC_Namespace 3464 : CodeCompletionContext::CCC_Other, 3465 &ResultBuilder::IsNamespace); 3466 3467 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) { 3468 // We only want to see those namespaces that have already been defined 3469 // within this scope, because its likely that the user is creating an 3470 // extended namespace declaration. Keep track of the most recent 3471 // definition of each namespace. 3472 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest; 3473 for (DeclContext::specific_decl_iterator<NamespaceDecl> 3474 NS(Ctx->decls_begin()), NSEnd(Ctx->decls_end()); 3475 NS != NSEnd; ++NS) 3476 OrigToLatest[NS->getOriginalNamespace()] = *NS; 3477 3478 // Add the most recent definition (or extended definition) of each 3479 // namespace to the list of results. 3480 Results.EnterNewScope(); 3481 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator 3482 NS = OrigToLatest.begin(), NSEnd = OrigToLatest.end(); 3483 NS != NSEnd; ++NS) 3484 Results.AddResult(CodeCompletionResult(NS->second, 0), 3485 CurContext, 0, false); 3486 Results.ExitScope(); 3487 } 3488 3489 HandleCodeCompleteResults(this, CodeCompleter, 3490 Results.getCompletionContext(), 3491 Results.data(),Results.size()); 3492} 3493 3494void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) { 3495 if (!CodeCompleter) 3496 return; 3497 3498 // After "namespace", we expect to see a namespace or alias. 3499 ResultBuilder Results(*this, CodeCompletionContext::CCC_Namespace, 3500 &ResultBuilder::IsNamespaceOrAlias); 3501 CodeCompletionDeclConsumer Consumer(Results, CurContext); 3502 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 3503 CodeCompleter->includeGlobals()); 3504 HandleCodeCompleteResults(this, CodeCompleter, 3505 Results.getCompletionContext(), 3506 Results.data(),Results.size()); 3507} 3508 3509void Sema::CodeCompleteOperatorName(Scope *S) { 3510 if (!CodeCompleter) 3511 return; 3512 3513 typedef CodeCompletionResult Result; 3514 ResultBuilder Results(*this, CodeCompletionContext::CCC_Type, 3515 &ResultBuilder::IsType); 3516 Results.EnterNewScope(); 3517 3518 // Add the names of overloadable operators. 3519#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 3520 if (std::strcmp(Spelling, "?")) \ 3521 Results.AddResult(Result(Spelling)); 3522#include "clang/Basic/OperatorKinds.def" 3523 3524 // Add any type names visible from the current scope 3525 Results.allowNestedNameSpecifiers(); 3526 CodeCompletionDeclConsumer Consumer(Results, CurContext); 3527 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 3528 CodeCompleter->includeGlobals()); 3529 3530 // Add any type specifiers 3531 AddTypeSpecifierResults(getLangOptions(), Results); 3532 Results.ExitScope(); 3533 3534 HandleCodeCompleteResults(this, CodeCompleter, 3535 CodeCompletionContext::CCC_Type, 3536 Results.data(),Results.size()); 3537} 3538 3539void Sema::CodeCompleteConstructorInitializer(Decl *ConstructorD, 3540 CXXBaseOrMemberInitializer** Initializers, 3541 unsigned NumInitializers) { 3542 CXXConstructorDecl *Constructor 3543 = static_cast<CXXConstructorDecl *>(ConstructorD); 3544 if (!Constructor) 3545 return; 3546 3547 ResultBuilder Results(*this, 3548 CodeCompletionContext::CCC_PotentiallyQualifiedName); 3549 Results.EnterNewScope(); 3550 3551 // Fill in any already-initialized fields or base classes. 3552 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields; 3553 llvm::SmallPtrSet<CanQualType, 4> InitializedBases; 3554 for (unsigned I = 0; I != NumInitializers; ++I) { 3555 if (Initializers[I]->isBaseInitializer()) 3556 InitializedBases.insert( 3557 Context.getCanonicalType(QualType(Initializers[I]->getBaseClass(), 0))); 3558 else 3559 InitializedFields.insert(cast<FieldDecl>(Initializers[I]->getMember())); 3560 } 3561 3562 // Add completions for base classes. 3563 bool SawLastInitializer = (NumInitializers == 0); 3564 CXXRecordDecl *ClassDecl = Constructor->getParent(); 3565 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->bases_begin(), 3566 BaseEnd = ClassDecl->bases_end(); 3567 Base != BaseEnd; ++Base) { 3568 if (!InitializedBases.insert(Context.getCanonicalType(Base->getType()))) { 3569 SawLastInitializer 3570 = NumInitializers > 0 && 3571 Initializers[NumInitializers - 1]->isBaseInitializer() && 3572 Context.hasSameUnqualifiedType(Base->getType(), 3573 QualType(Initializers[NumInitializers - 1]->getBaseClass(), 0)); 3574 continue; 3575 } 3576 3577 CodeCompletionString *Pattern = new CodeCompletionString; 3578 Pattern->AddTypedTextChunk( 3579 Base->getType().getAsString(Context.PrintingPolicy)); 3580 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 3581 Pattern->AddPlaceholderChunk("args"); 3582 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 3583 Results.AddResult(CodeCompletionResult(Pattern, 3584 SawLastInitializer? CCP_NextInitializer 3585 : CCP_MemberDeclaration)); 3586 SawLastInitializer = false; 3587 } 3588 3589 // Add completions for virtual base classes. 3590 for (CXXRecordDecl::base_class_iterator Base = ClassDecl->vbases_begin(), 3591 BaseEnd = ClassDecl->vbases_end(); 3592 Base != BaseEnd; ++Base) { 3593 if (!InitializedBases.insert(Context.getCanonicalType(Base->getType()))) { 3594 SawLastInitializer 3595 = NumInitializers > 0 && 3596 Initializers[NumInitializers - 1]->isBaseInitializer() && 3597 Context.hasSameUnqualifiedType(Base->getType(), 3598 QualType(Initializers[NumInitializers - 1]->getBaseClass(), 0)); 3599 continue; 3600 } 3601 3602 CodeCompletionString *Pattern = new CodeCompletionString; 3603 Pattern->AddTypedTextChunk( 3604 Base->getType().getAsString(Context.PrintingPolicy)); 3605 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 3606 Pattern->AddPlaceholderChunk("args"); 3607 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 3608 Results.AddResult(CodeCompletionResult(Pattern, 3609 SawLastInitializer? CCP_NextInitializer 3610 : CCP_MemberDeclaration)); 3611 SawLastInitializer = false; 3612 } 3613 3614 // Add completions for members. 3615 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 3616 FieldEnd = ClassDecl->field_end(); 3617 Field != FieldEnd; ++Field) { 3618 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl()))) { 3619 SawLastInitializer 3620 = NumInitializers > 0 && 3621 Initializers[NumInitializers - 1]->isMemberInitializer() && 3622 Initializers[NumInitializers - 1]->getMember() == *Field; 3623 continue; 3624 } 3625 3626 if (!Field->getDeclName()) 3627 continue; 3628 3629 CodeCompletionString *Pattern = new CodeCompletionString; 3630 Pattern->AddTypedTextChunk(Field->getIdentifier()->getName()); 3631 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 3632 Pattern->AddPlaceholderChunk("args"); 3633 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 3634 Results.AddResult(CodeCompletionResult(Pattern, 3635 SawLastInitializer? CCP_NextInitializer 3636 : CCP_MemberDeclaration, 3637 CXCursor_MemberRef)); 3638 SawLastInitializer = false; 3639 } 3640 Results.ExitScope(); 3641 3642 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 3643 Results.data(), Results.size()); 3644} 3645 3646// Macro that expands to @Keyword or Keyword, depending on whether NeedAt is 3647// true or false. 3648#define OBJC_AT_KEYWORD_NAME(NeedAt,Keyword) NeedAt? "@" #Keyword : #Keyword 3649static void AddObjCImplementationResults(const LangOptions &LangOpts, 3650 ResultBuilder &Results, 3651 bool NeedAt) { 3652 typedef CodeCompletionResult Result; 3653 // Since we have an implementation, we can end it. 3654 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,end))); 3655 3656 CodeCompletionString *Pattern = 0; 3657 if (LangOpts.ObjC2) { 3658 // @dynamic 3659 Pattern = new CodeCompletionString; 3660 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,dynamic)); 3661 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 3662 Pattern->AddPlaceholderChunk("property"); 3663 Results.AddResult(Result(Pattern)); 3664 3665 // @synthesize 3666 Pattern = new CodeCompletionString; 3667 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,synthesize)); 3668 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 3669 Pattern->AddPlaceholderChunk("property"); 3670 Results.AddResult(Result(Pattern)); 3671 } 3672} 3673 3674static void AddObjCInterfaceResults(const LangOptions &LangOpts, 3675 ResultBuilder &Results, 3676 bool NeedAt) { 3677 typedef CodeCompletionResult Result; 3678 3679 // Since we have an interface or protocol, we can end it. 3680 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,end))); 3681 3682 if (LangOpts.ObjC2) { 3683 // @property 3684 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,property))); 3685 3686 // @required 3687 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,required))); 3688 3689 // @optional 3690 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,optional))); 3691 } 3692} 3693 3694static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) { 3695 typedef CodeCompletionResult Result; 3696 CodeCompletionString *Pattern = 0; 3697 3698 // @class name ; 3699 Pattern = new CodeCompletionString; 3700 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,class)); 3701 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 3702 Pattern->AddPlaceholderChunk("name"); 3703 Results.AddResult(Result(Pattern)); 3704 3705 if (Results.includeCodePatterns()) { 3706 // @interface name 3707 // FIXME: Could introduce the whole pattern, including superclasses and 3708 // such. 3709 Pattern = new CodeCompletionString; 3710 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,interface)); 3711 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 3712 Pattern->AddPlaceholderChunk("class"); 3713 Results.AddResult(Result(Pattern)); 3714 3715 // @protocol name 3716 Pattern = new CodeCompletionString; 3717 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,protocol)); 3718 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 3719 Pattern->AddPlaceholderChunk("protocol"); 3720 Results.AddResult(Result(Pattern)); 3721 3722 // @implementation name 3723 Pattern = new CodeCompletionString; 3724 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,implementation)); 3725 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 3726 Pattern->AddPlaceholderChunk("class"); 3727 Results.AddResult(Result(Pattern)); 3728 } 3729 3730 // @compatibility_alias name 3731 Pattern = new CodeCompletionString; 3732 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,compatibility_alias)); 3733 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 3734 Pattern->AddPlaceholderChunk("alias"); 3735 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 3736 Pattern->AddPlaceholderChunk("class"); 3737 Results.AddResult(Result(Pattern)); 3738} 3739 3740void Sema::CodeCompleteObjCAtDirective(Scope *S, Decl *ObjCImpDecl, 3741 bool InInterface) { 3742 typedef CodeCompletionResult Result; 3743 ResultBuilder Results(*this, CodeCompletionContext::CCC_Other); 3744 Results.EnterNewScope(); 3745 if (ObjCImpDecl) 3746 AddObjCImplementationResults(getLangOptions(), Results, false); 3747 else if (InInterface) 3748 AddObjCInterfaceResults(getLangOptions(), Results, false); 3749 else 3750 AddObjCTopLevelResults(Results, false); 3751 Results.ExitScope(); 3752 HandleCodeCompleteResults(this, CodeCompleter, 3753 CodeCompletionContext::CCC_Other, 3754 Results.data(),Results.size()); 3755} 3756 3757static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) { 3758 typedef CodeCompletionResult Result; 3759 CodeCompletionString *Pattern = 0; 3760 3761 // @encode ( type-name ) 3762 Pattern = new CodeCompletionString; 3763 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,encode)); 3764 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 3765 Pattern->AddPlaceholderChunk("type-name"); 3766 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 3767 Results.AddResult(Result(Pattern)); 3768 3769 // @protocol ( protocol-name ) 3770 Pattern = new CodeCompletionString; 3771 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,protocol)); 3772 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 3773 Pattern->AddPlaceholderChunk("protocol-name"); 3774 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 3775 Results.AddResult(Result(Pattern)); 3776 3777 // @selector ( selector ) 3778 Pattern = new CodeCompletionString; 3779 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,selector)); 3780 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 3781 Pattern->AddPlaceholderChunk("selector"); 3782 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 3783 Results.AddResult(Result(Pattern)); 3784} 3785 3786static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) { 3787 typedef CodeCompletionResult Result; 3788 CodeCompletionString *Pattern = 0; 3789 3790 if (Results.includeCodePatterns()) { 3791 // @try { statements } @catch ( declaration ) { statements } @finally 3792 // { statements } 3793 Pattern = new CodeCompletionString; 3794 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,try)); 3795 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 3796 Pattern->AddPlaceholderChunk("statements"); 3797 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 3798 Pattern->AddTextChunk("@catch"); 3799 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 3800 Pattern->AddPlaceholderChunk("parameter"); 3801 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 3802 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 3803 Pattern->AddPlaceholderChunk("statements"); 3804 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 3805 Pattern->AddTextChunk("@finally"); 3806 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 3807 Pattern->AddPlaceholderChunk("statements"); 3808 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 3809 Results.AddResult(Result(Pattern)); 3810 } 3811 3812 // @throw 3813 Pattern = new CodeCompletionString; 3814 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,throw)); 3815 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 3816 Pattern->AddPlaceholderChunk("expression"); 3817 Results.AddResult(Result(Pattern)); 3818 3819 if (Results.includeCodePatterns()) { 3820 // @synchronized ( expression ) { statements } 3821 Pattern = new CodeCompletionString; 3822 Pattern->AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt,synchronized)); 3823 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 3824 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 3825 Pattern->AddPlaceholderChunk("expression"); 3826 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 3827 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 3828 Pattern->AddPlaceholderChunk("statements"); 3829 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 3830 Results.AddResult(Result(Pattern)); 3831 } 3832} 3833 3834static void AddObjCVisibilityResults(const LangOptions &LangOpts, 3835 ResultBuilder &Results, 3836 bool NeedAt) { 3837 typedef CodeCompletionResult Result; 3838 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,private))); 3839 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,protected))); 3840 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,public))); 3841 if (LangOpts.ObjC2) 3842 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt,package))); 3843} 3844 3845void Sema::CodeCompleteObjCAtVisibility(Scope *S) { 3846 ResultBuilder Results(*this, CodeCompletionContext::CCC_Other); 3847 Results.EnterNewScope(); 3848 AddObjCVisibilityResults(getLangOptions(), Results, false); 3849 Results.ExitScope(); 3850 HandleCodeCompleteResults(this, CodeCompleter, 3851 CodeCompletionContext::CCC_Other, 3852 Results.data(),Results.size()); 3853} 3854 3855void Sema::CodeCompleteObjCAtStatement(Scope *S) { 3856 ResultBuilder Results(*this, CodeCompletionContext::CCC_Other); 3857 Results.EnterNewScope(); 3858 AddObjCStatementResults(Results, false); 3859 AddObjCExpressionResults(Results, false); 3860 Results.ExitScope(); 3861 HandleCodeCompleteResults(this, CodeCompleter, 3862 CodeCompletionContext::CCC_Other, 3863 Results.data(),Results.size()); 3864} 3865 3866void Sema::CodeCompleteObjCAtExpression(Scope *S) { 3867 ResultBuilder Results(*this, CodeCompletionContext::CCC_Other); 3868 Results.EnterNewScope(); 3869 AddObjCExpressionResults(Results, false); 3870 Results.ExitScope(); 3871 HandleCodeCompleteResults(this, CodeCompleter, 3872 CodeCompletionContext::CCC_Other, 3873 Results.data(),Results.size()); 3874} 3875 3876/// \brief Determine whether the addition of the given flag to an Objective-C 3877/// property's attributes will cause a conflict. 3878static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) { 3879 // Check if we've already added this flag. 3880 if (Attributes & NewFlag) 3881 return true; 3882 3883 Attributes |= NewFlag; 3884 3885 // Check for collisions with "readonly". 3886 if ((Attributes & ObjCDeclSpec::DQ_PR_readonly) && 3887 (Attributes & (ObjCDeclSpec::DQ_PR_readwrite | 3888 ObjCDeclSpec::DQ_PR_assign | 3889 ObjCDeclSpec::DQ_PR_copy | 3890 ObjCDeclSpec::DQ_PR_retain))) 3891 return true; 3892 3893 // Check for more than one of { assign, copy, retain }. 3894 unsigned AssignCopyRetMask = Attributes & (ObjCDeclSpec::DQ_PR_assign | 3895 ObjCDeclSpec::DQ_PR_copy | 3896 ObjCDeclSpec::DQ_PR_retain); 3897 if (AssignCopyRetMask && 3898 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_assign && 3899 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_copy && 3900 AssignCopyRetMask != ObjCDeclSpec::DQ_PR_retain) 3901 return true; 3902 3903 return false; 3904} 3905 3906void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) { 3907 if (!CodeCompleter) 3908 return; 3909 3910 unsigned Attributes = ODS.getPropertyAttributes(); 3911 3912 typedef CodeCompletionResult Result; 3913 ResultBuilder Results(*this, CodeCompletionContext::CCC_Other); 3914 Results.EnterNewScope(); 3915 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readonly)) 3916 Results.AddResult(CodeCompletionResult("readonly")); 3917 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_assign)) 3918 Results.AddResult(CodeCompletionResult("assign")); 3919 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_readwrite)) 3920 Results.AddResult(CodeCompletionResult("readwrite")); 3921 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_retain)) 3922 Results.AddResult(CodeCompletionResult("retain")); 3923 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_copy)) 3924 Results.AddResult(CodeCompletionResult("copy")); 3925 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_nonatomic)) 3926 Results.AddResult(CodeCompletionResult("nonatomic")); 3927 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_setter)) { 3928 CodeCompletionString *Setter = new CodeCompletionString; 3929 Setter->AddTypedTextChunk("setter"); 3930 Setter->AddTextChunk(" = "); 3931 Setter->AddPlaceholderChunk("method"); 3932 Results.AddResult(CodeCompletionResult(Setter)); 3933 } 3934 if (!ObjCPropertyFlagConflicts(Attributes, ObjCDeclSpec::DQ_PR_getter)) { 3935 CodeCompletionString *Getter = new CodeCompletionString; 3936 Getter->AddTypedTextChunk("getter"); 3937 Getter->AddTextChunk(" = "); 3938 Getter->AddPlaceholderChunk("method"); 3939 Results.AddResult(CodeCompletionResult(Getter)); 3940 } 3941 Results.ExitScope(); 3942 HandleCodeCompleteResults(this, CodeCompleter, 3943 CodeCompletionContext::CCC_Other, 3944 Results.data(),Results.size()); 3945} 3946 3947/// \brief Descripts the kind of Objective-C method that we want to find 3948/// via code completion. 3949enum ObjCMethodKind { 3950 MK_Any, //< Any kind of method, provided it means other specified criteria. 3951 MK_ZeroArgSelector, //< Zero-argument (unary) selector. 3952 MK_OneArgSelector //< One-argument selector. 3953}; 3954 3955static bool isAcceptableObjCSelector(Selector Sel, 3956 ObjCMethodKind WantKind, 3957 IdentifierInfo **SelIdents, 3958 unsigned NumSelIdents) { 3959 if (NumSelIdents > Sel.getNumArgs()) 3960 return false; 3961 3962 switch (WantKind) { 3963 case MK_Any: break; 3964 case MK_ZeroArgSelector: return Sel.isUnarySelector(); 3965 case MK_OneArgSelector: return Sel.getNumArgs() == 1; 3966 } 3967 3968 for (unsigned I = 0; I != NumSelIdents; ++I) 3969 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I)) 3970 return false; 3971 3972 return true; 3973} 3974 3975static bool isAcceptableObjCMethod(ObjCMethodDecl *Method, 3976 ObjCMethodKind WantKind, 3977 IdentifierInfo **SelIdents, 3978 unsigned NumSelIdents) { 3979 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents, 3980 NumSelIdents); 3981} 3982 3983namespace { 3984 /// \brief A set of selectors, which is used to avoid introducing multiple 3985 /// completions with the same selector into the result set. 3986 typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet; 3987} 3988 3989/// \brief Add all of the Objective-C methods in the given Objective-C 3990/// container to the set of results. 3991/// 3992/// The container will be a class, protocol, category, or implementation of 3993/// any of the above. This mether will recurse to include methods from 3994/// the superclasses of classes along with their categories, protocols, and 3995/// implementations. 3996/// 3997/// \param Container the container in which we'll look to find methods. 3998/// 3999/// \param WantInstance whether to add instance methods (only); if false, this 4000/// routine will add factory methods (only). 4001/// 4002/// \param CurContext the context in which we're performing the lookup that 4003/// finds methods. 4004/// 4005/// \param Results the structure into which we'll add results. 4006static void AddObjCMethods(ObjCContainerDecl *Container, 4007 bool WantInstanceMethods, 4008 ObjCMethodKind WantKind, 4009 IdentifierInfo **SelIdents, 4010 unsigned NumSelIdents, 4011 DeclContext *CurContext, 4012 VisitedSelectorSet &Selectors, 4013 ResultBuilder &Results, 4014 bool InOriginalClass = true) { 4015 typedef CodeCompletionResult Result; 4016 for (ObjCContainerDecl::method_iterator M = Container->meth_begin(), 4017 MEnd = Container->meth_end(); 4018 M != MEnd; ++M) { 4019 if ((*M)->isInstanceMethod() == WantInstanceMethods) { 4020 // Check whether the selector identifiers we've been given are a 4021 // subset of the identifiers for this particular method. 4022 if (!isAcceptableObjCMethod(*M, WantKind, SelIdents, NumSelIdents)) 4023 continue; 4024 4025 if (!Selectors.insert((*M)->getSelector())) 4026 continue; 4027 4028 Result R = Result(*M, 0); 4029 R.StartParameter = NumSelIdents; 4030 R.AllParametersAreInformative = (WantKind != MK_Any); 4031 if (!InOriginalClass) 4032 R.Priority += CCD_InBaseClass; 4033 Results.MaybeAddResult(R, CurContext); 4034 } 4035 } 4036 4037 // Visit the protocols of protocols. 4038 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) { 4039 const ObjCList<ObjCProtocolDecl> &Protocols 4040 = Protocol->getReferencedProtocols(); 4041 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 4042 E = Protocols.end(); 4043 I != E; ++I) 4044 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, NumSelIdents, 4045 CurContext, Selectors, Results, false); 4046 } 4047 4048 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container); 4049 if (!IFace) 4050 return; 4051 4052 // Add methods in protocols. 4053 const ObjCList<ObjCProtocolDecl> &Protocols= IFace->getReferencedProtocols(); 4054 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 4055 E = Protocols.end(); 4056 I != E; ++I) 4057 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, NumSelIdents, 4058 CurContext, Selectors, Results, false); 4059 4060 // Add methods in categories. 4061 for (ObjCCategoryDecl *CatDecl = IFace->getCategoryList(); CatDecl; 4062 CatDecl = CatDecl->getNextClassCategory()) { 4063 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents, 4064 NumSelIdents, CurContext, Selectors, Results, 4065 InOriginalClass); 4066 4067 // Add a categories protocol methods. 4068 const ObjCList<ObjCProtocolDecl> &Protocols 4069 = CatDecl->getReferencedProtocols(); 4070 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 4071 E = Protocols.end(); 4072 I != E; ++I) 4073 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, 4074 NumSelIdents, CurContext, Selectors, Results, false); 4075 4076 // Add methods in category implementations. 4077 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation()) 4078 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, 4079 NumSelIdents, CurContext, Selectors, Results, 4080 InOriginalClass); 4081 } 4082 4083 // Add methods in superclass. 4084 if (IFace->getSuperClass()) 4085 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind, 4086 SelIdents, NumSelIdents, CurContext, Selectors, Results, 4087 false); 4088 4089 // Add methods in our implementation, if any. 4090 if (ObjCImplementationDecl *Impl = IFace->getImplementation()) 4091 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, 4092 NumSelIdents, CurContext, Selectors, Results, 4093 InOriginalClass); 4094} 4095 4096 4097void Sema::CodeCompleteObjCPropertyGetter(Scope *S, Decl *ClassDecl, 4098 Decl **Methods, 4099 unsigned NumMethods) { 4100 typedef CodeCompletionResult Result; 4101 4102 // Try to find the interface where getters might live. 4103 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(ClassDecl); 4104 if (!Class) { 4105 if (ObjCCategoryDecl *Category 4106 = dyn_cast_or_null<ObjCCategoryDecl>(ClassDecl)) 4107 Class = Category->getClassInterface(); 4108 4109 if (!Class) 4110 return; 4111 } 4112 4113 // Find all of the potential getters. 4114 ResultBuilder Results(*this, CodeCompletionContext::CCC_Other); 4115 Results.EnterNewScope(); 4116 4117 // FIXME: We need to do this because Objective-C methods don't get 4118 // pushed into DeclContexts early enough. Argh! 4119 for (unsigned I = 0; I != NumMethods; ++I) { 4120 if (ObjCMethodDecl *Method 4121 = dyn_cast_or_null<ObjCMethodDecl>(Methods[I])) 4122 if (Method->isInstanceMethod() && 4123 isAcceptableObjCMethod(Method, MK_ZeroArgSelector, 0, 0)) { 4124 Result R = Result(Method, 0); 4125 R.AllParametersAreInformative = true; 4126 Results.MaybeAddResult(R, CurContext); 4127 } 4128 } 4129 4130 VisitedSelectorSet Selectors; 4131 AddObjCMethods(Class, true, MK_ZeroArgSelector, 0, 0, CurContext, Selectors, 4132 Results); 4133 Results.ExitScope(); 4134 HandleCodeCompleteResults(this, CodeCompleter, 4135 CodeCompletionContext::CCC_Other, 4136 Results.data(),Results.size()); 4137} 4138 4139void Sema::CodeCompleteObjCPropertySetter(Scope *S, Decl *ObjCImplDecl, 4140 Decl **Methods, 4141 unsigned NumMethods) { 4142 typedef CodeCompletionResult Result; 4143 4144 // Try to find the interface where setters might live. 4145 ObjCInterfaceDecl *Class 4146 = dyn_cast_or_null<ObjCInterfaceDecl>(ObjCImplDecl); 4147 if (!Class) { 4148 if (ObjCCategoryDecl *Category 4149 = dyn_cast_or_null<ObjCCategoryDecl>(ObjCImplDecl)) 4150 Class = Category->getClassInterface(); 4151 4152 if (!Class) 4153 return; 4154 } 4155 4156 // Find all of the potential getters. 4157 ResultBuilder Results(*this, CodeCompletionContext::CCC_Other); 4158 Results.EnterNewScope(); 4159 4160 // FIXME: We need to do this because Objective-C methods don't get 4161 // pushed into DeclContexts early enough. Argh! 4162 for (unsigned I = 0; I != NumMethods; ++I) { 4163 if (ObjCMethodDecl *Method 4164 = dyn_cast_or_null<ObjCMethodDecl>(Methods[I])) 4165 if (Method->isInstanceMethod() && 4166 isAcceptableObjCMethod(Method, MK_OneArgSelector, 0, 0)) { 4167 Result R = Result(Method, 0); 4168 R.AllParametersAreInformative = true; 4169 Results.MaybeAddResult(R, CurContext); 4170 } 4171 } 4172 4173 VisitedSelectorSet Selectors; 4174 AddObjCMethods(Class, true, MK_OneArgSelector, 0, 0, CurContext, 4175 Selectors, Results); 4176 4177 Results.ExitScope(); 4178 HandleCodeCompleteResults(this, CodeCompleter, 4179 CodeCompletionContext::CCC_Other, 4180 Results.data(),Results.size()); 4181} 4182 4183void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS) { 4184 typedef CodeCompletionResult Result; 4185 ResultBuilder Results(*this, CodeCompletionContext::CCC_Type); 4186 Results.EnterNewScope(); 4187 4188 // Add context-sensitive, Objective-C parameter-passing keywords. 4189 bool AddedInOut = false; 4190 if ((DS.getObjCDeclQualifier() & 4191 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) { 4192 Results.AddResult("in"); 4193 Results.AddResult("inout"); 4194 AddedInOut = true; 4195 } 4196 if ((DS.getObjCDeclQualifier() & 4197 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) { 4198 Results.AddResult("out"); 4199 if (!AddedInOut) 4200 Results.AddResult("inout"); 4201 } 4202 if ((DS.getObjCDeclQualifier() & 4203 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref | 4204 ObjCDeclSpec::DQ_Oneway)) == 0) { 4205 Results.AddResult("bycopy"); 4206 Results.AddResult("byref"); 4207 Results.AddResult("oneway"); 4208 } 4209 4210 // Add various builtin type names and specifiers. 4211 AddOrdinaryNameResults(PCC_Type, S, *this, Results); 4212 Results.ExitScope(); 4213 4214 // Add the various type names 4215 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName); 4216 CodeCompletionDeclConsumer Consumer(Results, CurContext); 4217 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 4218 CodeCompleter->includeGlobals()); 4219 4220 if (CodeCompleter->includeMacros()) 4221 AddMacroResults(PP, Results); 4222 4223 HandleCodeCompleteResults(this, CodeCompleter, 4224 CodeCompletionContext::CCC_Type, 4225 Results.data(), Results.size()); 4226} 4227 4228/// \brief When we have an expression with type "id", we may assume 4229/// that it has some more-specific class type based on knowledge of 4230/// common uses of Objective-C. This routine returns that class type, 4231/// or NULL if no better result could be determined. 4232static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) { 4233 ObjCMessageExpr *Msg = dyn_cast_or_null<ObjCMessageExpr>(E); 4234 if (!Msg) 4235 return 0; 4236 4237 Selector Sel = Msg->getSelector(); 4238 if (Sel.isNull()) 4239 return 0; 4240 4241 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0); 4242 if (!Id) 4243 return 0; 4244 4245 ObjCMethodDecl *Method = Msg->getMethodDecl(); 4246 if (!Method) 4247 return 0; 4248 4249 // Determine the class that we're sending the message to. 4250 ObjCInterfaceDecl *IFace = 0; 4251 switch (Msg->getReceiverKind()) { 4252 case ObjCMessageExpr::Class: 4253 if (const ObjCObjectType *ObjType 4254 = Msg->getClassReceiver()->getAs<ObjCObjectType>()) 4255 IFace = ObjType->getInterface(); 4256 break; 4257 4258 case ObjCMessageExpr::Instance: { 4259 QualType T = Msg->getInstanceReceiver()->getType(); 4260 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>()) 4261 IFace = Ptr->getInterfaceDecl(); 4262 break; 4263 } 4264 4265 case ObjCMessageExpr::SuperInstance: 4266 case ObjCMessageExpr::SuperClass: 4267 break; 4268 } 4269 4270 if (!IFace) 4271 return 0; 4272 4273 ObjCInterfaceDecl *Super = IFace->getSuperClass(); 4274 if (Method->isInstanceMethod()) 4275 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName()) 4276 .Case("retain", IFace) 4277 .Case("autorelease", IFace) 4278 .Case("copy", IFace) 4279 .Case("copyWithZone", IFace) 4280 .Case("mutableCopy", IFace) 4281 .Case("mutableCopyWithZone", IFace) 4282 .Case("awakeFromCoder", IFace) 4283 .Case("replacementObjectFromCoder", IFace) 4284 .Case("class", IFace) 4285 .Case("classForCoder", IFace) 4286 .Case("superclass", Super) 4287 .Default(0); 4288 4289 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName()) 4290 .Case("new", IFace) 4291 .Case("alloc", IFace) 4292 .Case("allocWithZone", IFace) 4293 .Case("class", IFace) 4294 .Case("superclass", Super) 4295 .Default(0); 4296} 4297 4298// Add a special completion for a message send to "super", which fills in the 4299// most likely case of forwarding all of our arguments to the superclass 4300// function. 4301/// 4302/// \param S The semantic analysis object. 4303/// 4304/// \param S NeedSuperKeyword Whether we need to prefix this completion with 4305/// the "super" keyword. Otherwise, we just need to provide the arguments. 4306/// 4307/// \param SelIdents The identifiers in the selector that have already been 4308/// provided as arguments for a send to "super". 4309/// 4310/// \param NumSelIdents The number of identifiers in \p SelIdents. 4311/// 4312/// \param Results The set of results to augment. 4313/// 4314/// \returns the Objective-C method declaration that would be invoked by 4315/// this "super" completion. If NULL, no completion was added. 4316static ObjCMethodDecl *AddSuperSendCompletion(Sema &S, bool NeedSuperKeyword, 4317 IdentifierInfo **SelIdents, 4318 unsigned NumSelIdents, 4319 ResultBuilder &Results) { 4320 ObjCMethodDecl *CurMethod = S.getCurMethodDecl(); 4321 if (!CurMethod) 4322 return 0; 4323 4324 ObjCInterfaceDecl *Class = CurMethod->getClassInterface(); 4325 if (!Class) 4326 return 0; 4327 4328 // Try to find a superclass method with the same selector. 4329 ObjCMethodDecl *SuperMethod = 0; 4330 while ((Class = Class->getSuperClass()) && !SuperMethod) 4331 SuperMethod = Class->getMethod(CurMethod->getSelector(), 4332 CurMethod->isInstanceMethod()); 4333 4334 if (!SuperMethod) 4335 return 0; 4336 4337 // Check whether the superclass method has the same signature. 4338 if (CurMethod->param_size() != SuperMethod->param_size() || 4339 CurMethod->isVariadic() != SuperMethod->isVariadic()) 4340 return 0; 4341 4342 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(), 4343 CurPEnd = CurMethod->param_end(), 4344 SuperP = SuperMethod->param_begin(); 4345 CurP != CurPEnd; ++CurP, ++SuperP) { 4346 // Make sure the parameter types are compatible. 4347 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(), 4348 (*SuperP)->getType())) 4349 return 0; 4350 4351 // Make sure we have a parameter name to forward! 4352 if (!(*CurP)->getIdentifier()) 4353 return 0; 4354 } 4355 4356 // We have a superclass method. Now, form the send-to-super completion. 4357 CodeCompletionString *Pattern = new CodeCompletionString; 4358 4359 // Give this completion a return type. 4360 AddResultTypeChunk(S.Context, SuperMethod, Pattern); 4361 4362 // If we need the "super" keyword, add it (plus some spacing). 4363 if (NeedSuperKeyword) { 4364 Pattern->AddTypedTextChunk("super"); 4365 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 4366 } 4367 4368 Selector Sel = CurMethod->getSelector(); 4369 if (Sel.isUnarySelector()) { 4370 if (NeedSuperKeyword) 4371 Pattern->AddTextChunk(Sel.getIdentifierInfoForSlot(0)->getName()); 4372 else 4373 Pattern->AddTypedTextChunk(Sel.getIdentifierInfoForSlot(0)->getName()); 4374 } else { 4375 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(); 4376 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) { 4377 if (I > NumSelIdents) 4378 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 4379 4380 if (I < NumSelIdents) 4381 Pattern->AddInformativeChunk( 4382 Sel.getIdentifierInfoForSlot(I)->getName().str() + ":"); 4383 else if (NeedSuperKeyword || I > NumSelIdents) { 4384 Pattern->AddTextChunk( 4385 Sel.getIdentifierInfoForSlot(I)->getName().str() + ":"); 4386 Pattern->AddPlaceholderChunk((*CurP)->getIdentifier()->getName()); 4387 } else { 4388 Pattern->AddTypedTextChunk( 4389 Sel.getIdentifierInfoForSlot(I)->getName().str() + ":"); 4390 Pattern->AddPlaceholderChunk((*CurP)->getIdentifier()->getName()); 4391 } 4392 } 4393 } 4394 4395 Results.AddResult(CodeCompletionResult(Pattern, CCP_SuperCompletion, 4396 SuperMethod->isInstanceMethod() 4397 ? CXCursor_ObjCInstanceMethodDecl 4398 : CXCursor_ObjCClassMethodDecl)); 4399 return SuperMethod; 4400} 4401 4402void Sema::CodeCompleteObjCMessageReceiver(Scope *S) { 4403 typedef CodeCompletionResult Result; 4404 ResultBuilder Results(*this, CodeCompletionContext::CCC_ObjCMessageReceiver, 4405 &ResultBuilder::IsObjCMessageReceiver); 4406 4407 CodeCompletionDeclConsumer Consumer(Results, CurContext); 4408 Results.EnterNewScope(); 4409 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 4410 CodeCompleter->includeGlobals()); 4411 4412 // If we are in an Objective-C method inside a class that has a superclass, 4413 // add "super" as an option. 4414 if (ObjCMethodDecl *Method = getCurMethodDecl()) 4415 if (ObjCInterfaceDecl *Iface = Method->getClassInterface()) 4416 if (Iface->getSuperClass()) { 4417 Results.AddResult(Result("super")); 4418 4419 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, 0, 0, Results); 4420 } 4421 4422 Results.ExitScope(); 4423 4424 if (CodeCompleter->includeMacros()) 4425 AddMacroResults(PP, Results); 4426 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 4427 Results.data(), Results.size()); 4428 4429} 4430 4431void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc, 4432 IdentifierInfo **SelIdents, 4433 unsigned NumSelIdents, 4434 bool AtArgumentExpression) { 4435 ObjCInterfaceDecl *CDecl = 0; 4436 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) { 4437 // Figure out which interface we're in. 4438 CDecl = CurMethod->getClassInterface(); 4439 if (!CDecl) 4440 return; 4441 4442 // Find the superclass of this class. 4443 CDecl = CDecl->getSuperClass(); 4444 if (!CDecl) 4445 return; 4446 4447 if (CurMethod->isInstanceMethod()) { 4448 // We are inside an instance method, which means that the message 4449 // send [super ...] is actually calling an instance method on the 4450 // current object. Build the super expression and handle this like 4451 // an instance method. 4452 QualType SuperTy = Context.getObjCInterfaceType(CDecl); 4453 SuperTy = Context.getObjCObjectPointerType(SuperTy); 4454 ExprResult Super 4455 = Owned(new (Context) ObjCSuperExpr(SuperLoc, SuperTy)); 4456 return CodeCompleteObjCInstanceMessage(S, (Expr *)Super.get(), 4457 SelIdents, NumSelIdents, 4458 AtArgumentExpression, 4459 /*IsSuper=*/true); 4460 } 4461 4462 // Fall through to send to the superclass in CDecl. 4463 } else { 4464 // "super" may be the name of a type or variable. Figure out which 4465 // it is. 4466 IdentifierInfo *Super = &Context.Idents.get("super"); 4467 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc, 4468 LookupOrdinaryName); 4469 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) { 4470 // "super" names an interface. Use it. 4471 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) { 4472 if (const ObjCObjectType *Iface 4473 = Context.getTypeDeclType(TD)->getAs<ObjCObjectType>()) 4474 CDecl = Iface->getInterface(); 4475 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) { 4476 // "super" names an unresolved type; we can't be more specific. 4477 } else { 4478 // Assume that "super" names some kind of value and parse that way. 4479 CXXScopeSpec SS; 4480 UnqualifiedId id; 4481 id.setIdentifier(Super, SuperLoc); 4482 ExprResult SuperExpr = ActOnIdExpression(S, SS, id, false, false); 4483 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(), 4484 SelIdents, NumSelIdents, 4485 AtArgumentExpression); 4486 } 4487 4488 // Fall through 4489 } 4490 4491 ParsedType Receiver; 4492 if (CDecl) 4493 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl)); 4494 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents, 4495 NumSelIdents, AtArgumentExpression, 4496 /*IsSuper=*/true); 4497} 4498 4499/// \brief Given a set of code-completion results for the argument of a message 4500/// send, determine the preferred type (if any) for that argument expression. 4501static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results, 4502 unsigned NumSelIdents) { 4503 typedef CodeCompletionResult Result; 4504 ASTContext &Context = Results.getSema().Context; 4505 4506 QualType PreferredType; 4507 unsigned BestPriority = CCP_Unlikely * 2; 4508 Result *ResultsData = Results.data(); 4509 for (unsigned I = 0, N = Results.size(); I != N; ++I) { 4510 Result &R = ResultsData[I]; 4511 if (R.Kind == Result::RK_Declaration && 4512 isa<ObjCMethodDecl>(R.Declaration)) { 4513 if (R.Priority <= BestPriority) { 4514 ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration); 4515 if (NumSelIdents <= Method->param_size()) { 4516 QualType MyPreferredType = Method->param_begin()[NumSelIdents - 1] 4517 ->getType(); 4518 if (R.Priority < BestPriority || PreferredType.isNull()) { 4519 BestPriority = R.Priority; 4520 PreferredType = MyPreferredType; 4521 } else if (!Context.hasSameUnqualifiedType(PreferredType, 4522 MyPreferredType)) { 4523 PreferredType = QualType(); 4524 } 4525 } 4526 } 4527 } 4528 } 4529 4530 return PreferredType; 4531} 4532 4533static void AddClassMessageCompletions(Sema &SemaRef, Scope *S, 4534 ParsedType Receiver, 4535 IdentifierInfo **SelIdents, 4536 unsigned NumSelIdents, 4537 bool AtArgumentExpression, 4538 bool IsSuper, 4539 ResultBuilder &Results) { 4540 typedef CodeCompletionResult Result; 4541 ObjCInterfaceDecl *CDecl = 0; 4542 4543 // If the given name refers to an interface type, retrieve the 4544 // corresponding declaration. 4545 if (Receiver) { 4546 QualType T = SemaRef.GetTypeFromParser(Receiver, 0); 4547 if (!T.isNull()) 4548 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>()) 4549 CDecl = Interface->getInterface(); 4550 } 4551 4552 // Add all of the factory methods in this Objective-C class, its protocols, 4553 // superclasses, categories, implementation, etc. 4554 Results.EnterNewScope(); 4555 4556 // If this is a send-to-super, try to add the special "super" send 4557 // completion. 4558 if (IsSuper) { 4559 if (ObjCMethodDecl *SuperMethod 4560 = AddSuperSendCompletion(SemaRef, false, SelIdents, NumSelIdents, 4561 Results)) 4562 Results.Ignore(SuperMethod); 4563 } 4564 4565 // If we're inside an Objective-C method definition, prefer its selector to 4566 // others. 4567 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl()) 4568 Results.setPreferredSelector(CurMethod->getSelector()); 4569 4570 VisitedSelectorSet Selectors; 4571 if (CDecl) 4572 AddObjCMethods(CDecl, false, MK_Any, SelIdents, NumSelIdents, 4573 SemaRef.CurContext, Selectors, Results); 4574 else { 4575 // We're messaging "id" as a type; provide all class/factory methods. 4576 4577 // If we have an external source, load the entire class method 4578 // pool from the AST file. 4579 if (SemaRef.ExternalSource) { 4580 for (uint32_t I = 0, 4581 N = SemaRef.ExternalSource->GetNumExternalSelectors(); 4582 I != N; ++I) { 4583 Selector Sel = SemaRef.ExternalSource->GetExternalSelector(I); 4584 if (Sel.isNull() || SemaRef.MethodPool.count(Sel)) 4585 continue; 4586 4587 SemaRef.ReadMethodPool(Sel); 4588 } 4589 } 4590 4591 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(), 4592 MEnd = SemaRef.MethodPool.end(); 4593 M != MEnd; ++M) { 4594 for (ObjCMethodList *MethList = &M->second.second; 4595 MethList && MethList->Method; 4596 MethList = MethList->Next) { 4597 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents, 4598 NumSelIdents)) 4599 continue; 4600 4601 Result R(MethList->Method, 0); 4602 R.StartParameter = NumSelIdents; 4603 R.AllParametersAreInformative = false; 4604 Results.MaybeAddResult(R, SemaRef.CurContext); 4605 } 4606 } 4607 } 4608 4609 Results.ExitScope(); 4610} 4611 4612void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver, 4613 IdentifierInfo **SelIdents, 4614 unsigned NumSelIdents, 4615 bool AtArgumentExpression, 4616 bool IsSuper) { 4617 ResultBuilder Results(*this, CodeCompletionContext::CCC_Other); 4618 AddClassMessageCompletions(*this, S, Receiver, SelIdents, NumSelIdents, 4619 AtArgumentExpression, IsSuper, Results); 4620 4621 // If we're actually at the argument expression (rather than prior to the 4622 // selector), we're actually performing code completion for an expression. 4623 // Determine whether we have a single, best method. If so, we can 4624 // code-complete the expression using the corresponding parameter type as 4625 // our preferred type, improving completion results. 4626 if (AtArgumentExpression) { 4627 QualType PreferredType = getPreferredArgumentTypeForMessageSend(Results, 4628 NumSelIdents); 4629 if (PreferredType.isNull()) 4630 CodeCompleteOrdinaryName(S, PCC_Expression); 4631 else 4632 CodeCompleteExpression(S, PreferredType); 4633 return; 4634 } 4635 4636 HandleCodeCompleteResults(this, CodeCompleter, 4637 CodeCompletionContext::CCC_Other, 4638 Results.data(), Results.size()); 4639} 4640 4641void Sema::CodeCompleteObjCInstanceMessage(Scope *S, ExprTy *Receiver, 4642 IdentifierInfo **SelIdents, 4643 unsigned NumSelIdents, 4644 bool AtArgumentExpression, 4645 bool IsSuper) { 4646 typedef CodeCompletionResult Result; 4647 4648 Expr *RecExpr = static_cast<Expr *>(Receiver); 4649 4650 // If necessary, apply function/array conversion to the receiver. 4651 // C99 6.7.5.3p[7,8]. 4652 if (RecExpr) 4653 DefaultFunctionArrayLvalueConversion(RecExpr); 4654 QualType ReceiverType = RecExpr? RecExpr->getType() : 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 (IsSuper) { 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 bool IsInImplementation, 5160 KnownMethodsMap &KnownMethods, 5161 bool InOriginalClass = true) { 5162 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) { 5163 // Recurse into protocols. 5164 const ObjCList<ObjCProtocolDecl> &Protocols 5165 = IFace->getReferencedProtocols(); 5166 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 5167 E = Protocols.end(); 5168 I != E; ++I) 5169 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType, 5170 IsInImplementation, KnownMethods, 5171 InOriginalClass); 5172 5173 // If we're not in the implementation of a class, also visit the 5174 // superclass. 5175 if (!IsInImplementation && IFace->getSuperClass()) 5176 FindImplementableMethods(Context, IFace->getSuperClass(), 5177 WantInstanceMethods, ReturnType, 5178 IsInImplementation, KnownMethods, 5179 false); 5180 5181 // Add methods from any class extensions (but not from categories; 5182 // those should go into category implementations). 5183 for (const ObjCCategoryDecl *Cat = IFace->getFirstClassExtension(); Cat; 5184 Cat = Cat->getNextClassExtension()) 5185 FindImplementableMethods(Context, const_cast<ObjCCategoryDecl*>(Cat), 5186 WantInstanceMethods, ReturnType, 5187 IsInImplementation, KnownMethods, 5188 InOriginalClass); 5189 } 5190 5191 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) { 5192 // Recurse into protocols. 5193 const ObjCList<ObjCProtocolDecl> &Protocols 5194 = Category->getReferencedProtocols(); 5195 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 5196 E = Protocols.end(); 5197 I != E; ++I) 5198 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType, 5199 IsInImplementation, KnownMethods, 5200 InOriginalClass); 5201 } 5202 5203 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) { 5204 // Recurse into protocols. 5205 const ObjCList<ObjCProtocolDecl> &Protocols 5206 = Protocol->getReferencedProtocols(); 5207 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 5208 E = Protocols.end(); 5209 I != E; ++I) 5210 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType, 5211 IsInImplementation, KnownMethods, false); 5212 } 5213 5214 // Add methods in this container. This operation occurs last because 5215 // we want the methods from this container to override any methods 5216 // we've previously seen with the same selector. 5217 for (ObjCContainerDecl::method_iterator M = Container->meth_begin(), 5218 MEnd = Container->meth_end(); 5219 M != MEnd; ++M) { 5220 if ((*M)->isInstanceMethod() == WantInstanceMethods) { 5221 if (!ReturnType.isNull() && 5222 !Context.hasSameUnqualifiedType(ReturnType, (*M)->getResultType())) 5223 continue; 5224 5225 KnownMethods[(*M)->getSelector()] = std::make_pair(*M, InOriginalClass); 5226 } 5227 } 5228} 5229 5230void Sema::CodeCompleteObjCMethodDecl(Scope *S, 5231 bool IsInstanceMethod, 5232 ParsedType ReturnTy, 5233 Decl *IDecl) { 5234 // Determine the return type of the method we're declaring, if 5235 // provided. 5236 QualType ReturnType = GetTypeFromParser(ReturnTy); 5237 5238 // Determine where we should start searching for methods, and where we 5239 ObjCContainerDecl *SearchDecl = 0, *CurrentDecl = 0; 5240 bool IsInImplementation = false; 5241 if (Decl *D = IDecl) { 5242 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) { 5243 SearchDecl = Impl->getClassInterface(); 5244 CurrentDecl = Impl; 5245 IsInImplementation = true; 5246 } else if (ObjCCategoryImplDecl *CatImpl 5247 = dyn_cast<ObjCCategoryImplDecl>(D)) { 5248 SearchDecl = CatImpl->getCategoryDecl(); 5249 CurrentDecl = CatImpl; 5250 IsInImplementation = true; 5251 } else { 5252 SearchDecl = dyn_cast<ObjCContainerDecl>(D); 5253 CurrentDecl = SearchDecl; 5254 } 5255 } 5256 5257 if (!SearchDecl && S) { 5258 if (DeclContext *DC = static_cast<DeclContext *>(S->getEntity())) { 5259 SearchDecl = dyn_cast<ObjCContainerDecl>(DC); 5260 CurrentDecl = SearchDecl; 5261 } 5262 } 5263 5264 if (!SearchDecl || !CurrentDecl) { 5265 HandleCodeCompleteResults(this, CodeCompleter, 5266 CodeCompletionContext::CCC_Other, 5267 0, 0); 5268 return; 5269 } 5270 5271 // Find all of the methods that we could declare/implement here. 5272 KnownMethodsMap KnownMethods; 5273 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod, 5274 ReturnType, IsInImplementation, KnownMethods); 5275 5276 // Erase any methods that have already been declared or 5277 // implemented here. 5278 for (ObjCContainerDecl::method_iterator M = CurrentDecl->meth_begin(), 5279 MEnd = CurrentDecl->meth_end(); 5280 M != MEnd; ++M) { 5281 if ((*M)->isInstanceMethod() != IsInstanceMethod) 5282 continue; 5283 5284 KnownMethodsMap::iterator Pos = KnownMethods.find((*M)->getSelector()); 5285 if (Pos != KnownMethods.end()) 5286 KnownMethods.erase(Pos); 5287 } 5288 5289 // Add declarations or definitions for each of the known methods. 5290 typedef CodeCompletionResult Result; 5291 ResultBuilder Results(*this, CodeCompletionContext::CCC_Other); 5292 Results.EnterNewScope(); 5293 PrintingPolicy Policy(Context.PrintingPolicy); 5294 Policy.AnonymousTagLocations = false; 5295 for (KnownMethodsMap::iterator M = KnownMethods.begin(), 5296 MEnd = KnownMethods.end(); 5297 M != MEnd; ++M) { 5298 ObjCMethodDecl *Method = M->second.first; 5299 CodeCompletionString *Pattern = new CodeCompletionString; 5300 5301 // If the result type was not already provided, add it to the 5302 // pattern as (type). 5303 if (ReturnType.isNull()) { 5304 std::string TypeStr; 5305 Method->getResultType().getAsStringInternal(TypeStr, Policy); 5306 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 5307 Pattern->AddTextChunk(TypeStr); 5308 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 5309 } 5310 5311 Selector Sel = Method->getSelector(); 5312 5313 // Add the first part of the selector to the pattern. 5314 Pattern->AddTypedTextChunk(Sel.getIdentifierInfoForSlot(0)->getName()); 5315 5316 // Add parameters to the pattern. 5317 unsigned I = 0; 5318 for (ObjCMethodDecl::param_iterator P = Method->param_begin(), 5319 PEnd = Method->param_end(); 5320 P != PEnd; (void)++P, ++I) { 5321 // Add the part of the selector name. 5322 if (I == 0) 5323 Pattern->AddChunk(CodeCompletionString::CK_Colon); 5324 else if (I < Sel.getNumArgs()) { 5325 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5326 Pattern->AddTextChunk(Sel.getIdentifierInfoForSlot(I)->getName()); 5327 Pattern->AddChunk(CodeCompletionString::CK_Colon); 5328 } else 5329 break; 5330 5331 // Add the parameter type. 5332 std::string TypeStr; 5333 (*P)->getOriginalType().getAsStringInternal(TypeStr, Policy); 5334 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 5335 Pattern->AddTextChunk(TypeStr); 5336 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 5337 5338 if (IdentifierInfo *Id = (*P)->getIdentifier()) 5339 Pattern->AddTextChunk(Id->getName()); 5340 } 5341 5342 if (Method->isVariadic()) { 5343 if (Method->param_size() > 0) 5344 Pattern->AddChunk(CodeCompletionString::CK_Comma); 5345 Pattern->AddTextChunk("..."); 5346 } 5347 5348 if (IsInImplementation && Results.includeCodePatterns()) { 5349 // We will be defining the method here, so add a compound statement. 5350 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5351 Pattern->AddChunk(CodeCompletionString::CK_LeftBrace); 5352 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 5353 if (!Method->getResultType()->isVoidType()) { 5354 // If the result type is not void, add a return clause. 5355 Pattern->AddTextChunk("return"); 5356 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5357 Pattern->AddPlaceholderChunk("expression"); 5358 Pattern->AddChunk(CodeCompletionString::CK_SemiColon); 5359 } else 5360 Pattern->AddPlaceholderChunk("statements"); 5361 5362 Pattern->AddChunk(CodeCompletionString::CK_VerticalSpace); 5363 Pattern->AddChunk(CodeCompletionString::CK_RightBrace); 5364 } 5365 5366 unsigned Priority = CCP_CodePattern; 5367 if (!M->second.second) 5368 Priority += CCD_InBaseClass; 5369 5370 Results.AddResult(Result(Pattern, Priority, 5371 Method->isInstanceMethod() 5372 ? CXCursor_ObjCInstanceMethodDecl 5373 : CXCursor_ObjCClassMethodDecl)); 5374 } 5375 5376 Results.ExitScope(); 5377 5378 HandleCodeCompleteResults(this, CodeCompleter, 5379 CodeCompletionContext::CCC_Other, 5380 Results.data(),Results.size()); 5381} 5382 5383void Sema::CodeCompleteObjCMethodDeclSelector(Scope *S, 5384 bool IsInstanceMethod, 5385 bool AtParameterName, 5386 ParsedType ReturnTy, 5387 IdentifierInfo **SelIdents, 5388 unsigned NumSelIdents) { 5389 // If we have an external source, load the entire class method 5390 // pool from the AST file. 5391 if (ExternalSource) { 5392 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors(); 5393 I != N; ++I) { 5394 Selector Sel = ExternalSource->GetExternalSelector(I); 5395 if (Sel.isNull() || MethodPool.count(Sel)) 5396 continue; 5397 5398 ReadMethodPool(Sel); 5399 } 5400 } 5401 5402 // Build the set of methods we can see. 5403 typedef CodeCompletionResult Result; 5404 ResultBuilder Results(*this, CodeCompletionContext::CCC_Other); 5405 5406 if (ReturnTy) 5407 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType()); 5408 5409 Results.EnterNewScope(); 5410 for (GlobalMethodPool::iterator M = MethodPool.begin(), 5411 MEnd = MethodPool.end(); 5412 M != MEnd; ++M) { 5413 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first : 5414 &M->second.second; 5415 MethList && MethList->Method; 5416 MethList = MethList->Next) { 5417 if (!isAcceptableObjCMethod(MethList->Method, MK_Any, SelIdents, 5418 NumSelIdents)) 5419 continue; 5420 5421 if (AtParameterName) { 5422 // Suggest parameter names we've seen before. 5423 if (NumSelIdents && NumSelIdents <= MethList->Method->param_size()) { 5424 ParmVarDecl *Param = MethList->Method->param_begin()[NumSelIdents-1]; 5425 if (Param->getIdentifier()) { 5426 CodeCompletionString *Pattern = new CodeCompletionString; 5427 Pattern->AddTypedTextChunk(Param->getIdentifier()->getName()); 5428 Results.AddResult(Pattern); 5429 } 5430 } 5431 5432 continue; 5433 } 5434 5435 Result R(MethList->Method, 0); 5436 R.StartParameter = NumSelIdents; 5437 R.AllParametersAreInformative = false; 5438 R.DeclaringEntity = true; 5439 Results.MaybeAddResult(R, CurContext); 5440 } 5441 } 5442 5443 Results.ExitScope(); 5444 HandleCodeCompleteResults(this, CodeCompleter, 5445 CodeCompletionContext::CCC_Other, 5446 Results.data(),Results.size()); 5447} 5448 5449void Sema::CodeCompletePreprocessorDirective(bool InConditional) { 5450 ResultBuilder Results(*this, 5451 CodeCompletionContext::CCC_PreprocessorDirective); 5452 Results.EnterNewScope(); 5453 5454 // #if <condition> 5455 CodeCompletionString *Pattern = new CodeCompletionString; 5456 Pattern->AddTypedTextChunk("if"); 5457 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5458 Pattern->AddPlaceholderChunk("condition"); 5459 Results.AddResult(Pattern); 5460 5461 // #ifdef <macro> 5462 Pattern = new CodeCompletionString; 5463 Pattern->AddTypedTextChunk("ifdef"); 5464 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5465 Pattern->AddPlaceholderChunk("macro"); 5466 Results.AddResult(Pattern); 5467 5468 // #ifndef <macro> 5469 Pattern = new CodeCompletionString; 5470 Pattern->AddTypedTextChunk("ifndef"); 5471 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5472 Pattern->AddPlaceholderChunk("macro"); 5473 Results.AddResult(Pattern); 5474 5475 if (InConditional) { 5476 // #elif <condition> 5477 Pattern = new CodeCompletionString; 5478 Pattern->AddTypedTextChunk("elif"); 5479 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5480 Pattern->AddPlaceholderChunk("condition"); 5481 Results.AddResult(Pattern); 5482 5483 // #else 5484 Pattern = new CodeCompletionString; 5485 Pattern->AddTypedTextChunk("else"); 5486 Results.AddResult(Pattern); 5487 5488 // #endif 5489 Pattern = new CodeCompletionString; 5490 Pattern->AddTypedTextChunk("endif"); 5491 Results.AddResult(Pattern); 5492 } 5493 5494 // #include "header" 5495 Pattern = new CodeCompletionString; 5496 Pattern->AddTypedTextChunk("include"); 5497 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5498 Pattern->AddTextChunk("\""); 5499 Pattern->AddPlaceholderChunk("header"); 5500 Pattern->AddTextChunk("\""); 5501 Results.AddResult(Pattern); 5502 5503 // #include <header> 5504 Pattern = new CodeCompletionString; 5505 Pattern->AddTypedTextChunk("include"); 5506 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5507 Pattern->AddTextChunk("<"); 5508 Pattern->AddPlaceholderChunk("header"); 5509 Pattern->AddTextChunk(">"); 5510 Results.AddResult(Pattern); 5511 5512 // #define <macro> 5513 Pattern = new CodeCompletionString; 5514 Pattern->AddTypedTextChunk("define"); 5515 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5516 Pattern->AddPlaceholderChunk("macro"); 5517 Results.AddResult(Pattern); 5518 5519 // #define <macro>(<args>) 5520 Pattern = new CodeCompletionString; 5521 Pattern->AddTypedTextChunk("define"); 5522 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5523 Pattern->AddPlaceholderChunk("macro"); 5524 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 5525 Pattern->AddPlaceholderChunk("args"); 5526 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 5527 Results.AddResult(Pattern); 5528 5529 // #undef <macro> 5530 Pattern = new CodeCompletionString; 5531 Pattern->AddTypedTextChunk("undef"); 5532 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5533 Pattern->AddPlaceholderChunk("macro"); 5534 Results.AddResult(Pattern); 5535 5536 // #line <number> 5537 Pattern = new CodeCompletionString; 5538 Pattern->AddTypedTextChunk("line"); 5539 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5540 Pattern->AddPlaceholderChunk("number"); 5541 Results.AddResult(Pattern); 5542 5543 // #line <number> "filename" 5544 Pattern = new CodeCompletionString; 5545 Pattern->AddTypedTextChunk("line"); 5546 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5547 Pattern->AddPlaceholderChunk("number"); 5548 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5549 Pattern->AddTextChunk("\""); 5550 Pattern->AddPlaceholderChunk("filename"); 5551 Pattern->AddTextChunk("\""); 5552 Results.AddResult(Pattern); 5553 5554 // #error <message> 5555 Pattern = new CodeCompletionString; 5556 Pattern->AddTypedTextChunk("error"); 5557 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5558 Pattern->AddPlaceholderChunk("message"); 5559 Results.AddResult(Pattern); 5560 5561 // #pragma <arguments> 5562 Pattern = new CodeCompletionString; 5563 Pattern->AddTypedTextChunk("pragma"); 5564 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5565 Pattern->AddPlaceholderChunk("arguments"); 5566 Results.AddResult(Pattern); 5567 5568 if (getLangOptions().ObjC1) { 5569 // #import "header" 5570 Pattern = new CodeCompletionString; 5571 Pattern->AddTypedTextChunk("import"); 5572 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5573 Pattern->AddTextChunk("\""); 5574 Pattern->AddPlaceholderChunk("header"); 5575 Pattern->AddTextChunk("\""); 5576 Results.AddResult(Pattern); 5577 5578 // #import <header> 5579 Pattern = new CodeCompletionString; 5580 Pattern->AddTypedTextChunk("import"); 5581 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5582 Pattern->AddTextChunk("<"); 5583 Pattern->AddPlaceholderChunk("header"); 5584 Pattern->AddTextChunk(">"); 5585 Results.AddResult(Pattern); 5586 } 5587 5588 // #include_next "header" 5589 Pattern = new CodeCompletionString; 5590 Pattern->AddTypedTextChunk("include_next"); 5591 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5592 Pattern->AddTextChunk("\""); 5593 Pattern->AddPlaceholderChunk("header"); 5594 Pattern->AddTextChunk("\""); 5595 Results.AddResult(Pattern); 5596 5597 // #include_next <header> 5598 Pattern = new CodeCompletionString; 5599 Pattern->AddTypedTextChunk("include_next"); 5600 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5601 Pattern->AddTextChunk("<"); 5602 Pattern->AddPlaceholderChunk("header"); 5603 Pattern->AddTextChunk(">"); 5604 Results.AddResult(Pattern); 5605 5606 // #warning <message> 5607 Pattern = new CodeCompletionString; 5608 Pattern->AddTypedTextChunk("warning"); 5609 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5610 Pattern->AddPlaceholderChunk("message"); 5611 Results.AddResult(Pattern); 5612 5613 // Note: #ident and #sccs are such crazy anachronisms that we don't provide 5614 // completions for them. And __include_macros is a Clang-internal extension 5615 // that we don't want to encourage anyone to use. 5616 5617 // FIXME: we don't support #assert or #unassert, so don't suggest them. 5618 Results.ExitScope(); 5619 5620 HandleCodeCompleteResults(this, CodeCompleter, 5621 CodeCompletionContext::CCC_PreprocessorDirective, 5622 Results.data(), Results.size()); 5623} 5624 5625void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) { 5626 CodeCompleteOrdinaryName(S, 5627 S->getFnParent()? Sema::PCC_RecoveryInFunction 5628 : Sema::PCC_Namespace); 5629} 5630 5631void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) { 5632 ResultBuilder Results(*this, 5633 IsDefinition? CodeCompletionContext::CCC_MacroName 5634 : CodeCompletionContext::CCC_MacroNameUse); 5635 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) { 5636 // Add just the names of macros, not their arguments. 5637 Results.EnterNewScope(); 5638 for (Preprocessor::macro_iterator M = PP.macro_begin(), 5639 MEnd = PP.macro_end(); 5640 M != MEnd; ++M) { 5641 CodeCompletionString *Pattern = new CodeCompletionString; 5642 Pattern->AddTypedTextChunk(M->first->getName()); 5643 Results.AddResult(Pattern); 5644 } 5645 Results.ExitScope(); 5646 } else if (IsDefinition) { 5647 // FIXME: Can we detect when the user just wrote an include guard above? 5648 } 5649 5650 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 5651 Results.data(), Results.size()); 5652} 5653 5654void Sema::CodeCompletePreprocessorExpression() { 5655 ResultBuilder Results(*this, 5656 CodeCompletionContext::CCC_PreprocessorExpression); 5657 5658 if (!CodeCompleter || CodeCompleter->includeMacros()) 5659 AddMacroResults(PP, Results); 5660 5661 // defined (<macro>) 5662 Results.EnterNewScope(); 5663 CodeCompletionString *Pattern = new CodeCompletionString; 5664 Pattern->AddTypedTextChunk("defined"); 5665 Pattern->AddChunk(CodeCompletionString::CK_HorizontalSpace); 5666 Pattern->AddChunk(CodeCompletionString::CK_LeftParen); 5667 Pattern->AddPlaceholderChunk("macro"); 5668 Pattern->AddChunk(CodeCompletionString::CK_RightParen); 5669 Results.AddResult(Pattern); 5670 Results.ExitScope(); 5671 5672 HandleCodeCompleteResults(this, CodeCompleter, 5673 CodeCompletionContext::CCC_PreprocessorExpression, 5674 Results.data(), Results.size()); 5675} 5676 5677void Sema::CodeCompletePreprocessorMacroArgument(Scope *S, 5678 IdentifierInfo *Macro, 5679 MacroInfo *MacroInfo, 5680 unsigned Argument) { 5681 // FIXME: In the future, we could provide "overload" results, much like we 5682 // do for function calls. 5683 5684 CodeCompleteOrdinaryName(S, 5685 S->getFnParent()? Sema::PCC_RecoveryInFunction 5686 : Sema::PCC_Namespace); 5687} 5688 5689void Sema::CodeCompleteNaturalLanguage() { 5690 HandleCodeCompleteResults(this, CodeCompleter, 5691 CodeCompletionContext::CCC_NaturalLanguage, 5692 0, 0); 5693} 5694 5695void Sema::GatherGlobalCodeCompletions( 5696 llvm::SmallVectorImpl<CodeCompletionResult> &Results) { 5697 ResultBuilder Builder(*this, CodeCompletionContext::CCC_Recovery); 5698 5699 if (!CodeCompleter || CodeCompleter->includeGlobals()) { 5700 CodeCompletionDeclConsumer Consumer(Builder, 5701 Context.getTranslationUnitDecl()); 5702 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName, 5703 Consumer); 5704 } 5705 5706 if (!CodeCompleter || CodeCompleter->includeMacros()) 5707 AddMacroResults(PP, Builder); 5708 5709 Results.clear(); 5710 Results.insert(Results.end(), 5711 Builder.data(), Builder.data() + Builder.size()); 5712} 5713