[test] Add support for --enforce-compile-to-ewasm.

Author: aarlt

test/boostTest.cpp

@@ -79,7 +79,7 @@ int registerTests(
 		_enforceViaYul,
 		_enforceCompileToEwasm,
 		solidity::test::CommonOptions::get().enforceGasTest,
-		solidity::test::CommonOptions::get().enforceGasTestMinValue
+		solidity::test::CommonOptions::get().enforceGasTestMinValue,
 	};
 	if (fs::is_directory(fullpath))
 	{

test/libsolidity/SemanticTest.cpp

@@ -61,51 +61,41 @@ SemanticTest::SemanticTest(
 	m_enforceViaYul(_enforceViaYul),
 	m_enforceCompileToEwasm(_enforceCompileToEwasm),
 	m_enforceGasCost(_enforceGasCost),
-	m_enforceGasCostMinValue(_enforceGasCostMinValue)
+	m_enforceGasCostMinValue(std::move(_enforceGasCostMinValue))
 {
 	initializeBuiltins();
 
-	string choice = m_reader.stringSetting("compileViaYul", "default");
-	if (choice == "also")
-	{
-		m_runWithYul = true;
-		m_runWithoutYul = true;
-	}
-	else if (choice == "true")
-	{
-		m_runWithYul = true;
-		m_runWithoutYul = false;
-	}
-	else if (choice == "false")
+	static set<string> const compileViaYulAllowedValues{"also", "true", "false", "default"};
+	static set<string> const yulRunTriggers{"also", "true"};
+	static set<string> const legacyRunTriggers{"also", "false", "default"};
+
+	string compileViaYul = m_reader.stringSetting("compileViaYul", "default");
+	if (!contains(compileViaYulAllowedValues, compileViaYul))
+		BOOST_THROW_EXCEPTION(runtime_error("Invalid compileViaYul value: " + compileViaYul + "."));
+	m_testCaseWantsYulRun = contains(yulRunTriggers, compileViaYul);
+	m_testCaseWantsLegacyRun = contains(legacyRunTriggers, compileViaYul);
+
+	// Do not enforce via yul and ewasm, if via yul was explicitly denied.
+	if (compileViaYul == "false")
 	{
-		m_runWithYul = false;
-		m_runWithoutYul = true;
-		// Do not try to run via yul if explicitly denied.
 		m_enforceViaYul = false;
 		m_enforceCompileToEwasm = false;
 	}
-	else if (choice == "default")
-	{
-		m_runWithYul = false;
-		m_runWithoutYul = true;
-	}
-	else
-		BOOST_THROW_EXCEPTION(runtime_error("Invalid compileViaYul value: " + choice + "."));
 
 	string compileToEwasm = m_reader.stringSetting("compileToEwasm", "false");
 	if (compileToEwasm == "also")
-		m_runWithEwasm = true;
+		m_testCaseWantsEwasmRun = true;
 	else if (compileToEwasm == "false")
-		m_runWithEwasm = false;
+		m_testCaseWantsEwasmRun = false;
 	else
 		BOOST_THROW_EXCEPTION(runtime_error("Invalid compileToEwasm value: " + compileToEwasm + "."));
 
-	if (m_runWithEwasm && !m_runWithYul)
+	if (m_testCaseWantsEwasmRun && !m_testCaseWantsYulRun)
 		BOOST_THROW_EXCEPTION(runtime_error("Invalid compileToEwasm value: " + compileToEwasm + ", compileViaYul need to be enabled."));
 
 	// run ewasm tests only, if an ewasm evmc vm was defined
-	if (m_runWithEwasm && !m_supportsEwasm)
-		m_runWithEwasm = false;
+	if (m_testCaseWantsEwasmRun && !m_supportsEwasm)
+		m_testCaseWantsEwasmRun = false;
 
 	m_runWithABIEncoderV1Only = m_reader.boolSetting("ABIEncoderV1Only", false);
 	if (m_runWithABIEncoderV1Only && !solidity::test::CommonOptions::get().useABIEncoderV1)
@@ -139,17 +129,16 @@ void SemanticTest::initializeBuiltins()
 TestCase::TestResult SemanticTest::run(ostream& _stream, string const& _linePrefix, bool _formatted)
 {
 	TestResult result = TestResult::Success;
-	bool compileViaYul = m_runWithYul || m_enforceViaYul;
-	bool compileToEwasm = m_runWithEwasm || m_enforceCompileToEwasm;
 
-	if (m_runWithoutYul)
+	if (m_testCaseWantsLegacyRun)
 		result = runTest(_stream, _linePrefix, _formatted, false, false);
 
-	if (compileViaYul && result == TestResult::Success)
+	if ((m_testCaseWantsYulRun || m_enforceViaYul) && result == TestResult::Success)
 		result = runTest(_stream, _linePrefix, _formatted, true, false);
 
-	if (compileToEwasm && result == TestResult::Success)
+	if ((m_testCaseWantsEwasmRun || m_enforceCompileToEwasm) && result == TestResult::Success)
 	{
+		// TODO: Once we have full Ewasm support, we could remove try/catch here.
 		try
 		{
 			result = runTest(_stream, _linePrefix, _formatted, true, true);
@@ -167,32 +156,31 @@ TestCase::TestResult SemanticTest::runTest(
 	ostream& _stream,
 	string const& _linePrefix,
 	bool _formatted,
-	bool _compileViaYul,
-	bool _compileToEwasm
-)
+	bool _isYulRun,
+	bool _isEwasmRun)
 {
 	bool success = true;
 	m_gasCostFailure = false;
 
-	if (_compileViaYul && _compileToEwasm)
+	if (_isYulRun && _isEwasmRun)
 		selectVM(evmc_capabilities::EVMC_CAPABILITY_EWASM);
 	else
 		selectVM(evmc_capabilities::EVMC_CAPABILITY_EVM1);
 
 	reset();
 
-	m_compileViaYul = _compileViaYul;
-	if (_compileToEwasm)
+	m_compileViaYul = _isYulRun;
+	if (_isEwasmRun)
 	{
 		soltestAssert(m_compileViaYul, "");
-		m_compileToEwasm = _compileToEwasm;
+		m_compileToEwasm = _isEwasmRun;
 	}
 
-	m_compileViaYulCanBeSet = false;
-	m_compileToEwasmCanBeSet = false;
+	m_canEnableYulRun = false;
+	m_canEnableEwasmRun = false;
 
-	if (_compileViaYul)
-		AnsiColorized(_stream, _formatted, {BOLD, CYAN}) << _linePrefix << "Running via Yul:" << endl;
+	if (_isYulRun)
+		AnsiColorized(_stream, _formatted, {BOLD, CYAN}) << _linePrefix << "Running via Yul" << (_isEwasmRun ? " (ewasm):" : ":") << endl;
 
 	for (TestFunctionCall& test: m_tests)
 		test.reset();
@@ -244,7 +232,7 @@ TestCase::TestResult SemanticTest::runTest(
 		{
 			if (m_transactionSuccessful == test.call().expectations.failure)
 				success = false;
-			if (success && !checkGasCostExpectation(test, _compileViaYul))
+			if (success && !checkGasCostExpectation(test, _isYulRun))
 				m_gasCostFailure = true;
 
 			test.setFailure(!m_transactionSuccessful);
@@ -282,7 +270,7 @@ TestCase::TestResult SemanticTest::runTest(
 			}
 
 			bool outputMismatch = (output != test.call().expectations.rawBytes());
-			if (!outputMismatch && !checkGasCostExpectation(test, _compileViaYul))
+			if (!outputMismatch && !checkGasCostExpectation(test, _isYulRun))
 			{
 				success = false;
 				m_gasCostFailure = true;
@@ -301,9 +289,9 @@ TestCase::TestResult SemanticTest::runTest(
 		}
 	}
 
-	if (!m_runWithYul && _compileViaYul)
+	if (!m_testCaseWantsYulRun && _isYulRun)
 	{
-		m_compileViaYulCanBeSet = success;
+		m_canEnableYulRun = success;
 		string message = success ?
 			"Test can pass via Yul, but marked with \"compileViaYul: false.\"" :
 			"Test compiles via Yul, but it gives different test results.";
@@ -313,21 +301,29 @@ TestCase::TestResult SemanticTest::runTest(
 		return TestResult::Failure;
 	}
 
-	if (success && !m_runWithEwasm && _compileToEwasm)
+	// Right now we have sometimes different test results in Yul vs. Ewasm.
+	// The main reason is that Ewasm just returns a failure in some cases.
+	// TODO: If Ewasm support got fully implemented, we could implement this in the same way as above.
+	if (success && !m_testCaseWantsEwasmRun && _isEwasmRun)
 	{
+		// TODO: There is something missing in Ewasm to support other types of revert strings:
+		//  for now, we just ignore test-cases that are different from RevertStrings::Default.
 		if (m_revertStrings != RevertStrings::Default)
 			return TestResult::Success;
 
-		m_compileToEwasmCanBeSet = true;
-		AnsiColorized(_stream, _formatted, {BOLD, YELLOW})
-			<< _linePrefix << endl
-			<< _linePrefix << "Test can pass via Yul (ewasm), but marked with \"compileToEwasm: false.\"" << endl;
+		m_canEnableEwasmRun = true;
+		AnsiColorized(_stream, _formatted, {BOLD, YELLOW}) <<
+			_linePrefix << endl <<
+			_linePrefix << "Test can pass via Yul (Ewasm), but marked with \"compileToEwasm: false.\"" << endl;
 		return TestResult::Failure;
 	}
 
-	if (!success && (m_runWithYul || !_compileViaYul))
+	if (!success)
 	{
-		if (!m_runWithEwasm && m_enforceCompileToEwasm)
+		// Ignore failing tests that can't yet get compiled to Ewasm:
+		// if the test run was not successful and enforce compiling to ewasm was set,
+		// but the test case did not wanted to get run with Ewasm, we just ignore this failure.
+		if (m_enforceCompileToEwasm && !m_testCaseWantsEwasmRun)
 			return TestResult::Success;
 
 		AnsiColorized(_stream, _formatted, {BOLD, CYAN}) << _linePrefix << "Expected result:" << endl;
@@ -360,13 +356,13 @@ TestCase::TestResult SemanticTest::runTest(
 		AnsiColorized(_stream, _formatted, {BOLD, RED})
 			<< _linePrefix << endl
 			<< _linePrefix << "Attention: Updates on the test will apply the detected format displayed." << endl;
-		if (_compileViaYul && m_runWithoutYul)
+		if (_isYulRun && m_testCaseWantsLegacyRun)
 		{
 			_stream << _linePrefix << endl << _linePrefix;
 			AnsiColorized(_stream, _formatted, {RED_BACKGROUND}) << "Note that the test passed without Yul.";
 			_stream << endl;
 		}
-		else if (!_compileViaYul && m_runWithYul)
+		else if (!_isYulRun && m_testCaseWantsYulRun)
 			AnsiColorized(_stream, _formatted, {BOLD, YELLOW})
 				<< _linePrefix << endl
 				<< _linePrefix << "Note that the test also has to pass via Yul." << endl;
@@ -460,32 +456,24 @@ void SemanticTest::printUpdatedExpectations(ostream& _stream, string const&) con
 void SemanticTest::printUpdatedSettings(ostream& _stream, string const& _linePrefix)
 {
 	auto& settings = m_reader.settings();
-	if (settings.empty() && !m_compileViaYulCanBeSet)
+	if (settings.empty() && !m_canEnableYulRun)
 		return;
 
 	_stream << _linePrefix << "// ====" << endl;
-	if (m_compileToEwasmCanBeSet)
+	if (m_canEnableEwasmRun)
 	{
-		// if test was already configured to run via yul,
-		// we need to preserve the original settings.
-		if (m_runWithYul)
-		{
-			// if test was also configured to run without yul.
-			if (m_runWithoutYul)
-				_stream << _linePrefix << "// compileViaYul: also\n";
-			// if test was configured only to run with yul.
-			else
-				_stream << _linePrefix << "// compileViaYul: true\n";
-		}
-
+		string compileViaYul = m_reader.stringSetting("compileViaYul", "");
+		if (!compileViaYul.empty())
+			_stream << _linePrefix << "// compileViaYul: " << compileViaYul << "\n";
 		_stream << _linePrefix << "// compileToEwasm: also\n";
 	}
-	else if (m_compileViaYulCanBeSet)
+	else if (m_canEnableYulRun)
 		_stream << _linePrefix << "// compileViaYul: also\n";
 
 	for (auto const& setting: settings)
-		if (!(m_compileViaYulCanBeSet || m_compileToEwasmCanBeSet) || setting.first != "compileViaYul")
-			_stream << _linePrefix << "// " << setting.first << ": " << setting.second << endl;
+		if (!(m_canEnableEwasmRun && setting.first == "compileToEwasm")
+			&& (!((m_canEnableYulRun || m_canEnableEwasmRun) && setting.first == "compileViaYul")))
+				_stream << _linePrefix << "// " << setting.first << ": " << setting.second << endl;
 }
 
 void SemanticTest::parseExpectations(istream& _stream)

test/libsolidity/SemanticTest.h

@@ -78,21 +78,21 @@ class SemanticTest: public SolidityExecutionFramework, public EVMVersionRestrict
 	bool deploy(std::string const& _contractName, u256 const& _value, bytes const& _arguments, std::map<std::string, solidity::test::Address> const& _libraries = {});
 
 private:
-	TestResult runTest(std::ostream& _stream, std::string const& _linePrefix, bool _formatted, bool _compileViaYul, bool _compileToEwasm);
+	TestResult runTest(std::ostream& _stream, std::string const& _linePrefix, bool _formatted, bool _isYulRun, bool _isEwasmRun);
 	bool checkGasCostExpectation(TestFunctionCall& io_test, bool _compileViaYul) const;
 	void initializeBuiltins();
 	SourceMap m_sources;
 	std::size_t m_lineOffset;
 	std::vector<TestFunctionCall> m_tests;
-	bool m_runWithYul = false;
-	bool m_runWithEwasm = false;
-	bool m_runWithoutYul = true;
+	bool m_testCaseWantsYulRun = false;
+	bool m_testCaseWantsEwasmRun = false;
+	bool m_testCaseWantsLegacyRun = true;
 	bool m_enforceViaYul = false;
 	bool m_enforceCompileToEwasm = false;
 	bool m_runWithABIEncoderV1Only = false;
 	bool m_allowNonExistingFunctions = false;
-	bool m_compileViaYulCanBeSet = false;
-	bool m_compileToEwasmCanBeSet = false;
+	bool m_canEnableYulRun = false;
+	bool m_canEnableEwasmRun = false;
 	std::map<std::string, Builtin> m_builtins{};
 
 	bool m_gasCostFailure = false;