Process input files in Standard JSON mode just like in other modes

- This makes `-` for stdin work.
- `--ignore-missing` now works with `--standard-json`, though it's not very useful because there can be at most one input file.
- Separate errors for situations where there are no input files on the command line (this can be detected in the parser) and where they are not present on disk.

Author: cameel

Changelog.md

@@ -15,6 +15,8 @@ Bugfixes:
  * Code Generator: Fix crash when passing an empty string literal to ``bytes.concat()``.
  * Code Generator: Fix internal compiler error when calling functions bound to calldata structs and arrays.
  * Code Generator: Fix internal compiler error when passing a 32-byte hex literal or a zero literal to ``bytes.concat()`` by disallowing such literals.
+ * Commandline Interface: Fix crash when a directory path is passed to ``--standard-json``.
+ * Commandline Interface: Read JSON from standard input when ``--standard-json`` gets ``-`` as a file name.
  * Standard JSON: Include source location for errors in files with empty name.
  * Type Checker: Fix internal error and prevent static calls to unimplemented modifiers.
  * Yul Code Generator: Fix internal compiler error when using a long literal with bitwise negation.

solc/CommandLineInterface.cpp

@@ -377,8 +377,18 @@ void CommandLineInterface::handleGasEstimation(string const& _contract)
 	}
 }
 
-bool CommandLineInterface::readInputFilesAndConfigureFileReader()
+bool CommandLineInterface::readInputFiles()
 {
+	solAssert(!m_standardJsonInput.has_value(), "");
+
+	m_fileReader.setBasePath(m_options.input.basePath);
+
+	if (m_fileReader.basePath() != "" && !boost::filesystem::is_directory(m_fileReader.basePath()))
+	{
+		serr() << "Base path must be a directory: " << m_fileReader.basePath() << endl;
+		return false;
+	}
+
 	for (boost::filesystem::path const& allowedDirectory: m_options.input.allowedDirectories)
 		m_fileReader.allowDirectory(allowedDirectory);
 
@@ -411,16 +421,33 @@ bool CommandLineInterface::readInputFilesAndConfigureFileReader()
 		}
 
 		// NOTE: we ignore the FileNotFound exception as we manually check above
-		m_fileReader.setSource(infile, readFileAsString(infile.string()));
-		m_fileReader.allowDirectory(boost::filesystem::path(boost::filesystem::canonical(infile).string()).remove_filename());
+		string fileContent = readFileAsString(infile.string());
+		if (m_options.input.mode == InputMode::StandardJson)
+		{
+			solAssert(!m_standardJsonInput.has_value(), "");
+			m_standardJsonInput = move(fileContent);
+		}
+		else
+		{
+			m_fileReader.setSource(infile, move(fileContent));
+			m_fileReader.allowDirectory(boost::filesystem::canonical(infile).remove_filename());
+		}
 	}
 
 	if (m_options.input.addStdin)
-		m_fileReader.setSource(g_stdinFileName, readUntilEnd(m_sin));
+	{
+		if (m_options.input.mode == InputMode::StandardJson)
+		{
+			solAssert(!m_standardJsonInput.has_value(), "");
+			m_standardJsonInput = readUntilEnd(m_sin);
+		}
+		else
+			m_fileReader.setSource(g_stdinFileName, readUntilEnd(m_sin));
+	}
 
-	if (m_fileReader.sourceCodes().size() == 0)
+	if (m_fileReader.sourceCodes().empty() && !m_standardJsonInput.has_value())
 	{
-		serr() << "No input files given. If you wish to use the standard input please specify \"-\" explicitly." << endl;
+		serr() << "All specified input files either do not exist or are not regular files." << endl;
 		return false;
 	}
 
