Merge pull request #6429 from ethereum/testSettings

Add settings framework for interactive tests.

test/TestCase.cpp

@@ -17,17 +17,33 @@
 
 #include <test/TestCase.h>
 
+#include <libdevcore/StringUtils.h>
+
 #include <boost/algorithm/cxx11/none_of.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/trim.hpp>
+#include <boost/range/adaptor/map.hpp>
 
 #include <stdexcept>
 
+#include <iostream>
+
 using namespace dev;
 using namespace solidity;
 using namespace dev::solidity::test;
 using namespace std;
 
+void TestCase::printUpdatedSettings(ostream& _stream, const string& _linePrefix, const bool)
+{
+	if (m_validatedSettings.empty())
+		return;
+
+	_stream << _linePrefix << "// ====" << endl;
+	for (auto const& setting: m_validatedSettings)
+		_stream << _linePrefix << "// " << setting.first << ": " << setting.second << endl;
+}
+
 bool TestCase::isTestFilename(boost::filesystem::path const& _filename)
 {
 	string extension = _filename.extension().string();
@@ -36,56 +52,44 @@ bool TestCase::isTestFilename(boost::filesystem::path const& _filename)
 			!boost::starts_with(_filename.string(), ".");
 }
 
-bool TestCase::supportedForEVMVersion(langutil::EVMVersion _evmVersion) const
+bool TestCase::validateSettings(langutil::EVMVersion)
 {
-	return boost::algorithm::none_of(m_evmVersionRules, [&](auto const& rule) { return !rule(_evmVersion); });
+	if (!m_settings.empty())
+		throw runtime_error(
+			"Unknown setting(s): " +
+			joinHumanReadable(m_settings | boost::adaptors::map_keys)
+		);
+	return true;
 }
 
-string TestCase::parseSource(istream& _stream)
+string TestCase::parseSourceAndSettings(istream& _stream)
 {
 	string source;
 	string line;
+	static string const settingsDelimiter("// ====");
 	static string const delimiter("// ----");
-	static string const evmVersion("// EVMVersion: ");
+	bool sourcePart = true;
-	bool isTop = true;
 	while (getline(_stream, line))
+	{
 		if (boost::algorithm::starts_with(line, delimiter))
 			break;
-		else
+		else if (boost::algorithm::starts_with(line, settingsDelimiter))
-		{
+			sourcePart = false;
-			if (isTop && boost::algorithm::starts_with(line, evmVersion))
+		else if (sourcePart)
-			{
-				string versionString = line.substr(evmVersion.size() + 1);
-				auto version = langutil::EVMVersion::fromString(versionString);
-				if (!version)
-					throw runtime_error("Invalid EVM version: \"" + versionString + "\"");
-				switch (line.at(evmVersion.size()))
-				{
-					case '>':
-						m_evmVersionRules.emplace_back([version](langutil::EVMVersion _version) {
-							return version < _version;
-						});
-						break;
-					case '<':
-						m_evmVersionRules.emplace_back([version](langutil::EVMVersion _version) {
-							return _version < version;
-						});
-						break;
-					case '=':
-						m_evmVersionRules.emplace_back([version](langutil::EVMVersion _version) {
-							return _version == version;
-						});
-						break;
-					case '!':
-						m_evmVersionRules.emplace_back([version](langutil::EVMVersion _version) {
-							return !(_version == version);
-						});
-						break;
-				}
-			}
-			else
-				isTop = false;
 			source += line + "\n";
+		else if (boost::algorithm::starts_with(line, "// "))
+		{
+			size_t colon = line.find(':');
+			if (colon == string::npos)
+				throw runtime_error(string("Expected \":\" inside setting."));
+			string key = line.substr(3, colon - 3);
+			string value = line.substr(colon + 1);
+			boost::algorithm::trim(key);
+			boost::algorithm::trim(value);
+			m_settings[key] = value;
+		}
+		else
+			throw runtime_error(string("Expected \"//\" or \"// ---\" to terminate settings and source."));
 	}
 	return source;
 }
@@ -96,3 +100,35 @@ void TestCase::expect(string::iterator& _it, string::iterator _end, string::valu
 		throw runtime_error(string("Invalid test expectation. Expected: \"") + _c + "\".");
 	++_it;
 }
+
+bool EVMVersionRestrictedTestCase::validateSettings(langutil::EVMVersion _evmVersion)
+{
+	if (!m_settings.count("EVMVersion"))
+		return true;
+
+	string versionString = m_settings["EVMVersion"];
+	m_validatedSettings["EVMVersion"] = versionString;
+	m_settings.erase("EVMVersion");
+
+	if (!TestCase::validateSettings(_evmVersion))
+		return false;
+
+	if (versionString.empty())
+		return true;
+
+	char comparator = versionString.front();
+	versionString = versionString.substr(1);
+	boost::optional<langutil::EVMVersion> version = langutil::EVMVersion::fromString(versionString);
+	if (!version)
+		throw runtime_error("Invalid EVM version: \"" + versionString + "\"");
+
+	switch (comparator)
+	{
+		case '>': return version < _evmVersion;
+		case '<': return _evmVersion < version;
+		case '=': return _evmVersion == version;
+		case '!': return !(_evmVersion == version);
+	}
+	throw runtime_error(string{"Invalid EVM comparator: \""} + comparator + "\"");
+	return false; // not reached
+}

test/TestCase.h

@@ -26,6 +26,7 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include <map>
 
 namespace dev
 {
@@ -42,7 +43,9 @@ namespace test
 	} \
 	while (false)
 
-/** Common superclass of SyntaxTest and SemanticsTest. */
+/**
+ * Common superclass of anything that can be run via isoltest.
+ */
 class TestCase
 {
 public:
@@ -68,17 +71,23 @@ public:
 	/// If @arg _formatted is true, color-coding may be used to indicate
 	/// error locations in the contract, if applicable.
 	virtual void printSource(std::ostream &_stream, std::string const &_linePrefix = "", bool const _formatted = false) const = 0;
+	/// Outputs the updated settings.
+	virtual void printUpdatedSettings(std::ostream &_stream, std::string const &_linePrefix = "", bool const _formatted = false);
 	/// Outputs test expectations to @arg _stream that match the actual results of the test.
 	/// Each line of output is prefixed with @arg _linePrefix.
 	virtual void printUpdatedExpectations(std::ostream& _stream, std::string const& _linePrefix) const = 0;
 
 	static bool isTestFilename(boost::filesystem::path const& _filename);
 
-	/// Returns true, if the test case is supported for EVM version @arg _evmVersion, false otherwise.
+	/// Validates the settings, i.e. moves them from m_settings to m_validatedSettings.
-	bool supportedForEVMVersion(langutil::EVMVersion _evmVersion) const;
+	/// Throws a runtime exception if any setting is left at this class (i.e. unknown setting).
+	/// Returns true, if the test case is supported in the current environment and false
+	/// otherwise which causes this test to be skipped.
+	/// This might check e.g. for restrictions on the EVM version.
+	virtual bool validateSettings(langutil::EVMVersion /*_evmVersion*/);
 
 protected:
-	std::string parseSource(std::istream& _file);
+	std::string parseSourceAndSettings(std::istream& _file);
 	static void expect(std::string::iterator& _it, std::string::iterator _end, std::string::value_type _c);
 
 	template<typename IteratorType>
@@ -94,10 +103,19 @@ protected:
 		while (_it != _end && *_it == '/')
 			++_it;
 	}
-private:
+
-	std::vector<std::function<bool(langutil::EVMVersion)>> m_evmVersionRules;
+	/// Parsed settings.
+	std::map<std::string, std::string> m_settings;
+	/// Updated settings after validation.
+	std::map<std::string, std::string> m_validatedSettings;
 };
 
