Test: Use new universal compiler host

Author: erak

test/ExecutionFramework.h

@@ -65,7 +65,7 @@ class ExecutionFramework
 		std::string const& _contractName = "",
 		bytes const& _arguments = {},
 		std::map<std::string, util::h160> const& _libraryAddresses = {},
-		std::optional<std::string> const& _sourceName = std::nullopt
+		std::optional<std::string> const& _mainSourceName = std::nullopt
 	) = 0;
 
 	bytes const& compileAndRun(

test/libsolidity/GasCosts.cpp

@@ -38,7 +38,8 @@ namespace solidity::frontend::test
 #define CHECK_DEPLOY_GAS(_gasNoOpt, _gasOpt, _evmVersion) \
 	do \
 	{ \
-		u256 metaCost = GasMeter::dataGas(m_compiler.cborMetadata(m_compiler.lastContractName()), true, _evmVersion); \
+		auto compiledContract = m_compiler.output().contract().value(); \
+		u256 metaCost = GasMeter::dataGas(compiledContract.cborMetadata, true, _evmVersion); \
 		u256 gasOpt{_gasOpt}; \
 		u256 gasNoOpt{_gasNoOpt}; \
 		u256 gas = m_optimiserSettings == OptimiserSettings::minimal() ? gasNoOpt : gasOpt; \
@@ -90,7 +91,7 @@ BOOST_AUTO_TEST_CASE(string_storage)
 			}
 		}
 	)";
-	m_compiler.setMetadataFormat(CompilerStack::MetadataFormat::NoMetadata);
+
 	m_appendCBORMetadata = false;
 	compileAndRun(sourceCode);
 
@@ -202,8 +203,9 @@ BOOST_AUTO_TEST_CASE(single_callvaluecheck)
 		}
 	)";
 	compileAndRun(sourceCode);
-	size_t bytecodeSizeNonpayable = m_compiler.object("Nonpayable").bytecode.size();
-	size_t bytecodeSizePayable = m_compiler.object("Payable").bytecode.size();
+	auto compilerOutput = m_compiler.output();
+	size_t bytecodeSizeNonpayable = compilerOutput.contract("Nonpayable").value().object.size();
+	size_t bytecodeSizePayable = compilerOutput.contract("Payable").value().object.size();
 
 	auto evmVersion = solidity::test::CommonOptions::get().evmVersion();
 	if (evmVersion < EVMVersion::shanghai())

test/libsolidity/GasMeter.cpp

@@ -22,6 +22,7 @@
  */
 
 #include <test/libsolidity/SolidityExecutionFramework.h>
+#include <test/libsolidity/util/SoltestErrors.h>
 #include <libevmasm/GasMeter.h>
 #include <libevmasm/KnownState.h>
 #include <libevmasm/PathGasMeter.h>
