Merge pull request #34417 from artemcm/FrontendParseableOutput

Add support for parseable-output straight from the frontend

Author: artemcm

include/swift/Basic/ParseableOutput.h

@@ -0,0 +1,78 @@
+//===----- ParseableOutput.h - Helpers for parseable output ------- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Helpers for emitting the compiler's parseable output.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_PARSEABLEOUTPUT_H
+#define SWIFT_PARSEABLEOUTPUT_H
+
+#include "swift/Basic/LLVM.h"
+#include "swift/Basic/TaskQueue.h"
+#include "swift/Basic/FileTypes.h"
+
+namespace swift {
+
+namespace parseable_output {
+
+/// Quasi-PIDs are _negative_ PID-like unique keys used to
+/// masquerade batch job constituents as (quasi)processes, when writing
+/// parseable output to consumers that don't understand the idea of a batch
+/// job. They are negative in order to avoid possibly colliding with real
+/// PIDs (which are always positive). We start at -1000 here as a crude but
+/// harmless hedge against colliding with an errno value that might slip
+/// into the stream of real PIDs (say, due to a TaskQueue bug).
+const int QUASI_PID_START = -1000;
+
+struct CommandInput {
+  std::string Path;
+  CommandInput() {}
+  CommandInput(StringRef Path) : Path(Path) {}
+};
+
+using OutputPair = std::pair<file_types::ID, std::string>;
+
+/// A client-agnostic (e.g. either the compiler driver or `swift-frontend`)
+/// description of a task that is the subject of a parseable-output message.
+struct DetailedTaskDescription {
+  std::string Executable;
+  SmallVector<std::string, 16> Arguments;
+  std::string CommandLine;
+  SmallVector<CommandInput, 4> Inputs;
+  SmallVector<OutputPair, 8> Outputs;
+};
+
+/// Emits a "began" message to the given stream.
+void emitBeganMessage(raw_ostream &os, StringRef Name,
+                      DetailedTaskDescription TascDesc,
+                      int64_t Pid, sys::TaskProcessInformation ProcInfo);
+
+/// Emits a "finished" message to the given stream.
+void emitFinishedMessage(raw_ostream &os, StringRef Name,
+                         std::string Output, int ExitStatus,
+                         int64_t Pid, sys::TaskProcessInformation ProcInfo);
+
+/// Emits a "signalled" message to the given stream.
+void emitSignalledMessage(raw_ostream &os, StringRef Name, StringRef ErrorMsg,
+                          StringRef Output, Optional<int> Signal,
+                          int64_t Pid, sys::TaskProcessInformation ProcInfo);
+
+/// Emits a "skipped" message to the given stream.
+void emitSkippedMessage(raw_ostream &os, StringRef Name,
+                        DetailedTaskDescription TascDesc);
+
+} // end namespace parseable_output
+} // end namespace swift
+
+#endif

include/swift/Basic/SupplementaryOutputPaths.h

@@ -14,6 +14,7 @@
 #define SWIFT_FRONTEND_SUPPLEMENTARYOUTPUTPATHS_H
 
 #include "swift/Basic/LLVM.h"
+#include "llvm/IR/Function.h"
 
 #include <string>
 
