solidity/libsolidity/ast/AST.cpp

556 lines
15 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.
*/
2015-10-20 22:21:52 +00:00
#include <libsolidity/ast/AST.h>
#include <libsolidity/ast/ASTVisitor.h>
#include <libsolidity/ast/AST_accept.h>
#include <libdevcore/SHA3.h>
#include <boost/algorithm/string.hpp>
#include <algorithm>
#include <functional>
2014-10-24 17:06:30 +00:00
using namespace std;
using namespace dev;
using namespace dev::solidity;
2014-10-24 17:06:30 +00:00
class IDDispenser
{
public:
static size_t next() { return ++instance(); }
static void reset() { instance() = 0; }
private:
static size_t& instance()
{
static IDDispenser dispenser;
return dispenser.id;
}
size_t id = 0;
};
ASTNode::ASTNode(SourceLocation const& _location):
m_id(IDDispenser::next()),
m_location(_location)
2014-10-16 12:08:54 +00:00
{
2014-10-23 17:22:30 +00:00
}
ASTNode::~ASTNode()
{
2015-09-21 16:55:58 +00:00
delete m_annotation;
}
void ASTNode::resetID()
{
IDDispenser::reset();
}
2015-09-21 16:55:58 +00:00
ASTAnnotation& ASTNode::annotation() const
{
if (!m_annotation)
m_annotation = new ASTAnnotation();
return *m_annotation;
}
Error ASTNode::createTypeError(string const& _description) const
{
return Error(Error::Type::TypeError) << errinfo_sourceLocation(location()) << errinfo_comment(_description);
}
2015-12-15 14:46:03 +00:00
SourceUnitAnnotation& SourceUnit::annotation() const
{
if (!m_annotation)
m_annotation = new SourceUnitAnnotation();
return dynamic_cast<SourceUnitAnnotation&>(*m_annotation);
2015-12-15 14:46:03 +00:00
}
2016-11-14 10:46:43 +00:00
string Declaration::sourceUnitName() const
{
solAssert(!!m_scope, "");
2016-11-14 10:46:43 +00:00
ASTNode const* scope = m_scope;
while (dynamic_cast<Declaration const*>(scope) && dynamic_cast<Declaration const*>(scope)->m_scope)
scope = dynamic_cast<Declaration const*>(scope)->m_scope;
return dynamic_cast<SourceUnit const&>(*scope).annotation().path;
}
2015-12-09 16:35:20 +00:00
ImportAnnotation& ImportDirective::annotation() const
{
if (!m_annotation)
m_annotation = new ImportAnnotation();
return dynamic_cast<ImportAnnotation&>(*m_annotation);
2015-12-09 16:35:20 +00:00
}
2015-12-15 14:46:03 +00:00
TypePointer ImportDirective::type() const
{
solAssert(!!annotation().sourceUnit, "");
return make_shared<ModuleType>(*annotation().sourceUnit);
}
2015-08-31 16:44:29 +00:00
map<FixedHash<4>, FunctionTypePointer> ContractDefinition::interfaceFunctions() const
{
2015-08-31 16:44:29 +00:00
auto exportedFunctionList = interfaceFunctionList();
map<FixedHash<4>, FunctionTypePointer> exportedFunctions;
for (auto const& it: exportedFunctionList)
exportedFunctions.insert(it);
2015-09-10 08:17:17 +00:00
solAssert(
exportedFunctionList.size() == exportedFunctions.size(),
"Hash collision at Function Definition Hash calculation"
);
return exportedFunctions;
}
2015-08-31 16:44:29 +00:00
FunctionDefinition const* ContractDefinition::constructor() const
2014-12-12 15:49:26 +00:00
{
for (FunctionDefinition const* f: definedFunctions())
if (f->isConstructor())
return f;
2014-12-12 15:49:26 +00:00
return nullptr;
}
bool ContractDefinition::constructorIsPublic() const
{
FunctionDefinition const* f = constructor();
return !f || f->isPublic();
}
2015-08-31 16:44:29 +00:00
FunctionDefinition const* ContractDefinition::fallbackFunction() const
2015-01-29 21:50:20 +00:00
{
for (ContractDefinition const* contract: annotation().linearizedBaseContracts)
for (FunctionDefinition const* f: contract->definedFunctions())
2015-08-31 16:44:29 +00:00
if (f->name().empty())
return f;
2015-01-29 21:50:20 +00:00
return nullptr;
}
vector<EventDefinition const*> const& ContractDefinition::interfaceEvents() const
{
if (!m_interfaceEvents)
{
set<string> eventsSeen;
m_interfaceEvents.reset(new vector<EventDefinition const*>());
for (ContractDefinition const* contract: annotation().linearizedBaseContracts)
for (EventDefinition const* e: contract->events())
2015-08-31 16:44:29 +00:00
if (eventsSeen.count(e->name()) == 0)
{
2015-08-31 16:44:29 +00:00
eventsSeen.insert(e->name());
m_interfaceEvents->push_back(e);
}
}
return *m_interfaceEvents;
}
2015-08-31 16:44:29 +00:00
vector<pair<FixedHash<4>, FunctionTypePointer>> const& ContractDefinition::interfaceFunctionList() const
{
if (!m_interfaceFunctionList)
{
set<string> functionsSeen;
2015-03-01 03:34:39 +00:00
set<string> signaturesSeen;
2015-01-29 16:28:14 +00:00
m_interfaceFunctionList.reset(new vector<pair<FixedHash<4>, FunctionTypePointer>>());
for (ContractDefinition const* contract: annotation().linearizedBaseContracts)
{
vector<FunctionTypePointer> functions;
for (FunctionDefinition const* f: contract->definedFunctions())
if (f->isPartOfExternalInterface())
functions.push_back(make_shared<FunctionType>(*f, false));
for (VariableDeclaration const* v: contract->stateVariables())
if (v->isPartOfExternalInterface())
functions.push_back(make_shared<FunctionType>(*v));
for (FunctionTypePointer const& fun: functions)
2015-03-01 03:34:39 +00:00
{
if (!fun->interfaceFunctionType())
// Fails hopefully because we already registered the error
continue;
string functionSignature = fun->externalSignature();
if (signaturesSeen.count(functionSignature) == 0)
{
2015-03-01 03:34:39 +00:00
signaturesSeen.insert(functionSignature);
2016-10-05 10:30:28 +00:00
FixedHash<4> hash(dev::keccak256(functionSignature));
m_interfaceFunctionList->push_back(make_pair(hash, fun));
}
2015-03-01 03:34:39 +00:00
}
}
}
return *m_interfaceFunctionList;
}
Json::Value const& ContractDefinition::devDocumentation() const
{
return m_devDocumentation;
}
Json::Value const& ContractDefinition::userDocumentation() const
{
return m_userDocumentation;
}
void ContractDefinition::setDevDocumentation(Json::Value const& _devDocumentation)
{
m_devDocumentation = _devDocumentation;
}
void ContractDefinition::setUserDocumentation(Json::Value const& _userDocumentation)
{
m_userDocumentation = _userDocumentation;
}
2015-08-31 16:44:29 +00:00
vector<Declaration const*> const& ContractDefinition::inheritableMembers() const
{
if (!m_inheritableMembers)
{
set<string> memberSeen;
m_inheritableMembers.reset(new vector<Declaration const*>());
auto addInheritableMember = [&](Declaration const* _decl)
{
2016-10-21 10:14:24 +00:00
solAssert(_decl, "addInheritableMember got a nullpointer.");
2015-08-31 16:44:29 +00:00
if (memberSeen.count(_decl->name()) == 0 && _decl->isVisibleInDerivedContracts())
{
2015-08-31 16:44:29 +00:00
memberSeen.insert(_decl->name());
m_inheritableMembers->push_back(_decl);
}
};
for (FunctionDefinition const* f: definedFunctions())
addInheritableMember(f);
for (VariableDeclaration const* v: stateVariables())
addInheritableMember(v);
2015-02-26 11:11:54 +00:00
for (StructDefinition const* s: definedStructs())
addInheritableMember(s);
for (EnumDefinition const* e: definedEnums())
addInheritableMember(e);
for (EventDefinition const* e: events())
addInheritableMember(e);
}
return *m_inheritableMembers;
}
2015-11-19 17:02:04 +00:00
TypePointer ContractDefinition::type() const
2015-02-10 12:40:21 +00:00
{
2015-11-19 17:02:04 +00:00
return make_shared<TypeType>(make_shared<ContractType>(*this));
}
2015-09-21 16:55:58 +00:00
ContractDefinitionAnnotation& ContractDefinition::annotation() const
{
if (!m_annotation)
m_annotation = new ContractDefinitionAnnotation();
return dynamic_cast<ContractDefinitionAnnotation&>(*m_annotation);
2015-09-21 16:55:58 +00:00
}
TypeNameAnnotation& TypeName::annotation() const
{
if (!m_annotation)
m_annotation = new TypeNameAnnotation();
return dynamic_cast<TypeNameAnnotation&>(*m_annotation);
2015-09-21 16:55:58 +00:00
}
2015-11-19 17:02:04 +00:00
TypePointer StructDefinition::type() const
{
return make_shared<TypeType>(make_shared<StructType>(*this));
}
TypeDeclarationAnnotation& StructDefinition::annotation() const
{
if (!m_annotation)
m_annotation = new TypeDeclarationAnnotation();
return dynamic_cast<TypeDeclarationAnnotation&>(*m_annotation);
}
2015-11-19 17:02:04 +00:00
TypePointer EnumValue::type() const
2014-12-03 06:46:55 +00:00
{
auto parentDef = dynamic_cast<EnumDefinition const*>(scope());
solAssert(parentDef, "Enclosing Scope of EnumValue was not set");
return make_shared<EnumType>(*parentDef);
2014-12-03 06:46:55 +00:00
}
2015-11-19 17:02:04 +00:00
TypePointer EnumDefinition::type() const
2015-02-09 17:08:56 +00:00
{
return make_shared<TypeType>(make_shared<EnumType>(*this));
2015-02-09 17:08:56 +00:00
}
TypeDeclarationAnnotation& EnumDefinition::annotation() const
{
if (!m_annotation)
m_annotation = new TypeDeclarationAnnotation();
return dynamic_cast<TypeDeclarationAnnotation&>(*m_annotation);
}
2017-01-10 17:55:36 +00:00
shared_ptr<FunctionType> FunctionDefinition::functionType(bool _internal) const
2017-01-10 15:26:13 +00:00
{
if (_internal)
{
switch (visibility())
{
case Declaration::Visibility::Default:
solAssert(false, "visibility() should not return Default");
case Declaration::Visibility::Private:
case Declaration::Visibility::Internal:
case Declaration::Visibility::Public:
2017-01-10 17:55:36 +00:00
return make_shared<FunctionType>(*this, _internal);
2017-01-10 15:26:13 +00:00
case Declaration::Visibility::External:
return {};
default:
solAssert(false, "visibility() should not return a Visibility");
}
}
else
{
switch (visibility())
{
case Declaration::Visibility::Default:
solAssert(false, "visibility() should not return Default");
case Declaration::Visibility::Private:
case Declaration::Visibility::Internal:
return {};
case Declaration::Visibility::Public:
case Declaration::Visibility::External:
2017-01-10 17:55:36 +00:00
return make_shared<FunctionType>(*this, _internal);
2017-01-10 15:26:13 +00:00
default:
solAssert(false, "visibility() should not return a Visibility");
}
}
// To make the compiler happy
return {};
}
2015-11-19 17:02:04 +00:00
TypePointer FunctionDefinition::type() const
{
return make_shared<FunctionType>(*this);
}
string FunctionDefinition::externalSignature() const
{
return FunctionType(*this).externalSignature();
}
2015-10-26 14:13:36 +00:00
FunctionDefinitionAnnotation& FunctionDefinition::annotation() const
{
if (!m_annotation)
m_annotation = new FunctionDefinitionAnnotation();
return dynamic_cast<FunctionDefinitionAnnotation&>(*m_annotation);
2015-10-26 14:13:36 +00:00
}
2015-11-19 17:02:04 +00:00
TypePointer ModifierDefinition::type() const
{
return make_shared<ModifierType>(*this);
}
2015-10-26 14:13:36 +00:00
ModifierDefinitionAnnotation& ModifierDefinition::annotation() const
{
if (!m_annotation)
m_annotation = new ModifierDefinitionAnnotation();
return dynamic_cast<ModifierDefinitionAnnotation&>(*m_annotation);
2015-10-26 14:13:36 +00:00
}
2015-11-19 17:02:04 +00:00
TypePointer EventDefinition::type() const
{
return make_shared<FunctionType>(*this);
}
2015-03-08 22:26:36 +00:00
2017-01-10 17:55:36 +00:00
std::shared_ptr<FunctionType> EventDefinition::functionType(bool _internal) const
{
if (_internal)
return make_shared<FunctionType>(*this);
else
return {};
}
2015-10-26 14:13:36 +00:00
EventDefinitionAnnotation& EventDefinition::annotation() const
{
if (!m_annotation)
m_annotation = new EventDefinitionAnnotation();
return dynamic_cast<EventDefinitionAnnotation&>(*m_annotation);
2015-10-26 14:13:36 +00:00
}
2015-09-21 16:55:58 +00:00
UserDefinedTypeNameAnnotation& UserDefinedTypeName::annotation() const
{
if (!m_annotation)
m_annotation = new UserDefinedTypeNameAnnotation();
return dynamic_cast<UserDefinedTypeNameAnnotation&>(*m_annotation);
2015-09-21 16:55:58 +00:00
}
bool VariableDeclaration::isLValue() const
{
// External function parameters and constant declared variables are Read-Only
return !isExternalCallableParameter() && !m_isConstant;
}
bool VariableDeclaration::isCallableParameter() const
{
2015-08-31 16:44:29 +00:00
auto const* callable = dynamic_cast<CallableDeclaration const*>(scope());
if (!callable)
return false;
2015-08-31 16:44:29 +00:00
for (auto const& variable: callable->parameters())
if (variable.get() == this)
return true;
2015-08-31 16:44:29 +00:00
if (callable->returnParameterList())
for (auto const& variable: callable->returnParameterList()->parameters())
if (variable.get() == this)
return true;
return false;
}
bool VariableDeclaration::isExternalCallableParameter() const
{
2015-08-31 16:44:29 +00:00
auto const* callable = dynamic_cast<CallableDeclaration const*>(scope());
if (!callable || callable->visibility() != Declaration::Visibility::External)
return false;
2015-08-31 16:44:29 +00:00
for (auto const& variable: callable->parameters())
if (variable.get() == this)
return true;
return false;
}
bool VariableDeclaration::canHaveAutoType() const
{
auto const* callable = dynamic_cast<CallableDeclaration const*>(scope());
return (!!callable && !isCallableParameter());
2014-10-13 16:22:15 +00:00
}
2015-11-19 17:02:04 +00:00
TypePointer VariableDeclaration::type() const
2014-10-13 16:22:15 +00:00
{
return annotation().type;
2014-10-16 12:08:54 +00:00
}
2015-09-21 16:55:58 +00:00
2017-01-10 17:55:36 +00:00
shared_ptr<FunctionType> VariableDeclaration::functionType(bool _internal) const
2017-01-10 15:26:13 +00:00
{
if (_internal)
return {};
switch (visibility())
{
case Declaration::Visibility::Default:
solAssert(false, "visibility() should not return Default");
case Declaration::Visibility::Private:
case Declaration::Visibility::Internal:
return {};
case Declaration::Visibility::Public:
case Declaration::Visibility::External:
2017-01-10 17:55:36 +00:00
return make_shared<FunctionType>(*this);
2017-01-10 15:26:13 +00:00
default:
solAssert(false, "visibility() should not return a Visibility");
}
// To make the compiler happy
return {};
}
2015-09-21 16:55:58 +00:00
VariableDeclarationAnnotation& VariableDeclaration::annotation() const
{
if (!m_annotation)
m_annotation = new VariableDeclarationAnnotation();
return dynamic_cast<VariableDeclarationAnnotation&>(*m_annotation);
2015-09-21 16:55:58 +00:00
}
2015-10-26 16:20:29 +00:00
StatementAnnotation& Statement::annotation() const
{
if (!m_annotation)
m_annotation = new StatementAnnotation();
return dynamic_cast<StatementAnnotation&>(*m_annotation);
2015-10-26 16:20:29 +00:00
}
InlineAssemblyAnnotation& InlineAssembly::annotation() const
{
if (!m_annotation)
m_annotation = new InlineAssemblyAnnotation();
return dynamic_cast<InlineAssemblyAnnotation&>(*m_annotation);
}
2015-09-21 16:55:58 +00:00
ReturnAnnotation& Return::annotation() const
{
if (!m_annotation)
m_annotation = new ReturnAnnotation();
return dynamic_cast<ReturnAnnotation&>(*m_annotation);
2015-09-21 16:55:58 +00:00
}
2015-10-09 18:44:56 +00:00
VariableDeclarationStatementAnnotation& VariableDeclarationStatement::annotation() const
{
if (!m_annotation)
m_annotation = new VariableDeclarationStatementAnnotation();
return dynamic_cast<VariableDeclarationStatementAnnotation&>(*m_annotation);
2015-10-09 18:44:56 +00:00
}
2015-09-21 16:55:58 +00:00
ExpressionAnnotation& Expression::annotation() const
{
if (!m_annotation)
m_annotation = new ExpressionAnnotation();
return dynamic_cast<ExpressionAnnotation&>(*m_annotation);
2015-09-21 16:55:58 +00:00
}
MemberAccessAnnotation& MemberAccess::annotation() const
{
if (!m_annotation)
m_annotation = new MemberAccessAnnotation();
return dynamic_cast<MemberAccessAnnotation&>(*m_annotation);
2015-09-21 16:55:58 +00:00
}
BinaryOperationAnnotation& BinaryOperation::annotation() const
{
if (!m_annotation)
m_annotation = new BinaryOperationAnnotation();
return dynamic_cast<BinaryOperationAnnotation&>(*m_annotation);
2015-09-21 16:55:58 +00:00
}
FunctionCallAnnotation& FunctionCall::annotation() const
{
if (!m_annotation)
m_annotation = new FunctionCallAnnotation();
return dynamic_cast<FunctionCallAnnotation&>(*m_annotation);
2015-09-21 16:55:58 +00:00
}
IdentifierAnnotation& Identifier::annotation() const
{
if (!m_annotation)
m_annotation = new IdentifierAnnotation();
return dynamic_cast<IdentifierAnnotation&>(*m_annotation);
2015-09-21 16:55:58 +00:00
}
2017-06-28 15:59:34 +00:00
bool Literal::isHexNumber() const
2017-06-26 11:49:05 +00:00
{
if (token() != Token::Number)
return false;
2017-06-28 16:00:14 +00:00
return boost::starts_with(value(), "0x");
2017-06-26 11:49:05 +00:00
}
bool Literal::looksLikeAddress() const
{
if (subDenomination() != SubDenomination::None)
return false;
2017-06-26 11:49:05 +00:00
2017-06-28 15:59:34 +00:00
if (!isHexNumber())
2017-06-22 14:39:42 +00:00
return false;
2017-06-26 11:49:05 +00:00
return abs(int(value().length()) - 42) <= 1;
}
bool Literal::passesAddressChecksum() const
{
2017-06-28 15:59:34 +00:00
solAssert(isHexNumber(), "Expected hex number");
2017-06-26 11:49:05 +00:00
return dev::passesAddressChecksum(value(), true);
}