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 28 using namespace clang; 29 30 //===----------------------------------------------------------------------===// 31 // Code completion context implementation 32 //===----------------------------------------------------------------------===// 33 34 bool 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 //===----------------------------------------------------------------------===// 81 CodeCompletionString::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 155 CodeCompletionString::Chunk 156 CodeCompletionString::Chunk::CreateText(const char *Text) { 157 return Chunk(CK_Text, Text); 158 } 159 160 CodeCompletionString::Chunk 161 CodeCompletionString::Chunk::CreateOptional(CodeCompletionString *Optional) { 162 Chunk Result; 163 Result.Kind = CK_Optional; 164 Result.Optional = Optional; 165 return Result; 166 } 167 168 CodeCompletionString::Chunk 169 CodeCompletionString::Chunk::CreatePlaceholder(const char *Placeholder) { 170 return Chunk(CK_Placeholder, Placeholder); 171 } 172 173 CodeCompletionString::Chunk 174 CodeCompletionString::Chunk::CreateInformative(const char *Informative) { 175 return Chunk(CK_Informative, Informative); 176 } 177 178 CodeCompletionString::Chunk 179 CodeCompletionString::Chunk::CreateResultType(const char *ResultType) { 180 return Chunk(CK_ResultType, ResultType); 181 } 182 183 CodeCompletionString::Chunk 184 CodeCompletionString::Chunk::CreateCurrentParameter( 185 const char *CurrentParameter) { 186 return Chunk(CK_CurrentParameter, CurrentParameter); 187 } 188 189 CodeCompletionString::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 213 unsigned CodeCompletionString::getAnnotationCount() const { 214 return NumAnnotations; 215 } 216 217 const 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 225 std::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 246 const 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 254 const 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 266 StringRef 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 *)~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 328 CodeCompletionString *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 342 void CodeCompletionBuilder::AddTypedTextChunk(const char *Text) { 343 Chunks.push_back(Chunk(CodeCompletionString::CK_TypedText, Text)); 344 } 345 346 void CodeCompletionBuilder::AddTextChunk(const char *Text) { 347 Chunks.push_back(Chunk::CreateText(Text)); 348 } 349 350 void CodeCompletionBuilder::AddOptionalChunk(CodeCompletionString *Optional) { 351 Chunks.push_back(Chunk::CreateOptional(Optional)); 352 } 353 354 void CodeCompletionBuilder::AddPlaceholderChunk(const char *Placeholder) { 355 Chunks.push_back(Chunk::CreatePlaceholder(Placeholder)); 356 } 357 358 void CodeCompletionBuilder::AddInformativeChunk(const char *Text) { 359 Chunks.push_back(Chunk::CreateInformative(Text)); 360 } 361 362 void CodeCompletionBuilder::AddResultTypeChunk(const char *ResultType) { 363 Chunks.push_back(Chunk::CreateResultType(ResultType)); 364 } 365 366 void 367 CodeCompletionBuilder::AddCurrentParameterChunk(const char *CurrentParameter) { 368 Chunks.push_back(Chunk::CreateCurrentParameter(CurrentParameter)); 369 } 370 371 void CodeCompletionBuilder::AddChunk(CodeCompletionString::ChunkKind CK, 372 const char *Text) { 373 Chunks.push_back(Chunk(CK, Text)); 374 } 375 376 void 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 391 void CodeCompletionBuilder::addBriefComment(StringRef Comment) { 392 BriefComment = Allocator.CopyString(Comment); 393 } 394 395 //===----------------------------------------------------------------------===// 396 // Code completion overload candidate implementation 397 //===----------------------------------------------------------------------===// 398 FunctionDecl * 399 CodeCompleteConsumer::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 408 const FunctionType * 409 CodeCompleteConsumer::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 429 CodeCompleteConsumer::~CodeCompleteConsumer() { } 430 431 void 432 PrintingCodeCompleteConsumer::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. 489 static 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 510 void 511 PrintingCodeCompleteConsumer::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. 526 static 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 533 void 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. 591 static 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 623 bool 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