solidity/NameAndTypeResolver.cpp

475 lines
15 KiB
C++
Raw Normal View History

2014-10-13 15:13:48 +00:00
/*
2014-10-16 12:08:54 +00:00
This file is part of cpp-ethereum.
2014-10-13 15:13:48 +00:00
2014-10-16 12:08:54 +00:00
cpp-ethereum is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
2014-10-13 15:13:48 +00:00
2014-10-16 12:08:54 +00:00
cpp-ethereum is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
2014-10-13 15:13:48 +00:00
2014-10-16 12:08:54 +00:00
You should have received a copy of the GNU General Public License
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
2014-10-13 15:13:48 +00:00
*/
/**
* @author Christian <c@ethdev.com>
* @date 2014
* Parser part that determines the declarations corresponding to names and the types of expressions.
*/
2014-10-13 13:07:21 +00:00
#include <libsolidity/NameAndTypeResolver.h>
#include <libsolidity/AST.h>
2014-10-15 12:45:51 +00:00
#include <libsolidity/Exceptions.h>
2014-10-13 13:07:21 +00:00
2014-10-24 17:06:30 +00:00
using namespace std;
2014-10-16 12:08:54 +00:00
namespace dev
{
namespace solidity
{
2014-10-13 13:07:21 +00:00
2015-04-20 12:57:56 +00:00
NameAndTypeResolver::NameAndTypeResolver(vector<Declaration const*> const& _globals)
{
2014-12-06 01:32:51 +00:00
for (Declaration const* declaration: _globals)
m_scopes[nullptr].registerDeclaration(*declaration);
}
void NameAndTypeResolver::registerDeclarations(SourceUnit& _sourceUnit)
{
// The helper registers all declarations in m_scopes as a side-effect of its construction.
DeclarationRegistrationHelper registrar(m_scopes, _sourceUnit);
}
2014-10-13 13:07:21 +00:00
void NameAndTypeResolver::resolveNamesAndTypes(ContractDefinition& _contract)
{
m_currentScope = &m_scopes[nullptr];
for (ASTPointer<InheritanceSpecifier> const& baseContract: _contract.getBaseContracts())
2015-01-19 18:18:34 +00:00
ReferencesResolver resolver(*baseContract, *this, &_contract, nullptr);
m_currentScope = &m_scopes[&_contract];
linearizeBaseContracts(_contract);
// we first import non-functions only as we do not yet know the argument types
for (ContractDefinition const* base: _contract.getLinearizedBaseContracts())
importInheritedScope(*base, false); // import non-functions
2014-11-13 00:12:57 +00:00
for (ASTPointer<StructDefinition> const& structDef: _contract.getDefinedStructs())
2015-01-19 18:18:34 +00:00
ReferencesResolver resolver(*structDef, *this, &_contract, nullptr);
for (ASTPointer<EnumDefinition> const& enumDef: _contract.getDefinedEnums())
ReferencesResolver resolver(*enumDef, *this, &_contract, nullptr);
for (ASTPointer<VariableDeclaration> const& variable: _contract.getStateVariables())
2015-01-19 18:18:34 +00:00
ReferencesResolver resolver(*variable, *this, &_contract, nullptr);
2015-01-29 13:35:28 +00:00
for (ASTPointer<EventDefinition> const& event: _contract.getEvents())
ReferencesResolver resolver(*event, *this, &_contract, nullptr);
// these can contain code, only resolve parameters for now
for (ASTPointer<ModifierDefinition> const& modifier: _contract.getFunctionModifiers())
{
m_currentScope = &m_scopes[modifier.get()];
ReferencesResolver resolver(*modifier, *this, &_contract, nullptr);
}
for (ASTPointer<FunctionDefinition> const& function: _contract.getDefinedFunctions())
2014-10-16 12:08:54 +00:00
{
m_currentScope = &m_scopes[function.get()];
2015-01-19 18:18:34 +00:00
ReferencesResolver referencesResolver(*function, *this, &_contract,
function->getReturnParameterList().get());
}
m_currentScope = &m_scopes[&_contract];
for (ContractDefinition const* base: _contract.getLinearizedBaseContracts())
importInheritedScope(*base, true); // import functions
// now resolve references inside the code
for (ASTPointer<ModifierDefinition> const& modifier: _contract.getFunctionModifiers())
{
m_currentScope = &m_scopes[modifier.get()];
ReferencesResolver resolver(*modifier, *this, &_contract, nullptr, true);
}
for (ASTPointer<FunctionDefinition> const& function: _contract.getDefinedFunctions())
{
m_currentScope = &m_scopes[function.get()];
ReferencesResolver referencesResolver(
*function,
*this,
&_contract,
function->getReturnParameterList().get(),
true
);
}
2014-10-13 13:07:21 +00:00
}
void NameAndTypeResolver::checkTypeRequirements(ContractDefinition& _contract)
{
for (ASTPointer<StructDefinition> const& structDef: _contract.getDefinedStructs())
structDef->checkValidityOfMembers();
_contract.checkTypeRequirements();
}
2014-12-06 01:32:51 +00:00
void NameAndTypeResolver::updateDeclaration(Declaration const& _declaration)
{
2015-02-13 23:43:02 +00:00
m_scopes[nullptr].registerDeclaration(_declaration, false, true);
solAssert(_declaration.getScope() == nullptr, "Updated declaration outside global scope.");
}
set<Declaration const*> NameAndTypeResolver::resolveName(ASTString const& _name, Declaration const* _scope) const
2014-10-13 13:07:21 +00:00
{
auto iterator = m_scopes.find(_scope);
if (iterator == end(m_scopes))
2015-04-20 12:57:56 +00:00
return set<Declaration const*>({});
return iterator->second.resolveName(_name, false);
2014-10-13 13:07:21 +00:00
}
set<Declaration const*> NameAndTypeResolver::getNameFromCurrentScope(ASTString const& _name, bool _recursive)
2014-10-13 13:07:21 +00:00
{
return m_currentScope->resolveName(_name, _recursive);
}
void NameAndTypeResolver::importInheritedScope(ContractDefinition const& _base, bool _importFunctions)
{
auto iterator = m_scopes.find(&_base);
solAssert(iterator != end(m_scopes), "");
for (auto const& nameAndDeclaration: iterator->second.getDeclarations())
2015-03-01 03:34:39 +00:00
for (auto const& declaration: nameAndDeclaration.second)
// Import if it was declared in the base, is not the constructor and is visible in derived classes
if (declaration->getScope() == &_base && declaration->isVisibleInDerivedContracts())
{
auto function = dynamic_cast<FunctionDefinition const*>(declaration);
if ((function == nullptr) == _importFunctions)
continue;
if (!!function)
{
FunctionType functionType(*function);
// only import if a function with the same arguments does not exist yet
bool functionWithEqualArgumentsFound = false;
for (auto knownDeclaration: m_currentScope->resolveName(nameAndDeclaration.first))
{
auto knownFunction = dynamic_cast<FunctionDefinition const*>(knownDeclaration);
if (!knownFunction)
continue; // this is not legal, but will be caught later
if (!FunctionType(*knownFunction).hasEqualArgumentTypes(functionType))
continue;
functionWithEqualArgumentsFound = true;
break;
}
if (functionWithEqualArgumentsFound)
continue;
}
2015-03-01 03:34:39 +00:00
m_currentScope->registerDeclaration(*declaration);
}
}
void NameAndTypeResolver::linearizeBaseContracts(ContractDefinition& _contract) const
{
// order in the lists is from derived to base
// list of lists to linearize, the last element is the list of direct bases
list<list<ContractDefinition const*>> input(1, {});
for (ASTPointer<InheritanceSpecifier> const& baseSpecifier: _contract.getBaseContracts())
{
ASTPointer<Identifier> baseName = baseSpecifier->getName();
auto base = dynamic_cast<ContractDefinition const*>(&baseName->getReferencedDeclaration());
if (!base)
BOOST_THROW_EXCEPTION(baseName->createTypeError("Contract expected."));
// "push_front" has the effect that bases mentioned later can overwrite members of bases
// mentioned earlier
input.back().push_front(base);
vector<ContractDefinition const*> const& basesBases = base->getLinearizedBaseContracts();
if (basesBases.empty())
BOOST_THROW_EXCEPTION(baseName->createTypeError("Definition of base has to precede definition of derived contract"));
input.push_front(list<ContractDefinition const*>(basesBases.begin(), basesBases.end()));
}
input.back().push_front(&_contract);
vector<ContractDefinition const*> result = cThreeMerge(input);
if (result.empty())
BOOST_THROW_EXCEPTION(_contract.createTypeError("Linearization of inheritance graph impossible"));
_contract.setLinearizedBaseContracts(result);
}
template <class _T>
vector<_T const*> NameAndTypeResolver::cThreeMerge(list<list<_T const*>>& _toMerge)
{
// returns true iff _candidate appears only as last element of the lists
auto appearsOnlyAtHead = [&](_T const* _candidate) -> bool
{
for (list<_T const*> const& bases: _toMerge)
{
solAssert(!bases.empty(), "");
if (find(++bases.begin(), bases.end(), _candidate) != bases.end())
return false;
}
return true;
};
// returns the next candidate to append to the linearized list or nullptr on failure
auto nextCandidate = [&]() -> _T const*
{
for (list<_T const*> const& bases: _toMerge)
{
solAssert(!bases.empty(), "");
if (appearsOnlyAtHead(bases.front()))
return bases.front();
}
return nullptr;
};
// removes the given contract from all lists
auto removeCandidate = [&](_T const* _candidate)
{
for (auto it = _toMerge.begin(); it != _toMerge.end();)
{
it->remove(_candidate);
if (it->empty())
it = _toMerge.erase(it);
else
++it;
}
};
_toMerge.remove_if([](list<_T const*> const& _bases) { return _bases.empty(); });
vector<_T const*> result;
while (!_toMerge.empty())
{
_T const* candidate = nextCandidate();
if (!candidate)
return vector<_T const*>();
result.push_back(candidate);
removeCandidate(candidate);
}
return result;
}
2014-12-01 14:22:45 +00:00
DeclarationRegistrationHelper::DeclarationRegistrationHelper(map<ASTNode const*, DeclarationContainer>& _scopes,
2014-10-22 22:24:07 +00:00
ASTNode& _astRoot):
2014-12-01 14:22:45 +00:00
m_scopes(_scopes), m_currentScope(nullptr)
{
_astRoot.accept(*this);
}
bool DeclarationRegistrationHelper::visit(ContractDefinition& _contract)
{
registerDeclaration(_contract, true);
return true;
}
void DeclarationRegistrationHelper::endVisit(ContractDefinition&)
{
closeCurrentScope();
}
bool DeclarationRegistrationHelper::visit(StructDefinition& _struct)
{
registerDeclaration(_struct, true);
return true;
}
void DeclarationRegistrationHelper::endVisit(StructDefinition&)
{
closeCurrentScope();
}
bool DeclarationRegistrationHelper::visit(EnumDefinition& _enum)
{
registerDeclaration(_enum, true);
return true;
}
void DeclarationRegistrationHelper::endVisit(EnumDefinition&)
{
closeCurrentScope();
}
2015-02-14 02:06:50 +00:00
bool DeclarationRegistrationHelper::visit(EnumValue& _value)
{
registerDeclaration(_value, false);
return true;
}
bool DeclarationRegistrationHelper::visit(FunctionDefinition& _function)
{
registerDeclaration(_function, true);
m_currentFunction = &_function;
return true;
}
void DeclarationRegistrationHelper::endVisit(FunctionDefinition&)
{
m_currentFunction = nullptr;
closeCurrentScope();
}
bool DeclarationRegistrationHelper::visit(ModifierDefinition& _modifier)
{
registerDeclaration(_modifier, true);
m_currentFunction = &_modifier;
return true;
}
void DeclarationRegistrationHelper::endVisit(ModifierDefinition&)
{
m_currentFunction = nullptr;
closeCurrentScope();
}
void DeclarationRegistrationHelper::endVisit(VariableDeclarationStatement& _variableDeclarationStatement)
{
// Register the local variables with the function
// This does not fit here perfectly, but it saves us another AST visit.
solAssert(m_currentFunction, "Variable declaration without function.");
m_currentFunction->addLocalVariable(_variableDeclarationStatement.getDeclaration());
}
bool DeclarationRegistrationHelper::visit(VariableDeclaration& _declaration)
2014-10-13 13:07:21 +00:00
{
registerDeclaration(_declaration, false);
return true;
}
2015-01-29 13:35:28 +00:00
bool DeclarationRegistrationHelper::visit(EventDefinition& _event)
{
2015-01-31 15:50:33 +00:00
registerDeclaration(_event, true);
2015-01-29 13:35:28 +00:00
return true;
}
2015-01-31 15:50:33 +00:00
void DeclarationRegistrationHelper::endVisit(EventDefinition&)
{
closeCurrentScope();
}
2014-12-06 01:32:51 +00:00
void DeclarationRegistrationHelper::enterNewSubScope(Declaration const& _declaration)
{
2014-12-01 14:22:45 +00:00
map<ASTNode const*, DeclarationContainer>::iterator iter;
2014-10-13 13:07:21 +00:00
bool newlyAdded;
2014-12-01 14:22:45 +00:00
tie(iter, newlyAdded) = m_scopes.emplace(&_declaration, DeclarationContainer(m_currentScope, &m_scopes[m_currentScope]));
solAssert(newlyAdded, "Unable to add new scope.");
2014-12-01 14:22:45 +00:00
m_currentScope = &_declaration;
2014-10-13 13:07:21 +00:00
}
void DeclarationRegistrationHelper::closeCurrentScope()
2014-10-13 13:07:21 +00:00
{
solAssert(m_currentScope, "Closed non-existing scope.");
2014-12-01 14:22:45 +00:00
m_currentScope = m_scopes[m_currentScope].getEnclosingDeclaration();
2014-10-13 13:07:21 +00:00
}
void DeclarationRegistrationHelper::registerDeclaration(Declaration& _declaration, bool _opensScope)
{
2015-02-13 23:43:02 +00:00
if (!m_scopes[m_currentScope].registerDeclaration(_declaration, !_declaration.isVisibleInContract()))
{
2015-05-04 12:46:52 +00:00
SourceLocation firstDeclarationLocation;
SourceLocation secondDeclarationLocation;
2015-05-04 13:46:46 +00:00
Declaration const* conflictingDeclaration = m_scopes[m_currentScope].conflictingDeclaration(_declaration);
solAssert(conflictingDeclaration, "");
2015-05-04 12:46:52 +00:00
2015-05-04 13:46:46 +00:00
if (_declaration.getLocation().start < conflictingDeclaration->getLocation().start)
2015-05-04 12:46:52 +00:00
{
firstDeclarationLocation = _declaration.getLocation();
2015-05-04 13:46:46 +00:00
secondDeclarationLocation = conflictingDeclaration->getLocation();
2015-05-04 12:46:52 +00:00
}
else
{
2015-05-04 13:46:46 +00:00
firstDeclarationLocation = conflictingDeclaration->getLocation();
2015-05-04 12:46:52 +00:00
secondDeclarationLocation = _declaration.getLocation();
}
2015-05-04 13:46:46 +00:00
BOOST_THROW_EXCEPTION(
DeclarationError() <<
errinfo_sourceLocation(secondDeclarationLocation) <<
errinfo_comment("Identifier already declared.") <<
errinfo_secondarySourceLocation(
SecondarySourceLocation().append("The previous declaration is here:", firstDeclarationLocation)));
}
2014-12-01 14:22:45 +00:00
_declaration.setScope(m_currentScope);
if (_opensScope)
enterNewSubScope(_declaration);
}
ReferencesResolver::ReferencesResolver(
ASTNode& _root,
NameAndTypeResolver& _resolver,
ContractDefinition const* _currentContract,
ParameterList const* _returnParameters,
bool _resolveInsideCode,
bool _allowLazyTypes
):
m_resolver(_resolver),
m_currentContract(_currentContract),
m_returnParameters(_returnParameters),
m_resolveInsideCode(_resolveInsideCode),
m_allowLazyTypes(_allowLazyTypes)
{
_root.accept(*this);
}
void ReferencesResolver::endVisit(VariableDeclaration& _variable)
{
// endVisit because the internal type needs resolving if it is a user defined type
// or mapping
2014-10-24 14:43:11 +00:00
if (_variable.getTypeName())
{
TypePointer type = _variable.getTypeName()->toType();
// All array parameter types should point to call data
if (_variable.isExternalFunctionParameter())
if (auto const* arrayType = dynamic_cast<ArrayType const*>(type.get()))
type = arrayType->copyForLocation(ArrayType::Location::CallData);
_variable.setType(type);
if (!_variable.getType())
BOOST_THROW_EXCEPTION(_variable.getTypeName()->createTypeError("Invalid type name"));
}
2014-11-13 00:12:57 +00:00
else if (!m_allowLazyTypes)
BOOST_THROW_EXCEPTION(_variable.createTypeError("Explicit type needed."));
// otherwise we have a "var"-declaration whose type is resolved by the first assignment
}
bool ReferencesResolver::visit(Return& _return)
{
2015-01-23 01:35:27 +00:00
_return.setFunctionReturnParameters(m_returnParameters);
return true;
}
2014-12-06 01:32:51 +00:00
bool ReferencesResolver::visit(Mapping&)
{
return true;
}
bool ReferencesResolver::visit(UserDefinedTypeName& _typeName)
{
2015-03-01 03:34:39 +00:00
auto declarations = m_resolver.getNameFromCurrentScope(_typeName.getName());
if (declarations.empty())
2015-04-20 12:57:56 +00:00
BOOST_THROW_EXCEPTION(
DeclarationError() <<
errinfo_sourceLocation(_typeName.getLocation()) <<
errinfo_comment("Undeclared identifier.")
);
2015-03-01 03:34:39 +00:00
else if (declarations.size() > 1)
2015-04-20 12:57:56 +00:00
BOOST_THROW_EXCEPTION(
DeclarationError() <<
errinfo_sourceLocation(_typeName.getLocation()) <<
errinfo_comment("Duplicate identifier.")
);
2015-03-01 03:34:39 +00:00
else
_typeName.setReferencedDeclaration(**declarations.begin());
return false;
}
bool ReferencesResolver::visit(Identifier& _identifier)
{
2015-03-01 03:34:39 +00:00
auto declarations = m_resolver.getNameFromCurrentScope(_identifier.getName());
if (declarations.empty())
2015-05-04 13:46:46 +00:00
BOOST_THROW_EXCEPTION(
DeclarationError() <<
errinfo_sourceLocation(_identifier.getLocation()) <<
errinfo_comment("Undeclared identifier.")
);
2015-03-01 03:34:39 +00:00
else if (declarations.size() == 1)
_identifier.setReferencedDeclaration(**declarations.begin(), m_currentContract);
else
// Duplicate declaration will be checked in checkTypeRequirements()
_identifier.setOverloadedDeclarations(declarations);
return false;
}
2014-10-16 12:08:54 +00:00
}
}