CIndexCodeCompletion.cpp revision 33e4e70c8c0a17e0ccb7465d96556b077a68ecb1 
1//===- CIndexCodeCompletion.cpp - Code Completion API hooks ---------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Clang-C Source Indexing library hooks for
11// code completion.
12//
13//===----------------------------------------------------------------------===//
14
15#include "CIndexer.h"
16#include "CXTranslationUnit.h"
17#include "CXString.h"
18#include "CIndexDiagnostic.h"
19#include "clang/Basic/SourceManager.h"
20#include "clang/Basic/FileManager.h"
21#include "clang/Frontend/ASTUnit.h"
22#include "clang/Frontend/CompilerInstance.h"
23#include "clang/Frontend/FrontendDiagnostic.h"
24#include "clang/Sema/CodeCompleteConsumer.h"
25#include "llvm/ADT/SmallString.h"
26#include "llvm/ADT/StringExtras.h"
27#include "llvm/Support/CrashRecoveryContext.h"
28#include "llvm/Support/MemoryBuffer.h"
29#include "llvm/Support/Timer.h"
30#include "llvm/Support/raw_ostream.h"
31#include "llvm/System/Program.h"
32#include <cstdlib>
33#include <cstdio>
34
35
36#ifdef UDP_CODE_COMPLETION_LOGGER
37#include "clang/Basic/Version.h"
38#include <arpa/inet.h>
39#include <sys/socket.h>
40#include <sys/types.h>
41#include <unistd.h>
42#endif
43
44using namespace clang;
45using namespace clang::cxstring;
46
47namespace {
48  /// \brief Stored representation of a completion string.
49  ///
50  /// This is the representation behind a CXCompletionString.
51  class CXStoredCodeCompletionString : public CodeCompletionString {
52    unsigned Priority;
53    CXAvailabilityKind Availability;
54
55  public:
56    CXStoredCodeCompletionString(unsigned Priority,
57                                 CXAvailabilityKind Availability)
58      : Priority(Priority), Availability(Availability) { }
59
60    unsigned getPriority() const { return Priority; }
61    CXAvailabilityKind getAvailability() const { return Availability; }
62  };
63}
64
65extern "C" {
66
67enum CXCompletionChunkKind
68clang_getCompletionChunkKind(CXCompletionString completion_string,
69                             unsigned chunk_number) {
70  CXStoredCodeCompletionString *CCStr
71    = (CXStoredCodeCompletionString *)completion_string;
72  if (!CCStr || chunk_number >= CCStr->size())
73    return CXCompletionChunk_Text;
74
75  switch ((*CCStr)[chunk_number].Kind) {
76  case CodeCompletionString::CK_TypedText:
77    return CXCompletionChunk_TypedText;
78  case CodeCompletionString::CK_Text:
79    return CXCompletionChunk_Text;
80  case CodeCompletionString::CK_Optional:
81    return CXCompletionChunk_Optional;
82  case CodeCompletionString::CK_Placeholder:
83    return CXCompletionChunk_Placeholder;
84  case CodeCompletionString::CK_Informative:
85    return CXCompletionChunk_Informative;
86  case CodeCompletionString::CK_ResultType:
87    return CXCompletionChunk_ResultType;
88  case CodeCompletionString::CK_CurrentParameter:
89    return CXCompletionChunk_CurrentParameter;
90  case CodeCompletionString::CK_LeftParen:
91    return CXCompletionChunk_LeftParen;
92  case CodeCompletionString::CK_RightParen:
93    return CXCompletionChunk_RightParen;
94  case CodeCompletionString::CK_LeftBracket:
95    return CXCompletionChunk_LeftBracket;
96  case CodeCompletionString::CK_RightBracket:
97    return CXCompletionChunk_RightBracket;
98  case CodeCompletionString::CK_LeftBrace:
99    return CXCompletionChunk_LeftBrace;
100  case CodeCompletionString::CK_RightBrace:
101    return CXCompletionChunk_RightBrace;
102  case CodeCompletionString::CK_LeftAngle:
103    return CXCompletionChunk_LeftAngle;
104  case CodeCompletionString::CK_RightAngle:
105    return CXCompletionChunk_RightAngle;
106  case CodeCompletionString::CK_Comma:
107    return CXCompletionChunk_Comma;
108  case CodeCompletionString::CK_Colon:
109    return CXCompletionChunk_Colon;
110  case CodeCompletionString::CK_SemiColon:
111    return CXCompletionChunk_SemiColon;
112  case CodeCompletionString::CK_Equal:
113    return CXCompletionChunk_Equal;
114  case CodeCompletionString::CK_HorizontalSpace:
115    return CXCompletionChunk_HorizontalSpace;
116  case CodeCompletionString::CK_VerticalSpace:
117    return CXCompletionChunk_VerticalSpace;
118  }
119
120  // Should be unreachable, but let's be careful.
121  return CXCompletionChunk_Text;
122}
123
124CXString clang_getCompletionChunkText(CXCompletionString completion_string,
125                                      unsigned chunk_number) {
126  CXStoredCodeCompletionString *CCStr
127    = (CXStoredCodeCompletionString *)completion_string;
128  if (!CCStr || chunk_number >= CCStr->size())
129    return createCXString((const char*)0);
130
131  switch ((*CCStr)[chunk_number].Kind) {
132  case CodeCompletionString::CK_TypedText:
133  case CodeCompletionString::CK_Text:
134  case CodeCompletionString::CK_Placeholder:
135  case CodeCompletionString::CK_CurrentParameter:
136  case CodeCompletionString::CK_Informative:
137  case CodeCompletionString::CK_LeftParen:
138  case CodeCompletionString::CK_RightParen:
139  case CodeCompletionString::CK_LeftBracket:
140  case CodeCompletionString::CK_RightBracket:
141  case CodeCompletionString::CK_LeftBrace:
142  case CodeCompletionString::CK_RightBrace:
143  case CodeCompletionString::CK_LeftAngle:
144  case CodeCompletionString::CK_RightAngle:
145  case CodeCompletionString::CK_Comma:
146  case CodeCompletionString::CK_ResultType:
147  case CodeCompletionString::CK_Colon:
148  case CodeCompletionString::CK_SemiColon:
149  case CodeCompletionString::CK_Equal:
150  case CodeCompletionString::CK_HorizontalSpace:
151  case CodeCompletionString::CK_VerticalSpace:
152    return createCXString((*CCStr)[chunk_number].Text, false);
153
154  case CodeCompletionString::CK_Optional:
155    // Note: treated as an empty text block.
156    return createCXString("");
157  }
158
159  // Should be unreachable, but let's be careful.
160  return createCXString((const char*)0);
161}
162
163
164CXCompletionString
165clang_getCompletionChunkCompletionString(CXCompletionString completion_string,
166                                         unsigned chunk_number) {
167  CXStoredCodeCompletionString *CCStr
168    = (CXStoredCodeCompletionString *)completion_string;
169  if (!CCStr || chunk_number >= CCStr->size())
170    return 0;
171
172  switch ((*CCStr)[chunk_number].Kind) {
173  case CodeCompletionString::CK_TypedText:
174  case CodeCompletionString::CK_Text:
175  case CodeCompletionString::CK_Placeholder:
176  case CodeCompletionString::CK_CurrentParameter:
177  case CodeCompletionString::CK_Informative:
178  case CodeCompletionString::CK_LeftParen:
179  case CodeCompletionString::CK_RightParen:
180  case CodeCompletionString::CK_LeftBracket:
181  case CodeCompletionString::CK_RightBracket:
182  case CodeCompletionString::CK_LeftBrace:
183  case CodeCompletionString::CK_RightBrace:
184  case CodeCompletionString::CK_LeftAngle:
185  case CodeCompletionString::CK_RightAngle:
186  case CodeCompletionString::CK_Comma:
187  case CodeCompletionString::CK_ResultType:
188  case CodeCompletionString::CK_Colon:
189  case CodeCompletionString::CK_SemiColon:
190  case CodeCompletionString::CK_Equal:
191  case CodeCompletionString::CK_HorizontalSpace:
192  case CodeCompletionString::CK_VerticalSpace:
193    return 0;
194
195  case CodeCompletionString::CK_Optional:
196    // Note: treated as an empty text block.
197    return (*CCStr)[chunk_number].Optional;
198  }
199
200  // Should be unreachable, but let's be careful.
201  return 0;
202}
203
204unsigned clang_getNumCompletionChunks(CXCompletionString completion_string) {
205  CXStoredCodeCompletionString *CCStr
206    = (CXStoredCodeCompletionString *)completion_string;
207  return CCStr? CCStr->size() : 0;
208}
209
210unsigned clang_getCompletionPriority(CXCompletionString completion_string) {
211  CXStoredCodeCompletionString *CCStr
212    = (CXStoredCodeCompletionString *)completion_string;
213  return CCStr? CCStr->getPriority() : unsigned(CCP_Unlikely);
214}
215
216enum CXAvailabilityKind
217clang_getCompletionAvailability(CXCompletionString completion_string) {
218  CXStoredCodeCompletionString *CCStr
219    = (CXStoredCodeCompletionString *)completion_string;
220  return CCStr? CCStr->getAvailability() : CXAvailability_Available;
221}
222
223/// \brief The CXCodeCompleteResults structure we allocate internally;
224/// the client only sees the initial CXCodeCompleteResults structure.
225struct AllocatedCXCodeCompleteResults : public CXCodeCompleteResults {
226  AllocatedCXCodeCompleteResults();
227  ~AllocatedCXCodeCompleteResults();
228
229  /// \brief Diagnostics produced while performing code completion.
230  llvm::SmallVector<StoredDiagnostic, 8> Diagnostics;
231
232  /// \brief Diag object
233  llvm::IntrusiveRefCntPtr<Diagnostic> Diag;
234
235  /// \brief Language options used to adjust source locations.
236  LangOptions LangOpts;
237
238  /// \brief File manager, used for diagnostics.
239  FileManager FileMgr;
240
241  FileSystemOptions FileSystemOpts;
242
243  /// \brief Source manager, used for diagnostics.
244  SourceManager SourceMgr;
245
246  /// \brief Temporary files that should be removed once we have finished
247  /// with the code-completion results.
248  std::vector<llvm::sys::Path> TemporaryFiles;
249
250  /// \brief Temporary buffers that will be deleted once we have finished with the code-completion results.
251  llvm::SmallVector<const llvm::MemoryBuffer *, 1> TemporaryBuffers;
252};
253
254/// \brief Tracks the number of code-completion result objects that are
255/// currently active.
256///
257/// Used for debugging purposes only.
258static unsigned CodeCompletionResultObjects;
259
260AllocatedCXCodeCompleteResults::AllocatedCXCodeCompleteResults()
261  : CXCodeCompleteResults(),
262    Diag(new Diagnostic(
263                   llvm::IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs))),
264    SourceMgr(*Diag, FileMgr, FileSystemOpts) {
265  if (getenv("LIBCLANG_OBJTRACKING")) {
266    ++CodeCompletionResultObjects;
267    fprintf(stderr, "+++ %d completion results\n", CodeCompletionResultObjects);
268  }
269}
270
271AllocatedCXCodeCompleteResults::~AllocatedCXCodeCompleteResults() {
272  for (unsigned I = 0, N = NumResults; I != N; ++I)
273    delete (CXStoredCodeCompletionString *)Results[I].CompletionString;
274  delete [] Results;
275
276  for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I)
277    TemporaryFiles[I].eraseFromDisk();
278  for (unsigned I = 0, N = TemporaryBuffers.size(); I != N; ++I)
279    delete TemporaryBuffers[I];
280
281  if (getenv("LIBCLANG_OBJTRACKING")) {
282    --CodeCompletionResultObjects;
283    fprintf(stderr, "--- %d completion results\n", CodeCompletionResultObjects);
284  }
285}
286
287} // end extern "C"
288
289namespace {
290  class CaptureCompletionResults : public CodeCompleteConsumer {
291    AllocatedCXCodeCompleteResults &AllocatedResults;
292    llvm::SmallVector<CXCompletionResult, 16> StoredResults;
293
294  public:
295    explicit CaptureCompletionResults(AllocatedCXCodeCompleteResults &Results)
296      : CodeCompleteConsumer(true, false, true, false),
297        AllocatedResults(Results) { }
298    ~CaptureCompletionResults() { Finish(); }
299
300    virtual void ProcessCodeCompleteResults(Sema &S,
301                                            CodeCompletionContext Context,
302                                            CodeCompletionResult *Results,
303                                            unsigned NumResults) {
304      StoredResults.reserve(StoredResults.size() + NumResults);
305      for (unsigned I = 0; I != NumResults; ++I) {
306        CXStoredCodeCompletionString *StoredCompletion
307          = new CXStoredCodeCompletionString(Results[I].Priority,
308                                             Results[I].Availability);
309        (void)Results[I].CreateCodeCompletionString(S, StoredCompletion);
310
311        CXCompletionResult R;
312        R.CursorKind = Results[I].CursorKind;
313        R.CompletionString = StoredCompletion;
314        StoredResults.push_back(R);
315      }
316    }
317
318    virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
319                                           OverloadCandidate *Candidates,
320                                           unsigned NumCandidates) {
321      StoredResults.reserve(StoredResults.size() + NumCandidates);
322      for (unsigned I = 0; I != NumCandidates; ++I) {
323        // FIXME: Set priority, availability appropriately.
324        CXStoredCodeCompletionString *StoredCompletion
325          = new CXStoredCodeCompletionString(1, CXAvailability_Available);
326        (void)Candidates[I].CreateSignatureString(CurrentArg, S,
327                                                  StoredCompletion);
328
329        CXCompletionResult R;
330        R.CursorKind = CXCursor_NotImplemented;
331        R.CompletionString = StoredCompletion;
332        StoredResults.push_back(R);
333      }
334    }
335
336  private:
337    void Finish() {
338      AllocatedResults.Results = new CXCompletionResult [StoredResults.size()];
339      AllocatedResults.NumResults = StoredResults.size();
340      std::memcpy(AllocatedResults.Results, StoredResults.data(),
341                  StoredResults.size() * sizeof(CXCompletionResult));
342      StoredResults.clear();
343    }
344  };
345}
346
347extern "C" {
348struct CodeCompleteAtInfo {
349  CXTranslationUnit TU;
350  const char *complete_filename;
351  unsigned complete_line;
352  unsigned complete_column;
353  struct CXUnsavedFile *unsaved_files;
354  unsigned num_unsaved_files;
355  unsigned options;
356  CXCodeCompleteResults *result;
357};
358void clang_codeCompleteAt_Impl(void *UserData) {
359  CodeCompleteAtInfo *CCAI = static_cast<CodeCompleteAtInfo*>(UserData);
360  CXTranslationUnit TU = CCAI->TU;
361  const char *complete_filename = CCAI->complete_filename;
362  unsigned complete_line = CCAI->complete_line;
363  unsigned complete_column = CCAI->complete_column;
364  struct CXUnsavedFile *unsaved_files = CCAI->unsaved_files;
365  unsigned num_unsaved_files = CCAI->num_unsaved_files;
366  unsigned options = CCAI->options;
367  CCAI->result = 0;
368
369#ifdef UDP_CODE_COMPLETION_LOGGER
370#ifdef UDP_CODE_COMPLETION_LOGGER_PORT
371  const llvm::TimeRecord &StartTime =  llvm::TimeRecord::getCurrentTime();
372#endif
373#endif
374
375  bool EnableLogging = getenv("LIBCLANG_CODE_COMPLETION_LOGGING") != 0;
376
377  ASTUnit *AST = static_cast<ASTUnit *>(TU->TUData);
378  if (!AST)
379    return;
380
381  ASTUnit::ConcurrencyCheck Check(*AST);
382
383  // Perform the remapping of source files.
384  llvm::SmallVector<ASTUnit::RemappedFile, 4> RemappedFiles;
385  for (unsigned I = 0; I != num_unsaved_files; ++I) {
386    llvm::StringRef Data(unsaved_files[I].Contents, unsaved_files[I].Length);
387    const llvm::MemoryBuffer *Buffer
388      = llvm::MemoryBuffer::getMemBufferCopy(Data, unsaved_files[I].Filename);
389    RemappedFiles.push_back(std::make_pair(unsaved_files[I].Filename,
390                                           Buffer));
391  }
392
393  if (EnableLogging) {
394    // FIXME: Add logging.
395  }
396
397  // Parse the resulting source file to find code-completion results.
398  AllocatedCXCodeCompleteResults *Results = new AllocatedCXCodeCompleteResults;
399  Results->Results = 0;
400  Results->NumResults = 0;
401
402  // Create a code-completion consumer to capture the results.
403  CaptureCompletionResults Capture(*Results);
404
405  // Perform completion.
406  AST->CodeComplete(complete_filename, complete_line, complete_column,
407                    RemappedFiles.data(), RemappedFiles.size(),
408                    (options & CXCodeComplete_IncludeMacros),
409                    (options & CXCodeComplete_IncludeCodePatterns),
410                    Capture,
411                    *Results->Diag, Results->LangOpts, Results->SourceMgr,
412                    Results->FileMgr, Results->Diagnostics,
413                    Results->TemporaryBuffers);
414
415
416
417#ifdef UDP_CODE_COMPLETION_LOGGER
418#ifdef UDP_CODE_COMPLETION_LOGGER_PORT
419  const llvm::TimeRecord &EndTime =  llvm::TimeRecord::getCurrentTime();
420  llvm::SmallString<256> LogResult;
421  llvm::raw_svector_ostream os(LogResult);
422
423  // Figure out the language and whether or not it uses PCH.
424  const char *lang = 0;
425  bool usesPCH = false;
426
427  for (std::vector<const char*>::iterator I = argv.begin(), E = argv.end();
428       I != E; ++I) {
429    if (*I == 0)
430      continue;
431    if (strcmp(*I, "-x") == 0) {
432      if (I + 1 != E) {
433        lang = *(++I);
434        continue;
435      }
436    }
437    else if (strcmp(*I, "-include") == 0) {
438      if (I+1 != E) {
439        const char *arg = *(++I);
440        llvm::SmallString<512> pchName;
441        {
442          llvm::raw_svector_ostream os(pchName);
443          os << arg << ".pth";
444        }
445        pchName.push_back('\0');
446        struct stat stat_results;
447        if (stat(pchName.data(), &stat_results) == 0)
448          usesPCH = true;
449        continue;
450      }
451    }
452  }
453
454  os << "{ ";
455  os << "\"wall\": " << (EndTime.getWallTime() - StartTime.getWallTime());
456  os << ", \"numRes\": " << Results->NumResults;
457  os << ", \"diags\": " << Results->Diagnostics.size();
458  os << ", \"pch\": " << (usesPCH ? "true" : "false");
459  os << ", \"lang\": \"" << (lang ? lang : "<unknown>") << '"';
460  const char *name = getlogin();
461  os << ", \"user\": \"" << (name ? name : "unknown") << '"';
462  os << ", \"clangVer\": \"" << getClangFullVersion() << '"';
463  os << " }";
464
465  llvm::StringRef res = os.str();
466  if (res.size() > 0) {
467    do {
468      // Setup the UDP socket.
469      struct sockaddr_in servaddr;
470      bzero(&servaddr, sizeof(servaddr));
471      servaddr.sin_family = AF_INET;
472      servaddr.sin_port = htons(UDP_CODE_COMPLETION_LOGGER_PORT);
473      if (inet_pton(AF_INET, UDP_CODE_COMPLETION_LOGGER,
474                    &servaddr.sin_addr) <= 0)
475        break;
476
477      int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
478      if (sockfd < 0)
479        break;
480
481      sendto(sockfd, res.data(), res.size(), 0,
482             (struct sockaddr *)&servaddr, sizeof(servaddr));
483      close(sockfd);
484    }
485    while (false);
486  }
487#endif
488#endif
489  CCAI->result = Results;
490}
491CXCodeCompleteResults *clang_codeCompleteAt(CXTranslationUnit TU,
492                                            const char *complete_filename,
493                                            unsigned complete_line,
494                                            unsigned complete_column,
495                                            struct CXUnsavedFile *unsaved_files,
496                                            unsigned num_unsaved_files,
497                                            unsigned options) {
498  CodeCompleteAtInfo CCAI = { TU, complete_filename, complete_line,
499                              complete_column, unsaved_files, num_unsaved_files,
500                              options, 0 };
501  llvm::CrashRecoveryContext CRC;
502
503  if (!RunSafely(CRC, clang_codeCompleteAt_Impl, &CCAI)) {
504    fprintf(stderr, "libclang: crash detected in code completion\n");
505    static_cast<ASTUnit *>(TU->TUData)->setUnsafeToFree(true);
506    return 0;
507  }
508
509  return CCAI.result;
510}
511
512unsigned clang_defaultCodeCompleteOptions(void) {
513  return CXCodeComplete_IncludeMacros;
514}
515
516void clang_disposeCodeCompleteResults(CXCodeCompleteResults *ResultsIn) {
517  if (!ResultsIn)
518    return;
519
520  AllocatedCXCodeCompleteResults *Results
521    = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn);
522  delete Results;
523}
524
525unsigned
526clang_codeCompleteGetNumDiagnostics(CXCodeCompleteResults *ResultsIn) {
527  AllocatedCXCodeCompleteResults *Results
528    = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn);
529  if (!Results)
530    return 0;
531
532  return Results->Diagnostics.size();
533}
534
535CXDiagnostic
536clang_codeCompleteGetDiagnostic(CXCodeCompleteResults *ResultsIn,
537                                unsigned Index) {
538  AllocatedCXCodeCompleteResults *Results
539    = static_cast<AllocatedCXCodeCompleteResults*>(ResultsIn);
540  if (!Results || Index >= Results->Diagnostics.size())
541    return 0;
542
543  return new CXStoredDiagnostic(Results->Diagnostics[Index], Results->LangOpts);
544}
545
546
547} // end extern "C"
548
549/// \brief Simple utility function that appends a \p New string to the given
550/// \p Old string, using the \p Buffer for storage.
551///
552/// \param Old The string to which we are appending. This parameter will be
553/// updated to reflect the complete string.
554///
555///
556/// \param New The string to append to \p Old.
557///
558/// \param Buffer A buffer that stores the actual, concatenated string. It will
559/// be used if the old string is already-non-empty.
560static void AppendToString(llvm::StringRef &Old, llvm::StringRef New,
561                           llvm::SmallString<256> &Buffer) {
562  if (Old.empty()) {
563    Old = New;
564    return;
565  }
566
567  if (Buffer.empty())
568    Buffer.append(Old.begin(), Old.end());
569  Buffer.append(New.begin(), New.end());
570  Old = Buffer.str();
571}
572
573/// \brief Get the typed-text blocks from the given code-completion string
574/// and return them as a single string.
575///
576/// \param String The code-completion string whose typed-text blocks will be
577/// concatenated.
578///
579/// \param Buffer A buffer used for storage of the completed name.
580static llvm::StringRef GetTypedName(CodeCompletionString *String,
581                                    llvm::SmallString<256> &Buffer) {
582  llvm::StringRef Result;
583  for (CodeCompletionString::iterator C = String->begin(), CEnd = String->end();
584       C != CEnd; ++C) {
585    if (C->Kind == CodeCompletionString::CK_TypedText)
586      AppendToString(Result, C->Text, Buffer);
587  }
588
589  return Result;
590}
591
592namespace {
593  struct OrderCompletionResults {
594    bool operator()(const CXCompletionResult &XR,
595                    const CXCompletionResult &YR) const {
596      CXStoredCodeCompletionString *X
597        = (CXStoredCodeCompletionString *)XR.CompletionString;
598      CXStoredCodeCompletionString *Y
599        = (CXStoredCodeCompletionString *)YR.CompletionString;
600
601      llvm::SmallString<256> XBuffer;
602      llvm::StringRef XText = GetTypedName(X, XBuffer);
603      llvm::SmallString<256> YBuffer;
604      llvm::StringRef YText = GetTypedName(Y, YBuffer);
605
606      if (XText.empty() || YText.empty())
607        return !XText.empty();
608
609      int result = XText.compare_lower(YText);
610      if (result < 0)
611        return true;
612      if (result > 0)
613        return false;
614
615      result = XText.compare(YText);
616      return result < 0;
617    }
618  };
619}
620
621extern "C" {
622  void clang_sortCodeCompletionResults(CXCompletionResult *Results,
623                                       unsigned NumResults) {
624    std::stable_sort(Results, Results + NumResults, OrderCompletionResults());
625  }
626}
627