+class EVMVersionRestrictedTestCase: public TestCase
+{
+public:
+	/// Returns true, if the test case is supported for EVM version @arg _evmVersion, false otherwise.
+	bool validateSettings(langutil::EVMVersion _evmVersion) override;
+};
 }
 }
 }

test/boostTest.cpp

@@ -105,7 +105,7 @@ int registerTests(
 					{
 						stringstream errorStream;
 						auto testCase = _testCaseCreator(config);
-						if (testCase->supportedForEVMVersion(dev::test::Options::get().evmVersion()))
+						if (testCase->validateSettings(dev::test::Options::get().evmVersion()))
 							if (!testCase->run(errorStream))
 								BOOST_ERROR("Test expectation mismatch.\n" + errorStream.str());
 					}

test/libsolidity/SemanticTest.cpp

@@ -43,7 +43,7 @@ SemanticTest::SemanticTest(string const& _filename, string const& _ipcPath, lang
 	soltestAssert(file, "Cannot open test contract: \"" + _filename + "\".");
 	file.exceptions(ios::badbit);
 
-	m_source = parseSource(file);
+	m_source = parseSourceAndSettings(file);
 	parseExpectations(file);
 }
 

test/libsolidity/SemanticTest.h

@@ -40,7 +40,7 @@ namespace test
  * section from the given file. This comment section should define a set of functions to be called
  * and an expected result they return after being executed.
  */
-class SemanticTest: public SolidityExecutionFramework, public TestCase
+class SemanticTest: public SolidityExecutionFramework, public EVMVersionRestrictedTestCase
 {
 public:
 	static std::unique_ptr<TestCase> create(Config const& _options)

test/libsolidity/SyntaxTest.cpp

@@ -59,7 +59,7 @@ SyntaxTest::SyntaxTest(string const& _filename, langutil::EVMVersion _evmVersion
 		BOOST_THROW_EXCEPTION(runtime_error("Cannot open test contract: \"" + _filename + "\"."));
 	file.exceptions(ios::badbit);
 
-	m_source = parseSource(file);
+	m_source = parseSourceAndSettings(file);
 	m_expectations = parseExpectations(file);
 }
 

test/libsolidity/SyntaxTest.h

@@ -50,7 +50,7 @@ struct SyntaxTestError
 };
 
 
-class SyntaxTest: AnalysisFramework, public TestCase
+class SyntaxTest: AnalysisFramework, public EVMVersionRestrictedTestCase
 {
 public:
 	static std::unique_ptr<TestCase> create(Config const& _config)

test/libsolidity/semanticTests/shifts.sol

@@ -0,0 +1,9 @@
+contract C {
+    function f(uint x) public returns (uint y) {
+        assembly { y := shl(2, x) }
+    }
+}
+// ====
+// EVMVersion: >byzantium
+// ----
+// f(uint256): 7 -> 28

test/libyul/YulOptimizerTest.cpp

@@ -78,19 +78,23 @@ YulOptimizerTest::YulOptimizerTest(string const& _filename)
 	m_optimizerStep = std::prev(std::prev(path.end()))->string();
 
 	ifstream file(_filename);
-	if (!file)
+	soltestAssert(file, "Cannot open test contract: \"" + _filename + "\".");
-		BOOST_THROW_EXCEPTION(runtime_error("Cannot open test case: \"" + _filename + "\"."));
 	file.exceptions(ios::badbit);
 
-	string line;
+	m_source = parseSourceAndSettings(file);
-	while (getline(file, line))
+	if (m_settings.count("yul"))
 	{
-		if (boost::algorithm::starts_with(line, "// ----"))
-			break;
-		if (m_source.empty() && boost::algorithm::starts_with(line, "// yul"))
 		m_yul = true;
-		m_source += line + "\n";
+		m_validatedSettings["yul"] = "true";
+		m_settings.erase("yul");
 	}
+	if (m_settings.count("step"))
+	{
+		m_validatedSettings["step"] = m_settings["step"];
+		m_settings.erase("step");
+	}
+
+	string line;
 	while (getline(file, line))
 		if (boost::algorithm::starts_with(line, "// "))
 			m_expectation += line.substr(3) + "\n";
@@ -266,8 +270,22 @@ bool YulOptimizerTest::run(ostream& _stream, string const& _linePrefix, bool con
 		return false;
 	}
 
-	m_obtainedResult = m_optimizerStep + "\n" + AsmPrinter{m_yul}(*m_ast) + "\n";
+	m_obtainedResult = AsmPrinter{m_yul}(*m_ast) + "\n";
 
+	bool success = true;
+	if (m_optimizerStep != m_validatedSettings["step"])
+	{
+		string nextIndentLevel = _linePrefix + "  ";
+		AnsiColorized(_stream, _formatted, {formatting::BOLD, formatting::CYAN}) <<
+			_linePrefix <<
+			"Invalid optimizer step. Given: \"" <<
+			m_validatedSettings["step"] <<
+			"\", should be: \"" <<
+			m_optimizerStep <<
+			"\"." <<
+			endl;
+		success = false;
+	}
 	if (m_expectation != m_obtainedResult)
 	{
 		string nextIndentLevel = _linePrefix + "  ";
@@ -276,9 +294,9 @@ bool YulOptimizerTest::run(ostream& _stream, string const& _linePrefix, bool con
 		printIndented(_stream, m_expectation, nextIndentLevel);
 		AnsiColorized(_stream, _formatted, {formatting::BOLD, formatting::CYAN}) << _linePrefix << "Obtained result:" << endl;
 		printIndented(_stream, m_obtainedResult, nextIndentLevel);
-		return false;
+		success = false;
 	}
-	return true;
+	return success;
 }
 
 void YulOptimizerTest::printSource(ostream& _stream, string const& _linePrefix, bool const) const
@@ -286,6 +304,12 @@ void YulOptimizerTest::printSource(ostream& _stream, string const& _linePrefix,
 	printIndented(_stream, m_source, _linePrefix);
 }
 
+void YulOptimizerTest::printUpdatedSettings(ostream& _stream, const string& _linePrefix, const bool _formatted)
+{
+	m_validatedSettings["step"] = m_optimizerStep;
+	EVMVersionRestrictedTestCase::printUpdatedSettings(_stream, _linePrefix, _formatted);
+}
+
 void YulOptimizerTest::printUpdatedExpectations(ostream& _stream, string const& _linePrefix) const
 {
 	printIndented(_stream, m_obtainedResult, _linePrefix);

test/libyul/YulOptimizerTest.h

@@ -38,7 +38,7 @@ namespace yul
 namespace test
 {
 
-class YulOptimizerTest: public dev::solidity::test::TestCase
+class YulOptimizerTest: public dev::solidity::test::EVMVersionRestrictedTestCase
 {
 public:
 	static std::unique_ptr<TestCase> create(Config const& _config)
@@ -51,6 +51,7 @@ public:
 	bool run(std::ostream& _stream, std::string const& _linePrefix = "", bool const _formatted = false) override;
 
 	void printSource(std::ostream& _stream, std::string const &_linePrefix = "", bool const _formatted = false) const override;
+	void printUpdatedSettings(std::ostream &_stream, std::string const &_linePrefix = "", bool const _formatted = false) override;
 	void printUpdatedExpectations(std::ostream& _stream, std::string const& _linePrefix) const override;
 
 private:

test/libyul/yulOptimizerTests/blockFlattener/basic.yul

@@ -8,8 +8,9 @@
   }
   let z := mload(2)
 }
+// ====
+// step: blockFlattener
 // ----
-// blockFlattener
 // {
 //     let _1 := mload(0)
 //     let f_a := mload(1)

test/libyul/yulOptimizerTests/blockFlattener/for_stmt.yul

@@ -3,8 +3,9 @@
         a := add(a, 1)
     }
 }
+// ====
+// step: blockFlattener
 // ----
-// blockFlattener
 // {
 //     for {
 //         let a := 1

test/libyul/yulOptimizerTests/blockFlattener/if_stmt.yul

@@ -8,8 +8,9 @@
   }
   let t := add(3, 9)
 }