@@ -171,6 +172,42 @@ struct SupplementaryOutputPaths {
   SupplementaryOutputPaths() = default;
   SupplementaryOutputPaths(const SupplementaryOutputPaths &) = default;
 
+  /// Apply a given function for each existing (non-empty string) supplementary output
+  void forEachSetOutput(llvm::function_ref<void(const std::string&)> fn) const {
+    if (!ObjCHeaderOutputPath.empty())
+      fn(ObjCHeaderOutputPath); 
+    if (!ModuleOutputPath.empty())
+      fn(ModuleOutputPath); 
+    if (!ModuleSourceInfoOutputPath.empty())
+      fn(ModuleSourceInfoOutputPath); 
+    if (!ModuleDocOutputPath.empty())
+      fn(ModuleDocOutputPath); 
+    if (!DependenciesFilePath.empty())
+      fn(DependenciesFilePath); 
+    if (!ReferenceDependenciesFilePath.empty())
+      fn(ReferenceDependenciesFilePath); 
+    if (!SwiftRangesFilePath.empty())
+      fn(SwiftRangesFilePath); 
+    if (!CompiledSourceFilePath.empty())
+      fn(CompiledSourceFilePath); 
+    if (!SerializedDiagnosticsPath.empty())
+      fn(SerializedDiagnosticsPath); 
+    if (!FixItsOutputPath.empty())
+      fn(FixItsOutputPath); 
+    if (!LoadedModuleTracePath.empty())
+      fn(LoadedModuleTracePath); 
+    if (!TBDPath.empty())
+      fn(TBDPath); 
+    if (!ModuleInterfaceOutputPath.empty())
+      fn(ModuleInterfaceOutputPath); 
+    if (!PrivateModuleInterfaceOutputPath.empty())
+      fn(PrivateModuleInterfaceOutputPath); 
+    if (!LdAddCFilePath.empty())
+      fn(LdAddCFilePath); 
+    if (!ModuleSummaryOutputPath.empty())
+      fn(ModuleSummaryOutputPath); 
+  }
+
   bool empty() const {
     return ObjCHeaderOutputPath.empty() && ModuleOutputPath.empty() &&
            ModuleDocOutputPath.empty() && DependenciesFilePath.empty() &&

include/swift/Driver/ParseableOutput.h

@@ -0,0 +1,97 @@
+//===- AccumulatingDiagnosticConsumer.h - Collect Text Diagnostics  C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the AccumulatingDiagnosticConsumer class, which collects
+//  all emitted diagnostics into an externally-owned collection.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_ACCUMULATINGDIAGNOSTICCONSUMER_H
+#define SWIFT_ACCUMULATINGDIAGNOSTICCONSUMER_H
+
+#include "swift/AST/DiagnosticConsumer.h"
+#include "swift/Basic/DiagnosticOptions.h"
+#include "swift/Basic/LLVM.h"
+
+#include <string>
+#include <sstream>
+
+namespace swift {
+/// Diagnostic consumer that simply collects all emitted diagnostics into the provided
+/// collection.
+class AccumulatingFileDiagnosticConsumer : public DiagnosticConsumer {
+  std::vector<std::string> &Diagnostics;
+
+public:
+  AccumulatingFileDiagnosticConsumer(std::vector<std::string> &DiagBuffer)
+    : Diagnostics(DiagBuffer) {}
+
+private:
+  void handleDiagnostic(SourceManager &SM,
+                        const DiagnosticInfo &Info) override {
+    addDiagnostic(SM, Info);
+
+    for (auto ChildInfo : Info.ChildDiagnosticInfo) {
+      addDiagnostic(SM, *ChildInfo);
+    }
+  }
+
+  // TODO: Support Swift-style diagnostic formatting
+  void addDiagnostic(SourceManager &SM, const DiagnosticInfo &Info) {
+    // Determine what kind of diagnostic we're emitting.
+    llvm::SourceMgr::DiagKind SMKind;
+    switch (Info.Kind) {
+    case DiagnosticKind::Error:
+      SMKind = llvm::SourceMgr::DK_Error;
+      break;
+    case DiagnosticKind::Warning:
+      SMKind = llvm::SourceMgr::DK_Warning;
+      break;
+
+    case DiagnosticKind::Note:
+      SMKind = llvm::SourceMgr::DK_Note;
+      break;
+
+    case DiagnosticKind::Remark:
+      SMKind = llvm::SourceMgr::DK_Remark;
+      break;
+    }
+
+    // Translate ranges.
+    SmallVector<llvm::SMRange, 2> Ranges;
+    for (auto R : Info.Ranges)
+      Ranges.push_back(getRawRange(SM, R));
+
+    // Translate fix-its.
+    SmallVector<llvm::SMFixIt, 2> FixIts;
+    for (DiagnosticInfo::FixIt F : Info.FixIts)
+      FixIts.push_back(getRawFixIt(SM, F));
+
+    // Actually substitute the diagnostic arguments into the diagnostic text.
+    llvm::SmallString<256> Text;
+    {
+      llvm::raw_svector_ostream Out(Text);
+      DiagnosticEngine::formatDiagnosticText(Out, Info.FormatString,
+                                             Info.FormatArgs);
+    }
+
+    const llvm::SourceMgr &rawSM = SM.getLLVMSourceMgr();
+    auto Msg = SM.GetMessage(Info.Loc, SMKind, Text, Ranges, FixIts);
+    std::string result;
+    llvm::raw_string_ostream os(result);
+    rawSM.PrintMessage(os, Msg, false);
+    os.flush();
+    Diagnostics.push_back(result);
+  }
+};
+}
+#endif

include/swift/Frontend/AccumulatingDiagnosticConsumer.h

@@ -110,6 +110,11 @@ class FrontendInputsAndOutputs {
   bool
   forEachPrimaryInput(llvm::function_ref<bool(const InputFile &)> fn) const;
 
+  /// Iterates over primary inputs, exposing their unique ordered index
+  /// If \p fn returns true, exit early and return true.
+  bool forEachPrimaryInputWithIndex(
+      llvm::function_ref<bool(const InputFile &, unsigned index)> fn) const;
+
   /// If \p fn returns true, exit early and return true.
   bool
   forEachNonPrimaryInput(llvm::function_ref<bool(const InputFile &)> fn) const;

include/swift/Frontend/FrontendInputsAndOutputs.h

@@ -184,6 +184,11 @@ class FrontendOptions {
   /// entity.
   bool ProfileEntities = false;
 
+  /// Emit parseable-output directly from the frontend, instead of relying
+  /// the driver to emit it. This is used in context where frontend jobs are executed by
+  /// clients other than the driver.
+  bool FrontendParseableOutput = false;
+
   /// Indicates whether or not an import statement can pick up a Swift source
   /// file (as opposed to a module file).
   bool EnableSourceImport = false;

include/swift/Frontend/FrontendOptions.h

@@ -30,6 +30,8 @@ def output_filelist : Separate<["-"], "output-filelist">,
 def supplementary_output_file_map : Separate<["-"], "supplementary-output-file-map">,
   HelpText<"Specify supplementary outputs in a file rather than on the command line">;
 
+def frontend_parseable_output : Flag<["-"], "frontend-parseable-output">,
+  HelpText<"Emit textual output in a parseable format">;
 
 def emit_module_doc : Flag<["-"], "emit-module-doc">,
   HelpText<"Emit a module documentation file based on documentation "

include/swift/Option/FrontendOptions.td

@@ -52,6 +52,7 @@ add_swift_host_library(swiftBasic STATIC
   FileSystem.cpp
   FileTypes.cpp
   Fingerprint.cpp
+  ParseableOutput.cpp
   JSONSerialization.cpp
   LangOptions.cpp
   Located.cpp