[isoltest] Add support for builtin functions.

aarlt · aarlt · commit 7903410239fb · 2021-02-01T15:03:54.000-05:00
diff --git a/liblangutil/Common.h b/liblangutil/Common.h
@@ -45,6 +45,11 @@ inline bool isIdentifierPart(char c)
 	return isIdentifierStart(c) || isDecimalDigit(c);
 }
 
+inline bool isIdentifierPartWithDot(char c)
+{
+	return isIdentifierPart(c) || c == '.';
+}
+
 inline int hexValue(char c)
 {
 	if (c >= '0' && c <= '9')
diff --git a/test/libsolidity/SemanticTest.cpp b/test/libsolidity/SemanticTest.cpp
@@ -13,6 +13,7 @@
 */
 
 #include <test/libsolidity/SemanticTest.h>
+#include <test/libsolidity/util/BytesUtils.h>
 #include <libsolutil/Whiskers.h>
 #include <libyul/Exceptions.h>
 #include <test/Common.h>
@@ -47,6 +48,15 @@ SemanticTest::SemanticTest(string const& _filename, langutil::EVMVersion _evmVer
 	m_lineOffset(m_reader.lineNumber()),
 	m_enforceViaYul(enforceViaYul)
 {
+	using namespace std::placeholders;
+	m_builtins
+		= {{"smoke",
+			{
+				{"test0()", std::bind(&SemanticTest::builtinSmokeTest, this, _1)},
+				{"test1(uint256)", std::bind(&SemanticTest::builtinSmokeTest, this, _1)},
+				{"test2(uint256,uint256)", std::bind(&SemanticTest::builtinSmokeTest, this, _1)},
+			}}};
+
 	string choice = m_reader.stringSetting("compileViaYul", "default");
 	if (choice == "also")
 	{
@@ -197,6 +207,15 @@ TestCase::TestResult SemanticTest::runTest(ostream& _stream, string const& _line
 			bytes output;
 			if (test.call().kind == FunctionCall::Kind::LowLevel)
 				output = callLowLevel(test.call().arguments.rawBytes(), test.call().value.value);
+			else if (test.call().kind == FunctionCall::Kind::Builtin)
+			{
+				std::vector<string> builtinPath;
+				boost::split(builtinPath, test.call().signature, boost::is_any_of("."));
+				assert(builtinPath.size() == 2);
+				auto builtin = m_builtins[builtinPath.front()][builtinPath.back()];
+				output = builtin(test.call());
+				test.setFailure(output.empty());
+			}
 			else
 			{
 				soltestAssert(
@@ -212,14 +231,33 @@ TestCase::TestResult SemanticTest::runTest(ostream& _stream, string const& _line
 				);
 			}
 
-			bool outputMismatch = (output != test.call().expectations.rawBytes());
-			// Pre byzantium, it was not possible to return failure data, so we disregard
-			// output mismatch for those EVM versions.
-			if (test.call().expectations.failure && !m_transactionSuccessful && !m_evmVersion.supportsReturndata())
-				outputMismatch = false;
-			if (m_transactionSuccessful != !test.call().expectations.failure || outputMismatch)
-				success = false;
+			bytes expectationOutput;
+			if (test.call().expectations.builtin)
+			{
+				std::vector<string> builtinPath;
+				boost::split(builtinPath, test.call().expectations.builtin->signature, boost::is_any_of("."));
+				assert(builtinPath.size() == 2);
+				auto builtin = m_builtins[builtinPath.front()][builtinPath.back()];
+				expectationOutput = builtin(*test.call().expectations.builtin);
+			}
+			else
+				expectationOutput = test.call().expectations.rawBytes();
 
+			bool outputMismatch = (output != expectationOutput);
+			if (test.call().kind == FunctionCall::Kind::Builtin)
+			{
+				if (outputMismatch)
+					success = false;
+			}
+			else
+			{
+				// Pre byzantium, it was not possible to return failure data, so we disregard
+				// output mismatch for those EVM versions.
+				if (test.call().expectations.failure && !m_transactionSuccessful && !m_evmVersion.supportsReturndata())
+					outputMismatch = false;
+				if (m_transactionSuccessful != !test.call().expectations.failure || outputMismatch)
+					success = false;
+			}
 			test.setFailure(!m_transactionSuccessful);
 			test.setRawBytes(std::move(output));
 			test.setContractABI(m_compiler.contractABI(m_compiler.lastContractName()));
@@ -340,13 +378,26 @@ void SemanticTest::printUpdatedSettings(ostream& _stream, string const& _linePre
 
 void SemanticTest::parseExpectations(istream& _stream)
 {
-	TestFileParser parser{_stream};
+	TestFileParser parser{_stream, &this->m_builtins};
 	auto functionCalls = parser.parseFunctionCalls(m_lineOffset);
 	std::move(functionCalls.begin(), functionCalls.end(), back_inserter(m_tests));
 }
 
-bool SemanticTest::deploy(string const& _contractName, u256 const& _value, bytes const& _arguments, map<string, solidity::test::Address> const& _libraries)
+bool SemanticTest::deploy(
+	string const& _contractName,
+	u256 const& _value,
+	bytes const& _arguments,
+	map<string, solidity::test::Address> const& _libraries)
 {
 	auto output = compileAndRunWithoutCheck(m_sources.sources, _value, _contractName, _arguments, _libraries);
 	return !output.empty() && m_transactionSuccessful;
 }
+
+bytes SemanticTest::builtinSmokeTest(FunctionCall const& call)
+{
+	// This function is only used in test/libsolidity/semanticTests/builtins/smoke.sol.
+	bytes result;
+	for (const auto & parameter : call.arguments.parameters)
+		result += util::toBigEndian(u256{util::fromHex(parameter.rawString)});
+	return result;
+}
diff --git a/test/libsolidity/SemanticTest.h b/test/libsolidity/SemanticTest.h
@@ -58,7 +58,11 @@ class SemanticTest: public SolidityExecutionFramework, public EVMVersionRestrict
 	/// Compiles and deploys currently held source.
 	/// Returns true if deployment was successful, false otherwise.
 	bool deploy(std::string const& _contractName, u256 const& _value, bytes const& _arguments, std::map<std::string, solidity::test::Address> const& _libraries = {});
+
 private:
+	// builtin functions
+	bytes builtinSmokeTest(FunctionCall const& call);
+
 	TestResult runTest(std::ostream& _stream, std::string const& _linePrefix, bool _formatted, bool _compileViaYul, bool _compileToEwasm);
 	SourceMap m_sources;
 	std::size_t m_lineOffset;
@@ -70,6 +74,7 @@ class SemanticTest: public SolidityExecutionFramework, public EVMVersionRestrict
 	bool m_runWithABIEncoderV1Only = false;
 	bool m_allowNonExistingFunctions = false;
 	bool m_compileViaYulCanBeSet = false;
+	BuiltinFunctions m_builtins;
 };
 
 }
diff --git a/test/libsolidity/semanticTests/builtins/smoke.sol b/test/libsolidity/semanticTests/builtins/smoke.sol
@@ -0,0 +1,8 @@
+contract ClientReceipt {
+}
+// ====
+// compileViaYul: also
+// ----
+// smoke.test0() ->
+// smoke.test1(uint256): 1 -> 1
+// smoke.test2(uint256,uint256): 2, 3 -> 2, 3
diff --git a/test/libsolidity/util/SoltestTypes.h b/test/libsolidity/util/SoltestTypes.h
@@ -17,6 +17,8 @@
 #include <libsolutil/AnsiColorized.h>
 #include <libsolutil/CommonData.h>
 
+#include <test/ExecutionFramework.h>
+
 namespace solidity::frontend::test
 {
 
@@ -174,6 +176,8 @@ struct Parameter
 };
 using ParameterList = std::vector<Parameter>;
 
+struct FunctionCall;
+
 /**
  * Represents the expected result of a function call after it has been executed. This may be a single
  * return value or a comma-separated list of return values. It also contains the detected input
@@ -193,6 +197,9 @@ struct FunctionCallExpectations
 	/// A Comment that can be attached to the expectations,
 	/// that is retained and can be displayed.
 	std::string comment;
+	/// An expectation can also be defined by a builtin function.
+	std::shared_ptr<FunctionCall> builtin;
+
 	/// ABI encoded `bytes` of parsed expected return values. It is checked
 	/// against the actual result of a function call when used in test framework.
 	bytes rawBytes() const
@@ -286,12 +293,17 @@ struct FunctionCall
 		/// Marks a library deployment call.
 		Library,
 		/// Check that the storage of the current contract is empty or non-empty.
-		Storage
+		Storage,
+		/// Call to a builtin.
+		Builtin
 	};
 	Kind kind = Kind::Regular;
 	/// Marks this function call as "short-handed", meaning
 	/// no `->` declared.
 	bool omitsArrow = true;
 };
 
+using BuiltinFunction = std::function<bytes(FunctionCall const&)>;
+using BuiltinFunctions = std::map<std::string, std::map<std::string, BuiltinFunction>>;
+
 }
diff --git a/test/libsolidity/util/TestFileParser.cpp b/test/libsolidity/util/TestFileParser.cpp
@@ -26,6 +26,7 @@
 
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/split.hpp>
 #include <boost/throw_exception.hpp>
 
 #include <fstream>
@@ -107,6 +108,13 @@ vector<solidity::frontend::test::FunctionCall> TestFileParser::parseFunctionCall
 						if (lowLevelCall)
 							call.kind = FunctionCall::Kind::LowLevel;
 
+						// Treat all calls to functions containing '.' as calls to builtin functions.
+						if (call.signature.find('.') != std::string::npos)
+						{
+							checkBuiltinFunction(call.signature);
+							call.kind = FunctionCall::Kind::Builtin;
+						}
+
 						if (accept(Token::Comma, true))
 							call.value = parseFunctionCallValue();
 
@@ -158,6 +166,24 @@ vector<solidity::frontend::test::FunctionCall> TestFileParser::parseFunctionCall
 	return calls;
 }
 
+void TestFileParser::checkBuiltinFunction(std::string const& signature)
+{
+	assert(m_builtins != nullptr);
+	vector<string> builtinPath;
+	boost::split(builtinPath, signature, boost::is_any_of("."));
+	assert(builtinPath.size() == 2);
+
+	auto module = m_builtins->find(builtinPath.front());
+	if (module == m_builtins->end())
+		throw TestParserError("builtin module '" + builtinPath.front() + "' not found");
+
+	auto builtin = module->second.find(builtinPath.back());
+	if (builtin == module->second.end())
+		throw TestParserError(
+			"builtin function '" + builtinPath.back() + "' not found in module '"
+				+ builtinPath.front() + "'");
+}
+
 bool TestFileParser::accept(Token _token, bool const _expect)
 {
 	if (m_scanner.currentToken() != _token)
@@ -257,21 +283,43 @@ FunctionCallExpectations TestFileParser::parseFunctionCallExpectations()
 {
 	FunctionCallExpectations expectations;
 
-	auto param = parseParameter();
-	if (param.abiType.type == ABIType::None)
+	if (accept(Token::Identifier, false))
 	{
-		expectations.failure = false;
-		return expectations;
+		string signature;
+		FunctionCallArgs arguments;
+
+		signature = parseFunctionSignature().first;
+		if (signature.find('.') == std::string::npos)
+			throw TestParserError("Only builtins can be called as an expectation.");
+
+		checkBuiltinFunction(signature);
+
+		if (accept(Token::Colon, true))
+			arguments = parseFunctionCallArguments();
+
+		expectations.builtin = std::make_unique<FunctionCall>();
+		expectations.builtin->arguments = arguments;
+		expectations.builtin->signature = signature;
+		expectations.builtin->kind = FunctionCall::Kind::Builtin;
 	}
-	expectations.result.emplace_back(param);
+	else
+	{
+		auto param = parseParameter();
+		if (param.abiType.type == ABIType::None)
+		{
+			expectations.failure = false;
+			return expectations;
+		}
+		expectations.result.emplace_back(param);
 
-	while (accept(Token::Comma, true))
-		expectations.result.emplace_back(parseParameter());
+		while (accept(Token::Comma, true))
+			expectations.result.emplace_back(parseParameter());
 
-	/// We have always one virtual parameter in the parameter list.
-	/// If its type is FAILURE, the expected result is also a REVERT etc.
-	if (expectations.result.at(0).abiType.type != ABIType::Failure)
-		expectations.failure = false;
+		/// We have always one virtual parameter in the parameter list.
+		/// If its type is FAILURE, the expected result is also a REVERT etc.
+		if (expectations.result.at(0).abiType.type != ABIType::Failure)
+			expectations.failure = false;
+	}
 	return expectations;
 }
 
@@ -602,7 +650,7 @@ string TestFileParser::Scanner::scanIdentifierOrKeyword()
 {
 	string identifier;
 	identifier += current();
-	while (langutil::isIdentifierPart(peek()))
+	while (langutil::isIdentifierPartWithDot(peek()))
 	{
 		advance();
 		identifier += current();
diff --git a/test/libsolidity/util/TestFileParser.h b/test/libsolidity/util/TestFileParser.h
@@ -52,7 +52,7 @@ class TestFileParser
 public:
 	/// Constructor that takes an input stream \param _stream to operate on
 	/// and creates the internal scanner.
-	TestFileParser(std::istream& _stream): m_scanner(_stream) {}
+	explicit TestFileParser(std::istream& _stream, BuiltinFunctions* _builtins = nullptr): m_scanner(_stream), m_builtins(_builtins) {}
 
 	/// Parses function calls blockwise and returns a list of function calls found.
 	/// Throws an exception if a function call cannot be parsed because of its
@@ -177,12 +177,18 @@ class TestFileParser
 	/// Parses the current string literal.
 	std::string parseString();
 
+	/// Checks whether a builtin function with the given signature exist.
+	/// This function will throw an TestParserError exception, if not.
+	void checkBuiltinFunction(std::string const& signature);
+
 	/// A scanner instance
 	Scanner m_scanner;
 
 	/// The current line number. Incremented when Token::Newline (//) is found and
 	/// used to enhance parser error messages.
 	size_t m_lineNumber = 0;
+
+	BuiltinFunctions* m_builtins{nullptr};
 };
 
 }
diff --git a/test/libsolidity/util/TestFunctionCall.cpp b/test/libsolidity/util/TestFunctionCall.cpp
@@ -124,20 +124,37 @@ string TestFunctionCall::format(
 
 		/// Format either the expected output or the actual result output
 		string result;
+		auto& builtin = m_call.expectations.builtin;
 		if (!_renderResult)
 		{
-			bool const isFailure = m_call.expectations.failure;
-			result = isFailure ?
-				formatFailure(_errorReporter, m_call, m_rawBytes, _renderResult, highlight) :
-				formatRawParameters(m_call.expectations.result);
+			if (builtin)
+			{
+				result = builtin->signature;
+				if (!builtin->arguments.parameters.empty())
+					result += ": ";
+				result += formatRawParameters(builtin->arguments.parameters);
+			}
+			else
+			{
+				bool const isFailure = m_call.expectations.failure;
+				result = isFailure ?
+						 formatFailure(_errorReporter, m_call, m_rawBytes, _renderResult, highlight) :
+						 formatRawParameters(m_call.expectations.result);
+			}
 			if (!result.empty())
-				AnsiColorized(stream, highlight, {util::formatting::RED_BACKGROUND}) << ws << result;
+			{
+				AnsiColorized(stream, false, {util::formatting::RESET}) << ws;
+				AnsiColorized(stream, highlight, {util::formatting::RED_BACKGROUND}) << result;
+			}
 		}
 		else
 		{
 			if (m_calledNonExistingFunction)
 				_errorReporter.warning("The function \"" + m_call.signature + "\" is not known to the compiler.");
 
+			if (builtin)
+				_errorReporter.warning("The expectation \"" + builtin->signature + ": " + formatRawParameters(builtin->arguments.parameters) + "\" will be replaced with the actual value returned by the test.");
+
 			bytes output = m_rawBytes;
 			bool const isFailure = m_failure;
 			result = isFailure ?
diff --git a/test/libsolidity/util/TestFunctionCallTests.cpp b/test/libsolidity/util/TestFunctionCallTests.cpp

Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,11 @@ inline bool isIdentifierPart(char c)`
`45`	`45`	`return isIdentifierStart(c) \|\| isDecimalDigit(c);`
`46`	`46`	`}`
`47`	`47`
	`48`	`+inline bool isIdentifierPartWithDot(char c)`
	`49`	`+{`
	`50`	`+ return isIdentifierPart(c) \|\| c == '.';`
	`51`	`+}`
	`52`	`+`
`48`	`53`	`inline int hexValue(char c)`
`49`	`54`	`{`
`50`	`55`	`if (c >= '0' && c <= '9')`