solidity/libsolidity/parsing/Parser.cpp

1785 lines
55 KiB
C++
Raw Normal View History

/*
This file is part of solidity.
solidity is free software: you can redistribute it and/or modify
2014-10-16 12:08:54 +00:00
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
solidity is distributed in the hope that it will be useful,
2014-10-16 12:08:54 +00:00
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.
2014-10-16 12:08:54 +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/>.
*/
/**
* @author Christian <c@ethdev.com>
* @date 2014
* Solidity parser.
*/
#include <cctype>
2014-12-03 06:46:55 +00:00
#include <vector>
2015-10-20 22:21:52 +00:00
#include <libsolidity/parsing/Parser.h>
#include <libyul/AsmParser.h>
#include <liblangutil/SourceLocation.h>
#include <liblangutil/ErrorReporter.h>
#include <liblangutil/Scanner.h>
2014-12-03 06:47:08 +00:00
using namespace std;
using namespace langutil;
2014-12-03 06:47:08 +00:00
2014-10-16 12:08:54 +00:00
namespace dev
{
namespace solidity
{
/// AST node factory that also tracks the begin and end position of an AST node
/// while it is being parsed
class Parser::ASTNodeFactory
{
public:
2017-08-21 14:42:17 +00:00
explicit ASTNodeFactory(Parser const& _parser):
m_parser(_parser), m_location(_parser.position(), -1, _parser.source()) {}
ASTNodeFactory(Parser const& _parser, ASTPointer<ASTNode> const& _childNode):
2015-08-31 16:44:29 +00:00
m_parser(_parser), m_location(_childNode->location()) {}
2014-10-13 16:22:15 +00:00
2015-08-31 16:44:29 +00:00
void markEndPosition() { m_location.end = m_parser.endPosition(); }
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
{
solAssert(m_location.source, "");
if (m_location.end < 0)
markEndPosition();
return make_shared<NodeType>(m_location, std::forward<Args>(_args)...);
2014-10-09 10:28:37 +00:00
}
private:
Parser const& m_parser;
SourceLocation m_location;
};
2014-12-03 06:46:55 +00:00
ASTPointer<SourceUnit> Parser::parse(shared_ptr<Scanner> const& _scanner)
{
2015-10-15 14:27:26 +00:00
try
{
2017-08-14 16:59:17 +00:00
m_recursionDepth = 0;
m_scanner = _scanner;
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;
case Token::Interface:
case Token::Contract:
case Token::Library:
nodes.push_back(parseContractDefinition());
break;
default:
fatalParserError(string("Expected pragma, import directive or contract/interface/library 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>(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
}
}
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("Token incompatible with Solidity parser as part of pragma directive.");
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);
}
m_scanner->next();
}
while (m_scanner->currentToken() != Token::Semicolon && m_scanner->currentToken() != Token::EOS);
nodeFactory.markEndPosition();
expectToken(Token::Semicolon);
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>();
2015-12-14 17:01:40 +00:00
vector<pair<ASTPointer<Identifier>, ASTPointer<ASTString>>> symbolAliases;
if (m_scanner->currentToken() == Token::StringLiteral)
{
path = getLiteralAndAdvance();
if (m_scanner->currentToken() == Token::As)
{
m_scanner->next();
unitAlias = expectIdentifierToken();
}
}
else
{
if (m_scanner->currentToken() == Token::LBrace)
{
m_scanner->next();
while (true)
{
ASTPointer<Identifier> id = parseIdentifier();
ASTPointer<ASTString> alias;
if (m_scanner->currentToken() == Token::As)
{
expectToken(Token::As);
alias = expectIdentifierToken();
}
2016-01-15 13:04:18 +00:00
symbolAliases.push_back(make_pair(move(id), move(alias)));
2015-12-14 17:01:40 +00:00
if (m_scanner->currentToken() != Token::Comma)
break;
m_scanner->next();
}
expectToken(Token::RBrace);
}
else if (m_scanner->currentToken() == Token::Mul)
{
m_scanner->next();
expectToken(Token::As);
unitAlias = expectIdentifierToken();
}
else
fatalParserError("Expected string literal (path), \"*\" or alias list.");
// "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("Expected \"from\".");
m_scanner->next();
if (m_scanner->currentToken() != Token::StringLiteral)
fatalParserError("Expected import path.");
path = getLiteralAndAdvance();
}
2014-12-03 06:46:55 +00:00
nodeFactory.markEndPosition();
expectToken(Token::Semicolon);
2015-12-14 17:01:40 +00:00
return nodeFactory.createNode<ImportDirective>(path, unitAlias, move(symbolAliases));
2014-12-03 06:46:55 +00:00
}
ContractDefinition::ContractKind Parser::parseContractKind()
{
ContractDefinition::ContractKind kind;
switch(m_scanner->currentToken())
{
case Token::Interface:
kind = ContractDefinition::ContractKind::Interface;
break;
case Token::Contract:
kind = ContractDefinition::ContractKind::Contract;
break;
case Token::Library:
kind = ContractDefinition::ContractKind::Library;
break;
default:
solAssert(false, "Invalid contract kind.");
}
m_scanner->next();
return kind;
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> docString;
if (m_scanner->currentCommentLiteral() != "")
docString = make_shared<ASTString>(m_scanner->currentCommentLiteral());
ContractDefinition::ContractKind contractKind = parseContractKind();
ASTPointer<ASTString> name = expectIdentifierToken();
vector<ASTPointer<InheritanceSpecifier>> baseContracts;
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() == Token::Is)
2015-01-15 15:15:01 +00:00
do
{
m_scanner->next();
baseContracts.push_back(parseInheritanceSpecifier());
2015-01-15 15:15:01 +00:00
}
2015-08-31 16:44:29 +00:00
while (m_scanner->currentToken() == Token::Comma);
vector<ASTPointer<ASTNode>> subNodes;
expectToken(Token::LBrace);
2014-10-16 12:08:54 +00:00
while (true)
{
Token currentTokenValue = m_scanner->currentToken();
if (currentTokenValue == Token::RBrace)
2014-10-09 10:28:37 +00:00
break;
2018-06-27 10:29:03 +00:00
else if (currentTokenValue == Token::Function || currentTokenValue == Token::Constructor)
2016-10-10 21:06:44 +00:00
// This can be a function or a state variable of function type (especially
// complicated to distinguish fallback function from function type state variable)
2018-06-27 10:29:03 +00:00
subNodes.push_back(parseFunctionDefinitionOrFunctionTypeStateVariable());
else if (currentTokenValue == Token::Struct)
subNodes.push_back(parseStructDefinition());
else if (currentTokenValue == Token::Enum)
subNodes.push_back(parseEnumDefinition());
else if (
currentTokenValue == Token::Identifier ||
currentTokenValue == Token::Mapping ||
TokenTraits::isElementaryTypeName(currentTokenValue)
)
2014-10-16 12:08:54 +00:00
{
2015-01-29 13:35:28 +00:00
VarDeclParserOptions options;
options.isStateVariable = true;
options.allowInitialValue = true;
subNodes.push_back(parseVariableDeclaration(options));
expectToken(Token::Semicolon);
2014-10-16 12:08:54 +00:00
}
else if (currentTokenValue == Token::Modifier)
subNodes.push_back(parseModifierDefinition());
else if (currentTokenValue == Token::Event)
subNodes.push_back(parseEventDefinition());
2015-11-22 19:39:10 +00:00
else if (currentTokenValue == Token::Using)
subNodes.push_back(parseUsingDirective());
2014-10-16 12:08:54 +00:00
else
2015-12-14 17:01:40 +00:00
fatalParserError(string("Function, variable, struct or modifier declaration expected."));
2014-10-09 10:28:37 +00:00
}
nodeFactory.markEndPosition();
expectToken(Token::RBrace);
return nodeFactory.createNode<ContractDefinition>(
name,
docString,
baseContracts,
subNodes,
contractKind
);
}
ASTPointer<InheritanceSpecifier> Parser::parseInheritanceSpecifier()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
ASTPointer<UserDefinedTypeName> name(parseUserDefinedTypeName());
unique_ptr<vector<ASTPointer<Expression>>> arguments;
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() == Token::LParen)
{
m_scanner->next();
arguments.reset(new vector<ASTPointer<Expression>>(parseFunctionCallListArguments()));
nodeFactory.markEndPosition();
expectToken(Token::RParen);
}
else
nodeFactory.setEndPositionFromNode(name);
return nodeFactory.createNode<InheritanceSpecifier>(name, std::move(arguments));
}
Declaration::Visibility Parser::parseVisibilitySpecifier()
2015-02-02 16:24:09 +00:00
{
Declaration::Visibility visibility(Declaration::Visibility::Default);
Token token = m_scanner->currentToken();
switch (token)
{
case Token::Public:
visibility = Declaration::Visibility::Public;
break;
case Token::Internal:
visibility = Declaration::Visibility::Internal;
break;
case Token::Private:
visibility = Declaration::Visibility::Private;
break;
case Token::External:
visibility = Declaration::Visibility::External;
break;
default:
solAssert(false, "Invalid visibility specifier.");
}
2015-02-02 16:24:09 +00:00
m_scanner->next();
return visibility;
}
StateMutability Parser::parseStateMutability()
{
StateMutability stateMutability(StateMutability::NonPayable);
Token token = m_scanner->currentToken();
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;
case Token::Constant:
stateMutability = StateMutability::View;
parserError(
"The state mutability modifier \"constant\" was removed in version 0.5.0. "
"Use \"view\" or \"pure\" instead."
);
break;
default:
solAssert(false, "Invalid state mutability specifier.");
2018-05-08 11:08:06 +00:00
}
m_scanner->next();
return stateMutability;
}
2018-06-27 10:29:03 +00:00
Parser::FunctionHeaderParserResult Parser::parseFunctionHeader(bool _forceEmptyName, bool _allowModifiers)
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
2016-09-27 19:37:32 +00:00
FunctionHeaderParserResult result;
result.isConstructor = false;
2018-06-27 10:29:03 +00:00
if (m_scanner->currentToken() == Token::Constructor)
result.isConstructor = true;
else if (m_scanner->currentToken() != Token::Function)
solAssert(false, "Function or constructor expected.");
m_scanner->next();
2018-06-27 10:29:03 +00:00
if (result.isConstructor)
result.name = make_shared<ASTString>();
2018-06-27 10:29:03 +00:00
else if (_forceEmptyName || m_scanner->currentToken() == Token::LParen)
result.name = make_shared<ASTString>();
else if (m_scanner->currentToken() == Token::Constructor)
fatalParserError(string(
"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."
));
2015-01-29 21:50:20 +00:00
else
2016-09-27 19:37:32 +00:00
result.name = expectIdentifierToken();
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 (_allowModifiers && token == Token::Identifier)
{
// If the name is empty (and this is not a constructor),
// then this can either be a modifier (fallback function declaration)
// or the name of the state variable (function type name plus variable).
if ((result.name->empty() && !result.isConstructor) && (
m_scanner->peekNextToken() == Token::Semicolon ||
m_scanner->peekNextToken() == Token::Assign
))
// Variable declaration, break here.
break;
else
result.modifiers.push_back(parseModifierInvocation());
}
else if (TokenTraits::isVisibilitySpecifier(token))
2015-02-02 16:24:09 +00:00
{
2016-09-27 19:37:32 +00:00
if (result.visibility != Declaration::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.
if (
(result.visibility == Declaration::Visibility::External || result.visibility == Declaration::Visibility::Internal) &&
result.modifiers.empty() &&
(result.name->empty() && !result.isConstructor)
2018-03-16 10:02:35 +00:00
)
break;
parserError(string(
"Visibility already specified as \"" +
2017-08-09 13:29:03 +00:00
Declaration::visibilityToString(result.visibility) +
"\"."
));
m_scanner->next();
}
else
result.visibility = parseVisibilitySpecifier();
2015-02-02 16:24:09 +00:00
}
else if (TokenTraits::isStateMutabilitySpecifier(token))
{
if (result.stateMutability != StateMutability::NonPayable)
{
parserError(string(
"State mutability already specified as \"" +
stateMutabilityToString(result.stateMutability) +
"\"."
));
m_scanner->next();
}
else
result.stateMutability = parseStateMutability();
}
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;
2014-10-09 10:28:37 +00:00
m_scanner->next();
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;
}
2018-06-27 10:29:03 +00:00
ASTPointer<ASTNode> Parser::parseFunctionDefinitionOrFunctionTypeStateVariable()
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<ASTString> docstring;
if (m_scanner->currentCommentLiteral() != "")
docstring = make_shared<ASTString>(m_scanner->currentCommentLiteral());
2018-06-27 10:29:03 +00:00
FunctionHeaderParserResult header = parseFunctionHeader(false, true);
2016-09-27 19:37:32 +00:00
2016-10-10 21:06:44 +00:00
if (
header.isConstructor ||
2016-10-10 21:06:44 +00:00
!header.modifiers.empty() ||
!header.name->empty() ||
m_scanner->currentToken() == Token::Semicolon ||
m_scanner->currentToken() == Token::LBrace
)
{
2016-10-10 21:06:44 +00:00
// this has to be a function
ASTPointer<Block> block = ASTPointer<Block>();
nodeFactory.markEndPosition();
if (m_scanner->currentToken() != Token::Semicolon)
{
block = parseBlock();
nodeFactory.setEndPositionFromNode(block);
}
else
m_scanner->next(); // just consume the ';'
return nodeFactory.createNode<FunctionDefinition>(
header.name,
header.visibility,
header.stateMutability,
header.isConstructor,
2016-10-10 21:06:44 +00:00
docstring,
header.parameters,
header.modifiers,
header.returnParameters,
block
);
}
else
2016-10-10 21:06:44 +00:00
{
// this has to be a state variable
ASTPointer<TypeName> type = nodeFactory.createNode<FunctionTypeName>(
header.parameters,
header.returnParameters,
header.visibility,
header.stateMutability
2016-10-10 21:06:44 +00:00
);
type = parseTypeNameSuffix(type, nodeFactory);
VarDeclParserOptions options;
options.isStateVariable = true;
options.allowInitialValue = true;
auto node = parseVariableDeclaration(options, type);
expectToken(Token::Semicolon);
return node;
}
}
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);
ASTPointer<ASTString> name = expectIdentifierToken();
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);
2014-10-09 10:28:37 +00:00
return nodeFactory.createNode<StructDefinition>(name, 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);
ASTPointer<ASTString> name = expectIdentifierToken();
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)
2018-05-02 18:59:05 +00:00
fatalParserError(string("Expected identifier after ','"));
2015-02-09 17:08:56 +00:00
}
2018-10-09 03:29:37 +00:00
if (members.empty())
2016-11-09 13:08:51 +00:00
parserError({"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, members);
}
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);
ASTPointer<TypeName> type;
if (_lookAheadArrayType)
type = _lookAheadArrayType;
else
{
type = parseTypeName(_options.allowVar);
if (type != nullptr)
nodeFactory.setEndPositionFromNode(type);
}
2015-01-29 13:35:28 +00:00
bool isIndexed = false;
bool isDeclaredConst = false;
Declaration::Visibility visibility(Declaration::Visibility::Default);
VariableDeclaration::Location location = VariableDeclaration::Location::Unspecified;
ASTPointer<ASTString> identifier;
while (true)
{
Token token = m_scanner->currentToken();
if (_options.isStateVariable && TokenTraits::isVariableVisibilitySpecifier(token))
{
nodeFactory.markEndPosition();
if (visibility != Declaration::Visibility::Default)
{
parserError(string(
"Visibility already specified as \"" +
2017-08-09 13:29:03 +00:00
Declaration::visibilityToString(visibility) +
"\"."
));
m_scanner->next();
}
else
visibility = parseVisibilitySpecifier();
}
else
{
if (_options.allowIndexed && token == Token::Indexed)
isIndexed = true;
2017-08-09 11:50:53 +00:00
else if (token == Token::Constant)
isDeclaredConst = true;
else if (_options.allowLocationSpecifier && TokenTraits::isLocationSpecifier(token))
{
if (location != VariableDeclaration::Location::Unspecified)
parserError(string("Location already specified."));
else if (!type)
parserError(string("Location specifier needs explicit type name."));
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();
m_scanner->next();
}
}
2015-08-31 16:44:29 +00:00
if (_options.allowEmptyName && m_scanner->currentToken() != Token::Identifier)
{
identifier = make_shared<ASTString>("");
solAssert(!_options.allowVar, ""); // allowEmptyName && allowVar makes no sense
}
else
{
nodeFactory.markEndPosition();
identifier = expectIdentifierToken();
}
ASTPointer<Expression> value;
if (_options.allowInitialValue)
{
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() == Token::Assign)
{
m_scanner->next();
value = parseExpression();
nodeFactory.setEndPositionFromNode(value);
}
}
2015-06-05 12:45:47 +00:00
return nodeFactory.createNode<VariableDeclaration>(
type,
identifier,
value,
visibility,
_options.isStateVariable,
isIndexed,
isDeclaredConst,
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<ASTString> docstring;
2015-08-31 16:44:29 +00:00
if (m_scanner->currentCommentLiteral() != "")
docstring = make_shared<ASTString>(m_scanner->currentCommentLiteral());
2015-01-21 10:16:18 +00:00
expectToken(Token::Modifier);
2015-01-21 10:16:18 +00:00
ASTPointer<ASTString> name(expectIdentifierToken());
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();
2015-01-21 10:16:18 +00:00
ASTPointer<Block> block = parseBlock();
nodeFactory.setEndPositionFromNode(block);
return nodeFactory.createNode<ModifierDefinition>(name, docstring, parameters, block);
}
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<ASTString> docstring;
2015-08-31 16:44:29 +00:00
if (m_scanner->currentCommentLiteral() != "")
docstring = make_shared<ASTString>(m_scanner->currentCommentLiteral());
2015-01-29 13:35:28 +00:00
expectToken(Token::Event);
2015-01-29 13:35:28 +00:00
ASTPointer<ASTString> name(expectIdentifierToken());
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;
m_scanner->next();
}
2015-01-29 13:35:28 +00:00
nodeFactory.markEndPosition();
expectToken(Token::Semicolon);
return nodeFactory.createNode<EventDefinition>(name, docstring, parameters, anonymous);
2015-01-29 13:35:28 +00:00
}
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);
ASTPointer<UserDefinedTypeName> library(parseUserDefinedTypeName());
2015-11-22 19:39:10 +00:00
ASTPointer<TypeName> typeName;
expectToken(Token::For);
if (m_scanner->currentToken() == Token::Mul)
m_scanner->next();
else
typeName = parseTypeName(false);
nodeFactory.markEndPosition();
expectToken(Token::Semicolon);
return nodeFactory.createNode<UsingForDirective>(library, typeName);
}
ASTPointer<ModifierInvocation> Parser::parseModifierInvocation()
{
2017-08-14 16:59:17 +00:00
RecursionGuard recursionGuard(*this);
ASTNodeFactory nodeFactory(*this);
2015-01-28 10:28:22 +00:00
ASTPointer<Identifier> name(parseIdentifier());
unique_ptr<vector<ASTPointer<Expression>>> arguments;
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() == Token::LParen)
{
m_scanner->next();
arguments.reset(new 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());
}
ASTPointer<UserDefinedTypeName> Parser::parseUserDefinedTypeName()
{
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)
{
m_scanner->next();
nodeFactory.markEndPosition();
identifierPath.push_back(*expectIdentifierToken());
}
return nodeFactory.createNode<UserDefinedTypeName>(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)
{
m_scanner->next();
ASTPointer<Expression> length;
if (m_scanner->currentToken() != Token::RBrack)
length = parseExpression();
nodeFactory.markEndPosition();
expectToken(Token::RBrack);
type = nodeFactory.createNode<ArrayTypeName>(type, length);
}
return type;
}
ASTPointer<TypeName> Parser::parseTypeName(bool _allowVar)
{
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();
2014-10-09 10:28:37 +00:00
m_scanner->next();
auto stateMutability = boost::make_optional(elemTypeName.token() == Token::Address, StateMutability::NonPayable);
if (TokenTraits::isStateMutabilitySpecifier(m_scanner->currentToken(), false))
{
if (elemTypeName.token() == Token::Address)
{
nodeFactory.markEndPosition();
stateMutability = parseStateMutability();
}
else
{
parserError("State mutability can only be specified for address types.");
m_scanner->next();
}
}
type = nodeFactory.createNode<ElementaryTypeName>(elemTypeName, stateMutability);
2014-10-16 12:08:54 +00:00
}
else if (token == Token::Var)
2014-10-16 12:08:54 +00:00
{
2014-10-13 16:22:15 +00:00
if (!_allowVar)
parserError(string("Expected explicit type name."));
2014-10-09 10:28:37 +00:00
m_scanner->next();
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
2015-12-14 17:01:40 +00:00
fatalParserError(string("Expected type name"));
if (type)
// Parse "[...]" postfixes for arrays.
2016-10-10 21:06:44 +00:00
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);
FunctionHeaderParserResult header = parseFunctionHeader(true, false);
solAssert(!header.isConstructor, "Tried to parse type as constructor.");
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<ElementaryTypeName> keyType;
Token token = m_scanner->currentToken();
if (!TokenTraits::isElementaryTypeName(token))
fatalParserError(string("Expected elementary type name for mapping key type"));
unsigned firstSize;
unsigned secondSize;
tie(firstSize, secondSize) = m_scanner->currentTokenInfo();
ElementaryTypeNameToken elemTypeName(token, firstSize, secondSize);
keyType = ASTNodeFactory(*this).createNode<ElementaryTypeName>(elemTypeName);
2014-10-09 10:28:37 +00:00
m_scanner->next();
expectToken(Token::Arrow);
2014-10-13 16:22:15 +00:00
bool const allowVar = false;
ASTPointer<TypeName> valueType = parseTypeName(allowVar);
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("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();
m_scanner->next();
return nodeFactory.createNode<ParameterList>(parameters);
}
2015-10-26 16:20:29 +00:00
ASTPointer<Block> Parser::parseBlock(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);
expectToken(Token::LBrace);
2014-12-03 06:47:08 +00:00
vector<ASTPointer<Statement>> statements;
2015-08-31 16:44:29 +00:00
while (m_scanner->currentToken() != Token::RBrace)
2014-10-09 10:28:37 +00:00
statements.push_back(parseStatement());
nodeFactory.markEndPosition();
expectToken(Token::RBrace);
2015-10-26 16:20:29 +00:00
return nodeFactory.createNode<Block>(_docString, statements);
2014-10-09 10:28:37 +00:00
}
ASTPointer<Statement> Parser::parseStatement()
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;
if (m_scanner->currentCommentLiteral() != "")
docString = make_shared<ASTString>(m_scanner->currentCommentLiteral());
ASTPointer<Statement> statement;
2015-08-31 16:44:29 +00:00
switch (m_scanner->currentToken())
2014-10-16 12:08:54 +00:00
{
case Token::If:
2015-10-26 16:20:29 +00:00
return parseIfStatement(docString);
case Token::While:
2015-10-26 16:20:29 +00:00
return parseWhileStatement(docString);
case Token::Do:
return parseDoWhileStatement(docString);
case Token::For:
2015-10-26 16:20:29 +00:00
return parseForStatement(docString);
case Token::LBrace:
2015-10-26 16:20:29 +00:00
return parseBlock(docString);
2014-10-16 12:08:54 +00:00
// starting from here, all statements must be terminated by a semicolon
case Token::Continue:
2015-10-26 16:20:29 +00:00
statement = ASTNodeFactory(*this).createNode<Continue>(docString);
m_scanner->next();
break;
case Token::Break:
2015-10-26 16:20:29 +00:00
statement = ASTNodeFactory(*this).createNode<Break>(docString);
m_scanner->next();
break;
case Token::Return:
2014-10-16 12:08:54 +00:00
{
ASTNodeFactory nodeFactory(*this);
ASTPointer<Expression> expression;
if (m_scanner->next() != Token::Semicolon)
{
2014-10-16 12:08:54 +00:00
expression = parseExpression();
nodeFactory.setEndPositionFromNode(expression);
}
2015-10-26 16:20:29 +00:00
statement = nodeFactory.createNode<Return>(docString, expression);
2015-01-21 10:16:18 +00:00
break;
2014-10-16 12:08:54 +00:00
}
2015-09-15 14:33:14 +00:00
case Token::Throw:
{
2015-10-26 16:20:29 +00:00
statement = ASTNodeFactory(*this).createNode<Throw>(docString);
2015-09-16 11:44:07 +00:00
m_scanner->next();
2015-09-15 14:33:14 +00:00
break;
}
2016-02-22 01:13:41 +00:00
case Token::Assembly:
return parseInlineAssembly(docString);
case Token::Emit:
statement = parseEmitStatement(docString);
break;
case Token::Identifier:
if (m_insideModifier && m_scanner->currentLiteral() == "_")
2015-01-21 10:16:18 +00:00
{
2015-10-26 16:20:29 +00:00
statement = ASTNodeFactory(*this).createNode<PlaceholderStatement>(docString);
2015-01-21 10:16:18 +00:00
m_scanner->next();
}
else
statement = parseSimpleStatement(docString);
break;
default:
2015-10-26 16:20:29 +00:00
statement = parseSimpleStatement(docString);
break;
}
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);
2016-02-22 01:13:41 +00:00
ASTNodeFactory nodeFactory(*this);
expectToken(Token::Assembly);
if (m_scanner->currentToken() == Token::StringLiteral)
{
if (m_scanner->currentLiteral() != "evmasm")
fatalParserError("Only \"evmasm\" supported.");
m_scanner->next();
}
2016-02-22 01:13:41 +00:00
yul::Parser asmParser(m_errorReporter);
shared_ptr<yul::Block> block = asmParser.parse(m_scanner, true);
2016-02-22 01:13:41 +00:00
nodeFactory.markEndPosition();
return nodeFactory.createNode<InlineAssembly>(_docString, 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
{
m_scanner->next();
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);
}
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);
// LTODO: 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);
m_scanner->next();
ASTNodeFactory eventCallNodeFactory(*this);
if (m_scanner->currentToken() != Token::Identifier)
fatalParserError("Expected event name or path.");
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;
m_scanner->next();
};
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);
auto statement = nodeFactory.createNode<EmitStatement>(_docString, eventCall);
return statement;
}
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)
{
m_scanner->next();
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());
vector<ASTPointer<VariableDeclaration>> variables;
ASTPointer<Expression> value;
if (
!_lookAheadArrayType &&
m_scanner->currentToken() == Token::Var &&
m_scanner->peekNextToken() == Token::LParen
)
{
// Parse `var (a, b, ,, c) = ...` into a single VariableDeclarationStatement with multiple variables.
m_scanner->next();
m_scanner->next();
2015-10-13 12:31:24 +00:00
if (m_scanner->currentToken() != Token::RParen)
while (true)
{
2015-10-13 12:31:24 +00:00
ASTPointer<VariableDeclaration> var;
if (
m_scanner->currentToken() != Token::Comma &&
m_scanner->currentToken() != Token::RParen
)
{
ASTNodeFactory varDeclNodeFactory(*this);
2015-10-12 21:02:35 +00:00
varDeclNodeFactory.markEndPosition();
2015-10-13 12:31:24 +00:00
ASTPointer<ASTString> name = expectIdentifierToken();
var = varDeclNodeFactory.createNode<VariableDeclaration>(
ASTPointer<TypeName>(),
name,
ASTPointer<Expression>(),
VariableDeclaration::Visibility::Default
);
}
variables.push_back(var);
if (m_scanner->currentToken() == Token::RParen)
break;
else
expectToken(Token::Comma);
}
nodeFactory.markEndPosition();
m_scanner->next();
}
else
{
VarDeclParserOptions options;
options.allowVar = true;
options.allowLocationSpecifier = true;
variables.push_back(parseVariableDeclaration(options, _lookAheadArrayType));
nodeFactory.setEndPositionFromNode(variables.back());
}
if (m_scanner->currentToken() == Token::Assign)
{
m_scanner->next();
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();
m_scanner->next();
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)
{
m_scanner->next();
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();
m_scanner->next();
ASTPointer<Expression> right = 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
m_scanner->next();
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();
m_scanner->next();
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);
ASTPointer<TypeName> typeName(parseTypeName(false));
if (typeName)
nodeFactory.setEndPositionFromNode(typeName);
else
nodeFactory.markEndPosition();
expression = nodeFactory.createNode<NewExpression>(typeName);
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:
{
m_scanner->next();
ASTPointer<Expression> index;
2015-08-31 16:44:29 +00:00
if (m_scanner->currentToken() != Token::RBrack)
index = parseExpression();
nodeFactory.markEndPosition();
expectToken(Token::RBrack);
expression = nodeFactory.createNode<IndexAccess>(expression, index);
break;
}
case Token::Period:
{
m_scanner->next();
nodeFactory.markEndPosition();
expression = nodeFactory.createNode<MemberAccess>(expression, expectIdentifierToken());
break;
}
case Token::LParen:
{
m_scanner->next();
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;
}
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:
if (TokenTraits::isEtherSubdenomination(m_scanner->peekNextToken()))
2015-02-06 12:38:10 +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());
2015-02-06 12:38:10 +00:00
m_scanner->next();
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());
2015-03-04 16:35:23 +00:00
m_scanner->next();
expression = nodeFactory.createNode<Literal>(token, literal, subdenomination);
}
else
{
nodeFactory.markEndPosition();
expression = nodeFactory.createNode<Literal>(token, getLiteralAndAdvance());
}
break;
case Token::StringLiteral:
nodeFactory.markEndPosition();
2015-02-06 12:38:10 +00:00
expression = nodeFactory.createNode<Literal>(token, getLiteralAndAdvance());
break;
case Token::Identifier:
nodeFactory.markEndPosition();
expression = nodeFactory.createNode<Identifier>(getLiteralAndAdvance());
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.
m_scanner->next();
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)
2015-12-16 23:26:41 +00:00
parserError("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(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();
ElementaryTypeNameToken elementaryExpression(m_scanner->currentToken(), firstSize, secondSize);
expression = nodeFactory.createNode<ElementaryTypeNameExpression>(elementaryExpression);
m_scanner->next();
2014-10-16 12:08:54 +00:00
}
else
2015-12-14 17:01:40 +00:00
fatalParserError(string("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);
bool first = true;
2015-08-31 16:44:29 +00:00
while (m_scanner->currentToken() != Token::RBrace)
2015-01-29 17:26:00 +00:00
{
if (!first)
expectToken(Token::Comma);
2015-02-03 20:45:16 +00:00
ret.second.push_back(expectIdentifierToken());
expectToken(Token::Colon);
2015-02-03 20:25:08 +00:00
ret.first.push_back(parseExpression());
2015-01-29 17:26:00 +00:00
if (
m_scanner->currentToken() == Token::Comma &&
m_scanner->peekNextToken() == Token::RBrace
)
{
parserError("Unexpected trailing comma.");
m_scanner->next();
}
first = false;
2015-01-29 17:26:00 +00:00
}
expectToken(Token::RBrace);
2015-01-29 17:26:00 +00:00
}
else
2015-02-03 20:25:08 +00:00
ret.first = parseFunctionCallListArguments();
return ret;
2015-01-29 17:26:00 +00:00
}
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);
2016-09-27 19:37:32 +00:00
if (token == Token::Mapping || token == Token::Function || token == Token::Var)
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, false))
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)
{
m_scanner->next();
iap.path.push_back(parseIdentifier());
}
}
else
{
unsigned firstNum;
unsigned secondNum;
tie(firstNum, secondNum) = m_scanner->currentTokenInfo();
ElementaryTypeNameToken elemToken(m_scanner->currentToken(), firstNum, secondNum);
iap.path.push_back(ASTNodeFactory(*this).createNode<ElementaryTypeNameExpression>(elemToken));
m_scanner->next();
}
while (m_scanner->currentToken() == Token::LBrack)
{
expectToken(Token::LBrack);
ASTPointer<Expression> index;
if (m_scanner->currentToken() != Token::RBrack)
index = parseExpression();
SourceLocation indexLocation = iap.path.front()->location();
indexLocation.end = endPosition();
iap.indices.push_back(make_pair(index, indexLocation));
expectToken(Token::RBrack);
}
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->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());
type = nodeFactory.createNode<UserDefinedTypeName>(path);
}
2018-04-26 08:42:56 +00:00
for (auto const& lengthExpression: _iap.indices)
{
nodeFactory.setLocation(lengthExpression.second);
type = nodeFactory.createNode<ArrayTypeName>(type, lengthExpression.first);
}
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.second);
expression = nodeFactory.createNode<IndexAccess>(expression, index.first);
}
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()
{
// do not advance on success
expectToken(Token::Identifier, false);
return getLiteralAndAdvance();
}
ASTPointer<ASTString> Parser::getLiteralAndAdvance()
{
ASTPointer<ASTString> identifier = make_shared<ASTString>(m_scanner->currentLiteral());
m_scanner->next();
return identifier;
}
2014-10-16 12:08:54 +00:00
}
}