lib/Driver/ParseableOutput.cpp - third_party/swift - Git at Google

 //===--- ParseableOutput.cpp - Helpers for parseable output ---------------===//
 //
 // This source file is part of the Swift.org open source project
 //
 // Copyright (c) 2014 - 2017 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
 //
 //===----------------------------------------------------------------------===//

 #include "swift/Driver/ParseableOutput.h"

 #include "swift/Basic/FileTypes.h"
 #include "swift/Basic/JSONSerialization.h"
 #include "swift/Basic/TaskQueue.h"
 #include "swift/Driver/Action.h"
 #include "swift/Driver/Job.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Support/raw_ostream.h"

 using namespace swift::driver::parseable_output;
 using namespace swift::driver;
 using namespace swift::sys;
 using namespace swift;

 namespace {
   struct CommandInput {
     std::string Path;
     CommandInput() {}
     CommandInput(StringRef Path) : Path(Path) {}
   };

   using OutputPair = std::pair<file_types::ID, std::string>;
 } // end anonymous namespace

 namespace swift {
 namespace json {
   template<>
   struct ScalarTraits<CommandInput> {
     static void output(const CommandInput &value, llvm::raw_ostream &os) {
       os << value.Path;
     }
     static bool mustQuote(StringRef) { return true; }
   };

   template <> struct ScalarEnumerationTraits<file_types::ID> {
     static void enumeration(Output &out, file_types::ID &value) {
       file_types::forAllTypes([&](file_types::ID ty) {
         std::string typeName = file_types::getTypeName(ty);
         out.enumCase(value, typeName.c_str(), ty);
       });
     }
   };

   template <> struct ObjectTraits<std::pair<file_types::ID, std::string>> {
     static void mapping(Output &out,
                         std::pair<file_types::ID, std::string> &value) {
       out.mapRequired("type", value.first);
       out.mapRequired("path", value.second);
     }
   };

   template<typename T, unsigned N>
   struct ArrayTraits<SmallVector<T, N>> {
     static size_t size(Output &out, SmallVector<T, N> &seq) {
       return seq.size();
     }

     static T &element(Output &out, SmallVector<T, N> &seq, size_t index) {
       if (index >= seq.size())
         seq.resize(index+1);
       return seq[index];
     }
   };
 } // namespace json
 } // namespace swift

 namespace {

 class Message {
   std::string Kind;
   std::string Name;
 public:
   Message(StringRef Kind, StringRef Name) : Kind(Kind), Name(Name) {}
   virtual ~Message() = default;

   virtual void provideMapping(swift::json::Output &out) {
     out.mapRequired("kind", Kind);
     out.mapRequired("name", Name);
   }
 };

 class CommandBasedMessage : public Message {
 public:
   CommandBasedMessage(StringRef Kind, const Job &Cmd) :
       Message(Kind, Cmd.getSource().getClassName()) {}
 };

 class DetailedCommandBasedMessage : public CommandBasedMessage {
   std::string Executable;
   SmallVector<std::string, 16> Arguments;
   std::string CommandLine;
   SmallVector<CommandInput, 4> Inputs;
   SmallVector<OutputPair, 8> Outputs;
 public:
   DetailedCommandBasedMessage(StringRef Kind, const Job &Cmd) :
       CommandBasedMessage(Kind, Cmd) {
     Executable = Cmd.getExecutable();
     for (const auto &A : Cmd.getArguments()) {
       Arguments.push_back(A);
     }
     llvm::raw_string_ostream wrapper(CommandLine);
     Cmd.printCommandLine(wrapper, "");
     wrapper.flush();

     for (const Action *A : Cmd.getSource().getInputs()) {
       if (const auto *IA = dyn_cast<InputAction>(A))
         Inputs.push_back(CommandInput(IA->getInputArg().getValue()));
     }

     for (const Job *J : Cmd.getInputs()) {
       auto OutFiles = J->getOutput().getPrimaryOutputFilenames();
       if (const auto *BJAction = dyn_cast<BackendJobAction>(&Cmd.getSource())) {
         Inputs.push_back(CommandInput(OutFiles[BJAction->getInputIndex()]));
       } else {
         for (const std::string &FileName : OutFiles) {
           Inputs.push_back(CommandInput(FileName));
         }
       }
     }

     // TODO: set up Outputs appropriately.
     file_types::ID PrimaryOutputType = Cmd.getOutput().getPrimaryOutputType();
     if (PrimaryOutputType != file_types::TY_Nothing) {
       for (const std::string &OutputFileName : Cmd.getOutput().
                                                  getPrimaryOutputFilenames()) {
         Outputs.push_back(OutputPair(PrimaryOutputType, OutputFileName));
       }
     }
     file_types::forAllTypes([&](file_types::ID Ty) {
       for (auto Output : Cmd.getOutput().getAdditionalOutputsForType(Ty)) {
         Outputs.push_back(OutputPair(Ty, Output));
       }
     });
   }

   void provideMapping(swift::json::Output &out) override {
     Message::provideMapping(out);
     out.mapRequired("command", CommandLine); // Deprecated, do not document
     out.mapRequired("command_executable", Executable);
     out.mapRequired("command_arguments", Arguments);
     out.mapOptional("inputs", Inputs);
     out.mapOptional("outputs", Outputs);
   }
 };

 class TaskBasedMessage : public CommandBasedMessage {
   int64_t Pid;
 public:
   TaskBasedMessage(StringRef Kind, const Job &Cmd, int64_t Pid) :
       CommandBasedMessage(Kind, Cmd), Pid(Pid) {}

   void provideMapping(swift::json::Output &out) override {
     CommandBasedMessage::provideMapping(out);
     out.mapRequired("pid", Pid);
   }
 };

 class BeganMessage : public DetailedCommandBasedMessage {
   int64_t Pid;
   TaskProcessInformation ProcInfo;

 public:
   BeganMessage(const Job &Cmd, int64_t Pid, TaskProcessInformation ProcInfo)
       : DetailedCommandBasedMessage("began", Cmd), Pid(Pid),
         ProcInfo(ProcInfo) {}

   void provideMapping(swift::json::Output &out) override {
     DetailedCommandBasedMessage::provideMapping(out);
     out.mapRequired("pid", Pid);
     out.mapRequired("process", ProcInfo);
   }
 };

 class TaskOutputMessage : public TaskBasedMessage {
   std::string Output;
   TaskProcessInformation ProcInfo;

 public:
   TaskOutputMessage(StringRef Kind, const Job &Cmd, int64_t Pid,
                     StringRef Output, TaskProcessInformation ProcInfo)
       : TaskBasedMessage(Kind, Cmd, Pid), Output(Output), ProcInfo(ProcInfo) {}

   void provideMapping(swift::json::Output &out) override {
     TaskBasedMessage::provideMapping(out);
     out.mapOptional("output", Output, std::string());
     out.mapRequired("process", ProcInfo);
   }
 };

 class FinishedMessage : public TaskOutputMessage {
   int ExitStatus;
 public:
   FinishedMessage(const Job &Cmd, int64_t Pid, StringRef Output,
                   TaskProcessInformation ProcInfo, int ExitStatus)
       : TaskOutputMessage("finished", Cmd, Pid, Output, ProcInfo),
         ExitStatus(ExitStatus) {}

   void provideMapping(swift::json::Output &out) override {
     TaskOutputMessage::provideMapping(out);
     out.mapRequired("exit-status", ExitStatus);
   }
 };

 class SignalledMessage : public TaskOutputMessage {
   std::string ErrorMsg;
   Optional<int> Signal;
 public:
   SignalledMessage(const Job &Cmd, int64_t Pid, StringRef Output,
                    StringRef ErrorMsg, Optional<int> Signal,
                    TaskProcessInformation ProcInfo)
       : TaskOutputMessage("signalled", Cmd, Pid, Output, ProcInfo),
         ErrorMsg(ErrorMsg), Signal(Signal) {}

   void provideMapping(swift::json::Output &out) override {
     TaskOutputMessage::provideMapping(out);
     out.mapOptional("error-message", ErrorMsg, std::string());
     out.mapOptional("signal", Signal);
   }
 };

 class SkippedMessage : public DetailedCommandBasedMessage {
 public:
   SkippedMessage(const Job &Cmd) :
       DetailedCommandBasedMessage("skipped", Cmd) {}
 };

 } // end anonymous namespace

 namespace swift {
 namespace json {

 template<>
 struct ObjectTraits<Message> {
   static void mapping(Output &out, Message &msg) {
     msg.provideMapping(out);
   }
 };

 } // namespace json
 } // namespace swift

 static void emitMessage(raw_ostream &os, Message &msg) {
   std::string JSONString;
   llvm::raw_string_ostream BufferStream(JSONString);
   json::Output yout(BufferStream);
   yout << msg;
   BufferStream.flush();
   os << JSONString.length() << '\n';
   os << JSONString << '\n';
 }

 void parseable_output::emitBeganMessage(raw_ostream &os, const Job &Cmd,
                                         int64_t Pid,
                                         TaskProcessInformation ProcInfo) {
   BeganMessage msg(Cmd, Pid, ProcInfo);
   emitMessage(os, msg);
 }

 void parseable_output::emitFinishedMessage(raw_ostream &os, const Job &Cmd,
                                            int64_t Pid, int ExitStatus,
                                            StringRef Output,
                                            TaskProcessInformation ProcInfo) {
   FinishedMessage msg(Cmd, Pid, Output, ProcInfo, ExitStatus);
   emitMessage(os, msg);
 }

 void parseable_output::emitSignalledMessage(raw_ostream &os, const Job &Cmd,
                                             int64_t Pid, StringRef ErrorMsg,
                                             StringRef Output,
                                             Optional<int> Signal,
                                             TaskProcessInformation ProcInfo) {
   SignalledMessage msg(Cmd, Pid, Output, ErrorMsg, Signal, ProcInfo);
   emitMessage(os, msg);
 }

 void parseable_output::emitSkippedMessage(raw_ostream &os, const Job &Cmd) {
   SkippedMessage msg(Cmd);
   emitMessage(os, msg);
 }
	//===--- ParseableOutput.cpp - Helpers for parseable output ---------------===//
	//
	// This source file is part of the Swift.org open source project
	//
	// Copyright (c) 2014 - 2017 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
	//
	//===----------------------------------------------------------------------===//

	#include "swift/Driver/ParseableOutput.h"

	#include "swift/Basic/FileTypes.h"
	#include "swift/Basic/JSONSerialization.h"
	#include "swift/Basic/TaskQueue.h"
	#include "swift/Driver/Action.h"
	#include "swift/Driver/Job.h"
	#include "llvm/Option/Arg.h"
	#include "llvm/Support/raw_ostream.h"

	using namespace swift::driver::parseable_output;
	using namespace swift::driver;
	using namespace swift::sys;
	using namespace swift;

	namespace {
	struct CommandInput {
	std::string Path;
	CommandInput() {}
	CommandInput(StringRef Path) : Path(Path) {}
	};

	using OutputPair = std::pair<file_types::ID, std::string>;
	} // end anonymous namespace

	namespace swift {
	namespace json {
	template<>
	struct ScalarTraits<CommandInput> {
	static void output(const CommandInput &value, llvm::raw_ostream &os) {
	os << value.Path;
	}
	static bool mustQuote(StringRef) { return true; }
	};

	template <> struct ScalarEnumerationTraits<file_types::ID> {
	static void enumeration(Output &out, file_types::ID &value) {
	file_types::forAllTypes([&](file_types::ID ty) {
	std::string typeName = file_types::getTypeName(ty);
	out.enumCase(value, typeName.c_str(), ty);
	});
	}
	};

	template <> struct ObjectTraits<std::pair<file_types::ID, std::string>> {
	static void mapping(Output &out,
	std::pair<file_types::ID, std::string> &value) {
	out.mapRequired("type", value.first);
	out.mapRequired("path", value.second);
	}
	};

	template<typename T, unsigned N>
	struct ArrayTraits<SmallVector<T, N>> {
	static size_t size(Output &out, SmallVector<T, N> &seq) {
	return seq.size();
	}

	static T &element(Output &out, SmallVector<T, N> &seq, size_t index) {
	if (index >= seq.size())
	seq.resize(index+1);
	return seq[index];
	}
	};
	} // namespace json
	} // namespace swift

	namespace {

	class Message {
	std::string Kind;
	std::string Name;
	public:
	Message(StringRef Kind, StringRef Name) : Kind(Kind), Name(Name) {}
	virtual ~Message() = default;

	virtual void provideMapping(swift::json::Output &out) {
	out.mapRequired("kind", Kind);
	out.mapRequired("name", Name);
	}
	};

	class CommandBasedMessage : public Message {
	public:
	CommandBasedMessage(StringRef Kind, const Job &Cmd) :
	Message(Kind, Cmd.getSource().getClassName()) {}
	};

	class DetailedCommandBasedMessage : public CommandBasedMessage {
	std::string Executable;
	SmallVector<std::string, 16> Arguments;
	std::string CommandLine;
	SmallVector<CommandInput, 4> Inputs;
	SmallVector<OutputPair, 8> Outputs;
	public:
	DetailedCommandBasedMessage(StringRef Kind, const Job &Cmd) :
	CommandBasedMessage(Kind, Cmd) {
	Executable = Cmd.getExecutable();
	for (const auto &A : Cmd.getArguments()) {
	Arguments.push_back(A);
	}
	llvm::raw_string_ostream wrapper(CommandLine);
	Cmd.printCommandLine(wrapper, "");
	wrapper.flush();

	for (const Action *A : Cmd.getSource().getInputs()) {
	if (const auto *IA = dyn_cast<InputAction>(A))
	Inputs.push_back(CommandInput(IA->getInputArg().getValue()));
	}

	for (const Job *J : Cmd.getInputs()) {
	auto OutFiles = J->getOutput().getPrimaryOutputFilenames();
	if (const auto *BJAction = dyn_cast<BackendJobAction>(&Cmd.getSource())) {
	Inputs.push_back(CommandInput(OutFiles[BJAction->getInputIndex()]));
	} else {
	for (const std::string &FileName : OutFiles) {
	Inputs.push_back(CommandInput(FileName));
	}
	}
	}

	// TODO: set up Outputs appropriately.
	file_types::ID PrimaryOutputType = Cmd.getOutput().getPrimaryOutputType();
	if (PrimaryOutputType != file_types::TY_Nothing) {
	for (const std::string &OutputFileName : Cmd.getOutput().
	getPrimaryOutputFilenames()) {
	Outputs.push_back(OutputPair(PrimaryOutputType, OutputFileName));
	}
	}
	file_types::forAllTypes([&](file_types::ID Ty) {
	for (auto Output : Cmd.getOutput().getAdditionalOutputsForType(Ty)) {
	Outputs.push_back(OutputPair(Ty, Output));
	}
	});
	}

	void provideMapping(swift::json::Output &out) override {
	Message::provideMapping(out);
	out.mapRequired("command", CommandLine); // Deprecated, do not document
	out.mapRequired("command_executable", Executable);
	out.mapRequired("command_arguments", Arguments);
	out.mapOptional("inputs", Inputs);
	out.mapOptional("outputs", Outputs);
	}
	};

	class TaskBasedMessage : public CommandBasedMessage {
	int64_t Pid;
	public:
	TaskBasedMessage(StringRef Kind, const Job &Cmd, int64_t Pid) :
	CommandBasedMessage(Kind, Cmd), Pid(Pid) {}

	void provideMapping(swift::json::Output &out) override {
	CommandBasedMessage::provideMapping(out);
	out.mapRequired("pid", Pid);
	}
	};

	class BeganMessage : public DetailedCommandBasedMessage {
	int64_t Pid;
	TaskProcessInformation ProcInfo;

	public:
	BeganMessage(const Job &Cmd, int64_t Pid, TaskProcessInformation ProcInfo)
	: DetailedCommandBasedMessage("began", Cmd), Pid(Pid),
	ProcInfo(ProcInfo) {}

	void provideMapping(swift::json::Output &out) override {
	DetailedCommandBasedMessage::provideMapping(out);
	out.mapRequired("pid", Pid);
	out.mapRequired("process", ProcInfo);
	}
	};

	class TaskOutputMessage : public TaskBasedMessage {
	std::string Output;
	TaskProcessInformation ProcInfo;

	public:
	TaskOutputMessage(StringRef Kind, const Job &Cmd, int64_t Pid,
	StringRef Output, TaskProcessInformation ProcInfo)
	: TaskBasedMessage(Kind, Cmd, Pid), Output(Output), ProcInfo(ProcInfo) {}

	void provideMapping(swift::json::Output &out) override {
	TaskBasedMessage::provideMapping(out);
	out.mapOptional("output", Output, std::string());
	out.mapRequired("process", ProcInfo);
	}
	};

	class FinishedMessage : public TaskOutputMessage {
	int ExitStatus;
	public:
	FinishedMessage(const Job &Cmd, int64_t Pid, StringRef Output,
	TaskProcessInformation ProcInfo, int ExitStatus)
	: TaskOutputMessage("finished", Cmd, Pid, Output, ProcInfo),
	ExitStatus(ExitStatus) {}

	void provideMapping(swift::json::Output &out) override {
	TaskOutputMessage::provideMapping(out);
	out.mapRequired("exit-status", ExitStatus);
	}
	};

	class SignalledMessage : public TaskOutputMessage {
	std::string ErrorMsg;
	Optional<int> Signal;
	public:
	SignalledMessage(const Job &Cmd, int64_t Pid, StringRef Output,
	StringRef ErrorMsg, Optional<int> Signal,
	TaskProcessInformation ProcInfo)
	: TaskOutputMessage("signalled", Cmd, Pid, Output, ProcInfo),
	ErrorMsg(ErrorMsg), Signal(Signal) {}

	void provideMapping(swift::json::Output &out) override {
	TaskOutputMessage::provideMapping(out);
	out.mapOptional("error-message", ErrorMsg, std::string());
	out.mapOptional("signal", Signal);
	}
	};

	class SkippedMessage : public DetailedCommandBasedMessage {
	public:
	SkippedMessage(const Job &Cmd) :
	DetailedCommandBasedMessage("skipped", Cmd) {}
	};

	} // end anonymous namespace

	namespace swift {
	namespace json {

	template<>
	struct ObjectTraits<Message> {
	static void mapping(Output &out, Message &msg) {
	msg.provideMapping(out);
	}
	};

	} // namespace json
	} // namespace swift

	static void emitMessage(raw_ostream &os, Message &msg) {
	std::string JSONString;
	llvm::raw_string_ostream BufferStream(JSONString);
	json::Output yout(BufferStream);
	yout << msg;
	BufferStream.flush();
	os << JSONString.length() << '\n';
	os << JSONString << '\n';
	}

	void parseable_output::emitBeganMessage(raw_ostream &os, const Job &Cmd,
	int64_t Pid,
	TaskProcessInformation ProcInfo) {
	BeganMessage msg(Cmd, Pid, ProcInfo);
	emitMessage(os, msg);
	}

	void parseable_output::emitFinishedMessage(raw_ostream &os, const Job &Cmd,
	int64_t Pid, int ExitStatus,
	StringRef Output,
	TaskProcessInformation ProcInfo) {
	FinishedMessage msg(Cmd, Pid, Output, ProcInfo, ExitStatus);
	emitMessage(os, msg);
	}

	void parseable_output::emitSignalledMessage(raw_ostream &os, const Job &Cmd,
	int64_t Pid, StringRef ErrorMsg,
	StringRef Output,
	Optional<int> Signal,
	TaskProcessInformation ProcInfo) {
	SignalledMessage msg(Cmd, Pid, Output, ErrorMsg, Signal, ProcInfo);
	emitMessage(os, msg);
	}

	void parseable_output::emitSkippedMessage(raw_ostream &os, const Job &Cmd) {
	SkippedMessage msg(Cmd);
	emitMessage(os, msg);
	}