+// ====
+// step: blockFlattener
 // ----
-// blockFlattener
 // {
 //     if add(mload(7), sload(mload(3)))
 //     {

test/libyul/yulOptimizerTests/blockFlattener/many_nested_blocks.yul

@@ -14,8 +14,9 @@
     a := add(a, c)
   }
 }
+// ====
+// step: blockFlattener
 // ----
-// blockFlattener
 // {
 //     let a := 3
 //     let b := 4

test/libyul/yulOptimizerTests/blockFlattener/switch_stmt.yul

@@ -5,8 +5,9 @@
     default { a := 3 { a := 4 } }
     a := 5
 }
+// ====
+// step: blockFlattener
 // ----
-// blockFlattener
 // {
 //     let a := 1
 //     switch calldataload(0)

test/libyul/yulOptimizerTests/commonSubexpressionEliminator/branches_for.yul

@@ -5,8 +5,9 @@
 	}
 	mstore(1, codesize())
 }
+// ====
+// step: commonSubexpressionEliminator
 // ----
-// commonSubexpressionEliminator
 // {
 //     let a := 1
 //     let b := codesize()

test/libyul/yulOptimizerTests/commonSubexpressionEliminator/branches_if.yul

@@ -3,8 +3,9 @@
     if b { b := 1 }
     let c := 1
 }
