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