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 "CIndexer.h" 15 #include "CIndexDiagnostic.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/Sema/CodeCompleteConsumer.h" 29 #include "clang/Sema/Sema.h" 30 #include "llvm/ADT/SmallString.h" 31 #include "llvm/ADT/StringExtras.h" 32 #include "llvm/Support/CrashRecoveryContext.h" 33 #include "llvm/Support/FileSystem.h" 34 #include "llvm/Support/FormatVariadic.h" 35 #include "llvm/Support/MemoryBuffer.h" 36 #include "llvm/Support/Program.h" 37 #include "llvm/Support/Timer.h" 38 #include "llvm/Support/raw_ostream.h" 39 #include <atomic> 40 #include <cstdio> 41 #include <cstdlib> 42 #include <string> 43 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_TypeQualifiers: { 547 //Only Clang results should be accepted, so we'll set all of the other 548 //context bits to 0 (i.e. the empty set) 549 contexts = CXCompletionContext_Unexposed; 550 break; 551 } 552 case CodeCompletionContext::CCC_Recovery: { 553 //We don't know what the current context is, so we'll return unknown 554 //This is the equivalent of setting all of the other context bits 555 contexts = CXCompletionContext_Unknown; 556 break; 557 } 558 } 559 return contexts; 560 } 561 562 namespace { 563 class CaptureCompletionResults : public CodeCompleteConsumer { 564 AllocatedCXCodeCompleteResults &AllocatedResults; 565 CodeCompletionTUInfo CCTUInfo; 566 SmallVector<CXCompletionResult, 16> StoredResults; 567 CXTranslationUnit *TU; 568 public: 569 CaptureCompletionResults(const CodeCompleteOptions &Opts, 570 AllocatedCXCodeCompleteResults &Results, 571 CXTranslationUnit *TranslationUnit) 572 : CodeCompleteConsumer(Opts), AllocatedResults(Results), 573 CCTUInfo(Results.CodeCompletionAllocator), TU(TranslationUnit) {} 574 ~CaptureCompletionResults() override { Finish(); } 575 576 void ProcessCodeCompleteResults(Sema &S, 577 CodeCompletionContext Context, 578 CodeCompletionResult *Results, 579 unsigned NumResults) override { 580 StoredResults.reserve(StoredResults.size() + NumResults); 581 if (includeFixIts()) 582 AllocatedResults.FixItsVector.reserve(NumResults); 583 for (unsigned I = 0; I != NumResults; ++I) { 584 CodeCompletionString *StoredCompletion 585 = Results[I].CreateCodeCompletionString(S, Context, getAllocator(), 586 getCodeCompletionTUInfo(), 587 includeBriefComments()); 588 589 CXCompletionResult R; 590 R.CursorKind = Results[I].CursorKind; 591 R.CompletionString = StoredCompletion; 592 StoredResults.push_back(R); 593 if (includeFixIts()) 594 AllocatedResults.FixItsVector.emplace_back(std::move(Results[I].FixIts)); 595 } 596 597 enum CodeCompletionContext::Kind contextKind = Context.getKind(); 598 599 AllocatedResults.ContextKind = contextKind; 600 AllocatedResults.Contexts = getContextsForContextKind(contextKind, S); 601 602 AllocatedResults.Selector = ""; 603 ArrayRef<IdentifierInfo *> SelIdents = Context.getSelIdents(); 604 for (ArrayRef<IdentifierInfo *>::iterator I = SelIdents.begin(), 605 E = SelIdents.end(); 606 I != E; ++I) { 607 if (IdentifierInfo *selIdent = *I) 608 AllocatedResults.Selector += selIdent->getName(); 609 AllocatedResults.Selector += ":"; 610 } 611 612 QualType baseType = Context.getBaseType(); 613 NamedDecl *D = nullptr; 614 615 if (!baseType.isNull()) { 616 // Get the declaration for a class/struct/union/enum type 617 if (const TagType *Tag = baseType->getAs<TagType>()) 618 D = Tag->getDecl(); 619 // Get the @interface declaration for a (possibly-qualified) Objective-C 620 // object pointer type, e.g., NSString* 621 else if (const ObjCObjectPointerType *ObjPtr = 622 baseType->getAs<ObjCObjectPointerType>()) 623 D = ObjPtr->getInterfaceDecl(); 624 // Get the @interface declaration for an Objective-C object type 625 else if (const ObjCObjectType *Obj = baseType->getAs<ObjCObjectType>()) 626 D = Obj->getInterface(); 627 // Get the class for a C++ injected-class-name 628 else if (const InjectedClassNameType *Injected = 629 baseType->getAs<InjectedClassNameType>()) 630 D = Injected->getDecl(); 631 } 632 633 if (D != nullptr) { 634 CXCursor cursor = cxcursor::MakeCXCursor(D, *TU); 635 636 AllocatedResults.ContainerKind = clang_getCursorKind(cursor); 637 638 CXString CursorUSR = clang_getCursorUSR(cursor); 639 AllocatedResults.ContainerUSR = clang_getCString(CursorUSR); 640 clang_disposeString(CursorUSR); 641 642 const Type *type = baseType.getTypePtrOrNull(); 643 if (type) { 644 AllocatedResults.ContainerIsIncomplete = type->isIncompleteType(); 645 } 646 else { 647 AllocatedResults.ContainerIsIncomplete = 1; 648 } 649 } 650 else { 651 AllocatedResults.ContainerKind = CXCursor_InvalidCode; 652 AllocatedResults.ContainerUSR.clear(); 653 AllocatedResults.ContainerIsIncomplete = 1; 654 } 655 } 656 657 void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg, 658 OverloadCandidate *Candidates, 659 unsigned NumCandidates, 660 SourceLocation OpenParLoc, 661 bool Braced) override { 662 StoredResults.reserve(StoredResults.size() + NumCandidates); 663 for (unsigned I = 0; I != NumCandidates; ++I) { 664 CodeCompletionString *StoredCompletion = 665 Candidates[I].CreateSignatureString(CurrentArg, S, getAllocator(), 666 getCodeCompletionTUInfo(), 667 includeBriefComments(), Braced); 668 669 CXCompletionResult R; 670 R.CursorKind = CXCursor_OverloadCandidate; 671 R.CompletionString = StoredCompletion; 672 StoredResults.push_back(R); 673 } 674 } 675 676 CodeCompletionAllocator &getAllocator() override { 677 return *AllocatedResults.CodeCompletionAllocator; 678 } 679 680 CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo;} 681 682 private: 683 void Finish() { 684 AllocatedResults.Results = new CXCompletionResult [StoredResults.size()]; 685 AllocatedResults.NumResults = StoredResults.size(); 686 std::memcpy(AllocatedResults.Results, StoredResults.data(), 687 StoredResults.size() * sizeof(CXCompletionResult)); 688 StoredResults.clear(); 689 } 690 }; 691 } 692 693 static CXCodeCompleteResults * 694 clang_codeCompleteAt_Impl(CXTranslationUnit TU, const char *complete_filename, 695 unsigned complete_line, unsigned complete_column, 696 ArrayRef<CXUnsavedFile> unsaved_files, 697 unsigned options) { 698 bool IncludeBriefComments = options & CXCodeComplete_IncludeBriefComments; 699 bool SkipPreamble = options & CXCodeComplete_SkipPreamble; 700 bool IncludeFixIts = options & CXCodeComplete_IncludeCompletionsWithFixIts; 701 702 #ifdef UDP_CODE_COMPLETION_LOGGER 703 #ifdef UDP_CODE_COMPLETION_LOGGER_PORT 704 const llvm::TimeRecord &StartTime = llvm::TimeRecord::getCurrentTime(); 705 #endif 706 #endif 707 bool EnableLogging = getenv("LIBCLANG_CODE_COMPLETION_LOGGING") != nullptr; 708 709 if (cxtu::isNotUsableTU(TU)) { 710 LOG_BAD_TU(TU); 711 return nullptr; 712 } 713 714 ASTUnit *AST = cxtu::getASTUnit(TU); 715 if (!AST) 716 return nullptr; 717 718 CIndexer *CXXIdx = TU->CIdx; 719 if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing)) 720 setThreadBackgroundPriority(); 721 722 ASTUnit::ConcurrencyCheck Check(*AST); 723 724 // Perform the remapping of source files. 725 SmallVector<ASTUnit::RemappedFile, 4> RemappedFiles; 726 727 for (auto &UF : unsaved_files) { 728 std::unique_ptr<llvm::MemoryBuffer> MB = 729 llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename); 730 RemappedFiles.push_back(std::make_pair(UF.Filename, MB.release())); 731 } 732 733 if (EnableLogging) { 734 // FIXME: Add logging. 735 } 736 737 // Parse the resulting source file to find code-completion results. 738 AllocatedCXCodeCompleteResults *Results = new AllocatedCXCodeCompleteResults( 739 &AST->getFileManager()); 740 Results->Results = nullptr; 741 Results->NumResults = 0; 742 743 // Create a code-completion consumer to capture the results. 744 CodeCompleteOptions Opts; 745 Opts.IncludeBriefComments = IncludeBriefComments; 746 Opts.LoadExternal = !SkipPreamble; 747 Opts.IncludeFixIts = IncludeFixIts; 748 CaptureCompletionResults Capture(Opts, *Results, &TU); 749 750 // Perform completion. 751 std::vector<const char *> CArgs; 752 for (const auto &Arg : TU->Arguments) 753 CArgs.push_back(Arg.c_str()); 754 std::string CompletionInvocation = 755 llvm::formatv("-code-completion-at={0}:{1}:{2}", complete_filename, 756 complete_line, complete_column) 757 .str(); 758 LibclangInvocationReporter InvocationReporter( 759 *CXXIdx, LibclangInvocationReporter::OperationKind::CompletionOperation, 760 TU->ParsingOptions, CArgs, CompletionInvocation, unsaved_files); 761 AST->CodeComplete(complete_filename, complete_line, complete_column, 762 RemappedFiles, (options & CXCodeComplete_IncludeMacros), 763 (options & CXCodeComplete_IncludeCodePatterns), 764 IncludeBriefComments, Capture, 765 CXXIdx->getPCHContainerOperations(), *Results->Diag, 766 Results->LangOpts, *Results->SourceMgr, *Results->FileMgr, 767 Results->Diagnostics, Results->TemporaryBuffers); 768 769 Results->DiagnosticsWrappers.resize(Results->Diagnostics.size()); 770 771 // Keep a reference to the allocator used for cached global completions, so 772 // that we can be sure that the memory used by our code completion strings 773 // doesn't get freed due to subsequent reparses (while the code completion 774 // results are still active). 775 Results->CachedCompletionAllocator = AST->getCachedCompletionAllocator(); 776 777 778 779 #ifdef UDP_CODE_COMPLETION_LOGGER 780 #ifdef UDP_CODE_COMPLETION_LOGGER_PORT 781 const llvm::TimeRecord &EndTime = llvm::TimeRecord::getCurrentTime(); 782 SmallString<256> LogResult; 783 llvm::raw_svector_ostream os(LogResult); 784 785 // Figure out the language and whether or not it uses PCH. 786 const char *lang = 0; 787 bool usesPCH = false; 788 789 for (std::vector<const char*>::iterator I = argv.begin(), E = argv.end(); 790 I != E; ++I) { 791 if (*I == 0) 792 continue; 793 if (strcmp(*I, "-x") == 0) { 794 if (I + 1 != E) { 795 lang = *(++I); 796 continue; 797 } 798 } 799 else if (strcmp(*I, "-include") == 0) { 800 if (I+1 != E) { 801 const char *arg = *(++I); 802 SmallString<512> pchName; 803 { 804 llvm::raw_svector_ostream os(pchName); 805 os << arg << ".pth"; 806 } 807 pchName.push_back('\0'); 808 llvm::sys::fs::file_status stat_results; 809 if (!llvm::sys::fs::status(pchName, stat_results)) 810 usesPCH = true; 811 continue; 812 } 813 } 814 } 815 816 os << "{ "; 817 os << "\"wall\": " << (EndTime.getWallTime() - StartTime.getWallTime()); 818 os << ", \"numRes\": " << Results->NumResults; 819 os << ", \"diags\": " << Results->Diagnostics.size(); 820 os << ", \"pch\": " << (usesPCH ? "true" : "false"); 821 os << ", \"lang\": \"" << (lang ? lang : "<unknown>") << '"'; 822 const char *name = getlogin(); 823 os << ", \"user\": \"" << (name ? name : "unknown") << '"'; 824 os << ", \"clangVer\": \"" << getClangFullVersion() << '"'; 825 os << " }"; 826 827 StringRef res = os.str(); 828 if (res.size() > 0) { 829 do { 830 // Setup the UDP socket. 831 struct sockaddr_in servaddr; 832 bzero(&servaddr, sizeof(servaddr)); 833 servaddr.sin_family = AF_INET; 834 servaddr.sin_port = htons(UDP_CODE_COMPLETION_LOGGER_PORT); 835 if (inet_pton(AF_INET, UDP_CODE_COMPLETION_LOGGER, 836 &servaddr.sin_addr) <= 0) 837 break; 838 839 int sockfd = socket(AF_INET, SOCK_DGRAM, 0); 840 if (sockfd < 0) 841 break; 842 843 sendto(sockfd, res.data(), res.size(), 0, 844 (struct sockaddr *)&servaddr, sizeof(servaddr)); 845 close(sockfd); 846 } 847 while (false); 848 } 849 #endif 850 #endif 851 return Results; 852 } 853 854 CXCodeCompleteResults *clang_codeCompleteAt(CXTranslationUnit TU, 855 const char *complete_filename, 856 unsigned complete_line, 857 unsigned complete_column, 858 struct CXUnsavedFile *unsaved_files, 859 unsigned num_unsaved_files, 860 unsigned options) { 861 LOG_FUNC_SECTION { 862 *Log << TU << ' ' 863 << complete_filename << ':' << complete_line << ':' << complete_column; 864 } 865 866 if (num_unsaved_files && !unsaved_files) 867 return nullptr; 868 869 CXCodeCompleteResults *result; 870 auto CodeCompleteAtImpl = [=, &result]() { 871 result = clang_codeCompleteAt_Impl( 872 TU, complete_filename, complete_line, complete_column, 873 llvm::ArrayRef(unsaved_files, num_unsaved_files), options); 874 }; 875 876 llvm::CrashRecoveryContext CRC; 877 878 if (!RunSafely(CRC, CodeCompleteAtImpl)) { 879 fprintf(stderr, "libclang: crash detected in code completion\n"); 880 cxtu::getASTUnit(TU)->setUnsafeToFree(true); 881 return nullptr; 882 } else if (getenv("LIBCLANG_RESOURCE_USAGE")) 883 PrintLibclangResourceUsage(TU); 884 885 return result; 886 } 887 888 unsigned clang_defaultCodeCompleteOptions(void) { 889 return CXCodeComplete_IncludeMacros; 890 } 891 892 void clang_disposeCodeCompleteResults(CXCodeCompleteResults *ResultsIn) { 893 if (!ResultsIn) 894 return; 895 896 AllocatedCXCodeCompleteResults *Results 897 = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn); 898 delete Results; 899 } 900 901 unsigned 902 clang_codeCompleteGetNumDiagnostics(CXCodeCompleteResults *ResultsIn) { 903 AllocatedCXCodeCompleteResults *Results 904 = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn); 905 if (!Results) 906 return 0; 907 908 return Results->Diagnostics.size(); 909 } 910 911 CXDiagnostic 912 clang_codeCompleteGetDiagnostic(CXCodeCompleteResults *ResultsIn, 913 unsigned Index) { 914 AllocatedCXCodeCompleteResults *Results 915 = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn); 916 if (!Results || Index >= Results->Diagnostics.size()) 917 return nullptr; 918 919 CXStoredDiagnostic *Diag = Results->DiagnosticsWrappers[Index].get(); 920 if (!Diag) 921 Diag = (Results->DiagnosticsWrappers[Index] = 922 std::make_unique<CXStoredDiagnostic>( 923 Results->Diagnostics[Index], Results->LangOpts)) 924 .get(); 925 return Diag; 926 } 927 928 unsigned long long 929 clang_codeCompleteGetContexts(CXCodeCompleteResults *ResultsIn) { 930 AllocatedCXCodeCompleteResults *Results 931 = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn); 932 if (!Results) 933 return 0; 934 935 return Results->Contexts; 936 } 937 938 enum CXCursorKind clang_codeCompleteGetContainerKind( 939 CXCodeCompleteResults *ResultsIn, 940 unsigned *IsIncomplete) { 941 AllocatedCXCodeCompleteResults *Results = 942 static_cast<AllocatedCXCodeCompleteResults *>(ResultsIn); 943 if (!Results) 944 return CXCursor_InvalidCode; 945 946 if (IsIncomplete != nullptr) { 947 *IsIncomplete = Results->ContainerIsIncomplete; 948 } 949 950 return Results->ContainerKind; 951 } 952 953 CXString clang_codeCompleteGetContainerUSR(CXCodeCompleteResults *ResultsIn) { 954 AllocatedCXCodeCompleteResults *Results = 955 static_cast<AllocatedCXCodeCompleteResults *>(ResultsIn); 956 if (!Results) 957 return cxstring::createEmpty(); 958 959 return cxstring::createRef(Results->ContainerUSR.c_str()); 960 } 961 962 963 CXString clang_codeCompleteGetObjCSelector(CXCodeCompleteResults *ResultsIn) { 964 AllocatedCXCodeCompleteResults *Results = 965 static_cast<AllocatedCXCodeCompleteResults *>(ResultsIn); 966 if (!Results) 967 return cxstring::createEmpty(); 968 969 return cxstring::createDup(Results->Selector); 970 } 971 972 /// Simple utility function that appends a \p New string to the given 973 /// \p Old string, using the \p Buffer for storage. 974 /// 975 /// \param Old The string to which we are appending. This parameter will be 976 /// updated to reflect the complete string. 977 /// 978 /// 979 /// \param New The string to append to \p Old. 980 /// 981 /// \param Buffer A buffer that stores the actual, concatenated string. It will 982 /// be used if the old string is already-non-empty. 983 static void AppendToString(StringRef &Old, StringRef New, 984 SmallString<256> &Buffer) { 985 if (Old.empty()) { 986 Old = New; 987 return; 988 } 989 990 if (Buffer.empty()) 991 Buffer.append(Old.begin(), Old.end()); 992 Buffer.append(New.begin(), New.end()); 993 Old = Buffer.str(); 994 } 995 996 /// Get the typed-text blocks from the given code-completion string 997 /// and return them as a single string. 998 /// 999 /// \param String The code-completion string whose typed-text blocks will be 1000 /// concatenated. 1001 /// 1002 /// \param Buffer A buffer used for storage of the completed name. 1003 static StringRef GetTypedName(CodeCompletionString *String, 1004 SmallString<256> &Buffer) { 1005 StringRef Result; 1006 for (CodeCompletionString::iterator C = String->begin(), CEnd = String->end(); 1007 C != CEnd; ++C) { 1008 if (C->Kind == CodeCompletionString::CK_TypedText) 1009 AppendToString(Result, C->Text, Buffer); 1010 } 1011 1012 return Result; 1013 } 1014 1015 namespace { 1016 struct OrderCompletionResults { 1017 bool operator()(const CXCompletionResult &XR, 1018 const CXCompletionResult &YR) const { 1019 CodeCompletionString *X 1020 = (CodeCompletionString *)XR.CompletionString; 1021 CodeCompletionString *Y 1022 = (CodeCompletionString *)YR.CompletionString; 1023 1024 SmallString<256> XBuffer; 1025 StringRef XText = GetTypedName(X, XBuffer); 1026 SmallString<256> YBuffer; 1027 StringRef YText = GetTypedName(Y, YBuffer); 1028 1029 if (XText.empty() || YText.empty()) 1030 return !XText.empty(); 1031 1032 int result = XText.compare_insensitive(YText); 1033 if (result < 0) 1034 return true; 1035 if (result > 0) 1036 return false; 1037 1038 result = XText.compare(YText); 1039 return result < 0; 1040 } 1041 }; 1042 } 1043 1044 void clang_sortCodeCompletionResults(CXCompletionResult *Results, 1045 unsigned NumResults) { 1046 std::stable_sort(Results, Results + NumResults, OrderCompletionResults()); 1047 } 1048