CIndexCodeCompletion.cpp revision a60ed47da13393796d8552b9fdca12abbb3eea42
1//===- CIndexCodeCompletion.cpp - Code Completion API hooks ---------------===// 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 Clang-C Source Indexing library hooks for 11// code completion. 12// 13//===----------------------------------------------------------------------===// 14 15#include "CIndexer.h" 16#include "CXString.h" 17#include "CIndexDiagnostic.h" 18#include "clang/Basic/SourceManager.h" 19#include "clang/Basic/FileManager.h" 20#include "clang/Frontend/ASTUnit.h" 21#include "clang/Frontend/CompilerInstance.h" 22#include "clang/Frontend/FrontendDiagnostic.h" 23#include "clang/Sema/CodeCompleteConsumer.h" 24#include "llvm/ADT/SmallString.h" 25#include "llvm/ADT/StringExtras.h" 26#include "llvm/Support/CrashRecoveryContext.h" 27#include "llvm/Support/MemoryBuffer.h" 28#include "llvm/Support/Timer.h" 29#include "llvm/Support/raw_ostream.h" 30#include "llvm/System/Program.h" 31#include <cstdlib> 32#include <cstdio> 33 34 35#ifdef UDP_CODE_COMPLETION_LOGGER 36#include "clang/Basic/Version.h" 37#include <arpa/inet.h> 38#include <sys/socket.h> 39#include <sys/types.h> 40#include <unistd.h> 41#endif 42 43using namespace clang; 44using namespace clang::cxstring; 45 46namespace { 47 /// \brief Stored representation of a completion string. 48 /// 49 /// This is the representation behind a CXCompletionString. 50 class CXStoredCodeCompletionString : public CodeCompletionString { 51 unsigned Priority; 52 CXAvailabilityKind Availability; 53 54 public: 55 CXStoredCodeCompletionString(unsigned Priority, 56 CXAvailabilityKind Availability) 57 : Priority(Priority), Availability(Availability) { } 58 59 unsigned getPriority() const { return Priority; } 60 CXAvailabilityKind getAvailability() const { return Availability; } 61 }; 62} 63 64extern "C" { 65 66enum CXCompletionChunkKind 67clang_getCompletionChunkKind(CXCompletionString completion_string, 68 unsigned chunk_number) { 69 CXStoredCodeCompletionString *CCStr 70 = (CXStoredCodeCompletionString *)completion_string; 71 if (!CCStr || chunk_number >= CCStr->size()) 72 return CXCompletionChunk_Text; 73 74 switch ((*CCStr)[chunk_number].Kind) { 75 case CodeCompletionString::CK_TypedText: 76 return CXCompletionChunk_TypedText; 77 case CodeCompletionString::CK_Text: 78 return CXCompletionChunk_Text; 79 case CodeCompletionString::CK_Optional: 80 return CXCompletionChunk_Optional; 81 case CodeCompletionString::CK_Placeholder: 82 return CXCompletionChunk_Placeholder; 83 case CodeCompletionString::CK_Informative: 84 return CXCompletionChunk_Informative; 85 case CodeCompletionString::CK_ResultType: 86 return CXCompletionChunk_ResultType; 87 case CodeCompletionString::CK_CurrentParameter: 88 return CXCompletionChunk_CurrentParameter; 89 case CodeCompletionString::CK_LeftParen: 90 return CXCompletionChunk_LeftParen; 91 case CodeCompletionString::CK_RightParen: 92 return CXCompletionChunk_RightParen; 93 case CodeCompletionString::CK_LeftBracket: 94 return CXCompletionChunk_LeftBracket; 95 case CodeCompletionString::CK_RightBracket: 96 return CXCompletionChunk_RightBracket; 97 case CodeCompletionString::CK_LeftBrace: 98 return CXCompletionChunk_LeftBrace; 99 case CodeCompletionString::CK_RightBrace: 100 return CXCompletionChunk_RightBrace; 101 case CodeCompletionString::CK_LeftAngle: 102 return CXCompletionChunk_LeftAngle; 103 case CodeCompletionString::CK_RightAngle: 104 return CXCompletionChunk_RightAngle; 105 case CodeCompletionString::CK_Comma: 106 return CXCompletionChunk_Comma; 107 case CodeCompletionString::CK_Colon: 108 return CXCompletionChunk_Colon; 109 case CodeCompletionString::CK_SemiColon: 110 return CXCompletionChunk_SemiColon; 111 case CodeCompletionString::CK_Equal: 112 return CXCompletionChunk_Equal; 113 case CodeCompletionString::CK_HorizontalSpace: 114 return CXCompletionChunk_HorizontalSpace; 115 case CodeCompletionString::CK_VerticalSpace: 116 return CXCompletionChunk_VerticalSpace; 117 } 118 119 // Should be unreachable, but let's be careful. 120 return CXCompletionChunk_Text; 121} 122 123CXString clang_getCompletionChunkText(CXCompletionString completion_string, 124 unsigned chunk_number) { 125 CXStoredCodeCompletionString *CCStr 126 = (CXStoredCodeCompletionString *)completion_string; 127 if (!CCStr || chunk_number >= CCStr->size()) 128 return createCXString((const char*)0); 129 130 switch ((*CCStr)[chunk_number].Kind) { 131 case CodeCompletionString::CK_TypedText: 132 case CodeCompletionString::CK_Text: 133 case CodeCompletionString::CK_Placeholder: 134 case CodeCompletionString::CK_CurrentParameter: 135 case CodeCompletionString::CK_Informative: 136 case CodeCompletionString::CK_LeftParen: 137 case CodeCompletionString::CK_RightParen: 138 case CodeCompletionString::CK_LeftBracket: 139 case CodeCompletionString::CK_RightBracket: 140 case CodeCompletionString::CK_LeftBrace: 141 case CodeCompletionString::CK_RightBrace: 142 case CodeCompletionString::CK_LeftAngle: 143 case CodeCompletionString::CK_RightAngle: 144 case CodeCompletionString::CK_Comma: 145 case CodeCompletionString::CK_ResultType: 146 case CodeCompletionString::CK_Colon: 147 case CodeCompletionString::CK_SemiColon: 148 case CodeCompletionString::CK_Equal: 149 case CodeCompletionString::CK_HorizontalSpace: 150 case CodeCompletionString::CK_VerticalSpace: 151 return createCXString((*CCStr)[chunk_number].Text, false); 152 153 case CodeCompletionString::CK_Optional: 154 // Note: treated as an empty text block. 155 return createCXString(""); 156 } 157 158 // Should be unreachable, but let's be careful. 159 return createCXString((const char*)0); 160} 161 162 163CXCompletionString 164clang_getCompletionChunkCompletionString(CXCompletionString completion_string, 165 unsigned chunk_number) { 166 CXStoredCodeCompletionString *CCStr 167 = (CXStoredCodeCompletionString *)completion_string; 168 if (!CCStr || chunk_number >= CCStr->size()) 169 return 0; 170 171 switch ((*CCStr)[chunk_number].Kind) { 172 case CodeCompletionString::CK_TypedText: 173 case CodeCompletionString::CK_Text: 174 case CodeCompletionString::CK_Placeholder: 175 case CodeCompletionString::CK_CurrentParameter: 176 case CodeCompletionString::CK_Informative: 177 case CodeCompletionString::CK_LeftParen: 178 case CodeCompletionString::CK_RightParen: 179 case CodeCompletionString::CK_LeftBracket: 180 case CodeCompletionString::CK_RightBracket: 181 case CodeCompletionString::CK_LeftBrace: 182 case CodeCompletionString::CK_RightBrace: 183 case CodeCompletionString::CK_LeftAngle: 184 case CodeCompletionString::CK_RightAngle: 185 case CodeCompletionString::CK_Comma: 186 case CodeCompletionString::CK_ResultType: 187 case CodeCompletionString::CK_Colon: 188 case CodeCompletionString::CK_SemiColon: 189 case CodeCompletionString::CK_Equal: 190 case CodeCompletionString::CK_HorizontalSpace: 191 case CodeCompletionString::CK_VerticalSpace: 192 return 0; 193 194 case CodeCompletionString::CK_Optional: 195 // Note: treated as an empty text block. 196 return (*CCStr)[chunk_number].Optional; 197 } 198 199 // Should be unreachable, but let's be careful. 200 return 0; 201} 202 203unsigned clang_getNumCompletionChunks(CXCompletionString completion_string) { 204 CXStoredCodeCompletionString *CCStr 205 = (CXStoredCodeCompletionString *)completion_string; 206 return CCStr? CCStr->size() : 0; 207} 208 209unsigned clang_getCompletionPriority(CXCompletionString completion_string) { 210 CXStoredCodeCompletionString *CCStr 211 = (CXStoredCodeCompletionString *)completion_string; 212 return CCStr? CCStr->getPriority() : unsigned(CCP_Unlikely); 213} 214 215enum CXAvailabilityKind 216clang_getCompletionAvailability(CXCompletionString completion_string) { 217 CXStoredCodeCompletionString *CCStr 218 = (CXStoredCodeCompletionString *)completion_string; 219 return CCStr? CCStr->getAvailability() : CXAvailability_Available; 220} 221 222/// \brief The CXCodeCompleteResults structure we allocate internally; 223/// the client only sees the initial CXCodeCompleteResults structure. 224struct AllocatedCXCodeCompleteResults : public CXCodeCompleteResults { 225 AllocatedCXCodeCompleteResults(); 226 ~AllocatedCXCodeCompleteResults(); 227 228 /// \brief Diagnostics produced while performing code completion. 229 llvm::SmallVector<StoredDiagnostic, 8> Diagnostics; 230 231 /// \brief Diag object 232 llvm::IntrusiveRefCntPtr<Diagnostic> Diag; 233 234 /// \brief Language options used to adjust source locations. 235 LangOptions LangOpts; 236 237 /// \brief File manager, used for diagnostics. 238 FileManager FileMgr; 239 240 FileSystemOptions FileSystemOpts; 241 242 /// \brief Source manager, used for diagnostics. 243 SourceManager SourceMgr; 244 245 /// \brief Temporary files that should be removed once we have finished 246 /// with the code-completion results. 247 std::vector<llvm::sys::Path> TemporaryFiles; 248 249 /// \brief Temporary buffers that will be deleted once we have finished with the code-completion results. 250 llvm::SmallVector<const llvm::MemoryBuffer *, 1> TemporaryBuffers; 251}; 252 253AllocatedCXCodeCompleteResults::AllocatedCXCodeCompleteResults() 254 : CXCodeCompleteResults(), Diag(new Diagnostic), 255 SourceMgr(*Diag, FileMgr, FileSystemOpts) { } 256 257AllocatedCXCodeCompleteResults::~AllocatedCXCodeCompleteResults() { 258 for (unsigned I = 0, N = NumResults; I != N; ++I) 259 delete (CXStoredCodeCompletionString *)Results[I].CompletionString; 260 delete [] Results; 261 262 for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I) 263 TemporaryFiles[I].eraseFromDisk(); 264 for (unsigned I = 0, N = TemporaryBuffers.size(); I != N; ++I) 265 delete TemporaryBuffers[I]; 266} 267 268} // end extern "C" 269 270namespace { 271 class CaptureCompletionResults : public CodeCompleteConsumer { 272 AllocatedCXCodeCompleteResults &AllocatedResults; 273 llvm::SmallVector<CXCompletionResult, 16> StoredResults; 274 275 public: 276 explicit CaptureCompletionResults(AllocatedCXCodeCompleteResults &Results) 277 : CodeCompleteConsumer(true, false, true, false), 278 AllocatedResults(Results) { } 279 ~CaptureCompletionResults() { Finish(); } 280 281 virtual void ProcessCodeCompleteResults(Sema &S, 282 CodeCompletionContext Context, 283 CodeCompletionResult *Results, 284 unsigned NumResults) { 285 StoredResults.reserve(StoredResults.size() + NumResults); 286 for (unsigned I = 0; I != NumResults; ++I) { 287 CXStoredCodeCompletionString *StoredCompletion 288 = new CXStoredCodeCompletionString(Results[I].Priority, 289 Results[I].Availability); 290 (void)Results[I].CreateCodeCompletionString(S, StoredCompletion); 291 292 CXCompletionResult R; 293 R.CursorKind = Results[I].CursorKind; 294 R.CompletionString = StoredCompletion; 295 StoredResults.push_back(R); 296 } 297 } 298 299 virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, 300 OverloadCandidate *Candidates, 301 unsigned NumCandidates) { 302 StoredResults.reserve(StoredResults.size() + NumCandidates); 303 for (unsigned I = 0; I != NumCandidates; ++I) { 304 // FIXME: Set priority, availability appropriately. 305 CXStoredCodeCompletionString *StoredCompletion 306 = new CXStoredCodeCompletionString(1, CXAvailability_Available); 307 (void)Candidates[I].CreateSignatureString(CurrentArg, S, 308 StoredCompletion); 309 310 CXCompletionResult R; 311 R.CursorKind = CXCursor_NotImplemented; 312 R.CompletionString = StoredCompletion; 313 StoredResults.push_back(R); 314 } 315 } 316 317 private: 318 void Finish() { 319 AllocatedResults.Results = new CXCompletionResult [StoredResults.size()]; 320 AllocatedResults.NumResults = StoredResults.size(); 321 std::memcpy(AllocatedResults.Results, StoredResults.data(), 322 StoredResults.size() * sizeof(CXCompletionResult)); 323 StoredResults.clear(); 324 } 325 }; 326} 327 328extern "C" { 329struct CodeCompleteAtInfo { 330 CXTranslationUnit TU; 331 const char *complete_filename; 332 unsigned complete_line; 333 unsigned complete_column; 334 struct CXUnsavedFile *unsaved_files; 335 unsigned num_unsaved_files; 336 unsigned options; 337 CXCodeCompleteResults *result; 338}; 339void clang_codeCompleteAt_Impl(void *UserData) { 340 CodeCompleteAtInfo *CCAI = static_cast<CodeCompleteAtInfo*>(UserData); 341 CXTranslationUnit TU = CCAI->TU; 342 const char *complete_filename = CCAI->complete_filename; 343 unsigned complete_line = CCAI->complete_line; 344 unsigned complete_column = CCAI->complete_column; 345 struct CXUnsavedFile *unsaved_files = CCAI->unsaved_files; 346 unsigned num_unsaved_files = CCAI->num_unsaved_files; 347 unsigned options = CCAI->options; 348 CCAI->result = 0; 349 350#ifdef UDP_CODE_COMPLETION_LOGGER 351#ifdef UDP_CODE_COMPLETION_LOGGER_PORT 352 const llvm::TimeRecord &StartTime = llvm::TimeRecord::getCurrentTime(); 353#endif 354#endif 355 356 bool EnableLogging = getenv("LIBCLANG_CODE_COMPLETION_LOGGING") != 0; 357 358 ASTUnit *AST = static_cast<ASTUnit *>(TU->TUData); 359 if (!AST) 360 return; 361 362 ASTUnit::ConcurrencyCheck Check(*AST); 363 364 // Perform the remapping of source files. 365 llvm::SmallVector<ASTUnit::RemappedFile, 4> RemappedFiles; 366 for (unsigned I = 0; I != num_unsaved_files; ++I) { 367 llvm::StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length); 368 const llvm::MemoryBuffer *Buffer 369 = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename); 370 RemappedFiles.push_back(std::make_pair(unsaved_files[I].Filename, 371 Buffer)); 372 } 373 374 if (EnableLogging) { 375 // FIXME: Add logging. 376 } 377 378 // Parse the resulting source file to find code-completion results. 379 AllocatedCXCodeCompleteResults *Results = new AllocatedCXCodeCompleteResults; 380 Results->Results = 0; 381 Results->NumResults = 0; 382 383 // Create a code-completion consumer to capture the results. 384 CaptureCompletionResults Capture(*Results); 385 386 // Perform completion. 387 AST->CodeComplete(complete_filename, complete_line, complete_column, 388 RemappedFiles.data(), RemappedFiles.size(), 389 (options & CXCodeComplete_IncludeMacros), 390 (options & CXCodeComplete_IncludeCodePatterns), 391 Capture, 392 *Results->Diag, Results->LangOpts, Results->SourceMgr, 393 Results->FileMgr, Results->Diagnostics, 394 Results->TemporaryBuffers); 395 396 397 398#ifdef UDP_CODE_COMPLETION_LOGGER 399#ifdef UDP_CODE_COMPLETION_LOGGER_PORT 400 const llvm::TimeRecord &EndTime = llvm::TimeRecord::getCurrentTime(); 401 llvm::SmallString<256> LogResult; 402 llvm::raw_svector_ostream os(LogResult); 403 404 // Figure out the language and whether or not it uses PCH. 405 const char *lang = 0; 406 bool usesPCH = false; 407 408 for (std::vector<const char*>::iterator I = argv.begin(), E = argv.end(); 409 I != E; ++I) { 410 if (*I == 0) 411 continue; 412 if (strcmp(*I, "-x") == 0) { 413 if (I + 1 != E) { 414 lang = *(++I); 415 continue; 416 } 417 } 418 else if (strcmp(*I, "-include") == 0) { 419 if (I+1 != E) { 420 const char *arg = *(++I); 421 llvm::SmallString<512> pchName; 422 { 423 llvm::raw_svector_ostream os(pchName); 424 os << arg << ".pth"; 425 } 426 pchName.push_back('\0'); 427 struct stat stat_results; 428 if (stat(pchName.data(), &stat_results) == 0) 429 usesPCH = true; 430 continue; 431 } 432 } 433 } 434 435 os << "{ "; 436 os << "\"wall\": " << (EndTime.getWallTime() - StartTime.getWallTime()); 437 os << ", \"numRes\": " << Results->NumResults; 438 os << ", \"diags\": " << Results->Diagnostics.size(); 439 os << ", \"pch\": " << (usesPCH ? "true" : "false"); 440 os << ", \"lang\": \"" << (lang ? lang : "<unknown>") << '"'; 441 const char *name = getlogin(); 442 os << ", \"user\": \"" << (name ? name : "unknown") << '"'; 443 os << ", \"clangVer\": \"" << getClangFullVersion() << '"'; 444 os << " }"; 445 446 llvm::StringRef res = os.str(); 447 if (res.size() > 0) { 448 do { 449 // Setup the UDP socket. 450 struct sockaddr_in servaddr; 451 bzero(&servaddr, sizeof(servaddr)); 452 servaddr.sin_family = AF_INET; 453 servaddr.sin_port = htons(UDP_CODE_COMPLETION_LOGGER_PORT); 454 if (inet_pton(AF_INET, UDP_CODE_COMPLETION_LOGGER, 455 &servaddr.sin_addr) <= 0) 456 break; 457 458 int sockfd = socket(AF_INET, SOCK_DGRAM, 0); 459 if (sockfd < 0) 460 break; 461 462 sendto(sockfd, res.data(), res.size(), 0, 463 (struct sockaddr *)&servaddr, sizeof(servaddr)); 464 close(sockfd); 465 } 466 while (false); 467 } 468#endif 469#endif 470 CCAI->result = Results; 471} 472CXCodeCompleteResults *clang_codeCompleteAt(CXTranslationUnit TU, 473 const char *complete_filename, 474 unsigned complete_line, 475 unsigned complete_column, 476 struct CXUnsavedFile *unsaved_files, 477 unsigned num_unsaved_files, 478 unsigned options) { 479 CodeCompleteAtInfo CCAI = { TU, complete_filename, complete_line, 480 complete_column, unsaved_files, num_unsaved_files, 481 options, 0 }; 482 llvm::CrashRecoveryContext CRC; 483 484 if (!RunSafely(CRC, clang_codeCompleteAt_Impl, &CCAI)) { 485 fprintf(stderr, "libclang: crash detected in code completion\n"); 486 static_cast<ASTUnit *>(TU->TUData)->setUnsafeToFree(true); 487 return 0; 488 } 489 490 return CCAI.result; 491} 492 493unsigned clang_defaultCodeCompleteOptions(void) { 494 return CXCodeComplete_IncludeMacros; 495} 496 497void clang_disposeCodeCompleteResults(CXCodeCompleteResults *ResultsIn) { 498 if (!ResultsIn) 499 return; 500 501 AllocatedCXCodeCompleteResults *Results 502 = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn); 503 delete Results; 504} 505 506unsigned 507clang_codeCompleteGetNumDiagnostics(CXCodeCompleteResults *ResultsIn) { 508 AllocatedCXCodeCompleteResults *Results 509 = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn); 510 if (!Results) 511 return 0; 512 513 return Results->Diagnostics.size(); 514} 515 516CXDiagnostic 517clang_codeCompleteGetDiagnostic(CXCodeCompleteResults *ResultsIn, 518 unsigned Index) { 519 AllocatedCXCodeCompleteResults *Results 520 = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn); 521 if (!Results || Index >= Results->Diagnostics.size()) 522 return 0; 523 524 return new CXStoredDiagnostic(Results->Diagnostics[Index], Results->LangOpts); 525} 526 527 528} // end extern "C" 529 530/// \brief Simple utility function that appends a \p New string to the given 531/// \p Old string, using the \p Buffer for storage. 532/// 533/// \param Old The string to which we are appending. This parameter will be 534/// updated to reflect the complete string. 535/// 536/// 537/// \param New The string to append to \p Old. 538/// 539/// \param Buffer A buffer that stores the actual, concatenated string. It will 540/// be used if the old string is already-non-empty. 541static void AppendToString(llvm::StringRef &Old, llvm::StringRef New, 542 llvm::SmallString<256> &Buffer) { 543 if (Old.empty()) { 544 Old = New; 545 return; 546 } 547 548 if (Buffer.empty()) 549 Buffer.append(Old.begin(), Old.end()); 550 Buffer.append(New.begin(), New.end()); 551 Old = Buffer.str(); 552} 553 554/// \brief Get the typed-text blocks from the given code-completion string 555/// and return them as a single string. 556/// 557/// \param String The code-completion string whose typed-text blocks will be 558/// concatenated. 559/// 560/// \param Buffer A buffer used for storage of the completed name. 561static llvm::StringRef GetTypedName(CodeCompletionString *String, 562 llvm::SmallString<256> &Buffer) { 563 llvm::StringRef Result; 564 for (CodeCompletionString::iterator C = String->begin(), CEnd = String->end(); 565 C != CEnd; ++C) { 566 if (C->Kind == CodeCompletionString::CK_TypedText) 567 AppendToString(Result, C->Text, Buffer); 568 } 569 570 return Result; 571} 572 573namespace { 574 struct OrderCompletionResults { 575 bool operator()(const CXCompletionResult &XR, 576 const CXCompletionResult &YR) const { 577 CXStoredCodeCompletionString *X 578 = (CXStoredCodeCompletionString *)XR.CompletionString; 579 CXStoredCodeCompletionString *Y 580 = (CXStoredCodeCompletionString *)YR.CompletionString; 581 582 llvm::SmallString<256> XBuffer; 583 llvm::StringRef XText = GetTypedName(X, XBuffer); 584 llvm::SmallString<256> YBuffer; 585 llvm::StringRef YText = GetTypedName(Y, YBuffer); 586 587 if (XText.empty() || YText.empty()) 588 return !XText.empty(); 589 590 int result = XText.compare_lower(YText); 591 if (result < 0) 592 return true; 593 if (result > 0) 594 return false; 595 596 result = XText.compare(YText); 597 return result < 0; 598 } 599 }; 600} 601 602extern "C" { 603 void clang_sortCodeCompletionResults(CXCompletionResult *Results, 604 unsigned NumResults) { 605 std::stable_sort(Results, Results + NumResults, OrderCompletionResults()); 606 } 607} 608