[Test] Add signature help to swift-ide-test

Author: a7medev

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

@@ -43,6 +43,8 @@
 #include "swift/IDE/IDERequests.h"
 #include "swift/IDE/ModuleInterfacePrinting.h"
 #include "swift/IDE/REPLCodeCompletion.h"
+#include "swift/IDE/SignatureHelp.h"
+#include "swift/IDE/SignatureHelpFormatter.h"
 #include "swift/IDE/SourceEntityWalker.h"
 #include "swift/IDE/SyntaxModel.h"
 #include "swift/IDE/TypeContextInfo.h"
@@ -117,6 +119,7 @@ enum class ActionType {
   Range,
   TypeContextInfo,
   ConformingMethodList,
+  SignatureHelp,
 };
 
 class NullDebuggerClient : public DebuggerClient {
@@ -251,7 +254,9 @@ Action(llvm::cl::desc("Mode:"), llvm::cl::init(ActionType::None),
                       "Print types for all expressions in the file"),
            clEnumValN(ActionType::ConformingMethodList,
 	                    "conforming-methods",
-                      "Perform conforming method analysis for expression")));
+                      "Perform conforming method analysis for expression"),
+           clEnumValN(ActionType::SignatureHelp, "signature-help",
+                      "Perform signature help")));
 
 static llvm::cl::opt<std::string>
 SourceFilename("source-filename", llvm::cl::desc("Name of the source file"),
@@ -1446,6 +1451,101 @@ printCodeCompletionLookedupTypeNames(ArrayRef<NullTerminatedStringRef> names,
   OS << "]\n";
 }
 
+static void printWithEscaping(StringRef Str, llvm::raw_ostream &OS) {
+  for (char C : Str) {
+    switch (C) {
+    case '\n':
+      OS << "\\n";
+      break;
+    case '\r':
+      OS << "\\r";
+      break;
+    case '\t':
+      OS << "\\t";
+      break;
+    case '\v':
+      OS << "\\v";
+      break;
+    case '\f':
+      OS << "\\f";
+      break;
+    default:
+      OS << C;
+      break;
+    }
+  }
+}
+
+static void printSignatureHelpResultsImpl(const FormattedSignatureHelp &Result,
+                                          llvm::raw_ostream &OS) {
+  OS << "Begin signatures, " << Result.Signatures.size() << " items\n";
+
+  for (unsigned i = 0; i < Result.Signatures.size(); ++i) {
+    const auto &Signature = Result.Signatures[i];
+    if (i == Result.ActiveSignature) {
+      OS << "Signature[Active]: ";
+    } else {
+      OS << "Signature: ";
+    }
+
+    StringRef signatureText = Signature.Text;
+    std::string formattedSignature;
+    llvm::raw_string_ostream signatureOS(formattedSignature);
+
+    unsigned currentPos = 0;
+    for (unsigned j = 0; j < Signature.Params.size(); ++j) {
+      const auto &Param = Signature.Params[j];
+
+      if (Param.Offset > currentPos) {
+        signatureOS << signatureText.substr(currentPos,
+                                            Param.Offset - currentPos);
+      }
+
+      signatureOS << "<param name=\"" << Param.Name << "\"";
+      if (Signature.ActiveParam && *Signature.ActiveParam == j) {
+        signatureOS << " active";
+      }
+      signatureOS << ">";
+      signatureOS << signatureText.substr(Param.Offset, Param.Length);
+      signatureOS << "</param>";
+
+      currentPos = Param.Offset + Param.Length;
+    }
+
+    if (currentPos < signatureText.size()) {
+      signatureOS << signatureText.substr(currentPos);
+    }
+
+    OS << formattedSignature;
+
+    if (!Signature.DocComment.empty()) {
+      OS << "; Documentation=";
+      printWithEscaping(Signature.DocComment, OS);
+    }
+
+    OS << "\n";
+  }
+
+  OS << "End signatures\n";
+}
+
+static int printSignatureHelpResults(
+    CancellableResult<SignatureHelpResults> CancellableResult) {
+  llvm::raw_fd_ostream &OS = llvm::outs();
+  return printResult<SignatureHelpResults>(
+      CancellableResult, [&](const SignatureHelpResults &Results) {
+        if (Results.Result) {
+          llvm::BumpPtrAllocator Allocator;
+          SignatureHelpFormatter Formatter(Allocator);
+          auto FormattedResult = Formatter.format(*Results.Result);
+          printSignatureHelpResultsImpl(FormattedResult, OS);
+        } else {
+          OS << "No signature help results\n";
+        }
+        return 0;
+      });
+}
+
 static int printCodeCompletionResults(
     CancellableResult<CodeCompleteResult> CancellableResult,
     bool IncludeKeywords, bool IncludeComments, bool IncludeSourceText,
@@ -1463,6 +1563,27 @@ static int printCodeCompletionResults(
       });
 }
 
