From fbcc5f4ee5bd629474047531f76beaa19c62972b Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Sun, 9 Jul 2017 00:10:22 +0100 Subject: [PATCH 1/6] Support experimental feature pragma --- libsolidity/analysis/SyntaxChecker.cpp | 32 ++++++++++++++++++++++---- libsolidity/analysis/SyntaxChecker.h | 2 ++ libsolidity/ast/ASTAnnotations.h | 2 ++ 3 files changed, 32 insertions(+), 4 deletions(-) diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index bde0e616e..04c4e2d83 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -33,9 +33,10 @@ bool SyntaxChecker::checkSyntax(ASTNode const& _astRoot) return Error::containsOnlyWarnings(m_errorReporter.errors()); } -bool SyntaxChecker::visit(SourceUnit const&) +bool SyntaxChecker::visit(SourceUnit const& _sourceUnit) { m_versionPragmaFound = false; + m_sourceUnit = &_sourceUnit; return true; } @@ -57,15 +58,36 @@ void SyntaxChecker::endVisit(SourceUnit const& _sourceUnit) m_errorReporter.warning(_sourceUnit.location(), errorString); } + m_sourceUnit = nullptr; } bool SyntaxChecker::visit(PragmaDirective const& _pragma) { solAssert(!_pragma.tokens().empty(), ""); solAssert(_pragma.tokens().size() == _pragma.literals().size(), ""); - if (_pragma.tokens()[0] != Token::Identifier || _pragma.literals()[0] != "solidity") - m_errorReporter.syntaxError(_pragma.location(), "Unknown pragma \"" + _pragma.literals()[0] + "\""); - else + if (_pragma.tokens()[0] != Token::Identifier) + m_errorReporter.syntaxError(_pragma.location(), "Invalid pragma \"" + _pragma.literals()[0] + "\""); + else if (_pragma.literals()[0] == "experimental") + { + solAssert(m_sourceUnit, ""); + vector literals(_pragma.literals().begin() + 1, _pragma.literals().end()); + if (literals.size() == 0) + m_errorReporter.syntaxError( + _pragma.location(), + "At least one experimental feature or the wildcard symbol \"*\" is required." + ); + else + for (string const literal: literals) + { + if (literal.empty()) + m_errorReporter.syntaxError(_pragma.location(), "Empty experimental feature name is invalid."); + else if (m_sourceUnit->annotation().experimentalFeatures.count(literal)) + m_errorReporter.syntaxError(_pragma.location(), "Duplicate experimental feature name."); + else + m_sourceUnit->annotation().experimentalFeatures.insert(literal); + } + } + else if (_pragma.literals()[0] == "solidity") { vector tokens(_pragma.tokens().begin() + 1, _pragma.tokens().end()); vector literals(_pragma.literals().begin() + 1, _pragma.literals().end()); @@ -81,6 +103,8 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma) ); m_versionPragmaFound = true; } + else + m_errorReporter.syntaxError(_pragma.location(), "Unknown pragma \"" + _pragma.literals()[0] + "\""); return true; } diff --git a/libsolidity/analysis/SyntaxChecker.h b/libsolidity/analysis/SyntaxChecker.h index fb5cc6d7a..fa34bab31 100644 --- a/libsolidity/analysis/SyntaxChecker.h +++ b/libsolidity/analysis/SyntaxChecker.h @@ -77,6 +77,8 @@ private: bool m_versionPragmaFound = false; int m_inLoopDepth = 0; + + SourceUnit const* m_sourceUnit = nullptr; }; } diff --git a/libsolidity/ast/ASTAnnotations.h b/libsolidity/ast/ASTAnnotations.h index f757f03c0..083ecfa48 100644 --- a/libsolidity/ast/ASTAnnotations.h +++ b/libsolidity/ast/ASTAnnotations.h @@ -61,6 +61,8 @@ struct SourceUnitAnnotation: ASTAnnotation std::string path; /// The exported symbols (all global symbols). std::map> exportedSymbols; + /// Experimental feature pragmas. + std::set experimentalFeatures; }; struct ImportAnnotation: ASTAnnotation From e44da40835670e667eda0ca30467fa52328a9075 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Wed, 2 Aug 2017 20:05:35 +0100 Subject: [PATCH 2/6] Warn if using experimental pragma --- libsolidity/analysis/SyntaxChecker.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index 04c4e2d83..db3e0a7ae 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -77,6 +77,7 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma) "At least one experimental feature or the wildcard symbol \"*\" is required." ); else + { for (string const literal: literals) { if (literal.empty()) @@ -84,8 +85,12 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma) else if (m_sourceUnit->annotation().experimentalFeatures.count(literal)) m_errorReporter.syntaxError(_pragma.location(), "Duplicate experimental feature name."); else + { m_sourceUnit->annotation().experimentalFeatures.insert(literal); + m_errorReporter.warning(_pragma.location(), "Experimental features are turned on. Do not use experimental features on live deployments."); + } } + } } else if (_pragma.literals()[0] == "solidity") { From de9e758ef7c0a2f60d526bb94c834a4e3c2a737a Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Wed, 2 Aug 2017 20:21:20 +0100 Subject: [PATCH 3/6] Reject unsupported experimental feature names --- libsolidity/analysis/SyntaxChecker.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index db3e0a7ae..8c92f439e 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -69,6 +69,9 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma) m_errorReporter.syntaxError(_pragma.location(), "Invalid pragma \"" + _pragma.literals()[0] + "\""); else if (_pragma.literals()[0] == "experimental") { + /// TODO: fill this out + static const set validFeatures = set{}; + solAssert(m_sourceUnit, ""); vector literals(_pragma.literals().begin() + 1, _pragma.literals().end()); if (literals.size() == 0) @@ -82,6 +85,8 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma) { if (literal.empty()) m_errorReporter.syntaxError(_pragma.location(), "Empty experimental feature name is invalid."); + else if (!validFeatures.count(literal)) + m_errorReporter.syntaxError(_pragma.location(), "Unsupported experimental feature name."); else if (m_sourceUnit->annotation().experimentalFeatures.count(literal)) m_errorReporter.syntaxError(_pragma.location(), "Duplicate experimental feature name."); else From 690ed37fd4b90119ac69def3e308035d46af0c60 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Fri, 4 Aug 2017 23:28:28 +0100 Subject: [PATCH 4/6] Reject wildcard and multiple experimental pragmas --- libsolidity/analysis/SyntaxChecker.cpp | 29 ++++++++++++++------------ 1 file changed, 16 insertions(+), 13 deletions(-) diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index 8c92f439e..39f788c40 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -77,23 +77,26 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma) if (literals.size() == 0) m_errorReporter.syntaxError( _pragma.location(), - "At least one experimental feature or the wildcard symbol \"*\" is required." + "Experimental feature name is missing." + ); + else if (literals.size() > 1) + m_errorReporter.syntaxError( + _pragma.location(), + "Stray arguments." ); else { - for (string const literal: literals) + string const literal = literals[0]; + if (literal.empty()) + m_errorReporter.syntaxError(_pragma.location(), "Empty experimental feature name is invalid."); + else if (!validFeatures.count(literal)) + m_errorReporter.syntaxError(_pragma.location(), "Unsupported experimental feature name."); + else if (m_sourceUnit->annotation().experimentalFeatures.count(literal)) + m_errorReporter.syntaxError(_pragma.location(), "Duplicate experimental feature name."); + else { - if (literal.empty()) - m_errorReporter.syntaxError(_pragma.location(), "Empty experimental feature name is invalid."); - else if (!validFeatures.count(literal)) - m_errorReporter.syntaxError(_pragma.location(), "Unsupported experimental feature name."); - else if (m_sourceUnit->annotation().experimentalFeatures.count(literal)) - m_errorReporter.syntaxError(_pragma.location(), "Duplicate experimental feature name."); - else - { - m_sourceUnit->annotation().experimentalFeatures.insert(literal); - m_errorReporter.warning(_pragma.location(), "Experimental features are turned on. Do not use experimental features on live deployments."); - } + m_sourceUnit->annotation().experimentalFeatures.insert(literal); + m_errorReporter.warning(_pragma.location(), "Experimental features are turned on. Do not use experimental features on live deployments."); } } } From 57c24511308f9cd1f981e92aacfb880825eb6ed9 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Tue, 8 Aug 2017 14:09:57 +0100 Subject: [PATCH 5/6] Introduce ExperimentalFeatures header --- libsolidity/analysis/SyntaxChecker.cpp | 10 +++----- libsolidity/ast/ASTAnnotations.h | 5 ++-- libsolidity/ast/ExperimentalFeatures.h | 35 ++++++++++++++++++++++++++ 3 files changed, 42 insertions(+), 8 deletions(-) create mode 100644 libsolidity/ast/ExperimentalFeatures.h diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index 39f788c40..d2571cd35 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -69,9 +70,6 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma) m_errorReporter.syntaxError(_pragma.location(), "Invalid pragma \"" + _pragma.literals()[0] + "\""); else if (_pragma.literals()[0] == "experimental") { - /// TODO: fill this out - static const set validFeatures = set{}; - solAssert(m_sourceUnit, ""); vector literals(_pragma.literals().begin() + 1, _pragma.literals().end()); if (literals.size() == 0) @@ -89,13 +87,13 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma) string const literal = literals[0]; if (literal.empty()) m_errorReporter.syntaxError(_pragma.location(), "Empty experimental feature name is invalid."); - else if (!validFeatures.count(literal)) + else if (!ExperimentalFeatureNames.count(literal)) m_errorReporter.syntaxError(_pragma.location(), "Unsupported experimental feature name."); - else if (m_sourceUnit->annotation().experimentalFeatures.count(literal)) + else if (m_sourceUnit->annotation().experimentalFeatures.count(ExperimentalFeatureNames.at(literal))) m_errorReporter.syntaxError(_pragma.location(), "Duplicate experimental feature name."); else { - m_sourceUnit->annotation().experimentalFeatures.insert(literal); + m_sourceUnit->annotation().experimentalFeatures.insert(ExperimentalFeatureNames.at(literal)); m_errorReporter.warning(_pragma.location(), "Experimental features are turned on. Do not use experimental features on live deployments."); } } diff --git a/libsolidity/ast/ASTAnnotations.h b/libsolidity/ast/ASTAnnotations.h index 083ecfa48..fd9efb4d9 100644 --- a/libsolidity/ast/ASTAnnotations.h +++ b/libsolidity/ast/ASTAnnotations.h @@ -23,6 +23,7 @@ #pragma once #include +#include #include #include @@ -61,8 +62,8 @@ struct SourceUnitAnnotation: ASTAnnotation std::string path; /// The exported symbols (all global symbols). std::map> exportedSymbols; - /// Experimental feature pragmas. - std::set experimentalFeatures; + /// Experimental features. + std::set experimentalFeatures; }; struct ImportAnnotation: ASTAnnotation diff --git a/libsolidity/ast/ExperimentalFeatures.h b/libsolidity/ast/ExperimentalFeatures.h new file mode 100644 index 000000000..b0a071426 --- /dev/null +++ b/libsolidity/ast/ExperimentalFeatures.h @@ -0,0 +1,35 @@ +/* + This file is part of solidity. + + solidity is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + solidity is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with solidity. If not, see . +*/ +/** + * List of experimental features. + */ + +#pragma once + +#include + +namespace dev +{ +namespace solidity +{ + +enum class ExperimentalFeature {}; + +static const std::map ExperimentalFeatureNames = {}; + +} +} From 470950e75e6f3a8a37d2a8fe1c263149be01c402 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Tue, 8 Aug 2017 14:41:46 +0100 Subject: [PATCH 6/6] Add tests for experimental pragma --- .../SolidityNameAndTypeResolution.cpp | 37 +++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/test/libsolidity/SolidityNameAndTypeResolution.cpp b/test/libsolidity/SolidityNameAndTypeResolution.cpp index 2fbc6ac8f..55ce5f7bd 100644 --- a/test/libsolidity/SolidityNameAndTypeResolution.cpp +++ b/test/libsolidity/SolidityNameAndTypeResolution.cpp @@ -6558,6 +6558,43 @@ BOOST_AUTO_TEST_CASE(library_function_without_implementation) CHECK_ERROR(text, TypeError, "Internal library function must be implemented if declared."); } +BOOST_AUTO_TEST_CASE(experimental_pragma) +{ + char const* text = R"( + pragma experimental; + )"; + CHECK_ERROR(text, SyntaxError, "Experimental feature name is missing."); + text = R"( + pragma experimental 123; + )"; + CHECK_ERROR(text, SyntaxError, "Unsupported experimental feature name."); + text = R"( + pragma experimental unsupportedName; + )"; + CHECK_ERROR(text, SyntaxError, "Unsupported experimental feature name."); + text = R"( + pragma experimental "unsupportedName"; + )"; + CHECK_ERROR(text, SyntaxError, "Unsupported experimental feature name."); + text = R"( + pragma experimental ""; + )"; + CHECK_ERROR(text, SyntaxError, "Empty experimental feature name is invalid."); + text = R"( + pragma experimental unsupportedName unsupportedName; + )"; + CHECK_ERROR(text, SyntaxError, "Stray arguments."); +// text = R"( +// pragma experimental supportedName; +// )"; +// CHECK_WARNING(text, "Experimental features are turned on. Do not use experimental features on live deployments."); +// text = R"( +// pragma experimental supportedName; +// pragma experimental supportedName; +// )"; +// CHECK_ERROR(text, SyntaxError, "Duplicate experimental feature name."); +} + BOOST_AUTO_TEST_SUITE_END() }