2 files changed, 65 insertions, 34 deletions

diff --git a/tools/c-index-test/c-index-test.c b/tools/c-index-test/c-index-test.c
index 4b9ab500dc..773c009321 100644
--- a/tools/c-index-test/c-index-test.c
+++ b/tools/c-index-test/c-index-test.c
@@ -817,7 +817,7 @@ static int perform_file_scan(const char *ast_file, const char *source_file,
 }
 
 /******************************************************************************/
-/* Logic for testing clang_codeComplete().                                    */
+/* Logic for testing clang code completion.                                   */
 /******************************************************************************/
 
 /* Parse file:line:column from the input string. Returns 0 on success, non-zero
@@ -1002,6 +1002,11 @@ int perform_code_completion(int argc, const char **argv, int timing_only) {
   int num_unsaved_files = 0;
   CXCodeCompleteResults *results = 0;
   CXTranslationUnit TU = 0;
+  unsigned I, Repeats = 1;
+  unsigned completionOptions = clang_defaultCodeCompleteOptions();
+  
+  if (getenv("CINDEXTEST_CODE_COMPLETE_PATTERNS"))
+    completionOptions |= CXCodeComplete_IncludeCodePatterns;
   
   if (timing_only)
     input += strlen("-code-completion-timing=");
@@ -1015,34 +1020,31 @@ int perform_code_completion(int argc, const char **argv, int timing_only) {
   if (parse_remapped_files(argc, argv, 2, &unsaved_files, &num_unsaved_files))
     return -1;
 
-  CIdx = clang_createIndex(0, 1);
-  if (getenv("CINDEXTEST_EDITING")) {
-    unsigned I, Repeats = 5;
-    TU = clang_parseTranslationUnit(CIdx, 0,
-                                    argv + num_unsaved_files + 2,
-                                    argc - num_unsaved_files - 2,
-                                    0, 0, getDefaultParsingOptions());
-    if (!TU) {
-      fprintf(stderr, "Unable to load translation unit!\n");
+  CIdx = clang_createIndex(0, 0);
+  
+  if (getenv("CINDEXTEST_EDITING"))
+    Repeats = 5;
+  
+  TU = clang_parseTranslationUnit(CIdx, 0,
+                                  argv + num_unsaved_files + 2,
+                                  argc - num_unsaved_files - 2,
+                                  0, 0, getDefaultParsingOptions());
+  if (!TU) {
+    fprintf(stderr, "Unable to load translation unit!\n");
+    return 1;
+  }
+  
+  for (I = 0; I != Repeats; ++I) {
+    results = clang_codeCompleteAt(TU, filename, line, column,
+                                   unsaved_files, num_unsaved_files,
+                                   completionOptions);
+    if (!results) {
+      fprintf(stderr, "Unable to perform code completion!\n");
       return 1;
     }
-    for (I = 0; I != Repeats; ++I) {
-      results = clang_codeCompleteAt(TU, filename, line, column,
-                                     unsaved_files, num_unsaved_files,
-                                     clang_defaultCodeCompleteOptions());
-      if (!results) {
-        fprintf(stderr, "Unable to perform code completion!\n");
-        return 1;
-      }
-      if (I != Repeats-1)
-        clang_disposeCodeCompleteResults(results);
-    }
-  } else
-    results = clang_codeComplete(CIdx,
-                                 argv[argc - 1], argc - num_unsaved_files - 3,
-                                 argv + num_unsaved_files + 2,
-                                 num_unsaved_files, unsaved_files,
-                                 filename, line, column);
+    if (I != Repeats-1)
+      clang_disposeCodeCompleteResults(results);
+  }
 
   if (results) {
     unsigned i, n = results->NumResults;
diff --git a/tools/libclang/CIndexCodeCompletion.cpp b/tools/libclang/CIndexCodeCompletion.cpp
index f33fdbe5f7..f64faa44c0 100644
--- a/tools/libclang/CIndexCodeCompletion.cpp
+++ b/tools/libclang/CIndexCodeCompletion.cpp
@@ -559,29 +559,58 @@ CXCodeCompleteResults *clang_codeComplete(CXIndex CIdx,
 namespace {
   class CaptureCompletionResults : public CodeCompleteConsumer {
     AllocatedCXCodeCompleteResults &AllocatedResults;
-
+    llvm::SmallVector<CXCompletionResult, 16> StoredResults;
+    
   public:
     explicit CaptureCompletionResults(AllocatedCXCodeCompleteResults &Results)
       : CodeCompleteConsumer(true, false, true, false), 
         AllocatedResults(Results) { }
-
+    ~CaptureCompletionResults() { Finish(); }
+    
     virtual void ProcessCodeCompleteResults(Sema &S, 
                                             CodeCompletionContext Context,
                                             CodeCompletionResult *Results,
                                             unsigned NumResults) {
-      AllocatedResults.Results = new CXCompletionResult [NumResults];
-      AllocatedResults.NumResults = NumResults;
+      StoredResults.reserve(StoredResults.size() + NumResults);
       for (unsigned I = 0; I != NumResults; ++I) {
         CXStoredCodeCompletionString *StoredCompletion
           = new CXStoredCodeCompletionString(Results[I].Priority,
                                              Results[I].Availability);
         (void)Results[I].CreateCodeCompletionString(S, StoredCompletion);
-        AllocatedResults.Results[I].CursorKind = Results[I].CursorKind;
-        AllocatedResults.Results[I].CompletionString = StoredCompletion;
+        
+        CXCompletionResult R;
+        R.CursorKind = Results[I].CursorKind;
+        R.CompletionString = StoredCompletion;
+        StoredResults.push_back(R);
       }
     }
     
-    // FIXME: Add ProcessOverloadCandidates?
+    virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
+                                           OverloadCandidate *Candidates,
+                                           unsigned NumCandidates) {
+      StoredResults.reserve(StoredResults.size() + NumCandidates);
+      for (unsigned I = 0; I != NumCandidates; ++I) {
+        // FIXME: Set priority, availability appropriately.
+        CXStoredCodeCompletionString *StoredCompletion
+          = new CXStoredCodeCompletionString(1, CXAvailability_Available);
+        (void)Candidates[I].CreateSignatureString(CurrentArg, S, 
+                                                  StoredCompletion);
+        
+        CXCompletionResult R;
+        R.CursorKind = CXCursor_NotImplemented;
+        R.CompletionString = StoredCompletion;
+        StoredResults.push_back(R);
+      }
+    }
+    
+  private:
+    void Finish() {
+      AllocatedResults.Results = new CXCompletionResult [StoredResults.size()];
+      AllocatedResults.NumResults = StoredResults.size();
+      std::memcpy(AllocatedResults.Results, StoredResults.data(), 
+                  StoredResults.size() * sizeof(CXCompletionResult));
+      StoredResults.clear();
+    }
   };
 }