@@ -43,24 +44,40 @@ class GasMeterTestFramework: public SolidityExecutionFramework
 	void compile(std::string const& _sourceCode)
 	{
 		m_compiler.reset();
-		m_compiler.setSources({{"", "pragma solidity >=0.0;\n"
-				"// SPDX-License-Identifier: GPL-3.0\n" + _sourceCode}});
-		m_compiler.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
-		m_compiler.setEVMVersion(m_evmVersion);
-		BOOST_REQUIRE_MESSAGE(m_compiler.compile(), "Compiling contract failed");
+		m_compilerInput = CompilerInput{};
+
+		m_compilerInput.sourceCode = {{"", "pragma solidity >=0.0;\n"
+				"// SPDX-License-Identifier: GPL-3.0\n" + _sourceCode}};
+		m_compilerInput.optimise = solidity::test::CommonOptions::get().optimize;
+		m_compilerInput.evmVersion = std::make_optional(m_evmVersion);
+
+		m_compiler.compile(m_compilerInput);
+
+		BOOST_REQUIRE_MESSAGE(m_compiler.output().success(), "Compiling contract failed");
 	}
 
 	void testCreationTimeGas(std::string const& _sourceCode, u256 const& _tolerance = u256(0))
 	{
 		compileAndRun(_sourceCode);
+
 		auto state = std::make_shared<KnownState>();
-		PathGasMeter meter(*m_compiler.assemblyItems(m_compiler.lastContractName()), solidity::test::CommonOptions::get().evmVersion());
+		auto output = m_compiler.output();
+		auto contract = output.contract();
+
+		soltestAssert(contract.has_value());
+		soltestAssert(contract.value().assemblyItems.has_value());
+
+		auto object = contract.value().object;
+		auto runtimeObject = contract.value().runtimeObject;
+		auto assemblyItems = contract.value().assemblyItems.value();
+
+		PathGasMeter meter(assemblyItems, solidity::test::CommonOptions::get().evmVersion());
 		GasMeter::GasConsumption gas = meter.estimateMax(0, state);
-		u256 bytecodeSize(m_compiler.runtimeObject(m_compiler.lastContractName()).bytecode.size());
+		u256 bytecodeSize(runtimeObject.size());
 		// costs for deployment
 		gas += bytecodeSize * GasCosts::createDataGas;
 		// costs for transaction
-		gas += gasForTransaction(m_compiler.object(m_compiler.lastContractName()).bytecode, true);
+		gas += gasForTransaction(object, true);
 
 		BOOST_REQUIRE(!gas.isInfinite);
 		BOOST_CHECK_LE(m_gasUsed, gas.value);
@@ -71,6 +88,14 @@ class GasMeterTestFramework: public SolidityExecutionFramework
 	/// against the actual gas usage computed by the VM on the given set of argument variants.
 	void testRunTimeGas(std::string const& _sig, std::vector<bytes> _argumentVariants, u256 const& _tolerance = u256(0))
 	{
+		auto output = m_compiler.output();
+		auto contract = output.contract();
+
+		soltestAssert(contract.has_value());
+		soltestAssert(contract.value().runtimeAssemblyItems.has_value());
+
+		auto runtimeAssemblyItems = contract.value().runtimeAssemblyItems.value();
+
 		u256 gasUsed = 0;
 		GasMeter::GasConsumption gas;
 		util::FixedHash<4> hash = util::selectorFromSignatureH32(_sig);
@@ -83,7 +108,7 @@ class GasMeterTestFramework: public SolidityExecutionFramework
 		}
 
 		gas += GasEstimator(solidity::test::CommonOptions::get().evmVersion()).functionalEstimation(
-			*m_compiler.runtimeAssemblyItems(m_compiler.lastContractName()),
+			runtimeAssemblyItems,
 			_sig
 		);
 		BOOST_REQUIRE(!gas.isInfinite);

test/libsolidity/SemanticTest.cpp

@@ -118,8 +118,8 @@ SemanticTest::SemanticTest(
 
 	if (m_enforceGasCost)
 	{
-		m_compiler.setMetadataFormat(CompilerStack::MetadataFormat::NoMetadata);
-		m_compiler.setMetadataHash(CompilerStack::MetadataHash::None);
+		m_compilerInput.metadataFormat = MetadataFormat::NoMetadata;
+		m_compilerInput.metadataHash = MetadataHash::None;
 	}
 }
 
@@ -231,13 +231,15 @@ std::string SemanticTest::formatEventParameter(std::optional<AnnotatedEventSigna
 
 std::vector<std::string> SemanticTest::eventSideEffectHook(FunctionCall const&) const
 {
+	auto output = m_compiler.output();
+
 	std::vector<std::string> sideEffects;
 	std::vector<LogRecord> recordedLogs = ExecutionFramework::recordedLogs();
 	for (LogRecord const& log: recordedLogs)
 	{
 		std::optional<AnnotatedEventSignature> eventSignature;
 		if (!log.topics.empty())
-			eventSignature = matchEvent(log.topics[0]);
+			eventSignature = output.matchEvent(log.topics[0]);
 		std::stringstream sideEffect;
 		sideEffect << "emit ";
 		if (eventSignature.has_value())
@@ -273,31 +275,6 @@ std::vector<std::string> SemanticTest::eventSideEffectHook(FunctionCall const&)
 	return sideEffects;
 }
 
-std::optional<AnnotatedEventSignature> SemanticTest::matchEvent(util::h256 const& hash) const
-{
-	std::optional<AnnotatedEventSignature> result;
-	for (std::string& contractName: m_compiler.contractNames())
-	{
-		ContractDefinition const& contract = m_compiler.contractDefinition(contractName);
-		for (EventDefinition const* event: contract.events() + contract.usedInterfaceEvents())
-		{
-			FunctionTypePointer eventFunctionType = event->functionType(true);
-			if (!event->isAnonymous() && keccak256(eventFunctionType->externalSignature()) == hash)
-			{
-				AnnotatedEventSignature eventInfo;
-				eventInfo.signature = eventFunctionType->externalSignature();
-				for (auto const& param: event->parameters())
-					if (param->isIndexed())
-						eventInfo.indexedTypes.emplace_back(param->type()->toString(true));
-					else
-						eventInfo.nonIndexedTypes.emplace_back(param->type()->toString(true));
-				result = eventInfo;
-			}
-		}
-	}
-	return result;
-}
-
 frontend::OptimiserSettings SemanticTest::optimizerSettingsFor(RequiresYulOptimizer _requiresYulOptimizer)
 {
 	switch (_requiresYulOptimizer)
@@ -383,13 +360,14 @@ TestCase::TestResult SemanticTest::runTest(
 		}
 		else if (test.call().kind == FunctionCall::Kind::Library)
 		{
+			std::string name = test.call().libraryFile + ":" + test.call().signature;
 			soltestAssert(
-				deploy(test.call().signature, 0, {}, libraries) && m_transactionSuccessful,
+				deploy(name, 0, {}, libraries) && m_transactionSuccessful,
 				"Failed to deploy library " + test.call().signature);
 			// For convenience, in semantic tests we assume that an unqualified name like `L` is equivalent to one
 			// with an empty source unit name (`:L`). This is fine because the compiler never uses unqualified
 			// names in the Yul code it produces and does not allow `linkersymbol()` at all in inline assembly.
-			libraries[test.call().libraryFile + ":" + test.call().signature] = m_contractAddress;
+			libraries[name] = m_contractAddress;
 			continue;
 		}
 		else
@@ -416,7 +394,14 @@ TestCase::TestResult SemanticTest::runTest(
 		}
 		else
 		{
+			ContractName contractName{m_sources.mainSourceFile, ""};
+
+			auto compiledContract = m_compiler.output().contract(contractName);
+			solAssert(compiledContract.has_value());
+
+			CompiledContract contract = compiledContract.value();
 			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)
@@ -432,9 +417,10 @@ TestCase::TestResult SemanticTest::runTest(
 			}
 			else
 			{
+				soltestAssert(contract.interfaceSymbols.has_value());
 				soltestAssert(
 					m_allowNonExistingFunctions ||
-					m_compiler.interfaceSymbols(m_compiler.lastContractName(m_sources.mainSourceFile))["methods"].contains(test.call().signature),
+					contract.interfaceSymbols.value()["methods"].contains(test.call().signature),
 					"The function " + test.call().signature + " is not known to the compiler"
 				);
 
@@ -462,7 +448,8 @@ TestCase::TestResult SemanticTest::runTest(
 			test.setFailure(!m_transactionSuccessful);
 			test.setRawBytes(std::move(output));
 			if (test.call().kind != FunctionCall::Kind::LowLevel)
-				test.setContractABI(m_compiler.contractABI(m_compiler.lastContractName(m_sources.mainSourceFile)));
+				if (contract.contractABI.has_value())
+					test.setContractABI(contract.contractABI.value());
 		}
 
 		std::vector<std::string> effects;

test/libsolidity/SemanticTest.h

@@ -30,13 +30,6 @@
 namespace solidity::frontend::test
 {
 
-struct AnnotatedEventSignature
-{
-	std::string signature;
-	std::vector<std::string> indexedTypes;
-	std::vector<std::string> nonIndexedTypes;
-};
-
 enum class RequiresYulOptimizer
 {
 	False,

test/libsolidity/SolidityEndToEndTest.cpp

@@ -105,7 +105,7 @@ BOOST_AUTO_TEST_CASE(creation_code_optimizer)
 		}
 	)";
 
-	m_metadataHash = CompilerStack::MetadataHash::None;
+	m_metadataHash = MetadataHash::None;
 	ALSO_VIA_YUL({
 		bytes bytecodeC = compileContract(codeC);
 		reset();
@@ -2815,9 +2815,17 @@ BOOST_AUTO_TEST_CASE(include_creation_bytecode_only_once)
 		}
 	)";
 	compileAndRun(sourceCode);
+
+	auto output = m_compiler.output();
+	auto contractDouble = output.contract("Double");
+	auto contractSingle = output.contract("Single");
+
+	solAssert(contractDouble);
+	solAssert(contractSingle);
+
 	BOOST_CHECK_LE(
-		double(m_compiler.object("Double").bytecode.size()),
-		1.2 * double(m_compiler.object("Single").bytecode.size())
+		double(contractDouble.value().object.size()),
+		1.2 * double(contractSingle.value().object.size())
 	);
 }
 

test/libsolidity/SolidityExecutionFramework.cpp

@@ -23,6 +23,7 @@
 
 #include <test/libsolidity/SolidityExecutionFramework.h>
 #include <test/libsolidity/util/Common.h>
+#include <test/libsolidity/util/SoltestErrors.h>
 
 #include <liblangutil/DebugInfoSelection.h>
 #include <libyul/Exceptions.h>
@@ -42,49 +43,63 @@ using namespace solidity::test;
 
 bytes SolidityExecutionFramework::multiSourceCompileContract(
 	std::map<std::string, std::string> const& _sourceCode,
-	std::optional<std::string> const& _mainSourceName,
 	std::string const& _contractName,
-	std::map<std::string, Address> const& _libraryAddresses
+	std::map<std::string, Address> const& _libraryAddresses,
+	std::optional<std::string> const& _mainSourceName
 )
 {
 	if (_mainSourceName.has_value())
 		solAssert(_sourceCode.find(_mainSourceName.value()) != _sourceCode.end(), "");
 
-	m_compiler.reset();
-	m_compiler.setSources(withPreamble(
+	m_compilerInput = CompilerInput{};
+	m_compilerInput.sourceCode = withPreamble(
 		_sourceCode,
 		solidity::test::CommonOptions::get().useABIEncoderV1 // _addAbicoderV1Pragma
-	));
-	m_compiler.setLibraries(_libraryAddresses);
-	m_compiler.setRevertStringBehaviour(m_revertStrings);
-	m_compiler.setEVMVersion(m_evmVersion);
-	m_compiler.setEOFVersion(m_eofVersion);
-	m_compiler.setOptimiserSettings(m_optimiserSettings);
-	m_compiler.setViaIR(m_compileViaYul);
-	m_compiler.setRevertStringBehaviour(m_revertStrings);
+	);
+	m_compilerInput.libraryAddresses = _libraryAddresses;
+	m_compilerInput.evmVersion = std::make_optional(m_evmVersion);
+	m_compilerInput.eofVersion = m_eofVersion;
+	m_compilerInput.optimiserSettings = std::make_optional(m_optimiserSettings);
+	m_compilerInput.revertStrings = std::make_optional(m_revertStrings);
+	m_compilerInput.metadataHash = std::make_optional(m_metadataHash);
+	m_compilerInput.viaIR = std::make_optional(m_compileViaYul);
 	if (!m_appendCBORMetadata) {
-		m_compiler.setMetadataFormat(CompilerStack::MetadataFormat::NoMetadata);
+		m_compilerInput.metadataFormat = std::make_optional(MetadataFormat::NoMetadata);
 	}
-	m_compiler.setMetadataHash(m_metadataHash);
 
-	if (!m_compiler.compile())
+	CompilerOutput const& output = m_compiler.compile(m_compilerInput);
+	if (!output.success())
 	{
 		// The testing framework expects an exception for
 		// "unimplemented" yul IR generation.
 		if (m_compileViaYul)
-			for (auto const& error: m_compiler.errors())
-				if (error->type() == langutil::Error::Type::CodeGenerationError)
-					BOOST_THROW_EXCEPTION(*error);
-		langutil::SourceReferenceFormatter{std::cerr, m_compiler, true, false}
-			.printErrorInformation(m_compiler.errors());
+		{
+			auto error = output.findError(langutil::Error::Type::CodeGenerationError);
+			if (error.has_value())
+				BOOST_THROW_EXCEPTION(error.value());
+		}
+		std::cout << output.errorInformation() << std::endl;
 		BOOST_ERROR("Compiling contract failed");
 	}
-	std::string contractName(_contractName.empty() ? m_compiler.lastContractName(_mainSourceName) : _contractName);
-	evmasm::LinkerObject obj = m_compiler.object(contractName);
-	BOOST_REQUIRE(obj.linkReferences.empty());
+
+	// Construct `ContractName` with the contract name given, and use `_mainSourceName`
+	// if the contract's name source prefix is empty.
+	ContractName name{_contractName};
+	ContractName lookupName = name.source().empty() ?
+		ContractName{_mainSourceName.value_or(""), name.contract()} :
+		name;
+
+	auto contract = output.contract(lookupName);
+	soltestAssert(contract.has_value());
+	soltestAssert(!contract.value().hasUnlinkedReferences);
+
 	if (m_showMetadata)
-		std::cout << "metadata: " << m_compiler.metadata(contractName) << std::endl;
-	return obj.bytecode;
+	{
+		auto metadata = contract.value().metadata.value_or("");
+		std::cout << "metadata: " << metadata << std::endl;
+	}
+
+	return contract.value().object;
 }
 
 bytes SolidityExecutionFramework::compileContract(
@@ -95,8 +110,8 @@ bytes SolidityExecutionFramework::compileContract(
 {
 	return multiSourceCompileContract(
 		{{"", _sourceCode}},
-		std::nullopt,
 		_contractName,
-		_libraryAddresses
+		_libraryAddresses,
+		std::nullopt
 	);
 }