+// ====
+// step: commonSubexpressionEliminator
 // ----
-// commonSubexpressionEliminator
 // {
 //     let b := 1
 //     if b

test/libyul/yulOptimizerTests/commonSubexpressionEliminator/case2.yul

@@ -23,8 +23,9 @@
         p_1 := add(array, _22)
     }
 }
+// ====
+// step: commonSubexpressionEliminator
 // ----
-// commonSubexpressionEliminator
 // {
 //     let _13 := 0x20
 //     let _14 := allocate(_13)

test/libyul/yulOptimizerTests/commonSubexpressionEliminator/function_scopes.yul

@@ -23,8 +23,9 @@
     let _11 := array_index_access(x, _10)
     mstore(_11, _9)
 }
+// ====
+// step: commonSubexpressionEliminator
 // ----
-// commonSubexpressionEliminator
 // {
 //     function allocate(size) -> p
 //     {

test/libyul/yulOptimizerTests/commonSubexpressionEliminator/non_movable_instr.yul

@@ -2,8 +2,9 @@
     let a := mload(1)
     let b := mload(1)
 }
+// ====
+// step: commonSubexpressionEliminator
 // ----
-// commonSubexpressionEliminator
 // {
 //     let a := mload(1)
 //     let b := mload(1)

test/libyul/yulOptimizerTests/commonSubexpressionEliminator/non_movable_instr2.yul

@@ -2,8 +2,9 @@
     let a := gas()
     let b := gas()
 }
+// ====
+// step: commonSubexpressionEliminator
 // ----
-// commonSubexpressionEliminator
 // {
 //     let a := gas()
 //     let b := gas()

test/libyul/yulOptimizerTests/commonSubexpressionEliminator/object_access.yul

@@ -11,8 +11,9 @@
     datacopy("abc", x, y)
     mstore(a, x)
 }
+// ====
+// step: commonSubexpressionEliminator
 // ----
-// commonSubexpressionEliminator
 // {
 //     let r := "abc"
 //     let a := datasize("abc")

test/libyul/yulOptimizerTests/commonSubexpressionEliminator/scopes.yul

@@ -10,8 +10,9 @@
     mstore(0, calldataload(0))
     mstore(0, x)
 }
+// ====
+// step: commonSubexpressionEliminator
 // ----
-// commonSubexpressionEliminator
 // {
 //     let a := 10
 //     let x := 20

test/libyul/yulOptimizerTests/commonSubexpressionEliminator/smoke.yul

@@ -1,5 +1,6 @@
 { }
+// ====
+// step: commonSubexpressionEliminator
 // ----
-// commonSubexpressionEliminator
 // {
 // }

test/libyul/yulOptimizerTests/commonSubexpressionEliminator/trivial.yul

@@ -2,8 +2,9 @@
     let a := mul(1, codesize())
     let b := mul(1, codesize())
 }
+// ====
+// step: commonSubexpressionEliminator
 // ----
-// commonSubexpressionEliminator
 // {
 //     let a := mul(1, codesize())
 //     let b := a

test/libyul/yulOptimizerTests/commonSubexpressionEliminator/unassigned_return.yul

@@ -9,8 +9,9 @@
     let b := 0
     sstore(a, b)
 }
+// ====
+// step: commonSubexpressionEliminator
 // ----
-// commonSubexpressionEliminator
 // {
 //     function f() -> x
 //     {

test/libyul/yulOptimizerTests/commonSubexpressionEliminator/unassigned_variables.yul

@@ -5,8 +5,9 @@
     let b
     mstore(sub(a, b), 7)
 }
+// ====
+// step: commonSubexpressionEliminator
 // ----
-// commonSubexpressionEliminator
 // {
 //     let a
 //     let b

test/libyul/yulOptimizerTests/commonSubexpressionEliminator/variable_for_variable.yul

@@ -12,8 +12,9 @@
     a := b
     mstore(2, a)
 }
+// ====
+// step: commonSubexpressionEliminator
 // ----
-// commonSubexpressionEliminator
 // {
 //     let a := mload(0)
 //     let b := add(a, 7)

test/libyul/yulOptimizerTests/deadCodeEliminator/conditional_break.yul

@@ -13,8 +13,9 @@
     }
 }
 
+// ====
+// step: deadCodeEliminator
 // ----
-// deadCodeEliminator
 // {
 //     for {
 //         let a := 20

test/libyul/yulOptimizerTests/deadCodeEliminator/early_break.yul

@@ -14,8 +14,9 @@
     }
 }
 
+// ====
+// step: deadCodeEliminator
 // ----
