Separate 'code' gas settings in semantic tests

cameel · cameel · commit 96233864437e · 2024-02-21T21:07:14.000+01:00
diff --git a/test/libsolidity/SemanticTest.cpp b/test/libsolidity/SemanticTest.cpp
@@ -569,6 +569,11 @@ bool SemanticTest::checkGasCostExpectation(TestFunctionCall& io_test, bool _comp
 		(_compileViaYul ? "ir"s : "legacy"s) +
 		(m_optimiserSettings == OptimiserSettings::full() ? "Optimized" : "");
 
+	soltestAssert(
+		io_test.call().expectations.gasUsed.count(setting) ==
+		io_test.call().expectations.gasUsedForCodeDeposit.count(setting)
+	);
+
 	// We don't check gas if enforce gas cost is not active
 	// or test is run with abi encoder v1 only
 	// or gas used less than threshold for enforcing feature
@@ -587,9 +592,12 @@ bool SemanticTest::checkGasCostExpectation(TestFunctionCall& io_test, bool _comp
 	solAssert(!m_runWithABIEncoderV1Only, "");
 
 	io_test.setGasCost(setting, m_gasUsed);
+	io_test.setCodeDepositGasCost(setting, m_gasUsedForCodeDeposit);
+
 	return
 		io_test.call().expectations.gasUsed.count(setting) > 0 &&
-		m_gasUsed == io_test.call().expectations.gasUsed.at(setting);
+		m_gasUsed == io_test.call().expectations.gasUsed.at(setting) &&
+		m_gasUsedForCodeDeposit == io_test.call().expectations.gasUsedForCodeDeposit.at(setting);
 }
 
 void SemanticTest::printSource(std::ostream& _stream, std::string const& _linePrefix, bool _formatted) const
diff --git a/test/libsolidity/util/SoltestTypes.h b/test/libsolidity/util/SoltestTypes.h
@@ -220,6 +220,11 @@ struct FunctionCallExpectations
 	/// bytecode (and therefore the cost), except for EVM version. E.g. IR codegen without
 	/// optimization legacy codegen with optimization.
 	std::map<std::string, u256> gasUsed;
+
+	/// The portion of @a gasUsed spent on code deposits of newly created contracts.
+	/// May exceed @a gasUsed in rare corner cases due to refunds.
+	/// Keys must always match @a gasUsedExcludingCode.
+	std::map<std::string, u256> gasUsedForCodeDeposit;
 };
 
 /**
diff --git a/test/libsolidity/util/TestFileParser.cpp b/test/libsolidity/util/TestFileParser.cpp
@@ -84,18 +84,31 @@ std::vector<solidity::frontend::test::FunctionCall> TestFileParser::parseFunctio
 							BOOST_THROW_EXCEPTION(TestParserError("Expected function call before gas usage filter."));
 
 						std::string runType = m_scanner.currentLiteral();
-						if (std::set<std::string>{"ir", "irOptimized", "legacy", "legacyOptimized"}.count(runType) > 0)
-						{
-							m_scanner.scanNextToken();
-							expect(Token::Colon);
-							if (calls.back().expectations.gasUsed.count(runType) > 0)
-								throw TestParserError("Gas usage expectation set multiple times.");
-							calls.back().expectations.gasUsed[runType] = u256(parseDecimalNumber());
-						}
-						else
+						if (std::set<std::string>{"ir", "irOptimized", "legacy", "legacyOptimized"}.count(runType) == 0)
 							BOOST_THROW_EXCEPTION(TestParserError(
 								"Expected \"ir\", \"irOptimized\", \"legacy\", or \"legacyOptimized\"."
 							));
+						m_scanner.scanNextToken();
+
+						bool isCodeDepositCost = false;
+						if (accept(Token::Identifier))
+						{
+							if (m_scanner.currentLiteral() != "code")
+								BOOST_THROW_EXCEPTION(TestParserError("Expected \"code\" or \":\"."));
+							isCodeDepositCost = true;
+							m_scanner.scanNextToken();
+						}
+
+						expect(Token::Colon);
+
+						std::map<std::string, u256>& gasExpectationMap = (isCodeDepositCost ?
+							calls.back().expectations.gasUsedForCodeDeposit :
+							calls.back().expectations.gasUsed
+						);
+						if (gasExpectationMap.count(runType) > 0)
+							throw TestParserError("Gas usage expectation set multiple times.");
+
+						gasExpectationMap[runType] = u256(parseDecimalNumber());
 					}
 					else
 					{
@@ -189,6 +202,17 @@ std::vector<solidity::frontend::test::FunctionCall> TestFileParser::parseFunctio
 			}
 		}
 	}
+
+	for (FunctionCall& call: calls)
+	{
+		// Ensure that each specified gas expectation has both components to simplify working with them.
+		for (auto const& [runType, gas]: call.expectations.gasUsedForCodeDeposit)
+			call.expectations.gasUsed.try_emplace({runType, 0});
+
+		for (auto const& [runType, gas]: call.expectations.gasUsed)
+			call.expectations.gasUsedForCodeDeposit.try_emplace({runType, 0});
+	}
+
 	return calls;
 }
 
diff --git a/test/libsolidity/util/TestFileParserTests.cpp b/test/libsolidity/util/TestFileParserTests.cpp
@@ -1079,6 +1079,11 @@ BOOST_AUTO_TEST_CASE(gas)
 		{"legacy", 5000},
 		{"legacyOptimized", 0},
 	}));
+	BOOST_TEST(calls[0].expectations.gasUsedForCodeDeposit == (std::map<std::string, u256>{
+		{"ir", 0},
+		{"legacy", 0},
+		{"legacyOptimized", 0},
+	}));
 }
 
 BOOST_AUTO_TEST_CASE(gas_before_call)
@@ -1109,6 +1114,103 @@ BOOST_AUTO_TEST_CASE(gas_duplicate_run_type)
 	)";
 	BOOST_REQUIRE_THROW(parse(source), TestParserError);
 }
+
+BOOST_AUTO_TEST_CASE(gas_with_code_deposit_cost)
+{
+	char const* source = R"(
+		// f() ->
+		// gas legacyOptimized code: 1
+		// gas ir: 13000
+		// gas irOptimized: 6666
+		// gas irOptimized code: 666
+		// gas legacy code: 0
+		// gas legacyOptimized: 2
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	BOOST_REQUIRE_EQUAL(calls[0].expectations.failure, false);
+	BOOST_TEST(calls[0].expectations.gasUsed == (std::map<std::string, u256>{
+		{"ir", 13000},
+		{"irOptimized", 6666},
+		{"legacy", 0},
+		{"legacyOptimized", 2},
+	}));
+	BOOST_TEST(calls[0].expectations.gasUsedForCodeDeposit == (std::map<std::string, u256>{
+		{"ir", 0},
+		{"irOptimized", 666},
+		{"legacy", 0},
+		{"legacyOptimized", 1},
+	}));
+}
+
+BOOST_AUTO_TEST_CASE(gas_with_code_deposit_cost_invalid_suffix)
+{
+	char const* source = R"(
+		// f() ->
+		// gas ir data: 3245
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(gas_with_code_deposit_cost_tokens_after_suffix)
+{
+	char const* source = R"(
+		// f() ->
+		// gas ir code code: 3245
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(gas_with_code_deposit_cost_double_code_gas)
+{
+	char const* source = R"(
+		// f() ->
+		// gas ir: 3245
+		// gas ir code: 1
+		// gas ir code: 1
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(gas_with_code_deposit_cost_negative_non_code_cost)
+{
+	// NOTE: This arrangement is unlikely but may still be possible due to refunds.
+	char const* source = R"(
+		// f() ->
+		// gas ir: 10
+		// gas ir code: 20
+	)";
+	auto const calls = parse(source);
+	BOOST_REQUIRE_EQUAL(calls.size(), 1);
+	BOOST_REQUIRE_EQUAL(calls[0].expectations.failure, false);
+	BOOST_TEST(calls[0].expectations.gasUsed == (std::map<std::string, u256>{
+		{"ir", 10},
+	}));
+	BOOST_TEST(calls[0].expectations.gasUsedForCodeDeposit == (std::map<std::string, u256>{
+		{"ir", 20},
+	}));
+}
+
+BOOST_AUTO_TEST_CASE(gas_with_code_deposit_cost_negative_total_cost)
+{
+	char const* source = R"(
+		// f() ->
+		// gas ir: -10
+		// gas ir code: 20
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
+BOOST_AUTO_TEST_CASE(gas_with_code_deposit_cost_negative_code_cost)
+{
+	char const* source = R"(
+		// f() ->
+		// gas ir: 20
+		// gas ir code: -10
+	)";
+	BOOST_REQUIRE_THROW(parse(source), TestParserError);
+}
+
 BOOST_AUTO_TEST_SUITE_END()
 
 }
diff --git a/test/libsolidity/util/TestFunctionCall.cpp b/test/libsolidity/util/TestFunctionCall.cpp
@@ -22,6 +22,9 @@
 #include <boost/algorithm/string.hpp>
 
 #include <fmt/format.h>
+#include <range/v3/view/map.hpp>
+#include <range/v3/view/set_algorithm.hpp>
+
 #include <optional>
 #include <stdexcept>
 #include <string>
@@ -371,18 +374,37 @@ std::string TestFunctionCall::formatGasExpectations(
 	bool _showDifference
 ) const
 {
+	using ranges::views::keys;
+	using ranges::views::set_symmetric_difference;
+
+	soltestAssert(set_symmetric_difference(m_codeDepositGasCosts | keys, m_gasCosts | keys).empty());
+	soltestAssert(set_symmetric_difference(m_call.expectations.gasUsedForCodeDeposit | keys, m_call.expectations.gasUsed | keys).empty());
+
 	std::stringstream os;
 	for (auto const& [runType, gasUsed]: (_useActualCost ? m_gasCosts : m_call.expectations.gasUsed))
 	{
 		soltestAssert(runType != "");
 
+		u256 gasUsedForCodeDeposit = (_useActualCost ? m_codeDepositGasCosts : m_call.expectations.gasUsedForCodeDeposit).at(runType);
+
 		os << std::endl << _linePrefix << "// gas " << runType << ": " << gasUsed.str();
 		std::string gasDiff = formatGasDiff(
 			gasOrNullopt(m_gasCosts, runType),
 			gasOrNullopt(m_call.expectations.gasUsed, runType)
 		);
 		if (_showDifference && !gasDiff.empty() && _useActualCost)
 			os << " [" << gasDiff << "]";
+
+		if (gasUsedForCodeDeposit != 0)
+		{
+			os << std::endl << _linePrefix << "// gas " << runType << " code: " << gasUsedForCodeDeposit.str();
+			std::string codeGasDiff = formatGasDiff(
+				gasOrNullopt(m_codeDepositGasCosts, runType),
+				gasOrNullopt(m_call.expectations.gasUsedForCodeDeposit, runType)
+			);
+			if (_showDifference && !codeGasDiff.empty() && _useActualCost)
+				os << " [" << codeGasDiff << "]";
+			}
 	}
 	return os.str();
 }
diff --git a/test/libsolidity/util/TestFunctionCall.h b/test/libsolidity/util/TestFunctionCall.h
@@ -51,7 +51,11 @@ class TestFunctionCall
 		ExpectedValuesActualGas
 	};
 
-	TestFunctionCall(FunctionCall _call): m_call(std::move(_call)), m_gasCosts(m_call.expectations.gasUsed) {}
+	TestFunctionCall(FunctionCall _call):
+		m_call(std::move(_call)),
+		m_gasCosts(m_call.expectations.gasUsed),
+		m_codeDepositGasCosts(m_call.expectations.gasUsedForCodeDeposit)
+	{}
 
 	/// Formats this function call test and applies the format that was detected during parsing.
 	/// _renderMode determines the source of values to be inserted into the updated test expectations.
@@ -94,6 +98,7 @@ class TestFunctionCall
 	void setFailure(const bool _failure) { m_failure = _failure; }
 	void setRawBytes(const bytes _rawBytes) { m_rawBytes = _rawBytes; }
 	void setGasCost(std::string const& _runType, u256 const& _gasCost) { m_gasCosts[_runType] = _gasCost; }
+	void setCodeDepositGasCost(std::string const& _runType, u256 const& _gasCost) { m_codeDepositGasCosts[_runType] = _gasCost; }
 	void setContractABI(Json::Value _contractABI) { m_contractABI = std::move(_contractABI); }
 	void setSideEffects(std::vector<std::string> _sideEffects) { m_call.actualSideEffects = _sideEffects; }
 
@@ -143,6 +148,8 @@ class TestFunctionCall
 	bytes m_rawBytes = bytes{};
 	/// Actual gas costs
 	std::map<std::string, u256> m_gasCosts;
+	/// Actual code deposit gas costs
+	std::map<std::string, u256> m_codeDepositGasCosts;
 	/// Transaction status of the actual call. False in case of a REVERT or any other failure.
 	bool m_failure = true;
 	/// JSON object which holds the contract ABI and that is used to set the output formatting
diff --git a/test/libsolidity/util/TestFunctionCallTests.cpp b/test/libsolidity/util/TestFunctionCallTests.cpp
