Introduce universal compilation host to execution framework

libsolidity/interface/CompilerStack.cpp

@@ -1256,6 +1256,18 @@ ContractDefinition const& CompilerStack::contractDefinition(std::string const& _
 	return *contract(_contractName).contract;
 }
 
+std::vector<ContractDefinition const*> CompilerStack::contractDefinitions(
+	std::string const& _sourceName
+) const
+{
+	std::vector<ContractDefinition const*> contracts;
+	if (auto source = m_sources.find(_sourceName); source != m_sources.end())
+		for (auto const* contract: ASTNode::filteredNodes<ContractDefinition>(source->second.ast->nodes()))
+			contracts.emplace_back(contract);
+
+	return contracts;
+}
+
 size_t CompilerStack::functionEntryPoint(
 	std::string const& _contractName,
 	FunctionDefinition const& _function

libsolidity/interface/CompilerStack.h

@@ -307,6 +307,9 @@ class CompilerStack: public langutil::CharStreamProvider, public evmasm::Abstrac
 	/// does not exist.
 	ContractDefinition const& contractDefinition(std::string const& _contractName) const;
 
+	/// @returns a list of parsed contracts per source unit with the supplied name.
+	std::vector<ContractDefinition const*> contractDefinitions(std::string const& _sourceName) const;
+
 	/// @returns a list of unhandled queries to the SMT solver (has to be supplied in a second run
 	/// by calling @a addSMTLib2Response).
 	std::vector<std::string> const& unhandledSMTLib2Queries() const { return m_unhandledSMTLib2Queries; }

test/CMakeLists.txt

@@ -117,6 +117,12 @@ set(libsolidity_sources
 detect_stray_source_files("${libsolidity_sources}" "libsolidity/")
 
 set(libsolidity_util_sources
+    libsolidity/util/compiler/Compiler.h
+    libsolidity/util/compiler/Compiler.cpp
+    libsolidity/util/compiler/InternalCompiler.h
+    libsolidity/util/compiler/InternalCompiler.cpp
+    libsolidity/util/compiler/CompilerHost.h
+    libsolidity/util/compiler/CompilerHost.cpp
     libsolidity/util/BytesUtils.cpp
     libsolidity/util/BytesUtilsTests.cpp
     libsolidity/util/BytesUtils.h

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())
 	);
 }