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