clang/tools/libclang/CIndexCodeCompletion.cpp

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