-// deadCodeEliminator
 // {
 //     for {
 //         let a := 20

test/libyul/yulOptimizerTests/deadCodeEliminator/early_continue.yul

@@ -14,8 +14,9 @@
     }
 }
 
+// ====
+// step: deadCodeEliminator
 // ----
-// deadCodeEliminator
 // {
 //     for {
 //         let a := 20

test/libyul/yulOptimizerTests/deadCodeEliminator/early_revert.yul

@@ -15,8 +15,9 @@
     }
 }
 
+// ====
+// step: deadCodeEliminator
 // ----
-// deadCodeEliminator
 // {
 //     let b := 20
 //     revert(0, 0)

test/libyul/yulOptimizerTests/deadCodeEliminator/early_stop.yul

@@ -15,8 +15,9 @@
     }
 }
 
+// ====
+// step: deadCodeEliminator
 // ----
-// deadCodeEliminator
 // {
 //     let b := 20
 //     stop()

test/libyul/yulOptimizerTests/deadCodeEliminator/function_after_revert.yul

@@ -12,8 +12,9 @@
 
     pop(add(1, 1))
 }
+// ====
+// step: deadCodeEliminator
 // ----
-// deadCodeEliminator
 // {
 //     fun()
 //     revert(0, 0)

test/libyul/yulOptimizerTests/deadCodeEliminator/nested_revert.yul

@@ -12,8 +12,9 @@
         y := 10 }
 }
 
+// ====
+// step: deadCodeEliminator
 // ----
-// deadCodeEliminator
 // {
 //     let y := mload(0)
 //     switch y

test/libyul/yulOptimizerTests/deadCodeEliminator/no_removal.yul

@@ -4,8 +4,9 @@
     }
     mstore(0, 0)
 }
+// ====
+// step: deadCodeEliminator
 // ----
-// deadCodeEliminator
 // {
 //     {
 //         revert(0, 0)

test/libyul/yulOptimizerTests/deadCodeEliminator/normal_break.yul

@@ -12,8 +12,9 @@
     }
 }
 
+// ====
+// step: deadCodeEliminator
 // ----
-// deadCodeEliminator
 // {
 //     for {
 //         let a := 20

test/libyul/yulOptimizerTests/deadCodeEliminator/normal_continue.yul

@@ -12,8 +12,9 @@
     }
 }
 
+// ====
+// step: deadCodeEliminator
 // ----
-// deadCodeEliminator
 // {
 //     for {
 //         let a := 20

test/libyul/yulOptimizerTests/deadCodeEliminator/normal_stop.yul

@@ -15,8 +15,9 @@
     stop()
 }
 
+// ====
+// step: deadCodeEliminator
 // ----
-// deadCodeEliminator
 // {
 //     let b := 20
 //     for {

test/libyul/yulOptimizerTests/disambiguator/for_statement.yul

@@ -1,4 +1,3 @@
-// yul
 {
     { let a:u256, b:u256 }
     {
@@ -7,8 +6,10 @@
         }
     }
 }
+// ====
+// step: disambiguator
+// yul: true
 // ----
-// disambiguator
 // {
 //     {
 //         let a:u256, b:u256

test/libyul/yulOptimizerTests/disambiguator/funtion_call.yul

@@ -1,4 +1,3 @@
-// yul
 {
     { let a:u256, b:u256, c:u256, d:u256, f:u256 }
     {
@@ -7,8 +6,10 @@
         }
     }
 }
+// ====
+// step: disambiguator
+// yul: true
 // ----
-// disambiguator
 // {
 //     {
 //         let a:u256, b:u256, c:u256, d:u256, f:u256

test/libyul/yulOptimizerTests/disambiguator/if_statement.yul

@@ -1,4 +1,3 @@
-// yul
 {
     { let a:u256, b:u256, c:u256 }
     {
@@ -6,8 +5,10 @@
         if a { let b:bool := a }
     }
 }
+// ====
+// step: disambiguator
+// yul: true
 // ----
-// disambiguator
 // {
 //     {
 //         let a:u256, b:u256, c:u256

test/libyul/yulOptimizerTests/disambiguator/long_names.yul

@@ -1,7 +1,8 @@
-// yul
 { { let aanteuhdaoneudbrgkjiuaothduiathudaoeuh:u256 } { let aanteuhdaoneudbrgkjiuaothduiathudaoeuh:u256 } }
+// ====
+// step: disambiguator
+// yul: true
 // ----
-// disambiguator
 // {
 //     {
 //         let aanteuhdaoneudbrgkjiuaothduiathudaoeuh:u256

test/libyul/yulOptimizerTests/disambiguator/smoke.yul

@@ -1,5 +1,6 @@
 { }
+// ====
+// step: disambiguator
 // ----
-// disambiguator
 // {
 // }

test/libyul/yulOptimizerTests/disambiguator/smoke_yul.yul

@@ -1,6 +1,7 @@
-// yul
 { }
+// ====
+// step: disambiguator
+// yul: true
 // ----
-// disambiguator
 // {
 // }

test/libyul/yulOptimizerTests/disambiguator/switch_statement.yul

@@ -1,4 +1,3 @@
-// yul
 {
     { let a:u256, b:u256, c:u256 }
     {
@@ -8,8 +7,10 @@
         default { let c:u256 := a }
     }
 }
+// ====
+// step: disambiguator
+// yul: true
 // ----
-// disambiguator
 // {
 //     {
 //         let a:u256, b:u256, c:u256

test/libyul/yulOptimizerTests/disambiguator/variables.yul

