CodeCompleteConsumer.cpp revision 309124
1//===--- CodeCompleteConsumer.cpp - Code Completion Interface ---*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the CodeCompleteConsumer class. 11// 12//===----------------------------------------------------------------------===// 13#include "clang/Sema/CodeCompleteConsumer.h" 14#include "clang-c/Index.h" 15#include "clang/AST/DeclCXX.h" 16#include "clang/AST/DeclObjC.h" 17#include "clang/AST/DeclTemplate.h" 18#include "clang/Sema/Scope.h" 19#include "clang/Sema/Sema.h" 20#include "llvm/ADT/STLExtras.h" 21#include "llvm/ADT/SmallString.h" 22#include "llvm/ADT/Twine.h" 23#include "llvm/Support/raw_ostream.h" 24#include <algorithm> 25#include <cstring> 26#include <functional> 27 28using namespace clang; 29 30//===----------------------------------------------------------------------===// 31// Code completion context implementation 32//===----------------------------------------------------------------------===// 33 34bool CodeCompletionContext::wantConstructorResults() const { 35 switch (Kind) { 36 case CCC_Recovery: 37 case CCC_Statement: 38 case CCC_Expression: 39 case CCC_ObjCMessageReceiver: 40 case CCC_ParenthesizedExpression: 41 return true; 42 43 case CCC_TopLevel: 44 case CCC_ObjCInterface: 45 case CCC_ObjCImplementation: 46 case CCC_ObjCIvarList: 47 case CCC_ClassStructUnion: 48 case CCC_DotMemberAccess: 49 case CCC_ArrowMemberAccess: 50 case CCC_ObjCPropertyAccess: 51 case CCC_EnumTag: 52 case CCC_UnionTag: 53 case CCC_ClassOrStructTag: 54 case CCC_ObjCProtocolName: 55 case CCC_Namespace: 56 case CCC_Type: 57 case CCC_Name: 58 case CCC_PotentiallyQualifiedName: 59 case CCC_MacroName: 60 case CCC_MacroNameUse: 61 case CCC_PreprocessorExpression: 62 case CCC_PreprocessorDirective: 63 case CCC_NaturalLanguage: 64 case CCC_SelectorName: 65 case CCC_TypeQualifiers: 66 case CCC_Other: 67 case CCC_OtherWithMacros: 68 case CCC_ObjCInstanceMessage: 69 case CCC_ObjCClassMessage: 70 case CCC_ObjCInterfaceName: 71 case CCC_ObjCCategoryName: 72 return false; 73 } 74 75 llvm_unreachable("Invalid CodeCompletionContext::Kind!"); 76} 77 78//===----------------------------------------------------------------------===// 79// Code completion string implementation 80//===----------------------------------------------------------------------===// 81CodeCompletionString::Chunk::Chunk(ChunkKind Kind, const char *Text) 82 : Kind(Kind), Text("") 83{ 84 switch (Kind) { 85 case CK_TypedText: 86 case CK_Text: 87 case CK_Placeholder: 88 case CK_Informative: 89 case CK_ResultType: 90 case CK_CurrentParameter: 91 this->Text = Text; 92 break; 93 94 case CK_Optional: 95 llvm_unreachable("Optional strings cannot be created from text"); 96 97 case CK_LeftParen: 98 this->Text = "("; 99 break; 100 101 case CK_RightParen: 102 this->Text = ")"; 103 break; 104 105 case CK_LeftBracket: 106 this->Text = "["; 107 break; 108 109 case CK_RightBracket: 110 this->Text = "]"; 111 break; 112 113 case CK_LeftBrace: 114 this->Text = "{"; 115 break; 116 117 case CK_RightBrace: 118 this->Text = "}"; 119 break; 120 121 case CK_LeftAngle: 122 this->Text = "<"; 123 break; 124 125 case CK_RightAngle: 126 this->Text = ">"; 127 break; 128 129 case CK_Comma: 130 this->Text = ", "; 131 break; 132 133 case CK_Colon: 134 this->Text = ":"; 135 break; 136 137 case CK_SemiColon: 138 this->Text = ";"; 139 break; 140 141 case CK_Equal: 142 this->Text = " = "; 143 break; 144 145 case CK_HorizontalSpace: 146 this->Text = " "; 147 break; 148 149 case CK_VerticalSpace: 150 this->Text = "\n"; 151 break; 152 } 153} 154 155CodeCompletionString::Chunk 156CodeCompletionString::Chunk::CreateText(const char *Text) { 157 return Chunk(CK_Text, Text); 158} 159 160CodeCompletionString::Chunk 161CodeCompletionString::Chunk::CreateOptional(CodeCompletionString *Optional) { 162 Chunk Result; 163 Result.Kind = CK_Optional; 164 Result.Optional = Optional; 165 return Result; 166} 167 168CodeCompletionString::Chunk 169CodeCompletionString::Chunk::CreatePlaceholder(const char *Placeholder) { 170 return Chunk(CK_Placeholder, Placeholder); 171} 172 173CodeCompletionString::Chunk 174CodeCompletionString::Chunk::CreateInformative(const char *Informative) { 175 return Chunk(CK_Informative, Informative); 176} 177 178CodeCompletionString::Chunk 179CodeCompletionString::Chunk::CreateResultType(const char *ResultType) { 180 return Chunk(CK_ResultType, ResultType); 181} 182 183CodeCompletionString::Chunk 184CodeCompletionString::Chunk::CreateCurrentParameter( 185 const char *CurrentParameter) { 186 return Chunk(CK_CurrentParameter, CurrentParameter); 187} 188 189CodeCompletionString::CodeCompletionString(const Chunk *Chunks, 190 unsigned NumChunks, 191 unsigned Priority, 192 CXAvailabilityKind Availability, 193 const char **Annotations, 194 unsigned NumAnnotations, 195 StringRef ParentName, 196 const char *BriefComment) 197 : NumChunks(NumChunks), NumAnnotations(NumAnnotations), 198 Priority(Priority), Availability(Availability), 199 ParentName(ParentName), BriefComment(BriefComment) 200{ 201 assert(NumChunks <= 0xffff); 202 assert(NumAnnotations <= 0xffff); 203 204 Chunk *StoredChunks = reinterpret_cast<Chunk *>(this + 1); 205 for (unsigned I = 0; I != NumChunks; ++I) 206 StoredChunks[I] = Chunks[I]; 207 208 const char **StoredAnnotations = reinterpret_cast<const char **>(StoredChunks + NumChunks); 209 for (unsigned I = 0; I != NumAnnotations; ++I) 210 StoredAnnotations[I] = Annotations[I]; 211} 212 213unsigned CodeCompletionString::getAnnotationCount() const { 214 return NumAnnotations; 215} 216 217const char *CodeCompletionString::getAnnotation(unsigned AnnotationNr) const { 218 if (AnnotationNr < NumAnnotations) 219 return reinterpret_cast<const char * const*>(end())[AnnotationNr]; 220 else 221 return nullptr; 222} 223 224 225std::string CodeCompletionString::getAsString() const { 226 std::string Result; 227 llvm::raw_string_ostream OS(Result); 228 229 for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) { 230 switch (C->Kind) { 231 case CK_Optional: OS << "{#" << C->Optional->getAsString() << "#}"; break; 232 case CK_Placeholder: OS << "<#" << C->Text << "#>"; break; 233 234 case CK_Informative: 235 case CK_ResultType: 236 OS << "[#" << C->Text << "#]"; 237 break; 238 239 case CK_CurrentParameter: OS << "<#" << C->Text << "#>"; break; 240 default: OS << C->Text; break; 241 } 242 } 243 return OS.str(); 244} 245 246const char *CodeCompletionString::getTypedText() const { 247 for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) 248 if (C->Kind == CK_TypedText) 249 return C->Text; 250 251 return nullptr; 252} 253 254const char *CodeCompletionAllocator::CopyString(const Twine &String) { 255 SmallString<128> Data; 256 StringRef Ref = String.toStringRef(Data); 257 // FIXME: It would be more efficient to teach Twine to tell us its size and 258 // then add a routine there to fill in an allocated char* with the contents 259 // of the string. 260 char *Mem = (char *)Allocate(Ref.size() + 1, 1); 261 std::copy(Ref.begin(), Ref.end(), Mem); 262 Mem[Ref.size()] = 0; 263 return Mem; 264} 265 266StringRef CodeCompletionTUInfo::getParentName(const DeclContext *DC) { 267 const NamedDecl *ND = dyn_cast<NamedDecl>(DC); 268 if (!ND) 269 return StringRef(); 270 271 // Check whether we've already cached the parent name. 272 StringRef &CachedParentName = ParentNames[DC]; 273 if (!CachedParentName.empty()) 274 return CachedParentName; 275 276 // If we already processed this DeclContext and assigned empty to it, the 277 // data pointer will be non-null. 278 if (CachedParentName.data() != nullptr) 279 return StringRef(); 280 281 // Find the interesting names. 282 SmallVector<const DeclContext *, 2> Contexts; 283 while (DC && !DC->isFunctionOrMethod()) { 284 if (const NamedDecl *ND = dyn_cast<NamedDecl>(DC)) { 285 if (ND->getIdentifier()) 286 Contexts.push_back(DC); 287 } 288 289 DC = DC->getParent(); 290 } 291 292 { 293 SmallString<128> S; 294 llvm::raw_svector_ostream OS(S); 295 bool First = true; 296 for (unsigned I = Contexts.size(); I != 0; --I) { 297 if (First) 298 First = false; 299 else { 300 OS << "::"; 301 } 302 303 const DeclContext *CurDC = Contexts[I-1]; 304 if (const ObjCCategoryImplDecl *CatImpl = dyn_cast<ObjCCategoryImplDecl>(CurDC)) 305 CurDC = CatImpl->getCategoryDecl(); 306 307 if (const ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(CurDC)) { 308 const ObjCInterfaceDecl *Interface = Cat->getClassInterface(); 309 if (!Interface) { 310 // Assign an empty StringRef but with non-null data to distinguish 311 // between empty because we didn't process the DeclContext yet. 312 CachedParentName = StringRef((const char *)(uintptr_t)~0U, 0); 313 return StringRef(); 314 } 315 316 OS << Interface->getName() << '(' << Cat->getName() << ')'; 317 } else { 318 OS << cast<NamedDecl>(CurDC)->getName(); 319 } 320 } 321 322 CachedParentName = AllocatorRef->CopyString(OS.str()); 323 } 324 325 return CachedParentName; 326} 327 328CodeCompletionString *CodeCompletionBuilder::TakeString() { 329 void *Mem = getAllocator().Allocate( 330 sizeof(CodeCompletionString) + sizeof(Chunk) * Chunks.size() 331 + sizeof(const char *) * Annotations.size(), 332 llvm::alignOf<CodeCompletionString>()); 333 CodeCompletionString *Result 334 = new (Mem) CodeCompletionString(Chunks.data(), Chunks.size(), 335 Priority, Availability, 336 Annotations.data(), Annotations.size(), 337 ParentName, BriefComment); 338 Chunks.clear(); 339 return Result; 340} 341 342void CodeCompletionBuilder::AddTypedTextChunk(const char *Text) { 343 Chunks.push_back(Chunk(CodeCompletionString::CK_TypedText, Text)); 344} 345 346void CodeCompletionBuilder::AddTextChunk(const char *Text) { 347 Chunks.push_back(Chunk::CreateText(Text)); 348} 349 350void CodeCompletionBuilder::AddOptionalChunk(CodeCompletionString *Optional) { 351 Chunks.push_back(Chunk::CreateOptional(Optional)); 352} 353 354void CodeCompletionBuilder::AddPlaceholderChunk(const char *Placeholder) { 355 Chunks.push_back(Chunk::CreatePlaceholder(Placeholder)); 356} 357 358void CodeCompletionBuilder::AddInformativeChunk(const char *Text) { 359 Chunks.push_back(Chunk::CreateInformative(Text)); 360} 361 362void CodeCompletionBuilder::AddResultTypeChunk(const char *ResultType) { 363 Chunks.push_back(Chunk::CreateResultType(ResultType)); 364} 365 366void 367CodeCompletionBuilder::AddCurrentParameterChunk(const char *CurrentParameter) { 368 Chunks.push_back(Chunk::CreateCurrentParameter(CurrentParameter)); 369} 370 371void CodeCompletionBuilder::AddChunk(CodeCompletionString::ChunkKind CK, 372 const char *Text) { 373 Chunks.push_back(Chunk(CK, Text)); 374} 375 376void CodeCompletionBuilder::addParentContext(const DeclContext *DC) { 377 if (DC->isTranslationUnit()) { 378 return; 379 } 380 381 if (DC->isFunctionOrMethod()) 382 return; 383 384 const NamedDecl *ND = dyn_cast<NamedDecl>(DC); 385 if (!ND) 386 return; 387 388 ParentName = getCodeCompletionTUInfo().getParentName(DC); 389} 390 391void CodeCompletionBuilder::addBriefComment(StringRef Comment) { 392 BriefComment = Allocator.CopyString(Comment); 393} 394 395//===----------------------------------------------------------------------===// 396// Code completion overload candidate implementation 397//===----------------------------------------------------------------------===// 398FunctionDecl * 399CodeCompleteConsumer::OverloadCandidate::getFunction() const { 400 if (getKind() == CK_Function) 401 return Function; 402 else if (getKind() == CK_FunctionTemplate) 403 return FunctionTemplate->getTemplatedDecl(); 404 else 405 return nullptr; 406} 407 408const FunctionType * 409CodeCompleteConsumer::OverloadCandidate::getFunctionType() const { 410 switch (Kind) { 411 case CK_Function: 412 return Function->getType()->getAs<FunctionType>(); 413 414 case CK_FunctionTemplate: 415 return FunctionTemplate->getTemplatedDecl()->getType() 416 ->getAs<FunctionType>(); 417 418 case CK_FunctionType: 419 return Type; 420 } 421 422 llvm_unreachable("Invalid CandidateKind!"); 423} 424 425//===----------------------------------------------------------------------===// 426// Code completion consumer implementation 427//===----------------------------------------------------------------------===// 428 429CodeCompleteConsumer::~CodeCompleteConsumer() { } 430 431void 432PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &SemaRef, 433 CodeCompletionContext Context, 434 CodeCompletionResult *Results, 435 unsigned NumResults) { 436 std::stable_sort(Results, Results + NumResults); 437 438 // Print the results. 439 for (unsigned I = 0; I != NumResults; ++I) { 440 OS << "COMPLETION: "; 441 switch (Results[I].Kind) { 442 case CodeCompletionResult::RK_Declaration: 443 OS << *Results[I].Declaration; 444 if (Results[I].Hidden) 445 OS << " (Hidden)"; 446 if (CodeCompletionString *CCS 447 = Results[I].CreateCodeCompletionString(SemaRef, Context, 448 getAllocator(), 449 CCTUInfo, 450 includeBriefComments())) { 451 OS << " : " << CCS->getAsString(); 452 if (const char *BriefComment = CCS->getBriefComment()) 453 OS << " : " << BriefComment; 454 } 455 456 OS << '\n'; 457 break; 458 459 case CodeCompletionResult::RK_Keyword: 460 OS << Results[I].Keyword << '\n'; 461 break; 462 463 case CodeCompletionResult::RK_Macro: { 464 OS << Results[I].Macro->getName(); 465 if (CodeCompletionString *CCS 466 = Results[I].CreateCodeCompletionString(SemaRef, Context, 467 getAllocator(), 468 CCTUInfo, 469 includeBriefComments())) { 470 OS << " : " << CCS->getAsString(); 471 } 472 OS << '\n'; 473 break; 474 } 475 476 case CodeCompletionResult::RK_Pattern: { 477 OS << "Pattern : " 478 << Results[I].Pattern->getAsString() << '\n'; 479 break; 480 } 481 } 482 } 483} 484 485// This function is used solely to preserve the former presentation of overloads 486// by "clang -cc1 -code-completion-at", since CodeCompletionString::getAsString 487// needs to be improved for printing the newer and more detailed overload 488// chunks. 489static std::string getOverloadAsString(const CodeCompletionString &CCS) { 490 std::string Result; 491 llvm::raw_string_ostream OS(Result); 492 493 for (auto &C : CCS) { 494 switch (C.Kind) { 495 case CodeCompletionString::CK_Informative: 496 case CodeCompletionString::CK_ResultType: 497 OS << "[#" << C.Text << "#]"; 498 break; 499 500 case CodeCompletionString::CK_CurrentParameter: 501 OS << "<#" << C.Text << "#>"; 502 break; 503 504 default: OS << C.Text; break; 505 } 506 } 507 return OS.str(); 508} 509 510void 511PrintingCodeCompleteConsumer::ProcessOverloadCandidates(Sema &SemaRef, 512 unsigned CurrentArg, 513 OverloadCandidate *Candidates, 514 unsigned NumCandidates) { 515 for (unsigned I = 0; I != NumCandidates; ++I) { 516 if (CodeCompletionString *CCS 517 = Candidates[I].CreateSignatureString(CurrentArg, SemaRef, 518 getAllocator(), CCTUInfo, 519 includeBriefComments())) { 520 OS << "OVERLOAD: " << getOverloadAsString(*CCS) << "\n"; 521 } 522 } 523} 524 525/// \brief Retrieve the effective availability of the given declaration. 526static AvailabilityResult getDeclAvailability(const Decl *D) { 527 AvailabilityResult AR = D->getAvailability(); 528 if (isa<EnumConstantDecl>(D)) 529 AR = std::max(AR, cast<Decl>(D->getDeclContext())->getAvailability()); 530 return AR; 531} 532 533void CodeCompletionResult::computeCursorKindAndAvailability(bool Accessible) { 534 switch (Kind) { 535 case RK_Pattern: 536 if (!Declaration) { 537 // Do nothing: Patterns can come with cursor kinds! 538 break; 539 } 540 // Fall through 541 542 case RK_Declaration: { 543 // Set the availability based on attributes. 544 switch (getDeclAvailability(Declaration)) { 545 case AR_Available: 546 case AR_NotYetIntroduced: 547 Availability = CXAvailability_Available; 548 break; 549 550 case AR_Deprecated: 551 Availability = CXAvailability_Deprecated; 552 break; 553 554 case AR_Unavailable: 555 Availability = CXAvailability_NotAvailable; 556 break; 557 } 558 559 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(Declaration)) 560 if (Function->isDeleted()) 561 Availability = CXAvailability_NotAvailable; 562 563 CursorKind = getCursorKindForDecl(Declaration); 564 if (CursorKind == CXCursor_UnexposedDecl) { 565 // FIXME: Forward declarations of Objective-C classes and protocols 566 // are not directly exposed, but we want code completion to treat them 567 // like a definition. 568 if (isa<ObjCInterfaceDecl>(Declaration)) 569 CursorKind = CXCursor_ObjCInterfaceDecl; 570 else if (isa<ObjCProtocolDecl>(Declaration)) 571 CursorKind = CXCursor_ObjCProtocolDecl; 572 else 573 CursorKind = CXCursor_NotImplemented; 574 } 575 break; 576 } 577 578 case RK_Macro: 579 case RK_Keyword: 580 llvm_unreachable("Macro and keyword kinds are handled by the constructors"); 581 } 582 583 if (!Accessible) 584 Availability = CXAvailability_NotAccessible; 585} 586 587/// \brief Retrieve the name that should be used to order a result. 588/// 589/// If the name needs to be constructed as a string, that string will be 590/// saved into Saved and the returned StringRef will refer to it. 591static StringRef getOrderedName(const CodeCompletionResult &R, 592 std::string &Saved) { 593 switch (R.Kind) { 594 case CodeCompletionResult::RK_Keyword: 595 return R.Keyword; 596 597 case CodeCompletionResult::RK_Pattern: 598 return R.Pattern->getTypedText(); 599 600 case CodeCompletionResult::RK_Macro: 601 return R.Macro->getName(); 602 603 case CodeCompletionResult::RK_Declaration: 604 // Handle declarations below. 605 break; 606 } 607 608 DeclarationName Name = R.Declaration->getDeclName(); 609 610 // If the name is a simple identifier (by far the common case), or a 611 // zero-argument selector, just return a reference to that identifier. 612 if (IdentifierInfo *Id = Name.getAsIdentifierInfo()) 613 return Id->getName(); 614 if (Name.isObjCZeroArgSelector()) 615 if (IdentifierInfo *Id 616 = Name.getObjCSelector().getIdentifierInfoForSlot(0)) 617 return Id->getName(); 618 619 Saved = Name.getAsString(); 620 return Saved; 621} 622 623bool clang::operator<(const CodeCompletionResult &X, 624 const CodeCompletionResult &Y) { 625 std::string XSaved, YSaved; 626 StringRef XStr = getOrderedName(X, XSaved); 627 StringRef YStr = getOrderedName(Y, YSaved); 628 int cmp = XStr.compare_lower(YStr); 629 if (cmp) 630 return cmp < 0; 631 632 // If case-insensitive comparison fails, try case-sensitive comparison. 633 cmp = XStr.compare(YStr); 634 if (cmp) 635 return cmp < 0; 636 637 return false; 638} 639