Skip to content

Commit eb1a20d

Browse files
erakerak
committed
Test: Use new universal compiler host
1 parent 9467e71 commit eb1a20d

7 files changed

+102
-78
lines changed

Diff for: ‎test/libsolidity/GasCosts.cpp

+6-4
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,8 @@ namespace solidity::frontend::test
3838
#define CHECK_DEPLOY_GAS(_gasNoOpt, _gasOpt, _evmVersion) \
3939
do \
4040
{ \
41-
u256 metaCost = GasMeter::dataGas(m_compiler.cborMetadata(m_compiler.lastContractName()), true, _evmVersion); \
41+
auto compiledContract = m_compiler.output().contract().value(); \
42+
u256 metaCost = GasMeter::dataGas(compiledContract.cborMetadata, true, _evmVersion); \
4243
u256 gasOpt{_gasOpt}; \
4344
u256 gasNoOpt{_gasNoOpt}; \
4445
u256 gas = m_optimiserSettings == OptimiserSettings::minimal() ? gasNoOpt : gasOpt; \
@@ -90,7 +91,7 @@ BOOST_AUTO_TEST_CASE(string_storage)
9091
}
9192
}
9293
)";
93-
m_compiler.setMetadataFormat(CompilerStack::MetadataFormat::NoMetadata);
94+
9495
m_appendCBORMetadata = false;
9596
compileAndRun(sourceCode);
9697

@@ -202,8 +203,9 @@ BOOST_AUTO_TEST_CASE(single_callvaluecheck)
202203
}
203204
)";
204205
compileAndRun(sourceCode);
205-
size_t bytecodeSizeNonpayable = m_compiler.object("Nonpayable").bytecode.size();
206-
size_t bytecodeSizePayable = m_compiler.object("Payable").bytecode.size();
206+
auto compilerOutput = m_compiler.output();
207+
size_t bytecodeSizeNonpayable = compilerOutput.contract("Nonpayable").value().object.size();
208+
size_t bytecodeSizePayable = compilerOutput.contract("Payable").value().object.size();
207209

208210
auto evmVersion = solidity::test::CommonOptions::get().evmVersion();
209211
if (evmVersion < EVMVersion::shanghai())

Diff for: ‎test/libsolidity/GasMeter.cpp

+34-9
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@
2222
*/
2323

2424
#include <test/libsolidity/SolidityExecutionFramework.h>
25+
#include <test/libsolidity/util/SoltestErrors.h>
2526
#include <libevmasm/GasMeter.h>
2627
#include <libevmasm/KnownState.h>
2728
#include <libevmasm/PathGasMeter.h>
@@ -43,24 +44,40 @@ class GasMeterTestFramework: public SolidityExecutionFramework
4344
void compile(std::string const& _sourceCode)
4445
{
4546
m_compiler.reset();
46-
m_compiler.setSources({{"", "pragma solidity >=0.0;\n"
47-
"// SPDX-License-Identifier: GPL-3.0\n" + _sourceCode}});
48-
m_compiler.setOptimiserSettings(solidity::test::CommonOptions::get().optimize);
49-
m_compiler.setEVMVersion(m_evmVersion);
50-
BOOST_REQUIRE_MESSAGE(m_compiler.compile(), "Compiling contract failed");
47+
m_compilerInput = CompilerInput{};
48+
49+
m_compilerInput.sourceCode = {{"", "pragma solidity >=0.0;\n"
50+
"// SPDX-License-Identifier: GPL-3.0\n" + _sourceCode}};
51+
m_compilerInput.optimise = solidity::test::CommonOptions::get().optimize;
52+
m_compilerInput.evmVersion = std::make_optional(m_evmVersion);
53+
54+
m_compiler.compile(m_compilerInput);
55+
56+
BOOST_REQUIRE_MESSAGE(m_compiler.output().success(), "Compiling contract failed");
5157
}
5258

