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