Handle struct members, enum members etc. in a special way during name resolution

Author: a3d4

libsolidity/analysis/DeclarationContainer.cpp

@@ -121,13 +121,7 @@ bool DeclarationContainer::registerDeclaration(
 		if (conflictingDeclaration(_declaration, _name))
 			return false;
 
-		// Do not warn about shadowing for structs and enums because their members are
-		// not accessible without prefixes. Also do not warn about event parameters
-		// because they do not participate in any proper scope.
-		FunctionDefinition const* functionDefinitionScope = dynamic_cast<FunctionDefinition const*>(_declaration.scope());
-		bool special = (_declaration.scope() && (_declaration.isStructMember() || _declaration.isEnumValue() || _declaration.isEventParameter())) ||
-			(functionDefinitionScope && !functionDefinitionScope->hasBody()); // parameter of a function without body
-		if (m_enclosingContainer && !special)
+		if (m_enclosingContainer && _declaration.isNameSelfSufficient())
 			m_homonymCandidates.emplace_back(*_name, _location ? _location : &_declaration.location());
 	}
 
@@ -146,14 +140,28 @@ bool DeclarationContainer::registerDeclaration(
 	return registerDeclaration(_declaration, nullptr, nullptr, _invisible, _update);
 }
 
-vector<Declaration const*> DeclarationContainer::resolveName(ASTString const& _name, bool _recursive, bool _alsoInvisible) const
+vector<Declaration const*> DeclarationContainer::resolveName(
+	ASTString const& _name,
+	bool _recursive,
+	bool _alsoInvisible,
+	bool _onlySelfSufficientNames
+) const
 {
 	solAssert(!_name.empty(), "Attempt to resolve empty name.");
 	vector<Declaration const*> result;
+
+	auto filter = [&result, &_onlySelfSufficientNames](vector<Declaration const*> _declarations) {
+		_onlySelfSufficientNames ?
+			copy_if(_declarations.cbegin(), _declarations.cend(), back_inserter(result), [](auto& _declaration) {
+				return _declaration->isNameSelfSufficient();
+			}) :
+			copy(_declarations.cbegin(), _declarations.cend(), back_inserter(result));
+	};
+
 	if (m_declarations.count(_name))
-		result = m_declarations.at(_name);
+		filter(m_declarations.at(_name));
 	if (_alsoInvisible && m_invisibleDeclarations.count(_name))
-		result += m_invisibleDeclarations.at(_name);
+		filter(m_invisibleDeclarations.at(_name));
 	if (result.empty() && _recursive && m_enclosingContainer)
 		result = m_enclosingContainer->resolveName(_name, true, _alsoInvisible);
 	return result;

libsolidity/analysis/DeclarationContainer.h

@@ -56,7 +56,12 @@ class DeclarationContainer
 	bool registerDeclaration(Declaration const& _declaration, ASTString const* _name, langutil::SourceLocation const* _location, bool _invisible, bool _update);
 	bool registerDeclaration(Declaration const& _declaration, bool _invisible, bool _update);
 
-	std::vector<Declaration const*> resolveName(ASTString const& _name, bool _recursive = false, bool _alsoInvisible = false) const;
+	std::vector<Declaration const*> resolveName(
+		ASTString const& _name,
+		bool _recursive = false,
+		bool _alsoInvisible = false,
+		bool _onlySelfSufficientNames = false
+	) const;
 	ASTNode const* enclosingNode() const { return m_enclosingNode; }
 	DeclarationContainer const* enclosingContainer() const { return m_enclosingContainer; }
 	ASTNode const* currentNode() const { return m_currentNode; }

libsolidity/analysis/NameAndTypeResolver.cpp

@@ -190,22 +190,7 @@ vector<Declaration const*> NameAndTypeResolver::nameFromCurrentScope(ASTString c
 Declaration const* NameAndTypeResolver::pathFromCurrentScope(vector<ASTString> const& _path) const
 {
 	solAssert(!_path.empty(), "");
-	vector<Declaration const*> candidates;
-
-	bool isStructScope = dynamic_cast<StructDefinition const*>(m_currentScope->currentNode());
-	if (isStructScope && _path.size() == 1)
-	{
-		// For cases like
-		// enum E {a}; struct S {E E;}
-		// the resolved name would be the struct member name, if we start from the current scope.
-		// So we start from the enclosing scope instead.
-		// It should be OK because there is no way to use unqualified access to struct members.
-		DeclarationContainer const* enclosingContainer = m_currentScope->enclosingContainer();
-		solAssert(enclosingContainer, "");
-		candidates = enclosingContainer->resolveName(_path.front(), true);
-	}
-	else
-		candidates = m_currentScope->resolveName(_path.front(), true);
+	vector<Declaration const*> candidates = m_currentScope->resolveName(_path.front(), true, false, true);
 
 	for (size_t i = 1; i < _path.size() && candidates.size() == 1; i++)
 	{

libsolidity/ast/AST.cpp

@@ -498,6 +498,18 @@ bool Declaration::isEventParameter() const
 	return dynamic_cast<EventDefinition const*>(scope());
 }
 
+bool Declaration::isNameSelfSufficient() const
+{
+	if (!scope())
+		return true;
+	if (isStructMember() || isEnumValue() || isEventParameter())
+		return false;
+	if (auto functionDefinition = dynamic_cast<FunctionDefinition const*>(scope()))
+		if (!functionDefinition->hasBody())
+			return false; // parameter of a function without body
+	return true;
+}
+
 DeclarationAnnotation& Declaration::annotation() const
 {
 	return initAnnotation<DeclarationAnnotation>();

libsolidity/ast/AST.h

@@ -268,6 +268,12 @@ class Declaration: public ASTNode, public Scopable
 	/// @returns true if this is a declaration of a parameter of an event.
 	bool isEventParameter() const;
 
+	/// @returns true if the name can be used as is.
+	/// Usually the name alone can be used to refer to the corresponding entity.
+	/// But, for example, struct member names or enum member names require a prefix.
+	/// Another example is event parameter names, which do not participate in any proper scope.
+	bool isNameSelfSufficient() const;
+
 	/// @returns the type of expressions referencing this declaration.
 	/// This can only be called once types of variable declarations have already been resolved.
 	virtual TypePointer type() const = 0;