[isoltest] Add support for call-effects.

aarlt · aarlt · commit 7390def56b1e · 2021-04-29T21:06:07.000-05:00
diff --git a/test/libsolidity/SemanticTest.cpp b/test/libsolidity/SemanticTest.cpp
@@ -123,7 +123,12 @@ void SemanticTest::initializeBuiltins()
 	solAssert(m_builtins.count("smokeTest") == 0, "");
 	m_builtins["smokeTest"] = [](FunctionCall const&) -> std::optional<bytes>
 	{
-		return util::toBigEndian(u256(0x1234));
+	  return util::toBigEndian(u256(0x1234));
+	};
+	solAssert(m_builtins.count("effectsTest") == 0, "");
+	m_builtins["effectsTest"] = [](FunctionCall const&) -> std::optional<bytes>
+	{
+		return util::toBigEndian(u256(0x2345));
 	};
 	soltestAssert(m_builtins.count("balance") == 0, "");
 	m_builtins["balance"] = [this](FunctionCall const& _call) -> std::optional<bytes>
@@ -142,6 +147,31 @@ void SemanticTest::initializeBuiltins()
 		soltestAssert(_call.arguments.parameters.empty(), "No arguments expected.");
 		return toBigEndian(u256(storageEmpty(m_contractAddress) ? 1 : 0));
 	};
+	m_hooks.emplace_back(
+		[](FunctionCall const& _call) -> std::vector<std::string>
+		{
+			if (_call.signature.find("effectsTest") != string::npos)
+				return {_call.signature + "0"};
+			return {};
+		}
+	);
+	m_hooks.emplace_back(
+		[](FunctionCall const& _call) -> std::vector<std::string>
+		{
+			if (_call.signature.find("effectsTest") != string::npos)
+				return {_call.signature + "1", _call.signature + "2"};
+			return {};
+		}
+	);
+}
+
+vector<string> SemanticTest::effectsOfCall(FunctionCall const& _call) const
+{
+	vector<string> effects;
+	for (auto const& hook: m_hooks)
+		for (auto const& effect: hook(_call))
+			effects.emplace_back(effect);
+	return effects;
 }
 
 TestCase::TestResult SemanticTest::run(ostream& _stream, string const& _linePrefix, bool _formatted)
@@ -299,6 +329,8 @@ TestCase::TestResult SemanticTest::runTest(
 			test.setRawBytes(std::move(output));
 			test.setContractABI(m_compiler.contractABI(m_compiler.lastContractName(m_sources.mainSourceFile)));
 		}
+
+		success &= test.call().effects == effectsOfCall(test.call());
 	}
 
 	if (!m_testCaseWantsYulRun && _isYulRun)
@@ -361,7 +393,8 @@ TestCase::TestResult SemanticTest::runTest(
 				_linePrefix,
 				m_gasCostFailure ? TestFunctionCall::RenderMode::ExpectedValuesActualGas : TestFunctionCall::RenderMode::ActualValuesExpectedGas,
 				_formatted,
-				/* _interactivePrint */ true
+				/* _interactivePrint */ true,
+				effectsOfCall(test.call())
 			) << endl;
 			_stream << errorReporter.format(_linePrefix, _formatted);
 		}
@@ -483,7 +516,8 @@ void SemanticTest::printUpdatedExpectations(ostream& _stream, string const&) con
 		_stream << test.format(
 			"",
 			m_gasCostFailure ? TestFunctionCall::RenderMode::ExpectedValuesActualGas : TestFunctionCall::RenderMode::ActualValuesExpectedGas,
-			/* _highlight = */ false
+			/* _highlight = */ false,
+			effectsOfCall(test.call())
 		) << endl;
 }
 
diff --git a/test/libsolidity/SemanticTest.h b/test/libsolidity/SemanticTest.h
@@ -81,6 +81,7 @@ class SemanticTest: public SolidityExecutionFramework, public EVMVersionRestrict
 	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();
+	std::vector<std::string> effectsOfCall(FunctionCall const& _call) const;
 	SourceMap m_sources;
 	std::size_t m_lineOffset;
 	std::vector<TestFunctionCall> m_tests;
@@ -94,7 +95,7 @@ class SemanticTest: public SolidityExecutionFramework, public EVMVersionRestrict
 	bool m_canEnableYulRun = false;
 	bool m_canEnableEwasmRun = false;
 	std::map<std::string, Builtin> m_builtins{};
-
+	std::vector<Hook> m_hooks{};
 	bool m_gasCostFailure = false;
 	bool m_enforceGasCost = false;
 	u256 m_enforceGasCostMinValue;