@@ -502,57 +529,35 @@ bool CommandLineInterface::parseArguments(int _argc, char const* const* _argv)
 
 bool CommandLineInterface::processInput()
 {
-	m_fileReader.setBasePath(m_options.input.basePath);
-
-	if (m_options.input.basePath != "" && !boost::filesystem::is_directory(m_options.input.basePath))
+	switch (m_options.input.mode)
 	{
-		serr() << "Base path must be a directory: \"" << m_options.input.basePath << "\"\n";
-		return false;
-	}
-
-	if (m_options.input.mode == InputMode::StandardJson)
+	case InputMode::StandardJson:
 	{
-		string input;
-		if (m_options.input.standardJsonFile.empty())
-			input = readUntilEnd(m_sin);
-		else
-		{
-			try
-			{
-				input = readFileAsString(m_options.input.standardJsonFile);
-			}
-			catch (FileNotFound const&)
-			{
-				serr() << "File not found: " << m_options.input.standardJsonFile << endl;
-				return false;
-			}
-			catch (NotAFile const&)
-			{
-				serr() << "Not a regular file: " << m_options.input.standardJsonFile << endl;
-				return false;
-			}
-		}
+		solAssert(m_standardJsonInput.has_value(), "");
+
 		StandardCompiler compiler(m_fileReader.reader(), m_options.formatting.json);
-		sout() << compiler.compile(std::move(input)) << endl;
+		sout() << compiler.compile(move(m_standardJsonInput.value())) << endl;
+		m_standardJsonInput.reset();
 		return true;
 	}
-
-	if (!readInputFilesAndConfigureFileReader())
-		return false;
-
-	if (m_options.input.mode == InputMode::Assembler)
+	case InputMode::Assembler:
+	{
 		return assemble(
 			m_options.assembly.inputLanguage,
 			m_options.assembly.targetMachine,
 			m_options.optimizer.enabled,
 			m_options.optimizer.yulSteps
 		);
-
-	if (m_options.input.mode == InputMode::Linker)
+	}
+	case InputMode::Linker:
 		return link();
+	case InputMode::Compiler:
+	case InputMode::CompilerWithASTImport:
+		return compile();
+	}
 
-	solAssert(m_options.input.mode == InputMode::Compiler || m_options.input.mode == InputMode::CompilerWithASTImport, "");
-	return compile();
+	solAssert(false, "");
+	return false;
 }
 
 bool CommandLineInterface::compile()

solc/CommandLineInterface.h

@@ -53,6 +53,8 @@ class CommandLineInterface
 
 	/// Parse command line arguments and return false if we should not continue
 	bool parseArguments(int _argc, char const* const* _argv);
+	/// Read the content of all input files and initialize the file reader.
+	bool readInputFiles();
 	/// Parse the files and create source code objects
 	bool processInput();
 	/// Perform actions on the input depending on provided compiler arguments
@@ -61,6 +63,7 @@ class CommandLineInterface
 
 	CommandLineOptions const& options() const { return m_options; }
 	FileReader const& fileReader() const { return m_fileReader; }
+	std::optional<std::string> const& standardJsonInput() const { return m_standardJsonInput; }
 
 private:
 	bool compile();
@@ -95,10 +98,6 @@ class CommandLineInterface
 	void handleGasEstimation(std::string const& _contract);
 	void handleStorageLayout(std::string const& _contract);
 
-	/// Reads the content of input files specified on the command line and passes them to FileReader.
-	/// @return false if there are no input files or input files cannot be read.
-	bool readInputFilesAndConfigureFileReader();
-
 	/// Tries to read @ m_sourceCodes as a JSONs holding ASTs
 	/// such that they can be imported into the compiler  (importASTs())
 	/// (produced by --combined-json ast,compact-format <file.sol>
@@ -129,6 +128,7 @@ class CommandLineInterface
 	bool m_hasOutput = false;
 	bool m_error = false; ///< If true, some error occurred.
 	FileReader m_fileReader;
+	std::optional<std::string> m_standardJsonInput;
 	std::unique_ptr<frontend::CompilerStack> m_compiler;
 	CommandLineOptions m_options;
 };

solc/CommandLineParser.cpp

