[swift-ide-test] Use dedicated method for typeContextInfo on CompletionInstance instead of generic performOperation

We are migrating all users of `performOperation` to dedicated methods on `CodeCompletionInstance`. Do the same in `swift-ide-test`.

Author: ahoppen

include/swift/IDE/TypeContextInfo.h

@@ -40,16 +40,6 @@ class TypeContextInfoConsumer {
   virtual void handleResults(ArrayRef<TypeContextInfoItem>) = 0;
 };
 
-/// Printing consumer
-class PrintingTypeContextInfoConsumer : public TypeContextInfoConsumer {
-  llvm::raw_ostream &OS;
-
-public:
-  PrintingTypeContextInfoConsumer(llvm::raw_ostream &OS) : OS(OS) {}
-
-  void handleResults(ArrayRef<TypeContextInfoItem>) override;
-};
-
 /// Create a factory for code completion callbacks.
 CodeCompletionCallbacksFactory *
 makeTypeContextInfoCallbacksFactory(TypeContextInfoConsumer &Consumer);

lib/IDE/TypeContextInfo.cpp

@@ -173,40 +173,6 @@ void ContextInfoCallbacks::getImplicitMembers(
                            /*includeProtocolExtensionMembers*/true);
 }
 
-void PrintingTypeContextInfoConsumer::handleResults(
-    ArrayRef<TypeContextInfoItem> results) {
-  OS << "-----BEGIN TYPE CONTEXT INFO-----\n";
-  for (auto resultItem : results) {
-    OS << "- TypeName: ";
-    resultItem.ExpectedTy.print(OS);
-    OS << "\n";
-
-    OS << "  TypeUSR: ";
-    printTypeUSR(resultItem.ExpectedTy, OS);
-    OS << "\n";
-
-    OS << "  ImplicitMembers:";
-    if (resultItem.ImplicitMembers.empty())
-      OS << " []";
-    OS << "\n";
-    for (auto VD : resultItem.ImplicitMembers) {
-      OS << "   - ";
-
-      OS << "Name: ";
-      VD->getName().print(OS);
-      OS << "\n";
-
-      StringRef BriefDoc = VD->getBriefComment();
-      if (!BriefDoc.empty()) {
-        OS << "     DocBrief: \"";
-        OS << VD->getBriefComment();
-        OS << "\"\n";
-      }
-    }
-  }
-  OS << "-----END TYPE CONTEXT INFO-----\n";
-}
-
 CodeCompletionCallbacksFactory *swift::ide::makeTypeContextInfoCallbacksFactory(
     TypeContextInfoConsumer &Consumer) {
 

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

@@ -831,13 +831,27 @@ static bool setBufferForFile(StringRef SourceFilename,
   return false;
 }
 
-static bool doCodeCompletionImpl(
-    CodeCompletionCallbacksFactory *callbacksFactory,
-    const CompilerInvocation &InitInvok,
-    StringRef SourceFilename,
-    StringRef SecondSourceFileName,
-    StringRef CodeCompletionToken,
-    bool CodeCompletionDiagnostics) {
+/// Result returned from \c performWithCompletionLikeOperationParams.
+struct CompletionLikeOperationParams {
+  swift::CompilerInvocation &Invocation;
+  llvm::ArrayRef<const char *> Args;
+  llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> FileSystem;
+  llvm::MemoryBuffer *CompletionBuffer;
+  unsigned int Offset;
+  swift::DiagnosticConsumer *DiagC;
+};
+
+/// Run \p PerformOperation with the parameters that are needed to perform a
+/// completion like operation on a \c CompletionInstance. This function will
+/// return the same value as \p PerformOperation.
+/// In case there was an error setting up the parameters for the operation,
+/// this method returns \c true and does not call \p PerformOperation.
+static bool performWithCompletionLikeOperationParams(
+    const CompilerInvocation &InitInvok, StringRef SourceFilename,
+    StringRef SecondSourceFileName, StringRef CodeCompletionToken,
+    bool CodeCompletionDiagnostics,
+    llvm::function_ref<bool(CompletionLikeOperationParams Params)>
+        PerformOperation) {
   std::unique_ptr<llvm::MemoryBuffer> FileBuf;
   if (setBufferForFile(SourceFilename, FileBuf))
     return true;
@@ -865,68 +879,149 @@ static bool doCodeCompletionImpl(
   }
 
   PrintingDiagnosticConsumer PrintDiags;
-  CompletionInstance CompletionInst;
-  std::string CompletionError;
-  bool CallbackCalled = false;
-  CompletionInst.performOperation(
-      Invocation, /*Args=*/{}, llvm::vfs::getRealFileSystem(), CleanFile.get(),
-      Offset, CodeCompletionDiagnostics ? &PrintDiags : nullptr,
-      [&](CancellableResult<CompletionInstanceResult> Result) {
-        CallbackCalled = true;
-        switch (Result.getKind()) {
-        case CancellableResultKind::Success: {
-          assert(!Result->DidReuseAST &&
-                 "reusing AST context without enabling it");
-
-          if (!Result->DidFindCodeCompletionToken) {
-            // Return empty results by not performing the second pass and never
-            // calling the consumer of the callback factory.
-            return;
-          }
 
-          performCodeCompletionSecondPass(*Result->CI.getCodeCompletionFile(),
-                                          *callbacksFactory);
-          break;
-        }
-        case CancellableResultKind::Failure:
-          CompletionError = "error: " + Result.getError();
-          break;
-        case CancellableResultKind::Cancelled:
-          CompletionError = "request cancelled";
-          break;
+  CompletionLikeOperationParams Params{Invocation,
+                                       /*Args=*/{},
+                                       llvm::vfs::getRealFileSystem(),
+                                       CleanFile.get(),
+                                       Offset,
+                                       CodeCompletionDiagnostics ? &PrintDiags
+                                                                 : nullptr};
+
+  return PerformOperation(Params);
+}
+
+static bool
+doCodeCompletionImpl(CodeCompletionCallbacksFactory *callbacksFactory,
+                     const CompilerInvocation &InitInvok,
+                     StringRef SourceFilename, StringRef SecondSourceFileName,
+                     StringRef CodeCompletionToken,
+                     bool CodeCompletionDiagnostics) {
+  return performWithCompletionLikeOperationParams(
+      InitInvok, SourceFilename, SecondSourceFileName, CodeCompletionToken,
+      CodeCompletionDiagnostics,
+      [&](CompletionLikeOperationParams Params) -> bool {
+        PrintingDiagnosticConsumer PrintDiags;
+        CompletionInstance CompletionInst;
+        std::string CompletionError;
+        bool CallbackCalled = false;
+        CompletionInst.performOperation(
+            Params.Invocation, Params.Args, Params.FileSystem,
+            Params.CompletionBuffer, Params.Offset, Params.DiagC,
+            [&](CancellableResult<CompletionInstanceResult> Result) {
+              CallbackCalled = true;
+              switch (Result.getKind()) {
+              case CancellableResultKind::Success: {
+                assert(!Result->DidReuseAST &&
+                       "reusing AST context without enabling it");
+
+                if (!Result->DidFindCodeCompletionToken) {
+                  // Return empty results by not performing the second pass and
+                  // never calling the consumer of the callback factory.
+                  return;
+                }
+
+                performCodeCompletionSecondPass(
+                    *Result->CI.getCodeCompletionFile(), *callbacksFactory);
+                break;
+              }
+              case CancellableResultKind::Failure:
+                CompletionError = "error: " + Result.getError();
+                break;
+              case CancellableResultKind::Cancelled:
+                CompletionError = "request cancelled";
+                break;
+              }
+            });
+        assert(CallbackCalled &&
+               "Expected callback to be called synchronously");
+        if (CompletionError == "error: did not find code completion token") {
+          // Do not consider failure to find the code completion token as a
+          // critical failure that returns a non-zero exit code. Instead, allow
+          // the caller to match the error message.
+          llvm::outs() << CompletionError << '\n';
+        } else if (!CompletionError.empty()) {
+          llvm::errs() << CompletionError << '\n';
+          return true;
         }
+        return false;
       });
-  assert(CallbackCalled &&
-         "We should always receive a callback call for code completion");
-  if (CompletionError == "error: did not find code completion token") {
-    // Do not consider failure to find the code completion token as a critical
-    // failure that returns a non-zero exit code. Instead, allow the caller to
-    // match the error message.
-    llvm::outs() << CompletionError << '\n';
-  } else if (!CompletionError.empty()) {
-    llvm::errs() << CompletionError << '\n';
-    return true;
+}
+
+template <typename ResultType>
+static int printResult(CancellableResult<ResultType> Result,
+                       llvm::function_ref<int(ResultType &)> PrintSuccess) {
+  switch (Result.getKind()) {
+  case CancellableResultKind::Success: {
+    return PrintSuccess(Result.getResult());
+  }
+  case CancellableResultKind::Failure:
+    llvm::errs() << "error: " << Result.getError() << '\n';
+    return 1;
+  case CancellableResultKind::Cancelled:
+    llvm::errs() << "request cancelled\n";
+    return 1;
+    break;
   }
-  return false;
+}
+
+static int printTypeContextInfo(
+    CancellableResult<TypeContextInfoResult> CancellableResult) {
+  return printResult<TypeContextInfoResult>(
+      CancellableResult, [](TypeContextInfoResult &Result) {
+        llvm::outs() << "-----BEGIN TYPE CONTEXT INFO-----\n";
+        for (auto resultItem : Result.Results) {
+          llvm::outs() << "- TypeName: ";
+          resultItem.ExpectedTy.print(llvm::outs());
+          llvm::outs() << "\n";
+
+          llvm::outs() << "  TypeUSR: ";
+          printTypeUSR(resultItem.ExpectedTy, llvm::outs());
+          llvm::outs() << "\n";
+
+          llvm::outs() << "  ImplicitMembers:";
+          if (resultItem.ImplicitMembers.empty())
+            llvm::outs() << " []";
+          llvm::outs() << "\n";
+          for (auto VD : resultItem.ImplicitMembers) {
+            llvm::outs() << "   - ";
+
+            llvm::outs() << "Name: ";
+            VD->getName().print(llvm::outs());
+            llvm::outs() << "\n";
+
+            StringRef BriefDoc = VD->getBriefComment();
+            if (!BriefDoc.empty()) {
+              llvm::outs() << "     DocBrief: \"";
+              llvm::outs() << VD->getBriefComment();
+              llvm::outs() << "\"\n";
+            }
+          }
+        }
+        llvm::outs() << "-----END TYPE CONTEXT INFO-----\n";
+        return 0;
+      });
 }
 
 static int doTypeContextInfo(const CompilerInvocation &InitInvok,
                              StringRef SourceFilename,
                              StringRef SecondSourceFileName,
                              StringRef CodeCompletionToken,
                              bool CodeCompletionDiagnostics) {
-  // Create a CodeCompletionConsumer.
-  std::unique_ptr<ide::TypeContextInfoConsumer> Consumer(
-      new ide::PrintingTypeContextInfoConsumer(llvm::outs()));
-
-  // Create a factory for code completion callbacks that will feed the
-  // Consumer.
-  std::unique_ptr<CodeCompletionCallbacksFactory> callbacksFactory(
-      ide::makeTypeContextInfoCallbacksFactory(*Consumer));
-
-  return doCodeCompletionImpl(callbacksFactory.get(), InitInvok, SourceFilename,
-                              SecondSourceFileName, CodeCompletionToken,
-                              CodeCompletionDiagnostics);
+  return performWithCompletionLikeOperationParams(
+      InitInvok, SourceFilename, SecondSourceFileName, CodeCompletionToken,
+      CodeCompletionDiagnostics,
+      [&](CompletionLikeOperationParams Params) -> bool {
+        CompletionInstance CompletionInst;
+        int ExitCode = 2;
+        CompletionInst.typeContextInfo(
+            Params.Invocation, Params.Args, Params.FileSystem,
+            Params.CompletionBuffer, Params.Offset, Params.DiagC,
+            [&](CancellableResult<TypeContextInfoResult> Result) {
+              ExitCode = printTypeContextInfo(Result);
+            });
+        return ExitCode;
+      });
 }
 
 static int