diff --git a/test/libsolidity/semanticTests/isoltestTesting/effects.sol b/test/libsolidity/semanticTests/isoltestTesting/effects.sol
@@ -0,0 +1,14 @@
+contract SmokeTest {
+}
+// ====
+// compileViaYul: also
+// ----
+// constructor()
+// effectsTest -> 0x2345
+// - effectsTest0
+// - effectsTest1
+// - effectsTest2
+// effectsTest -> 0x2345
+// - effectsTest0
+// - effectsTest1
+// - effectsTest2
diff --git a/test/libsolidity/util/SoltestTypes.h b/test/libsolidity/util/SoltestTypes.h
@@ -42,6 +42,7 @@ namespace solidity::frontend::test
 	T(Comma,  ",", 0)                  \
 	T(Period, ".", 0)                  \
 	T(Arrow, "->", 0)                  \
+	T(Effect, "- ", 0)                 \
 	T(Newline, "//", 0)                \
 	/* Literals & identifier */        \
 	T(Comment, "#", 0)                 \
@@ -302,8 +303,11 @@ struct FunctionCall
 	/// Marks this function call as "short-handed", meaning
 	/// no `->` declared.
 	bool omitsArrow = true;
+	/// A textual representation of the effect of the function call.
+	std::vector<std::string> effects{};
 };
 
 using Builtin = std::function<std::optional<bytes>(FunctionCall const&)>;
+using Hook = std::function<std::vector<std::string>(FunctionCall const&)>;
 
 }
diff --git a/test/libsolidity/util/TestFileParser.cpp b/test/libsolidity/util/TestFileParser.cpp
@@ -154,6 +154,8 @@ vector<solidity::frontend::test::FunctionCall> TestFileParser::parseFunctionCall
 								call.kind = FunctionCall::Kind::Constructor;
 						}
 
+						call.effects = parseFunctionCallEffects();
+
 						calls.emplace_back(std::move(call));
 					}
 				}
@@ -169,6 +171,25 @@ vector<solidity::frontend::test::FunctionCall> TestFileParser::parseFunctionCall
 	return calls;
 }
 
+vector<string> TestFileParser::parseFunctionCallEffects()
+{
+	vector<string> result;
+	while (accept(Token::Effect, false))
+	{
+		string effect = m_scanner.currentLiteral();
+		result.emplace_back(effect);
+
+		if (m_scanner.currentToken() == Token::Effect)
+			m_scanner.scanNextToken();
+		if (m_scanner.currentToken() == Token::Newline)
+			m_scanner.scanNextToken();
+		if (m_scanner.currentToken() == Token::EOS)
+			break;
+	}
+
+	return result;
+}
+
 bool TestFileParser::accept(Token _token, bool const _expect)
 {
 	if (m_scanner.currentToken() != _token)
@@ -542,6 +563,11 @@ void TestFileParser::Scanner::scanNextToken()
 				advance();
 				selectToken(Token::Arrow);
 			}
+			else if (peek() == ' ')
+			{
+				advance();
+				selectToken(Token::Effect, scanEffectString());
+			}
 			else
 				selectToken(Token::Sub);
 			break;
@@ -601,6 +627,17 @@ void TestFileParser::Scanner::scanNextToken()
 	while (m_currentToken == Token::Whitespace);
 }
 
+string TestFileParser::Scanner::scanEffectString()
+{
+	string effect;
+	while (peek() != '/' && peek() != '\0')
+	{
+		advance();
+		effect += current();
+	}
+	return effect;
+}
+
 string TestFileParser::Scanner::scanComment()
 {
 	string comment;
diff --git a/test/libsolidity/util/TestFileParser.h b/test/libsolidity/util/TestFileParser.h
@@ -87,6 +87,7 @@ class TestFileParser
 		std::string scanDecimalNumber();
 		std::string scanHexNumber();
 		std::string scanString();
+		std::string scanEffectString();
 		char scanHexPart();
 
 	private:
@@ -177,6 +178,9 @@ class TestFileParser
 	/// Parses the current string literal.
 	std::string parseString();
 
+	/// Parses the expected effects of a function call execution.
+	std::vector<std::string> parseFunctionCallEffects();
+
 	/// Checks whether a builtin function with the given signature exist.
 	/// @returns true, if builtin found, false otherwise
 	bool isBuiltinFunction(std::string const& signature);
diff --git a/test/libsolidity/util/TestFileParserTests.cpp b/test/libsolidity/util/TestFileParserTests.cpp
@@ -23,6 +23,7 @@
 #include <string>
 #include <tuple>
 #include <boost/test/unit_test.hpp>
+#include <boost/algorithm/string/trim.hpp>
 #include <liblangutil/Exceptions.h>
 #include <test/ExecutionFramework.h>
 
@@ -42,10 +43,10 @@ using Mode = FunctionCall::DisplayMode;
 namespace
 {
 
-vector<FunctionCall> parse(string const& _source)
+vector<FunctionCall> parse(string const& _source, std::map<std::string, Builtin> const& _builtins = {})
 {
 	istringstream stream{_source, ios_base::out};
-	TestFileParser parser{stream, {}};
+	TestFileParser parser{stream, _builtins};
 	return parser.parseFunctionCalls(0);
 }
 
@@ -958,6 +959,43 @@ BOOST_AUTO_TEST_CASE(library)
 	);
 }
 
