From a211b8911885ded6ddcd4d7400994a85235fe8e4 Mon Sep 17 00:00:00 2001 From: Christian Parpart Date: Wed, 6 Jun 2018 11:15:22 +0200 Subject: Enforce disallowing empty structs This patch enfoces an error when it encounters an empty struct, effectively eliminating the deprecation warning. Also adjust 419_interface_structs to explicitely test for (non-empty) structs, as this behaviour "may" change in the future. --- libsolidity/analysis/SyntaxChecker.cpp | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index 396058f4..f234dcaf 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -276,14 +276,8 @@ bool SyntaxChecker::visit(VariableDeclaration const& _declaration) bool SyntaxChecker::visit(StructDefinition const& _struct) { - bool const v050 = m_sourceUnit->annotation().experimentalFeatures.count(ExperimentalFeature::V050); - if (_struct.members().empty()) - { - if (v050) - m_errorReporter.syntaxError(_struct.location(), "Defining empty structs is disallowed."); - else - m_errorReporter.warning(_struct.location(), "Defining empty structs is deprecated."); - } + m_errorReporter.syntaxError(_struct.location(), "Defining empty structs is disallowed."); + return true; } -- cgit v1.2.3 From dbfee87860187e3f3d5b6c06fffe0e601d01d7ea Mon Sep 17 00:00:00 2001 From: Daniel Kirchner Date: Thu, 14 Jun 2018 17:32:09 +0200 Subject: Return parameters in function types may not be named. --- libsolidity/analysis/SyntaxChecker.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index f234dcaf..c408b393 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -255,7 +255,7 @@ bool SyntaxChecker::visit(FunctionTypeName const& _node) for (auto const& decl: _node.returnParameterTypeList()->parameters()) if (!decl->name().empty()) - m_errorReporter.warning(decl->location(), "Naming function type return parameters is deprecated."); + m_errorReporter.syntaxError(decl->location(), "Return parameters in function types may not be named."); return true; } -- cgit v1.2.3 From 1486d215b9c7f94831784ded50342897b65477c9 Mon Sep 17 00:00:00 2001 From: Christian Parpart Date: Mon, 11 Jun 2018 14:06:56 +0200 Subject: libsolidity: turns the var-keyword use from deprecation-warning to an error and include explicit type suggestion --- libsolidity/analysis/SyntaxChecker.cpp | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index c408b393..cd0dc2a4 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -262,14 +262,9 @@ bool SyntaxChecker::visit(FunctionTypeName const& _node) bool SyntaxChecker::visit(VariableDeclaration const& _declaration) { - bool const v050 = m_sourceUnit->annotation().experimentalFeatures.count(ExperimentalFeature::V050); - if (!_declaration.typeName()) { - if (v050) - m_errorReporter.syntaxError(_declaration.location(), "Use of the \"var\" keyword is deprecated."); - else - m_errorReporter.warning(_declaration.location(), "Use of the \"var\" keyword is deprecated."); + m_errorReporter.syntaxError(_declaration.location(), "Use of the \"var\" keyword is disallowed."); } return true; } -- cgit v1.2.3 From 8ca69ed8d86efe8058cb1001ab4c2609dbe297da Mon Sep 17 00:00:00 2001 From: Christian Parpart Date: Tue, 3 Jul 2018 11:10:14 +0200 Subject: defaulting to v0.5.0 behaviour of unary + operator (disallow); also adapting all tests to it --- libsolidity/analysis/SyntaxChecker.cpp | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index cd0dc2a4..63f8fac3 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -192,15 +192,9 @@ bool SyntaxChecker::visit(Throw const& _throwStatement) bool SyntaxChecker::visit(UnaryOperation const& _operation) { - bool const v050 = m_sourceUnit->annotation().experimentalFeatures.count(ExperimentalFeature::V050); - if (_operation.getOperator() == Token::Add) - { - if (v050) - m_errorReporter.syntaxError(_operation.location(), "Use of unary + is deprecated."); - else - m_errorReporter.warning(_operation.location(), "Use of unary + is deprecated."); - } + m_errorReporter.syntaxError(_operation.location(), "Use of unary + is disallowed."); + return true; } -- cgit v1.2.3 From 1505e28b56c3a90abdb606ed1389394d7918d7eb Mon Sep 17 00:00:00 2001 From: Christian Parpart Date: Mon, 2 Jul 2018 17:00:09 +0200 Subject: semantics: Suggest auto-deduced type when user declares variable with `var` keyword. --- libsolidity/analysis/SyntaxChecker.cpp | 9 --------- 1 file changed, 9 deletions(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index 63f8fac3..4311e77d 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -254,15 +254,6 @@ bool SyntaxChecker::visit(FunctionTypeName const& _node) return true; } -bool SyntaxChecker::visit(VariableDeclaration const& _declaration) -{ - if (!_declaration.typeName()) - { - m_errorReporter.syntaxError(_declaration.location(), "Use of the \"var\" keyword is disallowed."); - } - return true; -} - bool SyntaxChecker::visit(StructDefinition const& _struct) { if (_struct.members().empty()) -- cgit v1.2.3 From cc585138bc08ff421a026d08f07020b284d946ce Mon Sep 17 00:00:00 2001 From: Christian Parpart Date: Thu, 5 Jul 2018 12:31:46 +0200 Subject: Generates a syntax error when declaring a variable declaration's LHS has no named components --- libsolidity/analysis/SyntaxChecker.cpp | 13 +++++++++++++ 1 file changed, 13 insertions(+) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index 4311e77d..e33aafed 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -22,6 +22,7 @@ #include #include #include +#include using namespace std; using namespace dev; @@ -254,6 +255,18 @@ bool SyntaxChecker::visit(FunctionTypeName const& _node) return true; } +bool SyntaxChecker::visit(VariableDeclarationStatement const& _statement) +{ + // Report if none of the variable components in the tuple have a name (only possible via deprecated "var") + if (boost::algorithm::all_of_equal(_statement.declarations(), nullptr)) + m_errorReporter.syntaxError( + _statement.location(), + "The use of the \"var\" keyword is disallowed. The declaration part of the statement can be removed, since it is empty." + ); + + return true; +} + bool SyntaxChecker::visit(StructDefinition const& _struct) { if (_struct.members().empty()) -- cgit v1.2.3 From 21e97da2949a421987b0c6ad75bd401ce1dad0ab Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Wed, 11 Jul 2018 15:06:31 +0100 Subject: Deprecate the throw statement --- libsolidity/analysis/SyntaxChecker.cpp | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index e33aafed..fba18a45 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -175,18 +175,10 @@ bool SyntaxChecker::visit(Break const& _breakStatement) bool SyntaxChecker::visit(Throw const& _throwStatement) { - bool const v050 = m_sourceUnit->annotation().experimentalFeatures.count(ExperimentalFeature::V050); - - if (v050) - m_errorReporter.syntaxError( - _throwStatement.location(), - "\"throw\" is deprecated in favour of \"revert()\", \"require()\" and \"assert()\"." - ); - else - m_errorReporter.warning( - _throwStatement.location(), - "\"throw\" is deprecated in favour of \"revert()\", \"require()\" and \"assert()\"." - ); + m_errorReporter.syntaxError( + _throwStatement.location(), + "\"throw\" is deprecated in favour of \"revert()\", \"require()\" and \"assert()\"." + ); return true; } -- cgit v1.2.3 From b5ecfbe5bc2afdf8f42ec67715794aefad9dfe0f Mon Sep 17 00:00:00 2001 From: Erik Kundt Date: Wed, 4 Jul 2018 18:04:44 +0200 Subject: Enforces visibility specifier and updates docs. --- libsolidity/analysis/SyntaxChecker.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index fba18a45..234c177c 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -201,7 +201,7 @@ bool SyntaxChecker::visit(FunctionDefinition const& _function) { bool const v050 = m_sourceUnit->annotation().experimentalFeatures.count(ExperimentalFeature::V050); - if (v050 && _function.noVisibilitySpecified()) + if (_function.noVisibilitySpecified()) m_errorReporter.syntaxError(_function.location(), "No visibility specified."); if (_function.isOldStyleConstructor()) -- cgit v1.2.3 From dfd2fee91d2d6158dc11146ddc1773ac5eb12c6a Mon Sep 17 00:00:00 2001 From: chriseth Date: Tue, 10 Jul 2018 22:43:02 +0200 Subject: Suggests external for fallback and interface functions. --- libsolidity/analysis/SyntaxChecker.cpp | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index 234c177c..4d09e36d 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -197,12 +197,24 @@ bool SyntaxChecker::visit(PlaceholderStatement const&) return true; } +bool SyntaxChecker::visit(ContractDefinition const& _contract) +{ + m_isInterface = _contract.contractKind() == ContractDefinition::ContractKind::Interface; + return true; +} + bool SyntaxChecker::visit(FunctionDefinition const& _function) { bool const v050 = m_sourceUnit->annotation().experimentalFeatures.count(ExperimentalFeature::V050); if (_function.noVisibilitySpecified()) - m_errorReporter.syntaxError(_function.location(), "No visibility specified."); + { + string suggestedVisibility = _function.isFallback() || m_isInterface ? "external" : "public"; + m_errorReporter.syntaxError( + _function.location(), + "No visibility specified. Did you intend to add \"" + suggestedVisibility + "\"?" + ); + } if (_function.isOldStyleConstructor()) { -- cgit v1.2.3 From 182a0a95516e4f218524b929035e6a1bd5d2742c Mon Sep 17 00:00:00 2001 From: Erik Kundt Date: Wed, 27 Jun 2018 12:29:03 +0200 Subject: Disallows old constructor syntax. --- libsolidity/analysis/SyntaxChecker.cpp | 28 ++++++++-------------------- 1 file changed, 8 insertions(+), 20 deletions(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index 4d09e36d..5d16a33f 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -200,6 +200,14 @@ bool SyntaxChecker::visit(PlaceholderStatement const&) bool SyntaxChecker::visit(ContractDefinition const& _contract) { m_isInterface = _contract.contractKind() == ContractDefinition::ContractKind::Interface; + + ASTString const& contractName = _contract.name(); + for (FunctionDefinition const* function: _contract.definedFunctions()) + if (function->name() == contractName) + m_errorReporter.syntaxError(function->location(), + "Functions are not allowed to have the same name as the contract. " + "If you intend this to be a constructor, use \"constructor(...) { ... }\" to define it." + ); return true; } @@ -216,21 +224,6 @@ bool SyntaxChecker::visit(FunctionDefinition const& _function) ); } - if (_function.isOldStyleConstructor()) - { - if (v050) - m_errorReporter.syntaxError( - _function.location(), - "Functions are not allowed to have the same name as the contract. " - "If you intend this to be a constructor, use \"constructor(...) { ... }\" to define it." - ); - else - m_errorReporter.warning( - _function.location(), - "Defining constructors as functions with the same name as the contract is deprecated. " - "Use \"constructor(...) { ... }\" instead." - ); - } if (!_function.isImplemented() && !_function.modifiers().empty()) { if (v050) @@ -238,11 +231,6 @@ bool SyntaxChecker::visit(FunctionDefinition const& _function) else m_errorReporter.warning(_function.location(), "Modifiers of functions without implementation are ignored." ); } - if (_function.name() == "constructor") - m_errorReporter.warning(_function.location(), - "This function is named \"constructor\" but is not the constructor of the contract. " - "If you intend this to be a constructor, use \"constructor(...) { ... }\" without the \"function\" keyword to define it." - ); return true; } -- cgit v1.2.3 From 9f35f0b80571927ec89d77ec6827332c2ab60eba Mon Sep 17 00:00:00 2001 From: Christian Parpart Date: Tue, 3 Jul 2018 11:28:57 +0200 Subject: Disallow functions without implementation to use modifiers. This was already the case in the experimental 0.5.0 mode. --- libsolidity/analysis/SyntaxChecker.cpp | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index 5d16a33f..77492499 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -213,8 +213,6 @@ bool SyntaxChecker::visit(ContractDefinition const& _contract) bool SyntaxChecker::visit(FunctionDefinition const& _function) { - bool const v050 = m_sourceUnit->annotation().experimentalFeatures.count(ExperimentalFeature::V050); - if (_function.noVisibilitySpecified()) { string suggestedVisibility = _function.isFallback() || m_isInterface ? "external" : "public"; @@ -225,12 +223,8 @@ bool SyntaxChecker::visit(FunctionDefinition const& _function) } if (!_function.isImplemented() && !_function.modifiers().empty()) - { - if (v050) - m_errorReporter.syntaxError(_function.location(), "Functions without implementation cannot have modifiers."); - else - m_errorReporter.warning(_function.location(), "Modifiers of functions without implementation are ignored." ); - } + m_errorReporter.syntaxError(_function.location(), "Functions without implementation cannot have modifiers."); + return true; } -- cgit v1.2.3 From 09a36cba0223c16248335703412cee019c7aa59f Mon Sep 17 00:00:00 2001 From: Balajiganapathi S Date: Wed, 25 Oct 2017 13:42:07 +0530 Subject: Add stricter hex underscore rules --- libsolidity/analysis/SyntaxChecker.cpp | 43 ++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index 77492499..dc2e35e5 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -24,6 +24,9 @@ #include #include +#include +#include + using namespace std; using namespace dev; using namespace dev::solidity; @@ -183,6 +186,46 @@ bool SyntaxChecker::visit(Throw const& _throwStatement) return true; } +bool SyntaxChecker::visit(Literal const& _literal) +{ + if (!_literal.isHexNumber()) + return true; + // We have a hex literal. Do underscore validation + solAssert(_literal.value().substr(0, 2) == "0x", ""); + ASTString value = _literal.value().substr(2); // Skip the 0x + vector parts; + boost::split(parts, value, boost::is_any_of("_")); + + if (parts.size() == 1) // no underscores + return true; + // Everything except first and last part must be 4 chars in length + for (size_t i = 1; i + 1 < parts.size(); ++i) + { + if (parts[i].size() != 4) + m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in hex literal. Found inner part with " + to_string(parts[i].size()) + " digits (has to be 4 digits)."); + } + + // Validate rightmost block + if (parts.back().size() == 4) // If ends with 4 digits, then no need to validate first block + return true; + + // Validate leftmost block + // If first part is 4 digits then last part's length has to be even to avoid ambiguity over zero padding + if (parts.front().size() == 4) + { + if (parts.back().size() % 2 == 0) + return true; + m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in hex literal. If the first part has 4 digits, it is assumed to be a byte sequence instead of a number and thus the last part should have an even number of digits."); + } + else + { + // Both first and last part is invalid + m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in hex literal. First or last part must have 4 digits."); + } + + return true; +} + bool SyntaxChecker::visit(UnaryOperation const& _operation) { if (_operation.getOperator() == Token::Add) -- cgit v1.2.3 From b9222808f61e00833f8c11cd196cafb50ec9e1b9 Mon Sep 17 00:00:00 2001 From: Christian Parpart Date: Fri, 3 Aug 2018 16:13:52 +0200 Subject: Cleanup & polish numbers-with-underscores parsing, also improving tests. --- libsolidity/analysis/SyntaxChecker.cpp | 49 +++++++++++++++++----------------- 1 file changed, 24 insertions(+), 25 deletions(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index dc2e35e5..ac4fa72b 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -188,39 +188,38 @@ bool SyntaxChecker::visit(Throw const& _throwStatement) bool SyntaxChecker::visit(Literal const& _literal) { - if (!_literal.isHexNumber()) + if (_literal.token() != Token::Number) return true; - // We have a hex literal. Do underscore validation - solAssert(_literal.value().substr(0, 2) == "0x", ""); - ASTString value = _literal.value().substr(2); // Skip the 0x - vector parts; - boost::split(parts, value, boost::is_any_of("_")); - if (parts.size() == 1) // no underscores - return true; - // Everything except first and last part must be 4 chars in length - for (size_t i = 1; i + 1 < parts.size(); ++i) - { - if (parts[i].size() != 4) - m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in hex literal. Found inner part with " + to_string(parts[i].size()) + " digits (has to be 4 digits)."); - } + ASTString const& value = _literal.value(); + solAssert(!value.empty(), ""); - // Validate rightmost block - if (parts.back().size() == 4) // If ends with 4 digits, then no need to validate first block + // Generic checks no matter what base this number literal is of: + if (value.back() == '_') + { + m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in number literal. No trailing underscores allowed."); return true; + } - // Validate leftmost block - // If first part is 4 digits then last part's length has to be even to avoid ambiguity over zero padding - if (parts.front().size() == 4) + if (value.find("__") != ASTString::npos) { - if (parts.back().size() % 2 == 0) - return true; - m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in hex literal. If the first part has 4 digits, it is assumed to be a byte sequence instead of a number and thus the last part should have an even number of digits."); + m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in number literal. Only one consecutive underscores between digits allowed."); + return true; } - else + + if (!_literal.isHexNumber()) // decimal literal { - // Both first and last part is invalid - m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in hex literal. First or last part must have 4 digits."); + if (value.find("._") != ASTString::npos) + m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in number literal. No underscores in front of the fraction part allowed."); + + if (value.find("_.") != ASTString::npos) + m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in number literal. No underscores in front of the fraction part allowed."); + + if (value.find("_e") != ASTString::npos) + m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in number literal. No underscore at the end of the mantissa allowed."); + + if (value.find("e_") != ASTString::npos) + m_errorReporter.syntaxError(_literal.location(), "Invalid use of underscores in number literal. No underscore in front of exponent allowed."); } return true; -- cgit v1.2.3 From 4522c804f342707ec2bb86a19735a4084108d96d Mon Sep 17 00:00:00 2001 From: Leonardo Alt Date: Mon, 3 Sep 2018 18:17:59 +0200 Subject: Disallow single statement var decl in if/while/for without blocks --- libsolidity/analysis/SyntaxChecker.cpp | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index ac4fa72b..1b5c00c4 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -138,9 +138,25 @@ void SyntaxChecker::endVisit(ModifierDefinition const& _modifier) m_placeholderFound = false; } -bool SyntaxChecker::visit(WhileStatement const&) +void SyntaxChecker::checkSingleStatementVariableDeclaration(ASTNode const* _statement) +{ + auto varDecl = dynamic_cast(_statement); + if (varDecl) + m_errorReporter.syntaxError(_statement->location(), "Invalid variable declaration. Please declare it inside a block."); +} + +bool SyntaxChecker::visit(IfStatement const& _ifStatement) +{ + checkSingleStatementVariableDeclaration(&_ifStatement.trueStatement()); + if (Statement const* _statement = _ifStatement.falseStatement()) + checkSingleStatementVariableDeclaration(_statement); + return true; +} + +bool SyntaxChecker::visit(WhileStatement const& _whileStatement) { m_inLoopDepth++; + checkSingleStatementVariableDeclaration(&_whileStatement.body()); return true; } @@ -149,9 +165,10 @@ void SyntaxChecker::endVisit(WhileStatement const&) m_inLoopDepth--; } -bool SyntaxChecker::visit(ForStatement const&) +bool SyntaxChecker::visit(ForStatement const& _forStatement) { m_inLoopDepth++; + checkSingleStatementVariableDeclaration(&_forStatement.body()); return true; } -- cgit v1.2.3 From 17176871ab4903498be0f9d62997ca1a9ace04d8 Mon Sep 17 00:00:00 2001 From: Leonardo Alt Date: Tue, 4 Sep 2018 11:48:58 +0200 Subject: Changed error message and added tests --- libsolidity/analysis/SyntaxChecker.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index 1b5c00c4..ab883a21 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -142,7 +142,7 @@ void SyntaxChecker::checkSingleStatementVariableDeclaration(ASTNode const* _stat { auto varDecl = dynamic_cast(_statement); if (varDecl) - m_errorReporter.syntaxError(_statement->location(), "Invalid variable declaration. Please declare it inside a block."); + m_errorReporter.syntaxError(_statement->location(), "Variable declarations can only be used inside blocks."); } bool SyntaxChecker::visit(IfStatement const& _ifStatement) -- cgit v1.2.3 From ac8892e0e3ab4e0152ba74c5857b79aec54e7f1b Mon Sep 17 00:00:00 2001 From: Leonardo Alt Date: Tue, 4 Sep 2018 12:14:04 +0200 Subject: Review suggestions --- libsolidity/analysis/SyntaxChecker.cpp | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index ab883a21..0bc20f2e 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -138,25 +138,25 @@ void SyntaxChecker::endVisit(ModifierDefinition const& _modifier) m_placeholderFound = false; } -void SyntaxChecker::checkSingleStatementVariableDeclaration(ASTNode const* _statement) +void SyntaxChecker::checkSingleStatementVariableDeclaration(ASTNode const& _statement) { - auto varDecl = dynamic_cast(_statement); + auto varDecl = dynamic_cast(&_statement); if (varDecl) - m_errorReporter.syntaxError(_statement->location(), "Variable declarations can only be used inside blocks."); + m_errorReporter.syntaxError(_statement.location(), "Variable declarations can only be used inside blocks."); } bool SyntaxChecker::visit(IfStatement const& _ifStatement) { - checkSingleStatementVariableDeclaration(&_ifStatement.trueStatement()); + checkSingleStatementVariableDeclaration(_ifStatement.trueStatement()); if (Statement const* _statement = _ifStatement.falseStatement()) - checkSingleStatementVariableDeclaration(_statement); + checkSingleStatementVariableDeclaration(*_statement); return true; } bool SyntaxChecker::visit(WhileStatement const& _whileStatement) { m_inLoopDepth++; - checkSingleStatementVariableDeclaration(&_whileStatement.body()); + checkSingleStatementVariableDeclaration(_whileStatement.body()); return true; } @@ -168,7 +168,7 @@ void SyntaxChecker::endVisit(WhileStatement const&) bool SyntaxChecker::visit(ForStatement const& _forStatement) { m_inLoopDepth++; - checkSingleStatementVariableDeclaration(&_forStatement.body()); + checkSingleStatementVariableDeclaration(_forStatement.body()); return true; } -- cgit v1.2.3 From 6a0b7759ba039e8a365566b722c462df62d732ce Mon Sep 17 00:00:00 2001 From: chriseth Date: Mon, 8 Oct 2018 22:58:34 +0200 Subject: Fix pragma error suggestion. --- libsolidity/analysis/SyntaxChecker.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index 0bc20f2e..d40a00d4 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -53,7 +53,7 @@ void SyntaxChecker::endVisit(SourceUnit const& _sourceUnit) SemVerVersion recommendedVersion{string(VersionString)}; if (!recommendedVersion.isPrerelease()) errorString += - "Consider adding \"pragma solidity ^" + + " Consider adding \"pragma solidity ^" + to_string(recommendedVersion.major()) + string(".") + to_string(recommendedVersion.minor()) + -- cgit v1.2.3 From fa0ce6a7e7abd5bbc9bad1dd15f54ea4e9b11f85 Mon Sep 17 00:00:00 2001 From: Alex Beregszaszi Date: Tue, 9 Oct 2018 04:29:37 +0100 Subject: Use empty() instead of size() == 0 --- libsolidity/analysis/SyntaxChecker.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index 0bc20f2e..b79fb156 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -76,7 +76,7 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma) { solAssert(m_sourceUnit, ""); vector literals(_pragma.literals().begin() + 1, _pragma.literals().end()); - if (literals.size() == 0) + if (literals.empty()) m_errorReporter.syntaxError( _pragma.location(), "Experimental feature name is missing." -- cgit v1.2.3 From f112377dd44e8281bff092639bb546ec8a6a39ac Mon Sep 17 00:00:00 2001 From: Christian Parpart Date: Mon, 22 Oct 2018 16:48:21 +0200 Subject: Refactor `solidity::Token` into an `enum class` with `TokenTraits` helper namespace --- libsolidity/analysis/SyntaxChecker.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'libsolidity/analysis/SyntaxChecker.cpp') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index ab544388..3f9f8373 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -106,7 +106,7 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma) } else if (_pragma.literals()[0] == "solidity") { - vector tokens(_pragma.tokens().begin() + 1, _pragma.tokens().end()); + vector tokens(_pragma.tokens().begin() + 1, _pragma.tokens().end()); vector literals(_pragma.literals().begin() + 1, _pragma.literals().end()); SemVerMatchExpressionParser parser(tokens, literals); auto matchExpression = parser.parse(); -- cgit v1.2.3