1 //===---------------- SemaCodeComplete.cpp - Code Completion ----*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file defines the code-completion semantic actions. 10 // 11 //===----------------------------------------------------------------------===// 12 #include "clang/AST/ASTConcept.h" 13 #include "clang/AST/Decl.h" 14 #include "clang/AST/DeclBase.h" 15 #include "clang/AST/DeclCXX.h" 16 #include "clang/AST/DeclObjC.h" 17 #include "clang/AST/DeclTemplate.h" 18 #include "clang/AST/Expr.h" 19 #include "clang/AST/ExprCXX.h" 20 #include "clang/AST/ExprConcepts.h" 21 #include "clang/AST/ExprObjC.h" 22 #include "clang/AST/NestedNameSpecifier.h" 23 #include "clang/AST/QualTypeNames.h" 24 #include "clang/AST/RecursiveASTVisitor.h" 25 #include "clang/AST/Type.h" 26 #include "clang/Basic/AttributeCommonInfo.h" 27 #include "clang/Basic/CharInfo.h" 28 #include "clang/Basic/OperatorKinds.h" 29 #include "clang/Basic/Specifiers.h" 30 #include "clang/Lex/HeaderSearch.h" 31 #include "clang/Lex/MacroInfo.h" 32 #include "clang/Lex/Preprocessor.h" 33 #include "clang/Sema/CodeCompleteConsumer.h" 34 #include "clang/Sema/DeclSpec.h" 35 #include "clang/Sema/Designator.h" 36 #include "clang/Sema/Lookup.h" 37 #include "clang/Sema/Overload.h" 38 #include "clang/Sema/ParsedAttr.h" 39 #include "clang/Sema/ParsedTemplate.h" 40 #include "clang/Sema/Scope.h" 41 #include "clang/Sema/ScopeInfo.h" 42 #include "clang/Sema/Sema.h" 43 #include "clang/Sema/SemaInternal.h" 44 #include "llvm/ADT/ArrayRef.h" 45 #include "llvm/ADT/DenseSet.h" 46 #include "llvm/ADT/SmallBitVector.h" 47 #include "llvm/ADT/SmallPtrSet.h" 48 #include "llvm/ADT/SmallString.h" 49 #include "llvm/ADT/StringExtras.h" 50 #include "llvm/ADT/StringSwitch.h" 51 #include "llvm/ADT/Twine.h" 52 #include "llvm/ADT/iterator_range.h" 53 #include "llvm/Support/Casting.h" 54 #include "llvm/Support/Path.h" 55 #include "llvm/Support/raw_ostream.h" 56 #include <list> 57 #include <map> 58 #include <string> 59 #include <vector> 60 61 using namespace clang; 62 using namespace sema; 63 64 namespace { 65 /// A container of code-completion results. 66 class ResultBuilder { 67 public: 68 /// The type of a name-lookup filter, which can be provided to the 69 /// name-lookup routines to specify which declarations should be included in 70 /// the result set (when it returns true) and which declarations should be 71 /// filtered out (returns false). 72 typedef bool (ResultBuilder::*LookupFilter)(const NamedDecl *) const; 73 74 typedef CodeCompletionResult Result; 75 76 private: 77 /// The actual results we have found. 78 std::vector<Result> Results; 79 80 /// A record of all of the declarations we have found and placed 81 /// into the result set, used to ensure that no declaration ever gets into 82 /// the result set twice. 83 llvm::SmallPtrSet<const Decl *, 16> AllDeclsFound; 84 85 typedef std::pair<const NamedDecl *, unsigned> DeclIndexPair; 86 87 /// An entry in the shadow map, which is optimized to store 88 /// a single (declaration, index) mapping (the common case) but 89 /// can also store a list of (declaration, index) mappings. 90 class ShadowMapEntry { 91 typedef SmallVector<DeclIndexPair, 4> DeclIndexPairVector; 92 93 /// Contains either the solitary NamedDecl * or a vector 94 /// of (declaration, index) pairs. 95 llvm::PointerUnion<const NamedDecl *, DeclIndexPairVector *> DeclOrVector; 96 97 /// When the entry contains a single declaration, this is 98 /// the index associated with that entry. 99 unsigned SingleDeclIndex; 100 101 public: 102 ShadowMapEntry() : SingleDeclIndex(0) {} 103 ShadowMapEntry(const ShadowMapEntry &) = delete; 104 ShadowMapEntry(ShadowMapEntry &&Move) { *this = std::move(Move); } 105 ShadowMapEntry &operator=(const ShadowMapEntry &) = delete; 106 ShadowMapEntry &operator=(ShadowMapEntry &&Move) { 107 SingleDeclIndex = Move.SingleDeclIndex; 108 DeclOrVector = Move.DeclOrVector; 109 Move.DeclOrVector = nullptr; 110 return *this; 111 } 112 113 void Add(const NamedDecl *ND, unsigned Index) { 114 if (DeclOrVector.isNull()) { 115 // 0 - > 1 elements: just set the single element information. 116 DeclOrVector = ND; 117 SingleDeclIndex = Index; 118 return; 119 } 120 121 if (const NamedDecl *PrevND = 122 DeclOrVector.dyn_cast<const NamedDecl *>()) { 123 // 1 -> 2 elements: create the vector of results and push in the 124 // existing declaration. 125 DeclIndexPairVector *Vec = new DeclIndexPairVector; 126 Vec->push_back(DeclIndexPair(PrevND, SingleDeclIndex)); 127 DeclOrVector = Vec; 128 } 129 130 // Add the new element to the end of the vector. 131 DeclOrVector.get<DeclIndexPairVector *>()->push_back( 132 DeclIndexPair(ND, Index)); 133 } 134 135 ~ShadowMapEntry() { 136 if (DeclIndexPairVector *Vec = 137 DeclOrVector.dyn_cast<DeclIndexPairVector *>()) { 138 delete Vec; 139 DeclOrVector = ((NamedDecl *)nullptr); 140 } 141 } 142 143 // Iteration. 144 class iterator; 145 iterator begin() const; 146 iterator end() const; 147 }; 148 149 /// A mapping from declaration names to the declarations that have 150 /// this name within a particular scope and their index within the list of 151 /// results. 152 typedef llvm::DenseMap<DeclarationName, ShadowMapEntry> ShadowMap; 153 154 /// The semantic analysis object for which results are being 155 /// produced. 156 Sema &SemaRef; 157 158 /// The allocator used to allocate new code-completion strings. 159 CodeCompletionAllocator &Allocator; 160 161 CodeCompletionTUInfo &CCTUInfo; 162 163 /// If non-NULL, a filter function used to remove any code-completion 164 /// results that are not desirable. 165 LookupFilter Filter; 166 167 /// Whether we should allow declarations as 168 /// nested-name-specifiers that would otherwise be filtered out. 169 bool AllowNestedNameSpecifiers; 170 171 /// If set, the type that we would prefer our resulting value 172 /// declarations to have. 173 /// 174 /// Closely matching the preferred type gives a boost to a result's 175 /// priority. 176 CanQualType PreferredType; 177 178 /// A list of shadow maps, which is used to model name hiding at 179 /// different levels of, e.g., the inheritance hierarchy. 180 std::list<ShadowMap> ShadowMaps; 181 182 /// Overloaded C++ member functions found by SemaLookup. 183 /// Used to determine when one overload is dominated by another. 184 llvm::DenseMap<std::pair<DeclContext *, /*Name*/uintptr_t>, ShadowMapEntry> 185 OverloadMap; 186 187 /// If we're potentially referring to a C++ member function, the set 188 /// of qualifiers applied to the object type. 189 Qualifiers ObjectTypeQualifiers; 190 /// The kind of the object expression, for rvalue/lvalue overloads. 191 ExprValueKind ObjectKind; 192 193 /// Whether the \p ObjectTypeQualifiers field is active. 194 bool HasObjectTypeQualifiers; 195 196 /// The selector that we prefer. 197 Selector PreferredSelector; 198 199 /// The completion context in which we are gathering results. 200 CodeCompletionContext CompletionContext; 201 202 /// If we are in an instance method definition, the \@implementation 203 /// object. 204 ObjCImplementationDecl *ObjCImplementation; 205 206 void AdjustResultPriorityForDecl(Result &R); 207 208 void MaybeAddConstructorResults(Result R); 209 210 public: 211 explicit ResultBuilder(Sema &SemaRef, CodeCompletionAllocator &Allocator, 212 CodeCompletionTUInfo &CCTUInfo, 213 const CodeCompletionContext &CompletionContext, 214 LookupFilter Filter = nullptr) 215 : SemaRef(SemaRef), Allocator(Allocator), CCTUInfo(CCTUInfo), 216 Filter(Filter), AllowNestedNameSpecifiers(false), 217 HasObjectTypeQualifiers(false), CompletionContext(CompletionContext), 218 ObjCImplementation(nullptr) { 219 // If this is an Objective-C instance method definition, dig out the 220 // corresponding implementation. 221 switch (CompletionContext.getKind()) { 222 case CodeCompletionContext::CCC_Expression: 223 case CodeCompletionContext::CCC_ObjCMessageReceiver: 224 case CodeCompletionContext::CCC_ParenthesizedExpression: 225 case CodeCompletionContext::CCC_Statement: 226 case CodeCompletionContext::CCC_Recovery: 227 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) 228 if (Method->isInstanceMethod()) 229 if (ObjCInterfaceDecl *Interface = Method->getClassInterface()) 230 ObjCImplementation = Interface->getImplementation(); 231 break; 232 233 default: 234 break; 235 } 236 } 237 238 /// Determine the priority for a reference to the given declaration. 239 unsigned getBasePriority(const NamedDecl *D); 240 241 /// Whether we should include code patterns in the completion 242 /// results. 243 bool includeCodePatterns() const { 244 return SemaRef.CodeCompleter && 245 SemaRef.CodeCompleter->includeCodePatterns(); 246 } 247 248 /// Set the filter used for code-completion results. 249 void setFilter(LookupFilter Filter) { this->Filter = Filter; } 250 251 Result *data() { return Results.empty() ? nullptr : &Results.front(); } 252 unsigned size() const { return Results.size(); } 253 bool empty() const { return Results.empty(); } 254 255 /// Specify the preferred type. 256 void setPreferredType(QualType T) { 257 PreferredType = SemaRef.Context.getCanonicalType(T); 258 } 259 260 /// Set the cv-qualifiers on the object type, for us in filtering 261 /// calls to member functions. 262 /// 263 /// When there are qualifiers in this set, they will be used to filter 264 /// out member functions that aren't available (because there will be a 265 /// cv-qualifier mismatch) or prefer functions with an exact qualifier 266 /// match. 267 void setObjectTypeQualifiers(Qualifiers Quals, ExprValueKind Kind) { 268 ObjectTypeQualifiers = Quals; 269 ObjectKind = Kind; 270 HasObjectTypeQualifiers = true; 271 } 272 273 /// Set the preferred selector. 274 /// 275 /// When an Objective-C method declaration result is added, and that 276 /// method's selector matches this preferred selector, we give that method 277 /// a slight priority boost. 278 void setPreferredSelector(Selector Sel) { PreferredSelector = Sel; } 279 280 /// Retrieve the code-completion context for which results are 281 /// being collected. 282 const CodeCompletionContext &getCompletionContext() const { 283 return CompletionContext; 284 } 285 286 /// Specify whether nested-name-specifiers are allowed. 287 void allowNestedNameSpecifiers(bool Allow = true) { 288 AllowNestedNameSpecifiers = Allow; 289 } 290 291 /// Return the semantic analysis object for which we are collecting 292 /// code completion results. 293 Sema &getSema() const { return SemaRef; } 294 295 /// Retrieve the allocator used to allocate code completion strings. 296 CodeCompletionAllocator &getAllocator() const { return Allocator; } 297 298 CodeCompletionTUInfo &getCodeCompletionTUInfo() const { return CCTUInfo; } 299 300 /// Determine whether the given declaration is at all interesting 301 /// as a code-completion result. 302 /// 303 /// \param ND the declaration that we are inspecting. 304 /// 305 /// \param AsNestedNameSpecifier will be set true if this declaration is 306 /// only interesting when it is a nested-name-specifier. 307 bool isInterestingDecl(const NamedDecl *ND, 308 bool &AsNestedNameSpecifier) const; 309 310 /// Check whether the result is hidden by the Hiding declaration. 311 /// 312 /// \returns true if the result is hidden and cannot be found, false if 313 /// the hidden result could still be found. When false, \p R may be 314 /// modified to describe how the result can be found (e.g., via extra 315 /// qualification). 316 bool CheckHiddenResult(Result &R, DeclContext *CurContext, 317 const NamedDecl *Hiding); 318 319 /// Add a new result to this result set (if it isn't already in one 320 /// of the shadow maps), or replace an existing result (for, e.g., a 321 /// redeclaration). 322 /// 323 /// \param R the result to add (if it is unique). 324 /// 325 /// \param CurContext the context in which this result will be named. 326 void MaybeAddResult(Result R, DeclContext *CurContext = nullptr); 327 328 /// Add a new result to this result set, where we already know 329 /// the hiding declaration (if any). 330 /// 331 /// \param R the result to add (if it is unique). 332 /// 333 /// \param CurContext the context in which this result will be named. 334 /// 335 /// \param Hiding the declaration that hides the result. 336 /// 337 /// \param InBaseClass whether the result was found in a base 338 /// class of the searched context. 339 void AddResult(Result R, DeclContext *CurContext, NamedDecl *Hiding, 340 bool InBaseClass); 341 342 /// Add a new non-declaration result to this result set. 343 void AddResult(Result R); 344 345 /// Enter into a new scope. 346 void EnterNewScope(); 347 348 /// Exit from the current scope. 349 void ExitScope(); 350 351 /// Ignore this declaration, if it is seen again. 352 void Ignore(const Decl *D) { AllDeclsFound.insert(D->getCanonicalDecl()); } 353 354 /// Add a visited context. 355 void addVisitedContext(DeclContext *Ctx) { 356 CompletionContext.addVisitedContext(Ctx); 357 } 358 359 /// \name Name lookup predicates 360 /// 361 /// These predicates can be passed to the name lookup functions to filter the 362 /// results of name lookup. All of the predicates have the same type, so that 363 /// 364 //@{ 365 bool IsOrdinaryName(const NamedDecl *ND) const; 366 bool IsOrdinaryNonTypeName(const NamedDecl *ND) const; 367 bool IsIntegralConstantValue(const NamedDecl *ND) const; 368 bool IsOrdinaryNonValueName(const NamedDecl *ND) const; 369 bool IsNestedNameSpecifier(const NamedDecl *ND) const; 370 bool IsEnum(const NamedDecl *ND) const; 371 bool IsClassOrStruct(const NamedDecl *ND) const; 372 bool IsUnion(const NamedDecl *ND) const; 373 bool IsNamespace(const NamedDecl *ND) const; 374 bool IsNamespaceOrAlias(const NamedDecl *ND) const; 375 bool IsType(const NamedDecl *ND) const; 376 bool IsMember(const NamedDecl *ND) const; 377 bool IsObjCIvar(const NamedDecl *ND) const; 378 bool IsObjCMessageReceiver(const NamedDecl *ND) const; 379 bool IsObjCMessageReceiverOrLambdaCapture(const NamedDecl *ND) const; 380 bool IsObjCCollection(const NamedDecl *ND) const; 381 bool IsImpossibleToSatisfy(const NamedDecl *ND) const; 382 //@} 383 }; 384 } // namespace 385 386 void PreferredTypeBuilder::enterReturn(Sema &S, SourceLocation Tok) { 387 if (!Enabled) 388 return; 389 if (isa<BlockDecl>(S.CurContext)) { 390 if (sema::BlockScopeInfo *BSI = S.getCurBlock()) { 391 ComputeType = nullptr; 392 Type = BSI->ReturnType; 393 ExpectedLoc = Tok; 394 } 395 } else if (const auto *Function = dyn_cast<FunctionDecl>(S.CurContext)) { 396 ComputeType = nullptr; 397 Type = Function->getReturnType(); 398 ExpectedLoc = Tok; 399 } else if (const auto *Method = dyn_cast<ObjCMethodDecl>(S.CurContext)) { 400 ComputeType = nullptr; 401 Type = Method->getReturnType(); 402 ExpectedLoc = Tok; 403 } 404 } 405 406 void PreferredTypeBuilder::enterVariableInit(SourceLocation Tok, Decl *D) { 407 if (!Enabled) 408 return; 409 auto *VD = llvm::dyn_cast_or_null<ValueDecl>(D); 410 ComputeType = nullptr; 411 Type = VD ? VD->getType() : QualType(); 412 ExpectedLoc = Tok; 413 } 414 415 static QualType getDesignatedType(QualType BaseType, const Designation &Desig); 416 417 void PreferredTypeBuilder::enterDesignatedInitializer(SourceLocation Tok, 418 QualType BaseType, 419 const Designation &D) { 420 if (!Enabled) 421 return; 422 ComputeType = nullptr; 423 Type = getDesignatedType(BaseType, D); 424 ExpectedLoc = Tok; 425 } 426 427 void PreferredTypeBuilder::enterFunctionArgument( 428 SourceLocation Tok, llvm::function_ref<QualType()> ComputeType) { 429 if (!Enabled) 430 return; 431 this->ComputeType = ComputeType; 432 Type = QualType(); 433 ExpectedLoc = Tok; 434 } 435 436 void PreferredTypeBuilder::enterParenExpr(SourceLocation Tok, 437 SourceLocation LParLoc) { 438 if (!Enabled) 439 return; 440 // expected type for parenthesized expression does not change. 441 if (ExpectedLoc == LParLoc) 442 ExpectedLoc = Tok; 443 } 444 445 static QualType getPreferredTypeOfBinaryRHS(Sema &S, Expr *LHS, 446 tok::TokenKind Op) { 447 if (!LHS) 448 return QualType(); 449 450 QualType LHSType = LHS->getType(); 451 if (LHSType->isPointerType()) { 452 if (Op == tok::plus || Op == tok::plusequal || Op == tok::minusequal) 453 return S.getASTContext().getPointerDiffType(); 454 // Pointer difference is more common than subtracting an int from a pointer. 455 if (Op == tok::minus) 456 return LHSType; 457 } 458 459 switch (Op) { 460 // No way to infer the type of RHS from LHS. 461 case tok::comma: 462 return QualType(); 463 // Prefer the type of the left operand for all of these. 464 // Arithmetic operations. 465 case tok::plus: 466 case tok::plusequal: 467 case tok::minus: 468 case tok::minusequal: 469 case tok::percent: 470 case tok::percentequal: 471 case tok::slash: 472 case tok::slashequal: 473 case tok::star: 474 case tok::starequal: 475 // Assignment. 476 case tok::equal: 477 // Comparison operators. 478 case tok::equalequal: 479 case tok::exclaimequal: 480 case tok::less: 481 case tok::lessequal: 482 case tok::greater: 483 case tok::greaterequal: 484 case tok::spaceship: 485 return LHS->getType(); 486 // Binary shifts are often overloaded, so don't try to guess those. 487 case tok::greatergreater: 488 case tok::greatergreaterequal: 489 case tok::lessless: 490 case tok::lesslessequal: 491 if (LHSType->isIntegralOrEnumerationType()) 492 return S.getASTContext().IntTy; 493 return QualType(); 494 // Logical operators, assume we want bool. 495 case tok::ampamp: 496 case tok::pipepipe: 497 case tok::caretcaret: 498 return S.getASTContext().BoolTy; 499 // Operators often used for bit manipulation are typically used with the type 500 // of the left argument. 501 case tok::pipe: 502 case tok::pipeequal: 503 case tok::caret: 504 case tok::caretequal: 505 case tok::amp: 506 case tok::ampequal: 507 if (LHSType->isIntegralOrEnumerationType()) 508 return LHSType; 509 return QualType(); 510 // RHS should be a pointer to a member of the 'LHS' type, but we can't give 511 // any particular type here. 512 case tok::periodstar: 513 case tok::arrowstar: 514 return QualType(); 515 default: 516 // FIXME(ibiryukov): handle the missing op, re-add the assertion. 517 // assert(false && "unhandled binary op"); 518 return QualType(); 519 } 520 } 521 522 /// Get preferred type for an argument of an unary expression. \p ContextType is 523 /// preferred type of the whole unary expression. 524 static QualType getPreferredTypeOfUnaryArg(Sema &S, QualType ContextType, 525 tok::TokenKind Op) { 526 switch (Op) { 527 case tok::exclaim: 528 return S.getASTContext().BoolTy; 529 case tok::amp: 530 if (!ContextType.isNull() && ContextType->isPointerType()) 531 return ContextType->getPointeeType(); 532 return QualType(); 533 case tok::star: 534 if (ContextType.isNull()) 535 return QualType(); 536 return S.getASTContext().getPointerType(ContextType.getNonReferenceType()); 537 case tok::plus: 538 case tok::minus: 539 case tok::tilde: 540 case tok::minusminus: 541 case tok::plusplus: 542 if (ContextType.isNull()) 543 return S.getASTContext().IntTy; 544 // leave as is, these operators typically return the same type. 545 return ContextType; 546 case tok::kw___real: 547 case tok::kw___imag: 548 return QualType(); 549 default: 550 assert(false && "unhandled unary op"); 551 return QualType(); 552 } 553 } 554 555 void PreferredTypeBuilder::enterBinary(Sema &S, SourceLocation Tok, Expr *LHS, 556 tok::TokenKind Op) { 557 if (!Enabled) 558 return; 559 ComputeType = nullptr; 560 Type = getPreferredTypeOfBinaryRHS(S, LHS, Op); 561 ExpectedLoc = Tok; 562 } 563 564 void PreferredTypeBuilder::enterMemAccess(Sema &S, SourceLocation Tok, 565 Expr *Base) { 566 if (!Enabled || !Base) 567 return; 568 // Do we have expected type for Base? 569 if (ExpectedLoc != Base->getBeginLoc()) 570 return; 571 // Keep the expected type, only update the location. 572 ExpectedLoc = Tok; 573 } 574 575 void PreferredTypeBuilder::enterUnary(Sema &S, SourceLocation Tok, 576 tok::TokenKind OpKind, 577 SourceLocation OpLoc) { 578 if (!Enabled) 579 return; 580 ComputeType = nullptr; 581 Type = getPreferredTypeOfUnaryArg(S, this->get(OpLoc), OpKind); 582 ExpectedLoc = Tok; 583 } 584 585 void PreferredTypeBuilder::enterSubscript(Sema &S, SourceLocation Tok, 586 Expr *LHS) { 587 if (!Enabled) 588 return; 589 ComputeType = nullptr; 590 Type = S.getASTContext().IntTy; 591 ExpectedLoc = Tok; 592 } 593 594 void PreferredTypeBuilder::enterTypeCast(SourceLocation Tok, 595 QualType CastType) { 596 if (!Enabled) 597 return; 598 ComputeType = nullptr; 599 Type = !CastType.isNull() ? CastType.getCanonicalType() : QualType(); 600 ExpectedLoc = Tok; 601 } 602 603 void PreferredTypeBuilder::enterCondition(Sema &S, SourceLocation Tok) { 604 if (!Enabled) 605 return; 606 ComputeType = nullptr; 607 Type = S.getASTContext().BoolTy; 608 ExpectedLoc = Tok; 609 } 610 611 class ResultBuilder::ShadowMapEntry::iterator { 612 llvm::PointerUnion<const NamedDecl *, const DeclIndexPair *> DeclOrIterator; 613 unsigned SingleDeclIndex; 614 615 public: 616 typedef DeclIndexPair value_type; 617 typedef value_type reference; 618 typedef std::ptrdiff_t difference_type; 619 typedef std::input_iterator_tag iterator_category; 620 621 class pointer { 622 DeclIndexPair Value; 623 624 public: 625 pointer(const DeclIndexPair &Value) : Value(Value) {} 626 627 const DeclIndexPair *operator->() const { return &Value; } 628 }; 629 630 iterator() : DeclOrIterator((NamedDecl *)nullptr), SingleDeclIndex(0) {} 631 632 iterator(const NamedDecl *SingleDecl, unsigned Index) 633 : DeclOrIterator(SingleDecl), SingleDeclIndex(Index) {} 634 635 iterator(const DeclIndexPair *Iterator) 636 : DeclOrIterator(Iterator), SingleDeclIndex(0) {} 637 638 iterator &operator++() { 639 if (DeclOrIterator.is<const NamedDecl *>()) { 640 DeclOrIterator = (NamedDecl *)nullptr; 641 SingleDeclIndex = 0; 642 return *this; 643 } 644 645 const DeclIndexPair *I = DeclOrIterator.get<const DeclIndexPair *>(); 646 ++I; 647 DeclOrIterator = I; 648 return *this; 649 } 650 651 /*iterator operator++(int) { 652 iterator tmp(*this); 653 ++(*this); 654 return tmp; 655 }*/ 656 657 reference operator*() const { 658 if (const NamedDecl *ND = DeclOrIterator.dyn_cast<const NamedDecl *>()) 659 return reference(ND, SingleDeclIndex); 660 661 return *DeclOrIterator.get<const DeclIndexPair *>(); 662 } 663 664 pointer operator->() const { return pointer(**this); } 665 666 friend bool operator==(const iterator &X, const iterator &Y) { 667 return X.DeclOrIterator.getOpaqueValue() == 668 Y.DeclOrIterator.getOpaqueValue() && 669 X.SingleDeclIndex == Y.SingleDeclIndex; 670 } 671 672 friend bool operator!=(const iterator &X, const iterator &Y) { 673 return !(X == Y); 674 } 675 }; 676 677 ResultBuilder::ShadowMapEntry::iterator 678 ResultBuilder::ShadowMapEntry::begin() const { 679 if (DeclOrVector.isNull()) 680 return iterator(); 681 682 if (const NamedDecl *ND = DeclOrVector.dyn_cast<const NamedDecl *>()) 683 return iterator(ND, SingleDeclIndex); 684 685 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->begin()); 686 } 687 688 ResultBuilder::ShadowMapEntry::iterator 689 ResultBuilder::ShadowMapEntry::end() const { 690 if (DeclOrVector.is<const NamedDecl *>() || DeclOrVector.isNull()) 691 return iterator(); 692 693 return iterator(DeclOrVector.get<DeclIndexPairVector *>()->end()); 694 } 695 696 /// Compute the qualification required to get from the current context 697 /// (\p CurContext) to the target context (\p TargetContext). 698 /// 699 /// \param Context the AST context in which the qualification will be used. 700 /// 701 /// \param CurContext the context where an entity is being named, which is 702 /// typically based on the current scope. 703 /// 704 /// \param TargetContext the context in which the named entity actually 705 /// resides. 706 /// 707 /// \returns a nested name specifier that refers into the target context, or 708 /// NULL if no qualification is needed. 709 static NestedNameSpecifier * 710 getRequiredQualification(ASTContext &Context, const DeclContext *CurContext, 711 const DeclContext *TargetContext) { 712 SmallVector<const DeclContext *, 4> TargetParents; 713 714 for (const DeclContext *CommonAncestor = TargetContext; 715 CommonAncestor && !CommonAncestor->Encloses(CurContext); 716 CommonAncestor = CommonAncestor->getLookupParent()) { 717 if (CommonAncestor->isTransparentContext() || 718 CommonAncestor->isFunctionOrMethod()) 719 continue; 720 721 TargetParents.push_back(CommonAncestor); 722 } 723 724 NestedNameSpecifier *Result = nullptr; 725 while (!TargetParents.empty()) { 726 const DeclContext *Parent = TargetParents.pop_back_val(); 727 728 if (const auto *Namespace = dyn_cast<NamespaceDecl>(Parent)) { 729 if (!Namespace->getIdentifier()) 730 continue; 731 732 Result = NestedNameSpecifier::Create(Context, Result, Namespace); 733 } else if (const auto *TD = dyn_cast<TagDecl>(Parent)) 734 Result = NestedNameSpecifier::Create( 735 Context, Result, false, Context.getTypeDeclType(TD).getTypePtr()); 736 } 737 return Result; 738 } 739 740 // Some declarations have reserved names that we don't want to ever show. 741 // Filter out names reserved for the implementation if they come from a 742 // system header. 743 static bool shouldIgnoreDueToReservedName(const NamedDecl *ND, Sema &SemaRef) { 744 ReservedIdentifierStatus Status = ND->isReserved(SemaRef.getLangOpts()); 745 // Ignore reserved names for compiler provided decls. 746 if (isReservedInAllContexts(Status) && ND->getLocation().isInvalid()) 747 return true; 748 749 // For system headers ignore only double-underscore names. 750 // This allows for system headers providing private symbols with a single 751 // underscore. 752 if (Status == ReservedIdentifierStatus::StartsWithDoubleUnderscore && 753 SemaRef.SourceMgr.isInSystemHeader( 754 SemaRef.SourceMgr.getSpellingLoc(ND->getLocation()))) 755 return true; 756 757 return false; 758 } 759 760 bool ResultBuilder::isInterestingDecl(const NamedDecl *ND, 761 bool &AsNestedNameSpecifier) const { 762 AsNestedNameSpecifier = false; 763 764 auto *Named = ND; 765 ND = ND->getUnderlyingDecl(); 766 767 // Skip unnamed entities. 768 if (!ND->getDeclName()) 769 return false; 770 771 // Friend declarations and declarations introduced due to friends are never 772 // added as results. 773 if (ND->getFriendObjectKind() == Decl::FOK_Undeclared) 774 return false; 775 776 // Class template (partial) specializations are never added as results. 777 if (isa<ClassTemplateSpecializationDecl>(ND) || 778 isa<ClassTemplatePartialSpecializationDecl>(ND)) 779 return false; 780 781 // Using declarations themselves are never added as results. 782 if (isa<UsingDecl>(ND)) 783 return false; 784 785 if (shouldIgnoreDueToReservedName(ND, SemaRef)) 786 return false; 787 788 if (Filter == &ResultBuilder::IsNestedNameSpecifier || 789 (isa<NamespaceDecl>(ND) && Filter != &ResultBuilder::IsNamespace && 790 Filter != &ResultBuilder::IsNamespaceOrAlias && Filter != nullptr)) 791 AsNestedNameSpecifier = true; 792 793 // Filter out any unwanted results. 794 if (Filter && !(this->*Filter)(Named)) { 795 // Check whether it is interesting as a nested-name-specifier. 796 if (AllowNestedNameSpecifiers && SemaRef.getLangOpts().CPlusPlus && 797 IsNestedNameSpecifier(ND) && 798 (Filter != &ResultBuilder::IsMember || 799 (isa<CXXRecordDecl>(ND) && 800 cast<CXXRecordDecl>(ND)->isInjectedClassName()))) { 801 AsNestedNameSpecifier = true; 802 return true; 803 } 804 805 return false; 806 } 807 // ... then it must be interesting! 808 return true; 809 } 810 811 bool ResultBuilder::CheckHiddenResult(Result &R, DeclContext *CurContext, 812 const NamedDecl *Hiding) { 813 // In C, there is no way to refer to a hidden name. 814 // FIXME: This isn't true; we can find a tag name hidden by an ordinary 815 // name if we introduce the tag type. 816 if (!SemaRef.getLangOpts().CPlusPlus) 817 return true; 818 819 const DeclContext *HiddenCtx = 820 R.Declaration->getDeclContext()->getRedeclContext(); 821 822 // There is no way to qualify a name declared in a function or method. 823 if (HiddenCtx->isFunctionOrMethod()) 824 return true; 825 826 if (HiddenCtx == Hiding->getDeclContext()->getRedeclContext()) 827 return true; 828 829 // We can refer to the result with the appropriate qualification. Do it. 830 R.Hidden = true; 831 R.QualifierIsInformative = false; 832 833 if (!R.Qualifier) 834 R.Qualifier = getRequiredQualification(SemaRef.Context, CurContext, 835 R.Declaration->getDeclContext()); 836 return false; 837 } 838 839 /// A simplified classification of types used to determine whether two 840 /// types are "similar enough" when adjusting priorities. 841 SimplifiedTypeClass clang::getSimplifiedTypeClass(CanQualType T) { 842 switch (T->getTypeClass()) { 843 case Type::Builtin: 844 switch (cast<BuiltinType>(T)->getKind()) { 845 case BuiltinType::Void: 846 return STC_Void; 847 848 case BuiltinType::NullPtr: 849 return STC_Pointer; 850 851 case BuiltinType::Overload: 852 case BuiltinType::Dependent: 853 return STC_Other; 854 855 case BuiltinType::ObjCId: 856 case BuiltinType::ObjCClass: 857 case BuiltinType::ObjCSel: 858 return STC_ObjectiveC; 859 860 default: 861 return STC_Arithmetic; 862 } 863 864 case Type::Complex: 865 return STC_Arithmetic; 866 867 case Type::Pointer: 868 return STC_Pointer; 869 870 case Type::BlockPointer: 871 return STC_Block; 872 873 case Type::LValueReference: 874 case Type::RValueReference: 875 return getSimplifiedTypeClass(T->getAs<ReferenceType>()->getPointeeType()); 876 877 case Type::ConstantArray: 878 case Type::IncompleteArray: 879 case Type::VariableArray: 880 case Type::DependentSizedArray: 881 return STC_Array; 882 883 case Type::DependentSizedExtVector: 884 case Type::Vector: 885 case Type::ExtVector: 886 return STC_Arithmetic; 887 888 case Type::FunctionProto: 889 case Type::FunctionNoProto: 890 return STC_Function; 891 892 case Type::Record: 893 return STC_Record; 894 895 case Type::Enum: 896 return STC_Arithmetic; 897 898 case Type::ObjCObject: 899 case Type::ObjCInterface: 900 case Type::ObjCObjectPointer: 901 return STC_ObjectiveC; 902 903 default: 904 return STC_Other; 905 } 906 } 907 908 /// Get the type that a given expression will have if this declaration 909 /// is used as an expression in its "typical" code-completion form. 910 QualType clang::getDeclUsageType(ASTContext &C, const NamedDecl *ND) { 911 ND = ND->getUnderlyingDecl(); 912 913 if (const auto *Type = dyn_cast<TypeDecl>(ND)) 914 return C.getTypeDeclType(Type); 915 if (const auto *Iface = dyn_cast<ObjCInterfaceDecl>(ND)) 916 return C.getObjCInterfaceType(Iface); 917 918 QualType T; 919 if (const FunctionDecl *Function = ND->getAsFunction()) 920 T = Function->getCallResultType(); 921 else if (const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) 922 T = Method->getSendResultType(); 923 else if (const auto *Enumerator = dyn_cast<EnumConstantDecl>(ND)) 924 T = C.getTypeDeclType(cast<EnumDecl>(Enumerator->getDeclContext())); 925 else if (const auto *Property = dyn_cast<ObjCPropertyDecl>(ND)) 926 T = Property->getType(); 927 else if (const auto *Value = dyn_cast<ValueDecl>(ND)) 928 T = Value->getType(); 929 930 if (T.isNull()) 931 return QualType(); 932 933 // Dig through references, function pointers, and block pointers to 934 // get down to the likely type of an expression when the entity is 935 // used. 936 do { 937 if (const auto *Ref = T->getAs<ReferenceType>()) { 938 T = Ref->getPointeeType(); 939 continue; 940 } 941 942 if (const auto *Pointer = T->getAs<PointerType>()) { 943 if (Pointer->getPointeeType()->isFunctionType()) { 944 T = Pointer->getPointeeType(); 945 continue; 946 } 947 948 break; 949 } 950 951 if (const auto *Block = T->getAs<BlockPointerType>()) { 952 T = Block->getPointeeType(); 953 continue; 954 } 955 956 if (const auto *Function = T->getAs<FunctionType>()) { 957 T = Function->getReturnType(); 958 continue; 959 } 960 961 break; 962 } while (true); 963 964 return T; 965 } 966 967 unsigned ResultBuilder::getBasePriority(const NamedDecl *ND) { 968 if (!ND) 969 return CCP_Unlikely; 970 971 // Context-based decisions. 972 const DeclContext *LexicalDC = ND->getLexicalDeclContext(); 973 if (LexicalDC->isFunctionOrMethod()) { 974 // _cmd is relatively rare 975 if (const auto *ImplicitParam = dyn_cast<ImplicitParamDecl>(ND)) 976 if (ImplicitParam->getIdentifier() && 977 ImplicitParam->getIdentifier()->isStr("_cmd")) 978 return CCP_ObjC_cmd; 979 980 return CCP_LocalDeclaration; 981 } 982 983 const DeclContext *DC = ND->getDeclContext()->getRedeclContext(); 984 if (DC->isRecord() || isa<ObjCContainerDecl>(DC)) { 985 // Explicit destructor calls are very rare. 986 if (isa<CXXDestructorDecl>(ND)) 987 return CCP_Unlikely; 988 // Explicit operator and conversion function calls are also very rare. 989 auto DeclNameKind = ND->getDeclName().getNameKind(); 990 if (DeclNameKind == DeclarationName::CXXOperatorName || 991 DeclNameKind == DeclarationName::CXXLiteralOperatorName || 992 DeclNameKind == DeclarationName::CXXConversionFunctionName) 993 return CCP_Unlikely; 994 return CCP_MemberDeclaration; 995 } 996 997 // Content-based decisions. 998 if (isa<EnumConstantDecl>(ND)) 999 return CCP_Constant; 1000 1001 // Use CCP_Type for type declarations unless we're in a statement, Objective-C 1002 // message receiver, or parenthesized expression context. There, it's as 1003 // likely that the user will want to write a type as other declarations. 1004 if ((isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) && 1005 !(CompletionContext.getKind() == CodeCompletionContext::CCC_Statement || 1006 CompletionContext.getKind() == 1007 CodeCompletionContext::CCC_ObjCMessageReceiver || 1008 CompletionContext.getKind() == 1009 CodeCompletionContext::CCC_ParenthesizedExpression)) 1010 return CCP_Type; 1011 1012 return CCP_Declaration; 1013 } 1014 1015 void ResultBuilder::AdjustResultPriorityForDecl(Result &R) { 1016 // If this is an Objective-C method declaration whose selector matches our 1017 // preferred selector, give it a priority boost. 1018 if (!PreferredSelector.isNull()) 1019 if (const auto *Method = dyn_cast<ObjCMethodDecl>(R.Declaration)) 1020 if (PreferredSelector == Method->getSelector()) 1021 R.Priority += CCD_SelectorMatch; 1022 1023 // If we have a preferred type, adjust the priority for results with exactly- 1024 // matching or nearly-matching types. 1025 if (!PreferredType.isNull()) { 1026 QualType T = getDeclUsageType(SemaRef.Context, R.Declaration); 1027 if (!T.isNull()) { 1028 CanQualType TC = SemaRef.Context.getCanonicalType(T); 1029 // Check for exactly-matching types (modulo qualifiers). 1030 if (SemaRef.Context.hasSameUnqualifiedType(PreferredType, TC)) 1031 R.Priority /= CCF_ExactTypeMatch; 1032 // Check for nearly-matching types, based on classification of each. 1033 else if ((getSimplifiedTypeClass(PreferredType) == 1034 getSimplifiedTypeClass(TC)) && 1035 !(PreferredType->isEnumeralType() && TC->isEnumeralType())) 1036 R.Priority /= CCF_SimilarTypeMatch; 1037 } 1038 } 1039 } 1040 1041 static DeclContext::lookup_result getConstructors(ASTContext &Context, 1042 const CXXRecordDecl *Record) { 1043 QualType RecordTy = Context.getTypeDeclType(Record); 1044 DeclarationName ConstructorName = 1045 Context.DeclarationNames.getCXXConstructorName( 1046 Context.getCanonicalType(RecordTy)); 1047 return Record->lookup(ConstructorName); 1048 } 1049 1050 void ResultBuilder::MaybeAddConstructorResults(Result R) { 1051 if (!SemaRef.getLangOpts().CPlusPlus || !R.Declaration || 1052 !CompletionContext.wantConstructorResults()) 1053 return; 1054 1055 const NamedDecl *D = R.Declaration; 1056 const CXXRecordDecl *Record = nullptr; 1057 if (const ClassTemplateDecl *ClassTemplate = dyn_cast<ClassTemplateDecl>(D)) 1058 Record = ClassTemplate->getTemplatedDecl(); 1059 else if ((Record = dyn_cast<CXXRecordDecl>(D))) { 1060 // Skip specializations and partial specializations. 1061 if (isa<ClassTemplateSpecializationDecl>(Record)) 1062 return; 1063 } else { 1064 // There are no constructors here. 1065 return; 1066 } 1067 1068 Record = Record->getDefinition(); 1069 if (!Record) 1070 return; 1071 1072 for (NamedDecl *Ctor : getConstructors(SemaRef.Context, Record)) { 1073 R.Declaration = Ctor; 1074 R.CursorKind = getCursorKindForDecl(R.Declaration); 1075 Results.push_back(R); 1076 } 1077 } 1078 1079 static bool isConstructor(const Decl *ND) { 1080 if (const auto *Tmpl = dyn_cast<FunctionTemplateDecl>(ND)) 1081 ND = Tmpl->getTemplatedDecl(); 1082 return isa<CXXConstructorDecl>(ND); 1083 } 1084 1085 void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) { 1086 assert(!ShadowMaps.empty() && "Must enter into a results scope"); 1087 1088 if (R.Kind != Result::RK_Declaration) { 1089 // For non-declaration results, just add the result. 1090 Results.push_back(R); 1091 return; 1092 } 1093 1094 // Look through using declarations. 1095 if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) { 1096 CodeCompletionResult Result(Using->getTargetDecl(), 1097 getBasePriority(Using->getTargetDecl()), 1098 R.Qualifier); 1099 Result.ShadowDecl = Using; 1100 MaybeAddResult(Result, CurContext); 1101 return; 1102 } 1103 1104 const Decl *CanonDecl = R.Declaration->getCanonicalDecl(); 1105 unsigned IDNS = CanonDecl->getIdentifierNamespace(); 1106 1107 bool AsNestedNameSpecifier = false; 1108 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier)) 1109 return; 1110 1111 // C++ constructors are never found by name lookup. 1112 if (isConstructor(R.Declaration)) 1113 return; 1114 1115 ShadowMap &SMap = ShadowMaps.back(); 1116 ShadowMapEntry::iterator I, IEnd; 1117 ShadowMap::iterator NamePos = SMap.find(R.Declaration->getDeclName()); 1118 if (NamePos != SMap.end()) { 1119 I = NamePos->second.begin(); 1120 IEnd = NamePos->second.end(); 1121 } 1122 1123 for (; I != IEnd; ++I) { 1124 const NamedDecl *ND = I->first; 1125 unsigned Index = I->second; 1126 if (ND->getCanonicalDecl() == CanonDecl) { 1127 // This is a redeclaration. Always pick the newer declaration. 1128 Results[Index].Declaration = R.Declaration; 1129 1130 // We're done. 1131 return; 1132 } 1133 } 1134 1135 // This is a new declaration in this scope. However, check whether this 1136 // declaration name is hidden by a similarly-named declaration in an outer 1137 // scope. 1138 std::list<ShadowMap>::iterator SM, SMEnd = ShadowMaps.end(); 1139 --SMEnd; 1140 for (SM = ShadowMaps.begin(); SM != SMEnd; ++SM) { 1141 ShadowMapEntry::iterator I, IEnd; 1142 ShadowMap::iterator NamePos = SM->find(R.Declaration->getDeclName()); 1143 if (NamePos != SM->end()) { 1144 I = NamePos->second.begin(); 1145 IEnd = NamePos->second.end(); 1146 } 1147 for (; I != IEnd; ++I) { 1148 // A tag declaration does not hide a non-tag declaration. 1149 if (I->first->hasTagIdentifierNamespace() && 1150 (IDNS & (Decl::IDNS_Member | Decl::IDNS_Ordinary | 1151 Decl::IDNS_LocalExtern | Decl::IDNS_ObjCProtocol))) 1152 continue; 1153 1154 // Protocols are in distinct namespaces from everything else. 1155 if (((I->first->getIdentifierNamespace() & Decl::IDNS_ObjCProtocol) || 1156 (IDNS & Decl::IDNS_ObjCProtocol)) && 1157 I->first->getIdentifierNamespace() != IDNS) 1158 continue; 1159 1160 // The newly-added result is hidden by an entry in the shadow map. 1161 if (CheckHiddenResult(R, CurContext, I->first)) 1162 return; 1163 1164 break; 1165 } 1166 } 1167 1168 // Make sure that any given declaration only shows up in the result set once. 1169 if (!AllDeclsFound.insert(CanonDecl).second) 1170 return; 1171 1172 // If the filter is for nested-name-specifiers, then this result starts a 1173 // nested-name-specifier. 1174 if (AsNestedNameSpecifier) { 1175 R.StartsNestedNameSpecifier = true; 1176 R.Priority = CCP_NestedNameSpecifier; 1177 } else 1178 AdjustResultPriorityForDecl(R); 1179 1180 // If this result is supposed to have an informative qualifier, add one. 1181 if (R.QualifierIsInformative && !R.Qualifier && 1182 !R.StartsNestedNameSpecifier) { 1183 const DeclContext *Ctx = R.Declaration->getDeclContext(); 1184 if (const NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(Ctx)) 1185 R.Qualifier = 1186 NestedNameSpecifier::Create(SemaRef.Context, nullptr, Namespace); 1187 else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx)) 1188 R.Qualifier = NestedNameSpecifier::Create( 1189 SemaRef.Context, nullptr, false, 1190 SemaRef.Context.getTypeDeclType(Tag).getTypePtr()); 1191 else 1192 R.QualifierIsInformative = false; 1193 } 1194 1195 // Insert this result into the set of results and into the current shadow 1196 // map. 1197 SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size()); 1198 Results.push_back(R); 1199 1200 if (!AsNestedNameSpecifier) 1201 MaybeAddConstructorResults(R); 1202 } 1203 1204 static void setInBaseClass(ResultBuilder::Result &R) { 1205 R.Priority += CCD_InBaseClass; 1206 R.InBaseClass = true; 1207 } 1208 1209 enum class OverloadCompare { BothViable, Dominates, Dominated }; 1210 // Will Candidate ever be called on the object, when overloaded with Incumbent? 1211 // Returns Dominates if Candidate is always called, Dominated if Incumbent is 1212 // always called, BothViable if either may be called dependending on arguments. 1213 // Precondition: must actually be overloads! 1214 static OverloadCompare compareOverloads(const CXXMethodDecl &Candidate, 1215 const CXXMethodDecl &Incumbent, 1216 const Qualifiers &ObjectQuals, 1217 ExprValueKind ObjectKind) { 1218 // Base/derived shadowing is handled elsewhere. 1219 if (Candidate.getDeclContext() != Incumbent.getDeclContext()) 1220 return OverloadCompare::BothViable; 1221 if (Candidate.isVariadic() != Incumbent.isVariadic() || 1222 Candidate.getNumParams() != Incumbent.getNumParams() || 1223 Candidate.getMinRequiredArguments() != 1224 Incumbent.getMinRequiredArguments()) 1225 return OverloadCompare::BothViable; 1226 for (unsigned I = 0, E = Candidate.getNumParams(); I != E; ++I) 1227 if (Candidate.parameters()[I]->getType().getCanonicalType() != 1228 Incumbent.parameters()[I]->getType().getCanonicalType()) 1229 return OverloadCompare::BothViable; 1230 if (!llvm::empty(Candidate.specific_attrs<EnableIfAttr>()) || 1231 !llvm::empty(Incumbent.specific_attrs<EnableIfAttr>())) 1232 return OverloadCompare::BothViable; 1233 // At this point, we know calls can't pick one or the other based on 1234 // arguments, so one of the two must win. (Or both fail, handled elsewhere). 1235 RefQualifierKind CandidateRef = Candidate.getRefQualifier(); 1236 RefQualifierKind IncumbentRef = Incumbent.getRefQualifier(); 1237 if (CandidateRef != IncumbentRef) { 1238 // If the object kind is LValue/RValue, there's one acceptable ref-qualifier 1239 // and it can't be mixed with ref-unqualified overloads (in valid code). 1240 1241 // For xvalue objects, we prefer the rvalue overload even if we have to 1242 // add qualifiers (which is rare, because const&& is rare). 1243 if (ObjectKind == clang::VK_XValue) 1244 return CandidateRef == RQ_RValue ? OverloadCompare::Dominates 1245 : OverloadCompare::Dominated; 1246 } 1247 // Now the ref qualifiers are the same (or we're in some invalid state). 1248 // So make some decision based on the qualifiers. 1249 Qualifiers CandidateQual = Candidate.getMethodQualifiers(); 1250 Qualifiers IncumbentQual = Incumbent.getMethodQualifiers(); 1251 bool CandidateSuperset = CandidateQual.compatiblyIncludes(IncumbentQual); 1252 bool IncumbentSuperset = IncumbentQual.compatiblyIncludes(CandidateQual); 1253 if (CandidateSuperset == IncumbentSuperset) 1254 return OverloadCompare::BothViable; 1255 return IncumbentSuperset ? OverloadCompare::Dominates 1256 : OverloadCompare::Dominated; 1257 } 1258 1259 void ResultBuilder::AddResult(Result R, DeclContext *CurContext, 1260 NamedDecl *Hiding, bool InBaseClass = false) { 1261 if (R.Kind != Result::RK_Declaration) { 1262 // For non-declaration results, just add the result. 1263 Results.push_back(R); 1264 return; 1265 } 1266 1267 // Look through using declarations. 1268 if (const auto *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) { 1269 CodeCompletionResult Result(Using->getTargetDecl(), 1270 getBasePriority(Using->getTargetDecl()), 1271 R.Qualifier); 1272 Result.ShadowDecl = Using; 1273 AddResult(Result, CurContext, Hiding); 1274 return; 1275 } 1276 1277 bool AsNestedNameSpecifier = false; 1278 if (!isInterestingDecl(R.Declaration, AsNestedNameSpecifier)) 1279 return; 1280 1281 // C++ constructors are never found by name lookup. 1282 if (isConstructor(R.Declaration)) 1283 return; 1284 1285 if (Hiding && CheckHiddenResult(R, CurContext, Hiding)) 1286 return; 1287 1288 // Make sure that any given declaration only shows up in the result set once. 1289 if (!AllDeclsFound.insert(R.Declaration->getCanonicalDecl()).second) 1290 return; 1291 1292 // If the filter is for nested-name-specifiers, then this result starts a 1293 // nested-name-specifier. 1294 if (AsNestedNameSpecifier) { 1295 R.StartsNestedNameSpecifier = true; 1296 R.Priority = CCP_NestedNameSpecifier; 1297 } else if (Filter == &ResultBuilder::IsMember && !R.Qualifier && 1298 InBaseClass && 1299 isa<CXXRecordDecl>( 1300 R.Declaration->getDeclContext()->getRedeclContext())) 1301 R.QualifierIsInformative = true; 1302 1303 // If this result is supposed to have an informative qualifier, add one. 1304 if (R.QualifierIsInformative && !R.Qualifier && 1305 !R.StartsNestedNameSpecifier) { 1306 const DeclContext *Ctx = R.Declaration->getDeclContext(); 1307 if (const auto *Namespace = dyn_cast<NamespaceDecl>(Ctx)) 1308 R.Qualifier = 1309 NestedNameSpecifier::Create(SemaRef.Context, nullptr, Namespace); 1310 else if (const auto *Tag = dyn_cast<TagDecl>(Ctx)) 1311 R.Qualifier = NestedNameSpecifier::Create( 1312 SemaRef.Context, nullptr, false, 1313 SemaRef.Context.getTypeDeclType(Tag).getTypePtr()); 1314 else 1315 R.QualifierIsInformative = false; 1316 } 1317 1318 // Adjust the priority if this result comes from a base class. 1319 if (InBaseClass) 1320 setInBaseClass(R); 1321 1322 AdjustResultPriorityForDecl(R); 1323 1324 if (HasObjectTypeQualifiers) 1325 if (const auto *Method = dyn_cast<CXXMethodDecl>(R.Declaration)) 1326 if (Method->isInstance()) { 1327 Qualifiers MethodQuals = Method->getMethodQualifiers(); 1328 if (ObjectTypeQualifiers == MethodQuals) 1329 R.Priority += CCD_ObjectQualifierMatch; 1330 else if (ObjectTypeQualifiers - MethodQuals) { 1331 // The method cannot be invoked, because doing so would drop 1332 // qualifiers. 1333 return; 1334 } 1335 // Detect cases where a ref-qualified method cannot be invoked. 1336 switch (Method->getRefQualifier()) { 1337 case RQ_LValue: 1338 if (ObjectKind != VK_LValue && !MethodQuals.hasConst()) 1339 return; 1340 break; 1341 case RQ_RValue: 1342 if (ObjectKind == VK_LValue) 1343 return; 1344 break; 1345 case RQ_None: 1346 break; 1347 } 1348 1349 /// Check whether this dominates another overloaded method, which should 1350 /// be suppressed (or vice versa). 1351 /// Motivating case is const_iterator begin() const vs iterator begin(). 1352 auto &OverloadSet = OverloadMap[std::make_pair( 1353 CurContext, Method->getDeclName().getAsOpaqueInteger())]; 1354 for (const DeclIndexPair Entry : OverloadSet) { 1355 Result &Incumbent = Results[Entry.second]; 1356 switch (compareOverloads(*Method, 1357 *cast<CXXMethodDecl>(Incumbent.Declaration), 1358 ObjectTypeQualifiers, ObjectKind)) { 1359 case OverloadCompare::Dominates: 1360 // Replace the dominated overload with this one. 1361 // FIXME: if the overload dominates multiple incumbents then we 1362 // should remove all. But two overloads is by far the common case. 1363 Incumbent = std::move(R); 1364 return; 1365 case OverloadCompare::Dominated: 1366 // This overload can't be called, drop it. 1367 return; 1368 case OverloadCompare::BothViable: 1369 break; 1370 } 1371 } 1372 OverloadSet.Add(Method, Results.size()); 1373 } 1374 1375 // Insert this result into the set of results. 1376 Results.push_back(R); 1377 1378 if (!AsNestedNameSpecifier) 1379 MaybeAddConstructorResults(R); 1380 } 1381 1382 void ResultBuilder::AddResult(Result R) { 1383 assert(R.Kind != Result::RK_Declaration && 1384 "Declaration results need more context"); 1385 Results.push_back(R); 1386 } 1387 1388 /// Enter into a new scope. 1389 void ResultBuilder::EnterNewScope() { ShadowMaps.emplace_back(); } 1390 1391 /// Exit from the current scope. 1392 void ResultBuilder::ExitScope() { 1393 ShadowMaps.pop_back(); 1394 } 1395 1396 /// Determines whether this given declaration will be found by 1397 /// ordinary name lookup. 1398 bool ResultBuilder::IsOrdinaryName(const NamedDecl *ND) const { 1399 ND = ND->getUnderlyingDecl(); 1400 1401 // If name lookup finds a local extern declaration, then we are in a 1402 // context where it behaves like an ordinary name. 1403 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern; 1404 if (SemaRef.getLangOpts().CPlusPlus) 1405 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member; 1406 else if (SemaRef.getLangOpts().ObjC) { 1407 if (isa<ObjCIvarDecl>(ND)) 1408 return true; 1409 } 1410 1411 return ND->getIdentifierNamespace() & IDNS; 1412 } 1413 1414 /// Determines whether this given declaration will be found by 1415 /// ordinary name lookup but is not a type name. 1416 bool ResultBuilder::IsOrdinaryNonTypeName(const NamedDecl *ND) const { 1417 ND = ND->getUnderlyingDecl(); 1418 if (isa<TypeDecl>(ND)) 1419 return false; 1420 // Objective-C interfaces names are not filtered by this method because they 1421 // can be used in a class property expression. We can still filter out 1422 // @class declarations though. 1423 if (const auto *ID = dyn_cast<ObjCInterfaceDecl>(ND)) { 1424 if (!ID->getDefinition()) 1425 return false; 1426 } 1427 1428 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern; 1429 if (SemaRef.getLangOpts().CPlusPlus) 1430 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace | Decl::IDNS_Member; 1431 else if (SemaRef.getLangOpts().ObjC) { 1432 if (isa<ObjCIvarDecl>(ND)) 1433 return true; 1434 } 1435 1436 return ND->getIdentifierNamespace() & IDNS; 1437 } 1438 1439 bool ResultBuilder::IsIntegralConstantValue(const NamedDecl *ND) const { 1440 if (!IsOrdinaryNonTypeName(ND)) 1441 return false; 1442 1443 if (const auto *VD = dyn_cast<ValueDecl>(ND->getUnderlyingDecl())) 1444 if (VD->getType()->isIntegralOrEnumerationType()) 1445 return true; 1446 1447 return false; 1448 } 1449 1450 /// Determines whether this given declaration will be found by 1451 /// ordinary name lookup. 1452 bool ResultBuilder::IsOrdinaryNonValueName(const NamedDecl *ND) const { 1453 ND = ND->getUnderlyingDecl(); 1454 1455 unsigned IDNS = Decl::IDNS_Ordinary | Decl::IDNS_LocalExtern; 1456 if (SemaRef.getLangOpts().CPlusPlus) 1457 IDNS |= Decl::IDNS_Tag | Decl::IDNS_Namespace; 1458 1459 return (ND->getIdentifierNamespace() & IDNS) && !isa<ValueDecl>(ND) && 1460 !isa<FunctionTemplateDecl>(ND) && !isa<ObjCPropertyDecl>(ND); 1461 } 1462 1463 /// Determines whether the given declaration is suitable as the 1464 /// start of a C++ nested-name-specifier, e.g., a class or namespace. 1465 bool ResultBuilder::IsNestedNameSpecifier(const NamedDecl *ND) const { 1466 // Allow us to find class templates, too. 1467 if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND)) 1468 ND = ClassTemplate->getTemplatedDecl(); 1469 1470 return SemaRef.isAcceptableNestedNameSpecifier(ND); 1471 } 1472 1473 /// Determines whether the given declaration is an enumeration. 1474 bool ResultBuilder::IsEnum(const NamedDecl *ND) const { 1475 return isa<EnumDecl>(ND); 1476 } 1477 1478 /// Determines whether the given declaration is a class or struct. 1479 bool ResultBuilder::IsClassOrStruct(const NamedDecl *ND) const { 1480 // Allow us to find class templates, too. 1481 if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND)) 1482 ND = ClassTemplate->getTemplatedDecl(); 1483 1484 // For purposes of this check, interfaces match too. 1485 if (const auto *RD = dyn_cast<RecordDecl>(ND)) 1486 return RD->getTagKind() == TTK_Class || RD->getTagKind() == TTK_Struct || 1487 RD->getTagKind() == TTK_Interface; 1488 1489 return false; 1490 } 1491 1492 /// Determines whether the given declaration is a union. 1493 bool ResultBuilder::IsUnion(const NamedDecl *ND) const { 1494 // Allow us to find class templates, too. 1495 if (const auto *ClassTemplate = dyn_cast<ClassTemplateDecl>(ND)) 1496 ND = ClassTemplate->getTemplatedDecl(); 1497 1498 if (const auto *RD = dyn_cast<RecordDecl>(ND)) 1499 return RD->getTagKind() == TTK_Union; 1500 1501 return false; 1502 } 1503 1504 /// Determines whether the given declaration is a namespace. 1505 bool ResultBuilder::IsNamespace(const NamedDecl *ND) const { 1506 return isa<NamespaceDecl>(ND); 1507 } 1508 1509 /// Determines whether the given declaration is a namespace or 1510 /// namespace alias. 1511 bool ResultBuilder::IsNamespaceOrAlias(const NamedDecl *ND) const { 1512 return isa<NamespaceDecl>(ND->getUnderlyingDecl()); 1513 } 1514 1515 /// Determines whether the given declaration is a type. 1516 bool ResultBuilder::IsType(const NamedDecl *ND) const { 1517 ND = ND->getUnderlyingDecl(); 1518 return isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND); 1519 } 1520 1521 /// Determines which members of a class should be visible via 1522 /// "." or "->". Only value declarations, nested name specifiers, and 1523 /// using declarations thereof should show up. 1524 bool ResultBuilder::IsMember(const NamedDecl *ND) const { 1525 ND = ND->getUnderlyingDecl(); 1526 return isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND) || 1527 isa<ObjCPropertyDecl>(ND); 1528 } 1529 1530 static bool isObjCReceiverType(ASTContext &C, QualType T) { 1531 T = C.getCanonicalType(T); 1532 switch (T->getTypeClass()) { 1533 case Type::ObjCObject: 1534 case Type::ObjCInterface: 1535 case Type::ObjCObjectPointer: 1536 return true; 1537 1538 case Type::Builtin: 1539 switch (cast<BuiltinType>(T)->getKind()) { 1540 case BuiltinType::ObjCId: 1541 case BuiltinType::ObjCClass: 1542 case BuiltinType::ObjCSel: 1543 return true; 1544 1545 default: 1546 break; 1547 } 1548 return false; 1549 1550 default: 1551 break; 1552 } 1553 1554 if (!C.getLangOpts().CPlusPlus) 1555 return false; 1556 1557 // FIXME: We could perform more analysis here to determine whether a 1558 // particular class type has any conversions to Objective-C types. For now, 1559 // just accept all class types. 1560 return T->isDependentType() || T->isRecordType(); 1561 } 1562 1563 bool ResultBuilder::IsObjCMessageReceiver(const NamedDecl *ND) const { 1564 QualType T = getDeclUsageType(SemaRef.Context, ND); 1565 if (T.isNull()) 1566 return false; 1567 1568 T = SemaRef.Context.getBaseElementType(T); 1569 return isObjCReceiverType(SemaRef.Context, T); 1570 } 1571 1572 bool ResultBuilder::IsObjCMessageReceiverOrLambdaCapture( 1573 const NamedDecl *ND) const { 1574 if (IsObjCMessageReceiver(ND)) 1575 return true; 1576 1577 const auto *Var = dyn_cast<VarDecl>(ND); 1578 if (!Var) 1579 return false; 1580 1581 return Var->hasLocalStorage() && !Var->hasAttr<BlocksAttr>(); 1582 } 1583 1584 bool ResultBuilder::IsObjCCollection(const NamedDecl *ND) const { 1585 if ((SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryName(ND)) || 1586 (!SemaRef.getLangOpts().CPlusPlus && !IsOrdinaryNonTypeName(ND))) 1587 return false; 1588 1589 QualType T = getDeclUsageType(SemaRef.Context, ND); 1590 if (T.isNull()) 1591 return false; 1592 1593 T = SemaRef.Context.getBaseElementType(T); 1594 return T->isObjCObjectType() || T->isObjCObjectPointerType() || 1595 T->isObjCIdType() || 1596 (SemaRef.getLangOpts().CPlusPlus && T->isRecordType()); 1597 } 1598 1599 bool ResultBuilder::IsImpossibleToSatisfy(const NamedDecl *ND) const { 1600 return false; 1601 } 1602 1603 /// Determines whether the given declaration is an Objective-C 1604 /// instance variable. 1605 bool ResultBuilder::IsObjCIvar(const NamedDecl *ND) const { 1606 return isa<ObjCIvarDecl>(ND); 1607 } 1608 1609 namespace { 1610 1611 /// Visible declaration consumer that adds a code-completion result 1612 /// for each visible declaration. 1613 class CodeCompletionDeclConsumer : public VisibleDeclConsumer { 1614 ResultBuilder &Results; 1615 DeclContext *InitialLookupCtx; 1616 // NamingClass and BaseType are used for access-checking. See 1617 // Sema::IsSimplyAccessible for details. 1618 CXXRecordDecl *NamingClass; 1619 QualType BaseType; 1620 std::vector<FixItHint> FixIts; 1621 1622 public: 1623 CodeCompletionDeclConsumer( 1624 ResultBuilder &Results, DeclContext *InitialLookupCtx, 1625 QualType BaseType = QualType(), 1626 std::vector<FixItHint> FixIts = std::vector<FixItHint>()) 1627 : Results(Results), InitialLookupCtx(InitialLookupCtx), 1628 FixIts(std::move(FixIts)) { 1629 NamingClass = llvm::dyn_cast<CXXRecordDecl>(InitialLookupCtx); 1630 // If BaseType was not provided explicitly, emulate implicit 'this->'. 1631 if (BaseType.isNull()) { 1632 auto ThisType = Results.getSema().getCurrentThisType(); 1633 if (!ThisType.isNull()) { 1634 assert(ThisType->isPointerType()); 1635 BaseType = ThisType->getPointeeType(); 1636 if (!NamingClass) 1637 NamingClass = BaseType->getAsCXXRecordDecl(); 1638 } 1639 } 1640 this->BaseType = BaseType; 1641 } 1642 1643 void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx, 1644 bool InBaseClass) override { 1645 ResultBuilder::Result Result(ND, Results.getBasePriority(ND), nullptr, 1646 false, IsAccessible(ND, Ctx), FixIts); 1647 Results.AddResult(Result, InitialLookupCtx, Hiding, InBaseClass); 1648 } 1649 1650 void EnteredContext(DeclContext *Ctx) override { 1651 Results.addVisitedContext(Ctx); 1652 } 1653 1654 private: 1655 bool IsAccessible(NamedDecl *ND, DeclContext *Ctx) { 1656 // Naming class to use for access check. In most cases it was provided 1657 // explicitly (e.g. member access (lhs.foo) or qualified lookup (X::)), 1658 // for unqualified lookup we fallback to the \p Ctx in which we found the 1659 // member. 1660 auto *NamingClass = this->NamingClass; 1661 QualType BaseType = this->BaseType; 1662 if (auto *Cls = llvm::dyn_cast_or_null<CXXRecordDecl>(Ctx)) { 1663 if (!NamingClass) 1664 NamingClass = Cls; 1665 // When we emulate implicit 'this->' in an unqualified lookup, we might 1666 // end up with an invalid naming class. In that case, we avoid emulating 1667 // 'this->' qualifier to satisfy preconditions of the access checking. 1668 if (NamingClass->getCanonicalDecl() != Cls->getCanonicalDecl() && 1669 !NamingClass->isDerivedFrom(Cls)) { 1670 NamingClass = Cls; 1671 BaseType = QualType(); 1672 } 1673 } else { 1674 // The decl was found outside the C++ class, so only ObjC access checks 1675 // apply. Those do not rely on NamingClass and BaseType, so we clear them 1676 // out. 1677 NamingClass = nullptr; 1678 BaseType = QualType(); 1679 } 1680 return Results.getSema().IsSimplyAccessible(ND, NamingClass, BaseType); 1681 } 1682 }; 1683 } // namespace 1684 1685 /// Add type specifiers for the current language as keyword results. 1686 static void AddTypeSpecifierResults(const LangOptions &LangOpts, 1687 ResultBuilder &Results) { 1688 typedef CodeCompletionResult Result; 1689 Results.AddResult(Result("short", CCP_Type)); 1690 Results.AddResult(Result("long", CCP_Type)); 1691 Results.AddResult(Result("signed", CCP_Type)); 1692 Results.AddResult(Result("unsigned", CCP_Type)); 1693 Results.AddResult(Result("void", CCP_Type)); 1694 Results.AddResult(Result("char", CCP_Type)); 1695 Results.AddResult(Result("int", CCP_Type)); 1696 Results.AddResult(Result("float", CCP_Type)); 1697 Results.AddResult(Result("double", CCP_Type)); 1698 Results.AddResult(Result("enum", CCP_Type)); 1699 Results.AddResult(Result("struct", CCP_Type)); 1700 Results.AddResult(Result("union", CCP_Type)); 1701 Results.AddResult(Result("const", CCP_Type)); 1702 Results.AddResult(Result("volatile", CCP_Type)); 1703 1704 if (LangOpts.C99) { 1705 // C99-specific 1706 Results.AddResult(Result("_Complex", CCP_Type)); 1707 Results.AddResult(Result("_Imaginary", CCP_Type)); 1708 Results.AddResult(Result("_Bool", CCP_Type)); 1709 Results.AddResult(Result("restrict", CCP_Type)); 1710 } 1711 1712 CodeCompletionBuilder Builder(Results.getAllocator(), 1713 Results.getCodeCompletionTUInfo()); 1714 if (LangOpts.CPlusPlus) { 1715 // C++-specific 1716 Results.AddResult( 1717 Result("bool", CCP_Type + (LangOpts.ObjC ? CCD_bool_in_ObjC : 0))); 1718 Results.AddResult(Result("class", CCP_Type)); 1719 Results.AddResult(Result("wchar_t", CCP_Type)); 1720 1721 // typename name 1722 Builder.AddTypedTextChunk("typename"); 1723 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 1724 Builder.AddPlaceholderChunk("name"); 1725 Results.AddResult(Result(Builder.TakeString())); 1726 1727 if (LangOpts.CPlusPlus11) { 1728 Results.AddResult(Result("auto", CCP_Type)); 1729 Results.AddResult(Result("char16_t", CCP_Type)); 1730 Results.AddResult(Result("char32_t", CCP_Type)); 1731 1732 Builder.AddTypedTextChunk("decltype"); 1733 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 1734 Builder.AddPlaceholderChunk("expression"); 1735 Builder.AddChunk(CodeCompletionString::CK_RightParen); 1736 Results.AddResult(Result(Builder.TakeString())); 1737 } 1738 } else 1739 Results.AddResult(Result("__auto_type", CCP_Type)); 1740 1741 // GNU keywords 1742 if (LangOpts.GNUKeywords) { 1743 // FIXME: Enable when we actually support decimal floating point. 1744 // Results.AddResult(Result("_Decimal32")); 1745 // Results.AddResult(Result("_Decimal64")); 1746 // Results.AddResult(Result("_Decimal128")); 1747 1748 Builder.AddTypedTextChunk("typeof"); 1749 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 1750 Builder.AddPlaceholderChunk("expression"); 1751 Results.AddResult(Result(Builder.TakeString())); 1752 1753 Builder.AddTypedTextChunk("typeof"); 1754 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 1755 Builder.AddPlaceholderChunk("type"); 1756 Builder.AddChunk(CodeCompletionString::CK_RightParen); 1757 Results.AddResult(Result(Builder.TakeString())); 1758 } 1759 1760 // Nullability 1761 Results.AddResult(Result("_Nonnull", CCP_Type)); 1762 Results.AddResult(Result("_Null_unspecified", CCP_Type)); 1763 Results.AddResult(Result("_Nullable", CCP_Type)); 1764 } 1765 1766 static void AddStorageSpecifiers(Sema::ParserCompletionContext CCC, 1767 const LangOptions &LangOpts, 1768 ResultBuilder &Results) { 1769 typedef CodeCompletionResult Result; 1770 // Note: we don't suggest either "auto" or "register", because both 1771 // are pointless as storage specifiers. Elsewhere, we suggest "auto" 1772 // in C++0x as a type specifier. 1773 Results.AddResult(Result("extern")); 1774 Results.AddResult(Result("static")); 1775 1776 if (LangOpts.CPlusPlus11) { 1777 CodeCompletionAllocator &Allocator = Results.getAllocator(); 1778 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo()); 1779 1780 // alignas 1781 Builder.AddTypedTextChunk("alignas"); 1782 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 1783 Builder.AddPlaceholderChunk("expression"); 1784 Builder.AddChunk(CodeCompletionString::CK_RightParen); 1785 Results.AddResult(Result(Builder.TakeString())); 1786 1787 Results.AddResult(Result("constexpr")); 1788 Results.AddResult(Result("thread_local")); 1789 } 1790 } 1791 1792 static void AddFunctionSpecifiers(Sema::ParserCompletionContext CCC, 1793 const LangOptions &LangOpts, 1794 ResultBuilder &Results) { 1795 typedef CodeCompletionResult Result; 1796 switch (CCC) { 1797 case Sema::PCC_Class: 1798 case Sema::PCC_MemberTemplate: 1799 if (LangOpts.CPlusPlus) { 1800 Results.AddResult(Result("explicit")); 1801 Results.AddResult(Result("friend")); 1802 Results.AddResult(Result("mutable")); 1803 Results.AddResult(Result("virtual")); 1804 } 1805 LLVM_FALLTHROUGH; 1806 1807 case Sema::PCC_ObjCInterface: 1808 case Sema::PCC_ObjCImplementation: 1809 case Sema::PCC_Namespace: 1810 case Sema::PCC_Template: 1811 if (LangOpts.CPlusPlus || LangOpts.C99) 1812 Results.AddResult(Result("inline")); 1813 break; 1814 1815 case Sema::PCC_ObjCInstanceVariableList: 1816 case Sema::PCC_Expression: 1817 case Sema::PCC_Statement: 1818 case Sema::PCC_ForInit: 1819 case Sema::PCC_Condition: 1820 case Sema::PCC_RecoveryInFunction: 1821 case Sema::PCC_Type: 1822 case Sema::PCC_ParenthesizedExpression: 1823 case Sema::PCC_LocalDeclarationSpecifiers: 1824 break; 1825 } 1826 } 1827 1828 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt); 1829 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt); 1830 static void AddObjCVisibilityResults(const LangOptions &LangOpts, 1831 ResultBuilder &Results, bool NeedAt); 1832 static void AddObjCImplementationResults(const LangOptions &LangOpts, 1833 ResultBuilder &Results, bool NeedAt); 1834 static void AddObjCInterfaceResults(const LangOptions &LangOpts, 1835 ResultBuilder &Results, bool NeedAt); 1836 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt); 1837 1838 static void AddTypedefResult(ResultBuilder &Results) { 1839 CodeCompletionBuilder Builder(Results.getAllocator(), 1840 Results.getCodeCompletionTUInfo()); 1841 Builder.AddTypedTextChunk("typedef"); 1842 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 1843 Builder.AddPlaceholderChunk("type"); 1844 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 1845 Builder.AddPlaceholderChunk("name"); 1846 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 1847 Results.AddResult(CodeCompletionResult(Builder.TakeString())); 1848 } 1849 1850 // using name = type 1851 static void AddUsingAliasResult(CodeCompletionBuilder &Builder, 1852 ResultBuilder &Results) { 1853 Builder.AddTypedTextChunk("using"); 1854 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 1855 Builder.AddPlaceholderChunk("name"); 1856 Builder.AddChunk(CodeCompletionString::CK_Equal); 1857 Builder.AddPlaceholderChunk("type"); 1858 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 1859 Results.AddResult(CodeCompletionResult(Builder.TakeString())); 1860 } 1861 1862 static bool WantTypesInContext(Sema::ParserCompletionContext CCC, 1863 const LangOptions &LangOpts) { 1864 switch (CCC) { 1865 case Sema::PCC_Namespace: 1866 case Sema::PCC_Class: 1867 case Sema::PCC_ObjCInstanceVariableList: 1868 case Sema::PCC_Template: 1869 case Sema::PCC_MemberTemplate: 1870 case Sema::PCC_Statement: 1871 case Sema::PCC_RecoveryInFunction: 1872 case Sema::PCC_Type: 1873 case Sema::PCC_ParenthesizedExpression: 1874 case Sema::PCC_LocalDeclarationSpecifiers: 1875 return true; 1876 1877 case Sema::PCC_Expression: 1878 case Sema::PCC_Condition: 1879 return LangOpts.CPlusPlus; 1880 1881 case Sema::PCC_ObjCInterface: 1882 case Sema::PCC_ObjCImplementation: 1883 return false; 1884 1885 case Sema::PCC_ForInit: 1886 return LangOpts.CPlusPlus || LangOpts.ObjC || LangOpts.C99; 1887 } 1888 1889 llvm_unreachable("Invalid ParserCompletionContext!"); 1890 } 1891 1892 static PrintingPolicy getCompletionPrintingPolicy(const ASTContext &Context, 1893 const Preprocessor &PP) { 1894 PrintingPolicy Policy = Sema::getPrintingPolicy(Context, PP); 1895 Policy.AnonymousTagLocations = false; 1896 Policy.SuppressStrongLifetime = true; 1897 Policy.SuppressUnwrittenScope = true; 1898 Policy.SuppressScope = true; 1899 Policy.CleanUglifiedParameters = true; 1900 return Policy; 1901 } 1902 1903 /// Retrieve a printing policy suitable for code completion. 1904 static PrintingPolicy getCompletionPrintingPolicy(Sema &S) { 1905 return getCompletionPrintingPolicy(S.Context, S.PP); 1906 } 1907 1908 /// Retrieve the string representation of the given type as a string 1909 /// that has the appropriate lifetime for code completion. 1910 /// 1911 /// This routine provides a fast path where we provide constant strings for 1912 /// common type names. 1913 static const char *GetCompletionTypeString(QualType T, ASTContext &Context, 1914 const PrintingPolicy &Policy, 1915 CodeCompletionAllocator &Allocator) { 1916 if (!T.getLocalQualifiers()) { 1917 // Built-in type names are constant strings. 1918 if (const BuiltinType *BT = dyn_cast<BuiltinType>(T)) 1919 return BT->getNameAsCString(Policy); 1920 1921 // Anonymous tag types are constant strings. 1922 if (const TagType *TagT = dyn_cast<TagType>(T)) 1923 if (TagDecl *Tag = TagT->getDecl()) 1924 if (!Tag->hasNameForLinkage()) { 1925 switch (Tag->getTagKind()) { 1926 case TTK_Struct: 1927 return "struct <anonymous>"; 1928 case TTK_Interface: 1929 return "__interface <anonymous>"; 1930 case TTK_Class: 1931 return "class <anonymous>"; 1932 case TTK_Union: 1933 return "union <anonymous>"; 1934 case TTK_Enum: 1935 return "enum <anonymous>"; 1936 } 1937 } 1938 } 1939 1940 // Slow path: format the type as a string. 1941 std::string Result; 1942 T.getAsStringInternal(Result, Policy); 1943 return Allocator.CopyString(Result); 1944 } 1945 1946 /// Add a completion for "this", if we're in a member function. 1947 static void addThisCompletion(Sema &S, ResultBuilder &Results) { 1948 QualType ThisTy = S.getCurrentThisType(); 1949 if (ThisTy.isNull()) 1950 return; 1951 1952 CodeCompletionAllocator &Allocator = Results.getAllocator(); 1953 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo()); 1954 PrintingPolicy Policy = getCompletionPrintingPolicy(S); 1955 Builder.AddResultTypeChunk( 1956 GetCompletionTypeString(ThisTy, S.Context, Policy, Allocator)); 1957 Builder.AddTypedTextChunk("this"); 1958 Results.AddResult(CodeCompletionResult(Builder.TakeString())); 1959 } 1960 1961 static void AddStaticAssertResult(CodeCompletionBuilder &Builder, 1962 ResultBuilder &Results, 1963 const LangOptions &LangOpts) { 1964 if (!LangOpts.CPlusPlus11) 1965 return; 1966 1967 Builder.AddTypedTextChunk("static_assert"); 1968 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 1969 Builder.AddPlaceholderChunk("expression"); 1970 Builder.AddChunk(CodeCompletionString::CK_Comma); 1971 Builder.AddPlaceholderChunk("message"); 1972 Builder.AddChunk(CodeCompletionString::CK_RightParen); 1973 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 1974 Results.AddResult(CodeCompletionResult(Builder.TakeString())); 1975 } 1976 1977 static void AddOverrideResults(ResultBuilder &Results, 1978 const CodeCompletionContext &CCContext, 1979 CodeCompletionBuilder &Builder) { 1980 Sema &S = Results.getSema(); 1981 const auto *CR = llvm::dyn_cast<CXXRecordDecl>(S.CurContext); 1982 // If not inside a class/struct/union return empty. 1983 if (!CR) 1984 return; 1985 // First store overrides within current class. 1986 // These are stored by name to make querying fast in the later step. 1987 llvm::StringMap<std::vector<FunctionDecl *>> Overrides; 1988 for (auto *Method : CR->methods()) { 1989 if (!Method->isVirtual() || !Method->getIdentifier()) 1990 continue; 1991 Overrides[Method->getName()].push_back(Method); 1992 } 1993 1994 for (const auto &Base : CR->bases()) { 1995 const auto *BR = Base.getType().getTypePtr()->getAsCXXRecordDecl(); 1996 if (!BR) 1997 continue; 1998 for (auto *Method : BR->methods()) { 1999 if (!Method->isVirtual() || !Method->getIdentifier()) 2000 continue; 2001 const auto it = Overrides.find(Method->getName()); 2002 bool IsOverriden = false; 2003 if (it != Overrides.end()) { 2004 for (auto *MD : it->second) { 2005 // If the method in current body is not an overload of this virtual 2006 // function, then it overrides this one. 2007 if (!S.IsOverload(MD, Method, false)) { 2008 IsOverriden = true; 2009 break; 2010 } 2011 } 2012 } 2013 if (!IsOverriden) { 2014 // Generates a new CodeCompletionResult by taking this function and 2015 // converting it into an override declaration with only one chunk in the 2016 // final CodeCompletionString as a TypedTextChunk. 2017 std::string OverrideSignature; 2018 llvm::raw_string_ostream OS(OverrideSignature); 2019 CodeCompletionResult CCR(Method, 0); 2020 PrintingPolicy Policy = 2021 getCompletionPrintingPolicy(S.getASTContext(), S.getPreprocessor()); 2022 auto *CCS = CCR.createCodeCompletionStringForOverride( 2023 S.getPreprocessor(), S.getASTContext(), Builder, 2024 /*IncludeBriefComments=*/false, CCContext, Policy); 2025 Results.AddResult(CodeCompletionResult(CCS, Method, CCP_CodePattern)); 2026 } 2027 } 2028 } 2029 } 2030 2031 /// Add language constructs that show up for "ordinary" names. 2032 static void AddOrdinaryNameResults(Sema::ParserCompletionContext CCC, Scope *S, 2033 Sema &SemaRef, ResultBuilder &Results) { 2034 CodeCompletionAllocator &Allocator = Results.getAllocator(); 2035 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo()); 2036 2037 typedef CodeCompletionResult Result; 2038 switch (CCC) { 2039 case Sema::PCC_Namespace: 2040 if (SemaRef.getLangOpts().CPlusPlus) { 2041 if (Results.includeCodePatterns()) { 2042 // namespace <identifier> { declarations } 2043 Builder.AddTypedTextChunk("namespace"); 2044 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2045 Builder.AddPlaceholderChunk("identifier"); 2046 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2047 Builder.AddChunk(CodeCompletionString::CK_LeftBrace); 2048 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2049 Builder.AddPlaceholderChunk("declarations"); 2050 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2051 Builder.AddChunk(CodeCompletionString::CK_RightBrace); 2052 Results.AddResult(Result(Builder.TakeString())); 2053 } 2054 2055 // namespace identifier = identifier ; 2056 Builder.AddTypedTextChunk("namespace"); 2057 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2058 Builder.AddPlaceholderChunk("name"); 2059 Builder.AddChunk(CodeCompletionString::CK_Equal); 2060 Builder.AddPlaceholderChunk("namespace"); 2061 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 2062 Results.AddResult(Result(Builder.TakeString())); 2063 2064 // Using directives 2065 Builder.AddTypedTextChunk("using namespace"); 2066 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2067 Builder.AddPlaceholderChunk("identifier"); 2068 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 2069 Results.AddResult(Result(Builder.TakeString())); 2070 2071 // asm(string-literal) 2072 Builder.AddTypedTextChunk("asm"); 2073 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2074 Builder.AddPlaceholderChunk("string-literal"); 2075 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2076 Results.AddResult(Result(Builder.TakeString())); 2077 2078 if (Results.includeCodePatterns()) { 2079 // Explicit template instantiation 2080 Builder.AddTypedTextChunk("template"); 2081 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2082 Builder.AddPlaceholderChunk("declaration"); 2083 Results.AddResult(Result(Builder.TakeString())); 2084 } else { 2085 Results.AddResult(Result("template", CodeCompletionResult::RK_Keyword)); 2086 } 2087 } 2088 2089 if (SemaRef.getLangOpts().ObjC) 2090 AddObjCTopLevelResults(Results, true); 2091 2092 AddTypedefResult(Results); 2093 LLVM_FALLTHROUGH; 2094 2095 case Sema::PCC_Class: 2096 if (SemaRef.getLangOpts().CPlusPlus) { 2097 // Using declaration 2098 Builder.AddTypedTextChunk("using"); 2099 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2100 Builder.AddPlaceholderChunk("qualifier"); 2101 Builder.AddTextChunk("::"); 2102 Builder.AddPlaceholderChunk("name"); 2103 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 2104 Results.AddResult(Result(Builder.TakeString())); 2105 2106 if (SemaRef.getLangOpts().CPlusPlus11) 2107 AddUsingAliasResult(Builder, Results); 2108 2109 // using typename qualifier::name (only in a dependent context) 2110 if (SemaRef.CurContext->isDependentContext()) { 2111 Builder.AddTypedTextChunk("using typename"); 2112 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2113 Builder.AddPlaceholderChunk("qualifier"); 2114 Builder.AddTextChunk("::"); 2115 Builder.AddPlaceholderChunk("name"); 2116 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 2117 Results.AddResult(Result(Builder.TakeString())); 2118 } 2119 2120 AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts()); 2121 2122 if (CCC == Sema::PCC_Class) { 2123 AddTypedefResult(Results); 2124 2125 bool IsNotInheritanceScope = 2126 !(S->getFlags() & Scope::ClassInheritanceScope); 2127 // public: 2128 Builder.AddTypedTextChunk("public"); 2129 if (IsNotInheritanceScope && Results.includeCodePatterns()) 2130 Builder.AddChunk(CodeCompletionString::CK_Colon); 2131 Results.AddResult(Result(Builder.TakeString())); 2132 2133 // protected: 2134 Builder.AddTypedTextChunk("protected"); 2135 if (IsNotInheritanceScope && Results.includeCodePatterns()) 2136 Builder.AddChunk(CodeCompletionString::CK_Colon); 2137 Results.AddResult(Result(Builder.TakeString())); 2138 2139 // private: 2140 Builder.AddTypedTextChunk("private"); 2141 if (IsNotInheritanceScope && Results.includeCodePatterns()) 2142 Builder.AddChunk(CodeCompletionString::CK_Colon); 2143 Results.AddResult(Result(Builder.TakeString())); 2144 2145 // FIXME: This adds override results only if we are at the first word of 2146 // the declaration/definition. Also call this from other sides to have 2147 // more use-cases. 2148 AddOverrideResults(Results, CodeCompletionContext::CCC_ClassStructUnion, 2149 Builder); 2150 } 2151 } 2152 LLVM_FALLTHROUGH; 2153 2154 case Sema::PCC_Template: 2155 case Sema::PCC_MemberTemplate: 2156 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) { 2157 // template < parameters > 2158 Builder.AddTypedTextChunk("template"); 2159 Builder.AddChunk(CodeCompletionString::CK_LeftAngle); 2160 Builder.AddPlaceholderChunk("parameters"); 2161 Builder.AddChunk(CodeCompletionString::CK_RightAngle); 2162 Results.AddResult(Result(Builder.TakeString())); 2163 } else { 2164 Results.AddResult(Result("template", CodeCompletionResult::RK_Keyword)); 2165 } 2166 2167 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results); 2168 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results); 2169 break; 2170 2171 case Sema::PCC_ObjCInterface: 2172 AddObjCInterfaceResults(SemaRef.getLangOpts(), Results, true); 2173 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results); 2174 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results); 2175 break; 2176 2177 case Sema::PCC_ObjCImplementation: 2178 AddObjCImplementationResults(SemaRef.getLangOpts(), Results, true); 2179 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results); 2180 AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results); 2181 break; 2182 2183 case Sema::PCC_ObjCInstanceVariableList: 2184 AddObjCVisibilityResults(SemaRef.getLangOpts(), Results, true); 2185 break; 2186 2187 case Sema::PCC_RecoveryInFunction: 2188 case Sema::PCC_Statement: { 2189 if (SemaRef.getLangOpts().CPlusPlus11) 2190 AddUsingAliasResult(Builder, Results); 2191 2192 AddTypedefResult(Results); 2193 2194 if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns() && 2195 SemaRef.getLangOpts().CXXExceptions) { 2196 Builder.AddTypedTextChunk("try"); 2197 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2198 Builder.AddChunk(CodeCompletionString::CK_LeftBrace); 2199 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2200 Builder.AddPlaceholderChunk("statements"); 2201 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2202 Builder.AddChunk(CodeCompletionString::CK_RightBrace); 2203 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2204 Builder.AddTextChunk("catch"); 2205 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2206 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2207 Builder.AddPlaceholderChunk("declaration"); 2208 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2209 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2210 Builder.AddChunk(CodeCompletionString::CK_LeftBrace); 2211 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2212 Builder.AddPlaceholderChunk("statements"); 2213 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2214 Builder.AddChunk(CodeCompletionString::CK_RightBrace); 2215 Results.AddResult(Result(Builder.TakeString())); 2216 } 2217 if (SemaRef.getLangOpts().ObjC) 2218 AddObjCStatementResults(Results, true); 2219 2220 if (Results.includeCodePatterns()) { 2221 // if (condition) { statements } 2222 Builder.AddTypedTextChunk("if"); 2223 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2224 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2225 if (SemaRef.getLangOpts().CPlusPlus) 2226 Builder.AddPlaceholderChunk("condition"); 2227 else 2228 Builder.AddPlaceholderChunk("expression"); 2229 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2230 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2231 Builder.AddChunk(CodeCompletionString::CK_LeftBrace); 2232 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2233 Builder.AddPlaceholderChunk("statements"); 2234 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2235 Builder.AddChunk(CodeCompletionString::CK_RightBrace); 2236 Results.AddResult(Result(Builder.TakeString())); 2237 2238 // switch (condition) { } 2239 Builder.AddTypedTextChunk("switch"); 2240 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2241 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2242 if (SemaRef.getLangOpts().CPlusPlus) 2243 Builder.AddPlaceholderChunk("condition"); 2244 else 2245 Builder.AddPlaceholderChunk("expression"); 2246 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2247 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2248 Builder.AddChunk(CodeCompletionString::CK_LeftBrace); 2249 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2250 Builder.AddPlaceholderChunk("cases"); 2251 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2252 Builder.AddChunk(CodeCompletionString::CK_RightBrace); 2253 Results.AddResult(Result(Builder.TakeString())); 2254 } 2255 2256 // Switch-specific statements. 2257 if (SemaRef.getCurFunction() && 2258 !SemaRef.getCurFunction()->SwitchStack.empty()) { 2259 // case expression: 2260 Builder.AddTypedTextChunk("case"); 2261 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2262 Builder.AddPlaceholderChunk("expression"); 2263 Builder.AddChunk(CodeCompletionString::CK_Colon); 2264 Results.AddResult(Result(Builder.TakeString())); 2265 2266 // default: 2267 Builder.AddTypedTextChunk("default"); 2268 Builder.AddChunk(CodeCompletionString::CK_Colon); 2269 Results.AddResult(Result(Builder.TakeString())); 2270 } 2271 2272 if (Results.includeCodePatterns()) { 2273 /// while (condition) { statements } 2274 Builder.AddTypedTextChunk("while"); 2275 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2276 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2277 if (SemaRef.getLangOpts().CPlusPlus) 2278 Builder.AddPlaceholderChunk("condition"); 2279 else 2280 Builder.AddPlaceholderChunk("expression"); 2281 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2282 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2283 Builder.AddChunk(CodeCompletionString::CK_LeftBrace); 2284 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2285 Builder.AddPlaceholderChunk("statements"); 2286 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2287 Builder.AddChunk(CodeCompletionString::CK_RightBrace); 2288 Results.AddResult(Result(Builder.TakeString())); 2289 2290 // do { statements } while ( expression ); 2291 Builder.AddTypedTextChunk("do"); 2292 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2293 Builder.AddChunk(CodeCompletionString::CK_LeftBrace); 2294 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2295 Builder.AddPlaceholderChunk("statements"); 2296 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2297 Builder.AddChunk(CodeCompletionString::CK_RightBrace); 2298 Builder.AddTextChunk("while"); 2299 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2300 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2301 Builder.AddPlaceholderChunk("expression"); 2302 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2303 Results.AddResult(Result(Builder.TakeString())); 2304 2305 // for ( for-init-statement ; condition ; expression ) { statements } 2306 Builder.AddTypedTextChunk("for"); 2307 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2308 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2309 if (SemaRef.getLangOpts().CPlusPlus || SemaRef.getLangOpts().C99) 2310 Builder.AddPlaceholderChunk("init-statement"); 2311 else 2312 Builder.AddPlaceholderChunk("init-expression"); 2313 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 2314 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2315 Builder.AddPlaceholderChunk("condition"); 2316 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 2317 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2318 Builder.AddPlaceholderChunk("inc-expression"); 2319 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2320 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2321 Builder.AddChunk(CodeCompletionString::CK_LeftBrace); 2322 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2323 Builder.AddPlaceholderChunk("statements"); 2324 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2325 Builder.AddChunk(CodeCompletionString::CK_RightBrace); 2326 Results.AddResult(Result(Builder.TakeString())); 2327 2328 if (SemaRef.getLangOpts().CPlusPlus11 || SemaRef.getLangOpts().ObjC) { 2329 // for ( range_declaration (:|in) range_expression ) { statements } 2330 Builder.AddTypedTextChunk("for"); 2331 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2332 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2333 Builder.AddPlaceholderChunk("range-declaration"); 2334 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2335 if (SemaRef.getLangOpts().ObjC) 2336 Builder.AddTextChunk("in"); 2337 else 2338 Builder.AddChunk(CodeCompletionString::CK_Colon); 2339 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2340 Builder.AddPlaceholderChunk("range-expression"); 2341 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2342 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2343 Builder.AddChunk(CodeCompletionString::CK_LeftBrace); 2344 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2345 Builder.AddPlaceholderChunk("statements"); 2346 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 2347 Builder.AddChunk(CodeCompletionString::CK_RightBrace); 2348 Results.AddResult(Result(Builder.TakeString())); 2349 } 2350 } 2351 2352 if (S->getContinueParent()) { 2353 // continue ; 2354 Builder.AddTypedTextChunk("continue"); 2355 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 2356 Results.AddResult(Result(Builder.TakeString())); 2357 } 2358 2359 if (S->getBreakParent()) { 2360 // break ; 2361 Builder.AddTypedTextChunk("break"); 2362 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 2363 Results.AddResult(Result(Builder.TakeString())); 2364 } 2365 2366 // "return expression ;" or "return ;", depending on the return type. 2367 QualType ReturnType; 2368 if (const auto *Function = dyn_cast<FunctionDecl>(SemaRef.CurContext)) 2369 ReturnType = Function->getReturnType(); 2370 else if (const auto *Method = dyn_cast<ObjCMethodDecl>(SemaRef.CurContext)) 2371 ReturnType = Method->getReturnType(); 2372 else if (SemaRef.getCurBlock() && 2373 !SemaRef.getCurBlock()->ReturnType.isNull()) 2374 ReturnType = SemaRef.getCurBlock()->ReturnType;; 2375 if (ReturnType.isNull() || ReturnType->isVoidType()) { 2376 Builder.AddTypedTextChunk("return"); 2377 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 2378 Results.AddResult(Result(Builder.TakeString())); 2379 } else { 2380 assert(!ReturnType.isNull()); 2381 // "return expression ;" 2382 Builder.AddTypedTextChunk("return"); 2383 Builder.AddChunk(clang::CodeCompletionString::CK_HorizontalSpace); 2384 Builder.AddPlaceholderChunk("expression"); 2385 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 2386 Results.AddResult(Result(Builder.TakeString())); 2387 // When boolean, also add 'return true;' and 'return false;'. 2388 if (ReturnType->isBooleanType()) { 2389 Builder.AddTypedTextChunk("return true"); 2390 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 2391 Results.AddResult(Result(Builder.TakeString())); 2392 2393 Builder.AddTypedTextChunk("return false"); 2394 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 2395 Results.AddResult(Result(Builder.TakeString())); 2396 } 2397 // For pointers, suggest 'return nullptr' in C++. 2398 if (SemaRef.getLangOpts().CPlusPlus11 && 2399 (ReturnType->isPointerType() || ReturnType->isMemberPointerType())) { 2400 Builder.AddTypedTextChunk("return nullptr"); 2401 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 2402 Results.AddResult(Result(Builder.TakeString())); 2403 } 2404 } 2405 2406 // goto identifier ; 2407 Builder.AddTypedTextChunk("goto"); 2408 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2409 Builder.AddPlaceholderChunk("label"); 2410 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 2411 Results.AddResult(Result(Builder.TakeString())); 2412 2413 // Using directives 2414 Builder.AddTypedTextChunk("using namespace"); 2415 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2416 Builder.AddPlaceholderChunk("identifier"); 2417 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 2418 Results.AddResult(Result(Builder.TakeString())); 2419 2420 AddStaticAssertResult(Builder, Results, SemaRef.getLangOpts()); 2421 } 2422 LLVM_FALLTHROUGH; 2423 2424 // Fall through (for statement expressions). 2425 case Sema::PCC_ForInit: 2426 case Sema::PCC_Condition: 2427 AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results); 2428 // Fall through: conditions and statements can have expressions. 2429 LLVM_FALLTHROUGH; 2430 2431 case Sema::PCC_ParenthesizedExpression: 2432 if (SemaRef.getLangOpts().ObjCAutoRefCount && 2433 CCC == Sema::PCC_ParenthesizedExpression) { 2434 // (__bridge <type>)<expression> 2435 Builder.AddTypedTextChunk("__bridge"); 2436 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2437 Builder.AddPlaceholderChunk("type"); 2438 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2439 Builder.AddPlaceholderChunk("expression"); 2440 Results.AddResult(Result(Builder.TakeString())); 2441 2442 // (__bridge_transfer <Objective-C type>)<expression> 2443 Builder.AddTypedTextChunk("__bridge_transfer"); 2444 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2445 Builder.AddPlaceholderChunk("Objective-C type"); 2446 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2447 Builder.AddPlaceholderChunk("expression"); 2448 Results.AddResult(Result(Builder.TakeString())); 2449 2450 // (__bridge_retained <CF type>)<expression> 2451 Builder.AddTypedTextChunk("__bridge_retained"); 2452 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2453 Builder.AddPlaceholderChunk("CF type"); 2454 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2455 Builder.AddPlaceholderChunk("expression"); 2456 Results.AddResult(Result(Builder.TakeString())); 2457 } 2458 // Fall through 2459 LLVM_FALLTHROUGH; 2460 2461 case Sema::PCC_Expression: { 2462 if (SemaRef.getLangOpts().CPlusPlus) { 2463 // 'this', if we're in a non-static member function. 2464 addThisCompletion(SemaRef, Results); 2465 2466 // true 2467 Builder.AddResultTypeChunk("bool"); 2468 Builder.AddTypedTextChunk("true"); 2469 Results.AddResult(Result(Builder.TakeString())); 2470 2471 // false 2472 Builder.AddResultTypeChunk("bool"); 2473 Builder.AddTypedTextChunk("false"); 2474 Results.AddResult(Result(Builder.TakeString())); 2475 2476 if (SemaRef.getLangOpts().RTTI) { 2477 // dynamic_cast < type-id > ( expression ) 2478 Builder.AddTypedTextChunk("dynamic_cast"); 2479 Builder.AddChunk(CodeCompletionString::CK_LeftAngle); 2480 Builder.AddPlaceholderChunk("type"); 2481 Builder.AddChunk(CodeCompletionString::CK_RightAngle); 2482 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2483 Builder.AddPlaceholderChunk("expression"); 2484 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2485 Results.AddResult(Result(Builder.TakeString())); 2486 } 2487 2488 // static_cast < type-id > ( expression ) 2489 Builder.AddTypedTextChunk("static_cast"); 2490 Builder.AddChunk(CodeCompletionString::CK_LeftAngle); 2491 Builder.AddPlaceholderChunk("type"); 2492 Builder.AddChunk(CodeCompletionString::CK_RightAngle); 2493 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2494 Builder.AddPlaceholderChunk("expression"); 2495 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2496 Results.AddResult(Result(Builder.TakeString())); 2497 2498 // reinterpret_cast < type-id > ( expression ) 2499 Builder.AddTypedTextChunk("reinterpret_cast"); 2500 Builder.AddChunk(CodeCompletionString::CK_LeftAngle); 2501 Builder.AddPlaceholderChunk("type"); 2502 Builder.AddChunk(CodeCompletionString::CK_RightAngle); 2503 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2504 Builder.AddPlaceholderChunk("expression"); 2505 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2506 Results.AddResult(Result(Builder.TakeString())); 2507 2508 // const_cast < type-id > ( expression ) 2509 Builder.AddTypedTextChunk("const_cast"); 2510 Builder.AddChunk(CodeCompletionString::CK_LeftAngle); 2511 Builder.AddPlaceholderChunk("type"); 2512 Builder.AddChunk(CodeCompletionString::CK_RightAngle); 2513 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2514 Builder.AddPlaceholderChunk("expression"); 2515 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2516 Results.AddResult(Result(Builder.TakeString())); 2517 2518 if (SemaRef.getLangOpts().RTTI) { 2519 // typeid ( expression-or-type ) 2520 Builder.AddResultTypeChunk("std::type_info"); 2521 Builder.AddTypedTextChunk("typeid"); 2522 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2523 Builder.AddPlaceholderChunk("expression-or-type"); 2524 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2525 Results.AddResult(Result(Builder.TakeString())); 2526 } 2527 2528 // new T ( ... ) 2529 Builder.AddTypedTextChunk("new"); 2530 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2531 Builder.AddPlaceholderChunk("type"); 2532 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2533 Builder.AddPlaceholderChunk("expressions"); 2534 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2535 Results.AddResult(Result(Builder.TakeString())); 2536 2537 // new T [ ] ( ... ) 2538 Builder.AddTypedTextChunk("new"); 2539 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2540 Builder.AddPlaceholderChunk("type"); 2541 Builder.AddChunk(CodeCompletionString::CK_LeftBracket); 2542 Builder.AddPlaceholderChunk("size"); 2543 Builder.AddChunk(CodeCompletionString::CK_RightBracket); 2544 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2545 Builder.AddPlaceholderChunk("expressions"); 2546 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2547 Results.AddResult(Result(Builder.TakeString())); 2548 2549 // delete expression 2550 Builder.AddResultTypeChunk("void"); 2551 Builder.AddTypedTextChunk("delete"); 2552 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2553 Builder.AddPlaceholderChunk("expression"); 2554 Results.AddResult(Result(Builder.TakeString())); 2555 2556 // delete [] expression 2557 Builder.AddResultTypeChunk("void"); 2558 Builder.AddTypedTextChunk("delete"); 2559 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2560 Builder.AddChunk(CodeCompletionString::CK_LeftBracket); 2561 Builder.AddChunk(CodeCompletionString::CK_RightBracket); 2562 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2563 Builder.AddPlaceholderChunk("expression"); 2564 Results.AddResult(Result(Builder.TakeString())); 2565 2566 if (SemaRef.getLangOpts().CXXExceptions) { 2567 // throw expression 2568 Builder.AddResultTypeChunk("void"); 2569 Builder.AddTypedTextChunk("throw"); 2570 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 2571 Builder.AddPlaceholderChunk("expression"); 2572 Results.AddResult(Result(Builder.TakeString())); 2573 } 2574 2575 // FIXME: Rethrow? 2576 2577 if (SemaRef.getLangOpts().CPlusPlus11) { 2578 // nullptr 2579 Builder.AddResultTypeChunk("std::nullptr_t"); 2580 Builder.AddTypedTextChunk("nullptr"); 2581 Results.AddResult(Result(Builder.TakeString())); 2582 2583 // alignof 2584 Builder.AddResultTypeChunk("size_t"); 2585 Builder.AddTypedTextChunk("alignof"); 2586 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2587 Builder.AddPlaceholderChunk("type"); 2588 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2589 Results.AddResult(Result(Builder.TakeString())); 2590 2591 // noexcept 2592 Builder.AddResultTypeChunk("bool"); 2593 Builder.AddTypedTextChunk("noexcept"); 2594 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2595 Builder.AddPlaceholderChunk("expression"); 2596 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2597 Results.AddResult(Result(Builder.TakeString())); 2598 2599 // sizeof... expression 2600 Builder.AddResultTypeChunk("size_t"); 2601 Builder.AddTypedTextChunk("sizeof..."); 2602 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2603 Builder.AddPlaceholderChunk("parameter-pack"); 2604 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2605 Results.AddResult(Result(Builder.TakeString())); 2606 } 2607 } 2608 2609 if (SemaRef.getLangOpts().ObjC) { 2610 // Add "super", if we're in an Objective-C class with a superclass. 2611 if (ObjCMethodDecl *Method = SemaRef.getCurMethodDecl()) { 2612 // The interface can be NULL. 2613 if (ObjCInterfaceDecl *ID = Method->getClassInterface()) 2614 if (ID->getSuperClass()) { 2615 std::string SuperType; 2616 SuperType = ID->getSuperClass()->getNameAsString(); 2617 if (Method->isInstanceMethod()) 2618 SuperType += " *"; 2619 2620 Builder.AddResultTypeChunk(Allocator.CopyString(SuperType)); 2621 Builder.AddTypedTextChunk("super"); 2622 Results.AddResult(Result(Builder.TakeString())); 2623 } 2624 } 2625 2626 AddObjCExpressionResults(Results, true); 2627 } 2628 2629 if (SemaRef.getLangOpts().C11) { 2630 // _Alignof 2631 Builder.AddResultTypeChunk("size_t"); 2632 if (SemaRef.PP.isMacroDefined("alignof")) 2633 Builder.AddTypedTextChunk("alignof"); 2634 else 2635 Builder.AddTypedTextChunk("_Alignof"); 2636 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2637 Builder.AddPlaceholderChunk("type"); 2638 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2639 Results.AddResult(Result(Builder.TakeString())); 2640 } 2641 2642 // sizeof expression 2643 Builder.AddResultTypeChunk("size_t"); 2644 Builder.AddTypedTextChunk("sizeof"); 2645 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 2646 Builder.AddPlaceholderChunk("expression-or-type"); 2647 Builder.AddChunk(CodeCompletionString::CK_RightParen); 2648 Results.AddResult(Result(Builder.TakeString())); 2649 break; 2650 } 2651 2652 case Sema::PCC_Type: 2653 case Sema::PCC_LocalDeclarationSpecifiers: 2654 break; 2655 } 2656 2657 if (WantTypesInContext(CCC, SemaRef.getLangOpts())) 2658 AddTypeSpecifierResults(SemaRef.getLangOpts(), Results); 2659 2660 if (SemaRef.getLangOpts().CPlusPlus && CCC != Sema::PCC_Type) 2661 Results.AddResult(Result("operator")); 2662 } 2663 2664 /// If the given declaration has an associated type, add it as a result 2665 /// type chunk. 2666 static void AddResultTypeChunk(ASTContext &Context, 2667 const PrintingPolicy &Policy, 2668 const NamedDecl *ND, QualType BaseType, 2669 CodeCompletionBuilder &Result) { 2670 if (!ND) 2671 return; 2672 2673 // Skip constructors and conversion functions, which have their return types 2674 // built into their names. 2675 if (isConstructor(ND) || isa<CXXConversionDecl>(ND)) 2676 return; 2677 2678 // Determine the type of the declaration (if it has a type). 2679 QualType T; 2680 if (const FunctionDecl *Function = ND->getAsFunction()) 2681 T = Function->getReturnType(); 2682 else if (const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) { 2683 if (!BaseType.isNull()) 2684 T = Method->getSendResultType(BaseType); 2685 else 2686 T = Method->getReturnType(); 2687 } else if (const auto *Enumerator = dyn_cast<EnumConstantDecl>(ND)) { 2688 T = Context.getTypeDeclType(cast<TypeDecl>(Enumerator->getDeclContext())); 2689 T = clang::TypeName::getFullyQualifiedType(T, Context); 2690 } else if (isa<UnresolvedUsingValueDecl>(ND)) { 2691 /* Do nothing: ignore unresolved using declarations*/ 2692 } else if (const auto *Ivar = dyn_cast<ObjCIvarDecl>(ND)) { 2693 if (!BaseType.isNull()) 2694 T = Ivar->getUsageType(BaseType); 2695 else 2696 T = Ivar->getType(); 2697 } else if (const auto *Value = dyn_cast<ValueDecl>(ND)) { 2698 T = Value->getType(); 2699 } else if (const auto *Property = dyn_cast<ObjCPropertyDecl>(ND)) { 2700 if (!BaseType.isNull()) 2701 T = Property->getUsageType(BaseType); 2702 else 2703 T = Property->getType(); 2704 } 2705 2706 if (T.isNull() || Context.hasSameType(T, Context.DependentTy)) 2707 return; 2708 2709 Result.AddResultTypeChunk( 2710 GetCompletionTypeString(T, Context, Policy, Result.getAllocator())); 2711 } 2712 2713 static void MaybeAddSentinel(Preprocessor &PP, 2714 const NamedDecl *FunctionOrMethod, 2715 CodeCompletionBuilder &Result) { 2716 if (SentinelAttr *Sentinel = FunctionOrMethod->getAttr<SentinelAttr>()) 2717 if (Sentinel->getSentinel() == 0) { 2718 if (PP.getLangOpts().ObjC && PP.isMacroDefined("nil")) 2719 Result.AddTextChunk(", nil"); 2720 else if (PP.isMacroDefined("NULL")) 2721 Result.AddTextChunk(", NULL"); 2722 else 2723 Result.AddTextChunk(", (void*)0"); 2724 } 2725 } 2726 2727 static std::string formatObjCParamQualifiers(unsigned ObjCQuals, 2728 QualType &Type) { 2729 std::string Result; 2730 if (ObjCQuals & Decl::OBJC_TQ_In) 2731 Result += "in "; 2732 else if (ObjCQuals & Decl::OBJC_TQ_Inout) 2733 Result += "inout "; 2734 else if (ObjCQuals & Decl::OBJC_TQ_Out) 2735 Result += "out "; 2736 if (ObjCQuals & Decl::OBJC_TQ_Bycopy) 2737 Result += "bycopy "; 2738 else if (ObjCQuals & Decl::OBJC_TQ_Byref) 2739 Result += "byref "; 2740 if (ObjCQuals & Decl::OBJC_TQ_Oneway) 2741 Result += "oneway "; 2742 if (ObjCQuals & Decl::OBJC_TQ_CSNullability) { 2743 if (auto nullability = AttributedType::stripOuterNullability(Type)) { 2744 switch (*nullability) { 2745 case NullabilityKind::NonNull: 2746 Result += "nonnull "; 2747 break; 2748 2749 case NullabilityKind::Nullable: 2750 Result += "nullable "; 2751 break; 2752 2753 case NullabilityKind::Unspecified: 2754 Result += "null_unspecified "; 2755 break; 2756 2757 case NullabilityKind::NullableResult: 2758 llvm_unreachable("Not supported as a context-sensitive keyword!"); 2759 break; 2760 } 2761 } 2762 } 2763 return Result; 2764 } 2765 2766 /// Tries to find the most appropriate type location for an Objective-C 2767 /// block placeholder. 2768 /// 2769 /// This function ignores things like typedefs and qualifiers in order to 2770 /// present the most relevant and accurate block placeholders in code completion 2771 /// results. 2772 static void findTypeLocationForBlockDecl(const TypeSourceInfo *TSInfo, 2773 FunctionTypeLoc &Block, 2774 FunctionProtoTypeLoc &BlockProto, 2775 bool SuppressBlock = false) { 2776 if (!TSInfo) 2777 return; 2778 TypeLoc TL = TSInfo->getTypeLoc().getUnqualifiedLoc(); 2779 while (true) { 2780 // Look through typedefs. 2781 if (!SuppressBlock) { 2782 if (TypedefTypeLoc TypedefTL = TL.getAs<TypedefTypeLoc>()) { 2783 if (TypeSourceInfo *InnerTSInfo = 2784 TypedefTL.getTypedefNameDecl()->getTypeSourceInfo()) { 2785 TL = InnerTSInfo->getTypeLoc().getUnqualifiedLoc(); 2786 continue; 2787 } 2788 } 2789 2790 // Look through qualified types 2791 if (QualifiedTypeLoc QualifiedTL = TL.getAs<QualifiedTypeLoc>()) { 2792 TL = QualifiedTL.getUnqualifiedLoc(); 2793 continue; 2794 } 2795 2796 if (AttributedTypeLoc AttrTL = TL.getAs<AttributedTypeLoc>()) { 2797 TL = AttrTL.getModifiedLoc(); 2798 continue; 2799 } 2800 } 2801 2802 // Try to get the function prototype behind the block pointer type, 2803 // then we're done. 2804 if (BlockPointerTypeLoc BlockPtr = TL.getAs<BlockPointerTypeLoc>()) { 2805 TL = BlockPtr.getPointeeLoc().IgnoreParens(); 2806 Block = TL.getAs<FunctionTypeLoc>(); 2807 BlockProto = TL.getAs<FunctionProtoTypeLoc>(); 2808 } 2809 break; 2810 } 2811 } 2812 2813 static std::string 2814 formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl, 2815 FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto, 2816 bool SuppressBlockName = false, 2817 bool SuppressBlock = false, 2818 Optional<ArrayRef<QualType>> ObjCSubsts = None); 2819 2820 static std::string 2821 FormatFunctionParameter(const PrintingPolicy &Policy, 2822 const DeclaratorDecl *Param, bool SuppressName = false, 2823 bool SuppressBlock = false, 2824 Optional<ArrayRef<QualType>> ObjCSubsts = None) { 2825 // Params are unavailable in FunctionTypeLoc if the FunctionType is invalid. 2826 // It would be better to pass in the param Type, which is usually available. 2827 // But this case is rare, so just pretend we fell back to int as elsewhere. 2828 if (!Param) 2829 return "int"; 2830 Decl::ObjCDeclQualifier ObjCQual = Decl::OBJC_TQ_None; 2831 if (const auto *PVD = dyn_cast<ParmVarDecl>(Param)) 2832 ObjCQual = PVD->getObjCDeclQualifier(); 2833 bool ObjCMethodParam = isa<ObjCMethodDecl>(Param->getDeclContext()); 2834 if (Param->getType()->isDependentType() || 2835 !Param->getType()->isBlockPointerType()) { 2836 // The argument for a dependent or non-block parameter is a placeholder 2837 // containing that parameter's type. 2838 std::string Result; 2839 2840 if (Param->getIdentifier() && !ObjCMethodParam && !SuppressName) 2841 Result = std::string(Param->getIdentifier()->deuglifiedName()); 2842 2843 QualType Type = Param->getType(); 2844 if (ObjCSubsts) 2845 Type = Type.substObjCTypeArgs(Param->getASTContext(), *ObjCSubsts, 2846 ObjCSubstitutionContext::Parameter); 2847 if (ObjCMethodParam) { 2848 Result = "(" + formatObjCParamQualifiers(ObjCQual, Type); 2849 Result += Type.getAsString(Policy) + ")"; 2850 if (Param->getIdentifier() && !SuppressName) 2851 Result += Param->getIdentifier()->deuglifiedName(); 2852 } else { 2853 Type.getAsStringInternal(Result, Policy); 2854 } 2855 return Result; 2856 } 2857 2858 // The argument for a block pointer parameter is a block literal with 2859 // the appropriate type. 2860 FunctionTypeLoc Block; 2861 FunctionProtoTypeLoc BlockProto; 2862 findTypeLocationForBlockDecl(Param->getTypeSourceInfo(), Block, BlockProto, 2863 SuppressBlock); 2864 // Try to retrieve the block type information from the property if this is a 2865 // parameter in a setter. 2866 if (!Block && ObjCMethodParam && 2867 cast<ObjCMethodDecl>(Param->getDeclContext())->isPropertyAccessor()) { 2868 if (const auto *PD = cast<ObjCMethodDecl>(Param->getDeclContext()) 2869 ->findPropertyDecl(/*CheckOverrides=*/false)) 2870 findTypeLocationForBlockDecl(PD->getTypeSourceInfo(), Block, BlockProto, 2871 SuppressBlock); 2872 } 2873 2874 if (!Block) { 2875 // We were unable to find a FunctionProtoTypeLoc with parameter names 2876 // for the block; just use the parameter type as a placeholder. 2877 std::string Result; 2878 if (!ObjCMethodParam && Param->getIdentifier()) 2879 Result = std::string(Param->getIdentifier()->deuglifiedName()); 2880 2881 QualType Type = Param->getType().getUnqualifiedType(); 2882 2883 if (ObjCMethodParam) { 2884 Result = Type.getAsString(Policy); 2885 std::string Quals = formatObjCParamQualifiers(ObjCQual, Type); 2886 if (!Quals.empty()) 2887 Result = "(" + Quals + " " + Result + ")"; 2888 if (Result.back() != ')') 2889 Result += " "; 2890 if (Param->getIdentifier()) 2891 Result += Param->getIdentifier()->deuglifiedName(); 2892 } else { 2893 Type.getAsStringInternal(Result, Policy); 2894 } 2895 2896 return Result; 2897 } 2898 2899 // We have the function prototype behind the block pointer type, as it was 2900 // written in the source. 2901 return formatBlockPlaceholder(Policy, Param, Block, BlockProto, 2902 /*SuppressBlockName=*/false, SuppressBlock, 2903 ObjCSubsts); 2904 } 2905 2906 /// Returns a placeholder string that corresponds to an Objective-C block 2907 /// declaration. 2908 /// 2909 /// \param BlockDecl A declaration with an Objective-C block type. 2910 /// 2911 /// \param Block The most relevant type location for that block type. 2912 /// 2913 /// \param SuppressBlockName Determines whether or not the name of the block 2914 /// declaration is included in the resulting string. 2915 static std::string 2916 formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl, 2917 FunctionTypeLoc &Block, FunctionProtoTypeLoc &BlockProto, 2918 bool SuppressBlockName, bool SuppressBlock, 2919 Optional<ArrayRef<QualType>> ObjCSubsts) { 2920 std::string Result; 2921 QualType ResultType = Block.getTypePtr()->getReturnType(); 2922 if (ObjCSubsts) 2923 ResultType = 2924 ResultType.substObjCTypeArgs(BlockDecl->getASTContext(), *ObjCSubsts, 2925 ObjCSubstitutionContext::Result); 2926 if (!ResultType->isVoidType() || SuppressBlock) 2927 ResultType.getAsStringInternal(Result, Policy); 2928 2929 // Format the parameter list. 2930 std::string Params; 2931 if (!BlockProto || Block.getNumParams() == 0) { 2932 if (BlockProto && BlockProto.getTypePtr()->isVariadic()) 2933 Params = "(...)"; 2934 else 2935 Params = "(void)"; 2936 } else { 2937 Params += "("; 2938 for (unsigned I = 0, N = Block.getNumParams(); I != N; ++I) { 2939 if (I) 2940 Params += ", "; 2941 Params += FormatFunctionParameter(Policy, Block.getParam(I), 2942 /*SuppressName=*/false, 2943 /*SuppressBlock=*/true, ObjCSubsts); 2944 2945 if (I == N - 1 && BlockProto.getTypePtr()->isVariadic()) 2946 Params += ", ..."; 2947 } 2948 Params += ")"; 2949 } 2950 2951 if (SuppressBlock) { 2952 // Format as a parameter. 2953 Result = Result + " (^"; 2954 if (!SuppressBlockName && BlockDecl->getIdentifier()) 2955 Result += BlockDecl->getIdentifier()->getName(); 2956 Result += ")"; 2957 Result += Params; 2958 } else { 2959 // Format as a block literal argument. 2960 Result = '^' + Result; 2961 Result += Params; 2962 2963 if (!SuppressBlockName && BlockDecl->getIdentifier()) 2964 Result += BlockDecl->getIdentifier()->getName(); 2965 } 2966 2967 return Result; 2968 } 2969 2970 static std::string GetDefaultValueString(const ParmVarDecl *Param, 2971 const SourceManager &SM, 2972 const LangOptions &LangOpts) { 2973 const SourceRange SrcRange = Param->getDefaultArgRange(); 2974 CharSourceRange CharSrcRange = CharSourceRange::getTokenRange(SrcRange); 2975 bool Invalid = CharSrcRange.isInvalid(); 2976 if (Invalid) 2977 return ""; 2978 StringRef srcText = 2979 Lexer::getSourceText(CharSrcRange, SM, LangOpts, &Invalid); 2980 if (Invalid) 2981 return ""; 2982 2983 if (srcText.empty() || srcText == "=") { 2984 // Lexer can't determine the value. 2985 // This happens if the code is incorrect (for example class is forward 2986 // declared). 2987 return ""; 2988 } 2989 std::string DefValue(srcText.str()); 2990 // FIXME: remove this check if the Lexer::getSourceText value is fixed and 2991 // this value always has (or always does not have) '=' in front of it 2992 if (DefValue.at(0) != '=') { 2993 // If we don't have '=' in front of value. 2994 // Lexer returns built-in types values without '=' and user-defined types 2995 // values with it. 2996 return " = " + DefValue; 2997 } 2998 return " " + DefValue; 2999 } 3000 3001 /// Add function parameter chunks to the given code completion string. 3002 static void AddFunctionParameterChunks(Preprocessor &PP, 3003 const PrintingPolicy &Policy, 3004 const FunctionDecl *Function, 3005 CodeCompletionBuilder &Result, 3006 unsigned Start = 0, 3007 bool InOptional = false) { 3008 bool FirstParameter = true; 3009 3010 for (unsigned P = Start, N = Function->getNumParams(); P != N; ++P) { 3011 const ParmVarDecl *Param = Function->getParamDecl(P); 3012 3013 if (Param->hasDefaultArg() && !InOptional) { 3014 // When we see an optional default argument, put that argument and 3015 // the remaining default arguments into a new, optional string. 3016 CodeCompletionBuilder Opt(Result.getAllocator(), 3017 Result.getCodeCompletionTUInfo()); 3018 if (!FirstParameter) 3019 Opt.AddChunk(CodeCompletionString::CK_Comma); 3020 AddFunctionParameterChunks(PP, Policy, Function, Opt, P, true); 3021 Result.AddOptionalChunk(Opt.TakeString()); 3022 break; 3023 } 3024 3025 if (FirstParameter) 3026 FirstParameter = false; 3027 else 3028 Result.AddChunk(CodeCompletionString::CK_Comma); 3029 3030 InOptional = false; 3031 3032 // Format the placeholder string. 3033 std::string PlaceholderStr = FormatFunctionParameter(Policy, Param); 3034 if (Param->hasDefaultArg()) 3035 PlaceholderStr += 3036 GetDefaultValueString(Param, PP.getSourceManager(), PP.getLangOpts()); 3037 3038 if (Function->isVariadic() && P == N - 1) 3039 PlaceholderStr += ", ..."; 3040 3041 // Add the placeholder string. 3042 Result.AddPlaceholderChunk( 3043 Result.getAllocator().CopyString(PlaceholderStr)); 3044 } 3045 3046 if (const auto *Proto = Function->getType()->getAs<FunctionProtoType>()) 3047 if (Proto->isVariadic()) { 3048 if (Proto->getNumParams() == 0) 3049 Result.AddPlaceholderChunk("..."); 3050 3051 MaybeAddSentinel(PP, Function, Result); 3052 } 3053 } 3054 3055 /// Add template parameter chunks to the given code completion string. 3056 static void AddTemplateParameterChunks( 3057 ASTContext &Context, const PrintingPolicy &Policy, 3058 const TemplateDecl *Template, CodeCompletionBuilder &Result, 3059 unsigned MaxParameters = 0, unsigned Start = 0, bool InDefaultArg = false) { 3060 bool FirstParameter = true; 3061 3062 // Prefer to take the template parameter names from the first declaration of 3063 // the template. 3064 Template = cast<TemplateDecl>(Template->getCanonicalDecl()); 3065 3066 TemplateParameterList *Params = Template->getTemplateParameters(); 3067 TemplateParameterList::iterator PEnd = Params->end(); 3068 if (MaxParameters) 3069 PEnd = Params->begin() + MaxParameters; 3070 for (TemplateParameterList::iterator P = Params->begin() + Start; P != PEnd; 3071 ++P) { 3072 bool HasDefaultArg = false; 3073 std::string PlaceholderStr; 3074 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*P)) { 3075 if (TTP->wasDeclaredWithTypename()) 3076 PlaceholderStr = "typename"; 3077 else if (const auto *TC = TTP->getTypeConstraint()) { 3078 llvm::raw_string_ostream OS(PlaceholderStr); 3079 TC->print(OS, Policy); 3080 OS.flush(); 3081 } else 3082 PlaceholderStr = "class"; 3083 3084 if (TTP->getIdentifier()) { 3085 PlaceholderStr += ' '; 3086 PlaceholderStr += TTP->getIdentifier()->deuglifiedName(); 3087 } 3088 3089 HasDefaultArg = TTP->hasDefaultArgument(); 3090 } else if (NonTypeTemplateParmDecl *NTTP = 3091 dyn_cast<NonTypeTemplateParmDecl>(*P)) { 3092 if (NTTP->getIdentifier()) 3093 PlaceholderStr = std::string(NTTP->getIdentifier()->deuglifiedName()); 3094 NTTP->getType().getAsStringInternal(PlaceholderStr, Policy); 3095 HasDefaultArg = NTTP->hasDefaultArgument(); 3096 } else { 3097 assert(isa<TemplateTemplateParmDecl>(*P)); 3098 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P); 3099 3100 // Since putting the template argument list into the placeholder would 3101 // be very, very long, we just use an abbreviation. 3102 PlaceholderStr = "template<...> class"; 3103 if (TTP->getIdentifier()) { 3104 PlaceholderStr += ' '; 3105 PlaceholderStr += TTP->getIdentifier()->deuglifiedName(); 3106 } 3107 3108 HasDefaultArg = TTP->hasDefaultArgument(); 3109 } 3110 3111 if (HasDefaultArg && !InDefaultArg) { 3112 // When we see an optional default argument, put that argument and 3113 // the remaining default arguments into a new, optional string. 3114 CodeCompletionBuilder Opt(Result.getAllocator(), 3115 Result.getCodeCompletionTUInfo()); 3116 if (!FirstParameter) 3117 Opt.AddChunk(CodeCompletionString::CK_Comma); 3118 AddTemplateParameterChunks(Context, Policy, Template, Opt, MaxParameters, 3119 P - Params->begin(), true); 3120 Result.AddOptionalChunk(Opt.TakeString()); 3121 break; 3122 } 3123 3124 InDefaultArg = false; 3125 3126 if (FirstParameter) 3127 FirstParameter = false; 3128 else 3129 Result.AddChunk(CodeCompletionString::CK_Comma); 3130 3131 // Add the placeholder string. 3132 Result.AddPlaceholderChunk( 3133 Result.getAllocator().CopyString(PlaceholderStr)); 3134 } 3135 } 3136 3137 /// Add a qualifier to the given code-completion string, if the 3138 /// provided nested-name-specifier is non-NULL. 3139 static void AddQualifierToCompletionString(CodeCompletionBuilder &Result, 3140 NestedNameSpecifier *Qualifier, 3141 bool QualifierIsInformative, 3142 ASTContext &Context, 3143 const PrintingPolicy &Policy) { 3144 if (!Qualifier) 3145 return; 3146 3147 std::string PrintedNNS; 3148 { 3149 llvm::raw_string_ostream OS(PrintedNNS); 3150 Qualifier->print(OS, Policy); 3151 } 3152 if (QualifierIsInformative) 3153 Result.AddInformativeChunk(Result.getAllocator().CopyString(PrintedNNS)); 3154 else 3155 Result.AddTextChunk(Result.getAllocator().CopyString(PrintedNNS)); 3156 } 3157 3158 static void 3159 AddFunctionTypeQualsToCompletionString(CodeCompletionBuilder &Result, 3160 const FunctionDecl *Function) { 3161 const auto *Proto = Function->getType()->getAs<FunctionProtoType>(); 3162 if (!Proto || !Proto->getMethodQuals()) 3163 return; 3164 3165 // FIXME: Add ref-qualifier! 3166 3167 // Handle single qualifiers without copying 3168 if (Proto->getMethodQuals().hasOnlyConst()) { 3169 Result.AddInformativeChunk(" const"); 3170 return; 3171 } 3172 3173 if (Proto->getMethodQuals().hasOnlyVolatile()) { 3174 Result.AddInformativeChunk(" volatile"); 3175 return; 3176 } 3177 3178 if (Proto->getMethodQuals().hasOnlyRestrict()) { 3179 Result.AddInformativeChunk(" restrict"); 3180 return; 3181 } 3182 3183 // Handle multiple qualifiers. 3184 std::string QualsStr; 3185 if (Proto->isConst()) 3186 QualsStr += " const"; 3187 if (Proto->isVolatile()) 3188 QualsStr += " volatile"; 3189 if (Proto->isRestrict()) 3190 QualsStr += " restrict"; 3191 Result.AddInformativeChunk(Result.getAllocator().CopyString(QualsStr)); 3192 } 3193 3194 /// Add the name of the given declaration 3195 static void AddTypedNameChunk(ASTContext &Context, const PrintingPolicy &Policy, 3196 const NamedDecl *ND, 3197 CodeCompletionBuilder &Result) { 3198 DeclarationName Name = ND->getDeclName(); 3199 if (!Name) 3200 return; 3201 3202 switch (Name.getNameKind()) { 3203 case DeclarationName::CXXOperatorName: { 3204 const char *OperatorName = nullptr; 3205 switch (Name.getCXXOverloadedOperator()) { 3206 case OO_None: 3207 case OO_Conditional: 3208 case NUM_OVERLOADED_OPERATORS: 3209 OperatorName = "operator"; 3210 break; 3211 3212 #define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \ 3213 case OO_##Name: \ 3214 OperatorName = "operator" Spelling; \ 3215 break; 3216 #define OVERLOADED_OPERATOR_MULTI(Name, Spelling, Unary, Binary, MemberOnly) 3217 #include "clang/Basic/OperatorKinds.def" 3218 3219 case OO_New: 3220 OperatorName = "operator new"; 3221 break; 3222 case OO_Delete: 3223 OperatorName = "operator delete"; 3224 break; 3225 case OO_Array_New: 3226 OperatorName = "operator new[]"; 3227 break; 3228 case OO_Array_Delete: 3229 OperatorName = "operator delete[]"; 3230 break; 3231 case OO_Call: 3232 OperatorName = "operator()"; 3233 break; 3234 case OO_Subscript: 3235 OperatorName = "operator[]"; 3236 break; 3237 } 3238 Result.AddTypedTextChunk(OperatorName); 3239 break; 3240 } 3241 3242 case DeclarationName::Identifier: 3243 case DeclarationName::CXXConversionFunctionName: 3244 case DeclarationName::CXXDestructorName: 3245 case DeclarationName::CXXLiteralOperatorName: 3246 Result.AddTypedTextChunk( 3247 Result.getAllocator().CopyString(ND->getNameAsString())); 3248 break; 3249 3250 case DeclarationName::CXXDeductionGuideName: 3251 case DeclarationName::CXXUsingDirective: 3252 case DeclarationName::ObjCZeroArgSelector: 3253 case DeclarationName::ObjCOneArgSelector: 3254 case DeclarationName::ObjCMultiArgSelector: 3255 break; 3256 3257 case DeclarationName::CXXConstructorName: { 3258 CXXRecordDecl *Record = nullptr; 3259 QualType Ty = Name.getCXXNameType(); 3260 if (const auto *RecordTy = Ty->getAs<RecordType>()) 3261 Record = cast<CXXRecordDecl>(RecordTy->getDecl()); 3262 else if (const auto *InjectedTy = Ty->getAs<InjectedClassNameType>()) 3263 Record = InjectedTy->getDecl(); 3264 else { 3265 Result.AddTypedTextChunk( 3266 Result.getAllocator().CopyString(ND->getNameAsString())); 3267 break; 3268 } 3269 3270 Result.AddTypedTextChunk( 3271 Result.getAllocator().CopyString(Record->getNameAsString())); 3272 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) { 3273 Result.AddChunk(CodeCompletionString::CK_LeftAngle); 3274 AddTemplateParameterChunks(Context, Policy, Template, Result); 3275 Result.AddChunk(CodeCompletionString::CK_RightAngle); 3276 } 3277 break; 3278 } 3279 } 3280 } 3281 3282 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString( 3283 Sema &S, const CodeCompletionContext &CCContext, 3284 CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo, 3285 bool IncludeBriefComments) { 3286 return CreateCodeCompletionString(S.Context, S.PP, CCContext, Allocator, 3287 CCTUInfo, IncludeBriefComments); 3288 } 3289 3290 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionStringForMacro( 3291 Preprocessor &PP, CodeCompletionAllocator &Allocator, 3292 CodeCompletionTUInfo &CCTUInfo) { 3293 assert(Kind == RK_Macro); 3294 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability); 3295 const MacroInfo *MI = PP.getMacroInfo(Macro); 3296 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Macro->getName())); 3297 3298 if (!MI || !MI->isFunctionLike()) 3299 return Result.TakeString(); 3300 3301 // Format a function-like macro with placeholders for the arguments. 3302 Result.AddChunk(CodeCompletionString::CK_LeftParen); 3303 MacroInfo::param_iterator A = MI->param_begin(), AEnd = MI->param_end(); 3304 3305 // C99 variadic macros add __VA_ARGS__ at the end. Skip it. 3306 if (MI->isC99Varargs()) { 3307 --AEnd; 3308 3309 if (A == AEnd) { 3310 Result.AddPlaceholderChunk("..."); 3311 } 3312 } 3313 3314 for (MacroInfo::param_iterator A = MI->param_begin(); A != AEnd; ++A) { 3315 if (A != MI->param_begin()) 3316 Result.AddChunk(CodeCompletionString::CK_Comma); 3317 3318 if (MI->isVariadic() && (A + 1) == AEnd) { 3319 SmallString<32> Arg = (*A)->getName(); 3320 if (MI->isC99Varargs()) 3321 Arg += ", ..."; 3322 else 3323 Arg += "..."; 3324 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg)); 3325 break; 3326 } 3327 3328 // Non-variadic macros are simple. 3329 Result.AddPlaceholderChunk( 3330 Result.getAllocator().CopyString((*A)->getName())); 3331 } 3332 Result.AddChunk(CodeCompletionString::CK_RightParen); 3333 return Result.TakeString(); 3334 } 3335 3336 /// If possible, create a new code completion string for the given 3337 /// result. 3338 /// 3339 /// \returns Either a new, heap-allocated code completion string describing 3340 /// how to use this result, or NULL to indicate that the string or name of the 3341 /// result is all that is needed. 3342 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString( 3343 ASTContext &Ctx, Preprocessor &PP, const CodeCompletionContext &CCContext, 3344 CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo, 3345 bool IncludeBriefComments) { 3346 if (Kind == RK_Macro) 3347 return CreateCodeCompletionStringForMacro(PP, Allocator, CCTUInfo); 3348 3349 CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability); 3350 3351 PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP); 3352 if (Kind == RK_Pattern) { 3353 Pattern->Priority = Priority; 3354 Pattern->Availability = Availability; 3355 3356 if (Declaration) { 3357 Result.addParentContext(Declaration->getDeclContext()); 3358 Pattern->ParentName = Result.getParentName(); 3359 if (const RawComment *RC = 3360 getPatternCompletionComment(Ctx, Declaration)) { 3361 Result.addBriefComment(RC->getBriefText(Ctx)); 3362 Pattern->BriefComment = Result.getBriefComment(); 3363 } 3364 } 3365 3366 return Pattern; 3367 } 3368 3369 if (Kind == RK_Keyword) { 3370 Result.AddTypedTextChunk(Keyword); 3371 return Result.TakeString(); 3372 } 3373 assert(Kind == RK_Declaration && "Missed a result kind?"); 3374 return createCodeCompletionStringForDecl( 3375 PP, Ctx, Result, IncludeBriefComments, CCContext, Policy); 3376 } 3377 3378 static void printOverrideString(const CodeCompletionString &CCS, 3379 std::string &BeforeName, 3380 std::string &NameAndSignature) { 3381 bool SeenTypedChunk = false; 3382 for (auto &Chunk : CCS) { 3383 if (Chunk.Kind == CodeCompletionString::CK_Optional) { 3384 assert(SeenTypedChunk && "optional parameter before name"); 3385 // Note that we put all chunks inside into NameAndSignature. 3386 printOverrideString(*Chunk.Optional, NameAndSignature, NameAndSignature); 3387 continue; 3388 } 3389 SeenTypedChunk |= Chunk.Kind == CodeCompletionString::CK_TypedText; 3390 if (SeenTypedChunk) 3391 NameAndSignature += Chunk.Text; 3392 else 3393 BeforeName += Chunk.Text; 3394 } 3395 } 3396 3397 CodeCompletionString * 3398 CodeCompletionResult::createCodeCompletionStringForOverride( 3399 Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result, 3400 bool IncludeBriefComments, const CodeCompletionContext &CCContext, 3401 PrintingPolicy &Policy) { 3402 auto *CCS = createCodeCompletionStringForDecl(PP, Ctx, Result, 3403 /*IncludeBriefComments=*/false, 3404 CCContext, Policy); 3405 std::string BeforeName; 3406 std::string NameAndSignature; 3407 // For overrides all chunks go into the result, none are informative. 3408 printOverrideString(*CCS, BeforeName, NameAndSignature); 3409 NameAndSignature += " override"; 3410 3411 Result.AddTextChunk(Result.getAllocator().CopyString(BeforeName)); 3412 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace); 3413 Result.AddTypedTextChunk(Result.getAllocator().CopyString(NameAndSignature)); 3414 return Result.TakeString(); 3415 } 3416 3417 // FIXME: Right now this works well with lambdas. Add support for other functor 3418 // types like std::function. 3419 static const NamedDecl *extractFunctorCallOperator(const NamedDecl *ND) { 3420 const auto *VD = dyn_cast<VarDecl>(ND); 3421 if (!VD) 3422 return nullptr; 3423 const auto *RecordDecl = VD->getType()->getAsCXXRecordDecl(); 3424 if (!RecordDecl || !RecordDecl->isLambda()) 3425 return nullptr; 3426 return RecordDecl->getLambdaCallOperator(); 3427 } 3428 3429 CodeCompletionString *CodeCompletionResult::createCodeCompletionStringForDecl( 3430 Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result, 3431 bool IncludeBriefComments, const CodeCompletionContext &CCContext, 3432 PrintingPolicy &Policy) { 3433 const NamedDecl *ND = Declaration; 3434 Result.addParentContext(ND->getDeclContext()); 3435 3436 if (IncludeBriefComments) { 3437 // Add documentation comment, if it exists. 3438 if (const RawComment *RC = getCompletionComment(Ctx, Declaration)) { 3439 Result.addBriefComment(RC->getBriefText(Ctx)); 3440 } 3441 } 3442 3443 if (StartsNestedNameSpecifier) { 3444 Result.AddTypedTextChunk( 3445 Result.getAllocator().CopyString(ND->getNameAsString())); 3446 Result.AddTextChunk("::"); 3447 return Result.TakeString(); 3448 } 3449 3450 for (const auto *I : ND->specific_attrs<AnnotateAttr>()) 3451 Result.AddAnnotation(Result.getAllocator().CopyString(I->getAnnotation())); 3452 3453 auto AddFunctionTypeAndResult = [&](const FunctionDecl *Function) { 3454 AddResultTypeChunk(Ctx, Policy, Function, CCContext.getBaseType(), Result); 3455 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, 3456 Ctx, Policy); 3457 AddTypedNameChunk(Ctx, Policy, ND, Result); 3458 Result.AddChunk(CodeCompletionString::CK_LeftParen); 3459 AddFunctionParameterChunks(PP, Policy, Function, Result); 3460 Result.AddChunk(CodeCompletionString::CK_RightParen); 3461 AddFunctionTypeQualsToCompletionString(Result, Function); 3462 }; 3463 3464 if (const auto *Function = dyn_cast<FunctionDecl>(ND)) { 3465 AddFunctionTypeAndResult(Function); 3466 return Result.TakeString(); 3467 } 3468 3469 if (const auto *CallOperator = 3470 dyn_cast_or_null<FunctionDecl>(extractFunctorCallOperator(ND))) { 3471 AddFunctionTypeAndResult(CallOperator); 3472 return Result.TakeString(); 3473 } 3474 3475 AddResultTypeChunk(Ctx, Policy, ND, CCContext.getBaseType(), Result); 3476 3477 if (const FunctionTemplateDecl *FunTmpl = 3478 dyn_cast<FunctionTemplateDecl>(ND)) { 3479 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, 3480 Ctx, Policy); 3481 FunctionDecl *Function = FunTmpl->getTemplatedDecl(); 3482 AddTypedNameChunk(Ctx, Policy, Function, Result); 3483 3484 // Figure out which template parameters are deduced (or have default 3485 // arguments). 3486 llvm::SmallBitVector Deduced; 3487 Sema::MarkDeducedTemplateParameters(Ctx, FunTmpl, Deduced); 3488 unsigned LastDeducibleArgument; 3489 for (LastDeducibleArgument = Deduced.size(); LastDeducibleArgument > 0; 3490 --LastDeducibleArgument) { 3491 if (!Deduced[LastDeducibleArgument - 1]) { 3492 // C++0x: Figure out if the template argument has a default. If so, 3493 // the user doesn't need to type this argument. 3494 // FIXME: We need to abstract template parameters better! 3495 bool HasDefaultArg = false; 3496 NamedDecl *Param = FunTmpl->getTemplateParameters()->getParam( 3497 LastDeducibleArgument - 1); 3498 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) 3499 HasDefaultArg = TTP->hasDefaultArgument(); 3500 else if (NonTypeTemplateParmDecl *NTTP = 3501 dyn_cast<NonTypeTemplateParmDecl>(Param)) 3502 HasDefaultArg = NTTP->hasDefaultArgument(); 3503 else { 3504 assert(isa<TemplateTemplateParmDecl>(Param)); 3505 HasDefaultArg = 3506 cast<TemplateTemplateParmDecl>(Param)->hasDefaultArgument(); 3507 } 3508 3509 if (!HasDefaultArg) 3510 break; 3511 } 3512 } 3513 3514 if (LastDeducibleArgument) { 3515 // Some of the function template arguments cannot be deduced from a 3516 // function call, so we introduce an explicit template argument list 3517 // containing all of the arguments up to the first deducible argument. 3518 Result.AddChunk(CodeCompletionString::CK_LeftAngle); 3519 AddTemplateParameterChunks(Ctx, Policy, FunTmpl, Result, 3520 LastDeducibleArgument); 3521 Result.AddChunk(CodeCompletionString::CK_RightAngle); 3522 } 3523 3524 // Add the function parameters 3525 Result.AddChunk(CodeCompletionString::CK_LeftParen); 3526 AddFunctionParameterChunks(PP, Policy, Function, Result); 3527 Result.AddChunk(CodeCompletionString::CK_RightParen); 3528 AddFunctionTypeQualsToCompletionString(Result, Function); 3529 return Result.TakeString(); 3530 } 3531 3532 if (const auto *Template = dyn_cast<TemplateDecl>(ND)) { 3533 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, 3534 Ctx, Policy); 3535 Result.AddTypedTextChunk( 3536 Result.getAllocator().CopyString(Template->getNameAsString())); 3537 Result.AddChunk(CodeCompletionString::CK_LeftAngle); 3538 AddTemplateParameterChunks(Ctx, Policy, Template, Result); 3539 Result.AddChunk(CodeCompletionString::CK_RightAngle); 3540 return Result.TakeString(); 3541 } 3542 3543 if (const auto *Method = dyn_cast<ObjCMethodDecl>(ND)) { 3544 Selector Sel = Method->getSelector(); 3545 if (Sel.isUnarySelector()) { 3546 Result.AddTypedTextChunk( 3547 Result.getAllocator().CopyString(Sel.getNameForSlot(0))); 3548 return Result.TakeString(); 3549 } 3550 3551 std::string SelName = Sel.getNameForSlot(0).str(); 3552 SelName += ':'; 3553 if (StartParameter == 0) 3554 Result.AddTypedTextChunk(Result.getAllocator().CopyString(SelName)); 3555 else { 3556 Result.AddInformativeChunk(Result.getAllocator().CopyString(SelName)); 3557 3558 // If there is only one parameter, and we're past it, add an empty 3559 // typed-text chunk since there is nothing to type. 3560 if (Method->param_size() == 1) 3561 Result.AddTypedTextChunk(""); 3562 } 3563 unsigned Idx = 0; 3564 // The extra Idx < Sel.getNumArgs() check is needed due to legacy C-style 3565 // method parameters. 3566 for (ObjCMethodDecl::param_const_iterator P = Method->param_begin(), 3567 PEnd = Method->param_end(); 3568 P != PEnd && Idx < Sel.getNumArgs(); (void)++P, ++Idx) { 3569 if (Idx > 0) { 3570 std::string Keyword; 3571 if (Idx > StartParameter) 3572 Result.AddChunk(CodeCompletionString::CK_HorizontalSpace); 3573 if (IdentifierInfo *II = Sel.getIdentifierInfoForSlot(Idx)) 3574 Keyword += II->getName(); 3575 Keyword += ":"; 3576 if (Idx < StartParameter || AllParametersAreInformative) 3577 Result.AddInformativeChunk(Result.getAllocator().CopyString(Keyword)); 3578 else 3579 Result.AddTypedTextChunk(Result.getAllocator().CopyString(Keyword)); 3580 } 3581 3582 // If we're before the starting parameter, skip the placeholder. 3583 if (Idx < StartParameter) 3584 continue; 3585 3586 std::string Arg; 3587 QualType ParamType = (*P)->getType(); 3588 Optional<ArrayRef<QualType>> ObjCSubsts; 3589 if (!CCContext.getBaseType().isNull()) 3590 ObjCSubsts = CCContext.getBaseType()->getObjCSubstitutions(Method); 3591 3592 if (ParamType->isBlockPointerType() && !DeclaringEntity) 3593 Arg = FormatFunctionParameter(Policy, *P, true, 3594 /*SuppressBlock=*/false, ObjCSubsts); 3595 else { 3596 if (ObjCSubsts) 3597 ParamType = ParamType.substObjCTypeArgs( 3598 Ctx, *ObjCSubsts, ObjCSubstitutionContext::Parameter); 3599 Arg = "(" + formatObjCParamQualifiers((*P)->getObjCDeclQualifier(), 3600 ParamType); 3601 Arg += ParamType.getAsString(Policy) + ")"; 3602 if (IdentifierInfo *II = (*P)->getIdentifier()) 3603 if (DeclaringEntity || AllParametersAreInformative) 3604 Arg += II->getName(); 3605 } 3606 3607 if (Method->isVariadic() && (P + 1) == PEnd) 3608 Arg += ", ..."; 3609 3610 if (DeclaringEntity) 3611 Result.AddTextChunk(Result.getAllocator().CopyString(Arg)); 3612 else if (AllParametersAreInformative) 3613 Result.AddInformativeChunk(Result.getAllocator().CopyString(Arg)); 3614 else 3615 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Arg)); 3616 } 3617 3618 if (Method->isVariadic()) { 3619 if (Method->param_size() == 0) { 3620 if (DeclaringEntity) 3621 Result.AddTextChunk(", ..."); 3622 else if (AllParametersAreInformative) 3623 Result.AddInformativeChunk(", ..."); 3624 else 3625 Result.AddPlaceholderChunk(", ..."); 3626 } 3627 3628 MaybeAddSentinel(PP, Method, Result); 3629 } 3630 3631 return Result.TakeString(); 3632 } 3633 3634 if (Qualifier) 3635 AddQualifierToCompletionString(Result, Qualifier, QualifierIsInformative, 3636 Ctx, Policy); 3637 3638 Result.AddTypedTextChunk( 3639 Result.getAllocator().CopyString(ND->getNameAsString())); 3640 return Result.TakeString(); 3641 } 3642 3643 const RawComment *clang::getCompletionComment(const ASTContext &Ctx, 3644 const NamedDecl *ND) { 3645 if (!ND) 3646 return nullptr; 3647 if (auto *RC = Ctx.getRawCommentForAnyRedecl(ND)) 3648 return RC; 3649 3650 // Try to find comment from a property for ObjC methods. 3651 const auto *M = dyn_cast<ObjCMethodDecl>(ND); 3652 if (!M) 3653 return nullptr; 3654 const ObjCPropertyDecl *PDecl = M->findPropertyDecl(); 3655 if (!PDecl) 3656 return nullptr; 3657 3658 return Ctx.getRawCommentForAnyRedecl(PDecl); 3659 } 3660 3661 const RawComment *clang::getPatternCompletionComment(const ASTContext &Ctx, 3662 const NamedDecl *ND) { 3663 const auto *M = dyn_cast_or_null<ObjCMethodDecl>(ND); 3664 if (!M || !M->isPropertyAccessor()) 3665 return nullptr; 3666 3667 // Provide code completion comment for self.GetterName where 3668 // GetterName is the getter method for a property with name 3669 // different from the property name (declared via a property 3670 // getter attribute. 3671 const ObjCPropertyDecl *PDecl = M->findPropertyDecl(); 3672 if (!PDecl) 3673 return nullptr; 3674 if (PDecl->getGetterName() == M->getSelector() && 3675 PDecl->getIdentifier() != M->getIdentifier()) { 3676 if (auto *RC = Ctx.getRawCommentForAnyRedecl(M)) 3677 return RC; 3678 if (auto *RC = Ctx.getRawCommentForAnyRedecl(PDecl)) 3679 return RC; 3680 } 3681 return nullptr; 3682 } 3683 3684 const RawComment *clang::getParameterComment( 3685 const ASTContext &Ctx, 3686 const CodeCompleteConsumer::OverloadCandidate &Result, unsigned ArgIndex) { 3687 auto FDecl = Result.getFunction(); 3688 if (!FDecl) 3689 return nullptr; 3690 if (ArgIndex < FDecl->getNumParams()) 3691 return Ctx.getRawCommentForAnyRedecl(FDecl->getParamDecl(ArgIndex)); 3692 return nullptr; 3693 } 3694 3695 static void AddOverloadAggregateChunks(const RecordDecl *RD, 3696 const PrintingPolicy &Policy, 3697 CodeCompletionBuilder &Result, 3698 unsigned CurrentArg) { 3699 unsigned ChunkIndex = 0; 3700 auto AddChunk = [&](llvm::StringRef Placeholder) { 3701 if (ChunkIndex > 0) 3702 Result.AddChunk(CodeCompletionString::CK_Comma); 3703 const char *Copy = Result.getAllocator().CopyString(Placeholder); 3704 if (ChunkIndex == CurrentArg) 3705 Result.AddCurrentParameterChunk(Copy); 3706 else 3707 Result.AddPlaceholderChunk(Copy); 3708 ++ChunkIndex; 3709 }; 3710 // Aggregate initialization has all bases followed by all fields. 3711 // (Bases are not legal in C++11 but in that case we never get here). 3712 if (auto *CRD = llvm::dyn_cast<CXXRecordDecl>(RD)) { 3713 for (const auto &Base : CRD->bases()) 3714 AddChunk(Base.getType().getAsString(Policy)); 3715 } 3716 for (const auto &Field : RD->fields()) 3717 AddChunk(FormatFunctionParameter(Policy, Field)); 3718 } 3719 3720 /// Add function overload parameter chunks to the given code completion 3721 /// string. 3722 static void AddOverloadParameterChunks(ASTContext &Context, 3723 const PrintingPolicy &Policy, 3724 const FunctionDecl *Function, 3725 const FunctionProtoType *Prototype, 3726 CodeCompletionBuilder &Result, 3727 unsigned CurrentArg, unsigned Start = 0, 3728 bool InOptional = false) { 3729 if (!Function && !Prototype) { 3730 Result.AddChunk(CodeCompletionString::CK_CurrentParameter, "..."); 3731 return; 3732 } 3733 3734 bool FirstParameter = true; 3735 unsigned NumParams = 3736 Function ? Function->getNumParams() : Prototype->getNumParams(); 3737 3738 for (unsigned P = Start; P != NumParams; ++P) { 3739 if (Function && Function->getParamDecl(P)->hasDefaultArg() && !InOptional) { 3740 // When we see an optional default argument, put that argument and 3741 // the remaining default arguments into a new, optional string. 3742 CodeCompletionBuilder Opt(Result.getAllocator(), 3743 Result.getCodeCompletionTUInfo()); 3744 if (!FirstParameter) 3745 Opt.AddChunk(CodeCompletionString::CK_Comma); 3746 // Optional sections are nested. 3747 AddOverloadParameterChunks(Context, Policy, Function, Prototype, Opt, 3748 CurrentArg, P, /*InOptional=*/true); 3749 Result.AddOptionalChunk(Opt.TakeString()); 3750 return; 3751 } 3752 3753 if (FirstParameter) 3754 FirstParameter = false; 3755 else 3756 Result.AddChunk(CodeCompletionString::CK_Comma); 3757 3758 InOptional = false; 3759 3760 // Format the placeholder string. 3761 std::string Placeholder; 3762 if (Function) { 3763 const ParmVarDecl *Param = Function->getParamDecl(P); 3764 Placeholder = FormatFunctionParameter(Policy, Param); 3765 if (Param->hasDefaultArg()) 3766 Placeholder += GetDefaultValueString(Param, Context.getSourceManager(), 3767 Context.getLangOpts()); 3768 } else { 3769 Placeholder = Prototype->getParamType(P).getAsString(Policy); 3770 } 3771 3772 if (P == CurrentArg) 3773 Result.AddCurrentParameterChunk( 3774 Result.getAllocator().CopyString(Placeholder)); 3775 else 3776 Result.AddPlaceholderChunk(Result.getAllocator().CopyString(Placeholder)); 3777 } 3778 3779 if (Prototype && Prototype->isVariadic()) { 3780 CodeCompletionBuilder Opt(Result.getAllocator(), 3781 Result.getCodeCompletionTUInfo()); 3782 if (!FirstParameter) 3783 Opt.AddChunk(CodeCompletionString::CK_Comma); 3784 3785 if (CurrentArg < NumParams) 3786 Opt.AddPlaceholderChunk("..."); 3787 else 3788 Opt.AddCurrentParameterChunk("..."); 3789 3790 Result.AddOptionalChunk(Opt.TakeString()); 3791 } 3792 } 3793 3794 static std::string 3795 formatTemplateParameterPlaceholder(const NamedDecl *Param, bool &Optional, 3796 const PrintingPolicy &Policy) { 3797 if (const auto *Type = dyn_cast<TemplateTypeParmDecl>(Param)) { 3798 Optional = Type->hasDefaultArgument(); 3799 } else if (const auto *NonType = dyn_cast<NonTypeTemplateParmDecl>(Param)) { 3800 Optional = NonType->hasDefaultArgument(); 3801 } else if (const auto *Template = dyn_cast<TemplateTemplateParmDecl>(Param)) { 3802 Optional = Template->hasDefaultArgument(); 3803 } 3804 std::string Result; 3805 llvm::raw_string_ostream OS(Result); 3806 Param->print(OS, Policy); 3807 return Result; 3808 } 3809 3810 static std::string templateResultType(const TemplateDecl *TD, 3811 const PrintingPolicy &Policy) { 3812 if (const auto *CTD = dyn_cast<ClassTemplateDecl>(TD)) 3813 return CTD->getTemplatedDecl()->getKindName().str(); 3814 if (const auto *VTD = dyn_cast<VarTemplateDecl>(TD)) 3815 return VTD->getTemplatedDecl()->getType().getAsString(Policy); 3816 if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(TD)) 3817 return FTD->getTemplatedDecl()->getReturnType().getAsString(Policy); 3818 if (isa<TypeAliasTemplateDecl>(TD)) 3819 return "type"; 3820 if (isa<TemplateTemplateParmDecl>(TD)) 3821 return "class"; 3822 if (isa<ConceptDecl>(TD)) 3823 return "concept"; 3824 return ""; 3825 } 3826 3827 static CodeCompletionString *createTemplateSignatureString( 3828 const TemplateDecl *TD, CodeCompletionBuilder &Builder, unsigned CurrentArg, 3829 const PrintingPolicy &Policy) { 3830 llvm::ArrayRef<NamedDecl *> Params = TD->getTemplateParameters()->asArray(); 3831 CodeCompletionBuilder OptionalBuilder(Builder.getAllocator(), 3832 Builder.getCodeCompletionTUInfo()); 3833 std::string ResultType = templateResultType(TD, Policy); 3834 if (!ResultType.empty()) 3835 Builder.AddResultTypeChunk(Builder.getAllocator().CopyString(ResultType)); 3836 Builder.AddTextChunk( 3837 Builder.getAllocator().CopyString(TD->getNameAsString())); 3838 Builder.AddChunk(CodeCompletionString::CK_LeftAngle); 3839 // Initially we're writing into the main string. Once we see an optional arg 3840 // (with default), we're writing into the nested optional chunk. 3841 CodeCompletionBuilder *Current = &Builder; 3842 for (unsigned I = 0; I < Params.size(); ++I) { 3843 bool Optional = false; 3844 std::string Placeholder = 3845 formatTemplateParameterPlaceholder(Params[I], Optional, Policy); 3846 if (Optional) 3847 Current = &OptionalBuilder; 3848 if (I > 0) 3849 Current->AddChunk(CodeCompletionString::CK_Comma); 3850 Current->AddChunk(I == CurrentArg 3851 ? CodeCompletionString::CK_CurrentParameter 3852 : CodeCompletionString::CK_Placeholder, 3853 Current->getAllocator().CopyString(Placeholder)); 3854 } 3855 // Add the optional chunk to the main string if we ever used it. 3856 if (Current == &OptionalBuilder) 3857 Builder.AddOptionalChunk(OptionalBuilder.TakeString()); 3858 Builder.AddChunk(CodeCompletionString::CK_RightAngle); 3859 // For function templates, ResultType was the function's return type. 3860 // Give some clue this is a function. (Don't show the possibly-bulky params). 3861 if (isa<FunctionTemplateDecl>(TD)) 3862 Builder.AddInformativeChunk("()"); 3863 return Builder.TakeString(); 3864 } 3865 3866 CodeCompletionString * 3867 CodeCompleteConsumer::OverloadCandidate::CreateSignatureString( 3868 unsigned CurrentArg, Sema &S, CodeCompletionAllocator &Allocator, 3869 CodeCompletionTUInfo &CCTUInfo, bool IncludeBriefComments, 3870 bool Braced) const { 3871 PrintingPolicy Policy = getCompletionPrintingPolicy(S); 3872 // Show signatures of constructors as they are declared: 3873 // vector(int n) rather than vector<string>(int n) 3874 // This is less noisy without being less clear, and avoids tricky cases. 3875 Policy.SuppressTemplateArgsInCXXConstructors = true; 3876 3877 // FIXME: Set priority, availability appropriately. 3878 CodeCompletionBuilder Result(Allocator, CCTUInfo, 1, 3879 CXAvailability_Available); 3880 3881 if (getKind() == CK_Template) 3882 return createTemplateSignatureString(getTemplate(), Result, CurrentArg, 3883 Policy); 3884 3885 FunctionDecl *FDecl = getFunction(); 3886 const FunctionProtoType *Proto = 3887 dyn_cast_or_null<FunctionProtoType>(getFunctionType()); 3888 3889 // First, the name/type of the callee. 3890 if (getKind() == CK_Aggregate) { 3891 Result.AddTextChunk( 3892 Result.getAllocator().CopyString(getAggregate()->getName())); 3893 } else if (FDecl) { 3894 if (IncludeBriefComments) { 3895 if (auto RC = getParameterComment(S.getASTContext(), *this, CurrentArg)) 3896 Result.addBriefComment(RC->getBriefText(S.getASTContext())); 3897 } 3898 AddResultTypeChunk(S.Context, Policy, FDecl, QualType(), Result); 3899 3900 std::string Name; 3901 llvm::raw_string_ostream OS(Name); 3902 FDecl->getDeclName().print(OS, Policy); 3903 Result.AddTextChunk(Result.getAllocator().CopyString(OS.str())); 3904 } else { 3905 // Function without a declaration. Just give the return type. 3906 Result.AddResultTypeChunk(Result.getAllocator().CopyString( 3907 getFunctionType()->getReturnType().getAsString(Policy))); 3908 } 3909 3910 // Next, the brackets and parameters. 3911 Result.AddChunk(Braced ? CodeCompletionString::CK_LeftBrace 3912 : CodeCompletionString::CK_LeftParen); 3913 if (getKind() == CK_Aggregate) 3914 AddOverloadAggregateChunks(getAggregate(), Policy, Result, CurrentArg); 3915 else 3916 AddOverloadParameterChunks(S.getASTContext(), Policy, FDecl, Proto, Result, 3917 CurrentArg); 3918 Result.AddChunk(Braced ? CodeCompletionString::CK_RightBrace 3919 : CodeCompletionString::CK_RightParen); 3920 3921 return Result.TakeString(); 3922 } 3923 3924 unsigned clang::getMacroUsagePriority(StringRef MacroName, 3925 const LangOptions &LangOpts, 3926 bool PreferredTypeIsPointer) { 3927 unsigned Priority = CCP_Macro; 3928 3929 // Treat the "nil", "Nil" and "NULL" macros as null pointer constants. 3930 if (MacroName.equals("nil") || MacroName.equals("NULL") || 3931 MacroName.equals("Nil")) { 3932 Priority = CCP_Constant; 3933 if (PreferredTypeIsPointer) 3934 Priority = Priority / CCF_SimilarTypeMatch; 3935 } 3936 // Treat "YES", "NO", "true", and "false" as constants. 3937 else if (MacroName.equals("YES") || MacroName.equals("NO") || 3938 MacroName.equals("true") || MacroName.equals("false")) 3939 Priority = CCP_Constant; 3940 // Treat "bool" as a type. 3941 else if (MacroName.equals("bool")) 3942 Priority = CCP_Type + (LangOpts.ObjC ? CCD_bool_in_ObjC : 0); 3943 3944 return Priority; 3945 } 3946 3947 CXCursorKind clang::getCursorKindForDecl(const Decl *D) { 3948 if (!D) 3949 return CXCursor_UnexposedDecl; 3950 3951 switch (D->getKind()) { 3952 case Decl::Enum: 3953 return CXCursor_EnumDecl; 3954 case Decl::EnumConstant: 3955 return CXCursor_EnumConstantDecl; 3956 case Decl::Field: 3957 return CXCursor_FieldDecl; 3958 case Decl::Function: 3959 return CXCursor_FunctionDecl; 3960 case Decl::ObjCCategory: 3961 return CXCursor_ObjCCategoryDecl; 3962 case Decl::ObjCCategoryImpl: 3963 return CXCursor_ObjCCategoryImplDecl; 3964 case Decl::ObjCImplementation: 3965 return CXCursor_ObjCImplementationDecl; 3966 3967 case Decl::ObjCInterface: 3968 return CXCursor_ObjCInterfaceDecl; 3969 case Decl::ObjCIvar: 3970 return CXCursor_ObjCIvarDecl; 3971 case Decl::ObjCMethod: 3972 return cast<ObjCMethodDecl>(D)->isInstanceMethod() 3973 ? CXCursor_ObjCInstanceMethodDecl 3974 : CXCursor_ObjCClassMethodDecl; 3975 case Decl::CXXMethod: 3976 return CXCursor_CXXMethod; 3977 case Decl::CXXConstructor: 3978 return CXCursor_Constructor; 3979 case Decl::CXXDestructor: 3980 return CXCursor_Destructor; 3981 case Decl::CXXConversion: 3982 return CXCursor_ConversionFunction; 3983 case Decl::ObjCProperty: 3984 return CXCursor_ObjCPropertyDecl; 3985 case Decl::ObjCProtocol: 3986 return CXCursor_ObjCProtocolDecl; 3987 case Decl::ParmVar: 3988 return CXCursor_ParmDecl; 3989 case Decl::Typedef: 3990 return CXCursor_TypedefDecl; 3991 case Decl::TypeAlias: 3992 return CXCursor_TypeAliasDecl; 3993 case Decl::TypeAliasTemplate: 3994 return CXCursor_TypeAliasTemplateDecl; 3995 case Decl::Var: 3996 return CXCursor_VarDecl; 3997 case Decl::Namespace: 3998 return CXCursor_Namespace; 3999 case Decl::NamespaceAlias: 4000 return CXCursor_NamespaceAlias; 4001 case Decl::TemplateTypeParm: 4002 return CXCursor_TemplateTypeParameter; 4003 case Decl::NonTypeTemplateParm: 4004 return CXCursor_NonTypeTemplateParameter; 4005 case Decl::TemplateTemplateParm: 4006 return CXCursor_TemplateTemplateParameter; 4007 case Decl::FunctionTemplate: 4008 return CXCursor_FunctionTemplate; 4009 case Decl::ClassTemplate: 4010 return CXCursor_ClassTemplate; 4011 case Decl::AccessSpec: 4012 return CXCursor_CXXAccessSpecifier; 4013 case Decl::ClassTemplatePartialSpecialization: 4014 return CXCursor_ClassTemplatePartialSpecialization; 4015 case Decl::UsingDirective: 4016 return CXCursor_UsingDirective; 4017 case Decl::StaticAssert: 4018 return CXCursor_StaticAssert; 4019 case Decl::Friend: 4020 return CXCursor_FriendDecl; 4021 case Decl::TranslationUnit: 4022 return CXCursor_TranslationUnit; 4023 4024 case Decl::Using: 4025 case Decl::UnresolvedUsingValue: 4026 case Decl::UnresolvedUsingTypename: 4027 return CXCursor_UsingDeclaration; 4028 4029 case Decl::UsingEnum: 4030 return CXCursor_EnumDecl; 4031 4032 case Decl::ObjCPropertyImpl: 4033 switch (cast<ObjCPropertyImplDecl>(D)->getPropertyImplementation()) { 4034 case ObjCPropertyImplDecl::Dynamic: 4035 return CXCursor_ObjCDynamicDecl; 4036 4037 case ObjCPropertyImplDecl::Synthesize: 4038 return CXCursor_ObjCSynthesizeDecl; 4039 } 4040 llvm_unreachable("Unexpected Kind!"); 4041 4042 case Decl::Import: 4043 return CXCursor_ModuleImportDecl; 4044 4045 case Decl::ObjCTypeParam: 4046 return CXCursor_TemplateTypeParameter; 4047 4048 default: 4049 if (const auto *TD = dyn_cast<TagDecl>(D)) { 4050 switch (TD->getTagKind()) { 4051 case TTK_Interface: // fall through 4052 case TTK_Struct: 4053 return CXCursor_StructDecl; 4054 case TTK_Class: 4055 return CXCursor_ClassDecl; 4056 case TTK_Union: 4057 return CXCursor_UnionDecl; 4058 case TTK_Enum: 4059 return CXCursor_EnumDecl; 4060 } 4061 } 4062 } 4063 4064 return CXCursor_UnexposedDecl; 4065 } 4066 4067 static void AddMacroResults(Preprocessor &PP, ResultBuilder &Results, 4068 bool LoadExternal, bool IncludeUndefined, 4069 bool TargetTypeIsPointer = false) { 4070 typedef CodeCompletionResult Result; 4071 4072 Results.EnterNewScope(); 4073 4074 for (Preprocessor::macro_iterator M = PP.macro_begin(LoadExternal), 4075 MEnd = PP.macro_end(LoadExternal); 4076 M != MEnd; ++M) { 4077 auto MD = PP.getMacroDefinition(M->first); 4078 if (IncludeUndefined || MD) { 4079 MacroInfo *MI = MD.getMacroInfo(); 4080 if (MI && MI->isUsedForHeaderGuard()) 4081 continue; 4082 4083 Results.AddResult( 4084 Result(M->first, MI, 4085 getMacroUsagePriority(M->first->getName(), PP.getLangOpts(), 4086 TargetTypeIsPointer))); 4087 } 4088 } 4089 4090 Results.ExitScope(); 4091 } 4092 4093 static void AddPrettyFunctionResults(const LangOptions &LangOpts, 4094 ResultBuilder &Results) { 4095 typedef CodeCompletionResult Result; 4096 4097 Results.EnterNewScope(); 4098 4099 Results.AddResult(Result("__PRETTY_FUNCTION__", CCP_Constant)); 4100 Results.AddResult(Result("__FUNCTION__", CCP_Constant)); 4101 if (LangOpts.C99 || LangOpts.CPlusPlus11) 4102 Results.AddResult(Result("__func__", CCP_Constant)); 4103 Results.ExitScope(); 4104 } 4105 4106 static void HandleCodeCompleteResults(Sema *S, 4107 CodeCompleteConsumer *CodeCompleter, 4108 CodeCompletionContext Context, 4109 CodeCompletionResult *Results, 4110 unsigned NumResults) { 4111 if (CodeCompleter) 4112 CodeCompleter->ProcessCodeCompleteResults(*S, Context, Results, NumResults); 4113 } 4114 4115 static CodeCompletionContext 4116 mapCodeCompletionContext(Sema &S, Sema::ParserCompletionContext PCC) { 4117 switch (PCC) { 4118 case Sema::PCC_Namespace: 4119 return CodeCompletionContext::CCC_TopLevel; 4120 4121 case Sema::PCC_Class: 4122 return CodeCompletionContext::CCC_ClassStructUnion; 4123 4124 case Sema::PCC_ObjCInterface: 4125 return CodeCompletionContext::CCC_ObjCInterface; 4126 4127 case Sema::PCC_ObjCImplementation: 4128 return CodeCompletionContext::CCC_ObjCImplementation; 4129 4130 case Sema::PCC_ObjCInstanceVariableList: 4131 return CodeCompletionContext::CCC_ObjCIvarList; 4132 4133 case Sema::PCC_Template: 4134 case Sema::PCC_MemberTemplate: 4135 if (S.CurContext->isFileContext()) 4136 return CodeCompletionContext::CCC_TopLevel; 4137 if (S.CurContext->isRecord()) 4138 return CodeCompletionContext::CCC_ClassStructUnion; 4139 return CodeCompletionContext::CCC_Other; 4140 4141 case Sema::PCC_RecoveryInFunction: 4142 return CodeCompletionContext::CCC_Recovery; 4143 4144 case Sema::PCC_ForInit: 4145 if (S.getLangOpts().CPlusPlus || S.getLangOpts().C99 || 4146 S.getLangOpts().ObjC) 4147 return CodeCompletionContext::CCC_ParenthesizedExpression; 4148 else 4149 return CodeCompletionContext::CCC_Expression; 4150 4151 case Sema::PCC_Expression: 4152 return CodeCompletionContext::CCC_Expression; 4153 case Sema::PCC_Condition: 4154 return CodeCompletionContext(CodeCompletionContext::CCC_Expression, 4155 S.getASTContext().BoolTy); 4156 4157 case Sema::PCC_Statement: 4158 return CodeCompletionContext::CCC_Statement; 4159 4160 case Sema::PCC_Type: 4161 return CodeCompletionContext::CCC_Type; 4162 4163 case Sema::PCC_ParenthesizedExpression: 4164 return CodeCompletionContext::CCC_ParenthesizedExpression; 4165 4166 case Sema::PCC_LocalDeclarationSpecifiers: 4167 return CodeCompletionContext::CCC_Type; 4168 } 4169 4170 llvm_unreachable("Invalid ParserCompletionContext!"); 4171 } 4172 4173 /// If we're in a C++ virtual member function, add completion results 4174 /// that invoke the functions we override, since it's common to invoke the 4175 /// overridden function as well as adding new functionality. 4176 /// 4177 /// \param S The semantic analysis object for which we are generating results. 4178 /// 4179 /// \param InContext This context in which the nested-name-specifier preceding 4180 /// the code-completion point 4181 static void MaybeAddOverrideCalls(Sema &S, DeclContext *InContext, 4182 ResultBuilder &Results) { 4183 // Look through blocks. 4184 DeclContext *CurContext = S.CurContext; 4185 while (isa<BlockDecl>(CurContext)) 4186 CurContext = CurContext->getParent(); 4187 4188 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(CurContext); 4189 if (!Method || !Method->isVirtual()) 4190 return; 4191 4192 // We need to have names for all of the parameters, if we're going to 4193 // generate a forwarding call. 4194 for (auto P : Method->parameters()) 4195 if (!P->getDeclName()) 4196 return; 4197 4198 PrintingPolicy Policy = getCompletionPrintingPolicy(S); 4199 for (const CXXMethodDecl *Overridden : Method->overridden_methods()) { 4200 CodeCompletionBuilder Builder(Results.getAllocator(), 4201 Results.getCodeCompletionTUInfo()); 4202 if (Overridden->getCanonicalDecl() == Method->getCanonicalDecl()) 4203 continue; 4204 4205 // If we need a nested-name-specifier, add one now. 4206 if (!InContext) { 4207 NestedNameSpecifier *NNS = getRequiredQualification( 4208 S.Context, CurContext, Overridden->getDeclContext()); 4209 if (NNS) { 4210 std::string Str; 4211 llvm::raw_string_ostream OS(Str); 4212 NNS->print(OS, Policy); 4213 Builder.AddTextChunk(Results.getAllocator().CopyString(OS.str())); 4214 } 4215 } else if (!InContext->Equals(Overridden->getDeclContext())) 4216 continue; 4217 4218 Builder.AddTypedTextChunk( 4219 Results.getAllocator().CopyString(Overridden->getNameAsString())); 4220 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 4221 bool FirstParam = true; 4222 for (auto P : Method->parameters()) { 4223 if (FirstParam) 4224 FirstParam = false; 4225 else 4226 Builder.AddChunk(CodeCompletionString::CK_Comma); 4227 4228 Builder.AddPlaceholderChunk( 4229 Results.getAllocator().CopyString(P->getIdentifier()->getName())); 4230 } 4231 Builder.AddChunk(CodeCompletionString::CK_RightParen); 4232 Results.AddResult(CodeCompletionResult( 4233 Builder.TakeString(), CCP_SuperCompletion, CXCursor_CXXMethod, 4234 CXAvailability_Available, Overridden)); 4235 Results.Ignore(Overridden); 4236 } 4237 } 4238 4239 void Sema::CodeCompleteModuleImport(SourceLocation ImportLoc, 4240 ModuleIdPath Path) { 4241 typedef CodeCompletionResult Result; 4242 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 4243 CodeCompleter->getCodeCompletionTUInfo(), 4244 CodeCompletionContext::CCC_Other); 4245 Results.EnterNewScope(); 4246 4247 CodeCompletionAllocator &Allocator = Results.getAllocator(); 4248 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo()); 4249 typedef CodeCompletionResult Result; 4250 if (Path.empty()) { 4251 // Enumerate all top-level modules. 4252 SmallVector<Module *, 8> Modules; 4253 PP.getHeaderSearchInfo().collectAllModules(Modules); 4254 for (unsigned I = 0, N = Modules.size(); I != N; ++I) { 4255 Builder.AddTypedTextChunk( 4256 Builder.getAllocator().CopyString(Modules[I]->Name)); 4257 Results.AddResult(Result( 4258 Builder.TakeString(), CCP_Declaration, CXCursor_ModuleImportDecl, 4259 Modules[I]->isAvailable() ? CXAvailability_Available 4260 : CXAvailability_NotAvailable)); 4261 } 4262 } else if (getLangOpts().Modules) { 4263 // Load the named module. 4264 Module *Mod = 4265 PP.getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible, 4266 /*IsInclusionDirective=*/false); 4267 // Enumerate submodules. 4268 if (Mod) { 4269 for (Module::submodule_iterator Sub = Mod->submodule_begin(), 4270 SubEnd = Mod->submodule_end(); 4271 Sub != SubEnd; ++Sub) { 4272 4273 Builder.AddTypedTextChunk( 4274 Builder.getAllocator().CopyString((*Sub)->Name)); 4275 Results.AddResult(Result( 4276 Builder.TakeString(), CCP_Declaration, CXCursor_ModuleImportDecl, 4277 (*Sub)->isAvailable() ? CXAvailability_Available 4278 : CXAvailability_NotAvailable)); 4279 } 4280 } 4281 } 4282 Results.ExitScope(); 4283 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 4284 Results.data(), Results.size()); 4285 } 4286 4287 void Sema::CodeCompleteOrdinaryName(Scope *S, 4288 ParserCompletionContext CompletionContext) { 4289 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 4290 CodeCompleter->getCodeCompletionTUInfo(), 4291 mapCodeCompletionContext(*this, CompletionContext)); 4292 Results.EnterNewScope(); 4293 4294 // Determine how to filter results, e.g., so that the names of 4295 // values (functions, enumerators, function templates, etc.) are 4296 // only allowed where we can have an expression. 4297 switch (CompletionContext) { 4298 case PCC_Namespace: 4299 case PCC_Class: 4300 case PCC_ObjCInterface: 4301 case PCC_ObjCImplementation: 4302 case PCC_ObjCInstanceVariableList: 4303 case PCC_Template: 4304 case PCC_MemberTemplate: 4305 case PCC_Type: 4306 case PCC_LocalDeclarationSpecifiers: 4307 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName); 4308 break; 4309 4310 case PCC_Statement: 4311 case PCC_ParenthesizedExpression: 4312 case PCC_Expression: 4313 case PCC_ForInit: 4314 case PCC_Condition: 4315 if (WantTypesInContext(CompletionContext, getLangOpts())) 4316 Results.setFilter(&ResultBuilder::IsOrdinaryName); 4317 else 4318 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName); 4319 4320 if (getLangOpts().CPlusPlus) 4321 MaybeAddOverrideCalls(*this, /*InContext=*/nullptr, Results); 4322 break; 4323 4324 case PCC_RecoveryInFunction: 4325 // Unfiltered 4326 break; 4327 } 4328 4329 // If we are in a C++ non-static member function, check the qualifiers on 4330 // the member function to filter/prioritize the results list. 4331 auto ThisType = getCurrentThisType(); 4332 if (!ThisType.isNull()) 4333 Results.setObjectTypeQualifiers(ThisType->getPointeeType().getQualifiers(), 4334 VK_LValue); 4335 4336 CodeCompletionDeclConsumer Consumer(Results, CurContext); 4337 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 4338 CodeCompleter->includeGlobals(), 4339 CodeCompleter->loadExternal()); 4340 4341 AddOrdinaryNameResults(CompletionContext, S, *this, Results); 4342 Results.ExitScope(); 4343 4344 switch (CompletionContext) { 4345 case PCC_ParenthesizedExpression: 4346 case PCC_Expression: 4347 case PCC_Statement: 4348 case PCC_RecoveryInFunction: 4349 if (S->getFnParent()) 4350 AddPrettyFunctionResults(getLangOpts(), Results); 4351 break; 4352 4353 case PCC_Namespace: 4354 case PCC_Class: 4355 case PCC_ObjCInterface: 4356 case PCC_ObjCImplementation: 4357 case PCC_ObjCInstanceVariableList: 4358 case PCC_Template: 4359 case PCC_MemberTemplate: 4360 case PCC_ForInit: 4361 case PCC_Condition: 4362 case PCC_Type: 4363 case PCC_LocalDeclarationSpecifiers: 4364 break; 4365 } 4366 4367 if (CodeCompleter->includeMacros()) 4368 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false); 4369 4370 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 4371 Results.data(), Results.size()); 4372 } 4373 4374 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S, 4375 ParsedType Receiver, 4376 ArrayRef<IdentifierInfo *> SelIdents, 4377 bool AtArgumentExpression, bool IsSuper, 4378 ResultBuilder &Results); 4379 4380 void Sema::CodeCompleteDeclSpec(Scope *S, DeclSpec &DS, 4381 bool AllowNonIdentifiers, 4382 bool AllowNestedNameSpecifiers) { 4383 typedef CodeCompletionResult Result; 4384 ResultBuilder Results( 4385 *this, CodeCompleter->getAllocator(), 4386 CodeCompleter->getCodeCompletionTUInfo(), 4387 AllowNestedNameSpecifiers 4388 // FIXME: Try to separate codepath leading here to deduce whether we 4389 // need an existing symbol or a new one. 4390 ? CodeCompletionContext::CCC_SymbolOrNewName 4391 : CodeCompletionContext::CCC_NewName); 4392 Results.EnterNewScope(); 4393 4394 // Type qualifiers can come after names. 4395 Results.AddResult(Result("const")); 4396 Results.AddResult(Result("volatile")); 4397 if (getLangOpts().C99) 4398 Results.AddResult(Result("restrict")); 4399 4400 if (getLangOpts().CPlusPlus) { 4401 if (getLangOpts().CPlusPlus11 && 4402 (DS.getTypeSpecType() == DeclSpec::TST_class || 4403 DS.getTypeSpecType() == DeclSpec::TST_struct)) 4404 Results.AddResult("final"); 4405 4406 if (AllowNonIdentifiers) { 4407 Results.AddResult(Result("operator")); 4408 } 4409 4410 // Add nested-name-specifiers. 4411 if (AllowNestedNameSpecifiers) { 4412 Results.allowNestedNameSpecifiers(); 4413 Results.setFilter(&ResultBuilder::IsImpossibleToSatisfy); 4414 CodeCompletionDeclConsumer Consumer(Results, CurContext); 4415 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer, 4416 CodeCompleter->includeGlobals(), 4417 CodeCompleter->loadExternal()); 4418 Results.setFilter(nullptr); 4419 } 4420 } 4421 Results.ExitScope(); 4422 4423 // If we're in a context where we might have an expression (rather than a 4424 // declaration), and what we've seen so far is an Objective-C type that could 4425 // be a receiver of a class message, this may be a class message send with 4426 // the initial opening bracket '[' missing. Add appropriate completions. 4427 if (AllowNonIdentifiers && !AllowNestedNameSpecifiers && 4428 DS.getParsedSpecifiers() == DeclSpec::PQ_TypeSpecifier && 4429 DS.getTypeSpecType() == DeclSpec::TST_typename && 4430 DS.getTypeSpecComplex() == DeclSpec::TSC_unspecified && 4431 DS.getTypeSpecSign() == TypeSpecifierSign::Unspecified && 4432 !DS.isTypeAltiVecVector() && S && 4433 (S->getFlags() & Scope::DeclScope) != 0 && 4434 (S->getFlags() & (Scope::ClassScope | Scope::TemplateParamScope | 4435 Scope::FunctionPrototypeScope | Scope::AtCatchScope)) == 4436 0) { 4437 ParsedType T = DS.getRepAsType(); 4438 if (!T.get().isNull() && T.get()->isObjCObjectOrInterfaceType()) 4439 AddClassMessageCompletions(*this, S, T, None, false, false, Results); 4440 } 4441 4442 // Note that we intentionally suppress macro results here, since we do not 4443 // encourage using macros to produce the names of entities. 4444 4445 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 4446 Results.data(), Results.size()); 4447 } 4448 4449 static const char *underscoreAttrScope(llvm::StringRef Scope) { 4450 if (Scope == "clang") 4451 return "_Clang"; 4452 if (Scope == "gnu") 4453 return "__gnu__"; 4454 return nullptr; 4455 } 4456 4457 static const char *noUnderscoreAttrScope(llvm::StringRef Scope) { 4458 if (Scope == "_Clang") 4459 return "clang"; 4460 if (Scope == "__gnu__") 4461 return "gnu"; 4462 return nullptr; 4463 } 4464 4465 void Sema::CodeCompleteAttribute(AttributeCommonInfo::Syntax Syntax, 4466 AttributeCompletion Completion, 4467 const IdentifierInfo *InScope) { 4468 if (Completion == AttributeCompletion::None) 4469 return; 4470 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 4471 CodeCompleter->getCodeCompletionTUInfo(), 4472 CodeCompletionContext::CCC_Attribute); 4473 4474 // We're going to iterate over the normalized spellings of the attribute. 4475 // These don't include "underscore guarding": the normalized spelling is 4476 // clang::foo but you can also write _Clang::__foo__. 4477 // 4478 // (Clang supports a mix like clang::__foo__ but we won't suggest it: either 4479 // you care about clashing with macros or you don't). 4480 // 4481 // So if we're already in a scope, we determine its canonical spellings 4482 // (for comparison with normalized attr spelling) and remember whether it was 4483 // underscore-guarded (so we know how to spell contained attributes). 4484 llvm::StringRef InScopeName; 4485 bool InScopeUnderscore = false; 4486 if (InScope) { 4487 InScopeName = InScope->getName(); 4488 if (const char *NoUnderscore = noUnderscoreAttrScope(InScopeName)) { 4489 InScopeName = NoUnderscore; 4490 InScopeUnderscore = true; 4491 } 4492 } 4493 bool SyntaxSupportsGuards = Syntax == AttributeCommonInfo::AS_GNU || 4494 Syntax == AttributeCommonInfo::AS_CXX11 || 4495 Syntax == AttributeCommonInfo::AS_C2x; 4496 4497 llvm::DenseSet<llvm::StringRef> FoundScopes; 4498 auto AddCompletions = [&](const ParsedAttrInfo &A) { 4499 if (A.IsTargetSpecific && !A.existsInTarget(Context.getTargetInfo())) 4500 return; 4501 if (!A.acceptsLangOpts(getLangOpts())) 4502 return; 4503 for (const auto &S : A.Spellings) { 4504 if (S.Syntax != Syntax) 4505 continue; 4506 llvm::StringRef Name = S.NormalizedFullName; 4507 llvm::StringRef Scope; 4508 if ((Syntax == AttributeCommonInfo::AS_CXX11 || 4509 Syntax == AttributeCommonInfo::AS_C2x)) { 4510 std::tie(Scope, Name) = Name.split("::"); 4511 if (Name.empty()) // oops, unscoped 4512 std::swap(Name, Scope); 4513 } 4514 4515 // Do we just want a list of scopes rather than attributes? 4516 if (Completion == AttributeCompletion::Scope) { 4517 // Make sure to emit each scope only once. 4518 if (!Scope.empty() && FoundScopes.insert(Scope).second) { 4519 Results.AddResult( 4520 CodeCompletionResult(Results.getAllocator().CopyString(Scope))); 4521 // Include alternate form (__gnu__ instead of gnu). 4522 if (const char *Scope2 = underscoreAttrScope(Scope)) 4523 Results.AddResult(CodeCompletionResult(Scope2)); 4524 } 4525 continue; 4526 } 4527 4528 // If a scope was specified, it must match but we don't need to print it. 4529 if (!InScopeName.empty()) { 4530 if (Scope != InScopeName) 4531 continue; 4532 Scope = ""; 4533 } 4534 4535 auto Add = [&](llvm::StringRef Scope, llvm::StringRef Name, 4536 bool Underscores) { 4537 CodeCompletionBuilder Builder(Results.getAllocator(), 4538 Results.getCodeCompletionTUInfo()); 4539 llvm::SmallString<32> Text; 4540 if (!Scope.empty()) { 4541 Text.append(Scope); 4542 Text.append("::"); 4543 } 4544 if (Underscores) 4545 Text.append("__"); 4546 Text.append(Name); 4547 if (Underscores) 4548 Text.append("__"); 4549 Builder.AddTypedTextChunk(Results.getAllocator().CopyString(Text)); 4550 4551 if (!A.ArgNames.empty()) { 4552 Builder.AddChunk(CodeCompletionString::CK_LeftParen, "("); 4553 bool First = true; 4554 for (const char *Arg : A.ArgNames) { 4555 if (!First) 4556 Builder.AddChunk(CodeCompletionString::CK_Comma, ", "); 4557 First = false; 4558 Builder.AddPlaceholderChunk(Arg); 4559 } 4560 Builder.AddChunk(CodeCompletionString::CK_RightParen, ")"); 4561 } 4562 4563 Results.AddResult(Builder.TakeString()); 4564 }; 4565 4566 // Generate the non-underscore-guarded result. 4567 // Note this is (a suffix of) the NormalizedFullName, no need to copy. 4568 // If an underscore-guarded scope was specified, only the 4569 // underscore-guarded attribute name is relevant. 4570 if (!InScopeUnderscore) 4571 Add(Scope, Name, /*Underscores=*/false); 4572 4573 // Generate the underscore-guarded version, for syntaxes that support it. 4574 // We skip this if the scope was already spelled and not guarded, or 4575 // we must spell it and can't guard it. 4576 if (!(InScope && !InScopeUnderscore) && SyntaxSupportsGuards) { 4577 llvm::SmallString<32> Guarded; 4578 if (Scope.empty()) { 4579 Add(Scope, Name, /*Underscores=*/true); 4580 } else { 4581 const char *GuardedScope = underscoreAttrScope(Scope); 4582 if (!GuardedScope) 4583 continue; 4584 Add(GuardedScope, Name, /*Underscores=*/true); 4585 } 4586 } 4587 4588 // It may be nice to include the Kind so we can look up the docs later. 4589 } 4590 }; 4591 4592 for (const auto *A : ParsedAttrInfo::getAllBuiltin()) 4593 AddCompletions(*A); 4594 for (const auto &Entry : ParsedAttrInfoRegistry::entries()) 4595 AddCompletions(*Entry.instantiate()); 4596 4597 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 4598 Results.data(), Results.size()); 4599 } 4600 4601 struct Sema::CodeCompleteExpressionData { 4602 CodeCompleteExpressionData(QualType PreferredType = QualType(), 4603 bool IsParenthesized = false) 4604 : PreferredType(PreferredType), IntegralConstantExpression(false), 4605 ObjCCollection(false), IsParenthesized(IsParenthesized) {} 4606 4607 QualType PreferredType; 4608 bool IntegralConstantExpression; 4609 bool ObjCCollection; 4610 bool IsParenthesized; 4611 SmallVector<Decl *, 4> IgnoreDecls; 4612 }; 4613 4614 namespace { 4615 /// Information that allows to avoid completing redundant enumerators. 4616 struct CoveredEnumerators { 4617 llvm::SmallPtrSet<EnumConstantDecl *, 8> Seen; 4618 NestedNameSpecifier *SuggestedQualifier = nullptr; 4619 }; 4620 } // namespace 4621 4622 static void AddEnumerators(ResultBuilder &Results, ASTContext &Context, 4623 EnumDecl *Enum, DeclContext *CurContext, 4624 const CoveredEnumerators &Enumerators) { 4625 NestedNameSpecifier *Qualifier = Enumerators.SuggestedQualifier; 4626 if (Context.getLangOpts().CPlusPlus && !Qualifier && Enumerators.Seen.empty()) { 4627 // If there are no prior enumerators in C++, check whether we have to 4628 // qualify the names of the enumerators that we suggest, because they 4629 // may not be visible in this scope. 4630 Qualifier = getRequiredQualification(Context, CurContext, Enum); 4631 } 4632 4633 Results.EnterNewScope(); 4634 for (auto *E : Enum->enumerators()) { 4635 if (Enumerators.Seen.count(E)) 4636 continue; 4637 4638 CodeCompletionResult R(E, CCP_EnumInCase, Qualifier); 4639 Results.AddResult(R, CurContext, nullptr, false); 4640 } 4641 Results.ExitScope(); 4642 } 4643 4644 /// Try to find a corresponding FunctionProtoType for function-like types (e.g. 4645 /// function pointers, std::function, etc). 4646 static const FunctionProtoType *TryDeconstructFunctionLike(QualType T) { 4647 assert(!T.isNull()); 4648 // Try to extract first template argument from std::function<> and similar. 4649 // Note we only handle the sugared types, they closely match what users wrote. 4650 // We explicitly choose to not handle ClassTemplateSpecializationDecl. 4651 if (auto *Specialization = T->getAs<TemplateSpecializationType>()) { 4652 if (Specialization->getNumArgs() != 1) 4653 return nullptr; 4654 const TemplateArgument &Argument = Specialization->getArg(0); 4655 if (Argument.getKind() != TemplateArgument::Type) 4656 return nullptr; 4657 return Argument.getAsType()->getAs<FunctionProtoType>(); 4658 } 4659 // Handle other cases. 4660 if (T->isPointerType()) 4661 T = T->getPointeeType(); 4662 return T->getAs<FunctionProtoType>(); 4663 } 4664 4665 /// Adds a pattern completion for a lambda expression with the specified 4666 /// parameter types and placeholders for parameter names. 4667 static void AddLambdaCompletion(ResultBuilder &Results, 4668 llvm::ArrayRef<QualType> Parameters, 4669 const LangOptions &LangOpts) { 4670 if (!Results.includeCodePatterns()) 4671 return; 4672 CodeCompletionBuilder Completion(Results.getAllocator(), 4673 Results.getCodeCompletionTUInfo()); 4674 // [](<parameters>) {} 4675 Completion.AddChunk(CodeCompletionString::CK_LeftBracket); 4676 Completion.AddPlaceholderChunk("="); 4677 Completion.AddChunk(CodeCompletionString::CK_RightBracket); 4678 if (!Parameters.empty()) { 4679 Completion.AddChunk(CodeCompletionString::CK_LeftParen); 4680 bool First = true; 4681 for (auto Parameter : Parameters) { 4682 if (!First) 4683 Completion.AddChunk(CodeCompletionString::ChunkKind::CK_Comma); 4684 else 4685 First = false; 4686 4687 constexpr llvm::StringLiteral NamePlaceholder = "!#!NAME_GOES_HERE!#!"; 4688 std::string Type = std::string(NamePlaceholder); 4689 Parameter.getAsStringInternal(Type, PrintingPolicy(LangOpts)); 4690 llvm::StringRef Prefix, Suffix; 4691 std::tie(Prefix, Suffix) = llvm::StringRef(Type).split(NamePlaceholder); 4692 Prefix = Prefix.rtrim(); 4693 Suffix = Suffix.ltrim(); 4694 4695 Completion.AddTextChunk(Completion.getAllocator().CopyString(Prefix)); 4696 Completion.AddChunk(CodeCompletionString::CK_HorizontalSpace); 4697 Completion.AddPlaceholderChunk("parameter"); 4698 Completion.AddTextChunk(Completion.getAllocator().CopyString(Suffix)); 4699 }; 4700 Completion.AddChunk(CodeCompletionString::CK_RightParen); 4701 } 4702 Completion.AddChunk(clang::CodeCompletionString::CK_HorizontalSpace); 4703 Completion.AddChunk(CodeCompletionString::CK_LeftBrace); 4704 Completion.AddChunk(CodeCompletionString::CK_HorizontalSpace); 4705 Completion.AddPlaceholderChunk("body"); 4706 Completion.AddChunk(CodeCompletionString::CK_HorizontalSpace); 4707 Completion.AddChunk(CodeCompletionString::CK_RightBrace); 4708 4709 Results.AddResult(Completion.TakeString()); 4710 } 4711 4712 /// Perform code-completion in an expression context when we know what 4713 /// type we're looking for. 4714 void Sema::CodeCompleteExpression(Scope *S, 4715 const CodeCompleteExpressionData &Data) { 4716 ResultBuilder Results( 4717 *this, CodeCompleter->getAllocator(), 4718 CodeCompleter->getCodeCompletionTUInfo(), 4719 CodeCompletionContext( 4720 Data.IsParenthesized 4721 ? CodeCompletionContext::CCC_ParenthesizedExpression 4722 : CodeCompletionContext::CCC_Expression, 4723 Data.PreferredType)); 4724 auto PCC = 4725 Data.IsParenthesized ? PCC_ParenthesizedExpression : PCC_Expression; 4726 if (Data.ObjCCollection) 4727 Results.setFilter(&ResultBuilder::IsObjCCollection); 4728 else if (Data.IntegralConstantExpression) 4729 Results.setFilter(&ResultBuilder::IsIntegralConstantValue); 4730 else if (WantTypesInContext(PCC, getLangOpts())) 4731 Results.setFilter(&ResultBuilder::IsOrdinaryName); 4732 else 4733 Results.setFilter(&ResultBuilder::IsOrdinaryNonTypeName); 4734 4735 if (!Data.PreferredType.isNull()) 4736 Results.setPreferredType(Data.PreferredType.getNonReferenceType()); 4737 4738 // Ignore any declarations that we were told that we don't care about. 4739 for (unsigned I = 0, N = Data.IgnoreDecls.size(); I != N; ++I) 4740 Results.Ignore(Data.IgnoreDecls[I]); 4741 4742 CodeCompletionDeclConsumer Consumer(Results, CurContext); 4743 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 4744 CodeCompleter->includeGlobals(), 4745 CodeCompleter->loadExternal()); 4746 4747 Results.EnterNewScope(); 4748 AddOrdinaryNameResults(PCC, S, *this, Results); 4749 Results.ExitScope(); 4750 4751 bool PreferredTypeIsPointer = false; 4752 if (!Data.PreferredType.isNull()) { 4753 PreferredTypeIsPointer = Data.PreferredType->isAnyPointerType() || 4754 Data.PreferredType->isMemberPointerType() || 4755 Data.PreferredType->isBlockPointerType(); 4756 if (Data.PreferredType->isEnumeralType()) { 4757 EnumDecl *Enum = Data.PreferredType->castAs<EnumType>()->getDecl(); 4758 if (auto *Def = Enum->getDefinition()) 4759 Enum = Def; 4760 // FIXME: collect covered enumerators in cases like: 4761 // if (x == my_enum::one) { ... } else if (x == ^) {} 4762 AddEnumerators(Results, Context, Enum, CurContext, CoveredEnumerators()); 4763 } 4764 } 4765 4766 if (S->getFnParent() && !Data.ObjCCollection && 4767 !Data.IntegralConstantExpression) 4768 AddPrettyFunctionResults(getLangOpts(), Results); 4769 4770 if (CodeCompleter->includeMacros()) 4771 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false, 4772 PreferredTypeIsPointer); 4773 4774 // Complete a lambda expression when preferred type is a function. 4775 if (!Data.PreferredType.isNull() && getLangOpts().CPlusPlus11) { 4776 if (const FunctionProtoType *F = 4777 TryDeconstructFunctionLike(Data.PreferredType)) 4778 AddLambdaCompletion(Results, F->getParamTypes(), getLangOpts()); 4779 } 4780 4781 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 4782 Results.data(), Results.size()); 4783 } 4784 4785 void Sema::CodeCompleteExpression(Scope *S, QualType PreferredType, 4786 bool IsParenthesized) { 4787 return CodeCompleteExpression( 4788 S, CodeCompleteExpressionData(PreferredType, IsParenthesized)); 4789 } 4790 4791 void Sema::CodeCompletePostfixExpression(Scope *S, ExprResult E, 4792 QualType PreferredType) { 4793 if (E.isInvalid()) 4794 CodeCompleteExpression(S, PreferredType); 4795 else if (getLangOpts().ObjC) 4796 CodeCompleteObjCInstanceMessage(S, E.get(), None, false); 4797 } 4798 4799 /// The set of properties that have already been added, referenced by 4800 /// property name. 4801 typedef llvm::SmallPtrSet<IdentifierInfo *, 16> AddedPropertiesSet; 4802 4803 /// Retrieve the container definition, if any? 4804 static ObjCContainerDecl *getContainerDef(ObjCContainerDecl *Container) { 4805 if (ObjCInterfaceDecl *Interface = dyn_cast<ObjCInterfaceDecl>(Container)) { 4806 if (Interface->hasDefinition()) 4807 return Interface->getDefinition(); 4808 4809 return Interface; 4810 } 4811 4812 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) { 4813 if (Protocol->hasDefinition()) 4814 return Protocol->getDefinition(); 4815 4816 return Protocol; 4817 } 4818 return Container; 4819 } 4820 4821 /// Adds a block invocation code completion result for the given block 4822 /// declaration \p BD. 4823 static void AddObjCBlockCall(ASTContext &Context, const PrintingPolicy &Policy, 4824 CodeCompletionBuilder &Builder, 4825 const NamedDecl *BD, 4826 const FunctionTypeLoc &BlockLoc, 4827 const FunctionProtoTypeLoc &BlockProtoLoc) { 4828 Builder.AddResultTypeChunk( 4829 GetCompletionTypeString(BlockLoc.getReturnLoc().getType(), Context, 4830 Policy, Builder.getAllocator())); 4831 4832 AddTypedNameChunk(Context, Policy, BD, Builder); 4833 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 4834 4835 if (BlockProtoLoc && BlockProtoLoc.getTypePtr()->isVariadic()) { 4836 Builder.AddPlaceholderChunk("..."); 4837 } else { 4838 for (unsigned I = 0, N = BlockLoc.getNumParams(); I != N; ++I) { 4839 if (I) 4840 Builder.AddChunk(CodeCompletionString::CK_Comma); 4841 4842 // Format the placeholder string. 4843 std::string PlaceholderStr = 4844 FormatFunctionParameter(Policy, BlockLoc.getParam(I)); 4845 4846 if (I == N - 1 && BlockProtoLoc && 4847 BlockProtoLoc.getTypePtr()->isVariadic()) 4848 PlaceholderStr += ", ..."; 4849 4850 // Add the placeholder string. 4851 Builder.AddPlaceholderChunk( 4852 Builder.getAllocator().CopyString(PlaceholderStr)); 4853 } 4854 } 4855 4856 Builder.AddChunk(CodeCompletionString::CK_RightParen); 4857 } 4858 4859 static void 4860 AddObjCProperties(const CodeCompletionContext &CCContext, 4861 ObjCContainerDecl *Container, bool AllowCategories, 4862 bool AllowNullaryMethods, DeclContext *CurContext, 4863 AddedPropertiesSet &AddedProperties, ResultBuilder &Results, 4864 bool IsBaseExprStatement = false, 4865 bool IsClassProperty = false, bool InOriginalClass = true) { 4866 typedef CodeCompletionResult Result; 4867 4868 // Retrieve the definition. 4869 Container = getContainerDef(Container); 4870 4871 // Add properties in this container. 4872 const auto AddProperty = [&](const ObjCPropertyDecl *P) { 4873 if (!AddedProperties.insert(P->getIdentifier()).second) 4874 return; 4875 4876 // FIXME: Provide block invocation completion for non-statement 4877 // expressions. 4878 if (!P->getType().getTypePtr()->isBlockPointerType() || 4879 !IsBaseExprStatement) { 4880 Result R = Result(P, Results.getBasePriority(P), nullptr); 4881 if (!InOriginalClass) 4882 setInBaseClass(R); 4883 Results.MaybeAddResult(R, CurContext); 4884 return; 4885 } 4886 4887 // Block setter and invocation completion is provided only when we are able 4888 // to find the FunctionProtoTypeLoc with parameter names for the block. 4889 FunctionTypeLoc BlockLoc; 4890 FunctionProtoTypeLoc BlockProtoLoc; 4891 findTypeLocationForBlockDecl(P->getTypeSourceInfo(), BlockLoc, 4892 BlockProtoLoc); 4893 if (!BlockLoc) { 4894 Result R = Result(P, Results.getBasePriority(P), nullptr); 4895 if (!InOriginalClass) 4896 setInBaseClass(R); 4897 Results.MaybeAddResult(R, CurContext); 4898 return; 4899 } 4900 4901 // The default completion result for block properties should be the block 4902 // invocation completion when the base expression is a statement. 4903 CodeCompletionBuilder Builder(Results.getAllocator(), 4904 Results.getCodeCompletionTUInfo()); 4905 AddObjCBlockCall(Container->getASTContext(), 4906 getCompletionPrintingPolicy(Results.getSema()), Builder, P, 4907 BlockLoc, BlockProtoLoc); 4908 Result R = Result(Builder.TakeString(), P, Results.getBasePriority(P)); 4909 if (!InOriginalClass) 4910 setInBaseClass(R); 4911 Results.MaybeAddResult(R, CurContext); 4912 4913 // Provide additional block setter completion iff the base expression is a 4914 // statement and the block property is mutable. 4915 if (!P->isReadOnly()) { 4916 CodeCompletionBuilder Builder(Results.getAllocator(), 4917 Results.getCodeCompletionTUInfo()); 4918 AddResultTypeChunk(Container->getASTContext(), 4919 getCompletionPrintingPolicy(Results.getSema()), P, 4920 CCContext.getBaseType(), Builder); 4921 Builder.AddTypedTextChunk( 4922 Results.getAllocator().CopyString(P->getName())); 4923 Builder.AddChunk(CodeCompletionString::CK_Equal); 4924 4925 std::string PlaceholderStr = formatBlockPlaceholder( 4926 getCompletionPrintingPolicy(Results.getSema()), P, BlockLoc, 4927 BlockProtoLoc, /*SuppressBlockName=*/true); 4928 // Add the placeholder string. 4929 Builder.AddPlaceholderChunk( 4930 Builder.getAllocator().CopyString(PlaceholderStr)); 4931 4932 // When completing blocks properties that return void the default 4933 // property completion result should show up before the setter, 4934 // otherwise the setter completion should show up before the default 4935 // property completion, as we normally want to use the result of the 4936 // call. 4937 Result R = 4938 Result(Builder.TakeString(), P, 4939 Results.getBasePriority(P) + 4940 (BlockLoc.getTypePtr()->getReturnType()->isVoidType() 4941 ? CCD_BlockPropertySetter 4942 : -CCD_BlockPropertySetter)); 4943 if (!InOriginalClass) 4944 setInBaseClass(R); 4945 Results.MaybeAddResult(R, CurContext); 4946 } 4947 }; 4948 4949 if (IsClassProperty) { 4950 for (const auto *P : Container->class_properties()) 4951 AddProperty(P); 4952 } else { 4953 for (const auto *P : Container->instance_properties()) 4954 AddProperty(P); 4955 } 4956 4957 // Add nullary methods or implicit class properties 4958 if (AllowNullaryMethods) { 4959 ASTContext &Context = Container->getASTContext(); 4960 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema()); 4961 // Adds a method result 4962 const auto AddMethod = [&](const ObjCMethodDecl *M) { 4963 IdentifierInfo *Name = M->getSelector().getIdentifierInfoForSlot(0); 4964 if (!Name) 4965 return; 4966 if (!AddedProperties.insert(Name).second) 4967 return; 4968 CodeCompletionBuilder Builder(Results.getAllocator(), 4969 Results.getCodeCompletionTUInfo()); 4970 AddResultTypeChunk(Context, Policy, M, CCContext.getBaseType(), Builder); 4971 Builder.AddTypedTextChunk( 4972 Results.getAllocator().CopyString(Name->getName())); 4973 Result R = Result(Builder.TakeString(), M, 4974 CCP_MemberDeclaration + CCD_MethodAsProperty); 4975 if (!InOriginalClass) 4976 setInBaseClass(R); 4977 Results.MaybeAddResult(R, CurContext); 4978 }; 4979 4980 if (IsClassProperty) { 4981 for (const auto *M : Container->methods()) { 4982 // Gather the class method that can be used as implicit property 4983 // getters. Methods with arguments or methods that return void aren't 4984 // added to the results as they can't be used as a getter. 4985 if (!M->getSelector().isUnarySelector() || 4986 M->getReturnType()->isVoidType() || M->isInstanceMethod()) 4987 continue; 4988 AddMethod(M); 4989 } 4990 } else { 4991 for (auto *M : Container->methods()) { 4992 if (M->getSelector().isUnarySelector()) 4993 AddMethod(M); 4994 } 4995 } 4996 } 4997 4998 // Add properties in referenced protocols. 4999 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) { 5000 for (auto *P : Protocol->protocols()) 5001 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods, 5002 CurContext, AddedProperties, Results, 5003 IsBaseExprStatement, IsClassProperty, 5004 /*InOriginalClass*/ false); 5005 } else if (ObjCInterfaceDecl *IFace = 5006 dyn_cast<ObjCInterfaceDecl>(Container)) { 5007 if (AllowCategories) { 5008 // Look through categories. 5009 for (auto *Cat : IFace->known_categories()) 5010 AddObjCProperties(CCContext, Cat, AllowCategories, AllowNullaryMethods, 5011 CurContext, AddedProperties, Results, 5012 IsBaseExprStatement, IsClassProperty, 5013 InOriginalClass); 5014 } 5015 5016 // Look through protocols. 5017 for (auto *I : IFace->all_referenced_protocols()) 5018 AddObjCProperties(CCContext, I, AllowCategories, AllowNullaryMethods, 5019 CurContext, AddedProperties, Results, 5020 IsBaseExprStatement, IsClassProperty, 5021 /*InOriginalClass*/ false); 5022 5023 // Look in the superclass. 5024 if (IFace->getSuperClass()) 5025 AddObjCProperties(CCContext, IFace->getSuperClass(), AllowCategories, 5026 AllowNullaryMethods, CurContext, AddedProperties, 5027 Results, IsBaseExprStatement, IsClassProperty, 5028 /*InOriginalClass*/ false); 5029 } else if (const auto *Category = 5030 dyn_cast<ObjCCategoryDecl>(Container)) { 5031 // Look through protocols. 5032 for (auto *P : Category->protocols()) 5033 AddObjCProperties(CCContext, P, AllowCategories, AllowNullaryMethods, 5034 CurContext, AddedProperties, Results, 5035 IsBaseExprStatement, IsClassProperty, 5036 /*InOriginalClass*/ false); 5037 } 5038 } 5039 5040 static void AddRecordMembersCompletionResults( 5041 Sema &SemaRef, ResultBuilder &Results, Scope *S, QualType BaseType, 5042 ExprValueKind BaseKind, RecordDecl *RD, Optional<FixItHint> AccessOpFixIt) { 5043 // Indicate that we are performing a member access, and the cv-qualifiers 5044 // for the base object type. 5045 Results.setObjectTypeQualifiers(BaseType.getQualifiers(), BaseKind); 5046 5047 // Access to a C/C++ class, struct, or union. 5048 Results.allowNestedNameSpecifiers(); 5049 std::vector<FixItHint> FixIts; 5050 if (AccessOpFixIt) 5051 FixIts.emplace_back(AccessOpFixIt.getValue()); 5052 CodeCompletionDeclConsumer Consumer(Results, RD, BaseType, std::move(FixIts)); 5053 SemaRef.LookupVisibleDecls(RD, Sema::LookupMemberName, Consumer, 5054 SemaRef.CodeCompleter->includeGlobals(), 5055 /*IncludeDependentBases=*/true, 5056 SemaRef.CodeCompleter->loadExternal()); 5057 5058 if (SemaRef.getLangOpts().CPlusPlus) { 5059 if (!Results.empty()) { 5060 // The "template" keyword can follow "->" or "." in the grammar. 5061 // However, we only want to suggest the template keyword if something 5062 // is dependent. 5063 bool IsDependent = BaseType->isDependentType(); 5064 if (!IsDependent) { 5065 for (Scope *DepScope = S; DepScope; DepScope = DepScope->getParent()) 5066 if (DeclContext *Ctx = DepScope->getEntity()) { 5067 IsDependent = Ctx->isDependentContext(); 5068 break; 5069 } 5070 } 5071 5072 if (IsDependent) 5073 Results.AddResult(CodeCompletionResult("template")); 5074 } 5075 } 5076 } 5077 5078 // Returns the RecordDecl inside the BaseType, falling back to primary template 5079 // in case of specializations. Since we might not have a decl for the 5080 // instantiation/specialization yet, e.g. dependent code. 5081 static RecordDecl *getAsRecordDecl(const QualType BaseType) { 5082 if (auto *RD = BaseType->getAsRecordDecl()) { 5083 if (const auto *CTSD = 5084 llvm::dyn_cast<ClassTemplateSpecializationDecl>(RD)) { 5085 // Template might not be instantiated yet, fall back to primary template 5086 // in such cases. 5087 if (CTSD->getTemplateSpecializationKind() == TSK_Undeclared) 5088 RD = CTSD->getSpecializedTemplate()->getTemplatedDecl(); 5089 } 5090 return RD; 5091 } 5092 5093 if (const auto *TST = BaseType->getAs<TemplateSpecializationType>()) { 5094 if (const auto *TD = dyn_cast_or_null<ClassTemplateDecl>( 5095 TST->getTemplateName().getAsTemplateDecl())) { 5096 return TD->getTemplatedDecl(); 5097 } 5098 } 5099 5100 return nullptr; 5101 } 5102 5103 namespace { 5104 // Collects completion-relevant information about a concept-constrainted type T. 5105 // In particular, examines the constraint expressions to find members of T. 5106 // 5107 // The design is very simple: we walk down each constraint looking for 5108 // expressions of the form T.foo(). 5109 // If we're extra lucky, the return type is specified. 5110 // We don't do any clever handling of && or || in constraint expressions, we 5111 // take members from both branches. 5112 // 5113 // For example, given: 5114 // template <class T> concept X = requires (T t, string& s) { t.print(s); }; 5115 // template <X U> void foo(U u) { u.^ } 5116 // We want to suggest the inferred member function 'print(string)'. 5117 // We see that u has type U, so X<U> holds. 5118 // X<U> requires t.print(s) to be valid, where t has type U (substituted for T). 5119 // By looking at the CallExpr we find the signature of print(). 5120 // 5121 // While we tend to know in advance which kind of members (access via . -> ::) 5122 // we want, it's simpler just to gather them all and post-filter. 5123 // 5124 // FIXME: some of this machinery could be used for non-concept type-parms too, 5125 // enabling completion for type parameters based on other uses of that param. 5126 // 5127 // FIXME: there are other cases where a type can be constrained by a concept, 5128 // e.g. inside `if constexpr(ConceptSpecializationExpr) { ... }` 5129 class ConceptInfo { 5130 public: 5131 // Describes a likely member of a type, inferred by concept constraints. 5132 // Offered as a code completion for T. T-> and T:: contexts. 5133 struct Member { 5134 // Always non-null: we only handle members with ordinary identifier names. 5135 const IdentifierInfo *Name = nullptr; 5136 // Set for functions we've seen called. 5137 // We don't have the declared parameter types, only the actual types of 5138 // arguments we've seen. These are still valuable, as it's hard to render 5139 // a useful function completion with neither parameter types nor names! 5140 llvm::Optional<SmallVector<QualType, 1>> ArgTypes; 5141 // Whether this is accessed as T.member, T->member, or T::member. 5142 enum AccessOperator { 5143 Colons, 5144 Arrow, 5145 Dot, 5146 } Operator = Dot; 5147 // What's known about the type of a variable or return type of a function. 5148 const TypeConstraint *ResultType = nullptr; 5149 // FIXME: also track: 5150 // - kind of entity (function/variable/type), to expose structured results 5151 // - template args kinds/types, as a proxy for template params 5152 5153 // For now we simply return these results as "pattern" strings. 5154 CodeCompletionString *render(Sema &S, CodeCompletionAllocator &Alloc, 5155 CodeCompletionTUInfo &Info) const { 5156 CodeCompletionBuilder B(Alloc, Info); 5157 // Result type 5158 if (ResultType) { 5159 std::string AsString; 5160 { 5161 llvm::raw_string_ostream OS(AsString); 5162 QualType ExactType = deduceType(*ResultType); 5163 if (!ExactType.isNull()) 5164 ExactType.print(OS, getCompletionPrintingPolicy(S)); 5165 else 5166 ResultType->print(OS, getCompletionPrintingPolicy(S)); 5167 } 5168 B.AddResultTypeChunk(Alloc.CopyString(AsString)); 5169 } 5170 // Member name 5171 B.AddTypedTextChunk(Alloc.CopyString(Name->getName())); 5172 // Function argument list 5173 if (ArgTypes) { 5174 B.AddChunk(clang::CodeCompletionString::CK_LeftParen); 5175 bool First = true; 5176 for (QualType Arg : *ArgTypes) { 5177 if (First) 5178 First = false; 5179 else { 5180 B.AddChunk(clang::CodeCompletionString::CK_Comma); 5181 B.AddChunk(clang::CodeCompletionString::CK_HorizontalSpace); 5182 } 5183 B.AddPlaceholderChunk(Alloc.CopyString( 5184 Arg.getAsString(getCompletionPrintingPolicy(S)))); 5185 } 5186 B.AddChunk(clang::CodeCompletionString::CK_RightParen); 5187 } 5188 return B.TakeString(); 5189 } 5190 }; 5191 5192 // BaseType is the type parameter T to infer members from. 5193 // T must be accessible within S, as we use it to find the template entity 5194 // that T is attached to in order to gather the relevant constraints. 5195 ConceptInfo(const TemplateTypeParmType &BaseType, Scope *S) { 5196 auto *TemplatedEntity = getTemplatedEntity(BaseType.getDecl(), S); 5197 for (const Expr *E : constraintsForTemplatedEntity(TemplatedEntity)) 5198 believe(E, &BaseType); 5199 } 5200 5201 std::vector<Member> members() { 5202 std::vector<Member> Results; 5203 for (const auto &E : this->Results) 5204 Results.push_back(E.second); 5205 llvm::sort(Results, [](const Member &L, const Member &R) { 5206 return L.Name->getName() < R.Name->getName(); 5207 }); 5208 return Results; 5209 } 5210 5211 private: 5212 // Infer members of T, given that the expression E (dependent on T) is true. 5213 void believe(const Expr *E, const TemplateTypeParmType *T) { 5214 if (!E || !T) 5215 return; 5216 if (auto *CSE = dyn_cast<ConceptSpecializationExpr>(E)) { 5217 // If the concept is 5218 // template <class A, class B> concept CD = f<A, B>(); 5219 // And the concept specialization is 5220 // CD<int, T> 5221 // Then we're substituting T for B, so we want to make f<A, B>() true 5222 // by adding members to B - i.e. believe(f<A, B>(), B); 5223 // 5224 // For simplicity: 5225 // - we don't attempt to substitute int for A 5226 // - when T is used in other ways (like CD<T*>) we ignore it 5227 ConceptDecl *CD = CSE->getNamedConcept(); 5228 TemplateParameterList *Params = CD->getTemplateParameters(); 5229 unsigned Index = 0; 5230 for (const auto &Arg : CSE->getTemplateArguments()) { 5231 if (Index >= Params->size()) 5232 break; // Won't happen in valid code. 5233 if (isApprox(Arg, T)) { 5234 auto *TTPD = dyn_cast<TemplateTypeParmDecl>(Params->getParam(Index)); 5235 if (!TTPD) 5236 continue; 5237 // T was used as an argument, and bound to the parameter TT. 5238 auto *TT = cast<TemplateTypeParmType>(TTPD->getTypeForDecl()); 5239 // So now we know the constraint as a function of TT is true. 5240 believe(CD->getConstraintExpr(), TT); 5241 // (concepts themselves have no associated constraints to require) 5242 } 5243 5244 ++Index; 5245 } 5246 } else if (auto *BO = dyn_cast<BinaryOperator>(E)) { 5247 // For A && B, we can infer members from both branches. 5248 // For A || B, the union is still more useful than the intersection. 5249 if (BO->getOpcode() == BO_LAnd || BO->getOpcode() == BO_LOr) { 5250 believe(BO->getLHS(), T); 5251 believe(BO->getRHS(), T); 5252 } 5253 } else if (auto *RE = dyn_cast<RequiresExpr>(E)) { 5254 // A requires(){...} lets us infer members from each requirement. 5255 for (const concepts::Requirement *Req : RE->getRequirements()) { 5256 if (!Req->isDependent()) 5257 continue; // Can't tell us anything about T. 5258 // Now Req cannot a substitution-error: those aren't dependent. 5259 5260 if (auto *TR = dyn_cast<concepts::TypeRequirement>(Req)) { 5261 // Do a full traversal so we get `foo` from `typename T::foo::bar`. 5262 QualType AssertedType = TR->getType()->getType(); 5263 ValidVisitor(this, T).TraverseType(AssertedType); 5264 } else if (auto *ER = dyn_cast<concepts::ExprRequirement>(Req)) { 5265 ValidVisitor Visitor(this, T); 5266 // If we have a type constraint on the value of the expression, 5267 // AND the whole outer expression describes a member, then we'll 5268 // be able to use the constraint to provide the return type. 5269 if (ER->getReturnTypeRequirement().isTypeConstraint()) { 5270 Visitor.OuterType = 5271 ER->getReturnTypeRequirement().getTypeConstraint(); 5272 Visitor.OuterExpr = ER->getExpr(); 5273 } 5274 Visitor.TraverseStmt(ER->getExpr()); 5275 } else if (auto *NR = dyn_cast<concepts::NestedRequirement>(Req)) { 5276 believe(NR->getConstraintExpr(), T); 5277 } 5278 } 5279 } 5280 } 5281 5282 // This visitor infers members of T based on traversing expressions/types 5283 // that involve T. It is invoked with code known to be valid for T. 5284 class ValidVisitor : public RecursiveASTVisitor<ValidVisitor> { 5285 ConceptInfo *Outer; 5286 const TemplateTypeParmType *T; 5287 5288 CallExpr *Caller = nullptr; 5289 Expr *Callee = nullptr; 5290 5291 public: 5292 // If set, OuterExpr is constrained by OuterType. 5293 Expr *OuterExpr = nullptr; 5294 const TypeConstraint *OuterType = nullptr; 5295 5296 ValidVisitor(ConceptInfo *Outer, const TemplateTypeParmType *T) 5297 : Outer(Outer), T(T) { 5298 assert(T); 5299 } 5300 5301 // In T.foo or T->foo, `foo` is a member function/variable. 5302 bool VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E) { 5303 const Type *Base = E->getBaseType().getTypePtr(); 5304 bool IsArrow = E->isArrow(); 5305 if (Base->isPointerType() && IsArrow) { 5306 IsArrow = false; 5307 Base = Base->getPointeeType().getTypePtr(); 5308 } 5309 if (isApprox(Base, T)) 5310 addValue(E, E->getMember(), IsArrow ? Member::Arrow : Member::Dot); 5311 return true; 5312 } 5313 5314 // In T::foo, `foo` is a static member function/variable. 5315 bool VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) { 5316 if (E->getQualifier() && isApprox(E->getQualifier()->getAsType(), T)) 5317 addValue(E, E->getDeclName(), Member::Colons); 5318 return true; 5319 } 5320 5321 // In T::typename foo, `foo` is a type. 5322 bool VisitDependentNameType(DependentNameType *DNT) { 5323 const auto *Q = DNT->getQualifier(); 5324 if (Q && isApprox(Q->getAsType(), T)) 5325 addType(DNT->getIdentifier()); 5326 return true; 5327 } 5328 5329 // In T::foo::bar, `foo` must be a type. 5330 // VisitNNS() doesn't exist, and TraverseNNS isn't always called :-( 5331 bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSL) { 5332 if (NNSL) { 5333 NestedNameSpecifier *NNS = NNSL.getNestedNameSpecifier(); 5334 const auto *Q = NNS->getPrefix(); 5335 if (Q && isApprox(Q->getAsType(), T)) 5336 addType(NNS->getAsIdentifier()); 5337 } 5338 // FIXME: also handle T::foo<X>::bar 5339 return RecursiveASTVisitor::TraverseNestedNameSpecifierLoc(NNSL); 5340 } 5341 5342 // FIXME also handle T::foo<X> 5343 5344 // Track the innermost caller/callee relationship so we can tell if a 5345 // nested expr is being called as a function. 5346 bool VisitCallExpr(CallExpr *CE) { 5347 Caller = CE; 5348 Callee = CE->getCallee(); 5349 return true; 5350 } 5351 5352 private: 5353 void addResult(Member &&M) { 5354 auto R = Outer->Results.try_emplace(M.Name); 5355 Member &O = R.first->second; 5356 // Overwrite existing if the new member has more info. 5357 // The preference of . vs :: vs -> is fairly arbitrary. 5358 if (/*Inserted*/ R.second || 5359 std::make_tuple(M.ArgTypes.hasValue(), M.ResultType != nullptr, 5360 M.Operator) > std::make_tuple(O.ArgTypes.hasValue(), 5361 O.ResultType != nullptr, 5362 O.Operator)) 5363 O = std::move(M); 5364 } 5365 5366 void addType(const IdentifierInfo *Name) { 5367 if (!Name) 5368 return; 5369 Member M; 5370 M.Name = Name; 5371 M.Operator = Member::Colons; 5372 addResult(std::move(M)); 5373 } 5374 5375 void addValue(Expr *E, DeclarationName Name, 5376 Member::AccessOperator Operator) { 5377 if (!Name.isIdentifier()) 5378 return; 5379 Member Result; 5380 Result.Name = Name.getAsIdentifierInfo(); 5381 Result.Operator = Operator; 5382 // If this is the callee of an immediately-enclosing CallExpr, then 5383 // treat it as a method, otherwise it's a variable. 5384 if (Caller != nullptr && Callee == E) { 5385 Result.ArgTypes.emplace(); 5386 for (const auto *Arg : Caller->arguments()) 5387 Result.ArgTypes->push_back(Arg->getType()); 5388 if (Caller == OuterExpr) { 5389 Result.ResultType = OuterType; 5390 } 5391 } else { 5392 if (E == OuterExpr) 5393 Result.ResultType = OuterType; 5394 } 5395 addResult(std::move(Result)); 5396 } 5397 }; 5398 5399 static bool isApprox(const TemplateArgument &Arg, const Type *T) { 5400 return Arg.getKind() == TemplateArgument::Type && 5401 isApprox(Arg.getAsType().getTypePtr(), T); 5402 } 5403 5404 static bool isApprox(const Type *T1, const Type *T2) { 5405 return T1 && T2 && 5406 T1->getCanonicalTypeUnqualified() == 5407 T2->getCanonicalTypeUnqualified(); 5408 } 5409 5410 // Returns the DeclContext immediately enclosed by the template parameter 5411 // scope. For primary templates, this is the templated (e.g.) CXXRecordDecl. 5412 // For specializations, this is e.g. ClassTemplatePartialSpecializationDecl. 5413 static DeclContext *getTemplatedEntity(const TemplateTypeParmDecl *D, 5414 Scope *S) { 5415 if (D == nullptr) 5416 return nullptr; 5417 Scope *Inner = nullptr; 5418 while (S) { 5419 if (S->isTemplateParamScope() && S->isDeclScope(D)) 5420 return Inner ? Inner->getEntity() : nullptr; 5421 Inner = S; 5422 S = S->getParent(); 5423 } 5424 return nullptr; 5425 } 5426 5427 // Gets all the type constraint expressions that might apply to the type 5428 // variables associated with DC (as returned by getTemplatedEntity()). 5429 static SmallVector<const Expr *, 1> 5430 constraintsForTemplatedEntity(DeclContext *DC) { 5431 SmallVector<const Expr *, 1> Result; 5432 if (DC == nullptr) 5433 return Result; 5434 // Primary templates can have constraints. 5435 if (const auto *TD = cast<Decl>(DC)->getDescribedTemplate()) 5436 TD->getAssociatedConstraints(Result); 5437 // Partial specializations may have constraints. 5438 if (const auto *CTPSD = 5439 dyn_cast<ClassTemplatePartialSpecializationDecl>(DC)) 5440 CTPSD->getAssociatedConstraints(Result); 5441 if (const auto *VTPSD = dyn_cast<VarTemplatePartialSpecializationDecl>(DC)) 5442 VTPSD->getAssociatedConstraints(Result); 5443 return Result; 5444 } 5445 5446 // Attempt to find the unique type satisfying a constraint. 5447 // This lets us show e.g. `int` instead of `std::same_as<int>`. 5448 static QualType deduceType(const TypeConstraint &T) { 5449 // Assume a same_as<T> return type constraint is std::same_as or equivalent. 5450 // In this case the return type is T. 5451 DeclarationName DN = T.getNamedConcept()->getDeclName(); 5452 if (DN.isIdentifier() && DN.getAsIdentifierInfo()->isStr("same_as")) 5453 if (const auto *Args = T.getTemplateArgsAsWritten()) 5454 if (Args->getNumTemplateArgs() == 1) { 5455 const auto &Arg = Args->arguments().front().getArgument(); 5456 if (Arg.getKind() == TemplateArgument::Type) 5457 return Arg.getAsType(); 5458 } 5459 return {}; 5460 } 5461 5462 llvm::DenseMap<const IdentifierInfo *, Member> Results; 5463 }; 5464 5465 // Returns a type for E that yields acceptable member completions. 5466 // In particular, when E->getType() is DependentTy, try to guess a likely type. 5467 // We accept some lossiness (like dropping parameters). 5468 // We only try to handle common expressions on the LHS of MemberExpr. 5469 QualType getApproximateType(const Expr *E) { 5470 QualType Unresolved = E->getType(); 5471 if (Unresolved.isNull() || 5472 !Unresolved->isSpecificBuiltinType(BuiltinType::Dependent)) 5473 return Unresolved; 5474 E = E->IgnoreParens(); 5475 // A call: approximate-resolve callee to a function type, get its return type 5476 if (const CallExpr *CE = llvm::dyn_cast<CallExpr>(E)) { 5477 QualType Callee = getApproximateType(CE->getCallee()); 5478 if (Callee.isNull() || 5479 Callee->isSpecificPlaceholderType(BuiltinType::BoundMember)) 5480 Callee = Expr::findBoundMemberType(CE->getCallee()); 5481 if (Callee.isNull()) 5482 return Unresolved; 5483 5484 if (const auto *FnTypePtr = Callee->getAs<PointerType>()) { 5485 Callee = FnTypePtr->getPointeeType(); 5486 } else if (const auto *BPT = Callee->getAs<BlockPointerType>()) { 5487 Callee = BPT->getPointeeType(); 5488 } 5489 if (const FunctionType *FnType = Callee->getAs<FunctionType>()) 5490 return FnType->getReturnType().getNonReferenceType(); 5491 5492 // Unresolved call: try to guess the return type. 5493 if (const auto *OE = llvm::dyn_cast<OverloadExpr>(CE->getCallee())) { 5494 // If all candidates have the same approximate return type, use it. 5495 // Discard references and const to allow more to be "the same". 5496 // (In particular, if there's one candidate + ADL, resolve it). 5497 const Type *Common = nullptr; 5498 for (const auto *D : OE->decls()) { 5499 QualType ReturnType; 5500 if (const auto *FD = llvm::dyn_cast<FunctionDecl>(D)) 5501 ReturnType = FD->getReturnType(); 5502 else if (const auto *FTD = llvm::dyn_cast<FunctionTemplateDecl>(D)) 5503 ReturnType = FTD->getTemplatedDecl()->getReturnType(); 5504 if (ReturnType.isNull()) 5505 continue; 5506 const Type *Candidate = 5507 ReturnType.getNonReferenceType().getCanonicalType().getTypePtr(); 5508 if (Common && Common != Candidate) 5509 return Unresolved; // Multiple candidates. 5510 Common = Candidate; 5511 } 5512 if (Common != nullptr) 5513 return QualType(Common, 0); 5514 } 5515 } 5516 // A dependent member: approximate-resolve the base, then lookup. 5517 if (const auto *CDSME = llvm::dyn_cast<CXXDependentScopeMemberExpr>(E)) { 5518 QualType Base = CDSME->isImplicitAccess() 5519 ? CDSME->getBaseType() 5520 : getApproximateType(CDSME->getBase()); 5521 if (CDSME->isArrow() && !Base.isNull()) 5522 Base = Base->getPointeeType(); // could handle unique_ptr etc here? 5523 auto *RD = 5524 Base.isNull() 5525 ? nullptr 5526 : llvm::dyn_cast_or_null<CXXRecordDecl>(getAsRecordDecl(Base)); 5527 if (RD && RD->isCompleteDefinition()) { 5528 // Look up member heuristically, including in bases. 5529 for (const auto *Member : RD->lookupDependentName( 5530 CDSME->getMember(), [](const NamedDecl *Member) { 5531 return llvm::isa<ValueDecl>(Member); 5532 })) { 5533 return llvm::cast<ValueDecl>(Member)->getType().getNonReferenceType(); 5534 } 5535 } 5536 } 5537 return Unresolved; 5538 } 5539 5540 // If \p Base is ParenListExpr, assume a chain of comma operators and pick the 5541 // last expr. We expect other ParenListExprs to be resolved to e.g. constructor 5542 // calls before here. (So the ParenListExpr should be nonempty, but check just 5543 // in case) 5544 Expr *unwrapParenList(Expr *Base) { 5545 if (auto *PLE = llvm::dyn_cast_or_null<ParenListExpr>(Base)) { 5546 if (PLE->getNumExprs() == 0) 5547 return nullptr; 5548 Base = PLE->getExpr(PLE->getNumExprs() - 1); 5549 } 5550 return Base; 5551 } 5552 5553 } // namespace 5554 5555 void Sema::CodeCompleteMemberReferenceExpr(Scope *S, Expr *Base, 5556 Expr *OtherOpBase, 5557 SourceLocation OpLoc, bool IsArrow, 5558 bool IsBaseExprStatement, 5559 QualType PreferredType) { 5560 Base = unwrapParenList(Base); 5561 OtherOpBase = unwrapParenList(OtherOpBase); 5562 if (!Base || !CodeCompleter) 5563 return; 5564 5565 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow); 5566 if (ConvertedBase.isInvalid()) 5567 return; 5568 QualType ConvertedBaseType = getApproximateType(ConvertedBase.get()); 5569 5570 enum CodeCompletionContext::Kind contextKind; 5571 5572 if (IsArrow) { 5573 if (const auto *Ptr = ConvertedBaseType->getAs<PointerType>()) 5574 ConvertedBaseType = Ptr->getPointeeType(); 5575 } 5576 5577 if (IsArrow) { 5578 contextKind = CodeCompletionContext::CCC_ArrowMemberAccess; 5579 } else { 5580 if (ConvertedBaseType->isObjCObjectPointerType() || 5581 ConvertedBaseType->isObjCObjectOrInterfaceType()) { 5582 contextKind = CodeCompletionContext::CCC_ObjCPropertyAccess; 5583 } else { 5584 contextKind = CodeCompletionContext::CCC_DotMemberAccess; 5585 } 5586 } 5587 5588 CodeCompletionContext CCContext(contextKind, ConvertedBaseType); 5589 CCContext.setPreferredType(PreferredType); 5590 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 5591 CodeCompleter->getCodeCompletionTUInfo(), CCContext, 5592 &ResultBuilder::IsMember); 5593 5594 auto DoCompletion = [&](Expr *Base, bool IsArrow, 5595 Optional<FixItHint> AccessOpFixIt) -> bool { 5596 if (!Base) 5597 return false; 5598 5599 ExprResult ConvertedBase = PerformMemberExprBaseConversion(Base, IsArrow); 5600 if (ConvertedBase.isInvalid()) 5601 return false; 5602 Base = ConvertedBase.get(); 5603 5604 QualType BaseType = getApproximateType(Base); 5605 if (BaseType.isNull()) 5606 return false; 5607 ExprValueKind BaseKind = Base->getValueKind(); 5608 5609 if (IsArrow) { 5610 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) { 5611 BaseType = Ptr->getPointeeType(); 5612 BaseKind = VK_LValue; 5613 } else if (BaseType->isObjCObjectPointerType() || 5614 BaseType->isTemplateTypeParmType()) { 5615 // Both cases (dot/arrow) handled below. 5616 } else { 5617 return false; 5618 } 5619 } 5620 5621 if (RecordDecl *RD = getAsRecordDecl(BaseType)) { 5622 AddRecordMembersCompletionResults(*this, Results, S, BaseType, BaseKind, 5623 RD, std::move(AccessOpFixIt)); 5624 } else if (const auto *TTPT = 5625 dyn_cast<TemplateTypeParmType>(BaseType.getTypePtr())) { 5626 auto Operator = 5627 IsArrow ? ConceptInfo::Member::Arrow : ConceptInfo::Member::Dot; 5628 for (const auto &R : ConceptInfo(*TTPT, S).members()) { 5629 if (R.Operator != Operator) 5630 continue; 5631 CodeCompletionResult Result( 5632 R.render(*this, CodeCompleter->getAllocator(), 5633 CodeCompleter->getCodeCompletionTUInfo())); 5634 if (AccessOpFixIt) 5635 Result.FixIts.push_back(*AccessOpFixIt); 5636 Results.AddResult(std::move(Result)); 5637 } 5638 } else if (!IsArrow && BaseType->isObjCObjectPointerType()) { 5639 // Objective-C property reference. Bail if we're performing fix-it code 5640 // completion since Objective-C properties are normally backed by ivars, 5641 // most Objective-C fix-its here would have little value. 5642 if (AccessOpFixIt.hasValue()) { 5643 return false; 5644 } 5645 AddedPropertiesSet AddedProperties; 5646 5647 if (const ObjCObjectPointerType *ObjCPtr = 5648 BaseType->getAsObjCInterfacePointerType()) { 5649 // Add property results based on our interface. 5650 assert(ObjCPtr && "Non-NULL pointer guaranteed above!"); 5651 AddObjCProperties(CCContext, ObjCPtr->getInterfaceDecl(), true, 5652 /*AllowNullaryMethods=*/true, CurContext, 5653 AddedProperties, Results, IsBaseExprStatement); 5654 } 5655 5656 // Add properties from the protocols in a qualified interface. 5657 for (auto *I : BaseType->castAs<ObjCObjectPointerType>()->quals()) 5658 AddObjCProperties(CCContext, I, true, /*AllowNullaryMethods=*/true, 5659 CurContext, AddedProperties, Results, 5660 IsBaseExprStatement, /*IsClassProperty*/ false, 5661 /*InOriginalClass*/ false); 5662 } else if ((IsArrow && BaseType->isObjCObjectPointerType()) || 5663 (!IsArrow && BaseType->isObjCObjectType())) { 5664 // Objective-C instance variable access. Bail if we're performing fix-it 5665 // code completion since Objective-C properties are normally backed by 5666 // ivars, most Objective-C fix-its here would have little value. 5667 if (AccessOpFixIt.hasValue()) { 5668 return false; 5669 } 5670 ObjCInterfaceDecl *Class = nullptr; 5671 if (const ObjCObjectPointerType *ObjCPtr = 5672 BaseType->getAs<ObjCObjectPointerType>()) 5673 Class = ObjCPtr->getInterfaceDecl(); 5674 else 5675 Class = BaseType->castAs<ObjCObjectType>()->getInterface(); 5676 5677 // Add all ivars from this class and its superclasses. 5678 if (Class) { 5679 CodeCompletionDeclConsumer Consumer(Results, Class, BaseType); 5680 Results.setFilter(&ResultBuilder::IsObjCIvar); 5681 LookupVisibleDecls( 5682 Class, LookupMemberName, Consumer, CodeCompleter->includeGlobals(), 5683 /*IncludeDependentBases=*/false, CodeCompleter->loadExternal()); 5684 } 5685 } 5686 5687 // FIXME: How do we cope with isa? 5688 return true; 5689 }; 5690 5691 Results.EnterNewScope(); 5692 5693 bool CompletionSucceded = DoCompletion(Base, IsArrow, None); 5694 if (CodeCompleter->includeFixIts()) { 5695 const CharSourceRange OpRange = 5696 CharSourceRange::getTokenRange(OpLoc, OpLoc); 5697 CompletionSucceded |= DoCompletion( 5698 OtherOpBase, !IsArrow, 5699 FixItHint::CreateReplacement(OpRange, IsArrow ? "." : "->")); 5700 } 5701 5702 Results.ExitScope(); 5703 5704 if (!CompletionSucceded) 5705 return; 5706 5707 // Hand off the results found for code completion. 5708 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 5709 Results.data(), Results.size()); 5710 } 5711 5712 void Sema::CodeCompleteObjCClassPropertyRefExpr(Scope *S, 5713 IdentifierInfo &ClassName, 5714 SourceLocation ClassNameLoc, 5715 bool IsBaseExprStatement) { 5716 IdentifierInfo *ClassNamePtr = &ClassName; 5717 ObjCInterfaceDecl *IFace = getObjCInterfaceDecl(ClassNamePtr, ClassNameLoc); 5718 if (!IFace) 5719 return; 5720 CodeCompletionContext CCContext( 5721 CodeCompletionContext::CCC_ObjCPropertyAccess); 5722 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 5723 CodeCompleter->getCodeCompletionTUInfo(), CCContext, 5724 &ResultBuilder::IsMember); 5725 Results.EnterNewScope(); 5726 AddedPropertiesSet AddedProperties; 5727 AddObjCProperties(CCContext, IFace, true, 5728 /*AllowNullaryMethods=*/true, CurContext, AddedProperties, 5729 Results, IsBaseExprStatement, 5730 /*IsClassProperty=*/true); 5731 Results.ExitScope(); 5732 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 5733 Results.data(), Results.size()); 5734 } 5735 5736 void Sema::CodeCompleteTag(Scope *S, unsigned TagSpec) { 5737 if (!CodeCompleter) 5738 return; 5739 5740 ResultBuilder::LookupFilter Filter = nullptr; 5741 enum CodeCompletionContext::Kind ContextKind = 5742 CodeCompletionContext::CCC_Other; 5743 switch ((DeclSpec::TST)TagSpec) { 5744 case DeclSpec::TST_enum: 5745 Filter = &ResultBuilder::IsEnum; 5746 ContextKind = CodeCompletionContext::CCC_EnumTag; 5747 break; 5748 5749 case DeclSpec::TST_union: 5750 Filter = &ResultBuilder::IsUnion; 5751 ContextKind = CodeCompletionContext::CCC_UnionTag; 5752 break; 5753 5754 case DeclSpec::TST_struct: 5755 case DeclSpec::TST_class: 5756 case DeclSpec::TST_interface: 5757 Filter = &ResultBuilder::IsClassOrStruct; 5758 ContextKind = CodeCompletionContext::CCC_ClassOrStructTag; 5759 break; 5760 5761 default: 5762 llvm_unreachable("Unknown type specifier kind in CodeCompleteTag"); 5763 } 5764 5765 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 5766 CodeCompleter->getCodeCompletionTUInfo(), ContextKind); 5767 CodeCompletionDeclConsumer Consumer(Results, CurContext); 5768 5769 // First pass: look for tags. 5770 Results.setFilter(Filter); 5771 LookupVisibleDecls(S, LookupTagName, Consumer, 5772 CodeCompleter->includeGlobals(), 5773 CodeCompleter->loadExternal()); 5774 5775 if (CodeCompleter->includeGlobals()) { 5776 // Second pass: look for nested name specifiers. 5777 Results.setFilter(&ResultBuilder::IsNestedNameSpecifier); 5778 LookupVisibleDecls(S, LookupNestedNameSpecifierName, Consumer, 5779 CodeCompleter->includeGlobals(), 5780 CodeCompleter->loadExternal()); 5781 } 5782 5783 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 5784 Results.data(), Results.size()); 5785 } 5786 5787 static void AddTypeQualifierResults(DeclSpec &DS, ResultBuilder &Results, 5788 const LangOptions &LangOpts) { 5789 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_const)) 5790 Results.AddResult("const"); 5791 if (!(DS.getTypeQualifiers() & DeclSpec::TQ_volatile)) 5792 Results.AddResult("volatile"); 5793 if (LangOpts.C99 && !(DS.getTypeQualifiers() & DeclSpec::TQ_restrict)) 5794 Results.AddResult("restrict"); 5795 if (LangOpts.C11 && !(DS.getTypeQualifiers() & DeclSpec::TQ_atomic)) 5796 Results.AddResult("_Atomic"); 5797 if (LangOpts.MSVCCompat && !(DS.getTypeQualifiers() & DeclSpec::TQ_unaligned)) 5798 Results.AddResult("__unaligned"); 5799 } 5800 5801 void Sema::CodeCompleteTypeQualifiers(DeclSpec &DS) { 5802 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 5803 CodeCompleter->getCodeCompletionTUInfo(), 5804 CodeCompletionContext::CCC_TypeQualifiers); 5805 Results.EnterNewScope(); 5806 AddTypeQualifierResults(DS, Results, LangOpts); 5807 Results.ExitScope(); 5808 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 5809 Results.data(), Results.size()); 5810 } 5811 5812 void Sema::CodeCompleteFunctionQualifiers(DeclSpec &DS, Declarator &D, 5813 const VirtSpecifiers *VS) { 5814 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 5815 CodeCompleter->getCodeCompletionTUInfo(), 5816 CodeCompletionContext::CCC_TypeQualifiers); 5817 Results.EnterNewScope(); 5818 AddTypeQualifierResults(DS, Results, LangOpts); 5819 if (LangOpts.CPlusPlus11) { 5820 Results.AddResult("noexcept"); 5821 if (D.getContext() == DeclaratorContext::Member && !D.isCtorOrDtor() && 5822 !D.isStaticMember()) { 5823 if (!VS || !VS->isFinalSpecified()) 5824 Results.AddResult("final"); 5825 if (!VS || !VS->isOverrideSpecified()) 5826 Results.AddResult("override"); 5827 } 5828 } 5829 Results.ExitScope(); 5830 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 5831 Results.data(), Results.size()); 5832 } 5833 5834 void Sema::CodeCompleteBracketDeclarator(Scope *S) { 5835 CodeCompleteExpression(S, QualType(getASTContext().getSizeType())); 5836 } 5837 5838 void Sema::CodeCompleteCase(Scope *S) { 5839 if (getCurFunction()->SwitchStack.empty() || !CodeCompleter) 5840 return; 5841 5842 SwitchStmt *Switch = getCurFunction()->SwitchStack.back().getPointer(); 5843 // Condition expression might be invalid, do not continue in this case. 5844 if (!Switch->getCond()) 5845 return; 5846 QualType type = Switch->getCond()->IgnoreImplicit()->getType(); 5847 if (!type->isEnumeralType()) { 5848 CodeCompleteExpressionData Data(type); 5849 Data.IntegralConstantExpression = true; 5850 CodeCompleteExpression(S, Data); 5851 return; 5852 } 5853 5854 // Code-complete the cases of a switch statement over an enumeration type 5855 // by providing the list of 5856 EnumDecl *Enum = type->castAs<EnumType>()->getDecl(); 5857 if (EnumDecl *Def = Enum->getDefinition()) 5858 Enum = Def; 5859 5860 // Determine which enumerators we have already seen in the switch statement. 5861 // FIXME: Ideally, we would also be able to look *past* the code-completion 5862 // token, in case we are code-completing in the middle of the switch and not 5863 // at the end. However, we aren't able to do so at the moment. 5864 CoveredEnumerators Enumerators; 5865 for (SwitchCase *SC = Switch->getSwitchCaseList(); SC; 5866 SC = SC->getNextSwitchCase()) { 5867 CaseStmt *Case = dyn_cast<CaseStmt>(SC); 5868 if (!Case) 5869 continue; 5870 5871 Expr *CaseVal = Case->getLHS()->IgnoreParenCasts(); 5872 if (auto *DRE = dyn_cast<DeclRefExpr>(CaseVal)) 5873 if (auto *Enumerator = 5874 dyn_cast<EnumConstantDecl>(DRE->getDecl())) { 5875 // We look into the AST of the case statement to determine which 5876 // enumerator was named. Alternatively, we could compute the value of 5877 // the integral constant expression, then compare it against the 5878 // values of each enumerator. However, value-based approach would not 5879 // work as well with C++ templates where enumerators declared within a 5880 // template are type- and value-dependent. 5881 Enumerators.Seen.insert(Enumerator); 5882 5883 // If this is a qualified-id, keep track of the nested-name-specifier 5884 // so that we can reproduce it as part of code completion, e.g., 5885 // 5886 // switch (TagD.getKind()) { 5887 // case TagDecl::TK_enum: 5888 // break; 5889 // case XXX 5890 // 5891 // At the XXX, our completions are TagDecl::TK_union, 5892 // TagDecl::TK_struct, and TagDecl::TK_class, rather than TK_union, 5893 // TK_struct, and TK_class. 5894 Enumerators.SuggestedQualifier = DRE->getQualifier(); 5895 } 5896 } 5897 5898 // Add any enumerators that have not yet been mentioned. 5899 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 5900 CodeCompleter->getCodeCompletionTUInfo(), 5901 CodeCompletionContext::CCC_Expression); 5902 AddEnumerators(Results, Context, Enum, CurContext, Enumerators); 5903 5904 if (CodeCompleter->includeMacros()) { 5905 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false); 5906 } 5907 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 5908 Results.data(), Results.size()); 5909 } 5910 5911 static bool anyNullArguments(ArrayRef<Expr *> Args) { 5912 if (Args.size() && !Args.data()) 5913 return true; 5914 5915 for (unsigned I = 0; I != Args.size(); ++I) 5916 if (!Args[I]) 5917 return true; 5918 5919 return false; 5920 } 5921 5922 typedef CodeCompleteConsumer::OverloadCandidate ResultCandidate; 5923 5924 static void mergeCandidatesWithResults( 5925 Sema &SemaRef, SmallVectorImpl<ResultCandidate> &Results, 5926 OverloadCandidateSet &CandidateSet, SourceLocation Loc, size_t ArgSize) { 5927 // Sort the overload candidate set by placing the best overloads first. 5928 llvm::stable_sort(CandidateSet, [&](const OverloadCandidate &X, 5929 const OverloadCandidate &Y) { 5930 return isBetterOverloadCandidate(SemaRef, X, Y, Loc, 5931 CandidateSet.getKind()); 5932 }); 5933 5934 // Add the remaining viable overload candidates as code-completion results. 5935 for (OverloadCandidate &Candidate : CandidateSet) { 5936 if (Candidate.Function) { 5937 if (Candidate.Function->isDeleted()) 5938 continue; 5939 if (shouldEnforceArgLimit(/*PartialOverloading=*/true, 5940 Candidate.Function) && 5941 Candidate.Function->getNumParams() <= ArgSize && 5942 // Having zero args is annoying, normally we don't surface a function 5943 // with 2 params, if you already have 2 params, because you are 5944 // inserting the 3rd now. But with zero, it helps the user to figure 5945 // out there are no overloads that take any arguments. Hence we are 5946 // keeping the overload. 5947 ArgSize > 0) 5948 continue; 5949 } 5950 if (Candidate.Viable) 5951 Results.push_back(ResultCandidate(Candidate.Function)); 5952 } 5953 } 5954 5955 /// Get the type of the Nth parameter from a given set of overload 5956 /// candidates. 5957 static QualType getParamType(Sema &SemaRef, 5958 ArrayRef<ResultCandidate> Candidates, unsigned N) { 5959 5960 // Given the overloads 'Candidates' for a function call matching all arguments 5961 // up to N, return the type of the Nth parameter if it is the same for all 5962 // overload candidates. 5963 QualType ParamType; 5964 for (auto &Candidate : Candidates) { 5965 QualType CandidateParamType = Candidate.getParamType(N); 5966 if (CandidateParamType.isNull()) 5967 continue; 5968 if (ParamType.isNull()) { 5969 ParamType = CandidateParamType; 5970 continue; 5971 } 5972 if (!SemaRef.Context.hasSameUnqualifiedType( 5973 ParamType.getNonReferenceType(), 5974 CandidateParamType.getNonReferenceType())) 5975 // Two conflicting types, give up. 5976 return QualType(); 5977 } 5978 5979 return ParamType; 5980 } 5981 5982 static QualType 5983 ProduceSignatureHelp(Sema &SemaRef, MutableArrayRef<ResultCandidate> Candidates, 5984 unsigned CurrentArg, SourceLocation OpenParLoc, 5985 bool Braced) { 5986 if (Candidates.empty()) 5987 return QualType(); 5988 if (SemaRef.getPreprocessor().isCodeCompletionReached()) 5989 SemaRef.CodeCompleter->ProcessOverloadCandidates( 5990 SemaRef, CurrentArg, Candidates.data(), Candidates.size(), OpenParLoc, 5991 Braced); 5992 return getParamType(SemaRef, Candidates, CurrentArg); 5993 } 5994 5995 QualType Sema::ProduceCallSignatureHelp(Expr *Fn, ArrayRef<Expr *> Args, 5996 SourceLocation OpenParLoc) { 5997 Fn = unwrapParenList(Fn); 5998 if (!CodeCompleter || !Fn) 5999 return QualType(); 6000 6001 // FIXME: Provide support for variadic template functions. 6002 // Ignore type-dependent call expressions entirely. 6003 if (Fn->isTypeDependent() || anyNullArguments(Args)) 6004 return QualType(); 6005 // In presence of dependent args we surface all possible signatures using the 6006 // non-dependent args in the prefix. Afterwards we do a post filtering to make 6007 // sure provided candidates satisfy parameter count restrictions. 6008 auto ArgsWithoutDependentTypes = 6009 Args.take_while([](Expr *Arg) { return !Arg->isTypeDependent(); }); 6010 6011 SmallVector<ResultCandidate, 8> Results; 6012 6013 Expr *NakedFn = Fn->IgnoreParenCasts(); 6014 // Build an overload candidate set based on the functions we find. 6015 SourceLocation Loc = Fn->getExprLoc(); 6016 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal); 6017 6018 if (auto ULE = dyn_cast<UnresolvedLookupExpr>(NakedFn)) { 6019 AddOverloadedCallCandidates(ULE, ArgsWithoutDependentTypes, CandidateSet, 6020 /*PartialOverloading=*/true); 6021 } else if (auto UME = dyn_cast<UnresolvedMemberExpr>(NakedFn)) { 6022 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr; 6023 if (UME->hasExplicitTemplateArgs()) { 6024 UME->copyTemplateArgumentsInto(TemplateArgsBuffer); 6025 TemplateArgs = &TemplateArgsBuffer; 6026 } 6027 6028 // Add the base as first argument (use a nullptr if the base is implicit). 6029 SmallVector<Expr *, 12> ArgExprs( 6030 1, UME->isImplicitAccess() ? nullptr : UME->getBase()); 6031 ArgExprs.append(ArgsWithoutDependentTypes.begin(), 6032 ArgsWithoutDependentTypes.end()); 6033 UnresolvedSet<8> Decls; 6034 Decls.append(UME->decls_begin(), UME->decls_end()); 6035 const bool FirstArgumentIsBase = !UME->isImplicitAccess() && UME->getBase(); 6036 AddFunctionCandidates(Decls, ArgExprs, CandidateSet, TemplateArgs, 6037 /*SuppressUserConversions=*/false, 6038 /*PartialOverloading=*/true, FirstArgumentIsBase); 6039 } else { 6040 FunctionDecl *FD = nullptr; 6041 if (auto *MCE = dyn_cast<MemberExpr>(NakedFn)) 6042 FD = dyn_cast<FunctionDecl>(MCE->getMemberDecl()); 6043 else if (auto *DRE = dyn_cast<DeclRefExpr>(NakedFn)) 6044 FD = dyn_cast<FunctionDecl>(DRE->getDecl()); 6045 if (FD) { // We check whether it's a resolved function declaration. 6046 if (!getLangOpts().CPlusPlus || 6047 !FD->getType()->getAs<FunctionProtoType>()) 6048 Results.push_back(ResultCandidate(FD)); 6049 else 6050 AddOverloadCandidate(FD, DeclAccessPair::make(FD, FD->getAccess()), 6051 ArgsWithoutDependentTypes, CandidateSet, 6052 /*SuppressUserConversions=*/false, 6053 /*PartialOverloading=*/true); 6054 6055 } else if (auto DC = NakedFn->getType()->getAsCXXRecordDecl()) { 6056 // If expression's type is CXXRecordDecl, it may overload the function 6057 // call operator, so we check if it does and add them as candidates. 6058 // A complete type is needed to lookup for member function call operators. 6059 if (isCompleteType(Loc, NakedFn->getType())) { 6060 DeclarationName OpName = 6061 Context.DeclarationNames.getCXXOperatorName(OO_Call); 6062 LookupResult R(*this, OpName, Loc, LookupOrdinaryName); 6063 LookupQualifiedName(R, DC); 6064 R.suppressDiagnostics(); 6065 SmallVector<Expr *, 12> ArgExprs(1, NakedFn); 6066 ArgExprs.append(ArgsWithoutDependentTypes.begin(), 6067 ArgsWithoutDependentTypes.end()); 6068 AddFunctionCandidates(R.asUnresolvedSet(), ArgExprs, CandidateSet, 6069 /*ExplicitArgs=*/nullptr, 6070 /*SuppressUserConversions=*/false, 6071 /*PartialOverloading=*/true); 6072 } 6073 } else { 6074 // Lastly we check whether expression's type is function pointer or 6075 // function. 6076 QualType T = NakedFn->getType(); 6077 if (!T->getPointeeType().isNull()) 6078 T = T->getPointeeType(); 6079 6080 if (auto FP = T->getAs<FunctionProtoType>()) { 6081 if (!TooManyArguments(FP->getNumParams(), 6082 ArgsWithoutDependentTypes.size(), 6083 /*PartialOverloading=*/true) || 6084 FP->isVariadic()) 6085 Results.push_back(ResultCandidate(FP)); 6086 } else if (auto FT = T->getAs<FunctionType>()) 6087 // No prototype and declaration, it may be a K & R style function. 6088 Results.push_back(ResultCandidate(FT)); 6089 } 6090 } 6091 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc, Args.size()); 6092 QualType ParamType = ProduceSignatureHelp(*this, Results, Args.size(), 6093 OpenParLoc, /*Braced=*/false); 6094 return !CandidateSet.empty() ? ParamType : QualType(); 6095 } 6096 6097 // Determine which param to continue aggregate initialization from after 6098 // a designated initializer. 6099 // 6100 // Given struct S { int a,b,c,d,e; }: 6101 // after `S{.b=1,` we want to suggest c to continue 6102 // after `S{.b=1, 2,` we continue with d (this is legal C and ext in C++) 6103 // after `S{.b=1, .a=2,` we continue with b (this is legal C and ext in C++) 6104 // 6105 // Possible outcomes: 6106 // - we saw a designator for a field, and continue from the returned index. 6107 // Only aggregate initialization is allowed. 6108 // - we saw a designator, but it was complex or we couldn't find the field. 6109 // Only aggregate initialization is possible, but we can't assist with it. 6110 // Returns an out-of-range index. 6111 // - we saw no designators, just positional arguments. 6112 // Returns None. 6113 static llvm::Optional<unsigned> 6114 getNextAggregateIndexAfterDesignatedInit(const ResultCandidate &Aggregate, 6115 ArrayRef<Expr *> Args) { 6116 static constexpr unsigned Invalid = std::numeric_limits<unsigned>::max(); 6117 assert(Aggregate.getKind() == ResultCandidate::CK_Aggregate); 6118 6119 // Look for designated initializers. 6120 // They're in their syntactic form, not yet resolved to fields. 6121 IdentifierInfo *DesignatedFieldName = nullptr; 6122 unsigned ArgsAfterDesignator = 0; 6123 for (const Expr *Arg : Args) { 6124 if (const auto *DIE = dyn_cast<DesignatedInitExpr>(Arg)) { 6125 if (DIE->size() == 1 && DIE->getDesignator(0)->isFieldDesignator()) { 6126 DesignatedFieldName = DIE->getDesignator(0)->getFieldName(); 6127 ArgsAfterDesignator = 0; 6128 } else { 6129 return Invalid; // Complicated designator. 6130 } 6131 } else if (isa<DesignatedInitUpdateExpr>(Arg)) { 6132 return Invalid; // Unsupported. 6133 } else { 6134 ++ArgsAfterDesignator; 6135 } 6136 } 6137 if (!DesignatedFieldName) 6138 return llvm::None; 6139 6140 // Find the index within the class's fields. 6141 // (Probing getParamDecl() directly would be quadratic in number of fields). 6142 unsigned DesignatedIndex = 0; 6143 const FieldDecl *DesignatedField = nullptr; 6144 for (const auto *Field : Aggregate.getAggregate()->fields()) { 6145 if (Field->getIdentifier() == DesignatedFieldName) { 6146 DesignatedField = Field; 6147 break; 6148 } 6149 ++DesignatedIndex; 6150 } 6151 if (!DesignatedField) 6152 return Invalid; // Designator referred to a missing field, give up. 6153 6154 // Find the index within the aggregate (which may have leading bases). 6155 unsigned AggregateSize = Aggregate.getNumParams(); 6156 while (DesignatedIndex < AggregateSize && 6157 Aggregate.getParamDecl(DesignatedIndex) != DesignatedField) 6158 ++DesignatedIndex; 6159 6160 // Continue from the index after the last named field. 6161 return DesignatedIndex + ArgsAfterDesignator + 1; 6162 } 6163 6164 QualType Sema::ProduceConstructorSignatureHelp(QualType Type, 6165 SourceLocation Loc, 6166 ArrayRef<Expr *> Args, 6167 SourceLocation OpenParLoc, 6168 bool Braced) { 6169 if (!CodeCompleter) 6170 return QualType(); 6171 SmallVector<ResultCandidate, 8> Results; 6172 6173 // A complete type is needed to lookup for constructors. 6174 RecordDecl *RD = 6175 isCompleteType(Loc, Type) ? Type->getAsRecordDecl() : nullptr; 6176 if (!RD) 6177 return Type; 6178 CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD); 6179 6180 // Consider aggregate initialization. 6181 // We don't check that types so far are correct. 6182 // We also don't handle C99/C++17 brace-elision, we assume init-list elements 6183 // are 1:1 with fields. 6184 // FIXME: it would be nice to support "unwrapping" aggregates that contain 6185 // a single subaggregate, like std::array<T, N> -> T __elements[N]. 6186 if (Braced && !RD->isUnion() && 6187 (!LangOpts.CPlusPlus || (CRD && CRD->isAggregate()))) { 6188 ResultCandidate AggregateSig(RD); 6189 unsigned AggregateSize = AggregateSig.getNumParams(); 6190 6191 if (auto NextIndex = 6192 getNextAggregateIndexAfterDesignatedInit(AggregateSig, Args)) { 6193 // A designator was used, only aggregate init is possible. 6194 if (*NextIndex >= AggregateSize) 6195 return Type; 6196 Results.push_back(AggregateSig); 6197 return ProduceSignatureHelp(*this, Results, *NextIndex, OpenParLoc, 6198 Braced); 6199 } 6200 6201 // Describe aggregate initialization, but also constructors below. 6202 if (Args.size() < AggregateSize) 6203 Results.push_back(AggregateSig); 6204 } 6205 6206 // FIXME: Provide support for member initializers. 6207 // FIXME: Provide support for variadic template constructors. 6208 6209 if (CRD) { 6210 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal); 6211 for (NamedDecl *C : LookupConstructors(CRD)) { 6212 if (auto *FD = dyn_cast<FunctionDecl>(C)) { 6213 // FIXME: we can't yet provide correct signature help for initializer 6214 // list constructors, so skip them entirely. 6215 if (Braced && LangOpts.CPlusPlus && isInitListConstructor(FD)) 6216 continue; 6217 AddOverloadCandidate(FD, DeclAccessPair::make(FD, C->getAccess()), Args, 6218 CandidateSet, 6219 /*SuppressUserConversions=*/false, 6220 /*PartialOverloading=*/true, 6221 /*AllowExplicit*/ true); 6222 } else if (auto *FTD = dyn_cast<FunctionTemplateDecl>(C)) { 6223 if (Braced && LangOpts.CPlusPlus && 6224 isInitListConstructor(FTD->getTemplatedDecl())) 6225 continue; 6226 6227 AddTemplateOverloadCandidate( 6228 FTD, DeclAccessPair::make(FTD, C->getAccess()), 6229 /*ExplicitTemplateArgs=*/nullptr, Args, CandidateSet, 6230 /*SuppressUserConversions=*/false, 6231 /*PartialOverloading=*/true); 6232 } 6233 } 6234 mergeCandidatesWithResults(*this, Results, CandidateSet, Loc, Args.size()); 6235 } 6236 6237 return ProduceSignatureHelp(*this, Results, Args.size(), OpenParLoc, Braced); 6238 } 6239 6240 QualType Sema::ProduceCtorInitMemberSignatureHelp( 6241 Decl *ConstructorDecl, CXXScopeSpec SS, ParsedType TemplateTypeTy, 6242 ArrayRef<Expr *> ArgExprs, IdentifierInfo *II, SourceLocation OpenParLoc, 6243 bool Braced) { 6244 if (!CodeCompleter) 6245 return QualType(); 6246 6247 CXXConstructorDecl *Constructor = 6248 dyn_cast<CXXConstructorDecl>(ConstructorDecl); 6249 if (!Constructor) 6250 return QualType(); 6251 // FIXME: Add support for Base class constructors as well. 6252 if (ValueDecl *MemberDecl = tryLookupCtorInitMemberDecl( 6253 Constructor->getParent(), SS, TemplateTypeTy, II)) 6254 return ProduceConstructorSignatureHelp(MemberDecl->getType(), 6255 MemberDecl->getLocation(), ArgExprs, 6256 OpenParLoc, Braced); 6257 return QualType(); 6258 } 6259 6260 static bool argMatchesTemplateParams(const ParsedTemplateArgument &Arg, 6261 unsigned Index, 6262 const TemplateParameterList &Params) { 6263 const NamedDecl *Param; 6264 if (Index < Params.size()) 6265 Param = Params.getParam(Index); 6266 else if (Params.hasParameterPack()) 6267 Param = Params.asArray().back(); 6268 else 6269 return false; // too many args 6270 6271 switch (Arg.getKind()) { 6272 case ParsedTemplateArgument::Type: 6273 return llvm::isa<TemplateTypeParmDecl>(Param); // constraints not checked 6274 case ParsedTemplateArgument::NonType: 6275 return llvm::isa<NonTypeTemplateParmDecl>(Param); // type not checked 6276 case ParsedTemplateArgument::Template: 6277 return llvm::isa<TemplateTemplateParmDecl>(Param); // signature not checked 6278 } 6279 llvm_unreachable("Unhandled switch case"); 6280 } 6281 6282 QualType Sema::ProduceTemplateArgumentSignatureHelp( 6283 TemplateTy ParsedTemplate, ArrayRef<ParsedTemplateArgument> Args, 6284 SourceLocation LAngleLoc) { 6285 if (!CodeCompleter || !ParsedTemplate) 6286 return QualType(); 6287 6288 SmallVector<ResultCandidate, 8> Results; 6289 auto Consider = [&](const TemplateDecl *TD) { 6290 // Only add if the existing args are compatible with the template. 6291 bool Matches = true; 6292 for (unsigned I = 0; I < Args.size(); ++I) { 6293 if (!argMatchesTemplateParams(Args[I], I, *TD->getTemplateParameters())) { 6294 Matches = false; 6295 break; 6296 } 6297 } 6298 if (Matches) 6299 Results.emplace_back(TD); 6300 }; 6301 6302 TemplateName Template = ParsedTemplate.get(); 6303 if (const auto *TD = Template.getAsTemplateDecl()) { 6304 Consider(TD); 6305 } else if (const auto *OTS = Template.getAsOverloadedTemplate()) { 6306 for (const NamedDecl *ND : *OTS) 6307 if (const auto *TD = llvm::dyn_cast<TemplateDecl>(ND)) 6308 Consider(TD); 6309 } 6310 return ProduceSignatureHelp(*this, Results, Args.size(), LAngleLoc, 6311 /*Braced=*/false); 6312 } 6313 6314 static QualType getDesignatedType(QualType BaseType, const Designation &Desig) { 6315 for (unsigned I = 0; I < Desig.getNumDesignators(); ++I) { 6316 if (BaseType.isNull()) 6317 break; 6318 QualType NextType; 6319 const auto &D = Desig.getDesignator(I); 6320 if (D.isArrayDesignator() || D.isArrayRangeDesignator()) { 6321 if (BaseType->isArrayType()) 6322 NextType = BaseType->getAsArrayTypeUnsafe()->getElementType(); 6323 } else { 6324 assert(D.isFieldDesignator()); 6325 auto *RD = getAsRecordDecl(BaseType); 6326 if (RD && RD->isCompleteDefinition()) { 6327 for (const auto *Member : RD->lookup(D.getField())) 6328 if (const FieldDecl *FD = llvm::dyn_cast<FieldDecl>(Member)) { 6329 NextType = FD->getType(); 6330 break; 6331 } 6332 } 6333 } 6334 BaseType = NextType; 6335 } 6336 return BaseType; 6337 } 6338 6339 void Sema::CodeCompleteDesignator(QualType BaseType, 6340 llvm::ArrayRef<Expr *> InitExprs, 6341 const Designation &D) { 6342 BaseType = getDesignatedType(BaseType, D); 6343 if (BaseType.isNull()) 6344 return; 6345 const auto *RD = getAsRecordDecl(BaseType); 6346 if (!RD || RD->fields().empty()) 6347 return; 6348 6349 CodeCompletionContext CCC(CodeCompletionContext::CCC_DotMemberAccess, 6350 BaseType); 6351 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 6352 CodeCompleter->getCodeCompletionTUInfo(), CCC); 6353 6354 Results.EnterNewScope(); 6355 for (const Decl *D : RD->decls()) { 6356 const FieldDecl *FD; 6357 if (auto *IFD = dyn_cast<IndirectFieldDecl>(D)) 6358 FD = IFD->getAnonField(); 6359 else if (auto *DFD = dyn_cast<FieldDecl>(D)) 6360 FD = DFD; 6361 else 6362 continue; 6363 6364 // FIXME: Make use of previous designators to mark any fields before those 6365 // inaccessible, and also compute the next initializer priority. 6366 ResultBuilder::Result Result(FD, Results.getBasePriority(FD)); 6367 Results.AddResult(Result, CurContext, /*Hiding=*/nullptr); 6368 } 6369 Results.ExitScope(); 6370 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 6371 Results.data(), Results.size()); 6372 } 6373 6374 void Sema::CodeCompleteInitializer(Scope *S, Decl *D) { 6375 ValueDecl *VD = dyn_cast_or_null<ValueDecl>(D); 6376 if (!VD) { 6377 CodeCompleteOrdinaryName(S, PCC_Expression); 6378 return; 6379 } 6380 6381 CodeCompleteExpressionData Data; 6382 Data.PreferredType = VD->getType(); 6383 // Ignore VD to avoid completing the variable itself, e.g. in 'int foo = ^'. 6384 Data.IgnoreDecls.push_back(VD); 6385 6386 CodeCompleteExpression(S, Data); 6387 } 6388 6389 void Sema::CodeCompleteAfterIf(Scope *S, bool IsBracedThen) { 6390 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 6391 CodeCompleter->getCodeCompletionTUInfo(), 6392 mapCodeCompletionContext(*this, PCC_Statement)); 6393 Results.setFilter(&ResultBuilder::IsOrdinaryName); 6394 Results.EnterNewScope(); 6395 6396 CodeCompletionDeclConsumer Consumer(Results, CurContext); 6397 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 6398 CodeCompleter->includeGlobals(), 6399 CodeCompleter->loadExternal()); 6400 6401 AddOrdinaryNameResults(PCC_Statement, S, *this, Results); 6402 6403 // "else" block 6404 CodeCompletionBuilder Builder(Results.getAllocator(), 6405 Results.getCodeCompletionTUInfo()); 6406 6407 auto AddElseBodyPattern = [&] { 6408 if (IsBracedThen) { 6409 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 6410 Builder.AddChunk(CodeCompletionString::CK_LeftBrace); 6411 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 6412 Builder.AddPlaceholderChunk("statements"); 6413 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 6414 Builder.AddChunk(CodeCompletionString::CK_RightBrace); 6415 } else { 6416 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 6417 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 6418 Builder.AddPlaceholderChunk("statement"); 6419 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 6420 } 6421 }; 6422 Builder.AddTypedTextChunk("else"); 6423 if (Results.includeCodePatterns()) 6424 AddElseBodyPattern(); 6425 Results.AddResult(Builder.TakeString()); 6426 6427 // "else if" block 6428 Builder.AddTypedTextChunk("else if"); 6429 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 6430 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 6431 if (getLangOpts().CPlusPlus) 6432 Builder.AddPlaceholderChunk("condition"); 6433 else 6434 Builder.AddPlaceholderChunk("expression"); 6435 Builder.AddChunk(CodeCompletionString::CK_RightParen); 6436 if (Results.includeCodePatterns()) { 6437 AddElseBodyPattern(); 6438 } 6439 Results.AddResult(Builder.TakeString()); 6440 6441 Results.ExitScope(); 6442 6443 if (S->getFnParent()) 6444 AddPrettyFunctionResults(getLangOpts(), Results); 6445 6446 if (CodeCompleter->includeMacros()) 6447 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false); 6448 6449 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 6450 Results.data(), Results.size()); 6451 } 6452 6453 void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS, 6454 bool EnteringContext, 6455 bool IsUsingDeclaration, QualType BaseType, 6456 QualType PreferredType) { 6457 if (SS.isEmpty() || !CodeCompleter) 6458 return; 6459 6460 CodeCompletionContext CC(CodeCompletionContext::CCC_Symbol, PreferredType); 6461 CC.setIsUsingDeclaration(IsUsingDeclaration); 6462 CC.setCXXScopeSpecifier(SS); 6463 6464 // We want to keep the scope specifier even if it's invalid (e.g. the scope 6465 // "a::b::" is not corresponding to any context/namespace in the AST), since 6466 // it can be useful for global code completion which have information about 6467 // contexts/symbols that are not in the AST. 6468 if (SS.isInvalid()) { 6469 // As SS is invalid, we try to collect accessible contexts from the current 6470 // scope with a dummy lookup so that the completion consumer can try to 6471 // guess what the specified scope is. 6472 ResultBuilder DummyResults(*this, CodeCompleter->getAllocator(), 6473 CodeCompleter->getCodeCompletionTUInfo(), CC); 6474 if (!PreferredType.isNull()) 6475 DummyResults.setPreferredType(PreferredType); 6476 if (S->getEntity()) { 6477 CodeCompletionDeclConsumer Consumer(DummyResults, S->getEntity(), 6478 BaseType); 6479 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 6480 /*IncludeGlobalScope=*/false, 6481 /*LoadExternal=*/false); 6482 } 6483 HandleCodeCompleteResults(this, CodeCompleter, 6484 DummyResults.getCompletionContext(), nullptr, 0); 6485 return; 6486 } 6487 // Always pretend to enter a context to ensure that a dependent type 6488 // resolves to a dependent record. 6489 DeclContext *Ctx = computeDeclContext(SS, /*EnteringContext=*/true); 6490 6491 // Try to instantiate any non-dependent declaration contexts before 6492 // we look in them. Bail out if we fail. 6493 NestedNameSpecifier *NNS = SS.getScopeRep(); 6494 if (NNS != nullptr && SS.isValid() && !NNS->isDependent()) { 6495 if (Ctx == nullptr || RequireCompleteDeclContext(SS, Ctx)) 6496 return; 6497 } 6498 6499 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 6500 CodeCompleter->getCodeCompletionTUInfo(), CC); 6501 if (!PreferredType.isNull()) 6502 Results.setPreferredType(PreferredType); 6503 Results.EnterNewScope(); 6504 6505 // The "template" keyword can follow "::" in the grammar, but only 6506 // put it into the grammar if the nested-name-specifier is dependent. 6507 // FIXME: results is always empty, this appears to be dead. 6508 if (!Results.empty() && NNS->isDependent()) 6509 Results.AddResult("template"); 6510 6511 // If the scope is a concept-constrained type parameter, infer nested 6512 // members based on the constraints. 6513 if (const auto *TTPT = 6514 dyn_cast_or_null<TemplateTypeParmType>(NNS->getAsType())) { 6515 for (const auto &R : ConceptInfo(*TTPT, S).members()) { 6516 if (R.Operator != ConceptInfo::Member::Colons) 6517 continue; 6518 Results.AddResult(CodeCompletionResult( 6519 R.render(*this, CodeCompleter->getAllocator(), 6520 CodeCompleter->getCodeCompletionTUInfo()))); 6521 } 6522 } 6523 6524 // Add calls to overridden virtual functions, if there are any. 6525 // 6526 // FIXME: This isn't wonderful, because we don't know whether we're actually 6527 // in a context that permits expressions. This is a general issue with 6528 // qualified-id completions. 6529 if (Ctx && !EnteringContext) 6530 MaybeAddOverrideCalls(*this, Ctx, Results); 6531 Results.ExitScope(); 6532 6533 if (Ctx && 6534 (CodeCompleter->includeNamespaceLevelDecls() || !Ctx->isFileContext())) { 6535 CodeCompletionDeclConsumer Consumer(Results, Ctx, BaseType); 6536 LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer, 6537 /*IncludeGlobalScope=*/true, 6538 /*IncludeDependentBases=*/true, 6539 CodeCompleter->loadExternal()); 6540 } 6541 6542 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 6543 Results.data(), Results.size()); 6544 } 6545 6546 void Sema::CodeCompleteUsing(Scope *S) { 6547 if (!CodeCompleter) 6548 return; 6549 6550 // This can be both a using alias or using declaration, in the former we 6551 // expect a new name and a symbol in the latter case. 6552 CodeCompletionContext Context(CodeCompletionContext::CCC_SymbolOrNewName); 6553 Context.setIsUsingDeclaration(true); 6554 6555 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 6556 CodeCompleter->getCodeCompletionTUInfo(), Context, 6557 &ResultBuilder::IsNestedNameSpecifier); 6558 Results.EnterNewScope(); 6559 6560 // If we aren't in class scope, we could see the "namespace" keyword. 6561 if (!S->isClassScope()) 6562 Results.AddResult(CodeCompletionResult("namespace")); 6563 6564 // After "using", we can see anything that would start a 6565 // nested-name-specifier. 6566 CodeCompletionDeclConsumer Consumer(Results, CurContext); 6567 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 6568 CodeCompleter->includeGlobals(), 6569 CodeCompleter->loadExternal()); 6570 Results.ExitScope(); 6571 6572 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 6573 Results.data(), Results.size()); 6574 } 6575 6576 void Sema::CodeCompleteUsingDirective(Scope *S) { 6577 if (!CodeCompleter) 6578 return; 6579 6580 // After "using namespace", we expect to see a namespace name or namespace 6581 // alias. 6582 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 6583 CodeCompleter->getCodeCompletionTUInfo(), 6584 CodeCompletionContext::CCC_Namespace, 6585 &ResultBuilder::IsNamespaceOrAlias); 6586 Results.EnterNewScope(); 6587 CodeCompletionDeclConsumer Consumer(Results, CurContext); 6588 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 6589 CodeCompleter->includeGlobals(), 6590 CodeCompleter->loadExternal()); 6591 Results.ExitScope(); 6592 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 6593 Results.data(), Results.size()); 6594 } 6595 6596 void Sema::CodeCompleteNamespaceDecl(Scope *S) { 6597 if (!CodeCompleter) 6598 return; 6599 6600 DeclContext *Ctx = S->getEntity(); 6601 if (!S->getParent()) 6602 Ctx = Context.getTranslationUnitDecl(); 6603 6604 bool SuppressedGlobalResults = 6605 Ctx && !CodeCompleter->includeGlobals() && isa<TranslationUnitDecl>(Ctx); 6606 6607 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 6608 CodeCompleter->getCodeCompletionTUInfo(), 6609 SuppressedGlobalResults 6610 ? CodeCompletionContext::CCC_Namespace 6611 : CodeCompletionContext::CCC_Other, 6612 &ResultBuilder::IsNamespace); 6613 6614 if (Ctx && Ctx->isFileContext() && !SuppressedGlobalResults) { 6615 // We only want to see those namespaces that have already been defined 6616 // within this scope, because its likely that the user is creating an 6617 // extended namespace declaration. Keep track of the most recent 6618 // definition of each namespace. 6619 std::map<NamespaceDecl *, NamespaceDecl *> OrigToLatest; 6620 for (DeclContext::specific_decl_iterator<NamespaceDecl> 6621 NS(Ctx->decls_begin()), 6622 NSEnd(Ctx->decls_end()); 6623 NS != NSEnd; ++NS) 6624 OrigToLatest[NS->getOriginalNamespace()] = *NS; 6625 6626 // Add the most recent definition (or extended definition) of each 6627 // namespace to the list of results. 6628 Results.EnterNewScope(); 6629 for (std::map<NamespaceDecl *, NamespaceDecl *>::iterator 6630 NS = OrigToLatest.begin(), 6631 NSEnd = OrigToLatest.end(); 6632 NS != NSEnd; ++NS) 6633 Results.AddResult( 6634 CodeCompletionResult(NS->second, Results.getBasePriority(NS->second), 6635 nullptr), 6636 CurContext, nullptr, false); 6637 Results.ExitScope(); 6638 } 6639 6640 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 6641 Results.data(), Results.size()); 6642 } 6643 6644 void Sema::CodeCompleteNamespaceAliasDecl(Scope *S) { 6645 if (!CodeCompleter) 6646 return; 6647 6648 // After "namespace", we expect to see a namespace or alias. 6649 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 6650 CodeCompleter->getCodeCompletionTUInfo(), 6651 CodeCompletionContext::CCC_Namespace, 6652 &ResultBuilder::IsNamespaceOrAlias); 6653 CodeCompletionDeclConsumer Consumer(Results, CurContext); 6654 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 6655 CodeCompleter->includeGlobals(), 6656 CodeCompleter->loadExternal()); 6657 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 6658 Results.data(), Results.size()); 6659 } 6660 6661 void Sema::CodeCompleteOperatorName(Scope *S) { 6662 if (!CodeCompleter) 6663 return; 6664 6665 typedef CodeCompletionResult Result; 6666 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 6667 CodeCompleter->getCodeCompletionTUInfo(), 6668 CodeCompletionContext::CCC_Type, 6669 &ResultBuilder::IsType); 6670 Results.EnterNewScope(); 6671 6672 // Add the names of overloadable operators. Note that OO_Conditional is not 6673 // actually overloadable. 6674 #define OVERLOADED_OPERATOR(Name, Spelling, Token, Unary, Binary, MemberOnly) \ 6675 if (OO_##Name != OO_Conditional) \ 6676 Results.AddResult(Result(Spelling)); 6677 #include "clang/Basic/OperatorKinds.def" 6678 6679 // Add any type names visible from the current scope 6680 Results.allowNestedNameSpecifiers(); 6681 CodeCompletionDeclConsumer Consumer(Results, CurContext); 6682 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 6683 CodeCompleter->includeGlobals(), 6684 CodeCompleter->loadExternal()); 6685 6686 // Add any type specifiers 6687 AddTypeSpecifierResults(getLangOpts(), Results); 6688 Results.ExitScope(); 6689 6690 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 6691 Results.data(), Results.size()); 6692 } 6693 6694 void Sema::CodeCompleteConstructorInitializer( 6695 Decl *ConstructorD, ArrayRef<CXXCtorInitializer *> Initializers) { 6696 if (!ConstructorD) 6697 return; 6698 6699 AdjustDeclIfTemplate(ConstructorD); 6700 6701 auto *Constructor = dyn_cast<CXXConstructorDecl>(ConstructorD); 6702 if (!Constructor) 6703 return; 6704 6705 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 6706 CodeCompleter->getCodeCompletionTUInfo(), 6707 CodeCompletionContext::CCC_Symbol); 6708 Results.EnterNewScope(); 6709 6710 // Fill in any already-initialized fields or base classes. 6711 llvm::SmallPtrSet<FieldDecl *, 4> InitializedFields; 6712 llvm::SmallPtrSet<CanQualType, 4> InitializedBases; 6713 for (unsigned I = 0, E = Initializers.size(); I != E; ++I) { 6714 if (Initializers[I]->isBaseInitializer()) 6715 InitializedBases.insert(Context.getCanonicalType( 6716 QualType(Initializers[I]->getBaseClass(), 0))); 6717 else 6718 InitializedFields.insert( 6719 cast<FieldDecl>(Initializers[I]->getAnyMember())); 6720 } 6721 6722 // Add completions for base classes. 6723 PrintingPolicy Policy = getCompletionPrintingPolicy(*this); 6724 bool SawLastInitializer = Initializers.empty(); 6725 CXXRecordDecl *ClassDecl = Constructor->getParent(); 6726 6727 auto GenerateCCS = [&](const NamedDecl *ND, const char *Name) { 6728 CodeCompletionBuilder Builder(Results.getAllocator(), 6729 Results.getCodeCompletionTUInfo()); 6730 Builder.AddTypedTextChunk(Name); 6731 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 6732 if (const auto *Function = dyn_cast<FunctionDecl>(ND)) 6733 AddFunctionParameterChunks(PP, Policy, Function, Builder); 6734 else if (const auto *FunTemplDecl = dyn_cast<FunctionTemplateDecl>(ND)) 6735 AddFunctionParameterChunks(PP, Policy, FunTemplDecl->getTemplatedDecl(), 6736 Builder); 6737 Builder.AddChunk(CodeCompletionString::CK_RightParen); 6738 return Builder.TakeString(); 6739 }; 6740 auto AddDefaultCtorInit = [&](const char *Name, const char *Type, 6741 const NamedDecl *ND) { 6742 CodeCompletionBuilder Builder(Results.getAllocator(), 6743 Results.getCodeCompletionTUInfo()); 6744 Builder.AddTypedTextChunk(Name); 6745 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 6746 Builder.AddPlaceholderChunk(Type); 6747 Builder.AddChunk(CodeCompletionString::CK_RightParen); 6748 if (ND) { 6749 auto CCR = CodeCompletionResult( 6750 Builder.TakeString(), ND, 6751 SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration); 6752 if (isa<FieldDecl>(ND)) 6753 CCR.CursorKind = CXCursor_MemberRef; 6754 return Results.AddResult(CCR); 6755 } 6756 return Results.AddResult(CodeCompletionResult( 6757 Builder.TakeString(), 6758 SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration)); 6759 }; 6760 auto AddCtorsWithName = [&](const CXXRecordDecl *RD, unsigned int Priority, 6761 const char *Name, const FieldDecl *FD) { 6762 if (!RD) 6763 return AddDefaultCtorInit(Name, 6764 FD ? Results.getAllocator().CopyString( 6765 FD->getType().getAsString(Policy)) 6766 : Name, 6767 FD); 6768 auto Ctors = getConstructors(Context, RD); 6769 if (Ctors.begin() == Ctors.end()) 6770 return AddDefaultCtorInit(Name, Name, RD); 6771 for (const NamedDecl *Ctor : Ctors) { 6772 auto CCR = CodeCompletionResult(GenerateCCS(Ctor, Name), RD, Priority); 6773 CCR.CursorKind = getCursorKindForDecl(Ctor); 6774 Results.AddResult(CCR); 6775 } 6776 }; 6777 auto AddBase = [&](const CXXBaseSpecifier &Base) { 6778 const char *BaseName = 6779 Results.getAllocator().CopyString(Base.getType().getAsString(Policy)); 6780 const auto *RD = Base.getType()->getAsCXXRecordDecl(); 6781 AddCtorsWithName( 6782 RD, SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration, 6783 BaseName, nullptr); 6784 }; 6785 auto AddField = [&](const FieldDecl *FD) { 6786 const char *FieldName = 6787 Results.getAllocator().CopyString(FD->getIdentifier()->getName()); 6788 const CXXRecordDecl *RD = FD->getType()->getAsCXXRecordDecl(); 6789 AddCtorsWithName( 6790 RD, SawLastInitializer ? CCP_NextInitializer : CCP_MemberDeclaration, 6791 FieldName, FD); 6792 }; 6793 6794 for (const auto &Base : ClassDecl->bases()) { 6795 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType())) 6796 .second) { 6797 SawLastInitializer = 6798 !Initializers.empty() && Initializers.back()->isBaseInitializer() && 6799 Context.hasSameUnqualifiedType( 6800 Base.getType(), QualType(Initializers.back()->getBaseClass(), 0)); 6801 continue; 6802 } 6803 6804 AddBase(Base); 6805 SawLastInitializer = false; 6806 } 6807 6808 // Add completions for virtual base classes. 6809 for (const auto &Base : ClassDecl->vbases()) { 6810 if (!InitializedBases.insert(Context.getCanonicalType(Base.getType())) 6811 .second) { 6812 SawLastInitializer = 6813 !Initializers.empty() && Initializers.back()->isBaseInitializer() && 6814 Context.hasSameUnqualifiedType( 6815 Base.getType(), QualType(Initializers.back()->getBaseClass(), 0)); 6816 continue; 6817 } 6818 6819 AddBase(Base); 6820 SawLastInitializer = false; 6821 } 6822 6823 // Add completions for members. 6824 for (auto *Field : ClassDecl->fields()) { 6825 if (!InitializedFields.insert(cast<FieldDecl>(Field->getCanonicalDecl())) 6826 .second) { 6827 SawLastInitializer = !Initializers.empty() && 6828 Initializers.back()->isAnyMemberInitializer() && 6829 Initializers.back()->getAnyMember() == Field; 6830 continue; 6831 } 6832 6833 if (!Field->getDeclName()) 6834 continue; 6835 6836 AddField(Field); 6837 SawLastInitializer = false; 6838 } 6839 Results.ExitScope(); 6840 6841 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 6842 Results.data(), Results.size()); 6843 } 6844 6845 /// Determine whether this scope denotes a namespace. 6846 static bool isNamespaceScope(Scope *S) { 6847 DeclContext *DC = S->getEntity(); 6848 if (!DC) 6849 return false; 6850 6851 return DC->isFileContext(); 6852 } 6853 6854 void Sema::CodeCompleteLambdaIntroducer(Scope *S, LambdaIntroducer &Intro, 6855 bool AfterAmpersand) { 6856 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 6857 CodeCompleter->getCodeCompletionTUInfo(), 6858 CodeCompletionContext::CCC_Other); 6859 Results.EnterNewScope(); 6860 6861 // Note what has already been captured. 6862 llvm::SmallPtrSet<IdentifierInfo *, 4> Known; 6863 bool IncludedThis = false; 6864 for (const auto &C : Intro.Captures) { 6865 if (C.Kind == LCK_This) { 6866 IncludedThis = true; 6867 continue; 6868 } 6869 6870 Known.insert(C.Id); 6871 } 6872 6873 // Look for other capturable variables. 6874 for (; S && !isNamespaceScope(S); S = S->getParent()) { 6875 for (const auto *D : S->decls()) { 6876 const auto *Var = dyn_cast<VarDecl>(D); 6877 if (!Var || !Var->hasLocalStorage() || Var->hasAttr<BlocksAttr>()) 6878 continue; 6879 6880 if (Known.insert(Var->getIdentifier()).second) 6881 Results.AddResult(CodeCompletionResult(Var, CCP_LocalDeclaration), 6882 CurContext, nullptr, false); 6883 } 6884 } 6885 6886 // Add 'this', if it would be valid. 6887 if (!IncludedThis && !AfterAmpersand && Intro.Default != LCD_ByCopy) 6888 addThisCompletion(*this, Results); 6889 6890 Results.ExitScope(); 6891 6892 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 6893 Results.data(), Results.size()); 6894 } 6895 6896 void Sema::CodeCompleteAfterFunctionEquals(Declarator &D) { 6897 if (!LangOpts.CPlusPlus11) 6898 return; 6899 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 6900 CodeCompleter->getCodeCompletionTUInfo(), 6901 CodeCompletionContext::CCC_Other); 6902 auto ShouldAddDefault = [&D, this]() { 6903 if (!D.isFunctionDeclarator()) 6904 return false; 6905 auto &Id = D.getName(); 6906 if (Id.getKind() == UnqualifiedIdKind::IK_DestructorName) 6907 return true; 6908 // FIXME(liuhui): Ideally, we should check the constructor parameter list to 6909 // verify that it is the default, copy or move constructor? 6910 if (Id.getKind() == UnqualifiedIdKind::IK_ConstructorName && 6911 D.getFunctionTypeInfo().NumParams <= 1) 6912 return true; 6913 if (Id.getKind() == UnqualifiedIdKind::IK_OperatorFunctionId) { 6914 auto Op = Id.OperatorFunctionId.Operator; 6915 // FIXME(liuhui): Ideally, we should check the function parameter list to 6916 // verify that it is the copy or move assignment? 6917 if (Op == OverloadedOperatorKind::OO_Equal) 6918 return true; 6919 if (LangOpts.CPlusPlus20 && 6920 (Op == OverloadedOperatorKind::OO_EqualEqual || 6921 Op == OverloadedOperatorKind::OO_ExclaimEqual || 6922 Op == OverloadedOperatorKind::OO_Less || 6923 Op == OverloadedOperatorKind::OO_LessEqual || 6924 Op == OverloadedOperatorKind::OO_Greater || 6925 Op == OverloadedOperatorKind::OO_GreaterEqual || 6926 Op == OverloadedOperatorKind::OO_Spaceship)) 6927 return true; 6928 } 6929 return false; 6930 }; 6931 6932 Results.EnterNewScope(); 6933 if (ShouldAddDefault()) 6934 Results.AddResult("default"); 6935 // FIXME(liuhui): Ideally, we should only provide `delete` completion for the 6936 // first function declaration. 6937 Results.AddResult("delete"); 6938 Results.ExitScope(); 6939 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 6940 Results.data(), Results.size()); 6941 } 6942 6943 /// Macro that optionally prepends an "@" to the string literal passed in via 6944 /// Keyword, depending on whether NeedAt is true or false. 6945 #define OBJC_AT_KEYWORD_NAME(NeedAt, Keyword) ((NeedAt) ? "@" Keyword : Keyword) 6946 6947 static void AddObjCImplementationResults(const LangOptions &LangOpts, 6948 ResultBuilder &Results, bool NeedAt) { 6949 typedef CodeCompletionResult Result; 6950 // Since we have an implementation, we can end it. 6951 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "end"))); 6952 6953 CodeCompletionBuilder Builder(Results.getAllocator(), 6954 Results.getCodeCompletionTUInfo()); 6955 if (LangOpts.ObjC) { 6956 // @dynamic 6957 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "dynamic")); 6958 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 6959 Builder.AddPlaceholderChunk("property"); 6960 Results.AddResult(Result(Builder.TakeString())); 6961 6962 // @synthesize 6963 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "synthesize")); 6964 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 6965 Builder.AddPlaceholderChunk("property"); 6966 Results.AddResult(Result(Builder.TakeString())); 6967 } 6968 } 6969 6970 static void AddObjCInterfaceResults(const LangOptions &LangOpts, 6971 ResultBuilder &Results, bool NeedAt) { 6972 typedef CodeCompletionResult Result; 6973 6974 // Since we have an interface or protocol, we can end it. 6975 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "end"))); 6976 6977 if (LangOpts.ObjC) { 6978 // @property 6979 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "property"))); 6980 6981 // @required 6982 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "required"))); 6983 6984 // @optional 6985 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "optional"))); 6986 } 6987 } 6988 6989 static void AddObjCTopLevelResults(ResultBuilder &Results, bool NeedAt) { 6990 typedef CodeCompletionResult Result; 6991 CodeCompletionBuilder Builder(Results.getAllocator(), 6992 Results.getCodeCompletionTUInfo()); 6993 6994 // @class name ; 6995 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "class")); 6996 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 6997 Builder.AddPlaceholderChunk("name"); 6998 Results.AddResult(Result(Builder.TakeString())); 6999 7000 if (Results.includeCodePatterns()) { 7001 // @interface name 7002 // FIXME: Could introduce the whole pattern, including superclasses and 7003 // such. 7004 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "interface")); 7005 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 7006 Builder.AddPlaceholderChunk("class"); 7007 Results.AddResult(Result(Builder.TakeString())); 7008 7009 // @protocol name 7010 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "protocol")); 7011 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 7012 Builder.AddPlaceholderChunk("protocol"); 7013 Results.AddResult(Result(Builder.TakeString())); 7014 7015 // @implementation name 7016 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "implementation")); 7017 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 7018 Builder.AddPlaceholderChunk("class"); 7019 Results.AddResult(Result(Builder.TakeString())); 7020 } 7021 7022 // @compatibility_alias name 7023 Builder.AddTypedTextChunk( 7024 OBJC_AT_KEYWORD_NAME(NeedAt, "compatibility_alias")); 7025 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 7026 Builder.AddPlaceholderChunk("alias"); 7027 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 7028 Builder.AddPlaceholderChunk("class"); 7029 Results.AddResult(Result(Builder.TakeString())); 7030 7031 if (Results.getSema().getLangOpts().Modules) { 7032 // @import name 7033 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "import")); 7034 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 7035 Builder.AddPlaceholderChunk("module"); 7036 Results.AddResult(Result(Builder.TakeString())); 7037 } 7038 } 7039 7040 void Sema::CodeCompleteObjCAtDirective(Scope *S) { 7041 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 7042 CodeCompleter->getCodeCompletionTUInfo(), 7043 CodeCompletionContext::CCC_Other); 7044 Results.EnterNewScope(); 7045 if (isa<ObjCImplDecl>(CurContext)) 7046 AddObjCImplementationResults(getLangOpts(), Results, false); 7047 else if (CurContext->isObjCContainer()) 7048 AddObjCInterfaceResults(getLangOpts(), Results, false); 7049 else 7050 AddObjCTopLevelResults(Results, false); 7051 Results.ExitScope(); 7052 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 7053 Results.data(), Results.size()); 7054 } 7055 7056 static void AddObjCExpressionResults(ResultBuilder &Results, bool NeedAt) { 7057 typedef CodeCompletionResult Result; 7058 CodeCompletionBuilder Builder(Results.getAllocator(), 7059 Results.getCodeCompletionTUInfo()); 7060 7061 // @encode ( type-name ) 7062 const char *EncodeType = "char[]"; 7063 if (Results.getSema().getLangOpts().CPlusPlus || 7064 Results.getSema().getLangOpts().ConstStrings) 7065 EncodeType = "const char[]"; 7066 Builder.AddResultTypeChunk(EncodeType); 7067 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "encode")); 7068 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 7069 Builder.AddPlaceholderChunk("type-name"); 7070 Builder.AddChunk(CodeCompletionString::CK_RightParen); 7071 Results.AddResult(Result(Builder.TakeString())); 7072 7073 // @protocol ( protocol-name ) 7074 Builder.AddResultTypeChunk("Protocol *"); 7075 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "protocol")); 7076 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 7077 Builder.AddPlaceholderChunk("protocol-name"); 7078 Builder.AddChunk(CodeCompletionString::CK_RightParen); 7079 Results.AddResult(Result(Builder.TakeString())); 7080 7081 // @selector ( selector ) 7082 Builder.AddResultTypeChunk("SEL"); 7083 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "selector")); 7084 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 7085 Builder.AddPlaceholderChunk("selector"); 7086 Builder.AddChunk(CodeCompletionString::CK_RightParen); 7087 Results.AddResult(Result(Builder.TakeString())); 7088 7089 // @"string" 7090 Builder.AddResultTypeChunk("NSString *"); 7091 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "\"")); 7092 Builder.AddPlaceholderChunk("string"); 7093 Builder.AddTextChunk("\""); 7094 Results.AddResult(Result(Builder.TakeString())); 7095 7096 // @[objects, ...] 7097 Builder.AddResultTypeChunk("NSArray *"); 7098 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "[")); 7099 Builder.AddPlaceholderChunk("objects, ..."); 7100 Builder.AddChunk(CodeCompletionString::CK_RightBracket); 7101 Results.AddResult(Result(Builder.TakeString())); 7102 7103 // @{key : object, ...} 7104 Builder.AddResultTypeChunk("NSDictionary *"); 7105 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "{")); 7106 Builder.AddPlaceholderChunk("key"); 7107 Builder.AddChunk(CodeCompletionString::CK_Colon); 7108 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 7109 Builder.AddPlaceholderChunk("object, ..."); 7110 Builder.AddChunk(CodeCompletionString::CK_RightBrace); 7111 Results.AddResult(Result(Builder.TakeString())); 7112 7113 // @(expression) 7114 Builder.AddResultTypeChunk("id"); 7115 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "(")); 7116 Builder.AddPlaceholderChunk("expression"); 7117 Builder.AddChunk(CodeCompletionString::CK_RightParen); 7118 Results.AddResult(Result(Builder.TakeString())); 7119 } 7120 7121 static void AddObjCStatementResults(ResultBuilder &Results, bool NeedAt) { 7122 typedef CodeCompletionResult Result; 7123 CodeCompletionBuilder Builder(Results.getAllocator(), 7124 Results.getCodeCompletionTUInfo()); 7125 7126 if (Results.includeCodePatterns()) { 7127 // @try { statements } @catch ( declaration ) { statements } @finally 7128 // { statements } 7129 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "try")); 7130 Builder.AddChunk(CodeCompletionString::CK_LeftBrace); 7131 Builder.AddPlaceholderChunk("statements"); 7132 Builder.AddChunk(CodeCompletionString::CK_RightBrace); 7133 Builder.AddTextChunk("@catch"); 7134 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 7135 Builder.AddPlaceholderChunk("parameter"); 7136 Builder.AddChunk(CodeCompletionString::CK_RightParen); 7137 Builder.AddChunk(CodeCompletionString::CK_LeftBrace); 7138 Builder.AddPlaceholderChunk("statements"); 7139 Builder.AddChunk(CodeCompletionString::CK_RightBrace); 7140 Builder.AddTextChunk("@finally"); 7141 Builder.AddChunk(CodeCompletionString::CK_LeftBrace); 7142 Builder.AddPlaceholderChunk("statements"); 7143 Builder.AddChunk(CodeCompletionString::CK_RightBrace); 7144 Results.AddResult(Result(Builder.TakeString())); 7145 } 7146 7147 // @throw 7148 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "throw")); 7149 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 7150 Builder.AddPlaceholderChunk("expression"); 7151 Results.AddResult(Result(Builder.TakeString())); 7152 7153 if (Results.includeCodePatterns()) { 7154 // @synchronized ( expression ) { statements } 7155 Builder.AddTypedTextChunk(OBJC_AT_KEYWORD_NAME(NeedAt, "synchronized")); 7156 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 7157 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 7158 Builder.AddPlaceholderChunk("expression"); 7159 Builder.AddChunk(CodeCompletionString::CK_RightParen); 7160 Builder.AddChunk(CodeCompletionString::CK_LeftBrace); 7161 Builder.AddPlaceholderChunk("statements"); 7162 Builder.AddChunk(CodeCompletionString::CK_RightBrace); 7163 Results.AddResult(Result(Builder.TakeString())); 7164 } 7165 } 7166 7167 static void AddObjCVisibilityResults(const LangOptions &LangOpts, 7168 ResultBuilder &Results, bool NeedAt) { 7169 typedef CodeCompletionResult Result; 7170 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "private"))); 7171 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "protected"))); 7172 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "public"))); 7173 if (LangOpts.ObjC) 7174 Results.AddResult(Result(OBJC_AT_KEYWORD_NAME(NeedAt, "package"))); 7175 } 7176 7177 void Sema::CodeCompleteObjCAtVisibility(Scope *S) { 7178 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 7179 CodeCompleter->getCodeCompletionTUInfo(), 7180 CodeCompletionContext::CCC_Other); 7181 Results.EnterNewScope(); 7182 AddObjCVisibilityResults(getLangOpts(), Results, false); 7183 Results.ExitScope(); 7184 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 7185 Results.data(), Results.size()); 7186 } 7187 7188 void Sema::CodeCompleteObjCAtStatement(Scope *S) { 7189 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 7190 CodeCompleter->getCodeCompletionTUInfo(), 7191 CodeCompletionContext::CCC_Other); 7192 Results.EnterNewScope(); 7193 AddObjCStatementResults(Results, false); 7194 AddObjCExpressionResults(Results, false); 7195 Results.ExitScope(); 7196 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 7197 Results.data(), Results.size()); 7198 } 7199 7200 void Sema::CodeCompleteObjCAtExpression(Scope *S) { 7201 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 7202 CodeCompleter->getCodeCompletionTUInfo(), 7203 CodeCompletionContext::CCC_Other); 7204 Results.EnterNewScope(); 7205 AddObjCExpressionResults(Results, false); 7206 Results.ExitScope(); 7207 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 7208 Results.data(), Results.size()); 7209 } 7210 7211 /// Determine whether the addition of the given flag to an Objective-C 7212 /// property's attributes will cause a conflict. 7213 static bool ObjCPropertyFlagConflicts(unsigned Attributes, unsigned NewFlag) { 7214 // Check if we've already added this flag. 7215 if (Attributes & NewFlag) 7216 return true; 7217 7218 Attributes |= NewFlag; 7219 7220 // Check for collisions with "readonly". 7221 if ((Attributes & ObjCPropertyAttribute::kind_readonly) && 7222 (Attributes & ObjCPropertyAttribute::kind_readwrite)) 7223 return true; 7224 7225 // Check for more than one of { assign, copy, retain, strong, weak }. 7226 unsigned AssignCopyRetMask = 7227 Attributes & 7228 (ObjCPropertyAttribute::kind_assign | 7229 ObjCPropertyAttribute::kind_unsafe_unretained | 7230 ObjCPropertyAttribute::kind_copy | ObjCPropertyAttribute::kind_retain | 7231 ObjCPropertyAttribute::kind_strong | ObjCPropertyAttribute::kind_weak); 7232 if (AssignCopyRetMask && 7233 AssignCopyRetMask != ObjCPropertyAttribute::kind_assign && 7234 AssignCopyRetMask != ObjCPropertyAttribute::kind_unsafe_unretained && 7235 AssignCopyRetMask != ObjCPropertyAttribute::kind_copy && 7236 AssignCopyRetMask != ObjCPropertyAttribute::kind_retain && 7237 AssignCopyRetMask != ObjCPropertyAttribute::kind_strong && 7238 AssignCopyRetMask != ObjCPropertyAttribute::kind_weak) 7239 return true; 7240 7241 return false; 7242 } 7243 7244 void Sema::CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS) { 7245 if (!CodeCompleter) 7246 return; 7247 7248 unsigned Attributes = ODS.getPropertyAttributes(); 7249 7250 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 7251 CodeCompleter->getCodeCompletionTUInfo(), 7252 CodeCompletionContext::CCC_Other); 7253 Results.EnterNewScope(); 7254 if (!ObjCPropertyFlagConflicts(Attributes, 7255 ObjCPropertyAttribute::kind_readonly)) 7256 Results.AddResult(CodeCompletionResult("readonly")); 7257 if (!ObjCPropertyFlagConflicts(Attributes, 7258 ObjCPropertyAttribute::kind_assign)) 7259 Results.AddResult(CodeCompletionResult("assign")); 7260 if (!ObjCPropertyFlagConflicts(Attributes, 7261 ObjCPropertyAttribute::kind_unsafe_unretained)) 7262 Results.AddResult(CodeCompletionResult("unsafe_unretained")); 7263 if (!ObjCPropertyFlagConflicts(Attributes, 7264 ObjCPropertyAttribute::kind_readwrite)) 7265 Results.AddResult(CodeCompletionResult("readwrite")); 7266 if (!ObjCPropertyFlagConflicts(Attributes, 7267 ObjCPropertyAttribute::kind_retain)) 7268 Results.AddResult(CodeCompletionResult("retain")); 7269 if (!ObjCPropertyFlagConflicts(Attributes, 7270 ObjCPropertyAttribute::kind_strong)) 7271 Results.AddResult(CodeCompletionResult("strong")); 7272 if (!ObjCPropertyFlagConflicts(Attributes, ObjCPropertyAttribute::kind_copy)) 7273 Results.AddResult(CodeCompletionResult("copy")); 7274 if (!ObjCPropertyFlagConflicts(Attributes, 7275 ObjCPropertyAttribute::kind_nonatomic)) 7276 Results.AddResult(CodeCompletionResult("nonatomic")); 7277 if (!ObjCPropertyFlagConflicts(Attributes, 7278 ObjCPropertyAttribute::kind_atomic)) 7279 Results.AddResult(CodeCompletionResult("atomic")); 7280 7281 // Only suggest "weak" if we're compiling for ARC-with-weak-references or GC. 7282 if (getLangOpts().ObjCWeak || getLangOpts().getGC() != LangOptions::NonGC) 7283 if (!ObjCPropertyFlagConflicts(Attributes, 7284 ObjCPropertyAttribute::kind_weak)) 7285 Results.AddResult(CodeCompletionResult("weak")); 7286 7287 if (!ObjCPropertyFlagConflicts(Attributes, 7288 ObjCPropertyAttribute::kind_setter)) { 7289 CodeCompletionBuilder Setter(Results.getAllocator(), 7290 Results.getCodeCompletionTUInfo()); 7291 Setter.AddTypedTextChunk("setter"); 7292 Setter.AddTextChunk("="); 7293 Setter.AddPlaceholderChunk("method"); 7294 Results.AddResult(CodeCompletionResult(Setter.TakeString())); 7295 } 7296 if (!ObjCPropertyFlagConflicts(Attributes, 7297 ObjCPropertyAttribute::kind_getter)) { 7298 CodeCompletionBuilder Getter(Results.getAllocator(), 7299 Results.getCodeCompletionTUInfo()); 7300 Getter.AddTypedTextChunk("getter"); 7301 Getter.AddTextChunk("="); 7302 Getter.AddPlaceholderChunk("method"); 7303 Results.AddResult(CodeCompletionResult(Getter.TakeString())); 7304 } 7305 if (!ObjCPropertyFlagConflicts(Attributes, 7306 ObjCPropertyAttribute::kind_nullability)) { 7307 Results.AddResult(CodeCompletionResult("nonnull")); 7308 Results.AddResult(CodeCompletionResult("nullable")); 7309 Results.AddResult(CodeCompletionResult("null_unspecified")); 7310 Results.AddResult(CodeCompletionResult("null_resettable")); 7311 } 7312 Results.ExitScope(); 7313 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 7314 Results.data(), Results.size()); 7315 } 7316 7317 /// Describes the kind of Objective-C method that we want to find 7318 /// via code completion. 7319 enum ObjCMethodKind { 7320 MK_Any, ///< Any kind of method, provided it means other specified criteria. 7321 MK_ZeroArgSelector, ///< Zero-argument (unary) selector. 7322 MK_OneArgSelector ///< One-argument selector. 7323 }; 7324 7325 static bool isAcceptableObjCSelector(Selector Sel, ObjCMethodKind WantKind, 7326 ArrayRef<IdentifierInfo *> SelIdents, 7327 bool AllowSameLength = true) { 7328 unsigned NumSelIdents = SelIdents.size(); 7329 if (NumSelIdents > Sel.getNumArgs()) 7330 return false; 7331 7332 switch (WantKind) { 7333 case MK_Any: 7334 break; 7335 case MK_ZeroArgSelector: 7336 return Sel.isUnarySelector(); 7337 case MK_OneArgSelector: 7338 return Sel.getNumArgs() == 1; 7339 } 7340 7341 if (!AllowSameLength && NumSelIdents && NumSelIdents == Sel.getNumArgs()) 7342 return false; 7343 7344 for (unsigned I = 0; I != NumSelIdents; ++I) 7345 if (SelIdents[I] != Sel.getIdentifierInfoForSlot(I)) 7346 return false; 7347 7348 return true; 7349 } 7350 7351 static bool isAcceptableObjCMethod(ObjCMethodDecl *Method, 7352 ObjCMethodKind WantKind, 7353 ArrayRef<IdentifierInfo *> SelIdents, 7354 bool AllowSameLength = true) { 7355 return isAcceptableObjCSelector(Method->getSelector(), WantKind, SelIdents, 7356 AllowSameLength); 7357 } 7358 7359 /// A set of selectors, which is used to avoid introducing multiple 7360 /// completions with the same selector into the result set. 7361 typedef llvm::SmallPtrSet<Selector, 16> VisitedSelectorSet; 7362 7363 /// Add all of the Objective-C methods in the given Objective-C 7364 /// container to the set of results. 7365 /// 7366 /// The container will be a class, protocol, category, or implementation of 7367 /// any of the above. This mether will recurse to include methods from 7368 /// the superclasses of classes along with their categories, protocols, and 7369 /// implementations. 7370 /// 7371 /// \param Container the container in which we'll look to find methods. 7372 /// 7373 /// \param WantInstanceMethods Whether to add instance methods (only); if 7374 /// false, this routine will add factory methods (only). 7375 /// 7376 /// \param CurContext the context in which we're performing the lookup that 7377 /// finds methods. 7378 /// 7379 /// \param AllowSameLength Whether we allow a method to be added to the list 7380 /// when it has the same number of parameters as we have selector identifiers. 7381 /// 7382 /// \param Results the structure into which we'll add results. 7383 static void AddObjCMethods(ObjCContainerDecl *Container, 7384 bool WantInstanceMethods, ObjCMethodKind WantKind, 7385 ArrayRef<IdentifierInfo *> SelIdents, 7386 DeclContext *CurContext, 7387 VisitedSelectorSet &Selectors, bool AllowSameLength, 7388 ResultBuilder &Results, bool InOriginalClass = true, 7389 bool IsRootClass = false) { 7390 typedef CodeCompletionResult Result; 7391 Container = getContainerDef(Container); 7392 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container); 7393 IsRootClass = IsRootClass || (IFace && !IFace->getSuperClass()); 7394 for (ObjCMethodDecl *M : Container->methods()) { 7395 // The instance methods on the root class can be messaged via the 7396 // metaclass. 7397 if (M->isInstanceMethod() == WantInstanceMethods || 7398 (IsRootClass && !WantInstanceMethods)) { 7399 // Check whether the selector identifiers we've been given are a 7400 // subset of the identifiers for this particular method. 7401 if (!isAcceptableObjCMethod(M, WantKind, SelIdents, AllowSameLength)) 7402 continue; 7403 7404 if (!Selectors.insert(M->getSelector()).second) 7405 continue; 7406 7407 Result R = Result(M, Results.getBasePriority(M), nullptr); 7408 R.StartParameter = SelIdents.size(); 7409 R.AllParametersAreInformative = (WantKind != MK_Any); 7410 if (!InOriginalClass) 7411 setInBaseClass(R); 7412 Results.MaybeAddResult(R, CurContext); 7413 } 7414 } 7415 7416 // Visit the protocols of protocols. 7417 if (const auto *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) { 7418 if (Protocol->hasDefinition()) { 7419 const ObjCList<ObjCProtocolDecl> &Protocols = 7420 Protocol->getReferencedProtocols(); 7421 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 7422 E = Protocols.end(); 7423 I != E; ++I) 7424 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext, 7425 Selectors, AllowSameLength, Results, false, IsRootClass); 7426 } 7427 } 7428 7429 if (!IFace || !IFace->hasDefinition()) 7430 return; 7431 7432 // Add methods in protocols. 7433 for (ObjCProtocolDecl *I : IFace->protocols()) 7434 AddObjCMethods(I, WantInstanceMethods, WantKind, SelIdents, CurContext, 7435 Selectors, AllowSameLength, Results, false, IsRootClass); 7436 7437 // Add methods in categories. 7438 for (ObjCCategoryDecl *CatDecl : IFace->known_categories()) { 7439 AddObjCMethods(CatDecl, WantInstanceMethods, WantKind, SelIdents, 7440 CurContext, Selectors, AllowSameLength, Results, 7441 InOriginalClass, IsRootClass); 7442 7443 // Add a categories protocol methods. 7444 const ObjCList<ObjCProtocolDecl> &Protocols = 7445 CatDecl->getReferencedProtocols(); 7446 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 7447 E = Protocols.end(); 7448 I != E; ++I) 7449 AddObjCMethods(*I, WantInstanceMethods, WantKind, SelIdents, CurContext, 7450 Selectors, AllowSameLength, Results, false, IsRootClass); 7451 7452 // Add methods in category implementations. 7453 if (ObjCCategoryImplDecl *Impl = CatDecl->getImplementation()) 7454 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext, 7455 Selectors, AllowSameLength, Results, InOriginalClass, 7456 IsRootClass); 7457 } 7458 7459 // Add methods in superclass. 7460 // Avoid passing in IsRootClass since root classes won't have super classes. 7461 if (IFace->getSuperClass()) 7462 AddObjCMethods(IFace->getSuperClass(), WantInstanceMethods, WantKind, 7463 SelIdents, CurContext, Selectors, AllowSameLength, Results, 7464 /*IsRootClass=*/false); 7465 7466 // Add methods in our implementation, if any. 7467 if (ObjCImplementationDecl *Impl = IFace->getImplementation()) 7468 AddObjCMethods(Impl, WantInstanceMethods, WantKind, SelIdents, CurContext, 7469 Selectors, AllowSameLength, Results, InOriginalClass, 7470 IsRootClass); 7471 } 7472 7473 void Sema::CodeCompleteObjCPropertyGetter(Scope *S) { 7474 // Try to find the interface where getters might live. 7475 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext); 7476 if (!Class) { 7477 if (ObjCCategoryDecl *Category = 7478 dyn_cast_or_null<ObjCCategoryDecl>(CurContext)) 7479 Class = Category->getClassInterface(); 7480 7481 if (!Class) 7482 return; 7483 } 7484 7485 // Find all of the potential getters. 7486 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 7487 CodeCompleter->getCodeCompletionTUInfo(), 7488 CodeCompletionContext::CCC_Other); 7489 Results.EnterNewScope(); 7490 7491 VisitedSelectorSet Selectors; 7492 AddObjCMethods(Class, true, MK_ZeroArgSelector, None, CurContext, Selectors, 7493 /*AllowSameLength=*/true, Results); 7494 Results.ExitScope(); 7495 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 7496 Results.data(), Results.size()); 7497 } 7498 7499 void Sema::CodeCompleteObjCPropertySetter(Scope *S) { 7500 // Try to find the interface where setters might live. 7501 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurContext); 7502 if (!Class) { 7503 if (ObjCCategoryDecl *Category = 7504 dyn_cast_or_null<ObjCCategoryDecl>(CurContext)) 7505 Class = Category->getClassInterface(); 7506 7507 if (!Class) 7508 return; 7509 } 7510 7511 // Find all of the potential getters. 7512 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 7513 CodeCompleter->getCodeCompletionTUInfo(), 7514 CodeCompletionContext::CCC_Other); 7515 Results.EnterNewScope(); 7516 7517 VisitedSelectorSet Selectors; 7518 AddObjCMethods(Class, true, MK_OneArgSelector, None, CurContext, Selectors, 7519 /*AllowSameLength=*/true, Results); 7520 7521 Results.ExitScope(); 7522 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 7523 Results.data(), Results.size()); 7524 } 7525 7526 void Sema::CodeCompleteObjCPassingType(Scope *S, ObjCDeclSpec &DS, 7527 bool IsParameter) { 7528 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 7529 CodeCompleter->getCodeCompletionTUInfo(), 7530 CodeCompletionContext::CCC_Type); 7531 Results.EnterNewScope(); 7532 7533 // Add context-sensitive, Objective-C parameter-passing keywords. 7534 bool AddedInOut = false; 7535 if ((DS.getObjCDeclQualifier() & 7536 (ObjCDeclSpec::DQ_In | ObjCDeclSpec::DQ_Inout)) == 0) { 7537 Results.AddResult("in"); 7538 Results.AddResult("inout"); 7539 AddedInOut = true; 7540 } 7541 if ((DS.getObjCDeclQualifier() & 7542 (ObjCDeclSpec::DQ_Out | ObjCDeclSpec::DQ_Inout)) == 0) { 7543 Results.AddResult("out"); 7544 if (!AddedInOut) 7545 Results.AddResult("inout"); 7546 } 7547 if ((DS.getObjCDeclQualifier() & 7548 (ObjCDeclSpec::DQ_Bycopy | ObjCDeclSpec::DQ_Byref | 7549 ObjCDeclSpec::DQ_Oneway)) == 0) { 7550 Results.AddResult("bycopy"); 7551 Results.AddResult("byref"); 7552 Results.AddResult("oneway"); 7553 } 7554 if ((DS.getObjCDeclQualifier() & ObjCDeclSpec::DQ_CSNullability) == 0) { 7555 Results.AddResult("nonnull"); 7556 Results.AddResult("nullable"); 7557 Results.AddResult("null_unspecified"); 7558 } 7559 7560 // If we're completing the return type of an Objective-C method and the 7561 // identifier IBAction refers to a macro, provide a completion item for 7562 // an action, e.g., 7563 // IBAction)<#selector#>:(id)sender 7564 if (DS.getObjCDeclQualifier() == 0 && !IsParameter && 7565 PP.isMacroDefined("IBAction")) { 7566 CodeCompletionBuilder Builder(Results.getAllocator(), 7567 Results.getCodeCompletionTUInfo(), 7568 CCP_CodePattern, CXAvailability_Available); 7569 Builder.AddTypedTextChunk("IBAction"); 7570 Builder.AddChunk(CodeCompletionString::CK_RightParen); 7571 Builder.AddPlaceholderChunk("selector"); 7572 Builder.AddChunk(CodeCompletionString::CK_Colon); 7573 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 7574 Builder.AddTextChunk("id"); 7575 Builder.AddChunk(CodeCompletionString::CK_RightParen); 7576 Builder.AddTextChunk("sender"); 7577 Results.AddResult(CodeCompletionResult(Builder.TakeString())); 7578 } 7579 7580 // If we're completing the return type, provide 'instancetype'. 7581 if (!IsParameter) { 7582 Results.AddResult(CodeCompletionResult("instancetype")); 7583 } 7584 7585 // Add various builtin type names and specifiers. 7586 AddOrdinaryNameResults(PCC_Type, S, *this, Results); 7587 Results.ExitScope(); 7588 7589 // Add the various type names 7590 Results.setFilter(&ResultBuilder::IsOrdinaryNonValueName); 7591 CodeCompletionDeclConsumer Consumer(Results, CurContext); 7592 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 7593 CodeCompleter->includeGlobals(), 7594 CodeCompleter->loadExternal()); 7595 7596 if (CodeCompleter->includeMacros()) 7597 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false); 7598 7599 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 7600 Results.data(), Results.size()); 7601 } 7602 7603 /// When we have an expression with type "id", we may assume 7604 /// that it has some more-specific class type based on knowledge of 7605 /// common uses of Objective-C. This routine returns that class type, 7606 /// or NULL if no better result could be determined. 7607 static ObjCInterfaceDecl *GetAssumedMessageSendExprType(Expr *E) { 7608 auto *Msg = dyn_cast_or_null<ObjCMessageExpr>(E); 7609 if (!Msg) 7610 return nullptr; 7611 7612 Selector Sel = Msg->getSelector(); 7613 if (Sel.isNull()) 7614 return nullptr; 7615 7616 IdentifierInfo *Id = Sel.getIdentifierInfoForSlot(0); 7617 if (!Id) 7618 return nullptr; 7619 7620 ObjCMethodDecl *Method = Msg->getMethodDecl(); 7621 if (!Method) 7622 return nullptr; 7623 7624 // Determine the class that we're sending the message to. 7625 ObjCInterfaceDecl *IFace = nullptr; 7626 switch (Msg->getReceiverKind()) { 7627 case ObjCMessageExpr::Class: 7628 if (const ObjCObjectType *ObjType = 7629 Msg->getClassReceiver()->getAs<ObjCObjectType>()) 7630 IFace = ObjType->getInterface(); 7631 break; 7632 7633 case ObjCMessageExpr::Instance: { 7634 QualType T = Msg->getInstanceReceiver()->getType(); 7635 if (const ObjCObjectPointerType *Ptr = T->getAs<ObjCObjectPointerType>()) 7636 IFace = Ptr->getInterfaceDecl(); 7637 break; 7638 } 7639 7640 case ObjCMessageExpr::SuperInstance: 7641 case ObjCMessageExpr::SuperClass: 7642 break; 7643 } 7644 7645 if (!IFace) 7646 return nullptr; 7647 7648 ObjCInterfaceDecl *Super = IFace->getSuperClass(); 7649 if (Method->isInstanceMethod()) 7650 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName()) 7651 .Case("retain", IFace) 7652 .Case("strong", IFace) 7653 .Case("autorelease", IFace) 7654 .Case("copy", IFace) 7655 .Case("copyWithZone", IFace) 7656 .Case("mutableCopy", IFace) 7657 .Case("mutableCopyWithZone", IFace) 7658 .Case("awakeFromCoder", IFace) 7659 .Case("replacementObjectFromCoder", IFace) 7660 .Case("class", IFace) 7661 .Case("classForCoder", IFace) 7662 .Case("superclass", Super) 7663 .Default(nullptr); 7664 7665 return llvm::StringSwitch<ObjCInterfaceDecl *>(Id->getName()) 7666 .Case("new", IFace) 7667 .Case("alloc", IFace) 7668 .Case("allocWithZone", IFace) 7669 .Case("class", IFace) 7670 .Case("superclass", Super) 7671 .Default(nullptr); 7672 } 7673 7674 // Add a special completion for a message send to "super", which fills in the 7675 // most likely case of forwarding all of our arguments to the superclass 7676 // function. 7677 /// 7678 /// \param S The semantic analysis object. 7679 /// 7680 /// \param NeedSuperKeyword Whether we need to prefix this completion with 7681 /// the "super" keyword. Otherwise, we just need to provide the arguments. 7682 /// 7683 /// \param SelIdents The identifiers in the selector that have already been 7684 /// provided as arguments for a send to "super". 7685 /// 7686 /// \param Results The set of results to augment. 7687 /// 7688 /// \returns the Objective-C method declaration that would be invoked by 7689 /// this "super" completion. If NULL, no completion was added. 7690 static ObjCMethodDecl * 7691 AddSuperSendCompletion(Sema &S, bool NeedSuperKeyword, 7692 ArrayRef<IdentifierInfo *> SelIdents, 7693 ResultBuilder &Results) { 7694 ObjCMethodDecl *CurMethod = S.getCurMethodDecl(); 7695 if (!CurMethod) 7696 return nullptr; 7697 7698 ObjCInterfaceDecl *Class = CurMethod->getClassInterface(); 7699 if (!Class) 7700 return nullptr; 7701 7702 // Try to find a superclass method with the same selector. 7703 ObjCMethodDecl *SuperMethod = nullptr; 7704 while ((Class = Class->getSuperClass()) && !SuperMethod) { 7705 // Check in the class 7706 SuperMethod = Class->getMethod(CurMethod->getSelector(), 7707 CurMethod->isInstanceMethod()); 7708 7709 // Check in categories or class extensions. 7710 if (!SuperMethod) { 7711 for (const auto *Cat : Class->known_categories()) { 7712 if ((SuperMethod = Cat->getMethod(CurMethod->getSelector(), 7713 CurMethod->isInstanceMethod()))) 7714 break; 7715 } 7716 } 7717 } 7718 7719 if (!SuperMethod) 7720 return nullptr; 7721 7722 // Check whether the superclass method has the same signature. 7723 if (CurMethod->param_size() != SuperMethod->param_size() || 7724 CurMethod->isVariadic() != SuperMethod->isVariadic()) 7725 return nullptr; 7726 7727 for (ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(), 7728 CurPEnd = CurMethod->param_end(), 7729 SuperP = SuperMethod->param_begin(); 7730 CurP != CurPEnd; ++CurP, ++SuperP) { 7731 // Make sure the parameter types are compatible. 7732 if (!S.Context.hasSameUnqualifiedType((*CurP)->getType(), 7733 (*SuperP)->getType())) 7734 return nullptr; 7735 7736 // Make sure we have a parameter name to forward! 7737 if (!(*CurP)->getIdentifier()) 7738 return nullptr; 7739 } 7740 7741 // We have a superclass method. Now, form the send-to-super completion. 7742 CodeCompletionBuilder Builder(Results.getAllocator(), 7743 Results.getCodeCompletionTUInfo()); 7744 7745 // Give this completion a return type. 7746 AddResultTypeChunk(S.Context, getCompletionPrintingPolicy(S), SuperMethod, 7747 Results.getCompletionContext().getBaseType(), Builder); 7748 7749 // If we need the "super" keyword, add it (plus some spacing). 7750 if (NeedSuperKeyword) { 7751 Builder.AddTypedTextChunk("super"); 7752 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 7753 } 7754 7755 Selector Sel = CurMethod->getSelector(); 7756 if (Sel.isUnarySelector()) { 7757 if (NeedSuperKeyword) 7758 Builder.AddTextChunk( 7759 Builder.getAllocator().CopyString(Sel.getNameForSlot(0))); 7760 else 7761 Builder.AddTypedTextChunk( 7762 Builder.getAllocator().CopyString(Sel.getNameForSlot(0))); 7763 } else { 7764 ObjCMethodDecl::param_iterator CurP = CurMethod->param_begin(); 7765 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I, ++CurP) { 7766 if (I > SelIdents.size()) 7767 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 7768 7769 if (I < SelIdents.size()) 7770 Builder.AddInformativeChunk( 7771 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":")); 7772 else if (NeedSuperKeyword || I > SelIdents.size()) { 7773 Builder.AddTextChunk( 7774 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":")); 7775 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString( 7776 (*CurP)->getIdentifier()->getName())); 7777 } else { 7778 Builder.AddTypedTextChunk( 7779 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":")); 7780 Builder.AddPlaceholderChunk(Builder.getAllocator().CopyString( 7781 (*CurP)->getIdentifier()->getName())); 7782 } 7783 } 7784 } 7785 7786 Results.AddResult(CodeCompletionResult(Builder.TakeString(), SuperMethod, 7787 CCP_SuperCompletion)); 7788 return SuperMethod; 7789 } 7790 7791 void Sema::CodeCompleteObjCMessageReceiver(Scope *S) { 7792 typedef CodeCompletionResult Result; 7793 ResultBuilder Results( 7794 *this, CodeCompleter->getAllocator(), 7795 CodeCompleter->getCodeCompletionTUInfo(), 7796 CodeCompletionContext::CCC_ObjCMessageReceiver, 7797 getLangOpts().CPlusPlus11 7798 ? &ResultBuilder::IsObjCMessageReceiverOrLambdaCapture 7799 : &ResultBuilder::IsObjCMessageReceiver); 7800 7801 CodeCompletionDeclConsumer Consumer(Results, CurContext); 7802 Results.EnterNewScope(); 7803 LookupVisibleDecls(S, LookupOrdinaryName, Consumer, 7804 CodeCompleter->includeGlobals(), 7805 CodeCompleter->loadExternal()); 7806 7807 // If we are in an Objective-C method inside a class that has a superclass, 7808 // add "super" as an option. 7809 if (ObjCMethodDecl *Method = getCurMethodDecl()) 7810 if (ObjCInterfaceDecl *Iface = Method->getClassInterface()) 7811 if (Iface->getSuperClass()) { 7812 Results.AddResult(Result("super")); 7813 7814 AddSuperSendCompletion(*this, /*NeedSuperKeyword=*/true, None, Results); 7815 } 7816 7817 if (getLangOpts().CPlusPlus11) 7818 addThisCompletion(*this, Results); 7819 7820 Results.ExitScope(); 7821 7822 if (CodeCompleter->includeMacros()) 7823 AddMacroResults(PP, Results, CodeCompleter->loadExternal(), false); 7824 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 7825 Results.data(), Results.size()); 7826 } 7827 7828 void Sema::CodeCompleteObjCSuperMessage(Scope *S, SourceLocation SuperLoc, 7829 ArrayRef<IdentifierInfo *> SelIdents, 7830 bool AtArgumentExpression) { 7831 ObjCInterfaceDecl *CDecl = nullptr; 7832 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) { 7833 // Figure out which interface we're in. 7834 CDecl = CurMethod->getClassInterface(); 7835 if (!CDecl) 7836 return; 7837 7838 // Find the superclass of this class. 7839 CDecl = CDecl->getSuperClass(); 7840 if (!CDecl) 7841 return; 7842 7843 if (CurMethod->isInstanceMethod()) { 7844 // We are inside an instance method, which means that the message 7845 // send [super ...] is actually calling an instance method on the 7846 // current object. 7847 return CodeCompleteObjCInstanceMessage(S, nullptr, SelIdents, 7848 AtArgumentExpression, CDecl); 7849 } 7850 7851 // Fall through to send to the superclass in CDecl. 7852 } else { 7853 // "super" may be the name of a type or variable. Figure out which 7854 // it is. 7855 IdentifierInfo *Super = getSuperIdentifier(); 7856 NamedDecl *ND = LookupSingleName(S, Super, SuperLoc, LookupOrdinaryName); 7857 if ((CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(ND))) { 7858 // "super" names an interface. Use it. 7859 } else if (TypeDecl *TD = dyn_cast_or_null<TypeDecl>(ND)) { 7860 if (const ObjCObjectType *Iface = 7861 Context.getTypeDeclType(TD)->getAs<ObjCObjectType>()) 7862 CDecl = Iface->getInterface(); 7863 } else if (ND && isa<UnresolvedUsingTypenameDecl>(ND)) { 7864 // "super" names an unresolved type; we can't be more specific. 7865 } else { 7866 // Assume that "super" names some kind of value and parse that way. 7867 CXXScopeSpec SS; 7868 SourceLocation TemplateKWLoc; 7869 UnqualifiedId id; 7870 id.setIdentifier(Super, SuperLoc); 7871 ExprResult SuperExpr = ActOnIdExpression(S, SS, TemplateKWLoc, id, 7872 /*HasTrailingLParen=*/false, 7873 /*IsAddressOfOperand=*/false); 7874 return CodeCompleteObjCInstanceMessage(S, (Expr *)SuperExpr.get(), 7875 SelIdents, AtArgumentExpression); 7876 } 7877 7878 // Fall through 7879 } 7880 7881 ParsedType Receiver; 7882 if (CDecl) 7883 Receiver = ParsedType::make(Context.getObjCInterfaceType(CDecl)); 7884 return CodeCompleteObjCClassMessage(S, Receiver, SelIdents, 7885 AtArgumentExpression, 7886 /*IsSuper=*/true); 7887 } 7888 7889 /// Given a set of code-completion results for the argument of a message 7890 /// send, determine the preferred type (if any) for that argument expression. 7891 static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results, 7892 unsigned NumSelIdents) { 7893 typedef CodeCompletionResult Result; 7894 ASTContext &Context = Results.getSema().Context; 7895 7896 QualType PreferredType; 7897 unsigned BestPriority = CCP_Unlikely * 2; 7898 Result *ResultsData = Results.data(); 7899 for (unsigned I = 0, N = Results.size(); I != N; ++I) { 7900 Result &R = ResultsData[I]; 7901 if (R.Kind == Result::RK_Declaration && 7902 isa<ObjCMethodDecl>(R.Declaration)) { 7903 if (R.Priority <= BestPriority) { 7904 const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration); 7905 if (NumSelIdents <= Method->param_size()) { 7906 QualType MyPreferredType = 7907 Method->parameters()[NumSelIdents - 1]->getType(); 7908 if (R.Priority < BestPriority || PreferredType.isNull()) { 7909 BestPriority = R.Priority; 7910 PreferredType = MyPreferredType; 7911 } else if (!Context.hasSameUnqualifiedType(PreferredType, 7912 MyPreferredType)) { 7913 PreferredType = QualType(); 7914 } 7915 } 7916 } 7917 } 7918 } 7919 7920 return PreferredType; 7921 } 7922 7923 static void AddClassMessageCompletions(Sema &SemaRef, Scope *S, 7924 ParsedType Receiver, 7925 ArrayRef<IdentifierInfo *> SelIdents, 7926 bool AtArgumentExpression, bool IsSuper, 7927 ResultBuilder &Results) { 7928 typedef CodeCompletionResult Result; 7929 ObjCInterfaceDecl *CDecl = nullptr; 7930 7931 // If the given name refers to an interface type, retrieve the 7932 // corresponding declaration. 7933 if (Receiver) { 7934 QualType T = SemaRef.GetTypeFromParser(Receiver, nullptr); 7935 if (!T.isNull()) 7936 if (const ObjCObjectType *Interface = T->getAs<ObjCObjectType>()) 7937 CDecl = Interface->getInterface(); 7938 } 7939 7940 // Add all of the factory methods in this Objective-C class, its protocols, 7941 // superclasses, categories, implementation, etc. 7942 Results.EnterNewScope(); 7943 7944 // If this is a send-to-super, try to add the special "super" send 7945 // completion. 7946 if (IsSuper) { 7947 if (ObjCMethodDecl *SuperMethod = 7948 AddSuperSendCompletion(SemaRef, false, SelIdents, Results)) 7949 Results.Ignore(SuperMethod); 7950 } 7951 7952 // If we're inside an Objective-C method definition, prefer its selector to 7953 // others. 7954 if (ObjCMethodDecl *CurMethod = SemaRef.getCurMethodDecl()) 7955 Results.setPreferredSelector(CurMethod->getSelector()); 7956 7957 VisitedSelectorSet Selectors; 7958 if (CDecl) 7959 AddObjCMethods(CDecl, false, MK_Any, SelIdents, SemaRef.CurContext, 7960 Selectors, AtArgumentExpression, Results); 7961 else { 7962 // We're messaging "id" as a type; provide all class/factory methods. 7963 7964 // If we have an external source, load the entire class method 7965 // pool from the AST file. 7966 if (SemaRef.getExternalSource()) { 7967 for (uint32_t I = 0, 7968 N = SemaRef.getExternalSource()->GetNumExternalSelectors(); 7969 I != N; ++I) { 7970 Selector Sel = SemaRef.getExternalSource()->GetExternalSelector(I); 7971 if (Sel.isNull() || SemaRef.MethodPool.count(Sel)) 7972 continue; 7973 7974 SemaRef.ReadMethodPool(Sel); 7975 } 7976 } 7977 7978 for (Sema::GlobalMethodPool::iterator M = SemaRef.MethodPool.begin(), 7979 MEnd = SemaRef.MethodPool.end(); 7980 M != MEnd; ++M) { 7981 for (ObjCMethodList *MethList = &M->second.second; 7982 MethList && MethList->getMethod(); MethList = MethList->getNext()) { 7983 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents)) 7984 continue; 7985 7986 Result R(MethList->getMethod(), 7987 Results.getBasePriority(MethList->getMethod()), nullptr); 7988 R.StartParameter = SelIdents.size(); 7989 R.AllParametersAreInformative = false; 7990 Results.MaybeAddResult(R, SemaRef.CurContext); 7991 } 7992 } 7993 } 7994 7995 Results.ExitScope(); 7996 } 7997 7998 void Sema::CodeCompleteObjCClassMessage(Scope *S, ParsedType Receiver, 7999 ArrayRef<IdentifierInfo *> SelIdents, 8000 bool AtArgumentExpression, 8001 bool IsSuper) { 8002 8003 QualType T = this->GetTypeFromParser(Receiver); 8004 8005 ResultBuilder Results( 8006 *this, CodeCompleter->getAllocator(), 8007 CodeCompleter->getCodeCompletionTUInfo(), 8008 CodeCompletionContext(CodeCompletionContext::CCC_ObjCClassMessage, T, 8009 SelIdents)); 8010 8011 AddClassMessageCompletions(*this, S, Receiver, SelIdents, 8012 AtArgumentExpression, IsSuper, Results); 8013 8014 // If we're actually at the argument expression (rather than prior to the 8015 // selector), we're actually performing code completion for an expression. 8016 // Determine whether we have a single, best method. If so, we can 8017 // code-complete the expression using the corresponding parameter type as 8018 // our preferred type, improving completion results. 8019 if (AtArgumentExpression) { 8020 QualType PreferredType = 8021 getPreferredArgumentTypeForMessageSend(Results, SelIdents.size()); 8022 if (PreferredType.isNull()) 8023 CodeCompleteOrdinaryName(S, PCC_Expression); 8024 else 8025 CodeCompleteExpression(S, PreferredType); 8026 return; 8027 } 8028 8029 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 8030 Results.data(), Results.size()); 8031 } 8032 8033 void Sema::CodeCompleteObjCInstanceMessage(Scope *S, Expr *Receiver, 8034 ArrayRef<IdentifierInfo *> SelIdents, 8035 bool AtArgumentExpression, 8036 ObjCInterfaceDecl *Super) { 8037 typedef CodeCompletionResult Result; 8038 8039 Expr *RecExpr = static_cast<Expr *>(Receiver); 8040 8041 // If necessary, apply function/array conversion to the receiver. 8042 // C99 6.7.5.3p[7,8]. 8043 if (RecExpr) { 8044 ExprResult Conv = DefaultFunctionArrayLvalueConversion(RecExpr); 8045 if (Conv.isInvalid()) // conversion failed. bail. 8046 return; 8047 RecExpr = Conv.get(); 8048 } 8049 QualType ReceiverType = RecExpr 8050 ? RecExpr->getType() 8051 : Super ? Context.getObjCObjectPointerType( 8052 Context.getObjCInterfaceType(Super)) 8053 : Context.getObjCIdType(); 8054 8055 // If we're messaging an expression with type "id" or "Class", check 8056 // whether we know something special about the receiver that allows 8057 // us to assume a more-specific receiver type. 8058 if (ReceiverType->isObjCIdType() || ReceiverType->isObjCClassType()) { 8059 if (ObjCInterfaceDecl *IFace = GetAssumedMessageSendExprType(RecExpr)) { 8060 if (ReceiverType->isObjCClassType()) 8061 return CodeCompleteObjCClassMessage( 8062 S, ParsedType::make(Context.getObjCInterfaceType(IFace)), SelIdents, 8063 AtArgumentExpression, Super); 8064 8065 ReceiverType = 8066 Context.getObjCObjectPointerType(Context.getObjCInterfaceType(IFace)); 8067 } 8068 } else if (RecExpr && getLangOpts().CPlusPlus) { 8069 ExprResult Conv = PerformContextuallyConvertToObjCPointer(RecExpr); 8070 if (Conv.isUsable()) { 8071 RecExpr = Conv.get(); 8072 ReceiverType = RecExpr->getType(); 8073 } 8074 } 8075 8076 // Build the set of methods we can see. 8077 ResultBuilder Results( 8078 *this, CodeCompleter->getAllocator(), 8079 CodeCompleter->getCodeCompletionTUInfo(), 8080 CodeCompletionContext(CodeCompletionContext::CCC_ObjCInstanceMessage, 8081 ReceiverType, SelIdents)); 8082 8083 Results.EnterNewScope(); 8084 8085 // If this is a send-to-super, try to add the special "super" send 8086 // completion. 8087 if (Super) { 8088 if (ObjCMethodDecl *SuperMethod = 8089 AddSuperSendCompletion(*this, false, SelIdents, Results)) 8090 Results.Ignore(SuperMethod); 8091 } 8092 8093 // If we're inside an Objective-C method definition, prefer its selector to 8094 // others. 8095 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) 8096 Results.setPreferredSelector(CurMethod->getSelector()); 8097 8098 // Keep track of the selectors we've already added. 8099 VisitedSelectorSet Selectors; 8100 8101 // Handle messages to Class. This really isn't a message to an instance 8102 // method, so we treat it the same way we would treat a message send to a 8103 // class method. 8104 if (ReceiverType->isObjCClassType() || 8105 ReceiverType->isObjCQualifiedClassType()) { 8106 if (ObjCMethodDecl *CurMethod = getCurMethodDecl()) { 8107 if (ObjCInterfaceDecl *ClassDecl = CurMethod->getClassInterface()) 8108 AddObjCMethods(ClassDecl, false, MK_Any, SelIdents, CurContext, 8109 Selectors, AtArgumentExpression, Results); 8110 } 8111 } 8112 // Handle messages to a qualified ID ("id<foo>"). 8113 else if (const ObjCObjectPointerType *QualID = 8114 ReceiverType->getAsObjCQualifiedIdType()) { 8115 // Search protocols for instance methods. 8116 for (auto *I : QualID->quals()) 8117 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext, Selectors, 8118 AtArgumentExpression, Results); 8119 } 8120 // Handle messages to a pointer to interface type. 8121 else if (const ObjCObjectPointerType *IFacePtr = 8122 ReceiverType->getAsObjCInterfacePointerType()) { 8123 // Search the class, its superclasses, etc., for instance methods. 8124 AddObjCMethods(IFacePtr->getInterfaceDecl(), true, MK_Any, SelIdents, 8125 CurContext, Selectors, AtArgumentExpression, Results); 8126 8127 // Search protocols for instance methods. 8128 for (auto *I : IFacePtr->quals()) 8129 AddObjCMethods(I, true, MK_Any, SelIdents, CurContext, Selectors, 8130 AtArgumentExpression, Results); 8131 } 8132 // Handle messages to "id". 8133 else if (ReceiverType->isObjCIdType()) { 8134 // We're messaging "id", so provide all instance methods we know 8135 // about as code-completion results. 8136 8137 // If we have an external source, load the entire class method 8138 // pool from the AST file. 8139 if (ExternalSource) { 8140 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors(); 8141 I != N; ++I) { 8142 Selector Sel = ExternalSource->GetExternalSelector(I); 8143 if (Sel.isNull() || MethodPool.count(Sel)) 8144 continue; 8145 8146 ReadMethodPool(Sel); 8147 } 8148 } 8149 8150 for (GlobalMethodPool::iterator M = MethodPool.begin(), 8151 MEnd = MethodPool.end(); 8152 M != MEnd; ++M) { 8153 for (ObjCMethodList *MethList = &M->second.first; 8154 MethList && MethList->getMethod(); MethList = MethList->getNext()) { 8155 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents)) 8156 continue; 8157 8158 if (!Selectors.insert(MethList->getMethod()->getSelector()).second) 8159 continue; 8160 8161 Result R(MethList->getMethod(), 8162 Results.getBasePriority(MethList->getMethod()), nullptr); 8163 R.StartParameter = SelIdents.size(); 8164 R.AllParametersAreInformative = false; 8165 Results.MaybeAddResult(R, CurContext); 8166 } 8167 } 8168 } 8169 Results.ExitScope(); 8170 8171 // If we're actually at the argument expression (rather than prior to the 8172 // selector), we're actually performing code completion for an expression. 8173 // Determine whether we have a single, best method. If so, we can 8174 // code-complete the expression using the corresponding parameter type as 8175 // our preferred type, improving completion results. 8176 if (AtArgumentExpression) { 8177 QualType PreferredType = 8178 getPreferredArgumentTypeForMessageSend(Results, SelIdents.size()); 8179 if (PreferredType.isNull()) 8180 CodeCompleteOrdinaryName(S, PCC_Expression); 8181 else 8182 CodeCompleteExpression(S, PreferredType); 8183 return; 8184 } 8185 8186 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 8187 Results.data(), Results.size()); 8188 } 8189 8190 void Sema::CodeCompleteObjCForCollection(Scope *S, 8191 DeclGroupPtrTy IterationVar) { 8192 CodeCompleteExpressionData Data; 8193 Data.ObjCCollection = true; 8194 8195 if (IterationVar.getAsOpaquePtr()) { 8196 DeclGroupRef DG = IterationVar.get(); 8197 for (DeclGroupRef::iterator I = DG.begin(), End = DG.end(); I != End; ++I) { 8198 if (*I) 8199 Data.IgnoreDecls.push_back(*I); 8200 } 8201 } 8202 8203 CodeCompleteExpression(S, Data); 8204 } 8205 8206 void Sema::CodeCompleteObjCSelector(Scope *S, 8207 ArrayRef<IdentifierInfo *> SelIdents) { 8208 // If we have an external source, load the entire class method 8209 // pool from the AST file. 8210 if (ExternalSource) { 8211 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors(); I != N; 8212 ++I) { 8213 Selector Sel = ExternalSource->GetExternalSelector(I); 8214 if (Sel.isNull() || MethodPool.count(Sel)) 8215 continue; 8216 8217 ReadMethodPool(Sel); 8218 } 8219 } 8220 8221 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 8222 CodeCompleter->getCodeCompletionTUInfo(), 8223 CodeCompletionContext::CCC_SelectorName); 8224 Results.EnterNewScope(); 8225 for (GlobalMethodPool::iterator M = MethodPool.begin(), 8226 MEnd = MethodPool.end(); 8227 M != MEnd; ++M) { 8228 8229 Selector Sel = M->first; 8230 if (!isAcceptableObjCSelector(Sel, MK_Any, SelIdents)) 8231 continue; 8232 8233 CodeCompletionBuilder Builder(Results.getAllocator(), 8234 Results.getCodeCompletionTUInfo()); 8235 if (Sel.isUnarySelector()) { 8236 Builder.AddTypedTextChunk( 8237 Builder.getAllocator().CopyString(Sel.getNameForSlot(0))); 8238 Results.AddResult(Builder.TakeString()); 8239 continue; 8240 } 8241 8242 std::string Accumulator; 8243 for (unsigned I = 0, N = Sel.getNumArgs(); I != N; ++I) { 8244 if (I == SelIdents.size()) { 8245 if (!Accumulator.empty()) { 8246 Builder.AddInformativeChunk( 8247 Builder.getAllocator().CopyString(Accumulator)); 8248 Accumulator.clear(); 8249 } 8250 } 8251 8252 Accumulator += Sel.getNameForSlot(I); 8253 Accumulator += ':'; 8254 } 8255 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString(Accumulator)); 8256 Results.AddResult(Builder.TakeString()); 8257 } 8258 Results.ExitScope(); 8259 8260 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 8261 Results.data(), Results.size()); 8262 } 8263 8264 /// Add all of the protocol declarations that we find in the given 8265 /// (translation unit) context. 8266 static void AddProtocolResults(DeclContext *Ctx, DeclContext *CurContext, 8267 bool OnlyForwardDeclarations, 8268 ResultBuilder &Results) { 8269 typedef CodeCompletionResult Result; 8270 8271 for (const auto *D : Ctx->decls()) { 8272 // Record any protocols we find. 8273 if (const auto *Proto = dyn_cast<ObjCProtocolDecl>(D)) 8274 if (!OnlyForwardDeclarations || !Proto->hasDefinition()) 8275 Results.AddResult( 8276 Result(Proto, Results.getBasePriority(Proto), nullptr), CurContext, 8277 nullptr, false); 8278 } 8279 } 8280 8281 void Sema::CodeCompleteObjCProtocolReferences( 8282 ArrayRef<IdentifierLocPair> Protocols) { 8283 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 8284 CodeCompleter->getCodeCompletionTUInfo(), 8285 CodeCompletionContext::CCC_ObjCProtocolName); 8286 8287 if (CodeCompleter->includeGlobals()) { 8288 Results.EnterNewScope(); 8289 8290 // Tell the result set to ignore all of the protocols we have 8291 // already seen. 8292 // FIXME: This doesn't work when caching code-completion results. 8293 for (const IdentifierLocPair &Pair : Protocols) 8294 if (ObjCProtocolDecl *Protocol = LookupProtocol(Pair.first, Pair.second)) 8295 Results.Ignore(Protocol); 8296 8297 // Add all protocols. 8298 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, false, 8299 Results); 8300 8301 Results.ExitScope(); 8302 } 8303 8304 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 8305 Results.data(), Results.size()); 8306 } 8307 8308 void Sema::CodeCompleteObjCProtocolDecl(Scope *) { 8309 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 8310 CodeCompleter->getCodeCompletionTUInfo(), 8311 CodeCompletionContext::CCC_ObjCProtocolName); 8312 8313 if (CodeCompleter->includeGlobals()) { 8314 Results.EnterNewScope(); 8315 8316 // Add all protocols. 8317 AddProtocolResults(Context.getTranslationUnitDecl(), CurContext, true, 8318 Results); 8319 8320 Results.ExitScope(); 8321 } 8322 8323 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 8324 Results.data(), Results.size()); 8325 } 8326 8327 /// Add all of the Objective-C interface declarations that we find in 8328 /// the given (translation unit) context. 8329 static void AddInterfaceResults(DeclContext *Ctx, DeclContext *CurContext, 8330 bool OnlyForwardDeclarations, 8331 bool OnlyUnimplemented, 8332 ResultBuilder &Results) { 8333 typedef CodeCompletionResult Result; 8334 8335 for (const auto *D : Ctx->decls()) { 8336 // Record any interfaces we find. 8337 if (const auto *Class = dyn_cast<ObjCInterfaceDecl>(D)) 8338 if ((!OnlyForwardDeclarations || !Class->hasDefinition()) && 8339 (!OnlyUnimplemented || !Class->getImplementation())) 8340 Results.AddResult( 8341 Result(Class, Results.getBasePriority(Class), nullptr), CurContext, 8342 nullptr, false); 8343 } 8344 } 8345 8346 void Sema::CodeCompleteObjCInterfaceDecl(Scope *S) { 8347 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 8348 CodeCompleter->getCodeCompletionTUInfo(), 8349 CodeCompletionContext::CCC_ObjCInterfaceName); 8350 Results.EnterNewScope(); 8351 8352 if (CodeCompleter->includeGlobals()) { 8353 // Add all classes. 8354 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false, 8355 false, Results); 8356 } 8357 8358 Results.ExitScope(); 8359 8360 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 8361 Results.data(), Results.size()); 8362 } 8363 8364 void Sema::CodeCompleteObjCSuperclass(Scope *S, IdentifierInfo *ClassName, 8365 SourceLocation ClassNameLoc) { 8366 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 8367 CodeCompleter->getCodeCompletionTUInfo(), 8368 CodeCompletionContext::CCC_ObjCInterfaceName); 8369 Results.EnterNewScope(); 8370 8371 // Make sure that we ignore the class we're currently defining. 8372 NamedDecl *CurClass = 8373 LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName); 8374 if (CurClass && isa<ObjCInterfaceDecl>(CurClass)) 8375 Results.Ignore(CurClass); 8376 8377 if (CodeCompleter->includeGlobals()) { 8378 // Add all classes. 8379 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false, 8380 false, Results); 8381 } 8382 8383 Results.ExitScope(); 8384 8385 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 8386 Results.data(), Results.size()); 8387 } 8388 8389 void Sema::CodeCompleteObjCImplementationDecl(Scope *S) { 8390 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 8391 CodeCompleter->getCodeCompletionTUInfo(), 8392 CodeCompletionContext::CCC_ObjCImplementation); 8393 Results.EnterNewScope(); 8394 8395 if (CodeCompleter->includeGlobals()) { 8396 // Add all unimplemented classes. 8397 AddInterfaceResults(Context.getTranslationUnitDecl(), CurContext, false, 8398 true, Results); 8399 } 8400 8401 Results.ExitScope(); 8402 8403 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 8404 Results.data(), Results.size()); 8405 } 8406 8407 void Sema::CodeCompleteObjCInterfaceCategory(Scope *S, 8408 IdentifierInfo *ClassName, 8409 SourceLocation ClassNameLoc) { 8410 typedef CodeCompletionResult Result; 8411 8412 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 8413 CodeCompleter->getCodeCompletionTUInfo(), 8414 CodeCompletionContext::CCC_ObjCCategoryName); 8415 8416 // Ignore any categories we find that have already been implemented by this 8417 // interface. 8418 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames; 8419 NamedDecl *CurClass = 8420 LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName); 8421 if (ObjCInterfaceDecl *Class = 8422 dyn_cast_or_null<ObjCInterfaceDecl>(CurClass)) { 8423 for (const auto *Cat : Class->visible_categories()) 8424 CategoryNames.insert(Cat->getIdentifier()); 8425 } 8426 8427 // Add all of the categories we know about. 8428 Results.EnterNewScope(); 8429 TranslationUnitDecl *TU = Context.getTranslationUnitDecl(); 8430 for (const auto *D : TU->decls()) 8431 if (const auto *Category = dyn_cast<ObjCCategoryDecl>(D)) 8432 if (CategoryNames.insert(Category->getIdentifier()).second) 8433 Results.AddResult( 8434 Result(Category, Results.getBasePriority(Category), nullptr), 8435 CurContext, nullptr, false); 8436 Results.ExitScope(); 8437 8438 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 8439 Results.data(), Results.size()); 8440 } 8441 8442 void Sema::CodeCompleteObjCImplementationCategory(Scope *S, 8443 IdentifierInfo *ClassName, 8444 SourceLocation ClassNameLoc) { 8445 typedef CodeCompletionResult Result; 8446 8447 // Find the corresponding interface. If we couldn't find the interface, the 8448 // program itself is ill-formed. However, we'll try to be helpful still by 8449 // providing the list of all of the categories we know about. 8450 NamedDecl *CurClass = 8451 LookupSingleName(TUScope, ClassName, ClassNameLoc, LookupOrdinaryName); 8452 ObjCInterfaceDecl *Class = dyn_cast_or_null<ObjCInterfaceDecl>(CurClass); 8453 if (!Class) 8454 return CodeCompleteObjCInterfaceCategory(S, ClassName, ClassNameLoc); 8455 8456 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 8457 CodeCompleter->getCodeCompletionTUInfo(), 8458 CodeCompletionContext::CCC_ObjCCategoryName); 8459 8460 // Add all of the categories that have have corresponding interface 8461 // declarations in this class and any of its superclasses, except for 8462 // already-implemented categories in the class itself. 8463 llvm::SmallPtrSet<IdentifierInfo *, 16> CategoryNames; 8464 Results.EnterNewScope(); 8465 bool IgnoreImplemented = true; 8466 while (Class) { 8467 for (const auto *Cat : Class->visible_categories()) { 8468 if ((!IgnoreImplemented || !Cat->getImplementation()) && 8469 CategoryNames.insert(Cat->getIdentifier()).second) 8470 Results.AddResult(Result(Cat, Results.getBasePriority(Cat), nullptr), 8471 CurContext, nullptr, false); 8472 } 8473 8474 Class = Class->getSuperClass(); 8475 IgnoreImplemented = false; 8476 } 8477 Results.ExitScope(); 8478 8479 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 8480 Results.data(), Results.size()); 8481 } 8482 8483 void Sema::CodeCompleteObjCPropertyDefinition(Scope *S) { 8484 CodeCompletionContext CCContext(CodeCompletionContext::CCC_Other); 8485 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 8486 CodeCompleter->getCodeCompletionTUInfo(), CCContext); 8487 8488 // Figure out where this @synthesize lives. 8489 ObjCContainerDecl *Container = 8490 dyn_cast_or_null<ObjCContainerDecl>(CurContext); 8491 if (!Container || (!isa<ObjCImplementationDecl>(Container) && 8492 !isa<ObjCCategoryImplDecl>(Container))) 8493 return; 8494 8495 // Ignore any properties that have already been implemented. 8496 Container = getContainerDef(Container); 8497 for (const auto *D : Container->decls()) 8498 if (const auto *PropertyImpl = dyn_cast<ObjCPropertyImplDecl>(D)) 8499 Results.Ignore(PropertyImpl->getPropertyDecl()); 8500 8501 // Add any properties that we find. 8502 AddedPropertiesSet AddedProperties; 8503 Results.EnterNewScope(); 8504 if (ObjCImplementationDecl *ClassImpl = 8505 dyn_cast<ObjCImplementationDecl>(Container)) 8506 AddObjCProperties(CCContext, ClassImpl->getClassInterface(), false, 8507 /*AllowNullaryMethods=*/false, CurContext, 8508 AddedProperties, Results); 8509 else 8510 AddObjCProperties(CCContext, 8511 cast<ObjCCategoryImplDecl>(Container)->getCategoryDecl(), 8512 false, /*AllowNullaryMethods=*/false, CurContext, 8513 AddedProperties, Results); 8514 Results.ExitScope(); 8515 8516 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 8517 Results.data(), Results.size()); 8518 } 8519 8520 void Sema::CodeCompleteObjCPropertySynthesizeIvar( 8521 Scope *S, IdentifierInfo *PropertyName) { 8522 typedef CodeCompletionResult Result; 8523 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 8524 CodeCompleter->getCodeCompletionTUInfo(), 8525 CodeCompletionContext::CCC_Other); 8526 8527 // Figure out where this @synthesize lives. 8528 ObjCContainerDecl *Container = 8529 dyn_cast_or_null<ObjCContainerDecl>(CurContext); 8530 if (!Container || (!isa<ObjCImplementationDecl>(Container) && 8531 !isa<ObjCCategoryImplDecl>(Container))) 8532 return; 8533 8534 // Figure out which interface we're looking into. 8535 ObjCInterfaceDecl *Class = nullptr; 8536 if (ObjCImplementationDecl *ClassImpl = 8537 dyn_cast<ObjCImplementationDecl>(Container)) 8538 Class = ClassImpl->getClassInterface(); 8539 else 8540 Class = cast<ObjCCategoryImplDecl>(Container) 8541 ->getCategoryDecl() 8542 ->getClassInterface(); 8543 8544 // Determine the type of the property we're synthesizing. 8545 QualType PropertyType = Context.getObjCIdType(); 8546 if (Class) { 8547 if (ObjCPropertyDecl *Property = Class->FindPropertyDeclaration( 8548 PropertyName, ObjCPropertyQueryKind::OBJC_PR_query_instance)) { 8549 PropertyType = 8550 Property->getType().getNonReferenceType().getUnqualifiedType(); 8551 8552 // Give preference to ivars 8553 Results.setPreferredType(PropertyType); 8554 } 8555 } 8556 8557 // Add all of the instance variables in this class and its superclasses. 8558 Results.EnterNewScope(); 8559 bool SawSimilarlyNamedIvar = false; 8560 std::string NameWithPrefix; 8561 NameWithPrefix += '_'; 8562 NameWithPrefix += PropertyName->getName(); 8563 std::string NameWithSuffix = PropertyName->getName().str(); 8564 NameWithSuffix += '_'; 8565 for (; Class; Class = Class->getSuperClass()) { 8566 for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar; 8567 Ivar = Ivar->getNextIvar()) { 8568 Results.AddResult(Result(Ivar, Results.getBasePriority(Ivar), nullptr), 8569 CurContext, nullptr, false); 8570 8571 // Determine whether we've seen an ivar with a name similar to the 8572 // property. 8573 if ((PropertyName == Ivar->getIdentifier() || 8574 NameWithPrefix == Ivar->getName() || 8575 NameWithSuffix == Ivar->getName())) { 8576 SawSimilarlyNamedIvar = true; 8577 8578 // Reduce the priority of this result by one, to give it a slight 8579 // advantage over other results whose names don't match so closely. 8580 if (Results.size() && 8581 Results.data()[Results.size() - 1].Kind == 8582 CodeCompletionResult::RK_Declaration && 8583 Results.data()[Results.size() - 1].Declaration == Ivar) 8584 Results.data()[Results.size() - 1].Priority--; 8585 } 8586 } 8587 } 8588 8589 if (!SawSimilarlyNamedIvar) { 8590 // Create ivar result _propName, that the user can use to synthesize 8591 // an ivar of the appropriate type. 8592 unsigned Priority = CCP_MemberDeclaration + 1; 8593 typedef CodeCompletionResult Result; 8594 CodeCompletionAllocator &Allocator = Results.getAllocator(); 8595 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo(), 8596 Priority, CXAvailability_Available); 8597 8598 PrintingPolicy Policy = getCompletionPrintingPolicy(*this); 8599 Builder.AddResultTypeChunk( 8600 GetCompletionTypeString(PropertyType, Context, Policy, Allocator)); 8601 Builder.AddTypedTextChunk(Allocator.CopyString(NameWithPrefix)); 8602 Results.AddResult( 8603 Result(Builder.TakeString(), Priority, CXCursor_ObjCIvarDecl)); 8604 } 8605 8606 Results.ExitScope(); 8607 8608 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 8609 Results.data(), Results.size()); 8610 } 8611 8612 // Mapping from selectors to the methods that implement that selector, along 8613 // with the "in original class" flag. 8614 typedef llvm::DenseMap<Selector, 8615 llvm::PointerIntPair<ObjCMethodDecl *, 1, bool>> 8616 KnownMethodsMap; 8617 8618 /// Find all of the methods that reside in the given container 8619 /// (and its superclasses, protocols, etc.) that meet the given 8620 /// criteria. Insert those methods into the map of known methods, 8621 /// indexed by selector so they can be easily found. 8622 static void FindImplementableMethods(ASTContext &Context, 8623 ObjCContainerDecl *Container, 8624 Optional<bool> WantInstanceMethods, 8625 QualType ReturnType, 8626 KnownMethodsMap &KnownMethods, 8627 bool InOriginalClass = true) { 8628 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(Container)) { 8629 // Make sure we have a definition; that's what we'll walk. 8630 if (!IFace->hasDefinition()) 8631 return; 8632 8633 IFace = IFace->getDefinition(); 8634 Container = IFace; 8635 8636 const ObjCList<ObjCProtocolDecl> &Protocols = 8637 IFace->getReferencedProtocols(); 8638 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 8639 E = Protocols.end(); 8640 I != E; ++I) 8641 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType, 8642 KnownMethods, InOriginalClass); 8643 8644 // Add methods from any class extensions and categories. 8645 for (auto *Cat : IFace->visible_categories()) { 8646 FindImplementableMethods(Context, Cat, WantInstanceMethods, ReturnType, 8647 KnownMethods, false); 8648 } 8649 8650 // Visit the superclass. 8651 if (IFace->getSuperClass()) 8652 FindImplementableMethods(Context, IFace->getSuperClass(), 8653 WantInstanceMethods, ReturnType, KnownMethods, 8654 false); 8655 } 8656 8657 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(Container)) { 8658 // Recurse into protocols. 8659 const ObjCList<ObjCProtocolDecl> &Protocols = 8660 Category->getReferencedProtocols(); 8661 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 8662 E = Protocols.end(); 8663 I != E; ++I) 8664 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType, 8665 KnownMethods, InOriginalClass); 8666 8667 // If this category is the original class, jump to the interface. 8668 if (InOriginalClass && Category->getClassInterface()) 8669 FindImplementableMethods(Context, Category->getClassInterface(), 8670 WantInstanceMethods, ReturnType, KnownMethods, 8671 false); 8672 } 8673 8674 if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) { 8675 // Make sure we have a definition; that's what we'll walk. 8676 if (!Protocol->hasDefinition()) 8677 return; 8678 Protocol = Protocol->getDefinition(); 8679 Container = Protocol; 8680 8681 // Recurse into protocols. 8682 const ObjCList<ObjCProtocolDecl> &Protocols = 8683 Protocol->getReferencedProtocols(); 8684 for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), 8685 E = Protocols.end(); 8686 I != E; ++I) 8687 FindImplementableMethods(Context, *I, WantInstanceMethods, ReturnType, 8688 KnownMethods, false); 8689 } 8690 8691 // Add methods in this container. This operation occurs last because 8692 // we want the methods from this container to override any methods 8693 // we've previously seen with the same selector. 8694 for (auto *M : Container->methods()) { 8695 if (!WantInstanceMethods || M->isInstanceMethod() == *WantInstanceMethods) { 8696 if (!ReturnType.isNull() && 8697 !Context.hasSameUnqualifiedType(ReturnType, M->getReturnType())) 8698 continue; 8699 8700 KnownMethods[M->getSelector()] = 8701 KnownMethodsMap::mapped_type(M, InOriginalClass); 8702 } 8703 } 8704 } 8705 8706 /// Add the parenthesized return or parameter type chunk to a code 8707 /// completion string. 8708 static void AddObjCPassingTypeChunk(QualType Type, unsigned ObjCDeclQuals, 8709 ASTContext &Context, 8710 const PrintingPolicy &Policy, 8711 CodeCompletionBuilder &Builder) { 8712 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 8713 std::string Quals = formatObjCParamQualifiers(ObjCDeclQuals, Type); 8714 if (!Quals.empty()) 8715 Builder.AddTextChunk(Builder.getAllocator().CopyString(Quals)); 8716 Builder.AddTextChunk( 8717 GetCompletionTypeString(Type, Context, Policy, Builder.getAllocator())); 8718 Builder.AddChunk(CodeCompletionString::CK_RightParen); 8719 } 8720 8721 /// Determine whether the given class is or inherits from a class by 8722 /// the given name. 8723 static bool InheritsFromClassNamed(ObjCInterfaceDecl *Class, StringRef Name) { 8724 if (!Class) 8725 return false; 8726 8727 if (Class->getIdentifier() && Class->getIdentifier()->getName() == Name) 8728 return true; 8729 8730 return InheritsFromClassNamed(Class->getSuperClass(), Name); 8731 } 8732 8733 /// Add code completions for Objective-C Key-Value Coding (KVC) and 8734 /// Key-Value Observing (KVO). 8735 static void AddObjCKeyValueCompletions(ObjCPropertyDecl *Property, 8736 bool IsInstanceMethod, 8737 QualType ReturnType, ASTContext &Context, 8738 VisitedSelectorSet &KnownSelectors, 8739 ResultBuilder &Results) { 8740 IdentifierInfo *PropName = Property->getIdentifier(); 8741 if (!PropName || PropName->getLength() == 0) 8742 return; 8743 8744 PrintingPolicy Policy = getCompletionPrintingPolicy(Results.getSema()); 8745 8746 // Builder that will create each code completion. 8747 typedef CodeCompletionResult Result; 8748 CodeCompletionAllocator &Allocator = Results.getAllocator(); 8749 CodeCompletionBuilder Builder(Allocator, Results.getCodeCompletionTUInfo()); 8750 8751 // The selector table. 8752 SelectorTable &Selectors = Context.Selectors; 8753 8754 // The property name, copied into the code completion allocation region 8755 // on demand. 8756 struct KeyHolder { 8757 CodeCompletionAllocator &Allocator; 8758 StringRef Key; 8759 const char *CopiedKey; 8760 8761 KeyHolder(CodeCompletionAllocator &Allocator, StringRef Key) 8762 : Allocator(Allocator), Key(Key), CopiedKey(nullptr) {} 8763 8764 operator const char *() { 8765 if (CopiedKey) 8766 return CopiedKey; 8767 8768 return CopiedKey = Allocator.CopyString(Key); 8769 } 8770 } Key(Allocator, PropName->getName()); 8771 8772 // The uppercased name of the property name. 8773 std::string UpperKey = std::string(PropName->getName()); 8774 if (!UpperKey.empty()) 8775 UpperKey[0] = toUppercase(UpperKey[0]); 8776 8777 bool ReturnTypeMatchesProperty = 8778 ReturnType.isNull() || 8779 Context.hasSameUnqualifiedType(ReturnType.getNonReferenceType(), 8780 Property->getType()); 8781 bool ReturnTypeMatchesVoid = ReturnType.isNull() || ReturnType->isVoidType(); 8782 8783 // Add the normal accessor -(type)key. 8784 if (IsInstanceMethod && 8785 KnownSelectors.insert(Selectors.getNullarySelector(PropName)).second && 8786 ReturnTypeMatchesProperty && !Property->getGetterMethodDecl()) { 8787 if (ReturnType.isNull()) 8788 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0, Context, Policy, 8789 Builder); 8790 8791 Builder.AddTypedTextChunk(Key); 8792 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern, 8793 CXCursor_ObjCInstanceMethodDecl)); 8794 } 8795 8796 // If we have an integral or boolean property (or the user has provided 8797 // an integral or boolean return type), add the accessor -(type)isKey. 8798 if (IsInstanceMethod && 8799 ((!ReturnType.isNull() && 8800 (ReturnType->isIntegerType() || ReturnType->isBooleanType())) || 8801 (ReturnType.isNull() && (Property->getType()->isIntegerType() || 8802 Property->getType()->isBooleanType())))) { 8803 std::string SelectorName = (Twine("is") + UpperKey).str(); 8804 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); 8805 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId)) 8806 .second) { 8807 if (ReturnType.isNull()) { 8808 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 8809 Builder.AddTextChunk("BOOL"); 8810 Builder.AddChunk(CodeCompletionString::CK_RightParen); 8811 } 8812 8813 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorId->getName())); 8814 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern, 8815 CXCursor_ObjCInstanceMethodDecl)); 8816 } 8817 } 8818 8819 // Add the normal mutator. 8820 if (IsInstanceMethod && ReturnTypeMatchesVoid && 8821 !Property->getSetterMethodDecl()) { 8822 std::string SelectorName = (Twine("set") + UpperKey).str(); 8823 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); 8824 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { 8825 if (ReturnType.isNull()) { 8826 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 8827 Builder.AddTextChunk("void"); 8828 Builder.AddChunk(CodeCompletionString::CK_RightParen); 8829 } 8830 8831 Builder.AddTypedTextChunk( 8832 Allocator.CopyString(SelectorId->getName() + ":")); 8833 AddObjCPassingTypeChunk(Property->getType(), /*Quals=*/0, Context, Policy, 8834 Builder); 8835 Builder.AddTextChunk(Key); 8836 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern, 8837 CXCursor_ObjCInstanceMethodDecl)); 8838 } 8839 } 8840 8841 // Indexed and unordered accessors 8842 unsigned IndexedGetterPriority = CCP_CodePattern; 8843 unsigned IndexedSetterPriority = CCP_CodePattern; 8844 unsigned UnorderedGetterPriority = CCP_CodePattern; 8845 unsigned UnorderedSetterPriority = CCP_CodePattern; 8846 if (const auto *ObjCPointer = 8847 Property->getType()->getAs<ObjCObjectPointerType>()) { 8848 if (ObjCInterfaceDecl *IFace = ObjCPointer->getInterfaceDecl()) { 8849 // If this interface type is not provably derived from a known 8850 // collection, penalize the corresponding completions. 8851 if (!InheritsFromClassNamed(IFace, "NSMutableArray")) { 8852 IndexedSetterPriority += CCD_ProbablyNotObjCCollection; 8853 if (!InheritsFromClassNamed(IFace, "NSArray")) 8854 IndexedGetterPriority += CCD_ProbablyNotObjCCollection; 8855 } 8856 8857 if (!InheritsFromClassNamed(IFace, "NSMutableSet")) { 8858 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection; 8859 if (!InheritsFromClassNamed(IFace, "NSSet")) 8860 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection; 8861 } 8862 } 8863 } else { 8864 IndexedGetterPriority += CCD_ProbablyNotObjCCollection; 8865 IndexedSetterPriority += CCD_ProbablyNotObjCCollection; 8866 UnorderedGetterPriority += CCD_ProbablyNotObjCCollection; 8867 UnorderedSetterPriority += CCD_ProbablyNotObjCCollection; 8868 } 8869 8870 // Add -(NSUInteger)countOf<key> 8871 if (IsInstanceMethod && 8872 (ReturnType.isNull() || ReturnType->isIntegerType())) { 8873 std::string SelectorName = (Twine("countOf") + UpperKey).str(); 8874 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); 8875 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId)) 8876 .second) { 8877 if (ReturnType.isNull()) { 8878 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 8879 Builder.AddTextChunk("NSUInteger"); 8880 Builder.AddChunk(CodeCompletionString::CK_RightParen); 8881 } 8882 8883 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorId->getName())); 8884 Results.AddResult( 8885 Result(Builder.TakeString(), 8886 std::min(IndexedGetterPriority, UnorderedGetterPriority), 8887 CXCursor_ObjCInstanceMethodDecl)); 8888 } 8889 } 8890 8891 // Indexed getters 8892 // Add -(id)objectInKeyAtIndex:(NSUInteger)index 8893 if (IsInstanceMethod && 8894 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) { 8895 std::string SelectorName = (Twine("objectIn") + UpperKey + "AtIndex").str(); 8896 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); 8897 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { 8898 if (ReturnType.isNull()) { 8899 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 8900 Builder.AddTextChunk("id"); 8901 Builder.AddChunk(CodeCompletionString::CK_RightParen); 8902 } 8903 8904 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); 8905 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 8906 Builder.AddTextChunk("NSUInteger"); 8907 Builder.AddChunk(CodeCompletionString::CK_RightParen); 8908 Builder.AddTextChunk("index"); 8909 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority, 8910 CXCursor_ObjCInstanceMethodDecl)); 8911 } 8912 } 8913 8914 // Add -(NSArray *)keyAtIndexes:(NSIndexSet *)indexes 8915 if (IsInstanceMethod && 8916 (ReturnType.isNull() || 8917 (ReturnType->isObjCObjectPointerType() && 8918 ReturnType->castAs<ObjCObjectPointerType>()->getInterfaceDecl() && 8919 ReturnType->castAs<ObjCObjectPointerType>() 8920 ->getInterfaceDecl() 8921 ->getName() == "NSArray"))) { 8922 std::string SelectorName = (Twine(Property->getName()) + "AtIndexes").str(); 8923 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); 8924 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { 8925 if (ReturnType.isNull()) { 8926 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 8927 Builder.AddTextChunk("NSArray *"); 8928 Builder.AddChunk(CodeCompletionString::CK_RightParen); 8929 } 8930 8931 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); 8932 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 8933 Builder.AddTextChunk("NSIndexSet *"); 8934 Builder.AddChunk(CodeCompletionString::CK_RightParen); 8935 Builder.AddTextChunk("indexes"); 8936 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority, 8937 CXCursor_ObjCInstanceMethodDecl)); 8938 } 8939 } 8940 8941 // Add -(void)getKey:(type **)buffer range:(NSRange)inRange 8942 if (IsInstanceMethod && ReturnTypeMatchesVoid) { 8943 std::string SelectorName = (Twine("get") + UpperKey).str(); 8944 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName), 8945 &Context.Idents.get("range")}; 8946 8947 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) { 8948 if (ReturnType.isNull()) { 8949 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 8950 Builder.AddTextChunk("void"); 8951 Builder.AddChunk(CodeCompletionString::CK_RightParen); 8952 } 8953 8954 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); 8955 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 8956 Builder.AddPlaceholderChunk("object-type"); 8957 Builder.AddTextChunk(" **"); 8958 Builder.AddChunk(CodeCompletionString::CK_RightParen); 8959 Builder.AddTextChunk("buffer"); 8960 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 8961 Builder.AddTypedTextChunk("range:"); 8962 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 8963 Builder.AddTextChunk("NSRange"); 8964 Builder.AddChunk(CodeCompletionString::CK_RightParen); 8965 Builder.AddTextChunk("inRange"); 8966 Results.AddResult(Result(Builder.TakeString(), IndexedGetterPriority, 8967 CXCursor_ObjCInstanceMethodDecl)); 8968 } 8969 } 8970 8971 // Mutable indexed accessors 8972 8973 // - (void)insertObject:(type *)object inKeyAtIndex:(NSUInteger)index 8974 if (IsInstanceMethod && ReturnTypeMatchesVoid) { 8975 std::string SelectorName = (Twine("in") + UpperKey + "AtIndex").str(); 8976 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get("insertObject"), 8977 &Context.Idents.get(SelectorName)}; 8978 8979 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) { 8980 if (ReturnType.isNull()) { 8981 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 8982 Builder.AddTextChunk("void"); 8983 Builder.AddChunk(CodeCompletionString::CK_RightParen); 8984 } 8985 8986 Builder.AddTypedTextChunk("insertObject:"); 8987 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 8988 Builder.AddPlaceholderChunk("object-type"); 8989 Builder.AddTextChunk(" *"); 8990 Builder.AddChunk(CodeCompletionString::CK_RightParen); 8991 Builder.AddTextChunk("object"); 8992 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 8993 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); 8994 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 8995 Builder.AddPlaceholderChunk("NSUInteger"); 8996 Builder.AddChunk(CodeCompletionString::CK_RightParen); 8997 Builder.AddTextChunk("index"); 8998 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority, 8999 CXCursor_ObjCInstanceMethodDecl)); 9000 } 9001 } 9002 9003 // - (void)insertKey:(NSArray *)array atIndexes:(NSIndexSet *)indexes 9004 if (IsInstanceMethod && ReturnTypeMatchesVoid) { 9005 std::string SelectorName = (Twine("insert") + UpperKey).str(); 9006 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName), 9007 &Context.Idents.get("atIndexes")}; 9008 9009 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) { 9010 if (ReturnType.isNull()) { 9011 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9012 Builder.AddTextChunk("void"); 9013 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9014 } 9015 9016 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); 9017 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9018 Builder.AddTextChunk("NSArray *"); 9019 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9020 Builder.AddTextChunk("array"); 9021 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9022 Builder.AddTypedTextChunk("atIndexes:"); 9023 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9024 Builder.AddPlaceholderChunk("NSIndexSet *"); 9025 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9026 Builder.AddTextChunk("indexes"); 9027 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority, 9028 CXCursor_ObjCInstanceMethodDecl)); 9029 } 9030 } 9031 9032 // -(void)removeObjectFromKeyAtIndex:(NSUInteger)index 9033 if (IsInstanceMethod && ReturnTypeMatchesVoid) { 9034 std::string SelectorName = 9035 (Twine("removeObjectFrom") + UpperKey + "AtIndex").str(); 9036 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); 9037 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { 9038 if (ReturnType.isNull()) { 9039 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9040 Builder.AddTextChunk("void"); 9041 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9042 } 9043 9044 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); 9045 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9046 Builder.AddTextChunk("NSUInteger"); 9047 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9048 Builder.AddTextChunk("index"); 9049 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority, 9050 CXCursor_ObjCInstanceMethodDecl)); 9051 } 9052 } 9053 9054 // -(void)removeKeyAtIndexes:(NSIndexSet *)indexes 9055 if (IsInstanceMethod && ReturnTypeMatchesVoid) { 9056 std::string SelectorName = (Twine("remove") + UpperKey + "AtIndexes").str(); 9057 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); 9058 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { 9059 if (ReturnType.isNull()) { 9060 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9061 Builder.AddTextChunk("void"); 9062 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9063 } 9064 9065 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); 9066 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9067 Builder.AddTextChunk("NSIndexSet *"); 9068 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9069 Builder.AddTextChunk("indexes"); 9070 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority, 9071 CXCursor_ObjCInstanceMethodDecl)); 9072 } 9073 } 9074 9075 // - (void)replaceObjectInKeyAtIndex:(NSUInteger)index withObject:(id)object 9076 if (IsInstanceMethod && ReturnTypeMatchesVoid) { 9077 std::string SelectorName = 9078 (Twine("replaceObjectIn") + UpperKey + "AtIndex").str(); 9079 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName), 9080 &Context.Idents.get("withObject")}; 9081 9082 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) { 9083 if (ReturnType.isNull()) { 9084 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9085 Builder.AddTextChunk("void"); 9086 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9087 } 9088 9089 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); 9090 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9091 Builder.AddPlaceholderChunk("NSUInteger"); 9092 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9093 Builder.AddTextChunk("index"); 9094 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9095 Builder.AddTypedTextChunk("withObject:"); 9096 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9097 Builder.AddTextChunk("id"); 9098 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9099 Builder.AddTextChunk("object"); 9100 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority, 9101 CXCursor_ObjCInstanceMethodDecl)); 9102 } 9103 } 9104 9105 // - (void)replaceKeyAtIndexes:(NSIndexSet *)indexes withKey:(NSArray *)array 9106 if (IsInstanceMethod && ReturnTypeMatchesVoid) { 9107 std::string SelectorName1 = 9108 (Twine("replace") + UpperKey + "AtIndexes").str(); 9109 std::string SelectorName2 = (Twine("with") + UpperKey).str(); 9110 IdentifierInfo *SelectorIds[2] = {&Context.Idents.get(SelectorName1), 9111 &Context.Idents.get(SelectorName2)}; 9112 9113 if (KnownSelectors.insert(Selectors.getSelector(2, SelectorIds)).second) { 9114 if (ReturnType.isNull()) { 9115 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9116 Builder.AddTextChunk("void"); 9117 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9118 } 9119 9120 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName1 + ":")); 9121 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9122 Builder.AddPlaceholderChunk("NSIndexSet *"); 9123 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9124 Builder.AddTextChunk("indexes"); 9125 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9126 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName2 + ":")); 9127 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9128 Builder.AddTextChunk("NSArray *"); 9129 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9130 Builder.AddTextChunk("array"); 9131 Results.AddResult(Result(Builder.TakeString(), IndexedSetterPriority, 9132 CXCursor_ObjCInstanceMethodDecl)); 9133 } 9134 } 9135 9136 // Unordered getters 9137 // - (NSEnumerator *)enumeratorOfKey 9138 if (IsInstanceMethod && 9139 (ReturnType.isNull() || 9140 (ReturnType->isObjCObjectPointerType() && 9141 ReturnType->getAs<ObjCObjectPointerType>()->getInterfaceDecl() && 9142 ReturnType->getAs<ObjCObjectPointerType>() 9143 ->getInterfaceDecl() 9144 ->getName() == "NSEnumerator"))) { 9145 std::string SelectorName = (Twine("enumeratorOf") + UpperKey).str(); 9146 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); 9147 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId)) 9148 .second) { 9149 if (ReturnType.isNull()) { 9150 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9151 Builder.AddTextChunk("NSEnumerator *"); 9152 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9153 } 9154 9155 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName)); 9156 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority, 9157 CXCursor_ObjCInstanceMethodDecl)); 9158 } 9159 } 9160 9161 // - (type *)memberOfKey:(type *)object 9162 if (IsInstanceMethod && 9163 (ReturnType.isNull() || ReturnType->isObjCObjectPointerType())) { 9164 std::string SelectorName = (Twine("memberOf") + UpperKey).str(); 9165 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); 9166 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { 9167 if (ReturnType.isNull()) { 9168 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9169 Builder.AddPlaceholderChunk("object-type"); 9170 Builder.AddTextChunk(" *"); 9171 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9172 } 9173 9174 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); 9175 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9176 if (ReturnType.isNull()) { 9177 Builder.AddPlaceholderChunk("object-type"); 9178 Builder.AddTextChunk(" *"); 9179 } else { 9180 Builder.AddTextChunk(GetCompletionTypeString( 9181 ReturnType, Context, Policy, Builder.getAllocator())); 9182 } 9183 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9184 Builder.AddTextChunk("object"); 9185 Results.AddResult(Result(Builder.TakeString(), UnorderedGetterPriority, 9186 CXCursor_ObjCInstanceMethodDecl)); 9187 } 9188 } 9189 9190 // Mutable unordered accessors 9191 // - (void)addKeyObject:(type *)object 9192 if (IsInstanceMethod && ReturnTypeMatchesVoid) { 9193 std::string SelectorName = 9194 (Twine("add") + UpperKey + Twine("Object")).str(); 9195 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); 9196 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { 9197 if (ReturnType.isNull()) { 9198 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9199 Builder.AddTextChunk("void"); 9200 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9201 } 9202 9203 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); 9204 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9205 Builder.AddPlaceholderChunk("object-type"); 9206 Builder.AddTextChunk(" *"); 9207 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9208 Builder.AddTextChunk("object"); 9209 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority, 9210 CXCursor_ObjCInstanceMethodDecl)); 9211 } 9212 } 9213 9214 // - (void)addKey:(NSSet *)objects 9215 if (IsInstanceMethod && ReturnTypeMatchesVoid) { 9216 std::string SelectorName = (Twine("add") + UpperKey).str(); 9217 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); 9218 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { 9219 if (ReturnType.isNull()) { 9220 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9221 Builder.AddTextChunk("void"); 9222 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9223 } 9224 9225 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); 9226 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9227 Builder.AddTextChunk("NSSet *"); 9228 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9229 Builder.AddTextChunk("objects"); 9230 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority, 9231 CXCursor_ObjCInstanceMethodDecl)); 9232 } 9233 } 9234 9235 // - (void)removeKeyObject:(type *)object 9236 if (IsInstanceMethod && ReturnTypeMatchesVoid) { 9237 std::string SelectorName = 9238 (Twine("remove") + UpperKey + Twine("Object")).str(); 9239 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); 9240 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { 9241 if (ReturnType.isNull()) { 9242 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9243 Builder.AddTextChunk("void"); 9244 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9245 } 9246 9247 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); 9248 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9249 Builder.AddPlaceholderChunk("object-type"); 9250 Builder.AddTextChunk(" *"); 9251 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9252 Builder.AddTextChunk("object"); 9253 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority, 9254 CXCursor_ObjCInstanceMethodDecl)); 9255 } 9256 } 9257 9258 // - (void)removeKey:(NSSet *)objects 9259 if (IsInstanceMethod && ReturnTypeMatchesVoid) { 9260 std::string SelectorName = (Twine("remove") + UpperKey).str(); 9261 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); 9262 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { 9263 if (ReturnType.isNull()) { 9264 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9265 Builder.AddTextChunk("void"); 9266 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9267 } 9268 9269 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); 9270 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9271 Builder.AddTextChunk("NSSet *"); 9272 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9273 Builder.AddTextChunk("objects"); 9274 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority, 9275 CXCursor_ObjCInstanceMethodDecl)); 9276 } 9277 } 9278 9279 // - (void)intersectKey:(NSSet *)objects 9280 if (IsInstanceMethod && ReturnTypeMatchesVoid) { 9281 std::string SelectorName = (Twine("intersect") + UpperKey).str(); 9282 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); 9283 if (KnownSelectors.insert(Selectors.getUnarySelector(SelectorId)).second) { 9284 if (ReturnType.isNull()) { 9285 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9286 Builder.AddTextChunk("void"); 9287 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9288 } 9289 9290 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName + ":")); 9291 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9292 Builder.AddTextChunk("NSSet *"); 9293 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9294 Builder.AddTextChunk("objects"); 9295 Results.AddResult(Result(Builder.TakeString(), UnorderedSetterPriority, 9296 CXCursor_ObjCInstanceMethodDecl)); 9297 } 9298 } 9299 9300 // Key-Value Observing 9301 // + (NSSet *)keyPathsForValuesAffectingKey 9302 if (!IsInstanceMethod && 9303 (ReturnType.isNull() || 9304 (ReturnType->isObjCObjectPointerType() && 9305 ReturnType->castAs<ObjCObjectPointerType>()->getInterfaceDecl() && 9306 ReturnType->castAs<ObjCObjectPointerType>() 9307 ->getInterfaceDecl() 9308 ->getName() == "NSSet"))) { 9309 std::string SelectorName = 9310 (Twine("keyPathsForValuesAffecting") + UpperKey).str(); 9311 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); 9312 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId)) 9313 .second) { 9314 if (ReturnType.isNull()) { 9315 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9316 Builder.AddTextChunk("NSSet<NSString *> *"); 9317 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9318 } 9319 9320 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName)); 9321 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern, 9322 CXCursor_ObjCClassMethodDecl)); 9323 } 9324 } 9325 9326 // + (BOOL)automaticallyNotifiesObserversForKey 9327 if (!IsInstanceMethod && 9328 (ReturnType.isNull() || ReturnType->isIntegerType() || 9329 ReturnType->isBooleanType())) { 9330 std::string SelectorName = 9331 (Twine("automaticallyNotifiesObserversOf") + UpperKey).str(); 9332 IdentifierInfo *SelectorId = &Context.Idents.get(SelectorName); 9333 if (KnownSelectors.insert(Selectors.getNullarySelector(SelectorId)) 9334 .second) { 9335 if (ReturnType.isNull()) { 9336 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9337 Builder.AddTextChunk("BOOL"); 9338 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9339 } 9340 9341 Builder.AddTypedTextChunk(Allocator.CopyString(SelectorName)); 9342 Results.AddResult(Result(Builder.TakeString(), CCP_CodePattern, 9343 CXCursor_ObjCClassMethodDecl)); 9344 } 9345 } 9346 } 9347 9348 void Sema::CodeCompleteObjCMethodDecl(Scope *S, Optional<bool> IsInstanceMethod, 9349 ParsedType ReturnTy) { 9350 // Determine the return type of the method we're declaring, if 9351 // provided. 9352 QualType ReturnType = GetTypeFromParser(ReturnTy); 9353 Decl *IDecl = nullptr; 9354 if (CurContext->isObjCContainer()) { 9355 ObjCContainerDecl *OCD = dyn_cast<ObjCContainerDecl>(CurContext); 9356 IDecl = OCD; 9357 } 9358 // Determine where we should start searching for methods. 9359 ObjCContainerDecl *SearchDecl = nullptr; 9360 bool IsInImplementation = false; 9361 if (Decl *D = IDecl) { 9362 if (ObjCImplementationDecl *Impl = dyn_cast<ObjCImplementationDecl>(D)) { 9363 SearchDecl = Impl->getClassInterface(); 9364 IsInImplementation = true; 9365 } else if (ObjCCategoryImplDecl *CatImpl = 9366 dyn_cast<ObjCCategoryImplDecl>(D)) { 9367 SearchDecl = CatImpl->getCategoryDecl(); 9368 IsInImplementation = true; 9369 } else 9370 SearchDecl = dyn_cast<ObjCContainerDecl>(D); 9371 } 9372 9373 if (!SearchDecl && S) { 9374 if (DeclContext *DC = S->getEntity()) 9375 SearchDecl = dyn_cast<ObjCContainerDecl>(DC); 9376 } 9377 9378 if (!SearchDecl) { 9379 HandleCodeCompleteResults(this, CodeCompleter, 9380 CodeCompletionContext::CCC_Other, nullptr, 0); 9381 return; 9382 } 9383 9384 // Find all of the methods that we could declare/implement here. 9385 KnownMethodsMap KnownMethods; 9386 FindImplementableMethods(Context, SearchDecl, IsInstanceMethod, ReturnType, 9387 KnownMethods); 9388 9389 // Add declarations or definitions for each of the known methods. 9390 typedef CodeCompletionResult Result; 9391 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 9392 CodeCompleter->getCodeCompletionTUInfo(), 9393 CodeCompletionContext::CCC_Other); 9394 Results.EnterNewScope(); 9395 PrintingPolicy Policy = getCompletionPrintingPolicy(*this); 9396 for (KnownMethodsMap::iterator M = KnownMethods.begin(), 9397 MEnd = KnownMethods.end(); 9398 M != MEnd; ++M) { 9399 ObjCMethodDecl *Method = M->second.getPointer(); 9400 CodeCompletionBuilder Builder(Results.getAllocator(), 9401 Results.getCodeCompletionTUInfo()); 9402 9403 // Add the '-'/'+' prefix if it wasn't provided yet. 9404 if (!IsInstanceMethod) { 9405 Builder.AddTextChunk(Method->isInstanceMethod() ? "-" : "+"); 9406 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9407 } 9408 9409 // If the result type was not already provided, add it to the 9410 // pattern as (type). 9411 if (ReturnType.isNull()) { 9412 QualType ResTy = Method->getSendResultType().stripObjCKindOfType(Context); 9413 AttributedType::stripOuterNullability(ResTy); 9414 AddObjCPassingTypeChunk(ResTy, Method->getObjCDeclQualifier(), Context, 9415 Policy, Builder); 9416 } 9417 9418 Selector Sel = Method->getSelector(); 9419 9420 if (Sel.isUnarySelector()) { 9421 // Unary selectors have no arguments. 9422 Builder.AddTypedTextChunk( 9423 Builder.getAllocator().CopyString(Sel.getNameForSlot(0))); 9424 } else { 9425 // Add all parameters to the pattern. 9426 unsigned I = 0; 9427 for (ObjCMethodDecl::param_iterator P = Method->param_begin(), 9428 PEnd = Method->param_end(); 9429 P != PEnd; (void)++P, ++I) { 9430 // Add the part of the selector name. 9431 if (I == 0) 9432 Builder.AddTypedTextChunk( 9433 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":")); 9434 else if (I < Sel.getNumArgs()) { 9435 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9436 Builder.AddTypedTextChunk( 9437 Builder.getAllocator().CopyString(Sel.getNameForSlot(I) + ":")); 9438 } else 9439 break; 9440 9441 // Add the parameter type. 9442 QualType ParamType; 9443 if ((*P)->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) 9444 ParamType = (*P)->getType(); 9445 else 9446 ParamType = (*P)->getOriginalType(); 9447 ParamType = ParamType.substObjCTypeArgs( 9448 Context, {}, ObjCSubstitutionContext::Parameter); 9449 AttributedType::stripOuterNullability(ParamType); 9450 AddObjCPassingTypeChunk(ParamType, (*P)->getObjCDeclQualifier(), 9451 Context, Policy, Builder); 9452 9453 if (IdentifierInfo *Id = (*P)->getIdentifier()) 9454 Builder.AddTextChunk( 9455 Builder.getAllocator().CopyString(Id->getName())); 9456 } 9457 } 9458 9459 if (Method->isVariadic()) { 9460 if (Method->param_size() > 0) 9461 Builder.AddChunk(CodeCompletionString::CK_Comma); 9462 Builder.AddTextChunk("..."); 9463 } 9464 9465 if (IsInImplementation && Results.includeCodePatterns()) { 9466 // We will be defining the method here, so add a compound statement. 9467 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9468 Builder.AddChunk(CodeCompletionString::CK_LeftBrace); 9469 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 9470 if (!Method->getReturnType()->isVoidType()) { 9471 // If the result type is not void, add a return clause. 9472 Builder.AddTextChunk("return"); 9473 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9474 Builder.AddPlaceholderChunk("expression"); 9475 Builder.AddChunk(CodeCompletionString::CK_SemiColon); 9476 } else 9477 Builder.AddPlaceholderChunk("statements"); 9478 9479 Builder.AddChunk(CodeCompletionString::CK_VerticalSpace); 9480 Builder.AddChunk(CodeCompletionString::CK_RightBrace); 9481 } 9482 9483 unsigned Priority = CCP_CodePattern; 9484 auto R = Result(Builder.TakeString(), Method, Priority); 9485 if (!M->second.getInt()) 9486 setInBaseClass(R); 9487 Results.AddResult(std::move(R)); 9488 } 9489 9490 // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of 9491 // the properties in this class and its categories. 9492 if (Context.getLangOpts().ObjC) { 9493 SmallVector<ObjCContainerDecl *, 4> Containers; 9494 Containers.push_back(SearchDecl); 9495 9496 VisitedSelectorSet KnownSelectors; 9497 for (KnownMethodsMap::iterator M = KnownMethods.begin(), 9498 MEnd = KnownMethods.end(); 9499 M != MEnd; ++M) 9500 KnownSelectors.insert(M->first); 9501 9502 ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(SearchDecl); 9503 if (!IFace) 9504 if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(SearchDecl)) 9505 IFace = Category->getClassInterface(); 9506 9507 if (IFace) 9508 for (auto *Cat : IFace->visible_categories()) 9509 Containers.push_back(Cat); 9510 9511 if (IsInstanceMethod) { 9512 for (unsigned I = 0, N = Containers.size(); I != N; ++I) 9513 for (auto *P : Containers[I]->instance_properties()) 9514 AddObjCKeyValueCompletions(P, *IsInstanceMethod, ReturnType, Context, 9515 KnownSelectors, Results); 9516 } 9517 } 9518 9519 Results.ExitScope(); 9520 9521 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 9522 Results.data(), Results.size()); 9523 } 9524 9525 void Sema::CodeCompleteObjCMethodDeclSelector( 9526 Scope *S, bool IsInstanceMethod, bool AtParameterName, ParsedType ReturnTy, 9527 ArrayRef<IdentifierInfo *> SelIdents) { 9528 // If we have an external source, load the entire class method 9529 // pool from the AST file. 9530 if (ExternalSource) { 9531 for (uint32_t I = 0, N = ExternalSource->GetNumExternalSelectors(); I != N; 9532 ++I) { 9533 Selector Sel = ExternalSource->GetExternalSelector(I); 9534 if (Sel.isNull() || MethodPool.count(Sel)) 9535 continue; 9536 9537 ReadMethodPool(Sel); 9538 } 9539 } 9540 9541 // Build the set of methods we can see. 9542 typedef CodeCompletionResult Result; 9543 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 9544 CodeCompleter->getCodeCompletionTUInfo(), 9545 CodeCompletionContext::CCC_Other); 9546 9547 if (ReturnTy) 9548 Results.setPreferredType(GetTypeFromParser(ReturnTy).getNonReferenceType()); 9549 9550 Results.EnterNewScope(); 9551 for (GlobalMethodPool::iterator M = MethodPool.begin(), 9552 MEnd = MethodPool.end(); 9553 M != MEnd; ++M) { 9554 for (ObjCMethodList *MethList = IsInstanceMethod ? &M->second.first 9555 : &M->second.second; 9556 MethList && MethList->getMethod(); MethList = MethList->getNext()) { 9557 if (!isAcceptableObjCMethod(MethList->getMethod(), MK_Any, SelIdents)) 9558 continue; 9559 9560 if (AtParameterName) { 9561 // Suggest parameter names we've seen before. 9562 unsigned NumSelIdents = SelIdents.size(); 9563 if (NumSelIdents && 9564 NumSelIdents <= MethList->getMethod()->param_size()) { 9565 ParmVarDecl *Param = 9566 MethList->getMethod()->parameters()[NumSelIdents - 1]; 9567 if (Param->getIdentifier()) { 9568 CodeCompletionBuilder Builder(Results.getAllocator(), 9569 Results.getCodeCompletionTUInfo()); 9570 Builder.AddTypedTextChunk(Builder.getAllocator().CopyString( 9571 Param->getIdentifier()->getName())); 9572 Results.AddResult(Builder.TakeString()); 9573 } 9574 } 9575 9576 continue; 9577 } 9578 9579 Result R(MethList->getMethod(), 9580 Results.getBasePriority(MethList->getMethod()), nullptr); 9581 R.StartParameter = SelIdents.size(); 9582 R.AllParametersAreInformative = false; 9583 R.DeclaringEntity = true; 9584 Results.MaybeAddResult(R, CurContext); 9585 } 9586 } 9587 9588 Results.ExitScope(); 9589 9590 if (!AtParameterName && !SelIdents.empty() && 9591 SelIdents.front()->getName().startswith("init")) { 9592 for (const auto &M : PP.macros()) { 9593 if (M.first->getName() != "NS_DESIGNATED_INITIALIZER") 9594 continue; 9595 Results.EnterNewScope(); 9596 CodeCompletionBuilder Builder(Results.getAllocator(), 9597 Results.getCodeCompletionTUInfo()); 9598 Builder.AddTypedTextChunk( 9599 Builder.getAllocator().CopyString(M.first->getName())); 9600 Results.AddResult(CodeCompletionResult(Builder.TakeString(), CCP_Macro, 9601 CXCursor_MacroDefinition)); 9602 Results.ExitScope(); 9603 } 9604 } 9605 9606 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 9607 Results.data(), Results.size()); 9608 } 9609 9610 void Sema::CodeCompletePreprocessorDirective(bool InConditional) { 9611 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 9612 CodeCompleter->getCodeCompletionTUInfo(), 9613 CodeCompletionContext::CCC_PreprocessorDirective); 9614 Results.EnterNewScope(); 9615 9616 // #if <condition> 9617 CodeCompletionBuilder Builder(Results.getAllocator(), 9618 Results.getCodeCompletionTUInfo()); 9619 Builder.AddTypedTextChunk("if"); 9620 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9621 Builder.AddPlaceholderChunk("condition"); 9622 Results.AddResult(Builder.TakeString()); 9623 9624 // #ifdef <macro> 9625 Builder.AddTypedTextChunk("ifdef"); 9626 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9627 Builder.AddPlaceholderChunk("macro"); 9628 Results.AddResult(Builder.TakeString()); 9629 9630 // #ifndef <macro> 9631 Builder.AddTypedTextChunk("ifndef"); 9632 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9633 Builder.AddPlaceholderChunk("macro"); 9634 Results.AddResult(Builder.TakeString()); 9635 9636 if (InConditional) { 9637 // #elif <condition> 9638 Builder.AddTypedTextChunk("elif"); 9639 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9640 Builder.AddPlaceholderChunk("condition"); 9641 Results.AddResult(Builder.TakeString()); 9642 9643 // #elifdef <macro> 9644 Builder.AddTypedTextChunk("elifdef"); 9645 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9646 Builder.AddPlaceholderChunk("macro"); 9647 Results.AddResult(Builder.TakeString()); 9648 9649 // #elifndef <macro> 9650 Builder.AddTypedTextChunk("elifndef"); 9651 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9652 Builder.AddPlaceholderChunk("macro"); 9653 Results.AddResult(Builder.TakeString()); 9654 9655 // #else 9656 Builder.AddTypedTextChunk("else"); 9657 Results.AddResult(Builder.TakeString()); 9658 9659 // #endif 9660 Builder.AddTypedTextChunk("endif"); 9661 Results.AddResult(Builder.TakeString()); 9662 } 9663 9664 // #include "header" 9665 Builder.AddTypedTextChunk("include"); 9666 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9667 Builder.AddTextChunk("\""); 9668 Builder.AddPlaceholderChunk("header"); 9669 Builder.AddTextChunk("\""); 9670 Results.AddResult(Builder.TakeString()); 9671 9672 // #include <header> 9673 Builder.AddTypedTextChunk("include"); 9674 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9675 Builder.AddTextChunk("<"); 9676 Builder.AddPlaceholderChunk("header"); 9677 Builder.AddTextChunk(">"); 9678 Results.AddResult(Builder.TakeString()); 9679 9680 // #define <macro> 9681 Builder.AddTypedTextChunk("define"); 9682 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9683 Builder.AddPlaceholderChunk("macro"); 9684 Results.AddResult(Builder.TakeString()); 9685 9686 // #define <macro>(<args>) 9687 Builder.AddTypedTextChunk("define"); 9688 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9689 Builder.AddPlaceholderChunk("macro"); 9690 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9691 Builder.AddPlaceholderChunk("args"); 9692 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9693 Results.AddResult(Builder.TakeString()); 9694 9695 // #undef <macro> 9696 Builder.AddTypedTextChunk("undef"); 9697 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9698 Builder.AddPlaceholderChunk("macro"); 9699 Results.AddResult(Builder.TakeString()); 9700 9701 // #line <number> 9702 Builder.AddTypedTextChunk("line"); 9703 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9704 Builder.AddPlaceholderChunk("number"); 9705 Results.AddResult(Builder.TakeString()); 9706 9707 // #line <number> "filename" 9708 Builder.AddTypedTextChunk("line"); 9709 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9710 Builder.AddPlaceholderChunk("number"); 9711 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9712 Builder.AddTextChunk("\""); 9713 Builder.AddPlaceholderChunk("filename"); 9714 Builder.AddTextChunk("\""); 9715 Results.AddResult(Builder.TakeString()); 9716 9717 // #error <message> 9718 Builder.AddTypedTextChunk("error"); 9719 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9720 Builder.AddPlaceholderChunk("message"); 9721 Results.AddResult(Builder.TakeString()); 9722 9723 // #pragma <arguments> 9724 Builder.AddTypedTextChunk("pragma"); 9725 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9726 Builder.AddPlaceholderChunk("arguments"); 9727 Results.AddResult(Builder.TakeString()); 9728 9729 if (getLangOpts().ObjC) { 9730 // #import "header" 9731 Builder.AddTypedTextChunk("import"); 9732 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9733 Builder.AddTextChunk("\""); 9734 Builder.AddPlaceholderChunk("header"); 9735 Builder.AddTextChunk("\""); 9736 Results.AddResult(Builder.TakeString()); 9737 9738 // #import <header> 9739 Builder.AddTypedTextChunk("import"); 9740 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9741 Builder.AddTextChunk("<"); 9742 Builder.AddPlaceholderChunk("header"); 9743 Builder.AddTextChunk(">"); 9744 Results.AddResult(Builder.TakeString()); 9745 } 9746 9747 // #include_next "header" 9748 Builder.AddTypedTextChunk("include_next"); 9749 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9750 Builder.AddTextChunk("\""); 9751 Builder.AddPlaceholderChunk("header"); 9752 Builder.AddTextChunk("\""); 9753 Results.AddResult(Builder.TakeString()); 9754 9755 // #include_next <header> 9756 Builder.AddTypedTextChunk("include_next"); 9757 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9758 Builder.AddTextChunk("<"); 9759 Builder.AddPlaceholderChunk("header"); 9760 Builder.AddTextChunk(">"); 9761 Results.AddResult(Builder.TakeString()); 9762 9763 // #warning <message> 9764 Builder.AddTypedTextChunk("warning"); 9765 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9766 Builder.AddPlaceholderChunk("message"); 9767 Results.AddResult(Builder.TakeString()); 9768 9769 // Note: #ident and #sccs are such crazy anachronisms that we don't provide 9770 // completions for them. And __include_macros is a Clang-internal extension 9771 // that we don't want to encourage anyone to use. 9772 9773 // FIXME: we don't support #assert or #unassert, so don't suggest them. 9774 Results.ExitScope(); 9775 9776 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 9777 Results.data(), Results.size()); 9778 } 9779 9780 void Sema::CodeCompleteInPreprocessorConditionalExclusion(Scope *S) { 9781 CodeCompleteOrdinaryName(S, S->getFnParent() ? Sema::PCC_RecoveryInFunction 9782 : Sema::PCC_Namespace); 9783 } 9784 9785 void Sema::CodeCompletePreprocessorMacroName(bool IsDefinition) { 9786 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 9787 CodeCompleter->getCodeCompletionTUInfo(), 9788 IsDefinition ? CodeCompletionContext::CCC_MacroName 9789 : CodeCompletionContext::CCC_MacroNameUse); 9790 if (!IsDefinition && (!CodeCompleter || CodeCompleter->includeMacros())) { 9791 // Add just the names of macros, not their arguments. 9792 CodeCompletionBuilder Builder(Results.getAllocator(), 9793 Results.getCodeCompletionTUInfo()); 9794 Results.EnterNewScope(); 9795 for (Preprocessor::macro_iterator M = PP.macro_begin(), 9796 MEnd = PP.macro_end(); 9797 M != MEnd; ++M) { 9798 Builder.AddTypedTextChunk( 9799 Builder.getAllocator().CopyString(M->first->getName())); 9800 Results.AddResult(CodeCompletionResult( 9801 Builder.TakeString(), CCP_CodePattern, CXCursor_MacroDefinition)); 9802 } 9803 Results.ExitScope(); 9804 } else if (IsDefinition) { 9805 // FIXME: Can we detect when the user just wrote an include guard above? 9806 } 9807 9808 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 9809 Results.data(), Results.size()); 9810 } 9811 9812 void Sema::CodeCompletePreprocessorExpression() { 9813 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 9814 CodeCompleter->getCodeCompletionTUInfo(), 9815 CodeCompletionContext::CCC_PreprocessorExpression); 9816 9817 if (!CodeCompleter || CodeCompleter->includeMacros()) 9818 AddMacroResults(PP, Results, 9819 !CodeCompleter || CodeCompleter->loadExternal(), true); 9820 9821 // defined (<macro>) 9822 Results.EnterNewScope(); 9823 CodeCompletionBuilder Builder(Results.getAllocator(), 9824 Results.getCodeCompletionTUInfo()); 9825 Builder.AddTypedTextChunk("defined"); 9826 Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace); 9827 Builder.AddChunk(CodeCompletionString::CK_LeftParen); 9828 Builder.AddPlaceholderChunk("macro"); 9829 Builder.AddChunk(CodeCompletionString::CK_RightParen); 9830 Results.AddResult(Builder.TakeString()); 9831 Results.ExitScope(); 9832 9833 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 9834 Results.data(), Results.size()); 9835 } 9836 9837 void Sema::CodeCompletePreprocessorMacroArgument(Scope *S, 9838 IdentifierInfo *Macro, 9839 MacroInfo *MacroInfo, 9840 unsigned Argument) { 9841 // FIXME: In the future, we could provide "overload" results, much like we 9842 // do for function calls. 9843 9844 // Now just ignore this. There will be another code-completion callback 9845 // for the expanded tokens. 9846 } 9847 9848 // This handles completion inside an #include filename, e.g. #include <foo/ba 9849 // We look for the directory "foo" under each directory on the include path, 9850 // list its files, and reassemble the appropriate #include. 9851 void Sema::CodeCompleteIncludedFile(llvm::StringRef Dir, bool Angled) { 9852 // RelDir should use /, but unescaped \ is possible on windows! 9853 // Our completions will normalize to / for simplicity, this case is rare. 9854 std::string RelDir = llvm::sys::path::convert_to_slash(Dir); 9855 // We need the native slashes for the actual file system interactions. 9856 SmallString<128> NativeRelDir = StringRef(RelDir); 9857 llvm::sys::path::native(NativeRelDir); 9858 llvm::vfs::FileSystem &FS = 9859 getSourceManager().getFileManager().getVirtualFileSystem(); 9860 9861 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 9862 CodeCompleter->getCodeCompletionTUInfo(), 9863 CodeCompletionContext::CCC_IncludedFile); 9864 llvm::DenseSet<StringRef> SeenResults; // To deduplicate results. 9865 9866 // Helper: adds one file or directory completion result. 9867 auto AddCompletion = [&](StringRef Filename, bool IsDirectory) { 9868 SmallString<64> TypedChunk = Filename; 9869 // Directory completion is up to the slash, e.g. <sys/ 9870 TypedChunk.push_back(IsDirectory ? '/' : Angled ? '>' : '"'); 9871 auto R = SeenResults.insert(TypedChunk); 9872 if (R.second) { // New completion 9873 const char *InternedTyped = Results.getAllocator().CopyString(TypedChunk); 9874 *R.first = InternedTyped; // Avoid dangling StringRef. 9875 CodeCompletionBuilder Builder(CodeCompleter->getAllocator(), 9876 CodeCompleter->getCodeCompletionTUInfo()); 9877 Builder.AddTypedTextChunk(InternedTyped); 9878 // The result is a "Pattern", which is pretty opaque. 9879 // We may want to include the real filename to allow smart ranking. 9880 Results.AddResult(CodeCompletionResult(Builder.TakeString())); 9881 } 9882 }; 9883 9884 // Helper: scans IncludeDir for nice files, and adds results for each. 9885 auto AddFilesFromIncludeDir = [&](StringRef IncludeDir, 9886 bool IsSystem, 9887 DirectoryLookup::LookupType_t LookupType) { 9888 llvm::SmallString<128> Dir = IncludeDir; 9889 if (!NativeRelDir.empty()) { 9890 if (LookupType == DirectoryLookup::LT_Framework) { 9891 // For a framework dir, #include <Foo/Bar/> actually maps to 9892 // a path of Foo.framework/Headers/Bar/. 9893 auto Begin = llvm::sys::path::begin(NativeRelDir); 9894 auto End = llvm::sys::path::end(NativeRelDir); 9895 9896 llvm::sys::path::append(Dir, *Begin + ".framework", "Headers"); 9897 llvm::sys::path::append(Dir, ++Begin, End); 9898 } else { 9899 llvm::sys::path::append(Dir, NativeRelDir); 9900 } 9901 } 9902 9903 const StringRef &Dirname = llvm::sys::path::filename(Dir); 9904 const bool isQt = Dirname.startswith("Qt") || Dirname == "ActiveQt"; 9905 const bool ExtensionlessHeaders = 9906 IsSystem || isQt || Dir.endswith(".framework/Headers"); 9907 std::error_code EC; 9908 unsigned Count = 0; 9909 for (auto It = FS.dir_begin(Dir, EC); 9910 !EC && It != llvm::vfs::directory_iterator(); It.increment(EC)) { 9911 if (++Count == 2500) // If we happen to hit a huge directory, 9912 break; // bail out early so we're not too slow. 9913 StringRef Filename = llvm::sys::path::filename(It->path()); 9914 9915 // To know whether a symlink should be treated as file or a directory, we 9916 // have to stat it. This should be cheap enough as there shouldn't be many 9917 // symlinks. 9918 llvm::sys::fs::file_type Type = It->type(); 9919 if (Type == llvm::sys::fs::file_type::symlink_file) { 9920 if (auto FileStatus = FS.status(It->path())) 9921 Type = FileStatus->getType(); 9922 } 9923 switch (Type) { 9924 case llvm::sys::fs::file_type::directory_file: 9925 // All entries in a framework directory must have a ".framework" suffix, 9926 // but the suffix does not appear in the source code's include/import. 9927 if (LookupType == DirectoryLookup::LT_Framework && 9928 NativeRelDir.empty() && !Filename.consume_back(".framework")) 9929 break; 9930 9931 AddCompletion(Filename, /*IsDirectory=*/true); 9932 break; 9933 case llvm::sys::fs::file_type::regular_file: { 9934 // Only files that really look like headers. (Except in special dirs). 9935 // Header extensions from Types.def, which we can't depend on here. 9936 const bool IsHeader = Filename.endswith_insensitive(".h") || 9937 Filename.endswith_insensitive(".hh") || 9938 Filename.endswith_insensitive(".hpp") || 9939 Filename.endswith_insensitive(".inc") || 9940 (ExtensionlessHeaders && !Filename.contains('.')); 9941 if (!IsHeader) 9942 break; 9943 AddCompletion(Filename, /*IsDirectory=*/false); 9944 break; 9945 } 9946 default: 9947 break; 9948 } 9949 } 9950 }; 9951 9952 // Helper: adds results relative to IncludeDir, if possible. 9953 auto AddFilesFromDirLookup = [&](const DirectoryLookup &IncludeDir, 9954 bool IsSystem) { 9955 switch (IncludeDir.getLookupType()) { 9956 case DirectoryLookup::LT_HeaderMap: 9957 // header maps are not (currently) enumerable. 9958 break; 9959 case DirectoryLookup::LT_NormalDir: 9960 AddFilesFromIncludeDir(IncludeDir.getDir()->getName(), IsSystem, 9961 DirectoryLookup::LT_NormalDir); 9962 break; 9963 case DirectoryLookup::LT_Framework: 9964 AddFilesFromIncludeDir(IncludeDir.getFrameworkDir()->getName(), IsSystem, 9965 DirectoryLookup::LT_Framework); 9966 break; 9967 } 9968 }; 9969 9970 // Finally with all our helpers, we can scan the include path. 9971 // Do this in standard order so deduplication keeps the right file. 9972 // (In case we decide to add more details to the results later). 9973 const auto &S = PP.getHeaderSearchInfo(); 9974 using llvm::make_range; 9975 if (!Angled) { 9976 // The current directory is on the include path for "quoted" includes. 9977 auto *CurFile = PP.getCurrentFileLexer()->getFileEntry(); 9978 if (CurFile && CurFile->getDir()) 9979 AddFilesFromIncludeDir(CurFile->getDir()->getName(), false, 9980 DirectoryLookup::LT_NormalDir); 9981 for (const auto &D : make_range(S.quoted_dir_begin(), S.quoted_dir_end())) 9982 AddFilesFromDirLookup(D, false); 9983 } 9984 for (const auto &D : make_range(S.angled_dir_begin(), S.angled_dir_end())) 9985 AddFilesFromDirLookup(D, false); 9986 for (const auto &D : make_range(S.system_dir_begin(), S.system_dir_end())) 9987 AddFilesFromDirLookup(D, true); 9988 9989 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 9990 Results.data(), Results.size()); 9991 } 9992 9993 void Sema::CodeCompleteNaturalLanguage() { 9994 HandleCodeCompleteResults(this, CodeCompleter, 9995 CodeCompletionContext::CCC_NaturalLanguage, nullptr, 9996 0); 9997 } 9998 9999 void Sema::CodeCompleteAvailabilityPlatformName() { 10000 ResultBuilder Results(*this, CodeCompleter->getAllocator(), 10001 CodeCompleter->getCodeCompletionTUInfo(), 10002 CodeCompletionContext::CCC_Other); 10003 Results.EnterNewScope(); 10004 static const char *Platforms[] = {"macOS", "iOS", "watchOS", "tvOS"}; 10005 for (const char *Platform : llvm::makeArrayRef(Platforms)) { 10006 Results.AddResult(CodeCompletionResult(Platform)); 10007 Results.AddResult(CodeCompletionResult(Results.getAllocator().CopyString( 10008 Twine(Platform) + "ApplicationExtension"))); 10009 } 10010 Results.ExitScope(); 10011 HandleCodeCompleteResults(this, CodeCompleter, Results.getCompletionContext(), 10012 Results.data(), Results.size()); 10013 } 10014 10015 void Sema::GatherGlobalCodeCompletions( 10016 CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo, 10017 SmallVectorImpl<CodeCompletionResult> &Results) { 10018 ResultBuilder Builder(*this, Allocator, CCTUInfo, 10019 CodeCompletionContext::CCC_Recovery); 10020 if (!CodeCompleter || CodeCompleter->includeGlobals()) { 10021 CodeCompletionDeclConsumer Consumer(Builder, 10022 Context.getTranslationUnitDecl()); 10023 LookupVisibleDecls(Context.getTranslationUnitDecl(), LookupAnyName, 10024 Consumer, 10025 !CodeCompleter || CodeCompleter->loadExternal()); 10026 } 10027 10028 if (!CodeCompleter || CodeCompleter->includeMacros()) 10029 AddMacroResults(PP, Builder, 10030 !CodeCompleter || CodeCompleter->loadExternal(), true); 10031 10032 Results.clear(); 10033 Results.insert(Results.end(), Builder.data(), 10034 Builder.data() + Builder.size()); 10035 } 10036