+BOOST_AUTO_TEST_CASE(call_effects)
+{
+	std::map<std::string, Builtin> builtins;
+	builtins["builtin_returning_call_effect"] = [](FunctionCall const&) -> std::optional<bytes>
+	{
+	  return util::toBigEndian(u256(0x1234));
+	};
+	char const* source = R"(
+		// builtin_returning_call_effect -> 1
+		// - bla
+		// - bla bla
+		// - bla bla bla
+	)";
+	vector<FunctionCall> calls = parse(source, builtins);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	BOOST_REQUIRE_EQUAL(calls[0].effects.size(), 3);
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].effects[0]), "bla");
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].effects[1]), "bla bla");
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].effects[2]), "bla bla bla");
+	source = R"(
+		// builtin_returning_call_effect -> 1
+		// - bla
+		// - bla bla
+		// builtin_returning_call_effect -> 2
+		// - bla bla bla
+		// builtin_returning_call_effect -> 3
+	)";
+	calls = parse(source, builtins);
+	BOOST_REQUIRE_EQUAL(calls.size(), 3);
+	BOOST_REQUIRE_EQUAL(calls[0].effects.size(), 2);
+	BOOST_REQUIRE_EQUAL(calls[1].effects.size(), 1);
+	BOOST_REQUIRE_EQUAL(calls[2].effects.size(), 0);
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].effects[0]), "bla");
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[0].effects[1]), "bla bla");
+	BOOST_REQUIRE_EQUAL(boost::trim_copy(calls[1].effects[0]), "bla bla bla");
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }
diff --git a/test/libsolidity/util/TestFunctionCall.cpp b/test/libsolidity/util/TestFunctionCall.cpp
@@ -37,7 +37,8 @@ string TestFunctionCall::format(
 	string const& _linePrefix,
 	RenderMode _renderMode,
 	bool const _highlight,
-	bool const _interactivePrint
+	bool const _interactivePrint,
+	std::vector<std::string> const & _callEffects
 ) const
 {
 	stringstream stream;
@@ -197,6 +198,17 @@ string TestFunctionCall::format(
 		}
 
 		stream << formatGasExpectations(_linePrefix, _renderMode == RenderMode::ExpectedValuesActualGas, _interactivePrint);
+
+		if (!_callEffects.empty())
+		{
+			stream << std::endl;
+			for (string const& effect: _callEffects)
+			{
+				stream << _linePrefix << "// - " << effect;
+				if (effect != *_callEffects.rbegin())
+					stream << std::endl;
+			}
+		}
 	};
 
 	formatOutput(m_call.displayMode == FunctionCall::DisplayMode::SingleLine);
diff --git a/test/libsolidity/util/TestFunctionCall.h b/test/libsolidity/util/TestFunctionCall.h
@@ -68,19 +68,21 @@ class TestFunctionCall
 		std::string const& _linePrefix = "",
 		RenderMode _renderMode = RenderMode::ExpectedValuesExpectedGas,
 		bool const _highlight = false,
-		bool const _interactivePrint = false
+		bool const _interactivePrint = false,
+		std::vector<std::string> const & _callEffects = {}
 	) const;
 
 	/// Overloaded version that passes an error reporter which is never used outside
 	/// of this function.
 	std::string format(
 		std::string const& _linePrefix = "",
 		RenderMode const _renderMode = RenderMode::ExpectedValuesExpectedGas,
-		bool const _highlight = false
+		bool const _highlight = false,
+		std::vector<std::string> const & _callEffects = {}
 	) const
 	{
 		ErrorReporter reporter;
-		return format(reporter, _linePrefix, _renderMode, _highlight);
+		return format(reporter, _linePrefix, _renderMode, _highlight, false, _callEffects);
 	}
 
 	/// Resets current results in case the function was called and the result
