[CodeComplete] Return result sink as code completion results

Previously the code completion methods just returned an `ArrayRef` that pointed into the result sink that contained the results but no effort was made to actually keep that that result sink alive, e.g. when transforming results in `transformAndForwardResults`.

Instead, return the `CodeCompletionResultSink` from the code compleiton methods now and adopt that sink from the inner results created in `transformAndForwardResults`.

Author: ahoppen

include/swift/IDE/CodeCompletion.h

@@ -1003,8 +1003,7 @@ class ImportDepth {
 class CodeCompletionContext {
   friend class CodeCompletionResultBuilder;
 
-  /// A set of current completion results, not yet delivered to the
-  /// consumer.
+  /// A set of current completion results.
   CodeCompletionResultSink CurrentResults;
 
 public:
@@ -1072,13 +1071,10 @@ class CodeCompletionContext {
   /// Allocate a string owned by the code completion context.
   StringRef copyString(StringRef Str);
 
-  /// Return current code completion results.
-  MutableArrayRef<CodeCompletionResult *> takeResults();
-
   /// Sort code completion results in an implementation-defined order
   /// in place.
-  static void sortCompletionResults(
-      MutableArrayRef<CodeCompletionResult *> Results);
+  static std::vector<CodeCompletionResult *>
+  sortCompletionResults(ArrayRef<CodeCompletionResult *> Results);
 
   CodeCompletionResultSink &getResultSink() {
     return CurrentResults;

include/swift/IDE/CompletionInstance.h

@@ -53,7 +53,7 @@ struct CompletionInstanceResult {
 
 /// The results returned from \c CompletionInstance::codeComplete.
 struct CodeCompleteResult {
-  MutableArrayRef<CodeCompletionResult *> Results;
+  CodeCompletionResultSink ResultSink;
   SwiftCompletionInfo &Info;
 };
 

lib/IDE/CodeCompletion.cpp

@@ -1354,18 +1354,6 @@ void CodeCompletionResultBuilder::finishResult() {
     Sink.Results.push_back(takeResult());
 }
 
-
-MutableArrayRef<CodeCompletionResult *> CodeCompletionContext::takeResults() {
-  // Copy pointers to the results.
-  const size_t Count = CurrentResults.Results.size();
-  CodeCompletionResult **Results =
-      CurrentResults.Allocator->Allocate<CodeCompletionResult *>(Count);
-  std::copy(CurrentResults.Results.begin(), CurrentResults.Results.end(),
-            Results);
-  CurrentResults.Results.clear();
-  return MutableArrayRef<CodeCompletionResult *>(Results, Count);
-}
-
 Optional<unsigned> CodeCompletionString::getFirstTextChunkIndex(
     bool includeLeadingPunctuation) const {
   for (auto i : indices(getChunks())) {
@@ -1451,25 +1439,29 @@ CodeCompletionString::getFirstTextChunk(bool includeLeadingPunctuation) const {
   return StringRef();
 }
 
-void CodeCompletionContext::sortCompletionResults(
-    MutableArrayRef<CodeCompletionResult *> Results) {
+std::vector<CodeCompletionResult *>
+CodeCompletionContext::sortCompletionResults(
+    ArrayRef<CodeCompletionResult *> Results) {
+  std::vector<CodeCompletionResult *> SortedResults(Results.begin(),
+                                                    Results.end());
   struct ResultAndName {
     CodeCompletionResult *result;
     std::string name;
   };
 
   // Caching the name of each field is important to avoid unnecessary calls to
   // CodeCompletionString::getName().
-  std::vector<ResultAndName> nameCache(Results.size());
-  for (unsigned i = 0, n = Results.size(); i < n; ++i) {
-    auto *result = Results[i];
+  std::vector<ResultAndName> nameCache(SortedResults.size());
+  for (unsigned i = 0, n = SortedResults.size(); i < n; ++i) {
+    auto *result = SortedResults[i];
     nameCache[i].result = result;
     llvm::raw_string_ostream OS(nameCache[i].name);
     printCodeCompletionResultFilterName(*result, OS);
     OS.flush();
   }
 
-  // Sort nameCache, and then transform Results to return the pointers in order.
+  // Sort nameCache, and then transform SortedResults to return the pointers in
+  // order.
   std::sort(nameCache.begin(), nameCache.end(),
             [](const ResultAndName &LHS, const ResultAndName &RHS) {
               int Result = StringRef(LHS.name).compare_insensitive(RHS.name);
@@ -1480,8 +1472,9 @@ void CodeCompletionContext::sortCompletionResults(
               return Result < 0;
             });
 
-  llvm::transform(nameCache, Results.begin(),
+  llvm::transform(nameCache, SortedResults.begin(),
                   [](const ResultAndName &entry) { return entry.result; });
+  return SortedResults;
 }
 
 namespace {

lib/IDE/CompletionInstance.cpp

@@ -709,9 +709,8 @@ void swift::ide::CompletionInstance::codeComplete(
           CancellationFlag->load(std::memory_order_relaxed)) {
         Callback(ResultType::cancelled());
       } else {
-        MutableArrayRef<CodeCompletionResult *> Results = context.takeResults();
         assert(SwiftContext.swiftASTContext);
-        Callback(ResultType::success({Results, SwiftContext}));
+        Callback(ResultType::success({context.getResultSink(), SwiftContext}));
       }
     }
   };

lib/IDE/REPLCodeCompletion.cpp

@@ -178,9 +178,9 @@ class REPLCodeCompletionConsumer : public SimpleCachingCodeCompletionConsumer {
       : Completions(Completions) {}
 
   void handleResults(CodeCompletionContext &context) override {
-    MutableArrayRef<CodeCompletionResult *> Results = context.takeResults();
-    CodeCompletionContext::sortCompletionResults(Results);
-    for (auto Result : Results) {
+    auto SortedResults = CodeCompletionContext::sortCompletionResults(
+        context.getResultSink().Results);
+    for (auto Result : SortedResults) {
       std::string InsertableString = toInsertableString(Result);
       if (StringRef(InsertableString).startswith(Completions.Prefix)) {
         llvm::SmallString<128> PrintedResult;

tools/SourceKit/lib/SwiftLang/SwiftCompletion.cpp

@@ -144,11 +144,18 @@ deliverCodeCompleteResults(SourceKit::CodeCompletionConsumer &SKConsumer,
 
     bool hasRequiredType = Result->Info.completionContext->typeContextKind ==
                            TypeContextKind::Required;
-    if (CCOpts.sortByName)
-      CodeCompletionContext::sortCompletionResults(Result->Results);
+    ArrayRef<CodeCompletionResult *> Results = Result->ResultSink.Results;
+    // If the results are sorted by name, this stores the sorted results, which
+    // will be referenced by `Results`.
+    std::vector<CodeCompletionResult *> SortedResultsStorage;
+    if (CCOpts.sortByName) {
+      SortedResultsStorage =
+          CodeCompletionContext::sortCompletionResults(Results);
+      Results = SortedResultsStorage;
+    }
     // FIXME: this adhoc filtering should be configurable like it is in the
     // codeCompleteOpen path.
-    for (auto *Result : Result->Results) {
+    for (auto *Result : Results) {
       if (Result->getKind() == CodeCompletionResult::ResultKind::Literal) {
         switch (Result->getLiteralKind()) {
         case CodeCompletionLiteralKind::NilLiteral:
@@ -1028,15 +1035,17 @@ static void transformAndForwardResults(
               return;
             }
             auto topResults = filterInnerResults(
-                Result->Results, options.addInnerResults,
-                options.addInnerOperators, hasDot, hasQDot, hasInit, rules);
+                ArrayRef<CodeCompletionResult *>(Result->ResultSink.Results),
+                options.addInnerResults, options.addInnerOperators, hasDot,
+                hasQDot, hasInit, rules);
             // FIXME: Clearing the flair (and semantic context) is a hack so
             // that they won't overwhelm other results that also match the
             // filter text.
             innerResults =
                 extendCompletions(topResults, innerSink, Result->Info,
                                   nameToPopularity, options, exactMatch,
                                   /*clearFlair=*/true);
+            innerSink.adoptSwiftSink(Result->ResultSink);
             break;
           }
           case CancellableResultKind::Failure:
@@ -1145,8 +1154,10 @@ void SwiftLangSupport::codeCompleteOpen(
           mayUseImplicitMemberExpr = completionCtx.MayUseImplicitMemberExpr;
           consumer.setReusingASTContext(completionCtx.ReusingASTContext);
           consumer.setAnnotatedTypename(completionCtx.getAnnotateResult());
-          completions = extendCompletions(Result->Results, sink, Result->Info,
-                                          nameToPopularity, CCOpts);
+          completions =
+              extendCompletions(Result->ResultSink.Results, sink, Result->Info,
+                                nameToPopularity, CCOpts);
+          sink.adoptSwiftSink(Result->ResultSink);
           break;
         }
         case CancellableResultKind::Failure:

tools/swift-ide-test/swift-ide-test.cpp

@@ -1056,7 +1056,7 @@ doConformingMethodList(const CompilerInvocation &InitInvok,
 }
 
 static void
-printCodeCompletionResultsImpl(MutableArrayRef<CodeCompletionResult *> Results,
+printCodeCompletionResultsImpl(ArrayRef<CodeCompletionResult *> Results,
                                llvm::raw_ostream &OS, bool IncludeKeywords,
                                bool IncludeComments, bool IncludeSourceText,
                                bool PrintAnnotatedDescription) {
@@ -1137,8 +1137,8 @@ static int printCodeCompletionResults(
   return printResult<CodeCompleteResult>(
       CancellableResult, [&](CodeCompleteResult &Result) {
         printCodeCompletionResultsImpl(
-            Result.Results, llvm::outs(), IncludeKeywords, IncludeComments,
-            IncludeSourceText, PrintAnnotatedDescription);
+            Result.ResultSink.Results, llvm::outs(), IncludeKeywords,
+            IncludeComments, IncludeSourceText, PrintAnnotatedDescription);
         return 0;
       });
 }
@@ -1514,8 +1514,9 @@ static int doBatchCodeCompletion(const CompilerInvocation &InitInvok,
           case CancellableResultKind::Success: {
             wasASTContextReused =
                 Result->Info.completionContext->ReusingASTContext;
-            printCodeCompletionResultsImpl(Result->Results, OS, IncludeKeywords,
-                                           IncludeComments, IncludeSourceText,
+            printCodeCompletionResultsImpl(Result->ResultSink.Results, OS,
+                                           IncludeKeywords, IncludeComments,
+                                           IncludeSourceText,
                                            CodeCompletionAnnotateResults);
             break;
           }