1 //===- CodeCompleteConsumer.cpp - Code Completion Interface ---------------===// 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 implements the CodeCompleteConsumer class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/Sema/CodeCompleteConsumer.h" 14 #include "clang-c/Index.h" 15 #include "clang/AST/Decl.h" 16 #include "clang/AST/DeclBase.h" 17 #include "clang/AST/DeclObjC.h" 18 #include "clang/AST/DeclTemplate.h" 19 #include "clang/AST/DeclarationName.h" 20 #include "clang/AST/Type.h" 21 #include "clang/Basic/IdentifierTable.h" 22 #include "clang/Lex/Preprocessor.h" 23 #include "clang/Sema/Sema.h" 24 #include "llvm/ADT/SmallString.h" 25 #include "llvm/ADT/SmallVector.h" 26 #include "llvm/ADT/StringExtras.h" 27 #include "llvm/ADT/StringRef.h" 28 #include "llvm/ADT/Twine.h" 29 #include "llvm/Support/Casting.h" 30 #include "llvm/Support/Compiler.h" 31 #include "llvm/Support/ErrorHandling.h" 32 #include "llvm/Support/FormatVariadic.h" 33 #include "llvm/Support/raw_ostream.h" 34 #include <algorithm> 35 #include <cassert> 36 #include <cstdint> 37 #include <string> 38 39 using namespace clang; 40 41 //===----------------------------------------------------------------------===// 42 // Code completion context implementation 43 //===----------------------------------------------------------------------===// 44 45 bool CodeCompletionContext::wantConstructorResults() const { 46 switch (CCKind) { 47 case CCC_Recovery: 48 case CCC_Statement: 49 case CCC_Expression: 50 case CCC_ObjCMessageReceiver: 51 case CCC_ParenthesizedExpression: 52 case CCC_Symbol: 53 case CCC_SymbolOrNewName: 54 case CCC_TopLevelOrExpression: 55 return true; 56 57 case CCC_TopLevel: 58 case CCC_ObjCInterface: 59 case CCC_ObjCImplementation: 60 case CCC_ObjCIvarList: 61 case CCC_ClassStructUnion: 62 case CCC_DotMemberAccess: 63 case CCC_ArrowMemberAccess: 64 case CCC_ObjCPropertyAccess: 65 case CCC_EnumTag: 66 case CCC_UnionTag: 67 case CCC_ClassOrStructTag: 68 case CCC_ObjCProtocolName: 69 case CCC_Namespace: 70 case CCC_Type: 71 case CCC_NewName: 72 case CCC_MacroName: 73 case CCC_MacroNameUse: 74 case CCC_PreprocessorExpression: 75 case CCC_PreprocessorDirective: 76 case CCC_NaturalLanguage: 77 case CCC_SelectorName: 78 case CCC_TypeQualifiers: 79 case CCC_Other: 80 case CCC_OtherWithMacros: 81 case CCC_ObjCInstanceMessage: 82 case CCC_ObjCClassMessage: 83 case CCC_ObjCInterfaceName: 84 case CCC_ObjCCategoryName: 85 case CCC_IncludedFile: 86 case CCC_Attribute: 87 case CCC_ObjCClassForwardDecl: 88 return false; 89 } 90 91 llvm_unreachable("Invalid CodeCompletionContext::Kind!"); 92 } 93 94 StringRef clang::getCompletionKindString(CodeCompletionContext::Kind Kind) { 95 using CCKind = CodeCompletionContext::Kind; 96 switch (Kind) { 97 case CCKind::CCC_Other: 98 return "Other"; 99 case CCKind::CCC_OtherWithMacros: 100 return "OtherWithMacros"; 101 case CCKind::CCC_TopLevel: 102 return "TopLevel"; 103 case CCKind::CCC_ObjCInterface: 104 return "ObjCInterface"; 105 case CCKind::CCC_ObjCImplementation: 106 return "ObjCImplementation"; 107 case CCKind::CCC_ObjCIvarList: 108 return "ObjCIvarList"; 109 case CCKind::CCC_ClassStructUnion: 110 return "ClassStructUnion"; 111 case CCKind::CCC_Statement: 112 return "Statement"; 113 case CCKind::CCC_Expression: 114 return "Expression"; 115 case CCKind::CCC_ObjCMessageReceiver: 116 return "ObjCMessageReceiver"; 117 case CCKind::CCC_DotMemberAccess: 118 return "DotMemberAccess"; 119 case CCKind::CCC_ArrowMemberAccess: 120 return "ArrowMemberAccess"; 121 case CCKind::CCC_ObjCPropertyAccess: 122 return "ObjCPropertyAccess"; 123 case CCKind::CCC_EnumTag: 124 return "EnumTag"; 125 case CCKind::CCC_UnionTag: 126 return "UnionTag"; 127 case CCKind::CCC_ClassOrStructTag: 128 return "ClassOrStructTag"; 129 case CCKind::CCC_ObjCProtocolName: 130 return "ObjCProtocolName"; 131 case CCKind::CCC_Namespace: 132 return "Namespace"; 133 case CCKind::CCC_Type: 134 return "Type"; 135 case CCKind::CCC_NewName: 136 return "NewName"; 137 case CCKind::CCC_Symbol: 138 return "Symbol"; 139 case CCKind::CCC_SymbolOrNewName: 140 return "SymbolOrNewName"; 141 case CCKind::CCC_MacroName: 142 return "MacroName"; 143 case CCKind::CCC_MacroNameUse: 144 return "MacroNameUse"; 145 case CCKind::CCC_PreprocessorExpression: 146 return "PreprocessorExpression"; 147 case CCKind::CCC_PreprocessorDirective: 148 return "PreprocessorDirective"; 149 case CCKind::CCC_NaturalLanguage: 150 return "NaturalLanguage"; 151 case CCKind::CCC_SelectorName: 152 return "SelectorName"; 153 case CCKind::CCC_TypeQualifiers: 154 return "TypeQualifiers"; 155 case CCKind::CCC_ParenthesizedExpression: 156 return "ParenthesizedExpression"; 157 case CCKind::CCC_ObjCInstanceMessage: 158 return "ObjCInstanceMessage"; 159 case CCKind::CCC_ObjCClassMessage: 160 return "ObjCClassMessage"; 161 case CCKind::CCC_ObjCInterfaceName: 162 return "ObjCInterfaceName"; 163 case CCKind::CCC_ObjCCategoryName: 164 return "ObjCCategoryName"; 165 case CCKind::CCC_IncludedFile: 166 return "IncludedFile"; 167 case CCKind::CCC_Attribute: 168 return "Attribute"; 169 case CCKind::CCC_Recovery: 170 return "Recovery"; 171 case CCKind::CCC_ObjCClassForwardDecl: 172 return "ObjCClassForwardDecl"; 173 case CCKind::CCC_TopLevelOrExpression: 174 return "ReplTopLevel"; 175 } 176 llvm_unreachable("Invalid CodeCompletionContext::Kind!"); 177 } 178 179 //===----------------------------------------------------------------------===// 180 // Code completion string implementation 181 //===----------------------------------------------------------------------===// 182 183 CodeCompletionString::Chunk::Chunk(ChunkKind Kind, const char *Text) 184 : Kind(Kind), Text("") { 185 switch (Kind) { 186 case CK_TypedText: 187 case CK_Text: 188 case CK_Placeholder: 189 case CK_Informative: 190 case CK_ResultType: 191 case CK_CurrentParameter: 192 this->Text = Text; 193 break; 194 195 case CK_Optional: 196 llvm_unreachable("Optional strings cannot be created from text"); 197 198 case CK_LeftParen: 199 this->Text = "("; 200 break; 201 202 case CK_RightParen: 203 this->Text = ")"; 204 break; 205 206 case CK_LeftBracket: 207 this->Text = "["; 208 break; 209 210 case CK_RightBracket: 211 this->Text = "]"; 212 break; 213 214 case CK_LeftBrace: 215 this->Text = "{"; 216 break; 217 218 case CK_RightBrace: 219 this->Text = "}"; 220 break; 221 222 case CK_LeftAngle: 223 this->Text = "<"; 224 break; 225 226 case CK_RightAngle: 227 this->Text = ">"; 228 break; 229 230 case CK_Comma: 231 this->Text = ", "; 232 break; 233 234 case CK_Colon: 235 this->Text = ":"; 236 break; 237 238 case CK_SemiColon: 239 this->Text = ";"; 240 break; 241 242 case CK_Equal: 243 this->Text = " = "; 244 break; 245 246 case CK_HorizontalSpace: 247 this->Text = " "; 248 break; 249 250 case CK_VerticalSpace: 251 this->Text = "\n"; 252 break; 253 } 254 } 255 256 CodeCompletionString::Chunk 257 CodeCompletionString::Chunk::CreateText(const char *Text) { 258 return Chunk(CK_Text, Text); 259 } 260 261 CodeCompletionString::Chunk 262 CodeCompletionString::Chunk::CreateOptional(CodeCompletionString *Optional) { 263 Chunk Result; 264 Result.Kind = CK_Optional; 265 Result.Optional = Optional; 266 return Result; 267 } 268 269 CodeCompletionString::Chunk 270 CodeCompletionString::Chunk::CreatePlaceholder(const char *Placeholder) { 271 return Chunk(CK_Placeholder, Placeholder); 272 } 273 274 CodeCompletionString::Chunk 275 CodeCompletionString::Chunk::CreateInformative(const char *Informative) { 276 return Chunk(CK_Informative, Informative); 277 } 278 279 CodeCompletionString::Chunk 280 CodeCompletionString::Chunk::CreateResultType(const char *ResultType) { 281 return Chunk(CK_ResultType, ResultType); 282 } 283 284 CodeCompletionString::Chunk CodeCompletionString::Chunk::CreateCurrentParameter( 285 const char *CurrentParameter) { 286 return Chunk(CK_CurrentParameter, CurrentParameter); 287 } 288 289 CodeCompletionString::CodeCompletionString( 290 const Chunk *Chunks, unsigned NumChunks, unsigned Priority, 291 CXAvailabilityKind Availability, const char **Annotations, 292 unsigned NumAnnotations, StringRef ParentName, const char *BriefComment) 293 : NumChunks(NumChunks), NumAnnotations(NumAnnotations), Priority(Priority), 294 Availability(Availability), ParentName(ParentName), 295 BriefComment(BriefComment) { 296 assert(NumChunks <= 0xffff); 297 assert(NumAnnotations <= 0xffff); 298 299 Chunk *StoredChunks = reinterpret_cast<Chunk *>(this + 1); 300 for (unsigned I = 0; I != NumChunks; ++I) 301 StoredChunks[I] = Chunks[I]; 302 303 const char **StoredAnnotations = 304 reinterpret_cast<const char **>(StoredChunks + NumChunks); 305 for (unsigned I = 0; I != NumAnnotations; ++I) 306 StoredAnnotations[I] = Annotations[I]; 307 } 308 309 unsigned CodeCompletionString::getAnnotationCount() const { 310 return NumAnnotations; 311 } 312 313 const char *CodeCompletionString::getAnnotation(unsigned AnnotationNr) const { 314 if (AnnotationNr < NumAnnotations) 315 return reinterpret_cast<const char *const *>(end())[AnnotationNr]; 316 else 317 return nullptr; 318 } 319 320 std::string CodeCompletionString::getAsString() const { 321 std::string Result; 322 llvm::raw_string_ostream OS(Result); 323 324 for (const Chunk &C : *this) { 325 switch (C.Kind) { 326 case CK_Optional: 327 OS << "{#" << C.Optional->getAsString() << "#}"; 328 break; 329 case CK_Placeholder: 330 OS << "<#" << C.Text << "#>"; 331 break; 332 case CK_Informative: 333 case CK_ResultType: 334 OS << "[#" << C.Text << "#]"; 335 break; 336 case CK_CurrentParameter: 337 OS << "<#" << C.Text << "#>"; 338 break; 339 default: 340 OS << C.Text; 341 break; 342 } 343 } 344 return Result; 345 } 346 347 const char *CodeCompletionString::getTypedText() const { 348 for (const Chunk &C : *this) 349 if (C.Kind == CK_TypedText) 350 return C.Text; 351 352 return nullptr; 353 } 354 355 std::string CodeCompletionString::getAllTypedText() const { 356 std::string Res; 357 for (const Chunk &C : *this) 358 if (C.Kind == CK_TypedText) 359 Res += C.Text; 360 361 return Res; 362 } 363 364 const char *CodeCompletionAllocator::CopyString(const Twine &String) { 365 SmallString<128> Data; 366 StringRef Ref = String.toStringRef(Data); 367 // FIXME: It would be more efficient to teach Twine to tell us its size and 368 // then add a routine there to fill in an allocated char* with the contents 369 // of the string. 370 char *Mem = (char *)Allocate(Ref.size() + 1, 1); 371 std::copy(Ref.begin(), Ref.end(), Mem); 372 Mem[Ref.size()] = 0; 373 return Mem; 374 } 375 376 StringRef CodeCompletionTUInfo::getParentName(const DeclContext *DC) { 377 if (!isa<NamedDecl>(DC)) 378 return {}; 379 380 // Check whether we've already cached the parent name. 381 StringRef &CachedParentName = ParentNames[DC]; 382 if (!CachedParentName.empty()) 383 return CachedParentName; 384 385 // If we already processed this DeclContext and assigned empty to it, the 386 // data pointer will be non-null. 387 if (CachedParentName.data() != nullptr) 388 return {}; 389 390 // Find the interesting names. 391 SmallVector<const DeclContext *, 2> Contexts; 392 while (DC && !DC->isFunctionOrMethod()) { 393 if (const auto *ND = dyn_cast<NamedDecl>(DC)) { 394 if (ND->getIdentifier()) 395 Contexts.push_back(DC); 396 } 397 398 DC = DC->getParent(); 399 } 400 401 { 402 SmallString<128> S; 403 llvm::raw_svector_ostream OS(S); 404 bool First = true; 405 for (const DeclContext *CurDC : llvm::reverse(Contexts)) { 406 if (First) 407 First = false; 408 else { 409 OS << "::"; 410 } 411 412 if (const auto *CatImpl = dyn_cast<ObjCCategoryImplDecl>(CurDC)) 413 CurDC = CatImpl->getCategoryDecl(); 414 415 if (const auto *Cat = dyn_cast<ObjCCategoryDecl>(CurDC)) { 416 const ObjCInterfaceDecl *Interface = Cat->getClassInterface(); 417 if (!Interface) { 418 // Assign an empty StringRef but with non-null data to distinguish 419 // between empty because we didn't process the DeclContext yet. 420 CachedParentName = StringRef((const char *)(uintptr_t)~0U, 0); 421 return {}; 422 } 423 424 OS << Interface->getName() << '(' << Cat->getName() << ')'; 425 } else { 426 OS << cast<NamedDecl>(CurDC)->getName(); 427 } 428 } 429 430 CachedParentName = AllocatorRef->CopyString(OS.str()); 431 } 432 433 return CachedParentName; 434 } 435 436 CodeCompletionString *CodeCompletionBuilder::TakeString() { 437 void *Mem = getAllocator().Allocate( 438 sizeof(CodeCompletionString) + sizeof(Chunk) * Chunks.size() + 439 sizeof(const char *) * Annotations.size(), 440 alignof(CodeCompletionString)); 441 CodeCompletionString *Result = new (Mem) CodeCompletionString( 442 Chunks.data(), Chunks.size(), Priority, Availability, Annotations.data(), 443 Annotations.size(), ParentName, BriefComment); 444 Chunks.clear(); 445 return Result; 446 } 447 448 void CodeCompletionBuilder::AddTypedTextChunk(const char *Text) { 449 Chunks.push_back(Chunk(CodeCompletionString::CK_TypedText, Text)); 450 } 451 452 void CodeCompletionBuilder::AddTextChunk(const char *Text) { 453 Chunks.push_back(Chunk::CreateText(Text)); 454 } 455 456 void CodeCompletionBuilder::AddOptionalChunk(CodeCompletionString *Optional) { 457 Chunks.push_back(Chunk::CreateOptional(Optional)); 458 } 459 460 void CodeCompletionBuilder::AddPlaceholderChunk(const char *Placeholder) { 461 Chunks.push_back(Chunk::CreatePlaceholder(Placeholder)); 462 } 463 464 void CodeCompletionBuilder::AddInformativeChunk(const char *Text) { 465 Chunks.push_back(Chunk::CreateInformative(Text)); 466 } 467 468 void CodeCompletionBuilder::AddResultTypeChunk(const char *ResultType) { 469 Chunks.push_back(Chunk::CreateResultType(ResultType)); 470 } 471 472 void CodeCompletionBuilder::AddCurrentParameterChunk( 473 const char *CurrentParameter) { 474 Chunks.push_back(Chunk::CreateCurrentParameter(CurrentParameter)); 475 } 476 477 void CodeCompletionBuilder::AddChunk(CodeCompletionString::ChunkKind CK, 478 const char *Text) { 479 Chunks.push_back(Chunk(CK, Text)); 480 } 481 482 void CodeCompletionBuilder::addParentContext(const DeclContext *DC) { 483 if (DC->isTranslationUnit()) 484 return; 485 486 if (DC->isFunctionOrMethod()) 487 return; 488 489 if (!isa<NamedDecl>(DC)) 490 return; 491 492 ParentName = getCodeCompletionTUInfo().getParentName(DC); 493 } 494 495 void CodeCompletionBuilder::addBriefComment(StringRef Comment) { 496 BriefComment = Allocator.CopyString(Comment); 497 } 498 499 //===----------------------------------------------------------------------===// 500 // Code completion overload candidate implementation 501 //===----------------------------------------------------------------------===// 502 FunctionDecl *CodeCompleteConsumer::OverloadCandidate::getFunction() const { 503 if (getKind() == CK_Function) 504 return Function; 505 else if (getKind() == CK_FunctionTemplate) 506 return FunctionTemplate->getTemplatedDecl(); 507 else 508 return nullptr; 509 } 510 511 const FunctionType * 512 CodeCompleteConsumer::OverloadCandidate::getFunctionType() const { 513 switch (Kind) { 514 case CK_Function: 515 return Function->getType()->getAs<FunctionType>(); 516 517 case CK_FunctionTemplate: 518 return FunctionTemplate->getTemplatedDecl() 519 ->getType() 520 ->getAs<FunctionType>(); 521 522 case CK_FunctionType: 523 return Type; 524 case CK_FunctionProtoTypeLoc: 525 return ProtoTypeLoc.getTypePtr(); 526 case CK_Template: 527 case CK_Aggregate: 528 return nullptr; 529 } 530 531 llvm_unreachable("Invalid CandidateKind!"); 532 } 533 534 const FunctionProtoTypeLoc 535 CodeCompleteConsumer::OverloadCandidate::getFunctionProtoTypeLoc() const { 536 if (Kind == CK_FunctionProtoTypeLoc) 537 return ProtoTypeLoc; 538 return FunctionProtoTypeLoc(); 539 } 540 541 unsigned CodeCompleteConsumer::OverloadCandidate::getNumParams() const { 542 if (Kind == CK_Template) 543 return Template->getTemplateParameters()->size(); 544 545 if (Kind == CK_Aggregate) { 546 unsigned Count = 547 std::distance(AggregateType->field_begin(), AggregateType->field_end()); 548 if (const auto *CRD = dyn_cast<CXXRecordDecl>(AggregateType)) 549 Count += CRD->getNumBases(); 550 return Count; 551 } 552 553 if (const auto *FT = getFunctionType()) 554 if (const auto *FPT = dyn_cast<FunctionProtoType>(FT)) 555 return FPT->getNumParams(); 556 557 return 0; 558 } 559 560 QualType 561 CodeCompleteConsumer::OverloadCandidate::getParamType(unsigned N) const { 562 if (Kind == CK_Aggregate) { 563 if (const auto *CRD = dyn_cast<CXXRecordDecl>(AggregateType)) { 564 if (N < CRD->getNumBases()) 565 return std::next(CRD->bases_begin(), N)->getType(); 566 N -= CRD->getNumBases(); 567 } 568 for (const auto *Field : AggregateType->fields()) 569 if (N-- == 0) 570 return Field->getType(); 571 return QualType(); 572 } 573 574 if (Kind == CK_Template) { 575 TemplateParameterList *TPL = getTemplate()->getTemplateParameters(); 576 if (N < TPL->size()) 577 if (const auto *D = dyn_cast<NonTypeTemplateParmDecl>(TPL->getParam(N))) 578 return D->getType(); 579 return QualType(); 580 } 581 582 if (const auto *FT = getFunctionType()) 583 if (const auto *FPT = dyn_cast<FunctionProtoType>(FT)) 584 if (N < FPT->getNumParams()) 585 return FPT->getParamType(N); 586 return QualType(); 587 } 588 589 const NamedDecl * 590 CodeCompleteConsumer::OverloadCandidate::getParamDecl(unsigned N) const { 591 if (Kind == CK_Aggregate) { 592 if (const auto *CRD = dyn_cast<CXXRecordDecl>(AggregateType)) { 593 if (N < CRD->getNumBases()) 594 return std::next(CRD->bases_begin(), N)->getType()->getAsTagDecl(); 595 N -= CRD->getNumBases(); 596 } 597 for (const auto *Field : AggregateType->fields()) 598 if (N-- == 0) 599 return Field; 600 return nullptr; 601 } 602 603 if (Kind == CK_Template) { 604 TemplateParameterList *TPL = getTemplate()->getTemplateParameters(); 605 if (N < TPL->size()) 606 return TPL->getParam(N); 607 return nullptr; 608 } 609 610 // Note that if we only have a FunctionProtoType, we don't have param decls. 611 if (const auto *FD = getFunction()) { 612 if (N < FD->param_size()) 613 return FD->getParamDecl(N); 614 } else if (Kind == CK_FunctionProtoTypeLoc) { 615 if (N < ProtoTypeLoc.getNumParams()) { 616 return ProtoTypeLoc.getParam(N); 617 } 618 } 619 620 return nullptr; 621 } 622 623 //===----------------------------------------------------------------------===// 624 // Code completion consumer implementation 625 //===----------------------------------------------------------------------===// 626 627 CodeCompleteConsumer::~CodeCompleteConsumer() = default; 628 629 bool PrintingCodeCompleteConsumer::isResultFilteredOut( 630 StringRef Filter, CodeCompletionResult Result) { 631 switch (Result.Kind) { 632 case CodeCompletionResult::RK_Declaration: 633 return !(Result.Declaration->getIdentifier() && 634 Result.Declaration->getIdentifier()->getName().startswith(Filter)); 635 case CodeCompletionResult::RK_Keyword: 636 return !StringRef(Result.Keyword).startswith(Filter); 637 case CodeCompletionResult::RK_Macro: 638 return !Result.Macro->getName().startswith(Filter); 639 case CodeCompletionResult::RK_Pattern: 640 return !(Result.Pattern->getTypedText() && 641 StringRef(Result.Pattern->getTypedText()).startswith(Filter)); 642 } 643 llvm_unreachable("Unknown code completion result Kind."); 644 } 645 646 void PrintingCodeCompleteConsumer::ProcessCodeCompleteResults( 647 Sema &SemaRef, CodeCompletionContext Context, CodeCompletionResult *Results, 648 unsigned NumResults) { 649 std::stable_sort(Results, Results + NumResults); 650 651 if (!Context.getPreferredType().isNull()) 652 OS << "PREFERRED-TYPE: " << Context.getPreferredType() << '\n'; 653 654 StringRef Filter = SemaRef.getPreprocessor().getCodeCompletionFilter(); 655 // Print the completions. 656 for (unsigned I = 0; I != NumResults; ++I) { 657 if (!Filter.empty() && isResultFilteredOut(Filter, Results[I])) 658 continue; 659 OS << "COMPLETION: "; 660 switch (Results[I].Kind) { 661 case CodeCompletionResult::RK_Declaration: 662 OS << *Results[I].Declaration; 663 { 664 std::vector<std::string> Tags; 665 if (Results[I].Hidden) 666 Tags.push_back("Hidden"); 667 if (Results[I].InBaseClass) 668 Tags.push_back("InBase"); 669 if (Results[I].Availability == 670 CXAvailabilityKind::CXAvailability_NotAccessible) 671 Tags.push_back("Inaccessible"); 672 if (!Tags.empty()) 673 OS << " (" << llvm::join(Tags, ",") << ")"; 674 } 675 if (CodeCompletionString *CCS = Results[I].CreateCodeCompletionString( 676 SemaRef, Context, getAllocator(), CCTUInfo, 677 includeBriefComments())) { 678 OS << " : " << CCS->getAsString(); 679 if (const char *BriefComment = CCS->getBriefComment()) 680 OS << " : " << BriefComment; 681 } 682 break; 683 684 case CodeCompletionResult::RK_Keyword: 685 OS << Results[I].Keyword; 686 break; 687 688 case CodeCompletionResult::RK_Macro: 689 OS << Results[I].Macro->getName(); 690 if (CodeCompletionString *CCS = Results[I].CreateCodeCompletionString( 691 SemaRef, Context, getAllocator(), CCTUInfo, 692 includeBriefComments())) { 693 OS << " : " << CCS->getAsString(); 694 } 695 break; 696 697 case CodeCompletionResult::RK_Pattern: 698 OS << "Pattern : " << Results[I].Pattern->getAsString(); 699 break; 700 } 701 for (const FixItHint &FixIt : Results[I].FixIts) { 702 const SourceLocation BLoc = FixIt.RemoveRange.getBegin(); 703 const SourceLocation ELoc = FixIt.RemoveRange.getEnd(); 704 705 SourceManager &SM = SemaRef.SourceMgr; 706 std::pair<FileID, unsigned> BInfo = SM.getDecomposedLoc(BLoc); 707 std::pair<FileID, unsigned> EInfo = SM.getDecomposedLoc(ELoc); 708 // Adjust for token ranges. 709 if (FixIt.RemoveRange.isTokenRange()) 710 EInfo.second += Lexer::MeasureTokenLength(ELoc, SM, SemaRef.LangOpts); 711 712 OS << " (requires fix-it:" 713 << " {" << SM.getLineNumber(BInfo.first, BInfo.second) << ':' 714 << SM.getColumnNumber(BInfo.first, BInfo.second) << '-' 715 << SM.getLineNumber(EInfo.first, EInfo.second) << ':' 716 << SM.getColumnNumber(EInfo.first, EInfo.second) << "}" 717 << " to \"" << FixIt.CodeToInsert << "\")"; 718 } 719 OS << '\n'; 720 } 721 } 722 723 // This function is used solely to preserve the former presentation of overloads 724 // by "clang -cc1 -code-completion-at", since CodeCompletionString::getAsString 725 // needs to be improved for printing the newer and more detailed overload 726 // chunks. 727 static std::string getOverloadAsString(const CodeCompletionString &CCS) { 728 std::string Result; 729 llvm::raw_string_ostream OS(Result); 730 731 for (auto &C : CCS) { 732 switch (C.Kind) { 733 case CodeCompletionString::CK_Informative: 734 case CodeCompletionString::CK_ResultType: 735 OS << "[#" << C.Text << "#]"; 736 break; 737 738 case CodeCompletionString::CK_CurrentParameter: 739 OS << "<#" << C.Text << "#>"; 740 break; 741 742 // FIXME: We can also print optional parameters of an overload. 743 case CodeCompletionString::CK_Optional: 744 break; 745 746 default: 747 OS << C.Text; 748 break; 749 } 750 } 751 return Result; 752 } 753 754 void PrintingCodeCompleteConsumer::ProcessOverloadCandidates( 755 Sema &SemaRef, unsigned CurrentArg, OverloadCandidate *Candidates, 756 unsigned NumCandidates, SourceLocation OpenParLoc, bool Braced) { 757 OS << "OPENING_PAREN_LOC: "; 758 OpenParLoc.print(OS, SemaRef.getSourceManager()); 759 OS << "\n"; 760 761 for (unsigned I = 0; I != NumCandidates; ++I) { 762 if (CodeCompletionString *CCS = Candidates[I].CreateSignatureString( 763 CurrentArg, SemaRef, getAllocator(), CCTUInfo, 764 includeBriefComments(), Braced)) { 765 OS << "OVERLOAD: " << getOverloadAsString(*CCS) << "\n"; 766 } 767 } 768 } 769 770 /// Retrieve the effective availability of the given declaration. 771 static AvailabilityResult getDeclAvailability(const Decl *D) { 772 AvailabilityResult AR = D->getAvailability(); 773 if (isa<EnumConstantDecl>(D)) 774 AR = std::max(AR, cast<Decl>(D->getDeclContext())->getAvailability()); 775 return AR; 776 } 777 778 void CodeCompletionResult::computeCursorKindAndAvailability(bool Accessible) { 779 switch (Kind) { 780 case RK_Pattern: 781 if (!Declaration) { 782 // Do nothing: Patterns can come with cursor kinds! 783 break; 784 } 785 [[fallthrough]]; 786 787 case RK_Declaration: { 788 // Set the availability based on attributes. 789 switch (getDeclAvailability(Declaration)) { 790 case AR_Available: 791 case AR_NotYetIntroduced: 792 Availability = CXAvailability_Available; 793 break; 794 795 case AR_Deprecated: 796 Availability = CXAvailability_Deprecated; 797 break; 798 799 case AR_Unavailable: 800 Availability = CXAvailability_NotAvailable; 801 break; 802 } 803 804 if (const auto *Function = dyn_cast<FunctionDecl>(Declaration)) 805 if (Function->isDeleted()) 806 Availability = CXAvailability_NotAvailable; 807 808 CursorKind = getCursorKindForDecl(Declaration); 809 if (CursorKind == CXCursor_UnexposedDecl) { 810 // FIXME: Forward declarations of Objective-C classes and protocols 811 // are not directly exposed, but we want code completion to treat them 812 // like a definition. 813 if (isa<ObjCInterfaceDecl>(Declaration)) 814 CursorKind = CXCursor_ObjCInterfaceDecl; 815 else if (isa<ObjCProtocolDecl>(Declaration)) 816 CursorKind = CXCursor_ObjCProtocolDecl; 817 else 818 CursorKind = CXCursor_NotImplemented; 819 } 820 break; 821 } 822 823 case RK_Macro: 824 case RK_Keyword: 825 llvm_unreachable("Macro and keyword kinds are handled by the constructors"); 826 } 827 828 if (!Accessible) 829 Availability = CXAvailability_NotAccessible; 830 } 831 832 /// Retrieve the name that should be used to order a result. 833 /// 834 /// If the name needs to be constructed as a string, that string will be 835 /// saved into Saved and the returned StringRef will refer to it. 836 StringRef CodeCompletionResult::getOrderedName(std::string &Saved) const { 837 switch (Kind) { 838 case RK_Keyword: 839 return Keyword; 840 case RK_Pattern: 841 return Pattern->getTypedText(); 842 case RK_Macro: 843 return Macro->getName(); 844 case RK_Declaration: 845 // Handle declarations below. 846 break; 847 } 848 849 DeclarationName Name = Declaration->getDeclName(); 850 851 // If the name is a simple identifier (by far the common case), or a 852 // zero-argument selector, just return a reference to that identifier. 853 if (IdentifierInfo *Id = Name.getAsIdentifierInfo()) 854 return Id->getName(); 855 if (Name.isObjCZeroArgSelector()) 856 if (IdentifierInfo *Id = Name.getObjCSelector().getIdentifierInfoForSlot(0)) 857 return Id->getName(); 858 859 Saved = Name.getAsString(); 860 return Saved; 861 } 862 863 bool clang::operator<(const CodeCompletionResult &X, 864 const CodeCompletionResult &Y) { 865 std::string XSaved, YSaved; 866 StringRef XStr = X.getOrderedName(XSaved); 867 StringRef YStr = Y.getOrderedName(YSaved); 868 int cmp = XStr.compare_insensitive(YStr); 869 if (cmp) 870 return cmp < 0; 871 872 // If case-insensitive comparison fails, try case-sensitive comparison. 873 return XStr.compare(YStr) < 0; 874 } 875