CodeCompleteConsumer.cpp revision 208600
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/AST/DeclCXX.h" 15#include "clang/Parse/Scope.h" 16#include "clang/Lex/Preprocessor.h" 17#include "clang-c/Index.h" 18#include "Sema.h" 19#include "llvm/ADT/STLExtras.h" 20#include "llvm/Support/raw_ostream.h" 21#include <algorithm> 22#include <cstring> 23#include <functional> 24 25using namespace clang; 26using llvm::StringRef; 27 28//===----------------------------------------------------------------------===// 29// Code completion string implementation 30//===----------------------------------------------------------------------===// 31CodeCompletionString::Chunk::Chunk(ChunkKind Kind, llvm::StringRef Text) 32 : Kind(Kind), Text("") 33{ 34 switch (Kind) { 35 case CK_TypedText: 36 case CK_Text: 37 case CK_Placeholder: 38 case CK_Informative: 39 case CK_ResultType: 40 case CK_CurrentParameter: { 41 char *New = new char [Text.size() + 1]; 42 std::memcpy(New, Text.data(), Text.size()); 43 New[Text.size()] = '\0'; 44 this->Text = New; 45 break; 46 } 47 48 case CK_Optional: 49 llvm_unreachable("Optional strings cannot be created from text"); 50 break; 51 52 case CK_LeftParen: 53 this->Text = "("; 54 break; 55 56 case CK_RightParen: 57 this->Text = ")"; 58 break; 59 60 case CK_LeftBracket: 61 this->Text = "["; 62 break; 63 64 case CK_RightBracket: 65 this->Text = "]"; 66 break; 67 68 case CK_LeftBrace: 69 this->Text = "{"; 70 break; 71 72 case CK_RightBrace: 73 this->Text = "}"; 74 break; 75 76 case CK_LeftAngle: 77 this->Text = "<"; 78 break; 79 80 case CK_RightAngle: 81 this->Text = ">"; 82 break; 83 84 case CK_Comma: 85 this->Text = ", "; 86 break; 87 88 case CK_Colon: 89 this->Text = ":"; 90 break; 91 92 case CK_SemiColon: 93 this->Text = ";"; 94 break; 95 96 case CK_Equal: 97 this->Text = " = "; 98 break; 99 100 case CK_HorizontalSpace: 101 this->Text = " "; 102 break; 103 104 case CK_VerticalSpace: 105 this->Text = "\n"; 106 break; 107 } 108} 109 110CodeCompletionString::Chunk 111CodeCompletionString::Chunk::CreateText(StringRef Text) { 112 return Chunk(CK_Text, Text); 113} 114 115CodeCompletionString::Chunk 116CodeCompletionString::Chunk::CreateOptional( 117 std::auto_ptr<CodeCompletionString> Optional) { 118 Chunk Result; 119 Result.Kind = CK_Optional; 120 Result.Optional = Optional.release(); 121 return Result; 122} 123 124CodeCompletionString::Chunk 125CodeCompletionString::Chunk::CreatePlaceholder(StringRef Placeholder) { 126 return Chunk(CK_Placeholder, Placeholder); 127} 128 129CodeCompletionString::Chunk 130CodeCompletionString::Chunk::CreateInformative(StringRef Informative) { 131 return Chunk(CK_Informative, Informative); 132} 133 134CodeCompletionString::Chunk 135CodeCompletionString::Chunk::CreateResultType(StringRef ResultType) { 136 return Chunk(CK_ResultType, ResultType); 137} 138 139CodeCompletionString::Chunk 140CodeCompletionString::Chunk::CreateCurrentParameter( 141 StringRef CurrentParameter) { 142 return Chunk(CK_CurrentParameter, CurrentParameter); 143} 144 145CodeCompletionString::Chunk CodeCompletionString::Chunk::Clone() const { 146 switch (Kind) { 147 case CK_TypedText: 148 case CK_Text: 149 case CK_Placeholder: 150 case CK_Informative: 151 case CK_ResultType: 152 case CK_CurrentParameter: 153 case CK_LeftParen: 154 case CK_RightParen: 155 case CK_LeftBracket: 156 case CK_RightBracket: 157 case CK_LeftBrace: 158 case CK_RightBrace: 159 case CK_LeftAngle: 160 case CK_RightAngle: 161 case CK_Comma: 162 case CK_Colon: 163 case CK_SemiColon: 164 case CK_Equal: 165 case CK_HorizontalSpace: 166 case CK_VerticalSpace: 167 return Chunk(Kind, Text); 168 169 case CK_Optional: { 170 std::auto_ptr<CodeCompletionString> Opt(Optional->Clone()); 171 return CreateOptional(Opt); 172 } 173 } 174 175 // Silence GCC warning. 176 return Chunk(); 177} 178 179void 180CodeCompletionString::Chunk::Destroy() { 181 switch (Kind) { 182 case CK_Optional: 183 delete Optional; 184 break; 185 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 delete [] Text; 193 break; 194 195 case CK_LeftParen: 196 case CK_RightParen: 197 case CK_LeftBracket: 198 case CK_RightBracket: 199 case CK_LeftBrace: 200 case CK_RightBrace: 201 case CK_LeftAngle: 202 case CK_RightAngle: 203 case CK_Comma: 204 case CK_Colon: 205 case CK_SemiColon: 206 case CK_Equal: 207 case CK_HorizontalSpace: 208 case CK_VerticalSpace: 209 break; 210 } 211} 212 213void CodeCompletionString::clear() { 214 std::for_each(Chunks.begin(), Chunks.end(), 215 std::mem_fun_ref(&Chunk::Destroy)); 216 Chunks.clear(); 217} 218 219std::string CodeCompletionString::getAsString() const { 220 std::string Result; 221 llvm::raw_string_ostream OS(Result); 222 223 for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) { 224 switch (C->Kind) { 225 case CK_Optional: OS << "{#" << C->Optional->getAsString() << "#}"; break; 226 case CK_Placeholder: OS << "<#" << C->Text << "#>"; break; 227 228 case CK_Informative: 229 case CK_ResultType: 230 OS << "[#" << C->Text << "#]"; 231 break; 232 233 case CK_CurrentParameter: OS << "<#" << C->Text << "#>"; break; 234 default: OS << C->Text; break; 235 } 236 } 237 OS.flush(); 238 return Result; 239} 240 241const char *CodeCompletionString::getTypedText() const { 242 for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) 243 if (C->Kind == CK_TypedText) 244 return C->Text; 245 246 return 0; 247} 248 249CodeCompletionString *CodeCompletionString::Clone() const { 250 CodeCompletionString *Result = new CodeCompletionString; 251 for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) 252 Result->AddChunk(C->Clone()); 253 return Result; 254} 255 256static void WriteUnsigned(llvm::raw_ostream &OS, unsigned Value) { 257 OS.write((const char *)&Value, sizeof(unsigned)); 258} 259 260static bool ReadUnsigned(const char *&Memory, const char *MemoryEnd, 261 unsigned &Value) { 262 if (Memory + sizeof(unsigned) > MemoryEnd) 263 return true; 264 265 memmove(&Value, Memory, sizeof(unsigned)); 266 Memory += sizeof(unsigned); 267 return false; 268} 269 270void CodeCompletionString::Serialize(llvm::raw_ostream &OS) const { 271 // Write the number of chunks. 272 WriteUnsigned(OS, size()); 273 274 for (iterator C = begin(), CEnd = end(); C != CEnd; ++C) { 275 WriteUnsigned(OS, C->Kind); 276 277 switch (C->Kind) { 278 case CK_TypedText: 279 case CK_Text: 280 case CK_Placeholder: 281 case CK_Informative: 282 case CK_ResultType: 283 case CK_CurrentParameter: { 284 const char *Text = C->Text; 285 unsigned StrLen = strlen(Text); 286 WriteUnsigned(OS, StrLen); 287 OS.write(Text, StrLen); 288 break; 289 } 290 291 case CK_Optional: 292 C->Optional->Serialize(OS); 293 break; 294 295 case CK_LeftParen: 296 case CK_RightParen: 297 case CK_LeftBracket: 298 case CK_RightBracket: 299 case CK_LeftBrace: 300 case CK_RightBrace: 301 case CK_LeftAngle: 302 case CK_RightAngle: 303 case CK_Comma: 304 case CK_Colon: 305 case CK_SemiColon: 306 case CK_Equal: 307 case CK_HorizontalSpace: 308 case CK_VerticalSpace: 309 break; 310 } 311 } 312} 313 314bool CodeCompletionString::Deserialize(const char *&Str, const char *StrEnd) { 315 if (Str == StrEnd || *Str == 0) 316 return false; 317 318 unsigned NumBlocks; 319 if (ReadUnsigned(Str, StrEnd, NumBlocks)) 320 return false; 321 322 for (unsigned I = 0; I != NumBlocks; ++I) { 323 if (Str + 1 >= StrEnd) 324 break; 325 326 // Parse the next kind. 327 unsigned KindValue; 328 if (ReadUnsigned(Str, StrEnd, KindValue)) 329 return false; 330 331 switch (ChunkKind Kind = (ChunkKind)KindValue) { 332 case CK_TypedText: 333 case CK_Text: 334 case CK_Placeholder: 335 case CK_Informative: 336 case CK_ResultType: 337 case CK_CurrentParameter: { 338 unsigned StrLen; 339 if (ReadUnsigned(Str, StrEnd, StrLen) || (Str + StrLen > StrEnd)) 340 return false; 341 342 AddChunk(Chunk(Kind, StringRef(Str, StrLen))); 343 Str += StrLen; 344 break; 345 } 346 347 case CK_Optional: { 348 std::auto_ptr<CodeCompletionString> Optional(new CodeCompletionString()); 349 if (Optional->Deserialize(Str, StrEnd)) 350 AddOptionalChunk(Optional); 351 break; 352 } 353 354 case CK_LeftParen: 355 case CK_RightParen: 356 case CK_LeftBracket: 357 case CK_RightBracket: 358 case CK_LeftBrace: 359 case CK_RightBrace: 360 case CK_LeftAngle: 361 case CK_RightAngle: 362 case CK_Comma: 363 case CK_Colon: 364 case CK_SemiColon: 365 case CK_Equal: 366 case CK_HorizontalSpace: 367 case CK_VerticalSpace: 368 AddChunk(Chunk(Kind)); 369 break; 370 } 371 }; 372 373 return true; 374} 375 376void CodeCompleteConsumer::Result::Destroy() { 377 if (Kind == RK_Pattern) { 378 delete Pattern; 379 Pattern = 0; 380 } 381} 382 383unsigned CodeCompleteConsumer::Result::getPriorityFromDecl(NamedDecl *ND) { 384 if (!ND) 385 return CCP_Unlikely; 386 387 // Context-based decisions. 388 DeclContext *DC = ND->getDeclContext()->getLookupContext(); 389 if (DC->isFunctionOrMethod() || isa<BlockDecl>(DC)) 390 return CCP_LocalDeclaration; 391 if (DC->isRecord() || isa<ObjCContainerDecl>(DC)) 392 return CCP_MemberDeclaration; 393 394 // Content-based decisions. 395 if (isa<EnumConstantDecl>(ND)) 396 return CCP_Constant; 397 if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) 398 return CCP_Type; 399 return CCP_Declaration; 400} 401 402//===----------------------------------------------------------------------===// 403// Code completion overload candidate implementation 404//===----------------------------------------------------------------------===// 405FunctionDecl * 406CodeCompleteConsumer::OverloadCandidate::getFunction() const { 407 if (getKind() == CK_Function) 408 return Function; 409 else if (getKind() == CK_FunctionTemplate) 410 return FunctionTemplate->getTemplatedDecl(); 411 else 412 return 0; 413} 414 415const FunctionType * 416CodeCompleteConsumer::OverloadCandidate::getFunctionType() const { 417 switch (Kind) { 418 case CK_Function: 419 return Function->getType()->getAs<FunctionType>(); 420 421 case CK_FunctionTemplate: 422 return FunctionTemplate->getTemplatedDecl()->getType() 423 ->getAs<FunctionType>(); 424 425 case CK_FunctionType: 426 return Type; 427 } 428 429 return 0; 430} 431 432//===----------------------------------------------------------------------===// 433// Code completion consumer implementation 434//===----------------------------------------------------------------------===// 435 436CodeCompleteConsumer::~CodeCompleteConsumer() { } 437 438void 439PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &SemaRef, 440 Result *Results, 441 unsigned NumResults) { 442 // Print the results. 443 for (unsigned I = 0; I != NumResults; ++I) { 444 OS << "COMPLETION: "; 445 switch (Results[I].Kind) { 446 case Result::RK_Declaration: 447 OS << Results[I].Declaration; 448 if (Results[I].Hidden) 449 OS << " (Hidden)"; 450 if (CodeCompletionString *CCS 451 = Results[I].CreateCodeCompletionString(SemaRef)) { 452 OS << " : " << CCS->getAsString(); 453 delete CCS; 454 } 455 456 OS << '\n'; 457 break; 458 459 case Result::RK_Keyword: 460 OS << Results[I].Keyword << '\n'; 461 break; 462 463 case Result::RK_Macro: { 464 OS << Results[I].Macro->getName(); 465 if (CodeCompletionString *CCS 466 = Results[I].CreateCodeCompletionString(SemaRef)) { 467 OS << " : " << CCS->getAsString(); 468 delete CCS; 469 } 470 OS << '\n'; 471 break; 472 } 473 474 case Result::RK_Pattern: { 475 OS << "Pattern : " 476 << Results[I].Pattern->getAsString() << '\n'; 477 break; 478 } 479 } 480 } 481} 482 483void 484PrintingCodeCompleteConsumer::ProcessOverloadCandidates(Sema &SemaRef, 485 unsigned CurrentArg, 486 OverloadCandidate *Candidates, 487 unsigned NumCandidates) { 488 for (unsigned I = 0; I != NumCandidates; ++I) { 489 if (CodeCompletionString *CCS 490 = Candidates[I].CreateSignatureString(CurrentArg, SemaRef)) { 491 OS << "OVERLOAD: " << CCS->getAsString() << "\n"; 492 delete CCS; 493 } 494 } 495} 496 497void 498CIndexCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &SemaRef, 499 Result *Results, 500 unsigned NumResults) { 501 // Print the results. 502 for (unsigned I = 0; I != NumResults; ++I) { 503 CXCursorKind Kind = CXCursor_NotImplemented; 504 505 switch (Results[I].Kind) { 506 case Result::RK_Declaration: 507 switch (Results[I].Declaration->getKind()) { 508 case Decl::Record: 509 case Decl::CXXRecord: 510 case Decl::ClassTemplateSpecialization: { 511 RecordDecl *Record = cast<RecordDecl>(Results[I].Declaration); 512 if (Record->isStruct()) 513 Kind = CXCursor_StructDecl; 514 else if (Record->isUnion()) 515 Kind = CXCursor_UnionDecl; 516 else 517 Kind = CXCursor_ClassDecl; 518 break; 519 } 520 521 case Decl::ObjCMethod: { 522 ObjCMethodDecl *Method = cast<ObjCMethodDecl>(Results[I].Declaration); 523 if (Method->isInstanceMethod()) 524 Kind = CXCursor_ObjCInstanceMethodDecl; 525 else 526 Kind = CXCursor_ObjCClassMethodDecl; 527 break; 528 } 529 530 case Decl::Typedef: 531 Kind = CXCursor_TypedefDecl; 532 break; 533 534 case Decl::Enum: 535 Kind = CXCursor_EnumDecl; 536 break; 537 538 case Decl::Field: 539 Kind = CXCursor_FieldDecl; 540 break; 541 542 case Decl::EnumConstant: 543 Kind = CXCursor_EnumConstantDecl; 544 break; 545 546 case Decl::Function: 547 case Decl::CXXMethod: 548 case Decl::CXXConstructor: 549 case Decl::CXXDestructor: 550 case Decl::CXXConversion: 551 Kind = CXCursor_FunctionDecl; 552 break; 553 554 case Decl::Var: 555 Kind = CXCursor_VarDecl; 556 break; 557 558 case Decl::ParmVar: 559 Kind = CXCursor_ParmDecl; 560 break; 561 562 case Decl::ObjCInterface: 563 Kind = CXCursor_ObjCInterfaceDecl; 564 break; 565 566 case Decl::ObjCCategory: 567 Kind = CXCursor_ObjCCategoryDecl; 568 break; 569 570 case Decl::ObjCProtocol: 571 Kind = CXCursor_ObjCProtocolDecl; 572 break; 573 574 case Decl::ObjCProperty: 575 Kind = CXCursor_ObjCPropertyDecl; 576 break; 577 578 case Decl::ObjCIvar: 579 Kind = CXCursor_ObjCIvarDecl; 580 break; 581 582 case Decl::ObjCImplementation: 583 Kind = CXCursor_ObjCImplementationDecl; 584 break; 585 586 case Decl::ObjCCategoryImpl: 587 Kind = CXCursor_ObjCCategoryImplDecl; 588 break; 589 590 default: 591 break; 592 } 593 break; 594 595 case Result::RK_Macro: 596 Kind = CXCursor_MacroDefinition; 597 break; 598 599 case Result::RK_Keyword: 600 case Result::RK_Pattern: 601 Kind = CXCursor_NotImplemented; 602 break; 603 } 604 605 WriteUnsigned(OS, Kind); 606 WriteUnsigned(OS, Results[I].Priority); 607 CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(SemaRef); 608 assert(CCS && "No code-completion string?"); 609 CCS->Serialize(OS); 610 delete CCS; 611 } 612} 613 614void 615CIndexCodeCompleteConsumer::ProcessOverloadCandidates(Sema &SemaRef, 616 unsigned CurrentArg, 617 OverloadCandidate *Candidates, 618 unsigned NumCandidates) { 619 for (unsigned I = 0; I != NumCandidates; ++I) { 620 WriteUnsigned(OS, CXCursor_NotImplemented); 621 WriteUnsigned(OS, /*Priority=*/0); 622 CodeCompletionString *CCS 623 = Candidates[I].CreateSignatureString(CurrentArg, SemaRef); 624 assert(CCS && "No code-completion string?"); 625 CCS->Serialize(OS); 626 delete CCS; 627 } 628} 629