@@ -265,7 +265,6 @@ bool CommandLineOptions::operator==(CommandLineOptions const& _other) const noex
 {
 	return
 		input.paths == _other.input.paths &&
-		input.standardJsonFile == _other.input.standardJsonFile &&
 		input.remappings == _other.input.remappings &&
 		input.addStdin == _other.input.addStdin &&
 		input.basePath == _other.input.basePath &&
@@ -301,12 +300,20 @@ bool CommandLineOptions::operator==(CommandLineOptions const& _other) const noex
 bool CommandLineParser::parseInputPathsAndRemappings()
 {
 	m_options.input.ignoreMissingFiles = (m_args.count(g_strIgnoreMissingFiles) > 0);
+
 	if (m_args.count(g_strInputFile))
 		for (string path: m_args[g_strInputFile].as<vector<string>>())
 		{
 			auto eq = find(path.begin(), path.end(), '=');
 			if (eq != path.end())
 			{
+				if (m_options.input.mode == InputMode::StandardJson)
+				{
+					serr() << "Import remappings are not accepted on the command line in Standard JSON mode." << endl;
+					serr() << "Please put them under 'settings.remappings' in the JSON input." << endl;
+					return false;
+				}
+
 				if (auto r = ImportRemapper::parseRemapping(path))
 					m_options.input.remappings.emplace_back(std::move(*r));
 				else
@@ -324,6 +331,25 @@ bool CommandLineParser::parseInputPathsAndRemappings()
 				m_options.input.paths.insert(path);
 		}
 
+	if (m_options.input.mode == InputMode::StandardJson)
+	{
+		if (m_options.input.paths.size() > 1 || (m_options.input.paths.size() == 1 && m_options.input.addStdin))
+		{
+			serr() << "Too many input files for --" << g_strStandardJSON << "." << endl;
+			serr() << "Please either specify a single file name or provide its content on standard input." << endl;
+			return false;
+		}
+		else if (m_options.input.paths.size() == 0)
+			// Standard JSON mode input used to be handled separately and zero files meant "read from stdin".
+			// Keep it working that way for backwards-compatibility.
+			m_options.input.addStdin = true;
+	}
+	else if (m_options.input.paths.size() == 0 && !m_options.input.addStdin)
+	{
+		serr() << "No input files given. If you wish to use the standard input please specify \"-\" explicitly." << endl;
+		return false;
+	}
+
 	return true;
 }
 
@@ -882,25 +908,12 @@ General Information)").c_str(),
 	else
 		m_options.input.mode = InputMode::Compiler;
 
-	if (m_options.input.mode == InputMode::StandardJson)
-	{
-		vector<string> inputFiles;
-		if (m_args.count(g_strInputFile))
-			inputFiles = m_args[g_strInputFile].as<vector<string>>();
-		if (inputFiles.size() == 1)
-			m_options.input.standardJsonFile = inputFiles[0];
-		else if (inputFiles.size() > 1)
-		{
-			serr() << "If --" << g_strStandardJSON << " is used, only zero or one input files are supported." << endl;
-			return false;
-		}
-
-		return true;
-	}
-
 	if (!parseInputPathsAndRemappings())
 		return false;
 
+	if (m_options.input.mode == InputMode::StandardJson)
+		return true;
+
 	if (m_args.count(g_strLibraries))
 		for (string const& library: m_args[g_strLibraries].as<vector<string>>())
 			if (!parseLibraryOption(library))

solc/CommandLineParser.h

@@ -107,7 +107,6 @@ struct CommandLineOptions
 	{
 		InputMode mode = InputMode::Compiler;
 		std::set<boost::filesystem::path> paths;
-		std::string standardJsonFile;
 		std::vector<ImportRemapper::Remapping> remappings;
 		bool addStdin = false;
 		boost::filesystem::path basePath = "";

solc/main.cpp

@@ -57,6 +57,8 @@ int main(int argc, char** argv)
 	solidity::frontend::CommandLineInterface cli(cin, cout, cerr);
 	if (!cli.parseArguments(argc, argv))
 		return 1;
+	if (!cli.readInputFiles())
+		return 1;
 	if (!cli.processInput())
 		return 1;
 	bool success = false;

test/CMakeLists.txt

@@ -152,6 +152,9 @@ set(libyul_sources
 detect_stray_source_files("${libyul_sources}" "libyul/")
 
 set(solcli_sources
+    solc/Common.cpp
+    solc/Common.h
+    solc/CommandLineInterface.cpp
     solc/CommandLineParser.cpp
 )
 detect_stray_source_files("${solcli_sources}" "solc/")

test/FilesystemUtils.cpp

@@ -24,6 +24,21 @@ using namespace std;
 using namespace solidity;
 using namespace solidity::test;
 
+void solidity::test::createFilesWithParentDirs(set<boost::filesystem::path> const& _paths, string const& _content)
+{
+	for (boost::filesystem::path const& path: _paths)
+	{
+		if (!path.parent_path().empty())
+			boost::filesystem::create_directories(path.parent_path());
+
+		ofstream newFile(path.string());
+		newFile << _content;
+
+		if (newFile.fail() || !boost::filesystem::exists(path))
+			BOOST_THROW_EXCEPTION(runtime_error("Failed to create an empty file: \"" + path.string() + "\"."));
+	}
+}
+
 void solidity::test::createFileWithContent(boost::filesystem::path const& _path, string const& content)
 {
 	if (boost::filesystem::is_regular_file(_path))

test/FilesystemUtils.h

@@ -23,11 +23,16 @@
 
 #include <boost/filesystem.hpp>
 
+#include <set>
 #include <string>
 
 namespace solidity::test
 {
 
+/// Creates all the specified files and fills them with the specifiedcontent. Creates their parent
+/// directories if they do not exist. Throws an exception if any part of the operation does not succeed.
+void createFilesWithParentDirs(std::set<boost::filesystem::path> const& _paths, std::string const& _content = "");
+
 /// Creates a file with the exact content specified in the second argument.
 /// Throws an exception if the file already exists or if the parent directory of the file does not.
 void createFileWithContent(boost::filesystem::path const& _path, std::string const& content);

test/cmdlineTests/standard_file_not_found/err

@@ -1 +1 @@
-File not found: input.sol
+"input.sol" is not found.