@@ -1,7 +1,8 @@
-// yul
 { { let a:u256 } { let a:u256 } }
+// ====
+// step: disambiguator
+// yul: true
 // ----
-// disambiguator
 // {
 //     {
 //         let a:u256

test/libyul/yulOptimizerTests/disambiguator/variables_clash.yul

@@ -1,7 +1,8 @@
-// yul
 { { let a:u256 let a_1:u256 } { let a:u256 } }
+// ====
+// step: disambiguator
+// yul: true
 // ----
-// disambiguator
 // {
 //     {
 //         let a:u256

test/libyul/yulOptimizerTests/disambiguator/variables_inside_functions.yul

@@ -1,4 +1,3 @@
-// yul
 {
     { let c:u256 let b:u256 }
     function f(a:u256, c:u256) -> b:u256 { let x:u256 }
@@ -6,8 +5,10 @@
         let a:u256 let x:u256
     }
 }
+// ====
+// step: disambiguator
+// yul: true
 // ----
-// disambiguator
 // {
 //     {
 //         let c:u256

test/libyul/yulOptimizerTests/equivalentFunctionCombiner/multiple_complex.yul

@@ -54,8 +54,9 @@
         }
   }
 }
+// ====
+// step: equivalentFunctionCombiner
 // ----
-// equivalentFunctionCombiner
 // {
 //     pop(f(1, 2, 3))
 //     pop(f(4, 5, 6))

test/libyul/yulOptimizerTests/equivalentFunctionCombiner/simple.yul

@@ -4,8 +4,9 @@
   function f() { mstore(1, mload(0)) }
   function g() { mstore(1, mload(0)) }
 }
+// ====
+// step: equivalentFunctionCombiner
 // ----
-// equivalentFunctionCombiner
 // {
 //     f()
 //     f()

test/libyul/yulOptimizerTests/equivalentFunctionCombiner/simple_different_vars.yul

@@ -4,8 +4,9 @@
   function f() -> b { let a := mload(0) b := a }
   function g() -> a { let b := mload(0) a := b }
 }
+// ====
+// step: equivalentFunctionCombiner
 // ----
-// equivalentFunctionCombiner
 // {
 //     pop(f())
 //     pop(f())

test/libyul/yulOptimizerTests/equivalentFunctionCombiner/switch_case_order.yul

@@ -4,8 +4,9 @@
   function f(x) { switch x case 0 { mstore(0, 42) } case 1 { mstore(1, 42) } }
   function g(x) { switch x case 1 { mstore(1, 42) } case 0 { mstore(0, 42) } }
 }
+// ====
+// step: equivalentFunctionCombiner
 // ----
-// equivalentFunctionCombiner
 // {
 //     f(0)
 //     f(1)

test/libyul/yulOptimizerTests/expressionInliner/complex_with_evm.yul

@@ -2,8 +2,9 @@
     function f(a) -> x { x := add(a, a) }
     let y := f(calldatasize())
 }
+// ====
+// step: expressionInliner
 // ----
-// expressionInliner
 // {
 //     function f(a) -> x
 //     {

test/libyul/yulOptimizerTests/expressionInliner/double_calls.yul

@@ -3,8 +3,9 @@
 	function g(b, c) -> y { y := mul(mload(c), f(b)) }
 	let y := g(calldatasize(), 7)
 }
+// ====
+// step: expressionInliner
 // ----
-// expressionInliner
 // {
 //     function f(a) -> x
 //     {

test/libyul/yulOptimizerTests/expressionInliner/double_recursive_calls.yul

@@ -3,8 +3,9 @@
 	function g(b, s) -> y { y := f(b, f(s, s)) }
 	let y := g(calldatasize(), 7)
 }
+// ====
+// step: expressionInliner
 // ----
-// expressionInliner
 // {
 //     function f(a, r) -> x
 //     {

test/libyul/yulOptimizerTests/expressionInliner/no_inline_mload.yul

@@ -3,8 +3,9 @@
     function f(a) -> x { x := a }
     let y := f(mload(2))
 }
+// ====
+// step: expressionInliner
 // ----
-// expressionInliner
 // {
 //     function f(a) -> x
 //     {

test/libyul/yulOptimizerTests/expressionInliner/no_move_with_sideeffects.yul

@@ -6,8 +6,9 @@
 	function h() -> z { mstore(0, 4) z := mload(0) }
 	let r := f(g(), h())
 }
+// ====
+// step: expressionInliner
 // ----
-// expressionInliner
 // {
 //     function f(a, b) -> x
 //     {

test/libyul/yulOptimizerTests/expressionInliner/simple.yul

@@ -1,10 +1,11 @@
-// yul
 {
     function f() -> x:u256 { x := 2:u256 }
     let y:u256 := f()
 }
+// ====
+// step: expressionInliner
+// yul: true
 // ----
-// expressionInliner
 // {
 //     function f() -> x:u256
 //     {

test/libyul/yulOptimizerTests/expressionInliner/with_args.yul

@@ -1,10 +1,11 @@
-// yul
 {
     function f(a:u256) -> x:u256 { x := a }
     let y:u256 := f(7:u256)
 }
+// ====
+// step: expressionInliner
+// yul: true
 // ----
-// expressionInliner
 // {
 //     function f(a:u256) -> x:u256
 //     {

test/libyul/yulOptimizerTests/expressionJoiner/if_condition.yul

@@ -10,8 +10,9 @@
 	let z := 3
 	let t := add(z, 9)
 }
