solidity/libsolidity/ast/AST.h

1697 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 abstract syntax tree.
*/
#pragma once
2014-10-13 16:22:15 +00:00
2015-10-20 22:21:52 +00:00
#include <libsolidity/ast/ASTForward.h>
#include <libsolidity/parsing/Token.h>
#include <libsolidity/ast/Types.h>
#include <libsolidity/ast/ASTAnnotations.h>
#include <libsolidity/ast/ASTEnums.h>
#include <libevmasm/SourceLocation.h>
#include <libevmasm/Instruction.h>
#include <libdevcore/FixedHash.h>
#include <json/json.h>
#include <boost/noncopyable.hpp>
#include <string>
#include <vector>
#include <memory>
2014-10-16 12:08:54 +00:00
namespace dev
{
namespace solidity
{
class ASTVisitor;
class ASTConstVisitor;
/**
* The root (abstract) class of the AST inheritance tree.
* It is possible to traverse all direct and indirect children of an AST node by calling
* accept, providing an ASTVisitor.
*/
2014-10-16 21:49:45 +00:00
class ASTNode: private boost::noncopyable
{
public:
explicit ASTNode(SourceLocation const& _location);
virtual ~ASTNode();
2017-01-17 09:31:09 +00:00
/// @returns an identifier of this AST node that is unique for a single compilation run.
size_t id() const { return m_id; }
/// Resets the global ID counter. This invalidates all previous IDs.
static void resetID();
2017-01-17 09:31:09 +00:00
virtual void accept(ASTVisitor& _visitor) = 0;
virtual void accept(ASTConstVisitor& _visitor) const = 0;
template <class T>
static void listAccept(std::vector<T> const& _list, ASTVisitor& _visitor)
2014-10-16 12:08:54 +00:00
{
for (T const& element: _list)
2014-10-16 12:08:54 +00:00
element->accept(_visitor);
}
template <class T>
static void listAccept(std::vector<T> const& _list, ASTConstVisitor& _visitor)
{
for (T const& element: _list)
element->accept(_visitor);
}
2015-11-26 16:28:44 +00:00
/// @returns a copy of the vector containing only the nodes which derive from T.
template <class _T>
static std::vector<_T const*> filteredNodes(std::vector<ASTPointer<ASTNode>> const& _nodes);
/// Returns the source code location of this node.
2015-08-31 16:44:29 +00:00
SourceLocation const& location() const { return m_location; }
2014-10-20 14:28:24 +00:00
///@todo make this const-safe by providing a different way to access the annotation
2015-09-21 16:55:58 +00:00
virtual ASTAnnotation& annotation() const;
2014-10-20 10:41:56 +00:00
///@{
///@name equality operators
2014-10-20 10:41:56 +00:00
/// Equality relies on the fact that nodes cannot be copied.
bool operator==(ASTNode const& _other) const { return this == &_other; }
bool operator!=(ASTNode const& _other) const { return !operator==(_other); }
///@}
2015-09-21 16:55:58 +00:00
protected:
2017-01-20 14:56:56 +00:00
size_t const m_id = 0;
2015-09-21 16:55:58 +00:00
/// Annotation - is specialised in derived classes, is created upon request (because of polymorphism).
mutable ASTAnnotation* m_annotation = nullptr;
private:
SourceLocation m_location;
};
2015-11-26 16:28:44 +00:00
template <class _T>
std::vector<_T const*> ASTNode::filteredNodes(std::vector<ASTPointer<ASTNode>> const& _nodes)
{
std::vector<_T const*> ret;
for (auto const& n: _nodes)
if (auto const* nt = dynamic_cast<_T const*>(n.get()))
ret.push_back(nt);
return ret;
}
2014-12-03 06:46:55 +00:00
/**
* Source unit containing import directives and contract definitions.
*/
class SourceUnit: public ASTNode
{
public:
SourceUnit(SourceLocation const& _location, std::vector<ASTPointer<ASTNode>> const& _nodes):
2014-12-03 06:46:55 +00:00
ASTNode(_location), m_nodes(_nodes) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-12-15 14:46:03 +00:00
virtual SourceUnitAnnotation& annotation() const override;
2014-12-03 06:46:55 +00:00
2015-08-31 16:44:29 +00:00
std::vector<ASTPointer<ASTNode>> nodes() const { return m_nodes; }
2014-12-03 06:46:55 +00:00
/// @returns a set of referenced SourceUnits. Recursively if @a _recurse is true.
std::set<SourceUnit const*> referencedSourceUnits(bool _recurse = false, std::set<SourceUnit const*> _skipList = std::set<SourceUnit const*>()) const;
2017-07-12 23:08:28 +00:00
2014-12-03 06:46:55 +00:00
private:
std::vector<ASTPointer<ASTNode>> m_nodes;
};
2018-02-09 15:53:25 +00:00
/**
* Abstract class that is added to each AST node that is stored inside a scope
* (including scopes).
*/
class Scopable
{
public:
virtual ~Scopable() = default;
2018-02-09 15:53:25 +00:00
/// @returns the scope this declaration resides in. Can be nullptr if it is the global scope.
/// Available only after name and type resolution step.
ASTNode const* scope() const { return m_scope; }
void setScope(ASTNode const* _scope) { m_scope = _scope; }
/// @returns the source unit this scopable is present in.
SourceUnit const& sourceUnit() const;
/// @returns the source name this scopable is present in.
/// Can be combined with annotation().canonicalName (if present) to form a globally unique name.
std::string sourceUnitName() const;
2018-02-09 15:53:25 +00:00
protected:
ASTNode const* m_scope = nullptr;
};
2014-12-03 06:46:55 +00:00
/**
2015-12-15 14:46:03 +00:00
* Abstract AST class for a declaration (contract, function, struct, variable, import directive).
*/
2018-02-09 15:53:25 +00:00
class Declaration: public ASTNode, public Scopable
2014-10-13 16:22:15 +00:00
{
public:
2015-02-13 23:43:02 +00:00
/// Visibility ordered from restricted to unrestricted.
2015-02-22 18:37:54 +00:00
enum class Visibility { Default, Private, Internal, Public, External };
2017-08-09 13:29:03 +00:00
static std::string visibilityToString(Declaration::Visibility _visibility)
{
switch(_visibility)
{
case Declaration::Visibility::Public:
return "public";
case Declaration::Visibility::Internal:
return "internal";
case Declaration::Visibility::Private:
return "private";
case Declaration::Visibility::External:
return "external";
default:
solAssert(false, "Invalid visibility specifier.");
}
return std::string();
}
2015-09-24 09:03:44 +00:00
Declaration(
SourceLocation const& _location,
ASTPointer<ASTString> const& _name,
Visibility _visibility = Visibility::Default
):
2018-02-09 15:53:25 +00:00
ASTNode(_location), m_name(_name), m_visibility(_visibility) {}
2014-10-13 16:22:15 +00:00
2014-12-01 14:22:45 +00:00
/// @returns the declared name.
2015-08-31 16:44:29 +00:00
ASTString const& name() const { return *m_name; }
bool noVisibilitySpecified() const { return m_visibility == Visibility::Default; }
2015-08-31 16:44:29 +00:00
Visibility visibility() const { return m_visibility == Visibility::Default ? defaultVisibility() : m_visibility; }
bool isPublic() const { return visibility() >= Visibility::Public; }
virtual bool isVisibleInContract() const { return visibility() != Visibility::External; }
bool isVisibleInDerivedContracts() const { return isVisibleInContract() && visibility() >= Visibility::Internal; }
bool isVisibleAsLibraryMember() const { return visibility() >= Visibility::Internal; }
2015-02-02 16:24:09 +00:00
2016-11-14 10:46:43 +00:00
virtual bool isLValue() const { return false; }
virtual bool isPartOfExternalInterface() const { return false; }
/// @returns the type of expressions referencing this declaration.
/// The current contract has to be given since this context can change the type, especially of
/// contract types.
/// This can only be called once types of variable declarations have already been resolved.
2015-11-19 17:02:04 +00:00
virtual TypePointer type() const = 0;
2017-01-10 15:26:13 +00:00
/// @param _internal false indicates external interface is concerned, true indicates internal interface is concerned.
/// @returns null when it is not accessible as a function.
virtual FunctionTypePointer functionType(bool /*_internal*/) const { return {}; }
2017-01-10 15:26:13 +00:00
2015-02-02 16:24:09 +00:00
protected:
2015-08-31 16:44:29 +00:00
virtual Visibility defaultVisibility() const { return Visibility::Public; }
2015-02-02 16:24:09 +00:00
2014-10-13 16:22:15 +00:00
private:
ASTPointer<ASTString> m_name;
2015-02-02 16:24:09 +00:00
Visibility m_visibility;
2014-10-13 16:22:15 +00:00
};
2016-08-19 17:57:21 +00:00
/**
* Pragma directive, only version requirements in the form `pragma solidity "^0.4.0";` are
* supported for now.
*/
class PragmaDirective: public ASTNode
{
public:
PragmaDirective(
SourceLocation const& _location,
std::vector<Token::Value> const& _tokens,
std::vector<ASTString> const& _literals
): ASTNode(_location), m_tokens(_tokens), m_literals(_literals)
{}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
std::vector<Token::Value> const& tokens() const { return m_tokens; }
std::vector<ASTString> const& literals() const { return m_literals; }
private:
/// Sequence of tokens following the "pragma" keyword.
std::vector<Token::Value> m_tokens;
/// Sequence of literals following the "pragma" keyword.
std::vector<ASTString> m_literals;
};
2015-12-15 14:46:03 +00:00
/**
* Import directive for referencing other files / source objects.
* Example: import "abc.sol" // imports all symbols of "abc.sol" into current scope
* Source objects are identified by a string which can be a file name but does not have to be.
* Other ways to use it:
* import "abc" as x; // creates symbol "x" that contains all symbols in "abc"
* import * as x from "abc"; // same as above
* import {a as b, c} from "abc"; // creates new symbols "b" and "c" referencing "a" and "c" in "abc", respectively.
*/
class ImportDirective: public Declaration
{
public:
ImportDirective(
SourceLocation const& _location,
ASTPointer<ASTString> const& _path,
ASTPointer<ASTString> const& _unitAlias,
std::vector<std::pair<ASTPointer<Identifier>, ASTPointer<ASTString>>>&& _symbolAliases
):
Declaration(_location, _unitAlias),
m_path(_path),
m_symbolAliases(_symbolAliases)
{ }
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
ASTString const& path() const { return *m_path; }
2016-01-11 12:55:58 +00:00
std::vector<std::pair<ASTPointer<Identifier>, ASTPointer<ASTString>>> const& symbolAliases() const
{
return m_symbolAliases;
}
2015-12-15 14:46:03 +00:00
virtual ImportAnnotation& annotation() const override;
virtual TypePointer type() const override;
private:
ASTPointer<ASTString> m_path;
/// The aliases for the specific symbols to import. If non-empty import the specific symbols.
/// If the second component is empty, import the identifier unchanged.
/// If both m_unitAlias and m_symbolAlias are empty, import all symbols into the current scope.
std::vector<std::pair<ASTPointer<Identifier>, ASTPointer<ASTString>>> m_symbolAliases;
};
2015-01-29 16:28:14 +00:00
/**
* Abstract class that is added to each AST node that can store local variables.
2018-02-09 15:53:52 +00:00
* Local variables in functions are always added to functions, even though they are not
* in scope for the whole function.
2015-01-29 16:28:14 +00:00
*/
class VariableScope
{
public:
virtual ~VariableScope() = default;
2015-01-29 16:28:14 +00:00
void addLocalVariable(VariableDeclaration const& _localVariable) { m_localVariables.push_back(&_localVariable); }
2015-08-31 16:44:29 +00:00
std::vector<VariableDeclaration const*> const& localVariables() const { return m_localVariables; }
2015-01-29 16:28:14 +00:00
private:
std::vector<VariableDeclaration const*> m_localVariables;
};
/**
* Abstract class that is added to each AST node that can receive documentation.
*/
class Documented
{
public:
virtual ~Documented() = default;
2015-01-29 16:28:14 +00:00
explicit Documented(ASTPointer<ASTString> const& _documentation): m_documentation(_documentation) {}
/// @return A shared pointer of an ASTString.
/// Can contain a nullptr in which case indicates absence of documentation
2015-08-31 16:44:29 +00:00
ASTPointer<ASTString> const& documentation() const { return m_documentation; }
2015-01-29 16:28:14 +00:00
protected:
ASTPointer<ASTString> m_documentation;
};
/**
* Abstract class that is added to AST nodes that can be marked as not being fully implemented
*/
class ImplementationOptional
{
public:
virtual ~ImplementationOptional() = default;
explicit ImplementationOptional(bool _implemented): m_implemented(_implemented) {}
/// @return whether this node is fully implemented or not
bool isImplemented() const { return m_implemented; }
protected:
bool m_implemented;
};
2015-01-29 16:28:14 +00:00
/// @}
/**
* Definition of a contract or library. This is the only AST nodes where child nodes are not visited in
* document order. It first visits all struct declarations, then all variable declarations and
* finally all function declarations.
*/
class ContractDefinition: public Declaration, public Documented
{
public:
2017-02-07 22:11:50 +00:00
enum class ContractKind { Interface, Contract, Library };
ContractDefinition(
SourceLocation const& _location,
ASTPointer<ASTString> const& _name,
ASTPointer<ASTString> const& _documentation,
std::vector<ASTPointer<InheritanceSpecifier>> const& _baseContracts,
std::vector<ASTPointer<ASTNode>> const& _subNodes,
2017-02-07 22:11:50 +00:00
ContractKind _contractKind = ContractKind::Contract
):
Declaration(_location, _name),
Documented(_documentation),
2015-01-15 15:15:01 +00:00
m_baseContracts(_baseContracts),
m_subNodes(_subNodes),
2017-02-07 22:11:50 +00:00
m_contractKind(_contractKind)
2014-10-09 10:28:37 +00:00
{}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-08-31 16:44:29 +00:00
std::vector<ASTPointer<InheritanceSpecifier>> const& baseContracts() const { return m_baseContracts; }
std::vector<ASTPointer<ASTNode>> const& subNodes() const { return m_subNodes; }
2015-11-25 13:23:35 +00:00
std::vector<UsingForDirective const*> usingForDirectives() const { return filteredNodes<UsingForDirective>(m_subNodes); }
2015-11-26 16:28:44 +00:00
std::vector<StructDefinition const*> definedStructs() const { return filteredNodes<StructDefinition>(m_subNodes); }
std::vector<EnumDefinition const*> definedEnums() const { return filteredNodes<EnumDefinition>(m_subNodes); }
std::vector<VariableDeclaration const*> stateVariables() const { return filteredNodes<VariableDeclaration>(m_subNodes); }
std::vector<ModifierDefinition const*> functionModifiers() const { return filteredNodes<ModifierDefinition>(m_subNodes); }
std::vector<FunctionDefinition const*> definedFunctions() const { return filteredNodes<FunctionDefinition>(m_subNodes); }
std::vector<EventDefinition const*> events() const { return filteredNodes<EventDefinition>(m_subNodes); }
std::vector<EventDefinition const*> const& interfaceEvents() const;
2017-02-07 22:11:50 +00:00
bool isLibrary() const { return m_contractKind == ContractKind::Library; }
2014-10-20 14:28:24 +00:00
/// @returns a map of canonical function signatures to FunctionDefinitions
/// as intended for use by the ABI.
2015-08-31 16:44:29 +00:00
std::map<FixedHash<4>, FunctionTypePointer> interfaceFunctions() const;
std::vector<std::pair<FixedHash<4>, FunctionTypePointer>> const& interfaceFunctionList() const;
2014-11-23 23:00:46 +00:00
/// @returns a list of the inheritable members of this contract
2015-08-31 16:44:29 +00:00
std::vector<Declaration const*> const& inheritableMembers() const;
2015-01-29 21:50:20 +00:00
/// Returns the constructor or nullptr if no constructor was specified.
2015-08-31 16:44:29 +00:00
FunctionDefinition const* constructor() const;
/// @returns true iff the constructor of this contract is public (or non-existing).
bool constructorIsPublic() const;
/// Returns the fallback function or nullptr if no fallback function was specified.
2015-08-31 16:44:29 +00:00
FunctionDefinition const* fallbackFunction() const;
2014-12-12 15:49:26 +00:00
std::string fullyQualifiedName() const { return sourceUnitName() + ":" + name(); }
2015-11-19 17:02:04 +00:00
virtual TypePointer type() const override;
2015-09-21 16:55:58 +00:00
virtual ContractDefinitionAnnotation& annotation() const override;
2017-02-07 22:11:50 +00:00
ContractKind contractKind() const { return m_contractKind; }
private:
std::vector<ASTPointer<InheritanceSpecifier>> m_baseContracts;
std::vector<ASTPointer<ASTNode>> m_subNodes;
2017-02-07 22:11:50 +00:00
ContractKind m_contractKind;
std::vector<ContractDefinition const*> m_linearizedBaseContracts;
mutable std::unique_ptr<std::vector<std::pair<FixedHash<4>, FunctionTypePointer>>> m_interfaceFunctionList;
mutable std::unique_ptr<std::vector<EventDefinition const*>> m_interfaceEvents;
mutable std::unique_ptr<std::vector<Declaration const*>> m_inheritableMembers;
};
class InheritanceSpecifier: public ASTNode
{
public:
InheritanceSpecifier(
SourceLocation const& _location,
ASTPointer<UserDefinedTypeName> const& _baseName,
std::unique_ptr<std::vector<ASTPointer<Expression>>> _arguments
):
ASTNode(_location), m_baseName(_baseName), m_arguments(std::move(_arguments)) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
UserDefinedTypeName const& name() const { return *m_baseName; }
// Returns nullptr if no argument list was given (``C``).
// If an argument list is given (``C(...)``), the arguments are returned
// as a vector of expressions. Note that this vector can be empty (``C()``).
std::vector<ASTPointer<Expression>> const* arguments() const { return m_arguments.get(); }
private:
ASTPointer<UserDefinedTypeName> m_baseName;
std::unique_ptr<std::vector<ASTPointer<Expression>>> m_arguments;
};
2015-11-22 19:39:10 +00:00
/**
* `using LibraryName for uint` will attach all functions from the library LibraryName
* to `uint` if the first parameter matches the type. `using LibraryName for *` attaches
* the function to any matching type.
*/
class UsingForDirective: public ASTNode
{
public:
UsingForDirective(
SourceLocation const& _location,
ASTPointer<UserDefinedTypeName> const& _libraryName,
2015-11-22 19:39:10 +00:00
ASTPointer<TypeName> const& _typeName
):
ASTNode(_location), m_libraryName(_libraryName), m_typeName(_typeName) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
UserDefinedTypeName const& libraryName() const { return *m_libraryName; }
2015-11-22 19:39:10 +00:00
/// @returns the type name the library is attached to, null for `*`.
TypeName const* typeName() const { return m_typeName.get(); }
private:
ASTPointer<UserDefinedTypeName> m_libraryName;
2015-11-22 19:39:10 +00:00
ASTPointer<TypeName> m_typeName;
};
2014-10-16 21:49:45 +00:00
class StructDefinition: public Declaration
{
public:
StructDefinition(
SourceLocation const& _location,
ASTPointer<ASTString> const& _name,
std::vector<ASTPointer<VariableDeclaration>> const& _members
):
2014-10-22 22:24:07 +00:00
Declaration(_location, _name), m_members(_members) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-08-31 16:44:29 +00:00
std::vector<ASTPointer<VariableDeclaration>> const& members() const { return m_members; }
2014-11-07 01:06:37 +00:00
2015-11-19 17:02:04 +00:00
virtual TypePointer type() const override;
virtual TypeDeclarationAnnotation& annotation() const override;
private:
std::vector<ASTPointer<VariableDeclaration>> m_members;
};
2015-02-09 17:08:56 +00:00
class EnumDefinition: public Declaration
{
public:
EnumDefinition(
SourceLocation const& _location,
ASTPointer<ASTString> const& _name,
std::vector<ASTPointer<EnumValue>> const& _members
):
2015-02-09 17:08:56 +00:00
Declaration(_location, _name), m_members(_members) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-08-31 16:44:29 +00:00
std::vector<ASTPointer<EnumValue>> const& members() const { return m_members; }
2015-02-09 17:08:56 +00:00
2015-11-19 17:02:04 +00:00
virtual TypePointer type() const override;
2015-02-09 17:08:56 +00:00
virtual TypeDeclarationAnnotation& annotation() const override;
2015-02-09 17:08:56 +00:00
private:
2015-02-13 16:34:46 +00:00
std::vector<ASTPointer<EnumValue>> m_members;
2015-02-09 17:08:56 +00:00
};
/**
* Declaration of an Enum Value
*/
class EnumValue: public Declaration
{
public:
EnumValue(SourceLocation const& _location, ASTPointer<ASTString> const& _name):
Declaration(_location, _name) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-11-19 17:02:04 +00:00
virtual TypePointer type() const override;
};
/**
* Parameter list, used as function parameter list and return list.
* None of the parameters is allowed to contain mappings (not even recursively
2014-11-13 00:12:57 +00:00
* inside structs).
*/
2014-10-16 21:49:45 +00:00
class ParameterList: public ASTNode
{
public:
2015-09-24 09:03:44 +00:00
ParameterList(
SourceLocation const& _location,
std::vector<ASTPointer<VariableDeclaration>> const& _parameters
):
2014-10-22 22:24:07 +00:00
ASTNode(_location), m_parameters(_parameters) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2014-10-13 13:07:21 +00:00
2015-08-31 16:44:29 +00:00
std::vector<ASTPointer<VariableDeclaration>> const& parameters() const { return m_parameters; }
2014-10-20 14:28:24 +00:00
private:
std::vector<ASTPointer<VariableDeclaration>> m_parameters;
};
/**
* Base class for all nodes that define function-like objects, i.e. FunctionDefinition,
* EventDefinition and ModifierDefinition.
*/
class CallableDeclaration: public Declaration, public VariableScope
{
public:
CallableDeclaration(
SourceLocation const& _location,
ASTPointer<ASTString> const& _name,
Declaration::Visibility _visibility,
ASTPointer<ParameterList> const& _parameters,
ASTPointer<ParameterList> const& _returnParameters = ASTPointer<ParameterList>()
):
Declaration(_location, _name, _visibility),
m_parameters(_parameters),
m_returnParameters(_returnParameters)
{
}
2015-08-31 16:44:29 +00:00
std::vector<ASTPointer<VariableDeclaration>> const& parameters() const { return m_parameters->parameters(); }
ParameterList const& parameterList() const { return *m_parameters; }
ASTPointer<ParameterList> const& returnParameterList() const { return m_returnParameters; }
protected:
ASTPointer<ParameterList> m_parameters;
ASTPointer<ParameterList> m_returnParameters;
};
class FunctionDefinition: public CallableDeclaration, public Documented, public ImplementationOptional
{
public:
FunctionDefinition(
SourceLocation const& _location,
ASTPointer<ASTString> const& _name,
Declaration::Visibility _visibility,
StateMutability _stateMutability,
bool _isConstructor,
ASTPointer<ASTString> const& _documentation,
ASTPointer<ParameterList> const& _parameters,
std::vector<ASTPointer<ModifierInvocation>> const& _modifiers,
ASTPointer<ParameterList> const& _returnParameters,
ASTPointer<Block> const& _body
):
CallableDeclaration(_location, _name, _visibility, _parameters, _returnParameters),
Documented(_documentation),
ImplementationOptional(_body != nullptr),
m_stateMutability(_stateMutability),
m_isConstructor(_isConstructor),
m_functionModifiers(_modifiers),
m_body(_body)
{}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
StateMutability stateMutability() const { return m_stateMutability; }
bool isConstructor() const { return m_isConstructor; }
bool isFallback() const { return !m_isConstructor && name().empty(); }
bool isPayable() const { return m_stateMutability == StateMutability::Payable; }
2015-08-31 16:44:29 +00:00
std::vector<ASTPointer<ModifierInvocation>> const& modifiers() const { return m_functionModifiers; }
std::vector<ASTPointer<VariableDeclaration>> const& returnParameters() const { return m_returnParameters->parameters(); }
Block const& body() const { solAssert(m_body, ""); return *m_body; }
virtual bool isVisibleInContract() const override
{
2017-07-27 19:55:55 +00:00
return Declaration::isVisibleInContract() && !isConstructor() && !isFallback();
}
2017-07-27 19:55:55 +00:00
virtual bool isPartOfExternalInterface() const override { return isPublic() && !isConstructor() && !isFallback(); }
2014-11-03 17:39:16 +00:00
/// @returns the external signature of the function
/// That consists of the name of the function followed by the types of the
/// arguments separated by commas all enclosed in parentheses without any spaces.
std::string externalSignature() const;
ContractDefinition::ContractKind inContractKind() const;
2015-11-19 17:02:04 +00:00
virtual TypePointer type() const override;
2017-01-10 15:26:13 +00:00
/// @param _internal false indicates external interface is concerned, true indicates internal interface is concerned.
/// @returns null when it is not accessible as a function.
virtual FunctionTypePointer functionType(bool /*_internal*/) const override;
2017-01-10 15:26:13 +00:00
2015-10-26 14:13:36 +00:00
virtual FunctionDefinitionAnnotation& annotation() const override;
private:
StateMutability m_stateMutability;
bool m_isConstructor;
std::vector<ASTPointer<ModifierInvocation>> m_functionModifiers;
ASTPointer<Block> m_body;
};
/**
* Declaration of a variable. This can be used in various places, e.g. in function parameter
2017-01-18 15:43:23 +00:00
* lists, struct definitions and even function bodies.
*/
2014-10-16 21:49:45 +00:00
class VariableDeclaration: public Declaration
{
public:
enum Location { Default, Storage, Memory, CallData };
2015-03-03 11:58:01 +00:00
VariableDeclaration(
SourceLocation const& _sourceLocation,
2015-03-16 13:45:11 +00:00
ASTPointer<TypeName> const& _type,
ASTPointer<ASTString> const& _name,
ASTPointer<Expression> _value,
Visibility _visibility,
bool _isStateVar = false,
bool _isIndexed = false,
bool _isConstant = false,
Location _referenceLocation = Location::Default
2015-03-16 13:45:11 +00:00
):
Declaration(_sourceLocation, _name, _visibility),
2015-03-03 11:58:01 +00:00
m_typeName(_type),
m_value(_value),
m_isStateVariable(_isStateVar),
m_isIndexed(_isIndexed),
m_isConstant(_isConstant),
m_location(_referenceLocation) {}
2015-03-03 11:58:01 +00:00
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
TypeName* typeName() const { return m_typeName.get(); }
2015-08-31 16:44:29 +00:00
ASTPointer<Expression> const& value() const { return m_value; }
2014-10-13 16:22:15 +00:00
virtual bool isLValue() const override;
virtual bool isPartOfExternalInterface() const override { return isPublic(); }
2018-08-07 13:58:34 +00:00
/// @returns true iff this variable is the parameter (or return parameter) of a function
/// (or function type name or event) or declared inside a function body.
2018-02-09 15:53:52 +00:00
bool isLocalVariable() const;
/// @returns true if this variable is a parameter or return parameter of a function.
bool isCallableParameter() const;
2017-07-06 09:05:05 +00:00
/// @returns true if this variable is a return parameter of a function.
bool isReturnParameter() const;
/// @returns true if this variable is a local variable or return parameter.
bool isLocalOrReturn() const;
/// @returns true if this variable is a parameter (not return parameter) of an external function.
2018-08-07 13:58:34 +00:00
/// This excludes parameters of external function type names.
bool isExternalCallableParameter() const;
2018-08-07 13:58:34 +00:00
/// @returns true if this variable is a parameter or return parameter of an internal function
/// or a function type of internal visibility.
bool isInternalCallableParameter() const;
/// @returns true iff this variable is a parameter(or return parameter of a library function
bool isLibraryFunctionParameter() const;
/// @returns true if the type of the variable does not need to be specified, i.e. it is declared
/// in the body of a function or modifier.
2018-08-07 13:58:34 +00:00
/// @returns true if this variable is a parameter of an event.
bool isEventParameter() const;
/// @returns true if the type of the variable is a reference or mapping type, i.e.
/// array, struct or mapping. These types can take a data location (and often require it).
/// Can only be called after reference resolution.
bool hasReferenceOrMappingType() const;
bool isStateVariable() const { return m_isStateVariable; }
2015-01-29 13:35:28 +00:00
bool isIndexed() const { return m_isIndexed; }
2015-03-03 11:58:01 +00:00
bool isConstant() const { return m_isConstant; }
Location referenceLocation() const { return m_location; }
2018-08-07 13:58:34 +00:00
/// @returns a set of allowed storage locations for the variable.
std::set<Location> allowedDataLocations() const;
2014-10-13 16:22:15 +00:00
2015-11-19 17:02:04 +00:00
virtual TypePointer type() const override;
2017-01-10 15:26:13 +00:00
/// @param _internal false indicates external interface is concerned, true indicates internal interface is concerned.
/// @returns null when it is not accessible as a function.
virtual FunctionTypePointer functionType(bool /*_internal*/) const override;
2017-01-10 15:26:13 +00:00
2015-09-21 16:55:58 +00:00
virtual VariableDeclarationAnnotation& annotation() const override;
2015-02-02 16:24:09 +00:00
protected:
2015-08-31 16:44:29 +00:00
Visibility defaultVisibility() const override { return Visibility::Internal; }
2015-02-02 16:24:09 +00:00
private:
2015-06-05 12:45:47 +00:00
ASTPointer<TypeName> m_typeName; ///< can be empty ("var")
/// Initially assigned value, can be missing. For local variables, this is stored inside
/// VariableDeclarationStatement and not here.
ASTPointer<Expression> m_value;
2015-06-05 12:45:47 +00:00
bool m_isStateVariable; ///< Whether or not this is a contract state variable
bool m_isIndexed; ///< Whether this is an indexed variable (used by events).
bool m_isConstant; ///< Whether the variable is a compile-time constant.
Location m_location; ///< Location of the variable if it is of reference type.
};
2015-01-21 10:16:18 +00:00
/**
* Definition of a function modifier.
*/
class ModifierDefinition: public CallableDeclaration, public Documented
2015-01-21 10:16:18 +00:00
{
public:
2015-06-15 12:39:34 +00:00
ModifierDefinition(
SourceLocation const& _location,
ASTPointer<ASTString> const& _name,
ASTPointer<ASTString> const& _documentation,
ASTPointer<ParameterList> const& _parameters,
ASTPointer<Block> const& _body
):
2017-07-18 21:58:48 +00:00
CallableDeclaration(_location, _name, Visibility::Internal, _parameters),
Documented(_documentation),
m_body(_body)
{
}
2015-01-21 10:16:18 +00:00
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-08-31 16:44:29 +00:00
Block const& body() const { return *m_body; }
2015-01-21 10:16:18 +00:00
2015-11-19 17:02:04 +00:00
virtual TypePointer type() const override;
2015-01-21 10:16:18 +00:00
2015-10-26 14:13:36 +00:00
virtual ModifierDefinitionAnnotation& annotation() const override;
2015-01-21 10:16:18 +00:00
private:
ASTPointer<Block> m_body;
};
/**
* Invocation/usage of a modifier in a function header or a base constructor call.
*/
class ModifierInvocation: public ASTNode
{
public:
ModifierInvocation(
SourceLocation const& _location,
ASTPointer<Identifier> const& _name,
std::unique_ptr<std::vector<ASTPointer<Expression>>> _arguments
):
ASTNode(_location), m_modifierName(_name), m_arguments(std::move(_arguments)) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-08-31 16:44:29 +00:00
ASTPointer<Identifier> const& name() const { return m_modifierName; }
// Returns nullptr if no argument list was given (``mod``).
// If an argument list is given (``mod(...)``), the arguments are returned
// as a vector of expressions. Note that this vector can be empty (``mod()``).
std::vector<ASTPointer<Expression>> const* arguments() const { return m_arguments.get(); }
private:
ASTPointer<Identifier> m_modifierName;
std::unique_ptr<std::vector<ASTPointer<Expression>>> m_arguments;
};
2015-01-29 13:35:28 +00:00
/**
* Definition of a (loggable) event.
*/
class EventDefinition: public CallableDeclaration, public Documented
2015-01-29 13:35:28 +00:00
{
public:
EventDefinition(
SourceLocation const& _location,
ASTPointer<ASTString> const& _name,
ASTPointer<ASTString> const& _documentation,
ASTPointer<ParameterList> const& _parameters,
bool _anonymous = false
):
CallableDeclaration(_location, _name, Visibility::Default, _parameters),
Documented(_documentation),
m_anonymous(_anonymous)
{
}
2015-01-29 13:35:28 +00:00
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-03-17 10:34:56 +00:00
bool isAnonymous() const { return m_anonymous; }
2015-01-29 13:35:28 +00:00
2015-11-19 17:02:04 +00:00
virtual TypePointer type() const override;
virtual FunctionTypePointer functionType(bool /*_internal*/) const override;
2015-01-29 13:35:28 +00:00
2015-10-26 14:13:36 +00:00
virtual EventDefinitionAnnotation& annotation() const override;
2015-01-29 13:35:28 +00:00
private:
bool m_anonymous = false;
2015-01-29 13:35:28 +00:00
};
2014-11-21 18:14:56 +00:00
/**
2014-11-26 12:19:17 +00:00
* Pseudo AST node that is used as declaration for "this", "msg", "tx", "block" and the global
* functions when such an identifier is encountered. Will never have a valid location in the source code.
2014-11-21 18:14:56 +00:00
*/
class MagicVariableDeclaration: public Declaration
{
public:
2014-11-26 12:19:17 +00:00
MagicVariableDeclaration(ASTString const& _name, std::shared_ptr<Type const> const& _type):
Declaration(SourceLocation(), std::make_shared<ASTString>(_name)), m_type(_type) {}
virtual void accept(ASTVisitor&) override
{
solAssert(false, "MagicVariableDeclaration used inside real AST.");
}
virtual void accept(ASTConstVisitor&) const override
{
solAssert(false, "MagicVariableDeclaration used inside real AST.");
}
2014-11-21 18:14:56 +00:00
virtual FunctionTypePointer functionType(bool) const override
{
solAssert(m_type->category() == Type::Category::Function, "");
return std::dynamic_pointer_cast<FunctionType const>(m_type);
}
2015-11-19 17:02:04 +00:00
virtual TypePointer type() const override { return m_type; }
2014-11-21 18:14:56 +00:00
private:
std::shared_ptr<Type const> m_type;
};
/// Types
/// @{
/**
* Abstract base class of a type name, can be any built-in or user-defined type.
*/
2014-10-16 21:49:45 +00:00
class TypeName: public ASTNode
{
protected:
explicit TypeName(SourceLocation const& _location): ASTNode(_location) {}
2014-10-13 16:22:15 +00:00
public:
2015-09-21 16:55:58 +00:00
virtual TypeNameAnnotation& annotation() const override;
};
/**
* Any pre-defined type name represented by a single keyword, i.e. it excludes mappings,
* contracts, functions, etc.
*/
2014-10-16 21:49:45 +00:00
class ElementaryTypeName: public TypeName
{
public:
ElementaryTypeName(SourceLocation const& _location, ElementaryTypeNameToken const& _elem):
TypeName(_location), m_type(_elem)
{}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
ElementaryTypeNameToken const& typeName() const { return m_type; }
2014-10-20 14:28:24 +00:00
private:
ElementaryTypeNameToken m_type;
};
/**
* Name referring to a user-defined type (i.e. a struct, contract, etc.).
*/
2014-10-16 21:49:45 +00:00
class UserDefinedTypeName: public TypeName
{
public:
2015-10-06 10:35:10 +00:00
UserDefinedTypeName(SourceLocation const& _location, std::vector<ASTString> const& _namePath):
TypeName(_location), m_namePath(_namePath) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-10-06 10:35:10 +00:00
std::vector<ASTString> const& namePath() const { return m_namePath; }
2014-10-20 14:28:24 +00:00
2015-09-21 16:55:58 +00:00
virtual UserDefinedTypeNameAnnotation& annotation() const override;
2014-10-20 14:28:24 +00:00
private:
2015-10-06 10:35:10 +00:00
std::vector<ASTString> m_namePath;
};
2016-09-27 19:37:32 +00:00
/**
* A literal function type. Its source form is "function (paramType1, paramType2) internal / external returns (retType1, retType2)"
*/
class FunctionTypeName: public TypeName
{
public:
FunctionTypeName(
SourceLocation const& _location,
ASTPointer<ParameterList> const& _parameterTypes,
ASTPointer<ParameterList> const& _returnTypes,
Declaration::Visibility _visibility,
StateMutability _stateMutability
2016-09-27 19:37:32 +00:00
):
TypeName(_location), m_parameterTypes(_parameterTypes), m_returnTypes(_returnTypes),
m_visibility(_visibility), m_stateMutability(_stateMutability)
2016-09-27 19:37:32 +00:00
{}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
std::vector<ASTPointer<VariableDeclaration>> const& parameterTypes() const { return m_parameterTypes->parameters(); }
std::vector<ASTPointer<VariableDeclaration>> const& returnParameterTypes() const { return m_returnTypes->parameters(); }
ASTPointer<ParameterList> const& parameterTypeList() const { return m_parameterTypes; }
ASTPointer<ParameterList> const& returnParameterTypeList() const { return m_returnTypes; }
2016-09-27 19:37:32 +00:00
Declaration::Visibility visibility() const
{
return m_visibility == Declaration::Visibility::Default ? Declaration::Visibility::Internal : m_visibility;
}
StateMutability stateMutability() const { return m_stateMutability; }
bool isPayable() const { return m_stateMutability == StateMutability::Payable; }
2016-09-27 19:37:32 +00:00
private:
ASTPointer<ParameterList> m_parameterTypes;
ASTPointer<ParameterList> m_returnTypes;
Declaration::Visibility m_visibility;
StateMutability m_stateMutability;
2016-09-27 19:37:32 +00:00
};
/**
* A mapping type. Its source form is "mapping('keyType' => 'valueType')"
*/
2014-10-16 21:49:45 +00:00
class Mapping: public TypeName
{
public:
2015-09-24 09:03:44 +00:00
Mapping(
SourceLocation const& _location,
ASTPointer<ElementaryTypeName> const& _keyType,
ASTPointer<TypeName> const& _valueType
):
2014-10-22 22:24:07 +00:00
TypeName(_location), m_keyType(_keyType), m_valueType(_valueType) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2014-11-10 16:31:09 +00:00
2015-08-31 16:44:29 +00:00
ElementaryTypeName const& keyType() const { return *m_keyType; }
TypeName const& valueType() const { return *m_valueType; }
2014-10-20 14:28:24 +00:00
private:
ASTPointer<ElementaryTypeName> m_keyType;
ASTPointer<TypeName> m_valueType;
};
/**
* An array type, can be "typename[]" or "typename[<expression>]".
*/
class ArrayTypeName: public TypeName
{
public:
2015-09-24 09:03:44 +00:00
ArrayTypeName(
SourceLocation const& _location,
ASTPointer<TypeName> const& _baseType,
ASTPointer<Expression> const& _length
):
TypeName(_location), m_baseType(_baseType), m_length(_length) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-08-31 16:44:29 +00:00
TypeName const& baseType() const { return *m_baseType; }
Expression const* length() const { return m_length.get(); }
private:
ASTPointer<TypeName> m_baseType;
ASTPointer<Expression> m_length; ///< Length of the array, might be empty.
};
/// @}
/// Statements
/// @{
/**
* Abstract base class for statements.
*/
2015-10-26 16:20:29 +00:00
class Statement: public ASTNode, public Documented
{
public:
2015-10-26 16:20:29 +00:00
explicit Statement(
SourceLocation const& _location,
ASTPointer<ASTString> const& _docString
): ASTNode(_location), Documented(_docString) {}
virtual StatementAnnotation& annotation() const override;
};
namespace assembly
{
// Forward-declaration to AsmData.h
struct Block;
}
2016-02-22 01:13:41 +00:00
/**
* Inline assembly.
*/
class InlineAssembly: public Statement
{
public:
InlineAssembly(
SourceLocation const& _location,
ASTPointer<ASTString> const& _docString,
std::shared_ptr<assembly::Block> const& _operations
2016-02-22 01:13:41 +00:00
):
Statement(_location, _docString), m_operations(_operations) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
assembly::Block const& operations() const { return *m_operations; }
virtual InlineAssemblyAnnotation& annotation() const override;
2016-02-22 01:13:41 +00:00
private:
std::shared_ptr<assembly::Block> m_operations;
2016-02-22 01:13:41 +00:00
};
/**
* Brace-enclosed block containing zero or more statements.
*/
2018-02-09 15:53:52 +00:00
class Block: public Statement, public Scopable
{
public:
2015-09-24 09:03:44 +00:00
Block(
SourceLocation const& _location,
2015-10-26 16:20:29 +00:00
ASTPointer<ASTString> const& _docString,
2015-09-24 09:03:44 +00:00
std::vector<ASTPointer<Statement>> const& _statements
):
2015-10-26 16:20:29 +00:00
Statement(_location, _docString), m_statements(_statements) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2014-10-13 16:22:15 +00:00
2015-11-11 14:20:53 +00:00
std::vector<ASTPointer<Statement>> const& statements() const { return m_statements; }
private:
std::vector<ASTPointer<Statement>> m_statements;
};
2015-01-21 10:16:18 +00:00
/**
* Special placeholder statement denoted by "_" used in function modifiers. This is replaced by
* the original function when the modifier is applied.
*/
class PlaceholderStatement: public Statement
{
public:
2015-10-26 16:20:29 +00:00
explicit PlaceholderStatement(
SourceLocation const& _location,
ASTPointer<ASTString> const& _docString
): Statement(_location, _docString) {}
2015-01-21 10:16:18 +00:00
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
};
/**
* If-statement with an optional "else" part. Note that "else if" is modeled by having a new
* if-statement as the false (else) body.
*/
2014-10-16 21:49:45 +00:00
class IfStatement: public Statement
{
public:
2015-09-24 09:03:44 +00:00
IfStatement(
SourceLocation const& _location,
2015-10-26 16:20:29 +00:00
ASTPointer<ASTString> const& _docString,
2015-09-24 09:03:44 +00:00
ASTPointer<Expression> const& _condition,
ASTPointer<Statement> const& _trueBody,
ASTPointer<Statement> const& _falseBody
):
2015-10-26 16:20:29 +00:00
Statement(_location, _docString),
2015-09-24 09:03:44 +00:00
m_condition(_condition),
m_trueBody(_trueBody),
m_falseBody(_falseBody)
{}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2014-10-20 14:28:24 +00:00
2015-08-31 16:44:29 +00:00
Expression const& condition() const { return *m_condition; }
Statement const& trueStatement() const { return *m_trueBody; }
2015-02-10 12:40:21 +00:00
/// @returns the "else" part of the if statement or nullptr if there is no "else" part.
2015-08-31 16:44:29 +00:00
Statement const* falseStatement() const { return m_falseBody.get(); }
2014-11-03 17:39:16 +00:00
private:
ASTPointer<Expression> m_condition;
ASTPointer<Statement> m_trueBody;
2014-10-31 12:29:32 +00:00
ASTPointer<Statement> m_falseBody; ///< "else" part, optional
};
/**
* Statement in which a break statement is legal (abstract class).
*/
2014-10-16 21:49:45 +00:00
class BreakableStatement: public Statement
{
public:
2015-10-26 16:20:29 +00:00
explicit BreakableStatement(
SourceLocation const& _location,
ASTPointer<ASTString> const& _docString
): Statement(_location, _docString) {}
};
2014-10-16 21:49:45 +00:00
class WhileStatement: public BreakableStatement
{
public:
2015-09-24 09:03:44 +00:00
WhileStatement(
SourceLocation const& _location,
2015-10-26 16:20:29 +00:00
ASTPointer<ASTString> const& _docString,
2015-09-24 09:03:44 +00:00
ASTPointer<Expression> const& _condition,
ASTPointer<Statement> const& _body,
bool _isDoWhile
2015-09-24 09:03:44 +00:00
):
BreakableStatement(_location, _docString), m_condition(_condition), m_body(_body),
m_isDoWhile(_isDoWhile) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2014-10-20 14:28:24 +00:00
2015-08-31 16:44:29 +00:00
Expression const& condition() const { return *m_condition; }
Statement const& body() const { return *m_body; }
bool isDoWhile() const { return m_isDoWhile; }
2014-11-03 17:39:16 +00:00
private:
ASTPointer<Expression> m_condition;
ASTPointer<Statement> m_body;
bool m_isDoWhile;
};
/**
* For loop statement
*/
2018-02-09 15:53:52 +00:00
class ForStatement: public BreakableStatement, public Scopable
{
public:
ForStatement(
SourceLocation const& _location,
2015-10-26 16:20:29 +00:00
ASTPointer<ASTString> const& _docString,
ASTPointer<Statement> const& _initExpression,
ASTPointer<Expression> const& _conditionExpression,
ASTPointer<ExpressionStatement> const& _loopExpression,
ASTPointer<Statement> const& _body
):
2015-10-26 16:20:29 +00:00
BreakableStatement(_location, _docString),
m_initExpression(_initExpression),
m_condExpression(_conditionExpression),
m_loopExpression(_loopExpression),
m_body(_body)
{}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-08-31 16:44:29 +00:00
Statement const* initializationExpression() const { return m_initExpression.get(); }
Expression const* condition() const { return m_condExpression.get(); }
ExpressionStatement const* loopExpression() const { return m_loopExpression.get(); }
Statement const& body() const { return *m_body; }
private:
/// For statement's initialization expression. for(XXX; ; ). Can be empty
ASTPointer<Statement> m_initExpression;
/// For statement's condition expression. for(; XXX ; ). Can be empty
ASTPointer<Expression> m_condExpression;
/// For statement's loop expression. for(;;XXX). Can be empty
ASTPointer<ExpressionStatement> m_loopExpression;
/// The body of the loop
ASTPointer<Statement> m_body;
};
2014-10-16 21:49:45 +00:00
class Continue: public Statement
{
public:
2015-10-26 16:20:29 +00:00
explicit Continue(SourceLocation const& _location, ASTPointer<ASTString> const& _docString):
Statement(_location, _docString) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
};
2014-10-16 21:49:45 +00:00
class Break: public Statement
{
public:
2015-10-26 16:20:29 +00:00
explicit Break(SourceLocation const& _location, ASTPointer<ASTString> const& _docString):
Statement(_location, _docString) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
};
2014-10-16 21:49:45 +00:00
class Return: public Statement
{
public:
2015-10-26 16:20:29 +00:00
Return(
SourceLocation const& _location,
ASTPointer<ASTString> const& _docString,
ASTPointer<Expression> _expression
): Statement(_location, _docString), m_expression(_expression) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2014-10-13 16:22:15 +00:00
2015-08-31 16:44:29 +00:00
Expression const* expression() const { return m_expression.get(); }
2014-10-20 14:28:24 +00:00
2015-09-21 16:55:58 +00:00
virtual ReturnAnnotation& annotation() const override;
private:
2014-10-31 12:29:32 +00:00
ASTPointer<Expression> m_expression; ///< value to return, optional
};
2015-09-15 14:33:14 +00:00
/**
* @brief The Throw statement to throw that triggers a solidity exception(jump to ErrorTag)
*/
class Throw: public Statement
{
public:
2015-10-26 16:20:29 +00:00
explicit Throw(SourceLocation const& _location, ASTPointer<ASTString> const& _docString):
Statement(_location, _docString) {}
2015-09-15 14:33:14 +00:00
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
};
2018-02-16 15:55:21 +00:00
/**
* The emit statement is used to emit events: emit EventName(arg1, ..., argn)
*/
class EmitStatement: public Statement
{
public:
explicit EmitStatement(
SourceLocation const& _location,
ASTPointer<ASTString> const& _docString,
ASTPointer<FunctionCall> const& _functionCall
):
Statement(_location, _docString), m_eventCall(_functionCall) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
FunctionCall const& eventCall() const { return *m_eventCall; }
private:
ASTPointer<FunctionCall> m_eventCall;
};
/**
* Definition of one or more variables as a statement inside a function.
* If multiple variables are declared, a value has to be assigned directly.
* If only a single variable is declared, the value can be missing.
* Examples:
* uint[] memory a; uint a = 2;
* (uint a, bytes32 b, ) = f(); (, uint a, , StructName storage x) = g();
*/
class VariableDeclarationStatement: public Statement
{
public:
VariableDeclarationStatement(
SourceLocation const& _location,
2015-10-26 16:20:29 +00:00
ASTPointer<ASTString> const& _docString,
std::vector<ASTPointer<VariableDeclaration>> const& _variables,
ASTPointer<Expression> const& _initialValue
):
2015-10-26 16:20:29 +00:00
Statement(_location, _docString), m_variables(_variables), m_initialValue(_initialValue) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2014-10-13 16:22:15 +00:00
std::vector<ASTPointer<VariableDeclaration>> const& declarations() const { return m_variables; }
Expression const* initialValue() const { return m_initialValue.get(); }
private:
/// List of variables, some of which can be empty pointers (unnamed components).
/// Note that the ``m_value`` member of these is unused. Instead, ``m_initialValue``
/// below is used, because the initial value can be a single expression assigned
/// to all variables.
std::vector<ASTPointer<VariableDeclaration>> m_variables;
/// The assigned expression / initial value.
ASTPointer<Expression> m_initialValue;
};
/**
* A statement that contains only an expression (i.e. an assignment, function call, ...).
*/
class ExpressionStatement: public Statement
{
public:
2015-09-24 09:03:44 +00:00
ExpressionStatement(
SourceLocation const& _location,
2015-10-26 16:20:29 +00:00
ASTPointer<ASTString> const& _docString,
2015-09-24 09:03:44 +00:00
ASTPointer<Expression> _expression
):
2015-10-26 16:20:29 +00:00
Statement(_location, _docString), m_expression(_expression) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-08-31 16:44:29 +00:00
Expression const& expression() const { return *m_expression; }
private:
ASTPointer<Expression> m_expression;
};
/// @}
/// Expressions
/// @{
/**
* An expression, i.e. something that has a value (which can also be of type "void" in case
* of some function calls).
* @abstract
*/
class Expression: public ASTNode
{
public:
2015-09-24 09:03:44 +00:00
explicit Expression(SourceLocation const& _location): ASTNode(_location) {}
2015-09-21 16:55:58 +00:00
ExpressionAnnotation& annotation() const override;
};
2015-12-22 16:44:51 +00:00
class Conditional: public Expression
{
public:
Conditional(
SourceLocation const& _location,
ASTPointer<Expression> const& _condition,
ASTPointer<Expression> const& _trueExpression,
ASTPointer<Expression> const& _falseExpression
):
Expression(_location),
m_condition(_condition),
m_trueExpression(_trueExpression),
m_falseExpression(_falseExpression)
{}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
Expression const& condition() const { return *m_condition; }
Expression const& trueExpression() const { return *m_trueExpression; }
Expression const& falseExpression() const { return *m_falseExpression; }
private:
ASTPointer<Expression> m_condition;
ASTPointer<Expression> m_trueExpression;
ASTPointer<Expression> m_falseExpression;
};
/// Assignment, can also be a compound assignment.
/// Examples: (a = 7 + 8) or (a *= 2)
2014-10-16 21:49:45 +00:00
class Assignment: public Expression
{
public:
Assignment(
SourceLocation const& _location,
ASTPointer<Expression> const& _leftHandSide,
Token::Value _assignmentOperator,
ASTPointer<Expression> const& _rightHandSide
):
Expression(_location),
m_leftHandSide(_leftHandSide),
m_assigmentOperator(_assignmentOperator),
m_rightHandSide(_rightHandSide)
2014-11-05 13:20:56 +00:00
{
solAssert(Token::isAssignmentOp(_assignmentOperator), "");
2014-11-05 13:20:56 +00:00
}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-08-31 16:44:29 +00:00
Expression const& leftHandSide() const { return *m_leftHandSide; }
Token::Value assignmentOperator() const { return m_assigmentOperator; }
Expression const& rightHandSide() const { return *m_rightHandSide; }
2014-10-20 14:28:24 +00:00
private:
ASTPointer<Expression> m_leftHandSide;
2014-10-09 10:28:37 +00:00
Token::Value m_assigmentOperator;
ASTPointer<Expression> m_rightHandSide;
};
2015-12-14 23:40:35 +00:00
2015-10-12 21:02:35 +00:00
/**
2015-12-14 23:40:35 +00:00
* Tuple, parenthesized expression, or bracketed expression.
* Examples: (1, 2), (x,), (x), (), [1, 2],
2015-10-12 21:02:35 +00:00
* Individual components might be empty shared pointers (as in the second example).
* The respective types in lvalue context are: 2-tuple, 2-tuple (with wildcard), type of x, 0-tuple
* Not in lvalue context: 2-tuple, _1_-tuple, type of x, 0-tuple.
*/
class TupleExpression: public Expression
{
public:
TupleExpression(
SourceLocation const& _location,
2015-12-15 17:16:54 +00:00
std::vector<ASTPointer<Expression>> const& _components,
bool _isArray
2015-10-12 21:02:35 +00:00
):
Expression(_location),
m_components(_components),
2015-12-15 17:16:54 +00:00
m_isArray(_isArray) {}
2015-10-12 21:02:35 +00:00
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
std::vector<ASTPointer<Expression>> const& components() const { return m_components; }
bool isInlineArray() const { return m_isArray; }
2015-10-12 21:02:35 +00:00
private:
std::vector<ASTPointer<Expression>> m_components;
bool m_isArray;
2015-10-12 21:02:35 +00:00
};
/**
* Operation involving a unary operator, pre- or postfix.
* Examples: ++i, delete x or !true
*/
2014-10-16 21:49:45 +00:00
class UnaryOperation: public Expression
{
public:
2015-09-24 09:03:44 +00:00
UnaryOperation(
SourceLocation const& _location,
Token::Value _operator,
ASTPointer<Expression> const& _subExpression,
bool _isPrefix
):
Expression(_location),
m_operator(_operator),
m_subExpression(_subExpression),
m_isPrefix(_isPrefix)
2014-11-05 13:20:56 +00:00
{
solAssert(Token::isUnaryOp(_operator), "");
2014-11-05 13:20:56 +00:00
}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
Token::Value getOperator() const { return m_operator; }
bool isPrefixOperation() const { return m_isPrefix; }
2015-08-31 16:44:29 +00:00
Expression const& subExpression() const { return *m_subExpression; }
2014-10-20 14:28:24 +00:00
private:
2014-10-09 10:28:37 +00:00
Token::Value m_operator;
ASTPointer<Expression> m_subExpression;
bool m_isPrefix;
};
/**
* Operation involving a binary operator.
* Examples: 1 + 2, true && false or 1 <= 4
*/
2014-10-16 21:49:45 +00:00
class BinaryOperation: public Expression
{
public:
2015-09-24 09:03:44 +00:00
BinaryOperation(
SourceLocation const& _location,
ASTPointer<Expression> const& _left,
Token::Value _operator,
ASTPointer<Expression> const& _right
):
2014-11-05 13:20:56 +00:00
Expression(_location), m_left(_left), m_operator(_operator), m_right(_right)
{
solAssert(Token::isBinaryOp(_operator) || Token::isCompareOp(_operator), "");
2014-11-05 13:20:56 +00:00
}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-08-31 16:44:29 +00:00
Expression const& leftExpression() const { return *m_left; }
Expression const& rightExpression() const { return *m_right; }
Token::Value getOperator() const { return m_operator; }
2014-10-20 14:28:24 +00:00
2015-09-21 16:55:58 +00:00
BinaryOperationAnnotation& annotation() const override;
2014-10-20 14:28:24 +00:00
private:
ASTPointer<Expression> m_left;
2014-10-09 10:28:37 +00:00
Token::Value m_operator;
ASTPointer<Expression> m_right;
};
/**
* Can be ordinary function call, type cast or struct construction.
*/
2014-10-16 21:49:45 +00:00
class FunctionCall: public Expression
{
public:
2015-09-24 09:03:44 +00:00
FunctionCall(
SourceLocation const& _location,
ASTPointer<Expression> const& _expression,
std::vector<ASTPointer<Expression>> const& _arguments,
std::vector<ASTPointer<ASTString>> const& _names
):
2015-01-29 17:26:00 +00:00
Expression(_location), m_expression(_expression), m_arguments(_arguments), m_names(_names) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-08-31 16:44:29 +00:00
Expression const& expression() const { return *m_expression; }
std::vector<ASTPointer<Expression const>> arguments() const { return {m_arguments.begin(), m_arguments.end()}; }
std::vector<ASTPointer<ASTString>> const& names() const { return m_names; }
2014-10-25 14:52:22 +00:00
2015-09-21 16:55:58 +00:00
virtual FunctionCallAnnotation& annotation() const override;
2014-10-20 14:28:24 +00:00
private:
ASTPointer<Expression> m_expression;
std::vector<ASTPointer<Expression>> m_arguments;
2015-02-03 20:25:08 +00:00
std::vector<ASTPointer<ASTString>> m_names;
};
2014-12-12 15:49:26 +00:00
/**
* Expression that creates a new contract or memory-array,
* e.g. the "new SomeContract" part in "new SomeContract(1, 2)".
2014-12-12 15:49:26 +00:00
*/
class NewExpression: public Expression
{
public:
2015-09-24 09:03:44 +00:00
NewExpression(
SourceLocation const& _location,
ASTPointer<TypeName> const& _typeName
2015-09-24 09:03:44 +00:00
):
Expression(_location), m_typeName(_typeName) {}
2014-12-12 15:49:26 +00:00
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
TypeName const& typeName() const { return *m_typeName; }
2014-12-12 15:49:26 +00:00
private:
ASTPointer<TypeName> m_typeName;
2014-12-12 15:49:26 +00:00
};
/**
* Access to a member of an object. Example: x.name
*/
2014-10-16 21:49:45 +00:00
class MemberAccess: public Expression
{
public:
2015-09-24 09:03:44 +00:00
MemberAccess(
SourceLocation const& _location,
ASTPointer<Expression> _expression,
ASTPointer<ASTString> const& _memberName
):
2014-10-22 22:24:07 +00:00
Expression(_location), m_expression(_expression), m_memberName(_memberName) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-08-31 16:44:29 +00:00
Expression const& expression() const { return *m_expression; }
ASTString const& memberName() const { return *m_memberName; }
2014-10-20 14:28:24 +00:00
2015-09-21 16:55:58 +00:00
virtual MemberAccessAnnotation& annotation() const override;
2014-10-20 14:28:24 +00:00
private:
ASTPointer<Expression> m_expression;
ASTPointer<ASTString> m_memberName;
};
/**
* Index access to an array. Example: a[2]
*/
2014-10-16 21:49:45 +00:00
class IndexAccess: public Expression
{
public:
2015-09-24 09:03:44 +00:00
IndexAccess(
SourceLocation const& _location,
ASTPointer<Expression> const& _base,
ASTPointer<Expression> const& _index
):
2014-10-22 22:24:07 +00:00
Expression(_location), m_base(_base), m_index(_index) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2014-10-20 14:28:24 +00:00
2015-08-31 16:44:29 +00:00
Expression const& baseExpression() const { return *m_base; }
Expression const* indexExpression() const { return m_index.get(); }
2014-11-13 00:12:57 +00:00
private:
ASTPointer<Expression> m_base;
ASTPointer<Expression> m_index;
};
/**
* Primary expression, i.e. an expression that cannot be divided any further. Examples are literals
* or variable references.
*/
2014-10-16 21:49:45 +00:00
class PrimaryExpression: public Expression
{
public:
PrimaryExpression(SourceLocation const& _location): Expression(_location) {}
};
/**
* An identifier, i.e. a reference to a declaration by name like a variable or function.
*/
2014-10-16 21:49:45 +00:00
class Identifier: public PrimaryExpression
{
public:
2015-09-24 09:03:44 +00:00
Identifier(
SourceLocation const& _location,
ASTPointer<ASTString> const& _name
):
2015-03-01 03:34:39 +00:00
PrimaryExpression(_location), m_name(_name) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-08-31 16:44:29 +00:00
ASTString const& name() const { return *m_name; }
2015-09-21 16:55:58 +00:00
virtual IdentifierAnnotation& annotation() const override;
private:
ASTPointer<ASTString> m_name;
};
/**
* An elementary type name expression is used in expressions like "a = uint32(2)" to change the
* type of an expression explicitly. Here, "uint32" is the elementary type name expression and
* "uint32(2)" is a @ref FunctionCall.
*/
2014-10-16 21:49:45 +00:00
class ElementaryTypeNameExpression: public PrimaryExpression
{
public:
ElementaryTypeNameExpression(SourceLocation const& _location, ElementaryTypeNameToken const& _type):
PrimaryExpression(_location), m_typeToken(_type)
{}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
ElementaryTypeNameToken const& typeName() const { return m_typeToken; }
2014-10-20 14:28:24 +00:00
private:
ElementaryTypeNameToken m_typeToken;
};
/**
* A literal string or number. @see ExpressionCompiler::endVisit() is used to actually parse its value.
*/
2014-10-16 21:49:45 +00:00
class Literal: public PrimaryExpression
{
public:
2015-02-05 21:38:07 +00:00
enum class SubDenomination
{
None = Token::Illegal,
2015-02-05 22:03:24 +00:00
Wei = Token::SubWei,
Szabo = Token::SubSzabo,
Finney = Token::SubFinney,
2015-03-04 16:35:23 +00:00
Ether = Token::SubEther,
Second = Token::SubSecond,
Minute = Token::SubMinute,
Hour = Token::SubHour,
Day = Token::SubDay,
Week = Token::SubWeek,
Year = Token::SubYear
2015-02-05 21:38:07 +00:00
};
2015-09-24 09:03:44 +00:00
Literal(
SourceLocation const& _location,
Token::Value _token,
ASTPointer<ASTString> const& _value,
SubDenomination _sub = SubDenomination::None
):
2015-02-06 12:38:10 +00:00
PrimaryExpression(_location), m_token(_token), m_value(_value), m_subDenomination(_sub) {}
virtual void accept(ASTVisitor& _visitor) override;
virtual void accept(ASTConstVisitor& _visitor) const override;
2015-08-31 16:44:29 +00:00
Token::Value token() const { return m_token; }
/// @returns the non-parsed value of the literal
2015-08-31 16:44:29 +00:00
ASTString const& value() const { return *m_value; }
2014-10-20 14:28:24 +00:00
2015-08-31 16:44:29 +00:00
SubDenomination subDenomination() const { return m_subDenomination; }
2017-06-26 11:49:05 +00:00
/// @returns true if this is a number with a hex prefix.
2017-06-28 15:59:34 +00:00
bool isHexNumber() const;
2017-06-26 11:49:05 +00:00
/// @returns true if this looks like a checksummed address.
bool looksLikeAddress() const;
/// @returns true if it passes the address checksum test.
bool passesAddressChecksum() const;
/// @returns the checksummed version of an address (or empty string if not valid)
std::string getChecksummedAddress() const;
private:
Token::Value m_token;
ASTPointer<ASTString> m_value;
2015-02-05 21:38:07 +00:00
SubDenomination m_subDenomination;
};
/// @}
2014-10-16 12:08:54 +00:00
}
}