5359
void testCreationTimeGas(std::string const& _sourceCode, u256 const& _tolerance = u256(0))
5460
{
5561
compileAndRun(_sourceCode);
62+
5663
auto state = std::make_shared<KnownState>();
57-
PathGasMeter meter(*m_compiler.assemblyItems(m_compiler.lastContractName()), solidity::test::CommonOptions::get().evmVersion());
64+
auto output = m_compiler.output();
65+
auto contract = output.contract();
66+
67+
soltestAssert(contract.has_value());
68+
soltestAssert(contract.value().assemblyItems.has_value());
69+
70+
auto object = contract.value().object;
71+
auto runtimeObject = contract.value().runtimeObject;
72+
auto assemblyItems = contract.value().assemblyItems.value();
73+
74+
PathGasMeter meter(assemblyItems, solidity::test::CommonOptions::get().evmVersion());
5875
GasMeter::GasConsumption gas = meter.estimateMax(0, state);
59-
u256 bytecodeSize(m_compiler.runtimeObject(m_compiler.lastContractName()).bytecode.size());
76+
u256 bytecodeSize(runtimeObject.size());
6077
// costs for deployment
6178
gas += bytecodeSize * GasCosts::createDataGas;
6279
// costs for transaction
63-
gas += gasForTransaction(m_compiler.object(m_compiler.lastContractName()).bytecode, true);
80+
gas += gasForTransaction(object, true);
6481

6582
BOOST_REQUIRE(!gas.isInfinite);
6683
BOOST_CHECK_LE(m_gasUsed, gas.value);
@@ -71,6 +88,14 @@ class GasMeterTestFramework: public SolidityExecutionFramework
7188
/// against the actual gas usage computed by the VM on the given set of argument variants.
7289
void testRunTimeGas(std::string const& _sig, std::vector<bytes> _argumentVariants, u256 const& _tolerance = u256(0))
7390
{
91+
auto output = m_compiler.output();
92+
auto contract = output.contract();
93+
94+
soltestAssert(contract.has_value());
95+
soltestAssert(contract.value().runtimeAssemblyItems.has_value());
96+
97+
auto runtimeAssemblyItems = contract.value().runtimeAssemblyItems.value();
98+
7499
u256 gasUsed = 0;
75100
GasMeter::GasConsumption gas;
76101
util::FixedHash<4> hash = util::selectorFromSignatureH32(_sig);
@@ -83,7 +108,7 @@ class GasMeterTestFramework: public SolidityExecutionFramework
83108
}
84109

85110
gas += GasEstimator(solidity::test::CommonOptions::get().evmVersion()).functionalEstimation(
86-
*m_compiler.runtimeAssemblyItems(m_compiler.lastContractName()),
111+
runtimeAssemblyItems,
87112
_sig
88113
);
89114
BOOST_REQUIRE(!gas.isInfinite);

Diff for: ‎test/libsolidity/SemanticTest.cpp

+10-30
Original file line numberDiff line numberDiff line change
@@ -118,8 +118,8 @@ SemanticTest::SemanticTest(
118118

119119
if (m_enforceGasCost)
120120
{
121-
m_compiler.setMetadataFormat(CompilerStack::MetadataFormat::NoMetadata);
122-
m_compiler.setMetadataHash(CompilerStack::MetadataHash::None);
121+
m_compilerInput.metadataFormat = MetadataFormat::NoMetadata;
122+
m_compilerInput.metadataHash = MetadataHash::None;
123123
}
124124
}
125125

@@ -231,13 +231,15 @@ std::string SemanticTest::formatEventParameter(std::optional<AnnotatedEventSigna
231231

232232
std::vector<std::string> SemanticTest::eventSideEffectHook(FunctionCall const&) const
233233
{
234+
auto output = m_compiler.output();
235+
234236
std::vector<std::string> sideEffects;
235237
std::vector<LogRecord> recordedLogs = ExecutionFramework::recordedLogs();
236238
for (LogRecord const& log: recordedLogs)
237239
{
238240
std::optional<AnnotatedEventSignature> eventSignature;
239241
if (!log.topics.empty())
240-
eventSignature = matchEvent(log.topics[0]);
242+
eventSignature = output.matchEvent(log.topics[0]);
241243
std::stringstream sideEffect;
242244
sideEffect << "emit ";
243245
if (eventSignature.has_value())
@@ -273,31 +275,6 @@ std::vector<std::string> SemanticTest::eventSideEffectHook(FunctionCall const&)
273275
return sideEffects;
274276
}
275277

276-
std::optional<AnnotatedEventSignature> SemanticTest::matchEvent(util::h256 const& hash) const
277-
{
278-
std::optional<AnnotatedEventSignature> result;
279-
for (std::string& contractName: m_compiler.contractNames())
280-
{
281-
ContractDefinition const& contract = m_compiler.contractDefinition(contractName);
282-
for (EventDefinition const* event: contract.events() + contract.usedInterfaceEvents())
283-
{
284-
FunctionTypePointer eventFunctionType = event->functionType(true);
285-
if (!event->isAnonymous() && keccak256(eventFunctionType->externalSignature()) == hash)
286-
{
287-
AnnotatedEventSignature eventInfo;
288-
eventInfo.signature = eventFunctionType->externalSignature();
289-
for (auto const& param: event->parameters())
290-
if (param->isIndexed())
291-
eventInfo.indexedTypes.emplace_back(param->type()->toString(true));
292-
else
293-
eventInfo.nonIndexedTypes.emplace_back(param->type()->toString(true));
294-
result = eventInfo;
295-
}
296-
}
297-
}
298-
return result;
299-
}
300-
301278
frontend::OptimiserSettings SemanticTest::optimizerSettingsFor(RequiresYulOptimizer _requiresYulOptimizer)
302279
{
303280
switch (_requiresYulOptimizer)
@@ -416,6 +393,9 @@ TestCase::TestResult SemanticTest::runTest(
416393
}
417394
else
418395
{
396+
auto compiledContract = m_compiler.output().contract(std::make_optional(m_sources.mainSourceFile), std::nullopt);
397+
solAssert(compiledContract.has_value());
398+
419399
bytes output;
420400
if (test.call().kind == FunctionCall::Kind::LowLevel)
421401
output = callLowLevel(test.call().arguments.rawBytes(), test.call().value.value);
@@ -434,7 +414,7 @@ TestCase::TestResult SemanticTest::runTest(
434414
{
435415
soltestAssert(
436416
m_allowNonExistingFunctions ||
437-
m_compiler.interfaceSymbols(m_compiler.lastContractName(m_sources.mainSourceFile))["methods"].contains(test.call().signature),
417+
compiledContract.value().interfaceSymbols["methods"].contains(test.call().signature),
438418
"The function " + test.call().signature + " is not known to the compiler"
439419
);
440420

@@ -462,7 +442,7 @@ TestCase::TestResult SemanticTest::runTest(
462442
test.setFailure(!m_transactionSuccessful);
463443
test.setRawBytes(std::move(output));
464444
if (test.call().kind != FunctionCall::Kind::LowLevel)
465-
test.setContractABI(m_compiler.contractABI(m_compiler.lastContractName(m_sources.mainSourceFile)));
445+
test.setContractABI(compiledContract.value().contractABI);
466446
}
467447

468448
std::vector<std::string> effects;

Diff for: ‎test/libsolidity/SemanticTest.h

-7
Original file line numberDiff line numberDiff line change
@@ -30,13 +30,6 @@
3030
namespace solidity::frontend::test
3131
{
3232

33-
struct AnnotatedEventSignature
34-
{
35-
std::string signature;
36-
std::vector<std::string> indexedTypes;
37-
std::vector<std::string> nonIndexedTypes;
38-
};
39-
4033
enum class RequiresYulOptimizer
4134
{
4235
False,

Diff for: ‎test/libsolidity/SolidityEndToEndTest.cpp

+11-3
Original file line numberDiff line numberDiff line change
@@ -105,7 +105,7 @@ BOOST_AUTO_TEST_CASE(creation_code_optimizer)
105105
}
106106
)";
107107

108-
m_metadataHash = CompilerStack::MetadataHash::None;
108+
m_metadataHash = MetadataHash::None;
109109
ALSO_VIA_YUL({
110110
bytes bytecodeC = compileContract(codeC);
111111
reset();
@@ -2815,9 +2815,17 @@ BOOST_AUTO_TEST_CASE(include_creation_bytecode_only_once)
28152815
}
28162816
)";
28172817
compileAndRun(sourceCode);
2818+
2819+
auto output = m_compiler.output();
2820+
auto contractDouble = output.contract(std::nullopt, "Double");
2821+
auto contractSingle = output.contract(std::nullopt, "Single");
2822+
2823+
solAssert(contractDouble);
2824+
solAssert(contractSingle);
2825+
28182826
BOOST_CHECK_LE(
2819-
double(m_compiler.object("Double").bytecode.size()),
2820-
1.2 * double(m_compiler.object("Single").bytecode.size())
2827+
double(contractDouble.value().object.size()),
2828+
1.2 * double(contractSingle.value().object.size())
28212829
);
28222830
}
28232831

Diff for: ‎test/libsolidity/SolidityExecutionFramework.cpp

+35-23
Original file line numberDiff line numberDiff line change
@@ -23,6 +23,7 @@
2323

2424
#include <test/libsolidity/SolidityExecutionFramework.h>
2525
#include <test/libsolidity/util/Common.h>
26+
#include <test/libsolidity/util/SoltestErrors.h>
2627

2728
#include <liblangutil/DebugInfoSelection.h>
2829
#include <libyul/Exceptions.h>
@@ -50,41 +51,52 @@ bytes SolidityExecutionFramework::multiSourceCompileContract(
5051
if (_mainSourceName.has_value())
5152
solAssert(_sourceCode.find(_mainSourceName.value()) != _sourceCode.end(), "");
5253

53-
m_compiler.reset();
54-
m_compiler.setSources(withPreamble(
54+
m_compilerInput = CompilerInput{};
55+
m_compilerInput.sourceCode = withPreamble(
5556
_sourceCode,
5657
solidity::test::CommonOptions::get().useABIEncoderV1 // _addAbicoderV1Pragma
57-
));
58-
m_compiler.setLibraries(_libraryAddresses);
59-
m_compiler.setRevertStringBehaviour(m_revertStrings);
60-
m_compiler.setEVMVersion(m_evmVersion);
61-
m_compiler.setEOFVersion(m_eofVersion);
62-
m_compiler.setOptimiserSettings(m_optimiserSettings);
63-
m_compiler.setViaIR(m_compileViaYul);
64-
m_compiler.setRevertStringBehaviour(m_revertStrings);
58+
);
59+
m_compilerInput.libraryAddresses = _libraryAddresses;
60+
m_compilerInput.evmVersion = std::make_optional(m_evmVersion);
61+
m_compilerInput.eofVersion = m_eofVersion;
62+
m_compilerInput.optimiserSettings = std::make_optional(m_optimiserSettings);
63+
m_compilerInput.revertStrings = std::make_optional(m_revertStrings);
64+
m_compilerInput.metadataHash = std::make_optional(m_metadataHash);
65+
m_compilerInput.viaIR = std::make_optional(m_compileViaYul);
6566
if (!m_appendCBORMetadata) {
66-
m_compiler.setMetadataFormat(CompilerStack::MetadataFormat::NoMetadata);
67+
m_compilerInput.metadataFormat = std::make_optional(MetadataFormat::NoMetadata);
6768
}
68-
m_compiler.setMetadataHash(m_metadataHash);
6969

70-
if (!m_compiler.compile())
70+
m_compiler.compile(m_compilerInput);
71+
72+
auto output = m_compiler.output();
73+
if (!output.success())
7174
{
7275
// The testing framework expects an exception for
7376
// "unimplemented" yul IR generation.
7477
if (m_compileViaYul)
75-
for (auto const& error: m_compiler.errors())
76-
if (error->type() == langutil::Error::Type::CodeGenerationError)
77-
BOOST_THROW_EXCEPTION(*error);
78-
langutil::SourceReferenceFormatter{std::cerr, m_compiler, true, false}
79-
.printErrorInformation(m_compiler.errors());
78+
{
79+
auto type = langutil::Error::Type::CodeGenerationError;
80+
auto error = output.findError(type);
81+
if (error.has_value())
82+
BOOST_THROW_EXCEPTION(error.value());
83+
}
84+
std::cout << output.errorInformation() << std::endl;
8085
BOOST_ERROR("Compiling contract failed");
8186
}
82-
std::string contractName(_contractName.empty() ? m_compiler.lastContractName(_mainSourceName) : _contractName);
83-
evmasm::LinkerObject obj = m_compiler.object(contractName);
84-
BOOST_REQUIRE(obj.linkReferences.empty());
87+
88+
std::optional<CompiledContract> contract;
89+
if (_contractName.empty())
90+
contract = output.contract(_mainSourceName, std::nullopt);
91+
else
92+
contract = output.contract(std::nullopt, std::make_optional(_contractName));
93+
94+
soltestAssert(contract.has_value());
95+
soltestAssert(!contract.value().hasUnlinkedReferences);
96+
8597
if (m_showMetadata)
86-
std::cout << "metadata: " << m_compiler.metadata(contractName) << std::endl;
87-
return obj.bytecode;
98+
std::cout << "metadata: " << contract.value().metadata << std::endl;
99+
return contract.value().object;
88100
}
89101

90102
bytes SolidityExecutionFramework::compileContract(

Diff for: ‎test/libsolidity/SolidityExecutionFramework.h

+6-2
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,9 @@
2727

2828
#include <test/ExecutionFramework.h>
2929

30+
#include <test/libsolidity/util/compiler/Compiler.h>
31+
#include <test/libsolidity/util/compiler/CompilerHost.h>
32+
3033
#include <libsolidity/interface/CompilerStack.h>
3134
#include <libsolidity/interface/DebugSettings.h>
3235

@@ -82,11 +85,12 @@ class SolidityExecutionFramework: public solidity::test::ExecutionFramework
8285
protected:
8386
using CompilerStack = solidity::frontend::CompilerStack;
8487
std::optional<uint8_t> m_eofVersion;
85-
CompilerStack m_compiler;
88+
CompilerInput m_compilerInput;
89+
CompilerHost m_compiler;
8690
bool m_compileViaYul = false;
8791
bool m_showMetadata = false;
8892
bool m_appendCBORMetadata = true;
89-
CompilerStack::MetadataHash m_metadataHash = CompilerStack::MetadataHash::IPFS;
93+
MetadataHash m_metadataHash = MetadataHash::IPFS;
9094
RevertStrings m_revertStrings = RevertStrings::Default;
9195
};
9296

0 commit comments

Comments
 (0)