+// ====
+// step: expressionJoiner
 // ----
-// expressionJoiner
 // {
 //     if add(mload(7), sload(mload(3)))
 //     {

test/libyul/yulOptimizerTests/expressionJoiner/muli_wrong_order3.yul

@@ -4,8 +4,9 @@
 	let x := mul(add(b, a), mload(2))
 	sstore(x, 3)
 }
+// ====
+// step: expressionJoiner
 // ----
-// expressionJoiner
 // {
 //     let a := mload(3)
 //     let b := mload(6)

test/libyul/yulOptimizerTests/expressionJoiner/multi.yul

@@ -4,8 +4,9 @@
 	let x := mul(add(b, a), 2)
 	sstore(x, 3)
 }
+// ====
+// step: expressionJoiner
 // ----
-// expressionJoiner
 // {
 //     sstore(mul(add(mload(6), mload(2)), 2), 3)
 // }

test/libyul/yulOptimizerTests/expressionJoiner/multi_reference.yul

@@ -3,8 +3,9 @@
 	let a := mload(2)
 	let b := add(a, a)
 }
+// ====
+// step: expressionJoiner
 // ----
-// expressionJoiner
 // {
 //     let a := mload(2)
 //     let b := add(a, a)

test/libyul/yulOptimizerTests/expressionJoiner/multi_wrong_order.yul

@@ -7,8 +7,9 @@
 	let x := mul(a, add(2, b))
 	sstore(x, 3)
 }
+// ====
+// step: expressionJoiner
 // ----
-// expressionJoiner
 // {
 //     let a := mload(2)
 //     sstore(mul(a, add(2, mload(6))), 3)

test/libyul/yulOptimizerTests/expressionJoiner/multi_wrong_order2.yul

@@ -4,8 +4,9 @@
 	let x := mul(add(a, b), 2)
 	sstore(x, 3)
 }
+// ====
+// step: expressionJoiner
 // ----
-// expressionJoiner
 // {
 //     let a := mload(2)
 //     sstore(mul(add(a, mload(6)), 2), 3)

test/libyul/yulOptimizerTests/expressionJoiner/no_replacement_across_blocks.yul

@@ -11,8 +11,9 @@
 	}
 	sstore(x, 3)
 }
+// ====
+// step: expressionJoiner
 // ----
-// expressionJoiner
 // {
 //     let x := calldataload(mload(2))
 //     sstore(x, 3)

test/libyul/yulOptimizerTests/expressionJoiner/no_replacement_in_loop_condition1.yul

@@ -1,8 +1,9 @@
 {
 	for { let b := mload(1) } b {} {}
 }
+// ====
+// step: expressionJoiner
 // ----
-// expressionJoiner
 // {
 //     for {
 //         let b := mload(1)

test/libyul/yulOptimizerTests/expressionJoiner/no_replacement_in_loop_condition2.yul

@@ -2,8 +2,9 @@
 	let a := mload(0)
 	for { } a {} {}
 }
+// ====
+// step: expressionJoiner
 // ----
-// expressionJoiner
 // {
 //     let a := mload(0)
 //     for {

test/libyul/yulOptimizerTests/expressionJoiner/only_assignment.yul

@@ -5,8 +5,9 @@
 		x := add(a, 3)
 	}
 }
+// ====
+// step: expressionJoiner
 // ----
-// expressionJoiner
 // {
 //     function f(a) -> x
 //     {

test/libyul/yulOptimizerTests/expressionJoiner/reassignment.yul

@@ -4,8 +4,9 @@
 	let b := mload(a)
 	a := 4
 }
+// ====
+// step: expressionJoiner
 // ----
-// expressionJoiner
 // {
 //     let a := mload(2)
 //     let b := mload(a)

test/libyul/yulOptimizerTests/expressionJoiner/simple.yul

@@ -3,8 +3,9 @@
 	let x := calldataload(a)
 	sstore(x, 3)
 }
+// ====
+// step: expressionJoiner
 // ----
-// expressionJoiner
 // {
 //     sstore(calldataload(mload(2)), 3)
 // }

test/libyul/yulOptimizerTests/expressionJoiner/single_wrong_order.yul

@@ -5,8 +5,9 @@
 	let d := add(b, c)
 	sstore(d, 0)
 }
+// ====
+// step: expressionJoiner
 // ----
-// expressionJoiner
 // {
 //     let b := sload(mload(3))
 //     sstore(add(b, mload(7)), 0)

test/libyul/yulOptimizerTests/expressionJoiner/smoke.yul

@@ -1,5 +1,6 @@
 { }
+// ====
+// step: expressionJoiner
 // ----
-// expressionJoiner
 // {
 // }

test/libyul/yulOptimizerTests/expressionJoiner/switch_expression.yul

@@ -14,8 +14,9 @@
 	let z := 3
 	let t := add(z, 9)
 }
+// ====
+// step: expressionJoiner
 // ----
-// expressionJoiner
 // {
 //     switch add(mload(7), sload(mload(3)))
 //     case 3 {

test/libyul/yulOptimizerTests/expressionJoiner/triple.yul

@@ -5,8 +5,9 @@
 	let x := mul(add(c, b), a)
 	sstore(x, 3)
 }
+// ====
+// step: expressionJoiner
 // ----
-// expressionJoiner
 // {
 //     sstore(mul(add(mload(7), mload(6)), mload(2)), 3)
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/assigned_vars_multi.yul

