1 //===- CIndexCodeCompletion.cpp - Code Completion API hooks ---------------===// 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 Clang-C Source Indexing library hooks for 10 // code completion. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "CIndexDiagnostic.h" 15 #include "CIndexer.h" 16 #include "CLog.h" 17 #include "CXCursor.h" 18 #include "CXSourceLocation.h" 19 #include "CXString.h" 20 #include "CXTranslationUnit.h" 21 #include "clang/AST/Decl.h" 22 #include "clang/AST/DeclObjC.h" 23 #include "clang/AST/Type.h" 24 #include "clang/Basic/FileManager.h" 25 #include "clang/Basic/SourceManager.h" 26 #include "clang/Frontend/ASTUnit.h" 27 #include "clang/Frontend/CompilerInstance.h" 28 #include "clang/Frontend/FrontendActions.h" 29 #include "clang/Sema/CodeCompleteConsumer.h" 30 #include "clang/Sema/Sema.h" 31 #include "llvm/ADT/SmallString.h" 32 #include "llvm/ADT/StringExtras.h" 33 #include "llvm/Support/CrashRecoveryContext.h" 34 #include "llvm/Support/FileSystem.h" 35 #include "llvm/Support/FormatVariadic.h" 36 #include "llvm/Support/MemoryBuffer.h" 37 #include "llvm/Support/Program.h" 38 #include "llvm/Support/Timer.h" 39 #include "llvm/Support/raw_ostream.h" 40 #include <atomic> 41 #include <cstdio> 42 #include <cstdlib> 43 #include <string> 44 45 #ifdef UDP_CODE_COMPLETION_LOGGER 46 #include "clang/Basic/Version.h" 47 #include <arpa/inet.h> 48 #include <sys/socket.h> 49 #include <sys/types.h> 50 #include <unistd.h> 51 #endif 52 53 using namespace clang; 54 using namespace clang::cxindex; 55 56 enum CXCompletionChunkKind 57 clang_getCompletionChunkKind(CXCompletionString completion_string, 58 unsigned chunk_number) { 59 CodeCompletionString *CCStr = (CodeCompletionString *)completion_string; 60 if (!CCStr || chunk_number >= CCStr->size()) 61 return CXCompletionChunk_Text; 62 63 switch ((*CCStr)[chunk_number].Kind) { 64 case CodeCompletionString::CK_TypedText: 65 return CXCompletionChunk_TypedText; 66 case CodeCompletionString::CK_Text: 67 return CXCompletionChunk_Text; 68 case CodeCompletionString::CK_Optional: 69 return CXCompletionChunk_Optional; 70 case CodeCompletionString::CK_Placeholder: 71 return CXCompletionChunk_Placeholder; 72 case CodeCompletionString::CK_Informative: 73 return CXCompletionChunk_Informative; 74 case CodeCompletionString::CK_ResultType: 75 return CXCompletionChunk_ResultType; 76 case CodeCompletionString::CK_CurrentParameter: 77 return CXCompletionChunk_CurrentParameter; 78 case CodeCompletionString::CK_LeftParen: 79 return CXCompletionChunk_LeftParen; 80 case CodeCompletionString::CK_RightParen: 81 return CXCompletionChunk_RightParen; 82 case CodeCompletionString::CK_LeftBracket: 83 return CXCompletionChunk_LeftBracket; 84 case CodeCompletionString::CK_RightBracket: 85 return CXCompletionChunk_RightBracket; 86 case CodeCompletionString::CK_LeftBrace: 87 return CXCompletionChunk_LeftBrace; 88 case CodeCompletionString::CK_RightBrace: 89 return CXCompletionChunk_RightBrace; 90 case CodeCompletionString::CK_LeftAngle: 91 return CXCompletionChunk_LeftAngle; 92 case CodeCompletionString::CK_RightAngle: 93 return CXCompletionChunk_RightAngle; 94 case CodeCompletionString::CK_Comma: 95 return CXCompletionChunk_Comma; 96 case CodeCompletionString::CK_Colon: 97 return CXCompletionChunk_Colon; 98 case CodeCompletionString::CK_SemiColon: 99 return CXCompletionChunk_SemiColon; 100 case CodeCompletionString::CK_Equal: 101 return CXCompletionChunk_Equal; 102 case CodeCompletionString::CK_HorizontalSpace: 103 return CXCompletionChunk_HorizontalSpace; 104 case CodeCompletionString::CK_VerticalSpace: 105 return CXCompletionChunk_VerticalSpace; 106 } 107 108 llvm_unreachable("Invalid CompletionKind!"); 109 } 110 111 CXString clang_getCompletionChunkText(CXCompletionString completion_string, 112 unsigned chunk_number) { 113 CodeCompletionString *CCStr = (CodeCompletionString *)completion_string; 114 if (!CCStr || chunk_number >= CCStr->size()) 115 return cxstring::createNull(); 116 117 switch ((*CCStr)[chunk_number].Kind) { 118 case CodeCompletionString::CK_TypedText: 119 case CodeCompletionString::CK_Text: 120 case CodeCompletionString::CK_Placeholder: 121 case CodeCompletionString::CK_CurrentParameter: 122 case CodeCompletionString::CK_Informative: 123 case CodeCompletionString::CK_LeftParen: 124 case CodeCompletionString::CK_RightParen: 125 case CodeCompletionString::CK_LeftBracket: 126 case CodeCompletionString::CK_RightBracket: 127 case CodeCompletionString::CK_LeftBrace: 128 case CodeCompletionString::CK_RightBrace: 129 case CodeCompletionString::CK_LeftAngle: 130 case CodeCompletionString::CK_RightAngle: 131 case CodeCompletionString::CK_Comma: 132 case CodeCompletionString::CK_ResultType: 133 case CodeCompletionString::CK_Colon: 134 case CodeCompletionString::CK_SemiColon: 135 case CodeCompletionString::CK_Equal: 136 case CodeCompletionString::CK_HorizontalSpace: 137 case CodeCompletionString::CK_VerticalSpace: 138 return cxstring::createRef((*CCStr)[chunk_number].Text); 139 140 case CodeCompletionString::CK_Optional: 141 // Note: treated as an empty text block. 142 return cxstring::createEmpty(); 143 } 144 145 llvm_unreachable("Invalid CodeCompletionString Kind!"); 146 } 147 148 149 CXCompletionString 150 clang_getCompletionChunkCompletionString(CXCompletionString completion_string, 151 unsigned chunk_number) { 152 CodeCompletionString *CCStr = (CodeCompletionString *)completion_string; 153 if (!CCStr || chunk_number >= CCStr->size()) 154 return nullptr; 155 156 switch ((*CCStr)[chunk_number].Kind) { 157 case CodeCompletionString::CK_TypedText: 158 case CodeCompletionString::CK_Text: 159 case CodeCompletionString::CK_Placeholder: 160 case CodeCompletionString::CK_CurrentParameter: 161 case CodeCompletionString::CK_Informative: 162 case CodeCompletionString::CK_LeftParen: 163 case CodeCompletionString::CK_RightParen: 164 case CodeCompletionString::CK_LeftBracket: 165 case CodeCompletionString::CK_RightBracket: 166 case CodeCompletionString::CK_LeftBrace: 167 case CodeCompletionString::CK_RightBrace: 168 case CodeCompletionString::CK_LeftAngle: 169 case CodeCompletionString::CK_RightAngle: 170 case CodeCompletionString::CK_Comma: 171 case CodeCompletionString::CK_ResultType: 172 case CodeCompletionString::CK_Colon: 173 case CodeCompletionString::CK_SemiColon: 174 case CodeCompletionString::CK_Equal: 175 case CodeCompletionString::CK_HorizontalSpace: 176 case CodeCompletionString::CK_VerticalSpace: 177 return nullptr; 178 179 case CodeCompletionString::CK_Optional: 180 // Note: treated as an empty text block. 181 return (*CCStr)[chunk_number].Optional; 182 } 183 184 llvm_unreachable("Invalid CompletionKind!"); 185 } 186 187 unsigned clang_getNumCompletionChunks(CXCompletionString completion_string) { 188 CodeCompletionString *CCStr = (CodeCompletionString *)completion_string; 189 return CCStr? CCStr->size() : 0; 190 } 191 192 unsigned clang_getCompletionPriority(CXCompletionString completion_string) { 193 CodeCompletionString *CCStr = (CodeCompletionString *)completion_string; 194 return CCStr? CCStr->getPriority() : unsigned(CCP_Unlikely); 195 } 196 197 enum CXAvailabilityKind 198 clang_getCompletionAvailability(CXCompletionString completion_string) { 199 CodeCompletionString *CCStr = (CodeCompletionString *)completion_string; 200 return CCStr? static_cast<CXAvailabilityKind>(CCStr->getAvailability()) 201 : CXAvailability_Available; 202 } 203 204 unsigned clang_getCompletionNumAnnotations(CXCompletionString completion_string) 205 { 206 CodeCompletionString *CCStr = (CodeCompletionString *)completion_string; 207 return CCStr ? CCStr->getAnnotationCount() : 0; 208 } 209 210 CXString clang_getCompletionAnnotation(CXCompletionString completion_string, 211 unsigned annotation_number) { 212 CodeCompletionString *CCStr = (CodeCompletionString *)completion_string; 213 return CCStr ? cxstring::createRef(CCStr->getAnnotation(annotation_number)) 214 : cxstring::createNull(); 215 } 216 217 CXString 218 clang_getCompletionParent(CXCompletionString completion_string, 219 CXCursorKind *kind) { 220 if (kind) 221 *kind = CXCursor_NotImplemented; 222 223 CodeCompletionString *CCStr = (CodeCompletionString *)completion_string; 224 if (!CCStr) 225 return cxstring::createNull(); 226 227 return cxstring::createRef(CCStr->getParentContextName()); 228 } 229 230 CXString 231 clang_getCompletionBriefComment(CXCompletionString completion_string) { 232 CodeCompletionString *CCStr = (CodeCompletionString *)completion_string; 233 234 if (!CCStr) 235 return cxstring::createNull(); 236 237 return cxstring::createRef(CCStr->getBriefComment()); 238 } 239 240 namespace { 241 242 /// The CXCodeCompleteResults structure we allocate internally; 243 /// the client only sees the initial CXCodeCompleteResults structure. 244 /// 245 /// Normally, clients of CXString shouldn't care whether or not a CXString is 246 /// managed by a pool or by explicitly malloc'ed memory. But 247 /// AllocatedCXCodeCompleteResults outlives the CXTranslationUnit, so we can 248 /// not rely on the StringPool in the TU. 249 struct AllocatedCXCodeCompleteResults : public CXCodeCompleteResults { 250 AllocatedCXCodeCompleteResults(IntrusiveRefCntPtr<FileManager> FileMgr); 251 ~AllocatedCXCodeCompleteResults(); 252 253 /// Diagnostics produced while performing code completion. 254 SmallVector<StoredDiagnostic, 8> Diagnostics; 255 256 /// Allocated API-exposed wrappters for Diagnostics. 257 SmallVector<std::unique_ptr<CXStoredDiagnostic>, 8> DiagnosticsWrappers; 258 259 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts; 260 261 /// Diag object 262 IntrusiveRefCntPtr<DiagnosticsEngine> Diag; 263 264 /// Language options used to adjust source locations. 265 LangOptions LangOpts; 266 267 /// File manager, used for diagnostics. 268 IntrusiveRefCntPtr<FileManager> FileMgr; 269 270 /// Source manager, used for diagnostics. 271 IntrusiveRefCntPtr<SourceManager> SourceMgr; 272 273 /// Temporary buffers that will be deleted once we have finished with 274 /// the code-completion results. 275 SmallVector<const llvm::MemoryBuffer *, 1> TemporaryBuffers; 276 277 /// Allocator used to store globally cached code-completion results. 278 std::shared_ptr<clang::GlobalCodeCompletionAllocator> 279 CachedCompletionAllocator; 280 281 /// Allocator used to store code completion results. 282 std::shared_ptr<clang::GlobalCodeCompletionAllocator> CodeCompletionAllocator; 283 284 /// Context under which completion occurred. 285 enum clang::CodeCompletionContext::Kind ContextKind; 286 287 /// A bitfield representing the acceptable completions for the 288 /// current context. 289 unsigned long long Contexts; 290 291 /// The kind of the container for the current context for completions. 292 enum CXCursorKind ContainerKind; 293 294 /// The USR of the container for the current context for completions. 295 std::string ContainerUSR; 296 297 /// a boolean value indicating whether there is complete information 298 /// about the container 299 unsigned ContainerIsIncomplete; 300 301 /// A string containing the Objective-C selector entered thus far for a 302 /// message send. 303 std::string Selector; 304 305 /// Vector of fix-its for each completion result that *must* be applied 306 /// before that result for the corresponding completion item. 307 std::vector<std::vector<FixItHint>> FixItsVector; 308 }; 309 310 } // end anonymous namespace 311 312 unsigned clang_getCompletionNumFixIts(CXCodeCompleteResults *results, 313 unsigned completion_index) { 314 AllocatedCXCodeCompleteResults *allocated_results = (AllocatedCXCodeCompleteResults *)results; 315 316 if (!allocated_results || allocated_results->FixItsVector.size() <= completion_index) 317 return 0; 318 319 return static_cast<unsigned>(allocated_results->FixItsVector[completion_index].size()); 320 } 321 322 CXString clang_getCompletionFixIt(CXCodeCompleteResults *results, 323 unsigned completion_index, 324 unsigned fixit_index, 325 CXSourceRange *replacement_range) { 326 AllocatedCXCodeCompleteResults *allocated_results = (AllocatedCXCodeCompleteResults *)results; 327 328 if (!allocated_results || allocated_results->FixItsVector.size() <= completion_index) { 329 if (replacement_range) 330 *replacement_range = clang_getNullRange(); 331 return cxstring::createNull(); 332 } 333 334 ArrayRef<FixItHint> FixIts = allocated_results->FixItsVector[completion_index]; 335 if (FixIts.size() <= fixit_index) { 336 if (replacement_range) 337 *replacement_range = clang_getNullRange(); 338 return cxstring::createNull(); 339 } 340 341 const FixItHint &FixIt = FixIts[fixit_index]; 342 if (replacement_range) { 343 *replacement_range = cxloc::translateSourceRange( 344 *allocated_results->SourceMgr, allocated_results->LangOpts, 345 FixIt.RemoveRange); 346 } 347 348 return cxstring::createRef(FixIt.CodeToInsert.c_str()); 349 } 350 351 /// Tracks the number of code-completion result objects that are 352 /// currently active. 353 /// 354 /// Used for debugging purposes only. 355 static std::atomic<unsigned> CodeCompletionResultObjects; 356 357 AllocatedCXCodeCompleteResults::AllocatedCXCodeCompleteResults( 358 IntrusiveRefCntPtr<FileManager> FileMgr) 359 : CXCodeCompleteResults(), DiagOpts(new DiagnosticOptions), 360 Diag(new DiagnosticsEngine( 361 IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts)), 362 FileMgr(std::move(FileMgr)), 363 SourceMgr(new SourceManager(*Diag, *this->FileMgr)), 364 CodeCompletionAllocator( 365 std::make_shared<clang::GlobalCodeCompletionAllocator>()), 366 Contexts(CXCompletionContext_Unknown), 367 ContainerKind(CXCursor_InvalidCode), ContainerIsIncomplete(1) { 368 if (getenv("LIBCLANG_OBJTRACKING")) 369 fprintf(stderr, "+++ %u completion results\n", 370 ++CodeCompletionResultObjects); 371 } 372 373 AllocatedCXCodeCompleteResults::~AllocatedCXCodeCompleteResults() { 374 delete [] Results; 375 376 for (unsigned I = 0, N = TemporaryBuffers.size(); I != N; ++I) 377 delete TemporaryBuffers[I]; 378 379 if (getenv("LIBCLANG_OBJTRACKING")) 380 fprintf(stderr, "--- %u completion results\n", 381 --CodeCompletionResultObjects); 382 } 383 384 static unsigned long long getContextsForContextKind( 385 enum CodeCompletionContext::Kind kind, 386 Sema &S) { 387 unsigned long long contexts = 0; 388 switch (kind) { 389 case CodeCompletionContext::CCC_OtherWithMacros: { 390 //We can allow macros here, but we don't know what else is permissible 391 //So we'll say the only thing permissible are macros 392 contexts = CXCompletionContext_MacroName; 393 break; 394 } 395 case CodeCompletionContext::CCC_TopLevel: 396 case CodeCompletionContext::CCC_ObjCIvarList: 397 case CodeCompletionContext::CCC_ClassStructUnion: 398 case CodeCompletionContext::CCC_Type: { 399 contexts = CXCompletionContext_AnyType | 400 CXCompletionContext_ObjCInterface; 401 if (S.getLangOpts().CPlusPlus) { 402 contexts |= CXCompletionContext_EnumTag | 403 CXCompletionContext_UnionTag | 404 CXCompletionContext_StructTag | 405 CXCompletionContext_ClassTag | 406 CXCompletionContext_NestedNameSpecifier; 407 } 408 break; 409 } 410 case CodeCompletionContext::CCC_Statement: { 411 contexts = CXCompletionContext_AnyType | 412 CXCompletionContext_ObjCInterface | 413 CXCompletionContext_AnyValue; 414 if (S.getLangOpts().CPlusPlus) { 415 contexts |= CXCompletionContext_EnumTag | 416 CXCompletionContext_UnionTag | 417 CXCompletionContext_StructTag | 418 CXCompletionContext_ClassTag | 419 CXCompletionContext_NestedNameSpecifier; 420 } 421 break; 422 } 423 case CodeCompletionContext::CCC_Expression: { 424 contexts = CXCompletionContext_AnyValue; 425 if (S.getLangOpts().CPlusPlus) { 426 contexts |= CXCompletionContext_AnyType | 427 CXCompletionContext_ObjCInterface | 428 CXCompletionContext_EnumTag | 429 CXCompletionContext_UnionTag | 430 CXCompletionContext_StructTag | 431 CXCompletionContext_ClassTag | 432 CXCompletionContext_NestedNameSpecifier; 433 } 434 break; 435 } 436 case CodeCompletionContext::CCC_ObjCMessageReceiver: { 437 contexts = CXCompletionContext_ObjCObjectValue | 438 CXCompletionContext_ObjCSelectorValue | 439 CXCompletionContext_ObjCInterface; 440 if (S.getLangOpts().CPlusPlus) { 441 contexts |= CXCompletionContext_CXXClassTypeValue | 442 CXCompletionContext_AnyType | 443 CXCompletionContext_EnumTag | 444 CXCompletionContext_UnionTag | 445 CXCompletionContext_StructTag | 446 CXCompletionContext_ClassTag | 447 CXCompletionContext_NestedNameSpecifier; 448 } 449 break; 450 } 451 case CodeCompletionContext::CCC_DotMemberAccess: { 452 contexts = CXCompletionContext_DotMemberAccess; 453 break; 454 } 455 case CodeCompletionContext::CCC_ArrowMemberAccess: { 456 contexts = CXCompletionContext_ArrowMemberAccess; 457 break; 458 } 459 case CodeCompletionContext::CCC_ObjCPropertyAccess: { 460 contexts = CXCompletionContext_ObjCPropertyAccess; 461 break; 462 } 463 case CodeCompletionContext::CCC_EnumTag: { 464 contexts = CXCompletionContext_EnumTag | 465 CXCompletionContext_NestedNameSpecifier; 466 break; 467 } 468 case CodeCompletionContext::CCC_UnionTag: { 469 contexts = CXCompletionContext_UnionTag | 470 CXCompletionContext_NestedNameSpecifier; 471 break; 472 } 473 case CodeCompletionContext::CCC_ClassOrStructTag: { 474 contexts = CXCompletionContext_StructTag | 475 CXCompletionContext_ClassTag | 476 CXCompletionContext_NestedNameSpecifier; 477 break; 478 } 479 case CodeCompletionContext::CCC_ObjCProtocolName: { 480 contexts = CXCompletionContext_ObjCProtocol; 481 break; 482 } 483 case CodeCompletionContext::CCC_Namespace: { 484 contexts = CXCompletionContext_Namespace; 485 break; 486 } 487 case CodeCompletionContext::CCC_SymbolOrNewName: 488 case CodeCompletionContext::CCC_Symbol: { 489 contexts = CXCompletionContext_NestedNameSpecifier; 490 break; 491 } 492 case CodeCompletionContext::CCC_MacroNameUse: { 493 contexts = CXCompletionContext_MacroName; 494 break; 495 } 496 case CodeCompletionContext::CCC_NaturalLanguage: { 497 contexts = CXCompletionContext_NaturalLanguage; 498 break; 499 } 500 case CodeCompletionContext::CCC_IncludedFile: { 501 contexts = CXCompletionContext_IncludedFile; 502 break; 503 } 504 case CodeCompletionContext::CCC_SelectorName: { 505 contexts = CXCompletionContext_ObjCSelectorName; 506 break; 507 } 508 case CodeCompletionContext::CCC_ParenthesizedExpression: { 509 contexts = CXCompletionContext_AnyType | 510 CXCompletionContext_ObjCInterface | 511 CXCompletionContext_AnyValue; 512 if (S.getLangOpts().CPlusPlus) { 513 contexts |= CXCompletionContext_EnumTag | 514 CXCompletionContext_UnionTag | 515 CXCompletionContext_StructTag | 516 CXCompletionContext_ClassTag | 517 CXCompletionContext_NestedNameSpecifier; 518 } 519 break; 520 } 521 case CodeCompletionContext::CCC_ObjCInstanceMessage: { 522 contexts = CXCompletionContext_ObjCInstanceMessage; 523 break; 524 } 525 case CodeCompletionContext::CCC_ObjCClassMessage: { 526 contexts = CXCompletionContext_ObjCClassMessage; 527 break; 528 } 529 case CodeCompletionContext::CCC_ObjCInterfaceName: { 530 contexts = CXCompletionContext_ObjCInterface; 531 break; 532 } 533 case CodeCompletionContext::CCC_ObjCCategoryName: { 534 contexts = CXCompletionContext_ObjCCategory; 535 break; 536 } 537 case CodeCompletionContext::CCC_Other: 538 case CodeCompletionContext::CCC_ObjCInterface: 539 case CodeCompletionContext::CCC_ObjCImplementation: 540 case CodeCompletionContext::CCC_ObjCClassForwardDecl: 541 case CodeCompletionContext::CCC_NewName: 542 case CodeCompletionContext::CCC_MacroName: 543 case CodeCompletionContext::CCC_PreprocessorExpression: 544 case CodeCompletionContext::CCC_PreprocessorDirective: 545 case CodeCompletionContext::CCC_Attribute: 546 case CodeCompletionContext::CCC_TopLevelOrExpression: 547 case CodeCompletionContext::CCC_TypeQualifiers: { 548 //Only Clang results should be accepted, so we'll set all of the other 549 //context bits to 0 (i.e. the empty set) 550 contexts = CXCompletionContext_Unexposed; 551 break; 552 } 553 case CodeCompletionContext::CCC_Recovery: { 554 //We don't know what the current context is, so we'll return unknown 555 //This is the equivalent of setting all of the other context bits 556 contexts = CXCompletionContext_Unknown; 557 break; 558 } 559 } 560 return contexts; 561 } 562 563 namespace { 564 class CaptureCompletionResults : public CodeCompleteConsumer { 565 AllocatedCXCodeCompleteResults &AllocatedResults; 566 CodeCompletionTUInfo CCTUInfo; 567 SmallVector<CXCompletionResult, 16> StoredResults; 568 CXTranslationUnit *TU; 569 public: 570 CaptureCompletionResults(const CodeCompleteOptions &Opts, 571 AllocatedCXCodeCompleteResults &Results, 572 CXTranslationUnit *TranslationUnit) 573 : CodeCompleteConsumer(Opts), AllocatedResults(Results), 574 CCTUInfo(Results.CodeCompletionAllocator), TU(TranslationUnit) {} 575 ~CaptureCompletionResults() override { Finish(); } 576 577 void ProcessCodeCompleteResults(Sema &S, 578 CodeCompletionContext Context, 579 CodeCompletionResult *Results, 580 unsigned NumResults) override { 581 StoredResults.reserve(StoredResults.size() + NumResults); 582 if (includeFixIts()) 583 AllocatedResults.FixItsVector.reserve(NumResults); 584 for (unsigned I = 0; I != NumResults; ++I) { 585 CodeCompletionString *StoredCompletion 586 = Results[I].CreateCodeCompletionString(S, Context, getAllocator(), 587 getCodeCompletionTUInfo(), 588 includeBriefComments()); 589 590 CXCompletionResult R; 591 R.CursorKind = Results[I].CursorKind; 592 R.CompletionString = StoredCompletion; 593 StoredResults.push_back(R); 594 if (includeFixIts()) 595 AllocatedResults.FixItsVector.emplace_back(std::move(Results[I].FixIts)); 596 } 597 598 enum CodeCompletionContext::Kind contextKind = Context.getKind(); 599 600 AllocatedResults.ContextKind = contextKind; 601 AllocatedResults.Contexts = getContextsForContextKind(contextKind, S); 602 603 AllocatedResults.Selector = ""; 604 ArrayRef<IdentifierInfo *> SelIdents = Context.getSelIdents(); 605 for (ArrayRef<IdentifierInfo *>::iterator I = SelIdents.begin(), 606 E = SelIdents.end(); 607 I != E; ++I) { 608 if (IdentifierInfo *selIdent = *I) 609 AllocatedResults.Selector += selIdent->getName(); 610 AllocatedResults.Selector += ":"; 611 } 612 613 QualType baseType = Context.getBaseType(); 614 NamedDecl *D = nullptr; 615 616 if (!baseType.isNull()) { 617 // Get the declaration for a class/struct/union/enum type 618 if (const TagType *Tag = baseType->getAs<TagType>()) 619 D = Tag->getDecl(); 620 // Get the @interface declaration for a (possibly-qualified) Objective-C 621 // object pointer type, e.g., NSString* 622 else if (const ObjCObjectPointerType *ObjPtr = 623 baseType->getAs<ObjCObjectPointerType>()) 624 D = ObjPtr->getInterfaceDecl(); 625 // Get the @interface declaration for an Objective-C object type 626 else if (const ObjCObjectType *Obj = baseType->getAs<ObjCObjectType>()) 627 D = Obj->getInterface(); 628 // Get the class for a C++ injected-class-name 629 else if (const InjectedClassNameType *Injected = 630 baseType->getAs<InjectedClassNameType>()) 631 D = Injected->getDecl(); 632 } 633 634 if (D != nullptr) { 635 CXCursor cursor = cxcursor::MakeCXCursor(D, *TU); 636 637 AllocatedResults.ContainerKind = clang_getCursorKind(cursor); 638 639 CXString CursorUSR = clang_getCursorUSR(cursor); 640 AllocatedResults.ContainerUSR = clang_getCString(CursorUSR); 641 clang_disposeString(CursorUSR); 642 643 const Type *type = baseType.getTypePtrOrNull(); 644 if (type) { 645 AllocatedResults.ContainerIsIncomplete = type->isIncompleteType(); 646 } 647 else { 648 AllocatedResults.ContainerIsIncomplete = 1; 649 } 650 } 651 else { 652 AllocatedResults.ContainerKind = CXCursor_InvalidCode; 653 AllocatedResults.ContainerUSR.clear(); 654 AllocatedResults.ContainerIsIncomplete = 1; 655 } 656 } 657 658 void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, 659 OverloadCandidate *Candidates, 660 unsigned NumCandidates, 661 SourceLocation OpenParLoc, 662 bool Braced) override { 663 StoredResults.reserve(StoredResults.size() + NumCandidates); 664 for (unsigned I = 0; I != NumCandidates; ++I) { 665 CodeCompletionString *StoredCompletion = 666 Candidates[I].CreateSignatureString(CurrentArg, S, getAllocator(), 667 getCodeCompletionTUInfo(), 668 includeBriefComments(), Braced); 669 670 CXCompletionResult R; 671 R.CursorKind = CXCursor_OverloadCandidate; 672 R.CompletionString = StoredCompletion; 673 StoredResults.push_back(R); 674 } 675 } 676 677 CodeCompletionAllocator &getAllocator() override { 678 return *AllocatedResults.CodeCompletionAllocator; 679 } 680 681 CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo;} 682 683 private: 684 void Finish() { 685 AllocatedResults.Results = new CXCompletionResult [StoredResults.size()]; 686 AllocatedResults.NumResults = StoredResults.size(); 687 std::memcpy(AllocatedResults.Results, StoredResults.data(), 688 StoredResults.size() * sizeof(CXCompletionResult)); 689 StoredResults.clear(); 690 } 691 }; 692 } 693 694 static CXCodeCompleteResults * 695 clang_codeCompleteAt_Impl(CXTranslationUnit TU, const char *complete_filename, 696 unsigned complete_line, unsigned complete_column, 697 ArrayRef<CXUnsavedFile> unsaved_files, 698 unsigned options) { 699 bool IncludeBriefComments = options & CXCodeComplete_IncludeBriefComments; 700 bool SkipPreamble = options & CXCodeComplete_SkipPreamble; 701 bool IncludeFixIts = options & CXCodeComplete_IncludeCompletionsWithFixIts; 702 703 #ifdef UDP_CODE_COMPLETION_LOGGER 704 #ifdef UDP_CODE_COMPLETION_LOGGER_PORT 705 const llvm::TimeRecord &StartTime = llvm::TimeRecord::getCurrentTime(); 706 #endif 707 #endif 708 bool EnableLogging = getenv("LIBCLANG_CODE_COMPLETION_LOGGING") != nullptr; 709 710 if (cxtu::isNotUsableTU(TU)) { 711 LOG_BAD_TU(TU); 712 return nullptr; 713 } 714 715 ASTUnit *AST = cxtu::getASTUnit(TU); 716 if (!AST) 717 return nullptr; 718 719 CIndexer *CXXIdx = TU->CIdx; 720 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing)) 721 setThreadBackgroundPriority(); 722 723 ASTUnit::ConcurrencyCheck Check(*AST); 724 725 // Perform the remapping of source files. 726 SmallVector<ASTUnit::RemappedFile, 4> RemappedFiles; 727 728 for (auto &UF : unsaved_files) { 729 std::unique_ptr<llvm::MemoryBuffer> MB = 730 llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename); 731 RemappedFiles.push_back(std::make_pair(UF.Filename, MB.release())); 732 } 733 734 if (EnableLogging) { 735 // FIXME: Add logging. 736 } 737 738 // Parse the resulting source file to find code-completion results. 739 AllocatedCXCodeCompleteResults *Results = new AllocatedCXCodeCompleteResults( 740 &AST->getFileManager()); 741 Results->Results = nullptr; 742 Results->NumResults = 0; 743 744 // Create a code-completion consumer to capture the results. 745 CodeCompleteOptions Opts; 746 Opts.IncludeBriefComments = IncludeBriefComments; 747 Opts.LoadExternal = !SkipPreamble; 748 Opts.IncludeFixIts = IncludeFixIts; 749 CaptureCompletionResults Capture(Opts, *Results, &TU); 750 751 // Perform completion. 752 std::vector<const char *> CArgs; 753 for (const auto &Arg : TU->Arguments) 754 CArgs.push_back(Arg.c_str()); 755 std::string CompletionInvocation = 756 llvm::formatv("-code-completion-at={0}:{1}:{2}", complete_filename, 757 complete_line, complete_column) 758 .str(); 759 LibclangInvocationReporter InvocationReporter( 760 *CXXIdx, LibclangInvocationReporter::OperationKind::CompletionOperation, 761 TU->ParsingOptions, CArgs, CompletionInvocation, unsaved_files); 762 AST->CodeComplete(complete_filename, complete_line, complete_column, 763 RemappedFiles, (options & CXCodeComplete_IncludeMacros), 764 (options & CXCodeComplete_IncludeCodePatterns), 765 IncludeBriefComments, Capture, 766 CXXIdx->getPCHContainerOperations(), *Results->Diag, 767 Results->LangOpts, *Results->SourceMgr, *Results->FileMgr, 768 Results->Diagnostics, Results->TemporaryBuffers); 769 770 Results->DiagnosticsWrappers.resize(Results->Diagnostics.size()); 771 772 // Keep a reference to the allocator used for cached global completions, so 773 // that we can be sure that the memory used by our code completion strings 774 // doesn't get freed due to subsequent reparses (while the code completion 775 // results are still active). 776 Results->CachedCompletionAllocator = AST->getCachedCompletionAllocator(); 777 778 779 780 #ifdef UDP_CODE_COMPLETION_LOGGER 781 #ifdef UDP_CODE_COMPLETION_LOGGER_PORT 782 const llvm::TimeRecord &EndTime = llvm::TimeRecord::getCurrentTime(); 783 SmallString<256> LogResult; 784 llvm::raw_svector_ostream os(LogResult); 785 786 // Figure out the language and whether or not it uses PCH. 787 const char *lang = 0; 788 bool usesPCH = false; 789 790 for (std::vector<const char*>::iterator I = argv.begin(), E = argv.end(); 791 I != E; ++I) { 792 if (*I == 0) 793 continue; 794 if (strcmp(*I, "-x") == 0) { 795 if (I + 1 != E) { 796 lang = *(++I); 797 continue; 798 } 799 } 800 else if (strcmp(*I, "-include") == 0) { 801 if (I+1 != E) { 802 const char *arg = *(++I); 803 SmallString<512> pchName; 804 { 805 llvm::raw_svector_ostream os(pchName); 806 os << arg << ".pth"; 807 } 808 pchName.push_back('\0'); 809 llvm::sys::fs::file_status stat_results; 810 if (!llvm::sys::fs::status(pchName, stat_results)) 811 usesPCH = true; 812 continue; 813 } 814 } 815 } 816 817 os << "{ "; 818 os << "\"wall\": " << (EndTime.getWallTime() - StartTime.getWallTime()); 819 os << ", \"numRes\": " << Results->NumResults; 820 os << ", \"diags\": " << Results->Diagnostics.size(); 821 os << ", \"pch\": " << (usesPCH ? "true" : "false"); 822 os << ", \"lang\": \"" << (lang ? lang : "<unknown>") << '"'; 823 const char *name = getlogin(); 824 os << ", \"user\": \"" << (name ? name : "unknown") << '"'; 825 os << ", \"clangVer\": \"" << getClangFullVersion() << '"'; 826 os << " }"; 827 828 StringRef res = os.str(); 829 if (res.size() > 0) { 830 do { 831 // Setup the UDP socket. 832 struct sockaddr_in servaddr; 833 bzero(&servaddr, sizeof(servaddr)); 834 servaddr.sin_family = AF_INET; 835 servaddr.sin_port = htons(UDP_CODE_COMPLETION_LOGGER_PORT); 836 if (inet_pton(AF_INET, UDP_CODE_COMPLETION_LOGGER, 837 &servaddr.sin_addr) <= 0) 838 break; 839 840 int sockfd = socket(AF_INET, SOCK_DGRAM, 0); 841 if (sockfd < 0) 842 break; 843 844 sendto(sockfd, res.data(), res.size(), 0, 845 (struct sockaddr *)&servaddr, sizeof(servaddr)); 846 close(sockfd); 847 } 848 while (false); 849 } 850 #endif 851 #endif 852 return Results; 853 } 854 855 CXCodeCompleteResults *clang_codeCompleteAt(CXTranslationUnit TU, 856 const char *complete_filename, 857 unsigned complete_line, 858 unsigned complete_column, 859 struct CXUnsavedFile *unsaved_files, 860 unsigned num_unsaved_files, 861 unsigned options) { 862 LOG_FUNC_SECTION { 863 *Log << TU << ' ' 864 << complete_filename << ':' << complete_line << ':' << complete_column; 865 } 866 867 if (num_unsaved_files && !unsaved_files) 868 return nullptr; 869 870 CXCodeCompleteResults *result; 871 auto CodeCompleteAtImpl = [=, &result]() { 872 result = clang_codeCompleteAt_Impl( 873 TU, complete_filename, complete_line, complete_column, 874 llvm::ArrayRef(unsaved_files, num_unsaved_files), options); 875 }; 876 877 llvm::CrashRecoveryContext CRC; 878 879 if (!RunSafely(CRC, CodeCompleteAtImpl)) { 880 fprintf(stderr, "libclang: crash detected in code completion\n"); 881 cxtu::getASTUnit(TU)->setUnsafeToFree(true); 882 return nullptr; 883 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) 884 PrintLibclangResourceUsage(TU); 885 886 return result; 887 } 888 889 unsigned clang_defaultCodeCompleteOptions(void) { 890 return CXCodeComplete_IncludeMacros; 891 } 892 893 void clang_disposeCodeCompleteResults(CXCodeCompleteResults *ResultsIn) { 894 if (!ResultsIn) 895 return; 896 897 AllocatedCXCodeCompleteResults *Results 898 = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn); 899 delete Results; 900 } 901 902 unsigned 903 clang_codeCompleteGetNumDiagnostics(CXCodeCompleteResults *ResultsIn) { 904 AllocatedCXCodeCompleteResults *Results 905 = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn); 906 if (!Results) 907 return 0; 908 909 return Results->Diagnostics.size(); 910 } 911 912 CXDiagnostic 913 clang_codeCompleteGetDiagnostic(CXCodeCompleteResults *ResultsIn, 914 unsigned Index) { 915 AllocatedCXCodeCompleteResults *Results 916 = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn); 917 if (!Results || Index >= Results->Diagnostics.size()) 918 return nullptr; 919 920 CXStoredDiagnostic *Diag = Results->DiagnosticsWrappers[Index].get(); 921 if (!Diag) 922 Diag = (Results->DiagnosticsWrappers[Index] = 923 std::make_unique<CXStoredDiagnostic>( 924 Results->Diagnostics[Index], Results->LangOpts)) 925 .get(); 926 return Diag; 927 } 928 929 unsigned long long 930 clang_codeCompleteGetContexts(CXCodeCompleteResults *ResultsIn) { 931 AllocatedCXCodeCompleteResults *Results 932 = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn); 933 if (!Results) 934 return 0; 935 936 return Results->Contexts; 937 } 938 939 enum CXCursorKind clang_codeCompleteGetContainerKind( 940 CXCodeCompleteResults *ResultsIn, 941 unsigned *IsIncomplete) { 942 AllocatedCXCodeCompleteResults *Results = 943 static_cast<AllocatedCXCodeCompleteResults *>(ResultsIn); 944 if (!Results) 945 return CXCursor_InvalidCode; 946 947 if (IsIncomplete != nullptr) { 948 *IsIncomplete = Results->ContainerIsIncomplete; 949 } 950 951 return Results->ContainerKind; 952 } 953 954 CXString clang_codeCompleteGetContainerUSR(CXCodeCompleteResults *ResultsIn) { 955 AllocatedCXCodeCompleteResults *Results = 956 static_cast<AllocatedCXCodeCompleteResults *>(ResultsIn); 957 if (!Results) 958 return cxstring::createEmpty(); 959 960 return cxstring::createRef(Results->ContainerUSR.c_str()); 961 } 962 963 964 CXString clang_codeCompleteGetObjCSelector(CXCodeCompleteResults *ResultsIn) { 965 AllocatedCXCodeCompleteResults *Results = 966 static_cast<AllocatedCXCodeCompleteResults *>(ResultsIn); 967 if (!Results) 968 return cxstring::createEmpty(); 969 970 return cxstring::createDup(Results->Selector); 971 } 972 973 /// Simple utility function that appends a \p New string to the given 974 /// \p Old string, using the \p Buffer for storage. 975 /// 976 /// \param Old The string to which we are appending. This parameter will be 977 /// updated to reflect the complete string. 978 /// 979 /// 980 /// \param New The string to append to \p Old. 981 /// 982 /// \param Buffer A buffer that stores the actual, concatenated string. It will 983 /// be used if the old string is already-non-empty. 984 static void AppendToString(StringRef &Old, StringRef New, 985 SmallString<256> &Buffer) { 986 if (Old.empty()) { 987 Old = New; 988 return; 989 } 990 991 if (Buffer.empty()) 992 Buffer.append(Old.begin(), Old.end()); 993 Buffer.append(New.begin(), New.end()); 994 Old = Buffer.str(); 995 } 996 997 /// Get the typed-text blocks from the given code-completion string 998 /// and return them as a single string. 999 /// 1000 /// \param String The code-completion string whose typed-text blocks will be 1001 /// concatenated. 1002 /// 1003 /// \param Buffer A buffer used for storage of the completed name. 1004 static StringRef GetTypedName(CodeCompletionString *String, 1005 SmallString<256> &Buffer) { 1006 StringRef Result; 1007 for (CodeCompletionString::iterator C = String->begin(), CEnd = String->end(); 1008 C != CEnd; ++C) { 1009 if (C->Kind == CodeCompletionString::CK_TypedText) 1010 AppendToString(Result, C->Text, Buffer); 1011 } 1012 1013 return Result; 1014 } 1015 1016 namespace { 1017 struct OrderCompletionResults { 1018 bool operator()(const CXCompletionResult &XR, 1019 const CXCompletionResult &YR) const { 1020 CodeCompletionString *X 1021 = (CodeCompletionString *)XR.CompletionString; 1022 CodeCompletionString *Y 1023 = (CodeCompletionString *)YR.CompletionString; 1024 1025 SmallString<256> XBuffer; 1026 StringRef XText = GetTypedName(X, XBuffer); 1027 SmallString<256> YBuffer; 1028 StringRef YText = GetTypedName(Y, YBuffer); 1029 1030 if (XText.empty() || YText.empty()) 1031 return !XText.empty(); 1032 1033 int result = XText.compare_insensitive(YText); 1034 if (result < 0) 1035 return true; 1036 if (result > 0) 1037 return false; 1038 1039 result = XText.compare(YText); 1040 return result < 0; 1041 } 1042 }; 1043 } 1044 1045 void clang_sortCodeCompletionResults(CXCompletionResult *Results, 1046 unsigned NumResults) { 1047 std::stable_sort(Results, Results + NumResults, OrderCompletionResults()); 1048 } 1049