solidity/libsolidity/parsing/Parser.cpp

2371 lines
72 KiB
C++
Raw Normal View History

/*
2019-02-13 15:56:46 +00:00
This file is part of solidity.
2019-02-13 15:56:46 +00:00
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.
2019-02-13 15:56:46 +00:00
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.
2019-02-13 15:56:46 +00:00
You should have received a copy of the GNU General Public License
along with solidity. If not, see <http://www.gnu.org/licenses/>.
*/
// SPDX-License-Identifier: GPL-3.0
/**
* @author Christian <c@ethdev.com>
* @date 2014
* Solidity parser.
*/
2015-10-20 22:21:52 +00:00
#include <libsolidity/parsing/Parser.h>
2018-12-17 18:28:10 +00:00
2018-12-12 15:45:17 +00:00
#include <libsolidity/interface/Version.h>
#include <libyul/AST.h>
2021-04-27 14:53:04 +00:00
#include <libyul/AsmParser.h>
2018-12-06 23:56:16 +00:00
#include <libyul/backends/evm/EVMDialect.h>
#include <liblangutil/ErrorReporter.h>
#include <liblangutil/Scanner.h>
#include <liblangutil/SemVerHandler.h>
2018-12-17 18:28:10 +00:00
#include <liblangutil/SourceLocation.h>
#include <libyul/backends/evm/EVMDialect.h>
#include <boost/algorithm/string/trim.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <boost/algorithm/string/predicate.hpp>
2018-12-17 18:28:10 +00:00
#include <cctype>
#include <vector>
#include <regex>
2014-12-03 06:47:08 +00:00
using namespace std;
2019-12-11 16:31:36 +00:00
using namespace solidity::langutil;
2014-12-03 06:47:08 +00:00
2019-12-11 16:31:36 +00:00
namespace solidity::frontend
2014-10-16 12:08:54 +00:00
{
/// AST node factory that also tracks the begin and end position of an AST node
/// while it is being parsed
class Parser::ASTNodeFactory
{
public:
2019-09-11 19:16:35 +00:00
explicit ASTNodeFactory(Parser& _parser):
2021-06-29 12:38:59 +00:00
m_parser(_parser), m_location{
_parser.currentLocation().start,
-1,
_parser.currentLocation().sourceName
}
{}
2019-09-11 19:16:35 +00:00
ASTNodeFactory(Parser& _parser, ASTPointer<ASTNode> const& _childNode):
m_parser(_parser), m_location{_childNode->location()} {}
2014-10-13 16:22:15 +00:00
void markEndPosition() { m_location.end = m_parser.currentLocation().end; }
void setLocation(SourceLocation const& _location) { m_location = _location; }
2014-10-16 21:49:45 +00:00
void setLocationEmpty() { m_location.end = m_location.start; }
2014-10-09 10:28:37 +00:00
/// Set the end position to the one of the given node.
2015-08-31 16:44:29 +00:00
void setEndPositionFromNode(ASTPointer<ASTNode> const& _node) { m_location.end = _node->location().end; }
2014-10-09 10:28:37 +00:00
template <class NodeType, typename... Args>
ASTPointer<NodeType> createNode(Args&& ... _args)
2014-10-09 10:28:37 +00:00
{
2021-06-29 12:38:59 +00:00
solAssert(m_location.sourceName, "");
if (m_location.end < 0)
markEndPosition();
2019-09-11 19:16:35 +00:00
return make_shared<NodeType>(m_parser.nextID(), m_location, std::forward<Args>(_args)...);
2014-10-09 10:28:37 +00:00
}
SourceLocation const& location() const noexcept { return m_location; }
private:
2019-09-11 19:16:35 +00:00
Parser& m_parser;
SourceLocation m_location;
};
2021-07-14 10:53:39 +00:00
ASTPointer<SourceUnit> Parser::parse(CharStream& _charStream)
2014-12-03 06:46:55 +00:00
{
2019-09-11 19:16:35 +00:00
solAssert(!m_insideModifier, "");
2015-10-15 14:27:26 +00:00
try
{
2017-08-14 16:59:17 +00:00
m_recursionDepth = 0;
2021-07-14 10:53:39 +00:00
m_scanner = make_shared<Scanner>(_charStream);
ASTNodeFactory nodeFactory(*this);
vector<ASTPointer<ASTNode>> nodes;
while (m_scanner->currentToken() != Token::EOS)
2014-12-03 06:46:55 +00:00
{
switch (m_scanner->currentToken())
{
2016-08-19 17:57:21 +00:00
case Token::Pragma:
nodes.push_back(parsePragmaDirective());
break;
case Token::Import:
nodes.push_back(parseImportDirective());
break;
2019-09-04 22:01:13 +00:00
case Token::Abstract:
case Token::Interface:
case Token::Contract:
case Token::Library:
nodes.push_back(parseContractDefinition());
break;
2019-08-15 13:35:57 +00:00
case Token::Struct:
nodes.push_back(parseStructDefinition());
break;
2019-09-02 09:52:51 +00:00
case Token::Enum:
nodes.push_back(parseEnumDefinition());
break;
case Token::Type:
nodes.push_back(parseUserDefinedValueTypeDefinition());
break;
2021-10-11 08:16:52 +00:00
case Token::Using:
nodes.push_back(parseUsingDirective());
break;
2020-05-04 16:38:00 +00:00
case Token::Function:
nodes.push_back(parseFunctionDefinition(true));
break;
default:
2021-01-28 11:56:22 +00:00
if (
// Workaround because `error` is not a keyword.
m_scanner->currentToken() == Token::Identifier &&
currentLiteral() == "error" &&
m_scanner->peekNextToken() == Token::Identifier &&
m_scanner->peekNextNextToken() == Token::LParen
)
nodes.push_back(parseErrorDefinition());
2020-09-25 10:15:31 +00:00
// Constant variable.
2021-01-28 11:56:22 +00:00
else if (variableDeclarationStart() && m_scanner->peekNextToken() != Token::EOS)
2020-09-25 10:15:31 +00:00
{
VarDeclParserOptions options;
options.kind = VarDeclKind::FileLevel;
options.allowInitialValue = true;
nodes.push_back(parseVariableDeclaration(options));
expectToken(Token::Semicolon);
}
else
fatalParserError(7858_error, "Expected pragma, import directive or contract/interface/library/struct/enum/constant/function/error definition.");
}
2014-12-03 06:46:55 +00:00
}
2017-08-14 16:59:17 +00:00
solAssert(m_recursionDepth == 0, "");
return nodeFactory.createNode<SourceUnit>(findLicenseString(nodes), nodes);
}
2015-11-26 13:47:28 +00:00
catch (FatalError const&)
{
if (m_errorReporter.errors().empty())
throw; // Something is weird here, rather throw again.
return nullptr;
2014-12-03 06:46:55 +00:00
}
}
void Parser::parsePragmaVersion(SourceLocation const& _location, vector<Token> const& _tokens, vector<string> const& _literals)
2018-12-12 15:45:17 +00:00
{
SemVerMatchExpressionParser parser(_tokens, _literals);
2018-12-12 15:45:17 +00:00
auto matchExpression = parser.parse();
if (!matchExpression.has_value())
m_errorReporter.fatalParserError(
1684_error,
_location,
"Found version pragma, but failed to parse it. "
"Please ensure there is a trailing semicolon."
);
2018-12-12 15:45:17 +00:00
static SemVerVersion const currentVersion{string(VersionString)};
// FIXME: only match for major version incompatibility
if (!matchExpression->matches(currentVersion))
// If m_parserErrorRecovery is true, the same message will appear from SyntaxChecker::visit(),
// so we don't need to report anything here.
if (!m_parserErrorRecovery)
m_errorReporter.fatalParserError(
5333_error,
_location,
"Source file requires different compiler version (current compiler is " +
string(VersionString) + ") - note that nightly builds are considered to be "
"strictly less than the released version"
);
2018-12-12 15:45:17 +00:00
}
ASTPointer<StructuredDocumentation> Parser::parseStructuredDocumentation()
{
if (m_scanner->currentCommentLiteral() != "")
{
ASTNodeFactory nodeFactory{*this};
nodeFactory.setLocation(m_scanner->currentCommentLocation());
return nodeFactory.createNode<StructuredDocumentation>(
make_shared<ASTString>(m_scanner->currentCommentLiteral())
);
}
return nullptr;
}
2016-08-19 17:57:21 +00:00
ASTPointer<PragmaDirective> Parser::parsePragmaDirective()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2016-08-19 17:57:21 +00:00
// pragma anything* ;
// Currently supported:
// pragma solidity ^0.4.0 || ^0.3.0;
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Pragma);
vector<string> literals;
vector<Token> tokens;
2016-08-19 17:57:21 +00:00
do
{
Token token = m_scanner->currentToken();
2016-08-19 17:57:21 +00:00
if (token == Token::Illegal)
parserError(6281_error, "Token incompatible with Solidity parser as part of pragma directive.");
2016-08-19 17:57:21 +00:00
else
{
string literal = m_scanner->currentLiteral();
if (literal.empty() && TokenTraits::toString(token))
literal = TokenTraits::toString(token);
2016-08-19 17:57:21 +00:00
literals.push_back(literal);
tokens.push_back(token);
}
advance();
2016-08-19 17:57:21 +00:00
}
while (m_scanner->currentToken() != Token::Semicolon && m_scanner->currentToken() != Token::EOS);
nodeFactory.markEndPosition();
expectToken(Token::Semicolon);
2018-12-12 15:45:17 +00:00
if (literals.size() >= 1 && literals[0] == "solidity")
2018-12-12 15:45:17 +00:00
{
parsePragmaVersion(
nodeFactory.location(),
2018-12-12 15:45:17 +00:00
vector<Token>(tokens.begin() + 1, tokens.end()),
vector<string>(literals.begin() + 1, literals.end())
);
}
2016-08-19 17:57:21 +00:00
return nodeFactory.createNode<PragmaDirective>(tokens, literals);
}
2014-12-03 06:46:55 +00:00
ASTPointer<ImportDirective> Parser::parseImportDirective()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2015-12-14 17:01:40 +00:00
// import "abc" [as x];
// import * as x from "abc";
// import {a as b, c} from "abc";
2014-12-03 06:46:55 +00:00
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Import);
2015-12-14 17:01:40 +00:00
ASTPointer<ASTString> path;
2015-12-15 14:46:03 +00:00
ASTPointer<ASTString> unitAlias = make_shared<string>();
SourceLocation unitAliasLocation{};
ImportDirective::SymbolAliasList symbolAliases;
2015-12-14 17:01:40 +00:00
if (m_scanner->currentToken() == Token::StringLiteral)
{
path = getLiteralAndAdvance();
if (m_scanner->currentToken() == Token::As)
{
advance();
tie(unitAlias, unitAliasLocation) = expectIdentifierWithLocation();
2015-12-14 17:01:40 +00:00
}
}
else
{
if (m_scanner->currentToken() == Token::LBrace)
{
advance();
2015-12-14 17:01:40 +00:00
while (true)
{
ASTPointer<ASTString> alias;
SourceLocation aliasLocation = currentLocation();
ASTPointer<Identifier> id = parseIdentifier();
2015-12-14 17:01:40 +00:00
if (m_scanner->currentToken() == Token::As)
{
expectToken(Token::As);
tie(alias, aliasLocation) = expectIdentifierWithLocation();
2015-12-14 17:01:40 +00:00
}
symbolAliases.emplace_back(ImportDirective::SymbolAlias{move(id), move(alias), aliasLocation});
2015-12-14 17:01:40 +00:00
if (m_scanner->currentToken() != Token::Comma)
break;
advance();
2015-12-14 17:01:40 +00:00
}
expectToken(Token::RBrace);
}
else if (m_scanner->currentToken() == Token::Mul)
{
advance();
2015-12-14 17:01:40 +00:00
expectToken(Token::As);
tie(unitAlias, unitAliasLocation) = expectIdentifierWithLocation();
2015-12-14 17:01:40 +00:00
}
else
fatalParserError(9478_error, "Expected string literal (path), \"*\" or alias list.");
2015-12-14 17:01:40 +00:00
// "from" is not a keyword but parsed as an identifier because of backwards
// compatibility and because it is a really common word.
if (m_scanner->currentToken() != Token::Identifier || m_scanner->currentLiteral() != "from")
fatalParserError(8208_error, "Expected \"from\".");
advance();
2015-12-14 17:01:40 +00:00
if (m_scanner->currentToken() != Token::StringLiteral)
fatalParserError(6845_error, "Expected import path.");
2015-12-14 17:01:40 +00:00
path = getLiteralAndAdvance();
}
2019-01-25 01:59:42 +00:00
if (path->empty())
fatalParserError(6326_error, "Import path cannot be empty.");
2014-12-03 06:46:55 +00:00
nodeFactory.markEndPosition();
expectToken(Token::Semicolon);
return nodeFactory.createNode<ImportDirective>(path, unitAlias, unitAliasLocation, move(symbolAliases));
2014-12-03 06:46:55 +00:00
}
std::pair<ContractKind, bool> Parser::parseContractKind()
{
ContractKind kind;
2019-09-04 22:01:13 +00:00
bool abstract = false;
if (m_scanner->currentToken() == Token::Abstract)
{
abstract = true;
advance();
2019-09-04 22:01:13 +00:00
}
2019-11-11 16:09:59 +00:00
switch (m_scanner->currentToken())
{
case Token::Interface:
kind = ContractKind::Interface;
break;
case Token::Contract:
kind = ContractKind::Contract;
break;
case Token::Library:
kind = ContractKind::Library;
break;
default:
parserError(3515_error, "Expected keyword \"contract\", \"interface\" or \"library\".");
2020-02-05 11:14:14 +00:00
return std::make_pair(ContractKind::Contract, abstract);
}
advance();
2019-09-04 22:01:13 +00:00
return std::make_pair(kind, abstract);
2017-02-15 11:40:29 +00:00
}
ASTPointer<ContractDefinition> Parser::parseContractDefinition()
2017-02-15 11:40:29 +00:00
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2017-02-15 11:40:29 +00:00
ASTNodeFactory nodeFactory(*this);
ASTPointer<ASTString> name = nullptr;
SourceLocation nameLocation{};
ASTPointer<StructuredDocumentation> documentation;
vector<ASTPointer<InheritanceSpecifier>> baseContracts;
vector<ASTPointer<ASTNode>> subNodes;
std::pair<ContractKind, bool> contractKind{};
try
{
documentation = parseStructuredDocumentation();
contractKind = parseContractKind();
tie(name, nameLocation) = expectIdentifierWithLocation();
if (m_scanner->currentToken() == Token::Is)
do
{
advance();
baseContracts.push_back(parseInheritanceSpecifier());
}
while (m_scanner->currentToken() == Token::Comma);
expectToken(Token::LBrace);
while (true)
{
Token currentTokenValue = m_scanner->currentToken();
if (currentTokenValue == Token::RBrace)
break;
else if (
(currentTokenValue == Token::Function && m_scanner->peekNextToken() != Token::LParen) ||
currentTokenValue == Token::Constructor ||
currentTokenValue == Token::Receive ||
currentTokenValue == Token::Fallback
)
subNodes.push_back(parseFunctionDefinition());
else if (currentTokenValue == Token::Struct)
subNodes.push_back(parseStructDefinition());
else if (currentTokenValue == Token::Enum)
subNodes.push_back(parseEnumDefinition());
else if (currentTokenValue == Token::Type)
subNodes.push_back(parseUserDefinedValueTypeDefinition());
2021-01-28 11:56:22 +00:00
else if (
// Workaround because `error` is not a keyword.
currentTokenValue == Token::Identifier &&
currentLiteral() == "error" &&
m_scanner->peekNextToken() == Token::Identifier &&
m_scanner->peekNextNextToken() == Token::LParen
)
subNodes.push_back(parseErrorDefinition());
2020-09-25 10:15:31 +00:00
else if (variableDeclarationStart())
{
VarDeclParserOptions options;
2020-09-25 10:15:31 +00:00
options.kind = VarDeclKind::State;
options.allowInitialValue = true;
subNodes.push_back(parseVariableDeclaration(options));
expectToken(Token::Semicolon);
}
else if (currentTokenValue == Token::Modifier)
subNodes.push_back(parseModifierDefinition());
else if (currentTokenValue == Token::Event)
subNodes.push_back(parseEventDefinition());
else if (currentTokenValue == Token::Using)
subNodes.push_back(parseUsingDirective());
else
2020-05-08 23:45:02 +00:00
fatalParserError(9182_error, "Function, variable, struct or modifier declaration expected.");
}
}
catch (FatalError const&)
{
if (
!m_errorReporter.hasErrors() ||
!m_parserErrorRecovery ||
m_errorReporter.hasExcessiveErrors()
)
BOOST_THROW_EXCEPTION(FatalError()); /* Don't try to recover here. */
m_inParserRecovery = true;
2014-10-09 10:28:37 +00:00
}
nodeFactory.markEndPosition();
if (m_inParserRecovery)
expectTokenOrConsumeUntil(Token::RBrace, "ContractDefinition");
else
expectToken(Token::RBrace);
return nodeFactory.createNode<ContractDefinition>(
name,
nameLocation,
documentation,
baseContracts,
subNodes,
2019-09-04 22:01:13 +00:00
contractKind.first,
contractKind.second
);
}
ASTPointer<InheritanceSpecifier> Parser::parseInheritanceSpecifier()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
ASTPointer<IdentifierPath> name(parseIdentifierPath());
unique_ptr<vector<ASTPointer<Expression>>> arguments;
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() == Token::LParen)
{
advance();
2019-11-27 16:24:21 +00:00
arguments = make_unique<vector<ASTPointer<Expression>>>(parseFunctionCallListArguments());
nodeFactory.markEndPosition();
expectToken(Token::RParen);
}
else
nodeFactory.setEndPositionFromNode(name);
return nodeFactory.createNode<InheritanceSpecifier>(name, std::move(arguments));
}
2019-12-10 14:54:09 +00:00
Visibility Parser::parseVisibilitySpecifier()
2015-02-02 16:24:09 +00:00
{
2019-12-10 14:54:09 +00:00
Visibility visibility(Visibility::Default);
Token token = m_scanner->currentToken();
switch (token)
{
case Token::Public:
2019-12-10 14:54:09 +00:00
visibility = Visibility::Public;
break;
case Token::Internal:
2019-12-10 14:54:09 +00:00
visibility = Visibility::Internal;
break;
case Token::Private:
2019-12-10 14:54:09 +00:00
visibility = Visibility::Private;
break;
case Token::External:
2019-12-10 14:54:09 +00:00
visibility = Visibility::External;
break;
default:
solAssert(false, "Invalid visibility specifier.");
}
advance();
2015-02-02 16:24:09 +00:00
return visibility;
}
2019-08-13 11:00:46 +00:00
ASTPointer<OverrideSpecifier> Parser::parseOverrideSpecifier()
{
solAssert(m_scanner->currentToken() == Token::Override, "");
ASTNodeFactory nodeFactory(*this);
std::vector<ASTPointer<IdentifierPath>> overrides;
2019-08-13 11:00:46 +00:00
nodeFactory.markEndPosition();
advance();
2019-08-13 11:00:46 +00:00
if (m_scanner->currentToken() == Token::LParen)
{
advance();
2019-08-13 11:00:46 +00:00
while (true)
{
overrides.push_back(parseIdentifierPath());
2019-08-13 11:00:46 +00:00
if (m_scanner->currentToken() == Token::RParen)
break;
expectToken(Token::Comma);
}
nodeFactory.markEndPosition();
expectToken(Token::RParen);
}
return nodeFactory.createNode<OverrideSpecifier>(move(overrides));
}
StateMutability Parser::parseStateMutability()
{
StateMutability stateMutability(StateMutability::NonPayable);
Token token = m_scanner->currentToken();
2019-11-11 16:09:59 +00:00
switch (token)
2018-05-08 11:08:06 +00:00
{
case Token::Payable:
stateMutability = StateMutability::Payable;
break;
case Token::View:
stateMutability = StateMutability::View;
break;
case Token::Pure:
stateMutability = StateMutability::Pure;
break;
default:
solAssert(false, "Invalid state mutability specifier.");
2018-05-08 11:08:06 +00:00
}
advance();
return stateMutability;
}
Parser::FunctionHeaderParserResult Parser::parseFunctionHeader(bool _isStateVariable)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2016-09-27 19:37:32 +00:00
FunctionHeaderParserResult result;
VarDeclParserOptions options;
options.allowLocationSpecifier = true;
2016-09-27 19:37:32 +00:00
result.parameters = parseParameterList(options);
while (true)
2014-10-16 12:08:54 +00:00
{
Token token = m_scanner->currentToken();
if (!_isStateVariable && token == Token::Identifier)
result.modifiers.push_back(parseModifierInvocation());
else if (TokenTraits::isVisibilitySpecifier(token))
2015-02-02 16:24:09 +00:00
{
2019-12-10 14:54:09 +00:00
if (result.visibility != Visibility::Default)
{
2018-03-16 10:02:35 +00:00
// There is the special case of a public state variable of function type.
// Detect this and return early.
2019-12-10 14:54:09 +00:00
if (_isStateVariable && (result.visibility == Visibility::External || result.visibility == Visibility::Internal))
2018-03-16 10:02:35 +00:00
break;
parserError(
2020-05-08 23:45:02 +00:00
9439_error,
"Visibility already specified as \"" +
2017-08-09 13:29:03 +00:00
Declaration::visibilityToString(result.visibility) +
"\"."
2020-05-08 23:45:02 +00:00
);
advance();
}
else
result.visibility = parseVisibilitySpecifier();
2015-02-02 16:24:09 +00:00
}
else if (TokenTraits::isStateMutabilitySpecifier(token))
{
if (result.stateMutability != StateMutability::NonPayable)
{
parserError(
2020-05-08 23:45:02 +00:00
9680_error,
"State mutability already specified as \"" +
stateMutabilityToString(result.stateMutability) +
"\"."
2020-05-08 23:45:02 +00:00
);
advance();
}
else
result.stateMutability = parseStateMutability();
}
else if (!_isStateVariable && token == Token::Override)
2019-08-13 11:00:46 +00:00
{
if (result.overrides)
parserError(1827_error, "Override already specified.");
2019-08-13 11:00:46 +00:00
result.overrides = parseOverrideSpecifier();
}
2019-10-30 13:34:37 +00:00
else if (!_isStateVariable && token == Token::Virtual)
{
if (result.isVirtual)
parserError(6879_error, "Virtual already specified.");
2019-10-30 13:34:37 +00:00
result.isVirtual = true;
advance();
2019-10-30 13:34:37 +00:00
}
else
break;
2014-10-09 10:28:37 +00:00
}
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() == Token::Returns)
2014-10-16 12:08:54 +00:00
{
bool const permitEmptyParameterList = false;
advance();
2016-09-27 19:37:32 +00:00
result.returnParameters = parseParameterList(options, permitEmptyParameterList);
2014-10-16 12:08:54 +00:00
}
else
2016-09-27 19:37:32 +00:00
result.returnParameters = createEmptyParameterList();
return result;
}
2020-05-04 16:38:00 +00:00
ASTPointer<ASTNode> Parser::parseFunctionDefinition(bool _freeFunction)
2016-09-27 19:37:32 +00:00
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2016-09-27 19:37:32 +00:00
ASTNodeFactory nodeFactory(*this);
ASTPointer<StructuredDocumentation> documentation = parseStructuredDocumentation();
2016-09-27 19:37:32 +00:00
Token kind = m_scanner->currentToken();
ASTPointer<ASTString> name;
SourceLocation nameLocation;
if (kind == Token::Function)
{
advance();
if (
m_scanner->currentToken() == Token::Constructor ||
m_scanner->currentToken() == Token::Fallback ||
m_scanner->currentToken() == Token::Receive
)
2016-10-10 21:06:44 +00:00
{
std::string expected = std::map<Token, std::string>{
{Token::Constructor, "constructor"},
{Token::Fallback, "fallback function"},
{Token::Receive, "receive function"},
}.at(m_scanner->currentToken());
nameLocation = currentLocation();
name = make_shared<ASTString>(TokenTraits::toString(m_scanner->currentToken()));
string message{
"This function is named \"" + *name + "\" but is not the " + expected + " of the contract. "
"If you intend this to be a " + expected + ", use \"" + *name + "(...) { ... }\" without "
"the \"function\" keyword to define it."
};
if (m_scanner->currentToken() == Token::Constructor)
parserError(3323_error, message);
else
parserWarning(3445_error, message);
advance();
2016-10-10 21:06:44 +00:00
}
else
tie(name, nameLocation) = expectIdentifierWithLocation();
}
else
2016-10-10 21:06:44 +00:00
{
solAssert(kind == Token::Constructor || kind == Token::Fallback || kind == Token::Receive, "");
advance();
name = make_shared<ASTString>();
}
FunctionHeaderParserResult header = parseFunctionHeader(false);
ASTPointer<Block> block;
nodeFactory.markEndPosition();
if (m_scanner->currentToken() == Token::Semicolon)
advance();
else
{
block = parseBlock();
nodeFactory.setEndPositionFromNode(block);
2016-10-10 21:06:44 +00:00
}
return nodeFactory.createNode<FunctionDefinition>(
name,
nameLocation,
header.visibility,
header.stateMutability,
2020-05-04 16:38:00 +00:00
_freeFunction,
kind,
2019-10-30 13:34:37 +00:00
header.isVirtual,
header.overrides,
documentation,
header.parameters,
header.modifiers,
header.returnParameters,
block
);
}
ASTPointer<StructDefinition> Parser::parseStructDefinition()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2014-10-09 10:28:37 +00:00
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Struct);
auto [name, nameLocation] = expectIdentifierWithLocation();
2014-12-03 06:47:08 +00:00
vector<ASTPointer<VariableDeclaration>> members;
expectToken(Token::LBrace);
2015-08-31 16:44:29 +00:00
while (m_scanner->currentToken() != Token::RBrace)
2014-10-16 12:08:54 +00:00
{
2015-01-29 13:35:28 +00:00
members.push_back(parseVariableDeclaration());
expectToken(Token::Semicolon);
2014-10-09 10:28:37 +00:00
}
nodeFactory.markEndPosition();
expectToken(Token::RBrace);
return nodeFactory.createNode<StructDefinition>(move(name), move(nameLocation), move(members));
}
ASTPointer<EnumValue> Parser::parseEnumValue()
2015-02-09 17:08:56 +00:00
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2015-02-09 17:08:56 +00:00
ASTNodeFactory nodeFactory(*this);
nodeFactory.markEndPosition();
return nodeFactory.createNode<EnumValue>(expectIdentifierToken());
2015-02-09 17:08:56 +00:00
}
ASTPointer<EnumDefinition> Parser::parseEnumDefinition()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2015-02-09 17:08:56 +00:00
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Enum);
auto [name, nameLocation] = expectIdentifierWithLocation();
2015-02-13 16:34:46 +00:00
vector<ASTPointer<EnumValue>> members;
2015-02-09 17:08:56 +00:00
expectToken(Token::LBrace);
2015-08-31 16:44:29 +00:00
while (m_scanner->currentToken() != Token::RBrace)
2015-02-09 17:08:56 +00:00
{
members.push_back(parseEnumValue());
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() == Token::RBrace)
2015-02-09 17:08:56 +00:00
break;
expectToken(Token::Comma);
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() != Token::Identifier)
2020-05-08 23:45:02 +00:00
fatalParserError(1612_error, "Expected identifier after ','");
2015-02-09 17:08:56 +00:00
}
2018-10-09 03:29:37 +00:00
if (members.empty())
parserError(3147_error, "Enum with no members is not allowed.");
2015-02-09 17:08:56 +00:00
nodeFactory.markEndPosition();
expectToken(Token::RBrace);
return nodeFactory.createNode<EnumDefinition>(name, nameLocation, members);
2015-02-09 17:08:56 +00:00
}
ASTPointer<VariableDeclaration> Parser::parseVariableDeclaration(
VarDeclParserOptions const& _options,
ASTPointer<TypeName> const& _lookAheadArrayType
)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory = _lookAheadArrayType ?
ASTNodeFactory(*this, _lookAheadArrayType) : ASTNodeFactory(*this);
2020-07-15 17:50:59 +00:00
ASTPointer<StructuredDocumentation> const documentation = parseStructuredDocumentation();
2020-07-15 17:50:59 +00:00
ASTPointer<TypeName> type = _lookAheadArrayType ? _lookAheadArrayType : parseTypeName();
nodeFactory.setEndPositionFromNode(type);
2020-09-25 10:15:31 +00:00
if (dynamic_cast<FunctionTypeName*>(type.get()) && _options.kind == VarDeclKind::State && m_scanner->currentToken() == Token::LBrace)
fatalParserError(
2915_error,
"Expected a state variable declaration. If you intended this as a fallback function "
"or a function to handle plain ether transactions, use the \"fallback\" keyword "
"or the \"receive\" keyword instead."
);
2015-01-29 13:35:28 +00:00
bool isIndexed = false;
2020-04-07 09:10:10 +00:00
VariableDeclaration::Mutability mutability = VariableDeclaration::Mutability::Mutable;
2019-08-13 11:00:46 +00:00
ASTPointer<OverrideSpecifier> overrides = nullptr;
2019-12-10 14:54:09 +00:00
Visibility visibility(Visibility::Default);
VariableDeclaration::Location location = VariableDeclaration::Location::Unspecified;
ASTPointer<ASTString> identifier;
SourceLocation nameLocation{};
while (true)
{
Token token = m_scanner->currentToken();
2020-09-25 10:15:31 +00:00
if (_options.kind == VarDeclKind::State && TokenTraits::isVariableVisibilitySpecifier(token))
{
nodeFactory.markEndPosition();
2019-12-10 14:54:09 +00:00
if (visibility != Visibility::Default)
{
parserError(
2020-05-08 23:45:02 +00:00
4110_error,
"Visibility already specified as \"" +
2017-08-09 13:29:03 +00:00
Declaration::visibilityToString(visibility) +
"\"."
2020-05-08 23:45:02 +00:00
);
advance();
}
else
visibility = parseVisibilitySpecifier();
}
2020-09-25 10:15:31 +00:00
else if (_options.kind == VarDeclKind::State && token == Token::Override)
2019-08-13 11:00:46 +00:00
{
if (overrides)
parserError(9125_error, "Override already specified.");
2019-08-13 11:00:46 +00:00
overrides = parseOverrideSpecifier();
}
else
{
if (_options.allowIndexed && token == Token::Indexed)
isIndexed = true;
2020-02-27 15:13:55 +00:00
else if (token == Token::Constant || token == Token::Immutable)
{
2020-04-07 09:10:10 +00:00
if (mutability != VariableDeclaration::Mutability::Mutable)
2020-02-27 15:13:55 +00:00
parserError(
3109_error,
2020-04-07 09:10:10 +00:00
string("Mutability already set to ") +
(mutability == VariableDeclaration::Mutability::Constant ? "\"constant\"" : "\"immutable\"")
2020-02-27 15:13:55 +00:00
);
else if (token == Token::Constant)
2020-04-07 09:10:10 +00:00
mutability = VariableDeclaration::Mutability::Constant;
2020-02-27 15:13:55 +00:00
else if (token == Token::Immutable)
2020-04-07 09:10:10 +00:00
mutability = VariableDeclaration::Mutability::Immutable;
2020-02-27 15:13:55 +00:00
}
else if (_options.allowLocationSpecifier && TokenTraits::isLocationSpecifier(token))
{
if (location != VariableDeclaration::Location::Unspecified)
2020-05-08 23:45:02 +00:00
parserError(3548_error, "Location already specified.");
else
{
switch (token)
{
case Token::Storage:
location = VariableDeclaration::Location::Storage;
break;
case Token::Memory:
location = VariableDeclaration::Location::Memory;
break;
case Token::CallData:
location = VariableDeclaration::Location::CallData;
break;
default:
solAssert(false, "Unknown data location.");
}
}
}
else
break;
nodeFactory.markEndPosition();
advance();
}
}
2015-08-31 16:44:29 +00:00
if (_options.allowEmptyName && m_scanner->currentToken() != Token::Identifier)
identifier = make_shared<ASTString>("");
else
{
nodeFactory.markEndPosition();
tie(identifier, nameLocation) = expectIdentifierWithLocation();
}
ASTPointer<Expression> value;
if (_options.allowInitialValue)
{
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() == Token::Assign)
{
advance();
value = parseExpression();
nodeFactory.setEndPositionFromNode(value);
}
}
2015-06-05 12:45:47 +00:00
return nodeFactory.createNode<VariableDeclaration>(
type,
identifier,
nameLocation,
2015-06-05 12:45:47 +00:00
value,
visibility,
documentation,
2015-06-05 12:45:47 +00:00
isIndexed,
2020-04-07 09:10:10 +00:00
mutability,
2019-08-13 11:00:46 +00:00
overrides,
2015-06-05 12:45:47 +00:00
location
);
}
2015-01-21 10:16:18 +00:00
ASTPointer<ModifierDefinition> Parser::parseModifierDefinition()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2015-01-21 10:16:18 +00:00
ScopeGuard resetModifierFlag([this]() { m_insideModifier = false; });
m_insideModifier = true;
ASTNodeFactory nodeFactory(*this);
ASTPointer<StructuredDocumentation> documentation = parseStructuredDocumentation();
2015-01-21 10:16:18 +00:00
expectToken(Token::Modifier);
auto [name, nameLocation] = expectIdentifierWithLocation();
2015-01-21 10:16:18 +00:00
ASTPointer<ParameterList> parameters;
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() == Token::LParen)
{
VarDeclParserOptions options;
options.allowIndexed = true;
options.allowLocationSpecifier = true;
parameters = parseParameterList(options);
}
2015-01-21 10:16:18 +00:00
else
2015-01-30 20:43:19 +00:00
parameters = createEmptyParameterList();
ASTPointer<OverrideSpecifier> overrides;
2019-10-30 13:34:37 +00:00
bool isVirtual = false;
2019-11-05 17:25:34 +00:00
while (true)
2019-10-30 13:34:37 +00:00
{
if (m_scanner->currentToken() == Token::Override)
{
if (overrides)
parserError(9102_error, "Override already specified.");
2019-10-30 13:34:37 +00:00
overrides = parseOverrideSpecifier();
}
else if (m_scanner->currentToken() == Token::Virtual)
{
if (isVirtual)
parserError(2662_error, "Virtual already specified.");
2019-10-30 13:34:37 +00:00
isVirtual = true;
advance();
2019-10-30 13:34:37 +00:00
}
else
break;
}
ASTPointer<Block> block;
nodeFactory.markEndPosition();
if (m_scanner->currentToken() != Token::Semicolon)
{
block = parseBlock();
nodeFactory.setEndPositionFromNode(block);
}
else
advance(); // just consume the ';'
return nodeFactory.createNode<ModifierDefinition>(name, nameLocation, documentation, parameters, isVirtual, overrides, block);
}
pair<ASTPointer<ASTString>, SourceLocation> Parser::expectIdentifierWithLocation()
{
SourceLocation nameLocation = currentLocation();
ASTPointer<ASTString> name = expectIdentifierToken();
return {move(name), move(nameLocation)};
2015-01-21 10:16:18 +00:00
}
2015-01-29 13:35:28 +00:00
ASTPointer<EventDefinition> Parser::parseEventDefinition()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2015-01-29 13:35:28 +00:00
ASTNodeFactory nodeFactory(*this);
ASTPointer<StructuredDocumentation> documentation = parseStructuredDocumentation();
2015-01-29 13:35:28 +00:00
expectToken(Token::Event);
auto [name, nameLocation] = expectIdentifierWithLocation();
2017-11-09 03:02:39 +00:00
VarDeclParserOptions options;
options.allowIndexed = true;
ASTPointer<ParameterList> parameters = parseParameterList(options);
bool anonymous = false;
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() == Token::Anonymous)
{
anonymous = true;
advance();
}
2015-01-29 13:35:28 +00:00
nodeFactory.markEndPosition();
expectToken(Token::Semicolon);
return nodeFactory.createNode<EventDefinition>(name, nameLocation, documentation, parameters, anonymous);
2015-01-29 13:35:28 +00:00
}
2021-01-28 11:56:22 +00:00
ASTPointer<ErrorDefinition> Parser::parseErrorDefinition()
{
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
ASTPointer<StructuredDocumentation> documentation = parseStructuredDocumentation();
solAssert(*expectIdentifierToken() == "error", "");
auto&& [name, nameLocation] = expectIdentifierWithLocation();
ASTPointer<ParameterList> parameters = parseParameterList({});
nodeFactory.markEndPosition();
expectToken(Token::Semicolon);
return nodeFactory.createNode<ErrorDefinition>(name, move(nameLocation), documentation, parameters);
}
2015-11-22 19:39:10 +00:00
ASTPointer<UsingForDirective> Parser::parseUsingDirective()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2015-11-22 19:39:10 +00:00
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Using);
2021-10-11 08:16:52 +00:00
vector<ASTPointer<IdentifierPath>> functions;
bool const usesBraces = m_scanner->currentToken() == Token::LBrace;
if (usesBraces)
{
do
{
advance();
functions.emplace_back(parseIdentifierPath());
}
while (m_scanner->currentToken() == Token::Comma);
expectToken(Token::RBrace);
}
else
functions.emplace_back(parseIdentifierPath());
2015-11-22 19:39:10 +00:00
ASTPointer<TypeName> typeName;
expectToken(Token::For);
if (m_scanner->currentToken() == Token::Mul)
advance();
2015-11-22 19:39:10 +00:00
else
2020-07-15 17:50:59 +00:00
typeName = parseTypeName();
2021-11-16 16:01:09 +00:00
bool global = false;
if (m_scanner->currentToken() == Token::Identifier && currentLiteral() == "global")
{
global = true;
advance();
}
2015-11-22 19:39:10 +00:00
nodeFactory.markEndPosition();
expectToken(Token::Semicolon);
2021-11-16 16:01:09 +00:00
return nodeFactory.createNode<UsingForDirective>(move(functions), usesBraces, typeName, global);
2015-11-22 19:39:10 +00:00
}
ASTPointer<ModifierInvocation> Parser::parseModifierInvocation()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
ASTPointer<IdentifierPath> name(parseIdentifierPath());
unique_ptr<vector<ASTPointer<Expression>>> arguments;
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() == Token::LParen)
{
advance();
2019-11-27 16:24:21 +00:00
arguments = make_unique<vector<ASTPointer<Expression>>>(parseFunctionCallListArguments());
nodeFactory.markEndPosition();
expectToken(Token::RParen);
}
else
nodeFactory.setEndPositionFromNode(name);
return nodeFactory.createNode<ModifierInvocation>(name, move(arguments));
}
2015-01-28 10:28:22 +00:00
ASTPointer<Identifier> Parser::parseIdentifier()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2015-01-28 10:28:22 +00:00
ASTNodeFactory nodeFactory(*this);
nodeFactory.markEndPosition();
return nodeFactory.createNode<Identifier>(expectIdentifierToken());
}
2021-02-24 15:28:13 +00:00
ASTPointer<Identifier> Parser::parseIdentifierOrAddress()
{
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
nodeFactory.markEndPosition();
return nodeFactory.createNode<Identifier>(expectIdentifierTokenOrAddress());
}
ASTPointer<UserDefinedTypeName> Parser::parseUserDefinedTypeName()
2020-08-31 15:37:03 +00:00
{
ASTNodeFactory nodeFactory(*this);
ASTPointer<IdentifierPath> identifierPath = parseIdentifierPath();
nodeFactory.setEndPositionFromNode(identifierPath);
return nodeFactory.createNode<UserDefinedTypeName>(identifierPath);
}
ASTPointer<UserDefinedValueTypeDefinition> Parser::parseUserDefinedValueTypeDefinition()
{
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Type);
auto&& [name, nameLocation] = expectIdentifierWithLocation();
expectToken(Token::Is);
ASTPointer<TypeName> typeName = parseTypeName();
nodeFactory.markEndPosition();
expectToken(Token::Semicolon);
return nodeFactory.createNode<UserDefinedValueTypeDefinition>(
name,
move(nameLocation),
typeName
);
}
2020-08-31 15:37:03 +00:00
ASTPointer<IdentifierPath> Parser::parseIdentifierPath()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
nodeFactory.markEndPosition();
vector<ASTString> identifierPath{*expectIdentifierToken()};
while (m_scanner->currentToken() == Token::Period)
{
advance();
nodeFactory.markEndPosition();
2021-02-24 15:28:13 +00:00
identifierPath.push_back(*expectIdentifierTokenOrAddress());
}
2020-08-31 15:37:03 +00:00
return nodeFactory.createNode<IdentifierPath>(identifierPath);
}
2016-10-10 21:06:44 +00:00
ASTPointer<TypeName> Parser::parseTypeNameSuffix(ASTPointer<TypeName> type, ASTNodeFactory& nodeFactory)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2016-10-10 21:06:44 +00:00
while (m_scanner->currentToken() == Token::LBrack)
{
advance();
2016-10-10 21:06:44 +00:00
ASTPointer<Expression> length;
if (m_scanner->currentToken() != Token::RBrack)
length = parseExpression();
nodeFactory.markEndPosition();
expectToken(Token::RBrack);
type = nodeFactory.createNode<ArrayTypeName>(type, length);
}
return type;
}
2020-07-15 17:50:59 +00:00
ASTPointer<TypeName> Parser::parseTypeName()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
ASTPointer<TypeName> type;
Token token = m_scanner->currentToken();
if (TokenTraits::isElementaryTypeName(token))
2014-10-16 12:08:54 +00:00
{
unsigned firstSize;
unsigned secondSize;
tie(firstSize, secondSize) = m_scanner->currentTokenInfo();
ElementaryTypeNameToken elemTypeName(token, firstSize, secondSize);
ASTNodeFactory nodeFactory(*this);
nodeFactory.markEndPosition();
advance();
auto stateMutability = elemTypeName.token() == Token::Address
? optional<StateMutability>{StateMutability::NonPayable}
: nullopt;
if (TokenTraits::isStateMutabilitySpecifier(m_scanner->currentToken()))
{
if (elemTypeName.token() == Token::Address)
{
nodeFactory.markEndPosition();
stateMutability = parseStateMutability();
}
else
{
parserError(9106_error, "State mutability can only be specified for address types.");
advance();
}
}
type = nodeFactory.createNode<ElementaryTypeName>(elemTypeName, stateMutability);
2014-10-16 12:08:54 +00:00
}
2016-09-27 19:37:32 +00:00
else if (token == Token::Function)
type = parseFunctionType();
else if (token == Token::Mapping)
2014-10-09 10:28:37 +00:00
type = parseMapping();
else if (token == Token::Identifier)
type = parseUserDefinedTypeName();
2014-10-16 12:08:54 +00:00
else
2020-05-08 23:45:02 +00:00
fatalParserError(3546_error, "Expected type name");
2020-07-15 17:50:59 +00:00
solAssert(type, "");
// Parse "[...]" postfixes for arrays.
type = parseTypeNameSuffix(type, nodeFactory);
2014-10-09 10:28:37 +00:00
return type;
}
2016-09-27 19:37:32 +00:00
ASTPointer<FunctionTypeName> Parser::parseFunctionType()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2016-09-27 19:37:32 +00:00
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Function);
FunctionHeaderParserResult header = parseFunctionHeader(true);
2016-09-27 19:37:32 +00:00
return nodeFactory.createNode<FunctionTypeName>(
header.parameters,
header.returnParameters,
header.visibility,
header.stateMutability
2016-09-27 19:37:32 +00:00
);
}
ASTPointer<Mapping> Parser::parseMapping()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2014-10-09 10:28:37 +00:00
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Mapping);
expectToken(Token::LParen);
ASTPointer<TypeName> keyType;
Token token = m_scanner->currentToken();
unsigned firstSize;
unsigned secondSize;
tie(firstSize, secondSize) = m_scanner->currentTokenInfo();
if (token == Token::Identifier)
keyType = parseUserDefinedTypeName();
else if (TokenTraits::isElementaryTypeName(token))
{
keyType = ASTNodeFactory(*this).createNode<ElementaryTypeName>(
ElementaryTypeNameToken{token, firstSize, secondSize}
);
advance();
}
else
2020-05-08 23:45:02 +00:00
fatalParserError(1005_error, "Expected elementary type name or identifier for mapping key type");
2020-08-27 10:42:00 +00:00
expectToken(Token::DoubleArrow);
2020-07-15 17:50:59 +00:00
ASTPointer<TypeName> valueType = parseTypeName();
2014-10-09 10:28:37 +00:00
nodeFactory.markEndPosition();
expectToken(Token::RParen);
2014-10-09 10:28:37 +00:00
return nodeFactory.createNode<Mapping>(keyType, valueType);
}
ASTPointer<ParameterList> Parser::parseParameterList(
VarDeclParserOptions const& _options,
bool _allowEmpty
)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2014-10-09 10:28:37 +00:00
ASTNodeFactory nodeFactory(*this);
2014-12-03 06:47:08 +00:00
vector<ASTPointer<VariableDeclaration>> parameters;
VarDeclParserOptions options(_options);
options.allowEmptyName = true;
expectToken(Token::LParen);
2015-08-31 16:44:29 +00:00
if (!_allowEmpty || m_scanner->currentToken() != Token::RParen)
2014-10-16 12:08:54 +00:00
{
2015-01-29 13:35:28 +00:00
parameters.push_back(parseVariableDeclaration(options));
2015-08-31 16:44:29 +00:00
while (m_scanner->currentToken() != Token::RParen)
2014-10-16 12:08:54 +00:00
{
if (m_scanner->currentToken() == Token::Comma && m_scanner->peekNextToken() == Token::RParen)
fatalParserError(7591_error, "Unexpected trailing comma in parameter list.");
expectToken(Token::Comma);
2015-01-29 13:35:28 +00:00
parameters.push_back(parseVariableDeclaration(options));
2014-10-09 10:28:37 +00:00
}
}
nodeFactory.markEndPosition();
advance();
2014-10-09 10:28:37 +00:00
return nodeFactory.createNode<ParameterList>(parameters);
}
2020-07-22 08:28:04 +00:00
ASTPointer<Block> Parser::parseBlock(bool _allowUnchecked, ASTPointer<ASTString> const& _docString)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2014-10-09 10:28:37 +00:00
ASTNodeFactory nodeFactory(*this);
2020-07-22 08:28:04 +00:00
bool const unchecked = m_scanner->currentToken() == Token::Unchecked;
if (unchecked)
{
if (!_allowUnchecked)
parserError(5296_error, "\"unchecked\" blocks can only be used inside regular blocks.");
advance();
2020-07-22 08:28:04 +00:00
}
expectToken(Token::LBrace);
2014-12-03 06:47:08 +00:00
vector<ASTPointer<Statement>> statements;
try
{
while (m_scanner->currentToken() != Token::RBrace)
2020-07-22 08:28:04 +00:00
statements.push_back(parseStatement(true));
nodeFactory.markEndPosition();
}
catch (FatalError const&)
{
if (
!m_errorReporter.hasErrors() ||
!m_parserErrorRecovery ||
m_errorReporter.hasExcessiveErrors()
)
BOOST_THROW_EXCEPTION(FatalError()); /* Don't try to recover here. */
m_inParserRecovery = true;
}
if (m_inParserRecovery)
expectTokenOrConsumeUntil(Token::RBrace, "Block");
else
expectToken(Token::RBrace);
2020-07-22 08:28:04 +00:00
return nodeFactory.createNode<Block>(_docString, unchecked, statements);
2014-10-09 10:28:37 +00:00
}
2020-07-22 08:28:04 +00:00
ASTPointer<Statement> Parser::parseStatement(bool _allowUnchecked)
2014-10-09 10:28:37 +00:00
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2015-10-26 16:20:29 +00:00
ASTPointer<ASTString> docString;
ASTPointer<Statement> statement;
try
{
if (m_scanner->currentCommentLiteral() != "")
docString = make_shared<ASTString>(m_scanner->currentCommentLiteral());
switch (m_scanner->currentToken())
{
case Token::If:
return parseIfStatement(docString);
case Token::While:
return parseWhileStatement(docString);
case Token::Do:
return parseDoWhileStatement(docString);
case Token::For:
return parseForStatement(docString);
2020-07-22 08:28:04 +00:00
case Token::Unchecked:
case Token::LBrace:
2020-07-22 08:28:04 +00:00
return parseBlock(_allowUnchecked, docString);
case Token::Continue:
statement = ASTNodeFactory(*this).createNode<Continue>(docString);
advance();
break;
case Token::Break:
statement = ASTNodeFactory(*this).createNode<Break>(docString);
advance();
break;
case Token::Return:
{
ASTNodeFactory nodeFactory(*this);
ASTPointer<Expression> expression;
if (advance() != Token::Semicolon)
{
expression = parseExpression();
nodeFactory.setEndPositionFromNode(expression);
}
statement = nodeFactory.createNode<Return>(docString, expression);
break;
2019-09-03 14:06:00 +00:00
}
case Token::Throw:
2019-09-03 14:06:00 +00:00
{
statement = ASTNodeFactory(*this).createNode<Throw>(docString);
advance();
2019-09-03 14:06:00 +00:00
break;
}
case Token::Try:
return parseTryStatement(docString);
case Token::Assembly:
return parseInlineAssembly(docString);
case Token::Emit:
statement = parseEmitStatement(docString);
break;
case Token::Identifier:
2021-02-24 09:55:49 +00:00
if (m_scanner->currentLiteral() == "revert" && m_scanner->peekNextToken() == Token::Identifier)
statement = parseRevertStatement(docString);
else if (m_insideModifier && m_scanner->currentLiteral() == "_")
{
statement = ASTNodeFactory(*this).createNode<PlaceholderStatement>(docString);
advance();
2021-02-24 09:55:49 +00:00
}
else
statement = parseSimpleStatement(docString);
break;
default:
statement = parseSimpleStatement(docString);
break;
}
2014-10-16 12:08:54 +00:00
}
catch (FatalError const&)
2015-09-15 14:33:14 +00:00
{
if (
!m_errorReporter.hasErrors() ||
!m_parserErrorRecovery ||
m_errorReporter.hasExcessiveErrors()
)
BOOST_THROW_EXCEPTION(FatalError()); /* Don't try to recover here. */
m_inParserRecovery = true;
}
if (m_inParserRecovery)
expectTokenOrConsumeUntil(Token::Semicolon, "Statement");
else
expectToken(Token::Semicolon);
return statement;
}
2016-02-22 01:13:41 +00:00
ASTPointer<InlineAssembly> Parser::parseInlineAssembly(ASTPointer<ASTString> const& _docString)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
SourceLocation location = currentLocation();
2016-02-22 01:13:41 +00:00
expectToken(Token::Assembly);
yul::Dialect const& dialect = yul::EVMDialect::strictAssemblyForEVM(m_evmVersion);
if (m_scanner->currentToken() == Token::StringLiteral)
{
if (m_scanner->currentLiteral() != "evmasm")
fatalParserError(4531_error, "Only \"evmasm\" supported.");
// This can be used in the future to set the dialect.
advance();
}
2016-02-22 01:13:41 +00:00
ASTPointer<vector<ASTPointer<ASTString>>> flags;
if (m_scanner->currentToken() == Token::LParen)
{
flags = make_shared<vector<ASTPointer<ASTString>>>();
do
{
advance();
expectToken(Token::StringLiteral, false);
flags->emplace_back(make_shared<ASTString>(m_scanner->currentLiteral()));
advance();
}
while (m_scanner->currentToken() == Token::Comma);
expectToken(Token::RParen);
}
yul::Parser asmParser(m_errorReporter, dialect);
2021-08-03 13:36:00 +00:00
shared_ptr<yul::Block> block = asmParser.parseInline(m_scanner);
if (block == nullptr)
BOOST_THROW_EXCEPTION(FatalError());
location.end = nativeLocationOf(*block).end;
return make_shared<InlineAssembly>(nextID(), location, _docString, dialect, move(flags), block);
2016-02-22 01:13:41 +00:00
}
2015-10-26 16:20:29 +00:00
ASTPointer<IfStatement> Parser::parseIfStatement(ASTPointer<ASTString> const& _docString)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
expectToken(Token::If);
expectToken(Token::LParen);
ASTPointer<Expression> condition = parseExpression();
expectToken(Token::RParen);
ASTPointer<Statement> trueBody = parseStatement();
ASTPointer<Statement> falseBody;
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() == Token::Else)
2014-10-16 12:08:54 +00:00
{
advance();
falseBody = parseStatement();
nodeFactory.setEndPositionFromNode(falseBody);
2014-10-16 12:08:54 +00:00
}
else
nodeFactory.setEndPositionFromNode(trueBody);
2015-10-26 16:20:29 +00:00
return nodeFactory.createNode<IfStatement>(_docString, condition, trueBody, falseBody);
}
2019-09-03 14:06:00 +00:00
ASTPointer<TryStatement> Parser::parseTryStatement(ASTPointer<ASTString> const& _docString)
{
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Try);
ASTPointer<Expression> externalCall = parseExpression();
vector<ASTPointer<TryCatchClause>> clauses;
ASTNodeFactory successClauseFactory(*this);
ASTPointer<ParameterList> returnsParameters;
if (m_scanner->currentToken() == Token::Returns)
{
advance();
2019-09-03 14:06:00 +00:00
VarDeclParserOptions options;
options.allowEmptyName = true;
options.allowLocationSpecifier = true;
returnsParameters = parseParameterList(options, false);
}
ASTPointer<Block> successBlock = parseBlock();
successClauseFactory.setEndPositionFromNode(successBlock);
clauses.emplace_back(successClauseFactory.createNode<TryCatchClause>(
make_shared<ASTString>(), returnsParameters, successBlock
));
do
{
clauses.emplace_back(parseCatchClause());
}
while (m_scanner->currentToken() == Token::Catch);
nodeFactory.setEndPositionFromNode(clauses.back());
return nodeFactory.createNode<TryStatement>(
_docString, externalCall, clauses
);
}
ASTPointer<TryCatchClause> Parser::parseCatchClause()
{
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Catch);
ASTPointer<ASTString> errorName = make_shared<string>();
ASTPointer<ParameterList> errorParameters;
if (m_scanner->currentToken() != Token::LBrace)
{
if (m_scanner->currentToken() == Token::Identifier)
errorName = expectIdentifierToken();
VarDeclParserOptions options;
options.allowEmptyName = true;
options.allowLocationSpecifier = true;
errorParameters = parseParameterList(options, !errorName->empty());
}
ASTPointer<Block> block = parseBlock();
nodeFactory.setEndPositionFromNode(block);
return nodeFactory.createNode<TryCatchClause>(errorName, errorParameters, block);
}
2015-10-26 16:20:29 +00:00
ASTPointer<WhileStatement> Parser::parseWhileStatement(ASTPointer<ASTString> const& _docString)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
expectToken(Token::While);
expectToken(Token::LParen);
ASTPointer<Expression> condition = parseExpression();
expectToken(Token::RParen);
ASTPointer<Statement> body = parseStatement();
nodeFactory.setEndPositionFromNode(body);
return nodeFactory.createNode<WhileStatement>(_docString, condition, body, false);
}
ASTPointer<WhileStatement> Parser::parseDoWhileStatement(ASTPointer<ASTString> const& _docString)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Do);
ASTPointer<Statement> body = parseStatement();
expectToken(Token::While);
expectToken(Token::LParen);
ASTPointer<Expression> condition = parseExpression();
expectToken(Token::RParen);
nodeFactory.markEndPosition();
expectToken(Token::Semicolon);
return nodeFactory.createNode<WhileStatement>(_docString, condition, body, true);
}
2015-10-26 16:20:29 +00:00
ASTPointer<ForStatement> Parser::parseForStatement(ASTPointer<ASTString> const& _docString)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
ASTPointer<Statement> initExpression;
ASTPointer<Expression> conditionExpression;
ASTPointer<ExpressionStatement> loopExpression;
expectToken(Token::For);
expectToken(Token::LParen);
2020-05-01 22:37:25 +00:00
// TODO: Maybe here have some predicate like peekExpression() instead of checking for semicolon and RParen?
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() != Token::Semicolon)
2015-10-26 16:20:29 +00:00
initExpression = parseSimpleStatement(ASTPointer<ASTString>());
expectToken(Token::Semicolon);
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() != Token::Semicolon)
conditionExpression = parseExpression();
expectToken(Token::Semicolon);
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() != Token::RParen)
2015-10-26 16:20:29 +00:00
loopExpression = parseExpressionStatement(ASTPointer<ASTString>());
expectToken(Token::RParen);
ASTPointer<Statement> body = parseStatement();
nodeFactory.setEndPositionFromNode(body);
2015-10-26 16:20:29 +00:00
return nodeFactory.createNode<ForStatement>(
_docString,
initExpression,
conditionExpression,
loopExpression,
body
);
}
2018-02-16 15:55:21 +00:00
ASTPointer<EmitStatement> Parser::parseEmitStatement(ASTPointer<ASTString> const& _docString)
{
expectToken(Token::Emit, false);
2018-02-16 15:55:21 +00:00
ASTNodeFactory nodeFactory(*this);
advance();
2018-02-16 15:55:21 +00:00
ASTNodeFactory eventCallNodeFactory(*this);
if (m_scanner->currentToken() != Token::Identifier)
fatalParserError(5620_error, "Expected event name or path.");
2018-02-16 15:55:21 +00:00
2018-04-26 08:42:56 +00:00
IndexAccessedPath iap;
2018-02-16 15:55:21 +00:00
while (true)
{
2018-04-26 08:42:56 +00:00
iap.path.push_back(parseIdentifier());
2018-02-16 15:55:21 +00:00
if (m_scanner->currentToken() != Token::Period)
break;
advance();
}
2018-02-16 15:55:21 +00:00
2018-04-26 08:42:56 +00:00
auto eventName = expressionFromIndexAccessStructure(iap);
2018-02-16 15:55:21 +00:00
expectToken(Token::LParen);
vector<ASTPointer<Expression>> arguments;
vector<ASTPointer<ASTString>> names;
std::tie(arguments, names) = parseFunctionCallArguments();
eventCallNodeFactory.markEndPosition();
nodeFactory.markEndPosition();
expectToken(Token::RParen);
auto eventCall = eventCallNodeFactory.createNode<FunctionCall>(eventName, arguments, names);
2021-02-24 09:55:49 +00:00
return nodeFactory.createNode<EmitStatement>(_docString, eventCall);
}
ASTPointer<RevertStatement> Parser::parseRevertStatement(ASTPointer<ASTString> const& _docString)
{
ASTNodeFactory nodeFactory(*this);
solAssert(*expectIdentifierToken() == "revert", "");
ASTNodeFactory errorCallNodeFactory(*this);
solAssert(m_scanner->currentToken() == Token::Identifier, "");
IndexAccessedPath iap;
while (true)
{
iap.path.push_back(parseIdentifier());
if (m_scanner->currentToken() != Token::Period)
break;
advance();
2021-02-24 09:55:49 +00:00
}
auto errorName = expressionFromIndexAccessStructure(iap);
expectToken(Token::LParen);
vector<ASTPointer<Expression>> arguments;
vector<ASTPointer<ASTString>> names;
std::tie(arguments, names) = parseFunctionCallArguments();
errorCallNodeFactory.markEndPosition();
nodeFactory.markEndPosition();
expectToken(Token::RParen);
auto errorCall = errorCallNodeFactory.createNode<FunctionCall>(errorName, arguments, names);
return nodeFactory.createNode<RevertStatement>(_docString, errorCall);
2018-02-16 15:55:21 +00:00
}
2015-10-26 16:20:29 +00:00
ASTPointer<Statement> Parser::parseSimpleStatement(ASTPointer<ASTString> const& _docString)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2018-04-27 22:26:56 +00:00
LookAheadInfo statementType;
IndexAccessedPath iap;
if (m_scanner->currentToken() == Token::LParen)
2018-04-27 22:26:56 +00:00
{
ASTNodeFactory nodeFactory(*this);
size_t emptyComponents = 0;
// First consume all empty components.
expectToken(Token::LParen);
while (m_scanner->currentToken() == Token::Comma)
{
advance();
emptyComponents++;
}
// Now see whether we have a variable declaration or an expression.
tie(statementType, iap) = tryParseIndexAccessedPath();
switch (statementType)
{
case LookAheadInfo::VariableDeclaration:
{
vector<ASTPointer<VariableDeclaration>> variables;
ASTPointer<Expression> value;
// We have already parsed something like `(,,,,a.b.c[2][3]`
VarDeclParserOptions options;
options.allowLocationSpecifier = true;
variables = vector<ASTPointer<VariableDeclaration>>(emptyComponents, nullptr);
variables.push_back(parseVariableDeclaration(options, typeNameFromIndexAccessStructure(iap)));
while (m_scanner->currentToken() != Token::RParen)
{
expectToken(Token::Comma);
if (m_scanner->currentToken() == Token::Comma || m_scanner->currentToken() == Token::RParen)
variables.push_back(nullptr);
else
variables.push_back(parseVariableDeclaration(options));
}
expectToken(Token::RParen);
expectToken(Token::Assign);
value = parseExpression();
nodeFactory.setEndPositionFromNode(value);
return nodeFactory.createNode<VariableDeclarationStatement>(_docString, variables, value);
}
case LookAheadInfo::Expression:
{
// Complete parsing the expression in the current component.
vector<ASTPointer<Expression>> components(emptyComponents, nullptr);
components.push_back(parseExpression(expressionFromIndexAccessStructure(iap)));
while (m_scanner->currentToken() != Token::RParen)
{
expectToken(Token::Comma);
if (m_scanner->currentToken() == Token::Comma || m_scanner->currentToken() == Token::RParen)
components.push_back(ASTPointer<Expression>());
else
components.push_back(parseExpression());
}
nodeFactory.markEndPosition();
expectToken(Token::RParen);
return parseExpressionStatement(_docString, nodeFactory.createNode<TupleExpression>(components, false));
}
default:
solAssert(false, "");
}
}
else
{
tie(statementType, iap) = tryParseIndexAccessedPath();
switch (statementType)
{
case LookAheadInfo::VariableDeclaration:
return parseVariableDeclarationStatement(_docString, typeNameFromIndexAccessStructure(iap));
case LookAheadInfo::Expression:
return parseExpressionStatement(_docString, expressionFromIndexAccessStructure(iap));
default:
solAssert(false, "");
}
2018-04-27 22:26:56 +00:00
}
}
bool Parser::IndexAccessedPath::empty() const
{
if (!indices.empty())
{
solAssert(!path.empty(), "");
}
return path.empty() && indices.empty();
}
2018-04-27 22:26:56 +00:00
pair<Parser::LookAheadInfo, Parser::IndexAccessedPath> Parser::tryParseIndexAccessedPath()
{
// These two cases are very hard to distinguish:
2018-04-27 22:26:56 +00:00
// x[7 * 20 + 3] a; and x[7 * 20 + 3] = 9;
// In the first case, x is a type name, in the second it is the name of a variable.
// As an extension, we can even have:
// `x.y.z[1][2] a;` and `x.y.z[1][2] = 10;`
// Where in the first, x.y.z leads to a type name where in the second, it accesses structs.
2018-04-27 22:26:56 +00:00
auto statementType = peekStatementType();
switch (statementType)
2015-02-23 13:38:44 +00:00
{
2018-04-27 22:26:56 +00:00
case LookAheadInfo::VariableDeclaration:
case LookAheadInfo::Expression:
return make_pair(statementType, IndexAccessedPath());
2015-02-23 13:55:06 +00:00
default:
break;
2015-02-23 13:38:44 +00:00
}
2018-04-26 08:42:56 +00:00
// At this point, we have 'Identifier "["' or 'Identifier "." Identifier' or 'ElementoryTypeName "["'.
2018-04-26 08:42:56 +00:00
// We parse '(Identifier ("." Identifier)* |ElementaryTypeName) ( "[" Expression "]" )*'
// until we can decide whether to hand this over to ExpressionStatement or create a
// VariableDeclarationStatement out of it.
2018-04-26 08:42:56 +00:00
IndexAccessedPath iap = parseIndexAccessedPath();
if (m_scanner->currentToken() == Token::Identifier || TokenTraits::isLocationSpecifier(m_scanner->currentToken()))
2018-04-27 22:26:56 +00:00
return make_pair(LookAheadInfo::VariableDeclaration, move(iap));
else
2018-04-27 22:26:56 +00:00
return make_pair(LookAheadInfo::Expression, move(iap));
}
ASTPointer<VariableDeclarationStatement> Parser::parseVariableDeclarationStatement(
2015-10-26 16:20:29 +00:00
ASTPointer<ASTString> const& _docString,
2015-09-25 14:47:40 +00:00
ASTPointer<TypeName> const& _lookAheadArrayType
)
{
// This does not parse multi variable declaration statements starting directly with
// `(`, they are parsed in parseSimpleStatement, because they are hard to distinguish
// from tuple expressions.
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
if (_lookAheadArrayType)
nodeFactory.setLocation(_lookAheadArrayType->location());
2020-07-15 17:50:59 +00:00
VarDeclParserOptions options;
options.allowLocationSpecifier = true;
vector<ASTPointer<VariableDeclaration>> variables;
2020-07-15 17:50:59 +00:00
variables.emplace_back(parseVariableDeclaration(options, _lookAheadArrayType));
nodeFactory.setEndPositionFromNode(variables.back());
ASTPointer<Expression> value;
if (m_scanner->currentToken() == Token::Assign)
{
advance();
value = parseExpression();
nodeFactory.setEndPositionFromNode(value);
}
2015-10-26 16:20:29 +00:00
return nodeFactory.createNode<VariableDeclarationStatement>(_docString, variables, value);
}
ASTPointer<ExpressionStatement> Parser::parseExpressionStatement(
2015-10-26 16:20:29 +00:00
ASTPointer<ASTString> const& _docString,
2018-04-27 22:17:35 +00:00
ASTPointer<Expression> const& _partialParserResult
2015-09-25 14:47:40 +00:00
)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2018-04-27 22:17:35 +00:00
ASTPointer<Expression> expression = parseExpression(_partialParserResult);
2015-10-26 16:20:29 +00:00
return ASTNodeFactory(*this, expression).createNode<ExpressionStatement>(_docString, expression);
}
ASTPointer<Expression> Parser::parseExpression(
2018-04-27 22:17:35 +00:00
ASTPointer<Expression> const& _partiallyParsedExpression
2015-09-25 14:47:40 +00:00
)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2018-04-27 22:17:35 +00:00
ASTPointer<Expression> expression = parseBinaryExpression(4, _partiallyParsedExpression);
if (TokenTraits::isAssignmentOp(m_scanner->currentToken()))
{
Token assignmentOperator = m_scanner->currentToken();
advance();
ASTPointer<Expression> rightHandSide = parseExpression();
ASTNodeFactory nodeFactory(*this, expression);
nodeFactory.setEndPositionFromNode(rightHandSide);
return nodeFactory.createNode<Assignment>(expression, assignmentOperator, rightHandSide);
}
else if (m_scanner->currentToken() == Token::Conditional)
{
advance();
ASTPointer<Expression> trueExpression = parseExpression();
expectToken(Token::Colon);
ASTPointer<Expression> falseExpression = parseExpression();
ASTNodeFactory nodeFactory(*this, expression);
nodeFactory.setEndPositionFromNode(falseExpression);
return nodeFactory.createNode<Conditional>(expression, trueExpression, falseExpression);
}
else
return expression;
}
2015-09-25 14:47:40 +00:00
ASTPointer<Expression> Parser::parseBinaryExpression(
int _minPrecedence,
2018-04-27 22:17:35 +00:00
ASTPointer<Expression> const& _partiallyParsedExpression
2015-09-25 14:47:40 +00:00
)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2018-04-27 22:17:35 +00:00
ASTPointer<Expression> expression = parseUnaryExpression(_partiallyParsedExpression);
ASTNodeFactory nodeFactory(*this, expression);
int precedence = TokenTraits::precedence(m_scanner->currentToken());
2014-10-16 12:08:54 +00:00
for (; precedence >= _minPrecedence; --precedence)
while (TokenTraits::precedence(m_scanner->currentToken()) == precedence)
2014-10-16 12:08:54 +00:00
{
Token op = m_scanner->currentToken();
advance();
static_assert(TokenTraits::hasExpHighestPrecedence(), "Exp does not have the highest precedence");
// Parse a**b**c as a**(b**c)
ASTPointer<Expression> right = (op == Token::Exp) ?
parseBinaryExpression(precedence) :
parseBinaryExpression(precedence + 1);
nodeFactory.setEndPositionFromNode(right);
expression = nodeFactory.createNode<BinaryOperation>(expression, op, right);
}
return expression;
}
ASTPointer<Expression> Parser::parseUnaryExpression(
2018-04-27 22:17:35 +00:00
ASTPointer<Expression> const& _partiallyParsedExpression
2015-09-25 14:47:40 +00:00
)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2018-04-27 22:17:35 +00:00
ASTNodeFactory nodeFactory = _partiallyParsedExpression ?
ASTNodeFactory(*this, _partiallyParsedExpression) : ASTNodeFactory(*this);
Token token = m_scanner->currentToken();
if (!_partiallyParsedExpression && (TokenTraits::isUnaryOp(token) || TokenTraits::isCountOp(token)))
2014-10-16 12:08:54 +00:00
{
// prefix expression
advance();
ASTPointer<Expression> subExpression = parseUnaryExpression();
nodeFactory.setEndPositionFromNode(subExpression);
return nodeFactory.createNode<UnaryOperation>(token, subExpression, true);
2014-10-16 12:08:54 +00:00
}
else
{
// potential postfix expression
2018-04-27 22:17:35 +00:00
ASTPointer<Expression> subExpression = parseLeftHandSideExpression(_partiallyParsedExpression);
2015-08-31 16:44:29 +00:00
token = m_scanner->currentToken();
if (!TokenTraits::isCountOp(token))
return subExpression;
nodeFactory.markEndPosition();
advance();
return nodeFactory.createNode<UnaryOperation>(token, subExpression, false);
}
}
ASTPointer<Expression> Parser::parseLeftHandSideExpression(
2018-04-27 22:17:35 +00:00
ASTPointer<Expression> const& _partiallyParsedExpression
2015-09-25 14:47:40 +00:00
)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2018-04-27 22:17:35 +00:00
ASTNodeFactory nodeFactory = _partiallyParsedExpression ?
ASTNodeFactory(*this, _partiallyParsedExpression) : ASTNodeFactory(*this);
2015-01-13 17:12:19 +00:00
ASTPointer<Expression> expression;
2018-04-27 22:17:35 +00:00
if (_partiallyParsedExpression)
expression = _partiallyParsedExpression;
2015-08-31 16:44:29 +00:00
else if (m_scanner->currentToken() == Token::New)
2015-01-13 17:12:19 +00:00
{
expectToken(Token::New);
2020-07-15 17:50:59 +00:00
ASTPointer<TypeName> typeName(parseTypeName());
nodeFactory.setEndPositionFromNode(typeName);
expression = nodeFactory.createNode<NewExpression>(typeName);
2015-01-13 17:12:19 +00:00
}
else if (m_scanner->currentToken() == Token::Payable)
{
expectToken(Token::Payable);
nodeFactory.markEndPosition();
auto expressionType = nodeFactory.createNode<ElementaryTypeName>(
ElementaryTypeNameToken(Token::Address, 0, 0),
std::make_optional(StateMutability::Payable)
);
expression = nodeFactory.createNode<ElementaryTypeNameExpression>(expressionType);
expectToken(Token::LParen, false);
}
2015-01-13 17:12:19 +00:00
else
expression = parsePrimaryExpression();
2014-10-16 12:08:54 +00:00
while (true)
{
2015-08-31 16:44:29 +00:00
switch (m_scanner->currentToken())
2014-10-16 12:08:54 +00:00
{
case Token::LBrack:
{
advance();
ASTPointer<Expression> index;
ASTPointer<Expression> endIndex;
if (m_scanner->currentToken() != Token::RBrack && m_scanner->currentToken() != Token::Colon)
index = parseExpression();
if (m_scanner->currentToken() == Token::Colon)
{
expectToken(Token::Colon);
if (m_scanner->currentToken() != Token::RBrack)
endIndex = parseExpression();
nodeFactory.markEndPosition();
expectToken(Token::RBrack);
expression = nodeFactory.createNode<IndexRangeAccess>(expression, index, endIndex);
}
else
{
nodeFactory.markEndPosition();
expectToken(Token::RBrack);
expression = nodeFactory.createNode<IndexAccess>(expression, index);
}
break;
}
case Token::Period:
{
advance();
nodeFactory.markEndPosition();
2021-02-24 15:28:13 +00:00
expression = nodeFactory.createNode<MemberAccess>(expression, expectIdentifierTokenOrAddress());
break;
}
case Token::LParen:
{
advance();
2015-01-29 17:26:00 +00:00
vector<ASTPointer<Expression>> arguments;
2015-02-03 20:25:08 +00:00
vector<ASTPointer<ASTString>> names;
std::tie(arguments, names) = parseFunctionCallArguments();
nodeFactory.markEndPosition();
expectToken(Token::RParen);
2015-01-29 17:26:00 +00:00
expression = nodeFactory.createNode<FunctionCall>(expression, arguments, names);
break;
}
case Token::LBrace:
{
// See if this is followed by <identifier>, followed by ":". If not, it is not
// a function call options but a Block (from a try statement).
if (
m_scanner->peekNextToken() != Token::Identifier ||
m_scanner->peekNextNextToken() != Token::Colon
)
return expression;
expectToken(Token::LBrace);
auto optionList = parseNamedArguments();
nodeFactory.markEndPosition();
expectToken(Token::RBrace);
expression = nodeFactory.createNode<FunctionCallOptions>(expression, optionList.first, optionList.second);
break;
}
default:
return expression;
}
}
}
ASTPointer<Expression> Parser::parsePrimaryExpression()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
Token token = m_scanner->currentToken();
ASTPointer<Expression> expression;
2014-10-16 12:08:54 +00:00
switch (token)
{
case Token::TrueLiteral:
case Token::FalseLiteral:
nodeFactory.markEndPosition();
expression = nodeFactory.createNode<Literal>(token, getLiteralAndAdvance());
break;
case Token::Number:
2020-07-08 18:35:02 +00:00
if (TokenTraits::isEtherSubdenomination(m_scanner->peekNextToken()))
2015-02-06 12:38:10 +00:00
{
ASTPointer<ASTString> literal = getLiteralAndAdvance();
nodeFactory.markEndPosition();
2020-07-08 18:35:02 +00:00
Literal::SubDenomination subdenomination = static_cast<Literal::SubDenomination>(m_scanner->currentToken());
advance();
2015-02-06 12:38:10 +00:00
expression = nodeFactory.createNode<Literal>(token, literal, subdenomination);
}
else if (TokenTraits::isTimeSubdenomination(m_scanner->peekNextToken()))
2015-03-04 16:35:23 +00:00
{
ASTPointer<ASTString> literal = getLiteralAndAdvance();
nodeFactory.markEndPosition();
2015-08-31 16:44:29 +00:00
Literal::SubDenomination subdenomination = static_cast<Literal::SubDenomination>(m_scanner->currentToken());
advance();
2015-03-04 16:35:23 +00:00
expression = nodeFactory.createNode<Literal>(token, literal, subdenomination);
}
else
{
nodeFactory.markEndPosition();
expression = nodeFactory.createNode<Literal>(token, getLiteralAndAdvance());
}
break;
case Token::StringLiteral:
case Token::UnicodeStringLiteral:
case Token::HexStringLiteral:
{
string literal = m_scanner->currentLiteral();
Token firstToken = m_scanner->currentToken();
while (m_scanner->peekNextToken() == firstToken)
{
advance();
literal += m_scanner->currentLiteral();
}
nodeFactory.markEndPosition();
advance();
if (m_scanner->currentToken() == Token::Illegal)
fatalParserError(5428_error, to_string(m_scanner->currentError()));
expression = nodeFactory.createNode<Literal>(token, make_shared<ASTString>(literal));
break;
}
case Token::Identifier:
nodeFactory.markEndPosition();
expression = nodeFactory.createNode<Identifier>(getLiteralAndAdvance());
break;
2019-01-10 15:28:39 +00:00
case Token::Type:
// Inside expressions "type" is the name of a special, globally-available function.
nodeFactory.markEndPosition();
advance();
2019-01-10 15:28:39 +00:00
expression = nodeFactory.createNode<Identifier>(make_shared<ASTString>("type"));
break;
2015-12-15 17:37:00 +00:00
case Token::LParen:
case Token::LBrack:
{
// Tuple/parenthesized expression or inline array/bracketed expression.
// Special cases: ()/[] is empty tuple/array type, (x) is not a real tuple,
// (x,) is one-dimensional tuple, elements in arrays cannot be left out, only in tuples.
advance();
2015-10-12 21:02:35 +00:00
vector<ASTPointer<Expression>> components;
Token oppositeToken = (token == Token::LParen ? Token::RParen : Token::RBrack);
bool isArray = (token == Token::LBrack);
if (m_scanner->currentToken() != oppositeToken)
2015-10-12 21:02:35 +00:00
while (true)
{
if (m_scanner->currentToken() != Token::Comma && m_scanner->currentToken() != oppositeToken)
2015-10-12 21:02:35 +00:00
components.push_back(parseExpression());
else if (isArray)
parserError(4799_error, "Expected expression (inline array elements cannot be omitted).");
2015-10-12 21:02:35 +00:00
else
components.push_back(ASTPointer<Expression>());
2017-08-08 21:58:06 +00:00
if (m_scanner->currentToken() == oppositeToken)
2015-10-12 21:02:35 +00:00
break;
2017-08-08 21:58:06 +00:00
expectToken(Token::Comma);
2015-10-12 21:02:35 +00:00
}
nodeFactory.markEndPosition();
expectToken(oppositeToken);
expression = nodeFactory.createNode<TupleExpression>(components, isArray);
break;
}
case Token::Illegal:
fatalParserError(8936_error, to_string(m_scanner->currentError()));
2018-11-22 16:37:19 +00:00
break;
default:
if (TokenTraits::isElementaryTypeName(token))
2014-10-16 12:08:54 +00:00
{
//used for casts
unsigned firstSize;
unsigned secondSize;
tie(firstSize, secondSize) = m_scanner->currentTokenInfo();
auto expressionType = nodeFactory.createNode<ElementaryTypeName>(
ElementaryTypeNameToken(m_scanner->currentToken(), firstSize, secondSize)
);
expression = nodeFactory.createNode<ElementaryTypeNameExpression>(expressionType);
advance();
2014-10-16 12:08:54 +00:00
}
else
2020-05-08 23:45:02 +00:00
fatalParserError(6933_error, "Expected primary expression.");
2014-10-16 21:49:45 +00:00
break;
2014-10-09 10:28:37 +00:00
}
return expression;
}
2015-01-29 17:26:00 +00:00
vector<ASTPointer<Expression>> Parser::parseFunctionCallListArguments()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2014-12-03 06:47:08 +00:00
vector<ASTPointer<Expression>> arguments;
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() != Token::RParen)
2014-10-16 12:08:54 +00:00
{
arguments.push_back(parseExpression());
2015-08-31 16:44:29 +00:00
while (m_scanner->currentToken() != Token::RParen)
2014-10-16 12:08:54 +00:00
{
expectToken(Token::Comma);
arguments.push_back(parseExpression());
}
}
return arguments;
}
2015-02-03 20:25:08 +00:00
pair<vector<ASTPointer<Expression>>, vector<ASTPointer<ASTString>>> Parser::parseFunctionCallArguments()
2015-01-29 17:26:00 +00:00
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2015-02-03 20:25:08 +00:00
pair<vector<ASTPointer<Expression>>, vector<ASTPointer<ASTString>>> ret;
Token token = m_scanner->currentToken();
if (token == Token::LBrace)
2015-01-29 17:26:00 +00:00
{
// call({arg1 : 1, arg2 : 2 })
expectToken(Token::LBrace);
ret = parseNamedArguments();
expectToken(Token::RBrace);
}
else
ret.first = parseFunctionCallListArguments();
return ret;
}
pair<vector<ASTPointer<Expression>>, vector<ASTPointer<ASTString>>> Parser::parseNamedArguments()
{
pair<vector<ASTPointer<Expression>>, vector<ASTPointer<ASTString>>> ret;
bool first = true;
while (m_scanner->currentToken() != Token::RBrace)
{
if (!first)
expectToken(Token::Comma);
2015-01-29 17:26:00 +00:00
ret.second.push_back(expectIdentifierToken());
expectToken(Token::Colon);
ret.first.push_back(parseExpression());
if (
m_scanner->currentToken() == Token::Comma &&
m_scanner->peekNextToken() == Token::RBrace
)
{
parserError(2074_error, "Unexpected trailing comma.");
advance();
2015-01-29 17:26:00 +00:00
}
first = false;
2015-01-29 17:26:00 +00:00
}
2015-02-03 20:25:08 +00:00
return ret;
2015-01-29 17:26:00 +00:00
}
2020-09-25 10:15:31 +00:00
bool Parser::variableDeclarationStart()
{
Token currentToken = m_scanner->currentToken();
return
currentToken == Token::Identifier ||
currentToken == Token::Mapping ||
TokenTraits::isElementaryTypeName(currentToken) ||
(currentToken == Token::Function && m_scanner->peekNextToken() == Token::LParen);
}
optional<string> Parser::findLicenseString(std::vector<ASTPointer<ASTNode>> const& _nodes)
{
// We circumvent the scanner here, because it skips non-docstring comments.
static regex const licenseNameRegex("([a-zA-Z0-9 ()+.-]+)");
static regex const licenseDeclarationRegex("SPDX-License-Identifier:\\s*(.+?)([\n\r]|(\\*/))");
// Search inside all parts of the source not covered by parsed nodes.
// This will leave e.g. "global comments".
2021-07-14 10:53:39 +00:00
using iter = std::string::const_iterator;
vector<pair<iter, iter>> sequencesToSearch;
string const& source = m_scanner->charStream().source();
sequencesToSearch.emplace_back(source.begin(), source.end());
for (ASTPointer<ASTNode> const& node: _nodes)
if (node->location().hasText())
{
sequencesToSearch.back().second = source.begin() + node->location().start;
sequencesToSearch.emplace_back(source.begin() + node->location().end, source.end());
}
vector<string> licenseNames;
for (auto const& [start, end]: sequencesToSearch)
{
auto declarationsBegin = std::sregex_iterator(start, end, licenseDeclarationRegex);
auto declarationsEnd = std::sregex_iterator();
for (std::sregex_iterator declIt = declarationsBegin; declIt != declarationsEnd; ++declIt)
if (!declIt->empty())
{
string license = boost::trim_copy(string((*declIt)[1]));
licenseNames.emplace_back(std::move(license));
}
}
if (licenseNames.size() == 1)
{
string const& license = licenseNames.front();
if (regex_match(license, licenseNameRegex))
return license;
else
parserError(
1114_error,
{-1, -1, m_scanner->currentLocation().sourceName},
"Invalid SPDX license identifier."
);
}
else if (licenseNames.empty())
parserWarning(
1878_error,
2021-06-29 12:38:59 +00:00
{-1, -1, m_scanner->currentLocation().sourceName},
"SPDX license identifier not provided in source file. "
"Before publishing, consider adding a comment containing "
"\"SPDX-License-Identifier: <SPDX-License>\" to each source file. "
"Use \"SPDX-License-Identifier: UNLICENSED\" for non-open-source code. "
"Please see https://spdx.org for more information."
);
else
parserError(
3716_error,
2021-06-29 12:38:59 +00:00
{-1, -1, m_scanner->currentLocation().sourceName},
"Multiple SPDX license identifiers found in source file. "
"Use \"AND\" or \"OR\" to combine multiple licenses. "
"Please see https://spdx.org for more information."
);
return {};
}
2015-02-23 13:38:44 +00:00
Parser::LookAheadInfo Parser::peekStatementType() const
{
// Distinguish between variable declaration (and potentially assignment) and expression statement
// (which include assignments to other expressions and pre-declared variables).
// We have a variable declaration if we get a keyword that specifies a type name.
// If it is an identifier or an elementary type name followed by an identifier
// or a mutability specifier, we also have a variable declaration.
// If we get an identifier followed by a "[" or ".", it can be both ("lib.type[9] a;" or "variable.el[9] = 7;").
// In all other cases, we have an expression statement.
Token token(m_scanner->currentToken());
bool mightBeTypeName = (TokenTraits::isElementaryTypeName(token) || token == Token::Identifier);
2020-07-15 17:50:59 +00:00
if (token == Token::Mapping || token == Token::Function)
2018-04-27 22:26:56 +00:00
return LookAheadInfo::VariableDeclaration;
if (mightBeTypeName)
{
Token next = m_scanner->peekNextToken();
// So far we only allow ``address payable`` in variable declaration statements and in no other
// kind of statement. This means, for example, that we do not allow type expressions of the form
// ``address payable;``.
// If we want to change this in the future, we need to consider another scanner token here.
if (TokenTraits::isElementaryTypeName(token) && TokenTraits::isStateMutabilitySpecifier(next))
return LookAheadInfo::VariableDeclaration;
if (next == Token::Identifier || TokenTraits::isLocationSpecifier(next))
2018-04-27 22:26:56 +00:00
return LookAheadInfo::VariableDeclaration;
if (next == Token::LBrack || next == Token::Period)
return LookAheadInfo::IndexAccessStructure;
}
2018-04-27 22:26:56 +00:00
return LookAheadInfo::Expression;
}
2018-04-26 08:42:56 +00:00
Parser::IndexAccessedPath Parser::parseIndexAccessedPath()
{
IndexAccessedPath iap;
if (m_scanner->currentToken() == Token::Identifier)
{
iap.path.push_back(parseIdentifier());
while (m_scanner->currentToken() == Token::Period)
{
advance();
2021-02-24 15:28:13 +00:00
iap.path.push_back(parseIdentifierOrAddress());
2018-04-26 08:42:56 +00:00
}
}
else
{
unsigned firstNum;
unsigned secondNum;
tie(firstNum, secondNum) = m_scanner->currentTokenInfo();
auto expressionType = ASTNodeFactory(*this).createNode<ElementaryTypeName>(
ElementaryTypeNameToken(m_scanner->currentToken(), firstNum, secondNum)
);
iap.path.push_back(ASTNodeFactory(*this).createNode<ElementaryTypeNameExpression>(expressionType));
advance();
2018-04-26 08:42:56 +00:00
}
while (m_scanner->currentToken() == Token::LBrack)
{
expectToken(Token::LBrack);
ASTPointer<Expression> index;
if (m_scanner->currentToken() != Token::RBrack && m_scanner->currentToken() != Token::Colon)
2018-04-26 08:42:56 +00:00
index = parseExpression();
SourceLocation indexLocation = iap.path.front()->location();
if (m_scanner->currentToken() == Token::Colon)
{
expectToken(Token::Colon);
ASTPointer<Expression> endIndex;
if (m_scanner->currentToken() != Token::RBrack)
endIndex = parseExpression();
indexLocation.end = currentLocation().end;
iap.indices.emplace_back(IndexAccessedPath::Index{index, {endIndex}, indexLocation});
expectToken(Token::RBrack);
}
else
{
indexLocation.end = currentLocation().end;
iap.indices.emplace_back(IndexAccessedPath::Index{index, {}, indexLocation});
expectToken(Token::RBrack);
}
2018-04-26 08:42:56 +00:00
}
return iap;
}
ASTPointer<TypeName> Parser::typeNameFromIndexAccessStructure(Parser::IndexAccessedPath const& _iap)
{
2018-04-27 22:26:56 +00:00
if (_iap.empty())
return {};
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
2018-04-26 08:42:56 +00:00
SourceLocation location = _iap.path.front()->location();
location.end = _iap.path.back()->location().end;
nodeFactory.setLocation(location);
ASTPointer<TypeName> type;
2018-04-26 08:42:56 +00:00
if (auto typeName = dynamic_cast<ElementaryTypeNameExpression const*>(_iap.path.front().get()))
{
2018-04-26 08:42:56 +00:00
solAssert(_iap.path.size() == 1, "");
type = nodeFactory.createNode<ElementaryTypeName>(typeName->type().typeName());
}
else
{
vector<ASTString> path;
2018-04-26 08:42:56 +00:00
for (auto const& el: _iap.path)
path.push_back(dynamic_cast<Identifier const&>(*el).name());
2020-08-31 15:37:03 +00:00
type = nodeFactory.createNode<UserDefinedTypeName>(nodeFactory.createNode<IdentifierPath>(path));
}
2018-04-26 08:42:56 +00:00
for (auto const& lengthExpression: _iap.indices)
{
if (lengthExpression.end)
parserError(5464_error, lengthExpression.location, "Expected array length expression.");
nodeFactory.setLocation(lengthExpression.location);
type = nodeFactory.createNode<ArrayTypeName>(type, lengthExpression.start);
}
return type;
}
2015-02-23 13:38:44 +00:00
ASTPointer<Expression> Parser::expressionFromIndexAccessStructure(
2018-04-26 08:42:56 +00:00
Parser::IndexAccessedPath const& _iap
2015-09-25 14:47:40 +00:00
)
{
2018-04-27 22:26:56 +00:00
if (_iap.empty())
return {};
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2018-04-26 08:42:56 +00:00
ASTNodeFactory nodeFactory(*this, _iap.path.front());
ASTPointer<Expression> expression(_iap.path.front());
for (size_t i = 1; i < _iap.path.size(); ++i)
{
2018-04-26 08:42:56 +00:00
SourceLocation location(_iap.path.front()->location());
location.end = _iap.path[i]->location().end;
nodeFactory.setLocation(location);
2018-04-26 08:42:56 +00:00
Identifier const& identifier = dynamic_cast<Identifier const&>(*_iap.path[i]);
expression = nodeFactory.createNode<MemberAccess>(
expression,
make_shared<ASTString>(identifier.name())
);
}
2018-04-26 08:42:56 +00:00
for (auto const& index: _iap.indices)
{
nodeFactory.setLocation(index.location);
if (index.end)
expression = nodeFactory.createNode<IndexRangeAccess>(expression, index.start, *index.end);
else
expression = nodeFactory.createNode<IndexAccess>(expression, index.start);
}
return expression;
}
2015-01-30 20:43:19 +00:00
ASTPointer<ParameterList> Parser::createEmptyParameterList()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2015-01-30 20:43:19 +00:00
ASTNodeFactory nodeFactory(*this);
nodeFactory.setLocationEmpty();
return nodeFactory.createNode<ParameterList>(vector<ASTPointer<VariableDeclaration>>());
}
ASTPointer<ASTString> Parser::expectIdentifierToken()
{
2021-02-24 15:28:13 +00:00
expectToken(Token::Identifier, false /* do not advance */);
return getLiteralAndAdvance();
}
2021-02-24 15:28:13 +00:00
ASTPointer<ASTString> Parser::expectIdentifierTokenOrAddress()
{
ASTPointer<ASTString> result;
if (m_scanner->currentToken() == Token::Address)
{
result = make_shared<ASTString>("address");
advance();
2021-02-24 15:28:13 +00:00
}
else
{
expectToken(Token::Identifier, false /* do not advance */);
result = getLiteralAndAdvance();
}
return result;
}
ASTPointer<ASTString> Parser::getLiteralAndAdvance()
{
ASTPointer<ASTString> identifier = make_shared<ASTString>(m_scanner->currentLiteral());
advance();
return identifier;
}
2014-10-16 12:08:54 +00:00
}