@@ -3,8 +3,9 @@
 	let c, d := f()
 	let y := add(d, add(c, 7))
 }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     function f() -> x, z
 //     {

test/libyul/yulOptimizerTests/expressionSimplifier/constant_propagation.yul

@@ -1,6 +1,7 @@
 { let a := add(7, sub(mload(0), 7)) }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     let a := mload(0)
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/constants.yul

@@ -1,6 +1,7 @@
 { let a := add(1, mul(3, 4)) }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     let a := 13
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/identity_rules_complex.yul

@@ -1,6 +1,7 @@
 { let a := sub(calldataload(0), calldataload(0)) }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     let a := 0
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/identity_rules_negative.yul

@@ -1,6 +1,7 @@
 { let a := sub(calldataload(1), calldataload(0)) }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     let a := sub(calldataload(1), calldataload(0))
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/identity_rules_simple.yul

@@ -2,8 +2,9 @@
     let a := mload(0)
     let b := sub(a, a)
 }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     let a := mload(0)
 //     let b := 0

test/libyul/yulOptimizerTests/expressionSimplifier/including_function_calls.yul

@@ -2,8 +2,9 @@
     function f() -> a {}
     let b := add(7, sub(f(), 7))
 }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     function f() -> a
 //     {

test/libyul/yulOptimizerTests/expressionSimplifier/inside_for.yul

@@ -1,8 +1,9 @@
 {
     for { let a := 10 } iszero(eq(a, 0)) { a := add(a, 1) } {}
 }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     for {
 //         let a := 10

test/libyul/yulOptimizerTests/expressionSimplifier/invariant.yul

@@ -2,8 +2,9 @@
     let a := mload(sub(7, 7))
     let b := sub(a, 0)
 }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     let a := mload(0)
 //     let b := a

test/libyul/yulOptimizerTests/expressionSimplifier/mod_and_1.yul

@@ -1,8 +1,9 @@
 {
     mstore(0, mod(calldataload(0), exp(2, 8)))
 }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     mstore(0, and(calldataload(0), 255))
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/mod_and_2.yul

@@ -1,8 +1,9 @@
 {
     mstore(0, mod(calldataload(0), exp(2, 255)))
 }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     mstore(0, and(calldataload(0), 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/not_applied_function_call_different_arguments.yul

@@ -2,8 +2,9 @@
     function f(a) -> b { }
     let c := sub(f(0), f(1))
 }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     function f(a) -> b
 //     {

test/libyul/yulOptimizerTests/expressionSimplifier/not_applied_function_call_different_names.yul

@@ -3,8 +3,9 @@
 	function f2() -> b { }
 	let c := sub(f1(), f2())
 }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     function f1() -> a
 //     {

test/libyul/yulOptimizerTests/expressionSimplifier/not_applied_function_call_equality_not_movable.yul

@@ -3,8 +3,9 @@
 	function f() -> a { }
 	let b := sub(f(), f())
 }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     function f() -> a
 //     {

test/libyul/yulOptimizerTests/expressionSimplifier/not_applied_removes_non_constant_and_not_movable.yul

@@ -3,8 +3,9 @@
 {
 	let a := div(keccak256(0, 0), 0)
 }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     let a := div(keccak256(0, 0), 0)
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/reassign.yul

@@ -3,8 +3,9 @@
 	x := 0
 	mstore(0, add(7, x))
 }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     let x := mload(0)
 //     x := 0

test/libyul/yulOptimizerTests/expressionSimplifier/return_vars_zero.yul

@@ -4,8 +4,9 @@
     	let y := add(d, add(c, 7))
     }
 }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     function f() -> c, d
 //     {

test/libyul/yulOptimizerTests/expressionSimplifier/reversed.yul

@@ -1,8 +1,9 @@
 {
     let a := add(0, mload(0))
 }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     let a := mload(0)
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/smoke.yul

@@ -1,5 +1,6 @@
 { }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 // }

test/libyul/yulOptimizerTests/expressionSimplifier/unassigend_vars_multi.yul

@@ -3,8 +3,9 @@
 	let c, d
 	let y := add(d, add(c, 7))
 }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     let c, d
 //     let y := 7

test/libyul/yulOptimizerTests/expressionSimplifier/unassigned_vars.yul

@@ -4,8 +4,9 @@
 	let d
 	let y := add(d, add(c, 7))
 }
+// ====
+// step: expressionSimplifier
 // ----
-// expressionSimplifier
 // {
 //     let c
 //     let d

test/libyul/yulOptimizerTests/expressionSplitter/control_flow.yul

@@ -7,8 +7,9 @@
 		}
 	}
 }
+// ====
+// step: expressionSplitter
 // ----
-// expressionSplitter
 // {
 //     let _1 := 0
 //     let x := calldataload(_1)

test/libyul/yulOptimizerTests/expressionSplitter/inside_function.yul

@@ -5,8 +5,9 @@
 	}
 	sstore(x, f(mload(2), mload(2)))
 }
+// ====
+// step: expressionSplitter
 // ----
-// expressionSplitter
 // {
 //     let _1 := 3
 //     let _2 := 7

test/libyul/yulOptimizerTests/expressionSplitter/object_access.yul

@@ -6,8 +6,9 @@
     // datacopy is fine, though
     datacopy(mload(0), mload(1), mload(2))
 }
+// ====
+// step: expressionSplitter
 // ----
-// expressionSplitter
 // {
 //     let x := dataoffset("abc")
 //     let y := datasize("abc")