From 862d7980477b3f2b6bc9ca29d61b06a8e8f81e57 Mon Sep 17 00:00:00 2001 From: Christian Parpart Date: Mon, 15 Apr 2019 15:27:51 +0200 Subject: [PATCH] [test] AnalysisFramework's instance of CompilerStack to be lazily instanciated. --- test/libsolidity/AnalysisFramework.cpp | 16 +++++++-------- test/libsolidity/AnalysisFramework.h | 20 ++++++++++++++++++- test/libsolidity/SolidityCompiler.cpp | 8 ++++---- .../SolidityNameAndTypeResolution.cpp | 2 +- test/libsolidity/SyntaxTest.cpp | 12 +++++------ 5 files changed, 38 insertions(+), 20 deletions(-) diff --git a/test/libsolidity/AnalysisFramework.cpp b/test/libsolidity/AnalysisFramework.cpp index f5c592906..faebfc3f5 100644 --- a/test/libsolidity/AnalysisFramework.cpp +++ b/test/libsolidity/AnalysisFramework.cpp @@ -47,21 +47,21 @@ AnalysisFramework::parseAnalyseAndReturnError( bool _allowMultipleErrors ) { - m_compiler.reset(); - m_compiler.setSources({{"", _insertVersionPragma ? "pragma solidity >=0.0;\n" + _source : _source}}); - m_compiler.setEVMVersion(dev::test::Options::get().evmVersion()); - if (!m_compiler.parse()) + compiler().reset(); + compiler().setSources({{"", _insertVersionPragma ? "pragma solidity >=0.0;\n" + _source : _source}}); + compiler().setEVMVersion(dev::test::Options::get().evmVersion()); + if (!compiler().parse()) { BOOST_FAIL("Parsing contract failed in analysis test suite:" + formatErrors()); } - m_compiler.analyze(); + compiler().analyze(); - ErrorList errors = filterErrors(m_compiler.errors(), _reportWarnings); + ErrorList errors = filterErrors(compiler().errors(), _reportWarnings); if (errors.size() > 1 && !_allowMultipleErrors) BOOST_FAIL("Multiple errors found: " + formatErrors()); - return make_pair(&m_compiler.ast(""), std::move(errors)); + return make_pair(&compiler().ast(""), std::move(errors)); } ErrorList AnalysisFramework::filterErrors(ErrorList const& _errorList, bool _includeWarnings) const @@ -118,7 +118,7 @@ ErrorList AnalysisFramework::expectError(std::string const& _source, bool _warni string AnalysisFramework::formatErrors() const { string message; - for (auto const& error: m_compiler.errors()) + for (auto const& error: compiler().errors()) message += formatError(*error); return message; } diff --git a/test/libsolidity/AnalysisFramework.h b/test/libsolidity/AnalysisFramework.h index 391a21dad..70ed6e33c 100644 --- a/test/libsolidity/AnalysisFramework.h +++ b/test/libsolidity/AnalysisFramework.h @@ -71,7 +71,25 @@ protected: langutil::ErrorList filterErrors(langutil::ErrorList const& _errorList, bool _includeWarnings) const; std::vector m_warningsToFilter = {"This is a pre-release compiler version"}; - dev::solidity::CompilerStack m_compiler; + + /// @returns reference to lazy-instanciated CompilerStack. + dev::solidity::CompilerStack& compiler() + { + if (!m_compiler) + m_compiler = std::make_unique(); + return *m_compiler; + } + + /// @returns reference to lazy-instanciated CompilerStack. + dev::solidity::CompilerStack const& compiler() const + { + if (!m_compiler) + m_compiler = std::make_unique(); + return *m_compiler; + } + +private: + mutable std::unique_ptr m_compiler; }; // Asserts that the compilation down to typechecking diff --git a/test/libsolidity/SolidityCompiler.cpp b/test/libsolidity/SolidityCompiler.cpp index 10bdf9a86..8d8405f8b 100644 --- a/test/libsolidity/SolidityCompiler.cpp +++ b/test/libsolidity/SolidityCompiler.cpp @@ -42,11 +42,11 @@ BOOST_AUTO_TEST_CASE(does_not_include_creation_time_only_internal_functions) function f() internal { for (uint i = 0; i < 10; ++i) x += 3 + i; } } )"; - m_compiler.setOptimiserSettings(dev::test::Options::get().optimize); + compiler().setOptimiserSettings(dev::test::Options::get().optimize); BOOST_REQUIRE(success(sourceCode)); - BOOST_REQUIRE_MESSAGE(m_compiler.compile(), "Compiling contract failed"); - bytes const& creationBytecode = dev::test::bytecodeSansMetadata(m_compiler.object("C").bytecode); - bytes const& runtimeBytecode = dev::test::bytecodeSansMetadata(m_compiler.runtimeObject("C").bytecode); + BOOST_REQUIRE_MESSAGE(compiler().compile(), "Compiling contract failed"); + bytes const& creationBytecode = dev::test::bytecodeSansMetadata(compiler().object("C").bytecode); + bytes const& runtimeBytecode = dev::test::bytecodeSansMetadata(compiler().runtimeObject("C").bytecode); BOOST_CHECK(creationBytecode.size() >= 90); BOOST_CHECK(creationBytecode.size() <= 120); BOOST_CHECK(runtimeBytecode.size() >= 10); diff --git a/test/libsolidity/SolidityNameAndTypeResolution.cpp b/test/libsolidity/SolidityNameAndTypeResolution.cpp index e3f3f077d..3a51672cf 100644 --- a/test/libsolidity/SolidityNameAndTypeResolution.cpp +++ b/test/libsolidity/SolidityNameAndTypeResolution.cpp @@ -436,7 +436,7 @@ BOOST_AUTO_TEST_CASE(getter_is_memory_type) )"; CHECK_SUCCESS_NO_WARNINGS(text); // Check that the getters return a memory strings, not a storage strings. - ContractDefinition const& c = dynamic_cast(*m_compiler.ast("").nodes().at(1)); + ContractDefinition const& c = dynamic_cast(*compiler().ast("").nodes().at(1)); BOOST_CHECK(c.interfaceFunctions().size() == 2); for (auto const& f: c.interfaceFunctions()) { diff --git a/test/libsolidity/SyntaxTest.cpp b/test/libsolidity/SyntaxTest.cpp index c1114c832..6806c8047 100644 --- a/test/libsolidity/SyntaxTest.cpp +++ b/test/libsolidity/SyntaxTest.cpp @@ -66,14 +66,14 @@ SyntaxTest::SyntaxTest(string const& _filename, langutil::EVMVersion _evmVersion bool SyntaxTest::run(ostream& _stream, string const& _linePrefix, bool _formatted) { string const versionPragma = "pragma solidity >=0.0;\n"; - m_compiler.reset(); - m_compiler.setSources({{"", versionPragma + m_source}}); - m_compiler.setEVMVersion(m_evmVersion); + compiler().reset(); + compiler().setSources({{"", versionPragma + m_source}}); + compiler().setEVMVersion(m_evmVersion); - if (m_compiler.parse()) - m_compiler.analyze(); + if (compiler().parse()) + compiler().analyze(); - for (auto const& currentError: filterErrors(m_compiler.errors(), true)) + for (auto const& currentError: filterErrors(compiler().errors(), true)) { int locationStart = -1, locationEnd = -1; if (auto location = boost::get_error_info(*currentError))