+static int doSignatureHelp(const CompilerInvocation &InitInvok,
+                           StringRef SourceFilename,
+                           StringRef SecondSourceFileName,
+                           StringRef SignatureHelpToken,
+                           bool SignatureHelpDiagnostics) {
+  return performWithCompletionLikeOperationParams(
+      InitInvok, SourceFilename, SecondSourceFileName, SignatureHelpToken,
+      SignatureHelpDiagnostics,
+      [&](CompletionLikeOperationParams Params) -> bool {
+        IDEInspectionInstance Inst(std::make_shared<PluginRegistry>());
+        int ExitCode = 2;
+        Inst.signatureHelp(Params.Invocation, Params.Args, Params.FileSystem,
+                           Params.CompletionBuffer, Params.Offset, Params.DiagC,
+                           /*CancellationFlag=*/nullptr,
+                           [&](CancellableResult<SignatureHelpResults> Result) {
+                             ExitCode = printSignatureHelpResults(Result);
+                           });
+        return ExitCode;
+      });
+}
+
 static int
 doCodeCompletion(const CompilerInvocation &InitInvok, StringRef SourceFilename,
                  StringRef SecondSourceFileName, StringRef CodeCompletionToken,
@@ -3470,19 +3591,6 @@ class ASTCommentPrinter : public ASTWalker {
   ASTCommentPrinter(SourceManager &SM, XMLValidator &TheXMLValidator)
       : OS(llvm::outs()), SM(SM), TheXMLValidator(TheXMLValidator) {}
 
-  void printWithEscaping(StringRef Str) {
-    for (char C : Str) {
-      switch (C) {
-      case '\n': OS << "\\n"; break;
-      case '\r': OS << "\\r"; break;
-      case '\t': OS << "\\t"; break;
-      case '\v': OS << "\\v"; break;
-      case '\f': OS << "\\f"; break;
-      default:   OS << C;     break;
-      }
-    }
-  }
-
   void printDeclName(const ValueDecl *VD) {
     if (auto *NTD = dyn_cast<NominalTypeDecl>(VD->getDeclContext())) {
       Identifier Id = NTD->getName();
@@ -3555,7 +3663,7 @@ class ASTCommentPrinter : public ASTWalker {
     }
     OS << "[";
     for (auto &SRC : RC.Comments)
-      printWithEscaping(SRC.RawText);
+      printWithEscaping(SRC.RawText, OS);
     OS << "]";
   }
 
@@ -3566,7 +3674,7 @@ class ASTCommentPrinter : public ASTWalker {
       return;
     }
     OS << "[";
-    printWithEscaping(Brief);
+    printWithEscaping(Brief, OS);
     OS << "]";
   }
 
@@ -3582,7 +3690,7 @@ class ASTCommentPrinter : public ASTWalker {
       return;
     }
     OS << "[";
-    printWithEscaping(XML);
+    printWithEscaping(XML, OS);
     OS << "]";
 
     auto Status = TheXMLValidator.validate(XML);
@@ -4849,6 +4957,16 @@ int main(int argc, char *argv[]) {
                                       options::ConformingMethodListExpectedTypes);
     break;
 
+  case ActionType::SignatureHelp:
+    if (options::CodeCompletionToken.empty()) {
+      llvm::errs() << "signature help token name required\n";
+      return 1;
+    }
+    ExitCode = doSignatureHelp(
+        InitInvok, options::SourceFilename, options::SecondSourceFilename,
+        options::CodeCompletionToken, options::CodeCompletionDiagnostics);
+    break;
+
   case ActionType::SyntaxColoring:
     ExitCode = doSyntaxColoring(InitInvok,
                                 options::SourceFilename,