solidity/libsolidity/analysis/NameAndTypeResolver.cpp

707 lines
23 KiB
C++
Raw Normal View History

2014-10-13 15:13:48 +00:00
/*
2019-02-13 15:56:46 +00:00
This file is part of solidity.
2014-10-13 15:13:48 +00:00
2019-02-13 15:56:46 +00:00
solidity is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
2014-10-13 15:13:48 +00:00
2019-02-13 15:56:46 +00:00
solidity is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
2014-10-13 15:13:48 +00:00
2019-02-13 15:56:46 +00:00
You should have received a copy of the GNU General Public License
along with solidity. If not, see <http://www.gnu.org/licenses/>.
2014-10-13 15:13:48 +00:00
*/
// SPDX-License-Identifier: GPL-3.0
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.
*/
2015-10-20 22:21:52 +00:00
#include <libsolidity/analysis/NameAndTypeResolver.h>
2017-02-16 11:36:43 +00:00
2015-10-20 22:21:52 +00:00
#include <libsolidity/analysis/TypeChecker.h>
2018-12-17 11:30:08 +00:00
#include <libsolidity/ast/AST.h>
#include <liblangutil/ErrorReporter.h>
#include <libsolutil/StringUtils.h>
#include <boost/algorithm/string.hpp>
#include <unordered_set>
2014-10-24 17:06:30 +00:00
using namespace std;
2019-12-11 16:31:36 +00:00
using namespace solidity::langutil;
2014-10-24 17:06:30 +00:00
2019-12-11 16:31:36 +00:00
namespace solidity::frontend
2014-10-16 12:08:54 +00:00
{
2014-10-13 13:07:21 +00:00
NameAndTypeResolver::NameAndTypeResolver(
GlobalContext& _globalContext,
langutil::EVMVersion _evmVersion,
ErrorReporter& _errorReporter
):
m_evmVersion(_evmVersion),
m_errorReporter(_errorReporter),
m_globalContext(_globalContext)
{
2020-05-14 09:56:10 +00:00
m_scopes[nullptr] = make_shared<DeclarationContainer>();
for (Declaration const* declaration: _globalContext.declarations())
{
solAssert(m_scopes[nullptr]->registerDeclaration(*declaration, false, false), "Unable to register global declaration.");
}
}
bool NameAndTypeResolver::registerDeclarations(SourceUnit& _sourceUnit, ASTNode const* _currentScope)
{
// The helper registers all declarations in m_scopes as a side-effect of its construction.
try
{
DeclarationRegistrationHelper registrar(m_scopes, _sourceUnit, m_errorReporter, m_globalContext, _currentScope);
}
catch (langutil::FatalError const&)
{
if (m_errorReporter.errors().empty())
throw; // Something is weird here, rather throw again.
return false;
}
return true;
}
2015-12-05 02:09:47 +00:00
bool NameAndTypeResolver::performImports(SourceUnit& _sourceUnit, map<string, SourceUnit const*> const& _sourceUnits)
{
DeclarationContainer& target = *m_scopes.at(&_sourceUnit);
bool error = false;
for (auto const& node: _sourceUnit.nodes())
if (auto imp = dynamic_cast<ImportDirective const*>(node.get()))
{
string const& path = *imp->annotation().absolutePath;
2015-12-09 16:35:20 +00:00
if (!_sourceUnits.count(path))
2015-12-05 02:09:47 +00:00
{
m_errorReporter.declarationError(
5073_error,
2016-01-11 12:55:58 +00:00
imp->location(),
"Import \"" + path + "\" (referenced as \"" + imp->path() + "\") not found."
2015-12-09 16:35:20 +00:00
);
2015-12-05 02:09:47 +00:00
error = true;
2016-01-11 12:55:58 +00:00
continue;
2015-12-05 02:09:47 +00:00
}
2016-01-11 12:55:58 +00:00
auto scope = m_scopes.find(_sourceUnits.at(path));
solAssert(scope != end(m_scopes), "");
if (!imp->symbolAliases().empty())
for (auto const& alias: imp->symbolAliases())
{
auto declarations = scope->second->resolveName(alias.symbol->name(), false);
2016-01-11 12:55:58 +00:00
if (declarations.empty())
{
m_errorReporter.declarationError(
2904_error,
2016-01-11 12:55:58 +00:00
imp->location(),
"Declaration \"" +
alias.symbol->name() +
2016-01-11 12:55:58 +00:00
"\" not found in \"" +
path +
"\" (referenced as \"" +
imp->path() +
"\")."
);
error = true;
}
else
for (Declaration const* declaration: declarations)
2017-02-02 11:39:12 +00:00
if (!DeclarationRegistrationHelper::registerDeclaration(
2020-09-26 22:00:56 +00:00
target, *declaration, alias.alias.get(), &alias.location, false, m_errorReporter
2017-02-02 11:39:12 +00:00
))
2016-01-11 12:55:58 +00:00
error = true;
}
2015-12-15 14:46:03 +00:00
else if (imp->name().empty())
2015-12-05 02:09:47 +00:00
for (auto const& nameAndDeclaration: scope->second->declarations())
for (auto const& declaration: nameAndDeclaration.second)
2017-02-02 11:39:12 +00:00
if (!DeclarationRegistrationHelper::registerDeclaration(
2020-09-26 22:00:56 +00:00
target, *declaration, &nameAndDeclaration.first, &imp->location(), false, m_errorReporter
2017-02-02 11:39:12 +00:00
))
error = true;
2015-12-05 02:09:47 +00:00
}
_sourceUnit.annotation().exportedSymbols = m_scopes[&_sourceUnit]->declarations();
2015-12-05 02:09:47 +00:00
return !error;
}
2020-06-11 15:17:07 +00:00
bool NameAndTypeResolver::resolveNamesAndTypes(SourceUnit& _source)
2014-10-13 13:07:21 +00:00
{
try
{
2020-06-11 15:17:07 +00:00
for (shared_ptr<ASTNode> const& node: _source.nodes())
2020-09-30 17:38:01 +00:00
{
setScope(&_source);
2020-06-11 15:17:07 +00:00
if (!resolveNamesAndTypesInternal(*node, true))
return false;
2020-09-30 17:38:01 +00:00
}
}
catch (langutil::FatalError const&)
{
if (m_errorReporter.errors().empty())
2015-11-04 13:49:54 +00:00
throw; // Something is weird here, rather throw again.
return false;
}
2020-06-11 15:17:07 +00:00
return true;
2014-10-13 13:07:21 +00:00
}
bool NameAndTypeResolver::updateDeclaration(Declaration const& _declaration)
{
try
{
m_scopes[nullptr]->registerDeclaration(_declaration, false, true);
solAssert(_declaration.scope() == nullptr, "Updated declaration outside global scope.");
}
catch (langutil::FatalError const&)
{
if (m_errorReporter.errors().empty())
throw; // Something is weird here, rather throw again.
return false;
}
return true;
}
void NameAndTypeResolver::activateVariable(string const& _name)
{
solAssert(m_currentScope, "");
2018-07-10 16:54:43 +00:00
// Scoped local variables are invisible before activation.
// When a local variable is activated, its name is removed
// from a scope's invisible variables.
// This is used to avoid activation of variables of same name
// in the same scope (an error is returned).
if (m_currentScope->isInvisible(_name))
m_currentScope->activateVariable(_name);
}
2015-12-05 02:09:47 +00:00
vector<Declaration const*> NameAndTypeResolver::resolveName(ASTString const& _name, ASTNode const* _scope) const
2014-10-13 13:07:21 +00:00
{
auto iterator = m_scopes.find(_scope);
if (iterator == end(m_scopes))
return vector<Declaration const*>({});
return iterator->second->resolveName(_name, false);
2014-10-13 13:07:21 +00:00
}
vector<Declaration const*> NameAndTypeResolver::nameFromCurrentScope(ASTString const& _name, bool _includeInvisibles) const
2014-10-13 13:07:21 +00:00
{
return m_currentScope->resolveName(_name, true, _includeInvisibles);
2014-10-13 13:07:21 +00:00
}
2018-02-09 14:09:22 +00:00
Declaration const* NameAndTypeResolver::pathFromCurrentScope(vector<ASTString> const& _path) const
2015-10-06 10:35:10 +00:00
{
solAssert(!_path.empty(), "");
2018-02-09 14:09:22 +00:00
vector<Declaration const*> candidates = m_currentScope->resolveName(_path.front(), true);
2015-10-06 10:35:10 +00:00
for (size_t i = 1; i < _path.size() && candidates.size() == 1; i++)
{
if (!m_scopes.count(candidates.front()))
return nullptr;
candidates = m_scopes.at(candidates.front())->resolveName(_path[i], false);
2015-10-06 10:35:10 +00:00
}
if (candidates.size() == 1)
return candidates.front();
else
return nullptr;
}
void NameAndTypeResolver::warnVariablesNamedLikeInstructions() const
{
2019-12-11 16:31:36 +00:00
for (auto const& instruction: evmasm::c_instructions)
{
string const instructionName{boost::algorithm::to_lower_copy(instruction.first)};
auto declarations = nameFromCurrentScope(instructionName, true);
for (Declaration const* const declaration: declarations)
{
solAssert(!!declaration, "");
if (dynamic_cast<MagicVariableDeclaration const* const>(declaration))
// Don't warn the user for what the user did not.
continue;
m_errorReporter.warning(
8261_error,
declaration->location(),
"Variable is shadowed in inline assembly by an instruction of the same name"
);
}
}
}
void NameAndTypeResolver::warnHomonymDeclarations() const
{
DeclarationContainer::Homonyms homonyms;
m_scopes.at(nullptr)->populateHomonyms(back_inserter(homonyms));
for (auto [innerLocation, outerDeclarations]: homonyms)
{
solAssert(innerLocation && !outerDeclarations.empty(), "");
bool magicShadowed = false;
SecondarySourceLocation homonymousLocations;
SecondarySourceLocation shadowedLocations;
for (Declaration const* outerDeclaration: outerDeclarations)
{
solAssert(outerDeclaration, "");
if (dynamic_cast<MagicVariableDeclaration const*>(outerDeclaration))
magicShadowed = true;
else if (!outerDeclaration->isVisibleInContract())
homonymousLocations.append("The other declaration is here:", outerDeclaration->location());
else
shadowedLocations.append("The shadowed declaration is here:", outerDeclaration->location());
}
if (magicShadowed)
m_errorReporter.warning(
2319_error,
*innerLocation,
"This declaration shadows a builtin symbol."
);
if (!homonymousLocations.infos.empty())
m_errorReporter.warning(
8760_error,
*innerLocation,
"This declaration has the same name as another declaration.",
homonymousLocations
);
if (!shadowedLocations.infos.empty())
m_errorReporter.warning(
2519_error,
*innerLocation,
"This declaration shadows an existing declaration.",
shadowedLocations
);
}
}
2018-02-09 15:53:25 +00:00
void NameAndTypeResolver::setScope(ASTNode const* _node)
{
m_currentScope = m_scopes[_node].get();
}
2017-02-16 11:36:43 +00:00
bool NameAndTypeResolver::resolveNamesAndTypesInternal(ASTNode& _node, bool _resolveInsideCode)
{
if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(&_node))
{
bool success = true;
2018-02-09 15:53:25 +00:00
setScope(contract->scope());
2017-02-16 11:36:43 +00:00
solAssert(!!m_currentScope, "");
2020-06-11 15:17:07 +00:00
solAssert(_resolveInsideCode, "");
2017-02-16 11:36:43 +00:00
m_globalContext.setCurrentContract(*contract);
2020-12-07 11:10:35 +00:00
if (!contract->isLibrary())
updateDeclaration(*m_globalContext.currentSuper());
updateDeclaration(*m_globalContext.currentThis());
2017-02-16 11:36:43 +00:00
for (ASTPointer<InheritanceSpecifier> const& baseContract: contract->baseContracts())
2020-06-11 15:17:07 +00:00
if (!resolveNamesAndTypesInternal(*baseContract, true))
2017-02-16 11:36:43 +00:00
success = false;
2018-02-09 15:53:25 +00:00
setScope(contract);
2017-02-16 11:36:43 +00:00
if (success)
{
linearizeBaseContracts(*contract);
vector<ContractDefinition const*> properBases(
++contract->annotation().linearizedBaseContracts.begin(),
contract->annotation().linearizedBaseContracts.end()
);
for (ContractDefinition const* base: properBases)
importInheritedScope(*base);
}
// these can contain code, only resolve parameters for now
for (ASTPointer<ASTNode> const& node: contract->subNodes())
{
2018-02-09 15:53:25 +00:00
setScope(contract);
2020-06-11 15:17:07 +00:00
if (!resolveNamesAndTypesInternal(*node, false))
2017-02-16 11:36:43 +00:00
success = false;
}
if (!success)
return false;
2018-02-09 15:53:25 +00:00
setScope(contract);
2017-02-16 11:36:43 +00:00
// now resolve references inside the code
for (ASTPointer<ASTNode> const& node: contract->subNodes())
{
2018-02-09 15:53:25 +00:00
setScope(contract);
2020-06-11 15:17:07 +00:00
if (!resolveNamesAndTypesInternal(*node, true))
2017-02-16 11:36:43 +00:00
success = false;
}
2020-05-04 16:38:00 +00:00
// make "this" and "super" invisible.
m_scopes[nullptr]->registerDeclaration(*m_globalContext.currentThis(), true, true);
m_scopes[nullptr]->registerDeclaration(*m_globalContext.currentSuper(), true, true);
2020-05-04 16:38:00 +00:00
m_globalContext.resetCurrentContract();
2017-02-16 11:36:43 +00:00
return success;
}
else
{
if (m_scopes.count(&_node))
2018-02-09 15:53:25 +00:00
setScope(&_node);
return ReferencesResolver(m_errorReporter, *this, m_evmVersion, _resolveInsideCode).resolve(_node);
2017-02-16 11:36:43 +00:00
}
}
void NameAndTypeResolver::importInheritedScope(ContractDefinition const& _base)
{
auto iterator = m_scopes.find(&_base);
solAssert(iterator != end(m_scopes), "");
for (auto const& nameAndDeclaration: iterator->second->declarations())
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
2015-08-31 16:44:29 +00:00
if (declaration->scope() == &_base && declaration->isVisibleInDerivedContracts())
if (!m_currentScope->registerDeclaration(*declaration, false, false))
{
SourceLocation firstDeclarationLocation;
SourceLocation secondDeclarationLocation;
Declaration const* conflictingDeclaration = m_currentScope->conflictingDeclaration(*declaration);
solAssert(conflictingDeclaration, "");
// Usual shadowing is not an error
if (
dynamic_cast<ModifierDefinition const*>(declaration) &&
dynamic_cast<ModifierDefinition const*>(conflictingDeclaration)
)
continue;
// Public state variable can override functions
if (auto varDecl = dynamic_cast<VariableDeclaration const*>(conflictingDeclaration))
if (
dynamic_cast<FunctionDefinition const*>(declaration) &&
varDecl->isStateVariable() &&
varDecl->isPublic()
)
continue;
if (declaration->location().start < conflictingDeclaration->location().start)
{
firstDeclarationLocation = declaration->location();
secondDeclarationLocation = conflictingDeclaration->location();
}
else
{
firstDeclarationLocation = conflictingDeclaration->location();
secondDeclarationLocation = declaration->location();
}
m_errorReporter.declarationError(
9097_error,
secondDeclarationLocation,
SecondarySourceLocation().append("The previous declaration is here:", firstDeclarationLocation),
"Identifier already declared."
);
}
}
void NameAndTypeResolver::linearizeBaseContracts(ContractDefinition& _contract)
{
// 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, list<ContractDefinition const*>{});
2015-08-31 16:44:29 +00:00
for (ASTPointer<InheritanceSpecifier> const& baseSpecifier: _contract.baseContracts())
{
IdentifierPath const& baseName = baseSpecifier->name();
auto base = dynamic_cast<ContractDefinition const*>(baseName.annotation().referencedDeclaration);
if (!base)
m_errorReporter.fatalTypeError(8758_error, baseName.location(), "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->annotation().linearizedBaseContracts;
if (basesBases.empty())
m_errorReporter.fatalTypeError(2449_error, baseName.location(), "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())
m_errorReporter.fatalTypeError(5005_error, _contract.location(), "Linearization of inheritance graph impossible");
_contract.annotation().linearizedBaseContracts = result;
2015-10-07 13:57:17 +00:00
_contract.annotation().contractDependencies.insert(result.begin() + 1, result.end());
}
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;
}
string NameAndTypeResolver::similarNameSuggestions(ASTString const& _name) const
{
2019-12-11 16:31:36 +00:00
return util::quotedAlternativesList(m_currentScope->similarNames(_name));
}
DeclarationRegistrationHelper::DeclarationRegistrationHelper(
2015-12-15 14:46:03 +00:00
map<ASTNode const*, shared_ptr<DeclarationContainer>>& _scopes,
ASTNode& _astRoot,
ErrorReporter& _errorReporter,
GlobalContext& _globalContext,
ASTNode const* _currentScope
):
m_scopes(_scopes),
m_currentScope(_currentScope),
m_errorReporter(_errorReporter),
m_globalContext(_globalContext)
{
_astRoot.accept(*this);
solAssert(m_currentScope == _currentScope, "Scopes not correctly closed.");
}
2017-02-02 11:39:12 +00:00
bool DeclarationRegistrationHelper::registerDeclaration(
DeclarationContainer& _container,
Declaration const& _declaration,
string const* _name,
SourceLocation const* _errorLocation,
bool _inactive,
2017-02-02 11:39:12 +00:00
ErrorReporter& _errorReporter
)
{
if (!_errorLocation)
_errorLocation = &_declaration.location();
string name = _name ? *_name : _declaration.name();
2017-02-02 11:39:12 +00:00
// We use "invisible" for both inactive variables in blocks and for members invisible in contracts.
// They cannot both be true at the same time.
solAssert(!(_inactive && !_declaration.isVisibleInContract()), "");
static set<string> illegalNames{"_", "super", "this"};
if (illegalNames.count(name))
{
auto isPublicFunctionOrEvent = [](Declaration const* _d) -> bool
{
if (auto functionDefinition = dynamic_cast<FunctionDefinition const*>(_d))
{
if (!functionDefinition->isFree() && functionDefinition->isPublic())
return true;
}
else if (dynamic_cast<EventDefinition const*>(_d))
return true;
return false;
};
// We allow an exception for public functions or events.
if (!isPublicFunctionOrEvent(&_declaration))
_errorReporter.declarationError(
3726_error,
*_errorLocation,
"The name \"" + name + "\" is reserved."
);
}
if (!_container.registerDeclaration(_declaration, _name, _errorLocation, !_declaration.isVisibleInContract() || _inactive, false))
2017-02-02 11:39:12 +00:00
{
SourceLocation firstDeclarationLocation;
SourceLocation secondDeclarationLocation;
Declaration const* conflictingDeclaration = _container.conflictingDeclaration(_declaration, _name);
solAssert(conflictingDeclaration, "");
bool const comparable =
_errorLocation->source &&
conflictingDeclaration->location().source &&
_errorLocation->source->name() == conflictingDeclaration->location().source->name();
2017-02-02 11:39:12 +00:00
if (comparable && _errorLocation->start < conflictingDeclaration->location().start)
{
firstDeclarationLocation = *_errorLocation;
secondDeclarationLocation = conflictingDeclaration->location();
}
else
{
firstDeclarationLocation = conflictingDeclaration->location();
secondDeclarationLocation = *_errorLocation;
}
_errorReporter.declarationError(
2333_error,
2017-02-02 11:39:12 +00:00
secondDeclarationLocation,
SecondarySourceLocation().append("The previous declaration is here:", firstDeclarationLocation),
"Identifier already declared."
);
return false;
}
2017-02-02 11:39:12 +00:00
return true;
}
bool DeclarationRegistrationHelper::visit(SourceUnit& _sourceUnit)
{
if (!m_scopes[&_sourceUnit])
// By importing, it is possible that the container already exists.
2019-11-27 16:24:21 +00:00
m_scopes[&_sourceUnit] = make_shared<DeclarationContainer>(m_currentScope, m_scopes[m_currentScope].get());
return ASTVisitor::visit(_sourceUnit);
}
void DeclarationRegistrationHelper::endVisit(SourceUnit& _sourceUnit)
{
ASTVisitor::endVisit(_sourceUnit);
}
2015-12-15 14:46:03 +00:00
bool DeclarationRegistrationHelper::visit(ImportDirective& _import)
{
SourceUnit const* importee = _import.annotation().sourceUnit;
solAssert(!!importee, "");
if (!m_scopes[importee])
2019-11-27 16:24:21 +00:00
m_scopes[importee] = make_shared<DeclarationContainer>(nullptr, m_scopes[nullptr].get());
2015-12-15 14:46:03 +00:00
m_scopes[&_import] = m_scopes[importee];
return ASTVisitor::visit(_import);
2015-12-15 14:46:03 +00:00
}
bool DeclarationRegistrationHelper::visit(ContractDefinition& _contract)
{
m_globalContext.setCurrentContract(_contract);
m_scopes[nullptr]->registerDeclaration(*m_globalContext.currentThis(), false, true);
m_scopes[nullptr]->registerDeclaration(*m_globalContext.currentSuper(), false, true);
m_currentContract = &_contract;
return ASTVisitor::visit(_contract);
}
void DeclarationRegistrationHelper::endVisit(ContractDefinition& _contract)
{
2020-05-04 16:38:00 +00:00
// make "this" and "super" invisible.
m_scopes[nullptr]->registerDeclaration(*m_globalContext.currentThis(), true, true);
m_scopes[nullptr]->registerDeclaration(*m_globalContext.currentSuper(), true, true);
2020-05-04 16:38:00 +00:00
m_globalContext.resetCurrentContract();
m_currentContract = nullptr;
ASTVisitor::endVisit(_contract);
2018-02-09 15:53:52 +00:00
}
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.");
for (ASTPointer<VariableDeclaration> const& var: _variableDeclarationStatement.declarations())
if (var)
m_currentFunction->addLocalVariable(*var);
ASTVisitor::endVisit(_variableDeclarationStatement);
}
bool DeclarationRegistrationHelper::visitNode(ASTNode& _node)
2014-10-13 13:07:21 +00:00
{
if (auto const* scopable = dynamic_cast<Scopable const*>(&_node))
solAssert(scopable->annotation().scope == m_currentScope, "");
if (auto* declaration = dynamic_cast<Declaration*>(&_node))
registerDeclaration(*declaration);
if (dynamic_cast<ScopeOpener const*>(&_node))
enterNewSubScope(_node);
if (auto* variableScope = dynamic_cast<VariableScope*>(&_node))
m_currentFunction = variableScope;
if (auto* annotation = dynamic_cast<TypeDeclarationAnnotation*>(&_node.annotation()))
annotation->canonicalName = currentCanonicalName();
2015-01-29 13:35:28 +00:00
return true;
}
void DeclarationRegistrationHelper::endVisitNode(ASTNode& _node)
2015-01-31 15:50:33 +00:00
{
if (dynamic_cast<ScopeOpener const*>(&_node))
closeCurrentScope();
if (dynamic_cast<VariableScope*>(&_node))
m_currentFunction = nullptr;
2015-01-31 15:50:33 +00:00
}
2018-02-09 15:53:25 +00:00
void DeclarationRegistrationHelper::enterNewSubScope(ASTNode& _subScope)
{
if (m_scopes.count(&_subScope))
// Source units are the only AST nodes for which containers can be created from multiple places due to imports.
solAssert(dynamic_cast<SourceUnit const*>(&_subScope), "Unexpected scope type.");
else
{
bool newlyAdded = m_scopes.emplace(&_subScope, make_shared<DeclarationContainer>(m_currentScope, m_scopes[m_currentScope].get())).second;
solAssert(newlyAdded, "Unable to add new scope.");
}
2018-02-09 15:53:25 +00:00
m_currentScope = &_subScope;
2014-10-13 13:07:21 +00:00
}
void DeclarationRegistrationHelper::closeCurrentScope()
2014-10-13 13:07:21 +00:00
{
solAssert(m_currentScope && m_scopes.count(m_currentScope), "Closed non-existing scope.");
2015-12-05 02:09:47 +00:00
m_currentScope = m_scopes[m_currentScope]->enclosingNode();
2014-10-13 13:07:21 +00:00
}
void DeclarationRegistrationHelper::registerDeclaration(Declaration& _declaration)
{
solAssert(m_currentScope && m_scopes.count(m_currentScope), "No current scope.");
2020-09-26 22:00:56 +00:00
solAssert(m_currentScope == _declaration.scope(), "Unexpected current scope.");
2015-05-04 13:46:46 +00:00
2018-06-15 10:30:28 +00:00
// Register declaration as inactive if we are in block scope.
bool inactive =
(dynamic_cast<Block const*>(m_currentScope) || dynamic_cast<ForStatement const*>(m_currentScope));
2020-09-26 22:00:56 +00:00
registerDeclaration(*m_scopes[m_currentScope], _declaration, nullptr, nullptr, inactive, m_errorReporter);
2020-08-06 12:46:04 +00:00
solAssert(_declaration.annotation().scope == m_currentScope, "");
solAssert(_declaration.annotation().contract == m_currentContract, "");
}
string DeclarationRegistrationHelper::currentCanonicalName() const
{
string ret;
for (
2015-12-05 02:09:47 +00:00
ASTNode const* scope = m_currentScope;
scope != nullptr;
2015-12-05 02:09:47 +00:00
scope = m_scopes[scope]->enclosingNode()
)
{
2015-12-05 02:09:47 +00:00
if (auto decl = dynamic_cast<Declaration const*>(scope))
{
if (!ret.empty())
ret = "." + ret;
ret = decl->name() + ret;
}
}
return ret;
}
2014-10-16 12:08:54 +00:00
}