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