1 //===- CIndexCodeCompletion.cpp - Code Completion API hooks ---------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the Clang-C Source Indexing library hooks for
11 // code completion.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "CIndexer.h"
16 #include "CIndexDiagnostic.h"
17 #include "CLog.h"
18 #include "CXCursor.h"
19 #include "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/Frontend/FrontendDiagnostic.h"
29 #include "clang/Sema/CodeCompleteConsumer.h"
30 #include "clang/Sema/Sema.h"
31 #include "llvm/ADT/SmallString.h"
32 #include "llvm/ADT/StringExtras.h"
33 #include "llvm/Support/CrashRecoveryContext.h"
34 #include "llvm/Support/FileSystem.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 /// \brief 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   /// \brief Diagnostics produced while performing code completion.
254   SmallVector<StoredDiagnostic, 8> Diagnostics;
255 
256   /// \brief Allocated API-exposed wrappters for Diagnostics.
257   SmallVector<CXStoredDiagnostic *, 8> DiagnosticsWrappers;
258 
259   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
260 
261   /// \brief Diag object
262   IntrusiveRefCntPtr<DiagnosticsEngine> Diag;
263 
264   /// \brief Language options used to adjust source locations.
265   LangOptions LangOpts;
266 
267   /// \brief File manager, used for diagnostics.
268   IntrusiveRefCntPtr<FileManager> FileMgr;
269 
270   /// \brief Source manager, used for diagnostics.
271   IntrusiveRefCntPtr<SourceManager> SourceMgr;
272 
273   /// \brief Temporary files that should be removed once we have finished
274   /// with the code-completion results.
275   std::vector<std::string> TemporaryFiles;
276 
277   /// \brief Temporary buffers that will be deleted once we have finished with
278   /// the code-completion results.
279   SmallVector<const llvm::MemoryBuffer *, 1> TemporaryBuffers;
280 
281   /// \brief Allocator used to store globally cached code-completion results.
282   std::shared_ptr<clang::GlobalCodeCompletionAllocator>
283       CachedCompletionAllocator;
284 
285   /// \brief Allocator used to store code completion results.
286   std::shared_ptr<clang::GlobalCodeCompletionAllocator> CodeCompletionAllocator;
287 
288   /// \brief Context under which completion occurred.
289   enum clang::CodeCompletionContext::Kind ContextKind;
290 
291   /// \brief A bitfield representing the acceptable completions for the
292   /// current context.
293   unsigned long long Contexts;
294 
295   /// \brief The kind of the container for the current context for completions.
296   enum CXCursorKind ContainerKind;
297 
298   /// \brief The USR of the container for the current context for completions.
299   std::string ContainerUSR;
300 
301   /// \brief a boolean value indicating whether there is complete information
302   /// about the container
303   unsigned ContainerIsIncomplete;
304 
305   /// \brief A string containing the Objective-C selector entered thus far for a
306   /// message send.
307   std::string Selector;
308 };
309 
310 } // end anonymous namespace
311 
312 /// \brief Tracks the number of code-completion result objects that are
313 /// currently active.
314 ///
315 /// Used for debugging purposes only.
316 static std::atomic<unsigned> CodeCompletionResultObjects;
317 
318 AllocatedCXCodeCompleteResults::AllocatedCXCodeCompleteResults(
319     IntrusiveRefCntPtr<FileManager> FileMgr)
320     : CXCodeCompleteResults(), DiagOpts(new DiagnosticOptions),
321       Diag(new DiagnosticsEngine(
322           IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts)),
323       FileMgr(FileMgr), SourceMgr(new SourceManager(*Diag, *FileMgr)),
324       CodeCompletionAllocator(
325           std::make_shared<clang::GlobalCodeCompletionAllocator>()),
326       Contexts(CXCompletionContext_Unknown),
327       ContainerKind(CXCursor_InvalidCode), ContainerIsIncomplete(1) {
328   if (getenv("LIBCLANG_OBJTRACKING"))
329     fprintf(stderr, "+++ %u completion results\n",
330             ++CodeCompletionResultObjects);
331 }
332 
333 AllocatedCXCodeCompleteResults::~AllocatedCXCodeCompleteResults() {
334   llvm::DeleteContainerPointers(DiagnosticsWrappers);
335   delete [] Results;
336 
337   for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I)
338     llvm::sys::fs::remove(TemporaryFiles[I]);
339   for (unsigned I = 0, N = TemporaryBuffers.size(); I != N; ++I)
340     delete TemporaryBuffers[I];
341 
342   if (getenv("LIBCLANG_OBJTRACKING"))
343     fprintf(stderr, "--- %u completion results\n",
344             --CodeCompletionResultObjects);
345 }
346 
347 static unsigned long long getContextsForContextKind(
348                                           enum CodeCompletionContext::Kind kind,
349                                                     Sema &S) {
350   unsigned long long contexts = 0;
351   switch (kind) {
352     case CodeCompletionContext::CCC_OtherWithMacros: {
353       //We can allow macros here, but we don't know what else is permissible
354       //So we'll say the only thing permissible are macros
355       contexts = CXCompletionContext_MacroName;
356       break;
357     }
358     case CodeCompletionContext::CCC_TopLevel:
359     case CodeCompletionContext::CCC_ObjCIvarList:
360     case CodeCompletionContext::CCC_ClassStructUnion:
361     case CodeCompletionContext::CCC_Type: {
362       contexts = CXCompletionContext_AnyType |
363                  CXCompletionContext_ObjCInterface;
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_Statement: {
374       contexts = CXCompletionContext_AnyType |
375                  CXCompletionContext_ObjCInterface |
376                  CXCompletionContext_AnyValue;
377       if (S.getLangOpts().CPlusPlus) {
378         contexts |= CXCompletionContext_EnumTag |
379                     CXCompletionContext_UnionTag |
380                     CXCompletionContext_StructTag |
381                     CXCompletionContext_ClassTag |
382                     CXCompletionContext_NestedNameSpecifier;
383       }
384       break;
385     }
386     case CodeCompletionContext::CCC_Expression: {
387       contexts = CXCompletionContext_AnyValue;
388       if (S.getLangOpts().CPlusPlus) {
389         contexts |= CXCompletionContext_AnyType |
390                     CXCompletionContext_ObjCInterface |
391                     CXCompletionContext_EnumTag |
392                     CXCompletionContext_UnionTag |
393                     CXCompletionContext_StructTag |
394                     CXCompletionContext_ClassTag |
395                     CXCompletionContext_NestedNameSpecifier;
396       }
397       break;
398     }
399     case CodeCompletionContext::CCC_ObjCMessageReceiver: {
400       contexts = CXCompletionContext_ObjCObjectValue |
401                  CXCompletionContext_ObjCSelectorValue |
402                  CXCompletionContext_ObjCInterface;
403       if (S.getLangOpts().CPlusPlus) {
404         contexts |= CXCompletionContext_CXXClassTypeValue |
405                     CXCompletionContext_AnyType |
406                     CXCompletionContext_EnumTag |
407                     CXCompletionContext_UnionTag |
408                     CXCompletionContext_StructTag |
409                     CXCompletionContext_ClassTag |
410                     CXCompletionContext_NestedNameSpecifier;
411       }
412       break;
413     }
414     case CodeCompletionContext::CCC_DotMemberAccess: {
415       contexts = CXCompletionContext_DotMemberAccess;
416       break;
417     }
418     case CodeCompletionContext::CCC_ArrowMemberAccess: {
419       contexts = CXCompletionContext_ArrowMemberAccess;
420       break;
421     }
422     case CodeCompletionContext::CCC_ObjCPropertyAccess: {
423       contexts = CXCompletionContext_ObjCPropertyAccess;
424       break;
425     }
426     case CodeCompletionContext::CCC_EnumTag: {
427       contexts = CXCompletionContext_EnumTag |
428                  CXCompletionContext_NestedNameSpecifier;
429       break;
430     }
431     case CodeCompletionContext::CCC_UnionTag: {
432       contexts = CXCompletionContext_UnionTag |
433                  CXCompletionContext_NestedNameSpecifier;
434       break;
435     }
436     case CodeCompletionContext::CCC_ClassOrStructTag: {
437       contexts = CXCompletionContext_StructTag |
438                  CXCompletionContext_ClassTag |
439                  CXCompletionContext_NestedNameSpecifier;
440       break;
441     }
442     case CodeCompletionContext::CCC_ObjCProtocolName: {
443       contexts = CXCompletionContext_ObjCProtocol;
444       break;
445     }
446     case CodeCompletionContext::CCC_Namespace: {
447       contexts = CXCompletionContext_Namespace;
448       break;
449     }
450     case CodeCompletionContext::CCC_PotentiallyQualifiedName: {
451       contexts = CXCompletionContext_NestedNameSpecifier;
452       break;
453     }
454     case CodeCompletionContext::CCC_MacroNameUse: {
455       contexts = CXCompletionContext_MacroName;
456       break;
457     }
458     case CodeCompletionContext::CCC_NaturalLanguage: {
459       contexts = CXCompletionContext_NaturalLanguage;
460       break;
461     }
462     case CodeCompletionContext::CCC_SelectorName: {
463       contexts = CXCompletionContext_ObjCSelectorName;
464       break;
465     }
466     case CodeCompletionContext::CCC_ParenthesizedExpression: {
467       contexts = CXCompletionContext_AnyType |
468                  CXCompletionContext_ObjCInterface |
469                  CXCompletionContext_AnyValue;
470       if (S.getLangOpts().CPlusPlus) {
471         contexts |= CXCompletionContext_EnumTag |
472                     CXCompletionContext_UnionTag |
473                     CXCompletionContext_StructTag |
474                     CXCompletionContext_ClassTag |
475                     CXCompletionContext_NestedNameSpecifier;
476       }
477       break;
478     }
479     case CodeCompletionContext::CCC_ObjCInstanceMessage: {
480       contexts = CXCompletionContext_ObjCInstanceMessage;
481       break;
482     }
483     case CodeCompletionContext::CCC_ObjCClassMessage: {
484       contexts = CXCompletionContext_ObjCClassMessage;
485       break;
486     }
487     case CodeCompletionContext::CCC_ObjCInterfaceName: {
488       contexts = CXCompletionContext_ObjCInterface;
489       break;
490     }
491     case CodeCompletionContext::CCC_ObjCCategoryName: {
492       contexts = CXCompletionContext_ObjCCategory;
493       break;
494     }
495     case CodeCompletionContext::CCC_Other:
496     case CodeCompletionContext::CCC_ObjCInterface:
497     case CodeCompletionContext::CCC_ObjCImplementation:
498     case CodeCompletionContext::CCC_Name:
499     case CodeCompletionContext::CCC_MacroName:
500     case CodeCompletionContext::CCC_PreprocessorExpression:
501     case CodeCompletionContext::CCC_PreprocessorDirective:
502     case CodeCompletionContext::CCC_TypeQualifiers: {
503       //Only Clang results should be accepted, so we'll set all of the other
504       //context bits to 0 (i.e. the empty set)
505       contexts = CXCompletionContext_Unexposed;
506       break;
507     }
508     case CodeCompletionContext::CCC_Recovery: {
509       //We don't know what the current context is, so we'll return unknown
510       //This is the equivalent of setting all of the other context bits
511       contexts = CXCompletionContext_Unknown;
512       break;
513     }
514   }
515   return contexts;
516 }
517 
518 namespace {
519   class CaptureCompletionResults : public CodeCompleteConsumer {
520     AllocatedCXCodeCompleteResults &AllocatedResults;
521     CodeCompletionTUInfo CCTUInfo;
522     SmallVector<CXCompletionResult, 16> StoredResults;
523     CXTranslationUnit *TU;
524   public:
525     CaptureCompletionResults(const CodeCompleteOptions &Opts,
526                              AllocatedCXCodeCompleteResults &Results,
527                              CXTranslationUnit *TranslationUnit)
528       : CodeCompleteConsumer(Opts, false),
529         AllocatedResults(Results), CCTUInfo(Results.CodeCompletionAllocator),
530         TU(TranslationUnit) { }
531     ~CaptureCompletionResults() override { Finish(); }
532 
533     void ProcessCodeCompleteResults(Sema &S,
534                                     CodeCompletionContext Context,
535                                     CodeCompletionResult *Results,
536                                     unsigned NumResults) override {
537       StoredResults.reserve(StoredResults.size() + NumResults);
538       for (unsigned I = 0; I != NumResults; ++I) {
539         CodeCompletionString *StoredCompletion
540           = Results[I].CreateCodeCompletionString(S, Context, getAllocator(),
541                                                   getCodeCompletionTUInfo(),
542                                                   includeBriefComments());
543 
544         CXCompletionResult R;
545         R.CursorKind = Results[I].CursorKind;
546         R.CompletionString = StoredCompletion;
547         StoredResults.push_back(R);
548       }
549 
550       enum CodeCompletionContext::Kind contextKind = Context.getKind();
551 
552       AllocatedResults.ContextKind = contextKind;
553       AllocatedResults.Contexts = getContextsForContextKind(contextKind, S);
554 
555       AllocatedResults.Selector = "";
556       ArrayRef<IdentifierInfo *> SelIdents = Context.getSelIdents();
557       for (ArrayRef<IdentifierInfo *>::iterator I = SelIdents.begin(),
558                                                 E = SelIdents.end();
559            I != E; ++I) {
560         if (IdentifierInfo *selIdent = *I)
561           AllocatedResults.Selector += selIdent->getName();
562         AllocatedResults.Selector += ":";
563       }
564 
565       QualType baseType = Context.getBaseType();
566       NamedDecl *D = nullptr;
567 
568       if (!baseType.isNull()) {
569         // Get the declaration for a class/struct/union/enum type
570         if (const TagType *Tag = baseType->getAs<TagType>())
571           D = Tag->getDecl();
572         // Get the @interface declaration for a (possibly-qualified) Objective-C
573         // object pointer type, e.g., NSString*
574         else if (const ObjCObjectPointerType *ObjPtr =
575                  baseType->getAs<ObjCObjectPointerType>())
576           D = ObjPtr->getInterfaceDecl();
577         // Get the @interface declaration for an Objective-C object type
578         else if (const ObjCObjectType *Obj = baseType->getAs<ObjCObjectType>())
579           D = Obj->getInterface();
580         // Get the class for a C++ injected-class-name
581         else if (const InjectedClassNameType *Injected =
582                  baseType->getAs<InjectedClassNameType>())
583           D = Injected->getDecl();
584       }
585 
586       if (D != nullptr) {
587         CXCursor cursor = cxcursor::MakeCXCursor(D, *TU);
588 
589         AllocatedResults.ContainerKind = clang_getCursorKind(cursor);
590 
591         CXString CursorUSR = clang_getCursorUSR(cursor);
592         AllocatedResults.ContainerUSR = clang_getCString(CursorUSR);
593         clang_disposeString(CursorUSR);
594 
595         const Type *type = baseType.getTypePtrOrNull();
596         if (type) {
597           AllocatedResults.ContainerIsIncomplete = type->isIncompleteType();
598         }
599         else {
600           AllocatedResults.ContainerIsIncomplete = 1;
601         }
602       }
603       else {
604         AllocatedResults.ContainerKind = CXCursor_InvalidCode;
605         AllocatedResults.ContainerUSR.clear();
606         AllocatedResults.ContainerIsIncomplete = 1;
607       }
608     }
609 
610     void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
611                                    OverloadCandidate *Candidates,
612                                    unsigned NumCandidates) override {
613       StoredResults.reserve(StoredResults.size() + NumCandidates);
614       for (unsigned I = 0; I != NumCandidates; ++I) {
615         CodeCompletionString *StoredCompletion
616           = Candidates[I].CreateSignatureString(CurrentArg, S, getAllocator(),
617                                                 getCodeCompletionTUInfo(),
618                                                 includeBriefComments());
619 
620         CXCompletionResult R;
621         R.CursorKind = CXCursor_OverloadCandidate;
622         R.CompletionString = StoredCompletion;
623         StoredResults.push_back(R);
624       }
625     }
626 
627     CodeCompletionAllocator &getAllocator() override {
628       return *AllocatedResults.CodeCompletionAllocator;
629     }
630 
631     CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo;}
632 
633   private:
634     void Finish() {
635       AllocatedResults.Results = new CXCompletionResult [StoredResults.size()];
636       AllocatedResults.NumResults = StoredResults.size();
637       std::memcpy(AllocatedResults.Results, StoredResults.data(),
638                   StoredResults.size() * sizeof(CXCompletionResult));
639       StoredResults.clear();
640     }
641   };
642 }
643 
644 static CXCodeCompleteResults *
645 clang_codeCompleteAt_Impl(CXTranslationUnit TU, const char *complete_filename,
646                           unsigned complete_line, unsigned complete_column,
647                           ArrayRef<CXUnsavedFile> unsaved_files,
648                           unsigned options) {
649   bool IncludeBriefComments = options & CXCodeComplete_IncludeBriefComments;
650 
651 #ifdef UDP_CODE_COMPLETION_LOGGER
652 #ifdef UDP_CODE_COMPLETION_LOGGER_PORT
653   const llvm::TimeRecord &StartTime =  llvm::TimeRecord::getCurrentTime();
654 #endif
655 #endif
656 
657   bool EnableLogging = getenv("LIBCLANG_CODE_COMPLETION_LOGGING") != nullptr;
658 
659   if (cxtu::isNotUsableTU(TU)) {
660     LOG_BAD_TU(TU);
661     return nullptr;
662   }
663 
664   ASTUnit *AST = cxtu::getASTUnit(TU);
665   if (!AST)
666     return nullptr;
667 
668   CIndexer *CXXIdx = TU->CIdx;
669   if (CXXIdx->isOptEnabled(CXGlobalOpt_ThreadBackgroundPriorityForEditing))
670     setThreadBackgroundPriority();
671 
672   ASTUnit::ConcurrencyCheck Check(*AST);
673 
674   // Perform the remapping of source files.
675   SmallVector<ASTUnit::RemappedFile, 4> RemappedFiles;
676 
677   for (auto &UF : unsaved_files) {
678     std::unique_ptr<llvm::MemoryBuffer> MB =
679         llvm::MemoryBuffer::getMemBufferCopy(getContents(UF), UF.Filename);
680     RemappedFiles.push_back(std::make_pair(UF.Filename, MB.release()));
681   }
682 
683   if (EnableLogging) {
684     // FIXME: Add logging.
685   }
686 
687   // Parse the resulting source file to find code-completion results.
688   AllocatedCXCodeCompleteResults *Results = new AllocatedCXCodeCompleteResults(
689       &AST->getFileManager());
690   Results->Results = nullptr;
691   Results->NumResults = 0;
692 
693   // Create a code-completion consumer to capture the results.
694   CodeCompleteOptions Opts;
695   Opts.IncludeBriefComments = IncludeBriefComments;
696   CaptureCompletionResults Capture(Opts, *Results, &TU);
697 
698   // Perform completion.
699   AST->CodeComplete(complete_filename, complete_line, complete_column,
700                     RemappedFiles, (options & CXCodeComplete_IncludeMacros),
701                     (options & CXCodeComplete_IncludeCodePatterns),
702                     IncludeBriefComments, Capture,
703                     CXXIdx->getPCHContainerOperations(), *Results->Diag,
704                     Results->LangOpts, *Results->SourceMgr, *Results->FileMgr,
705                     Results->Diagnostics, Results->TemporaryBuffers);
706 
707   Results->DiagnosticsWrappers.resize(Results->Diagnostics.size());
708 
709   // Keep a reference to the allocator used for cached global completions, so
710   // that we can be sure that the memory used by our code completion strings
711   // doesn't get freed due to subsequent reparses (while the code completion
712   // results are still active).
713   Results->CachedCompletionAllocator = AST->getCachedCompletionAllocator();
714 
715 
716 
717 #ifdef UDP_CODE_COMPLETION_LOGGER
718 #ifdef UDP_CODE_COMPLETION_LOGGER_PORT
719   const llvm::TimeRecord &EndTime =  llvm::TimeRecord::getCurrentTime();
720   SmallString<256> LogResult;
721   llvm::raw_svector_ostream os(LogResult);
722 
723   // Figure out the language and whether or not it uses PCH.
724   const char *lang = 0;
725   bool usesPCH = false;
726 
727   for (std::vector<const char*>::iterator I = argv.begin(), E = argv.end();
728        I != E; ++I) {
729     if (*I == 0)
730       continue;
731     if (strcmp(*I, "-x") == 0) {
732       if (I + 1 != E) {
733         lang = *(++I);
734         continue;
735       }
736     }
737     else if (strcmp(*I, "-include") == 0) {
738       if (I+1 != E) {
739         const char *arg = *(++I);
740         SmallString<512> pchName;
741         {
742           llvm::raw_svector_ostream os(pchName);
743           os << arg << ".pth";
744         }
745         pchName.push_back('\0');
746         struct stat stat_results;
747         if (stat(pchName.str().c_str(), &stat_results) == 0)
748           usesPCH = true;
749         continue;
750       }
751     }
752   }
753 
754   os << "{ ";
755   os << "\"wall\": " << (EndTime.getWallTime() - StartTime.getWallTime());
756   os << ", \"numRes\": " << Results->NumResults;
757   os << ", \"diags\": " << Results->Diagnostics.size();
758   os << ", \"pch\": " << (usesPCH ? "true" : "false");
759   os << ", \"lang\": \"" << (lang ? lang : "<unknown>") << '"';
760   const char *name = getlogin();
761   os << ", \"user\": \"" << (name ? name : "unknown") << '"';
762   os << ", \"clangVer\": \"" << getClangFullVersion() << '"';
763   os << " }";
764 
765   StringRef res = os.str();
766   if (res.size() > 0) {
767     do {
768       // Setup the UDP socket.
769       struct sockaddr_in servaddr;
770       bzero(&servaddr, sizeof(servaddr));
771       servaddr.sin_family = AF_INET;
772       servaddr.sin_port = htons(UDP_CODE_COMPLETION_LOGGER_PORT);
773       if (inet_pton(AF_INET, UDP_CODE_COMPLETION_LOGGER,
774                     &servaddr.sin_addr) <= 0)
775         break;
776 
777       int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
778       if (sockfd < 0)
779         break;
780 
781       sendto(sockfd, res.data(), res.size(), 0,
782              (struct sockaddr *)&servaddr, sizeof(servaddr));
783       close(sockfd);
784     }
785     while (false);
786   }
787 #endif
788 #endif
789   return Results;
790 }
791 
792 CXCodeCompleteResults *clang_codeCompleteAt(CXTranslationUnit TU,
793                                             const char *complete_filename,
794                                             unsigned complete_line,
795                                             unsigned complete_column,
796                                             struct CXUnsavedFile *unsaved_files,
797                                             unsigned num_unsaved_files,
798                                             unsigned options) {
799   LOG_FUNC_SECTION {
800     *Log << TU << ' '
801          << complete_filename << ':' << complete_line << ':' << complete_column;
802   }
803 
804   if (num_unsaved_files && !unsaved_files)
805     return nullptr;
806 
807   CXCodeCompleteResults *result;
808   auto CodeCompleteAtImpl = [=, &result]() {
809     result = clang_codeCompleteAt_Impl(
810         TU, complete_filename, complete_line, complete_column,
811         llvm::makeArrayRef(unsaved_files, num_unsaved_files), options);
812   };
813 
814   if (getenv("LIBCLANG_NOTHREADS")) {
815     CodeCompleteAtImpl();
816     return result;
817   }
818 
819   llvm::CrashRecoveryContext CRC;
820 
821   if (!RunSafely(CRC, CodeCompleteAtImpl)) {
822     fprintf(stderr, "libclang: crash detected in code completion\n");
823     cxtu::getASTUnit(TU)->setUnsafeToFree(true);
824     return nullptr;
825   } else if (getenv("LIBCLANG_RESOURCE_USAGE"))
826     PrintLibclangResourceUsage(TU);
827 
828   return result;
829 }
830 
831 unsigned clang_defaultCodeCompleteOptions(void) {
832   return CXCodeComplete_IncludeMacros;
833 }
834 
835 void clang_disposeCodeCompleteResults(CXCodeCompleteResults *ResultsIn) {
836   if (!ResultsIn)
837     return;
838 
839   AllocatedCXCodeCompleteResults *Results
840     = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn);
841   delete Results;
842 }
843 
844 unsigned
845 clang_codeCompleteGetNumDiagnostics(CXCodeCompleteResults *ResultsIn) {
846   AllocatedCXCodeCompleteResults *Results
847     = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn);
848   if (!Results)
849     return 0;
850 
851   return Results->Diagnostics.size();
852 }
853 
854 CXDiagnostic
855 clang_codeCompleteGetDiagnostic(CXCodeCompleteResults *ResultsIn,
856                                 unsigned Index) {
857   AllocatedCXCodeCompleteResults *Results
858     = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn);
859   if (!Results || Index >= Results->Diagnostics.size())
860     return nullptr;
861 
862   CXStoredDiagnostic *Diag = Results->DiagnosticsWrappers[Index];
863   if (!Diag)
864     Results->DiagnosticsWrappers[Index] = Diag =
865         new CXStoredDiagnostic(Results->Diagnostics[Index], Results->LangOpts);
866   return Diag;
867 }
868 
869 unsigned long long
870 clang_codeCompleteGetContexts(CXCodeCompleteResults *ResultsIn) {
871   AllocatedCXCodeCompleteResults *Results
872     = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn);
873   if (!Results)
874     return 0;
875 
876   return Results->Contexts;
877 }
878 
879 enum CXCursorKind clang_codeCompleteGetContainerKind(
880                                                CXCodeCompleteResults *ResultsIn,
881                                                      unsigned *IsIncomplete) {
882   AllocatedCXCodeCompleteResults *Results =
883     static_cast<AllocatedCXCodeCompleteResults *>(ResultsIn);
884   if (!Results)
885     return CXCursor_InvalidCode;
886 
887   if (IsIncomplete != nullptr) {
888     *IsIncomplete = Results->ContainerIsIncomplete;
889   }
890 
891   return Results->ContainerKind;
892 }
893 
894 CXString clang_codeCompleteGetContainerUSR(CXCodeCompleteResults *ResultsIn) {
895   AllocatedCXCodeCompleteResults *Results =
896     static_cast<AllocatedCXCodeCompleteResults *>(ResultsIn);
897   if (!Results)
898     return cxstring::createEmpty();
899 
900   return cxstring::createRef(Results->ContainerUSR.c_str());
901 }
902 
903 
904 CXString clang_codeCompleteGetObjCSelector(CXCodeCompleteResults *ResultsIn) {
905   AllocatedCXCodeCompleteResults *Results =
906     static_cast<AllocatedCXCodeCompleteResults *>(ResultsIn);
907   if (!Results)
908     return cxstring::createEmpty();
909 
910   return cxstring::createDup(Results->Selector);
911 }
912 
913 /// \brief Simple utility function that appends a \p New string to the given
914 /// \p Old string, using the \p Buffer for storage.
915 ///
916 /// \param Old The string to which we are appending. This parameter will be
917 /// updated to reflect the complete string.
918 ///
919 ///
920 /// \param New The string to append to \p Old.
921 ///
922 /// \param Buffer A buffer that stores the actual, concatenated string. It will
923 /// be used if the old string is already-non-empty.
924 static void AppendToString(StringRef &Old, StringRef New,
925                            SmallString<256> &Buffer) {
926   if (Old.empty()) {
927     Old = New;
928     return;
929   }
930 
931   if (Buffer.empty())
932     Buffer.append(Old.begin(), Old.end());
933   Buffer.append(New.begin(), New.end());
934   Old = Buffer.str();
935 }
936 
937 /// \brief Get the typed-text blocks from the given code-completion string
938 /// and return them as a single string.
939 ///
940 /// \param String The code-completion string whose typed-text blocks will be
941 /// concatenated.
942 ///
943 /// \param Buffer A buffer used for storage of the completed name.
944 static StringRef GetTypedName(CodeCompletionString *String,
945                                     SmallString<256> &Buffer) {
946   StringRef Result;
947   for (CodeCompletionString::iterator C = String->begin(), CEnd = String->end();
948        C != CEnd; ++C) {
949     if (C->Kind == CodeCompletionString::CK_TypedText)
950       AppendToString(Result, C->Text, Buffer);
951   }
952 
953   return Result;
954 }
955 
956 namespace {
957   struct OrderCompletionResults {
958     bool operator()(const CXCompletionResult &XR,
959                     const CXCompletionResult &YR) const {
960       CodeCompletionString *X
961         = (CodeCompletionString *)XR.CompletionString;
962       CodeCompletionString *Y
963         = (CodeCompletionString *)YR.CompletionString;
964 
965       SmallString<256> XBuffer;
966       StringRef XText = GetTypedName(X, XBuffer);
967       SmallString<256> YBuffer;
968       StringRef YText = GetTypedName(Y, YBuffer);
969 
970       if (XText.empty() || YText.empty())
971         return !XText.empty();
972 
973       int result = XText.compare_lower(YText);
974       if (result < 0)
975         return true;
976       if (result > 0)
977         return false;
978 
979       result = XText.compare(YText);
980       return result < 0;
981     }
982   };
983 }
984 
985 void clang_sortCodeCompletionResults(CXCompletionResult *Results,
986                                      unsigned NumResults) {
987   std::stable_sort(Results, Results + NumResults, OrderCompletionResults());
988 }
989