YulNameRepository with node id handles

Author: clonker

Changelog.md

@@ -15,6 +15,7 @@ Compiler Features:
 
 
 Bugfixes:
+ * AsmParser: Parsing rules for source location comments have been relaxed: Whitespace between the indices as well as single-quoted code snippets are now allowed.
  * SMTChecker: Fix error that reports invalid number of verified checks for BMC and CHC engines.
  * SMTChecker: Fix formatting of unary minus expressions in invariants.
  * SMTChecker: Fix internal compiler error when reporting proved targets for BMC engine.

libsolidity/analysis/ControlFlowBuilder.cpp

@@ -582,13 +582,13 @@ void ControlFlowBuilder::operator()(yul::FunctionCall const& _functionCall)
 	solAssert(m_currentNode && m_inlineAssembly, "");
 	yul::ASTWalker::operator()(_functionCall);
 
-	if (auto const *builtinFunction = m_inlineAssembly->dialect().builtin(_functionCall.functionName.name))
+	if (auto const *builtinFunction = m_inlineAssembly->nameRepository().builtin(_functionCall.functionName.name))
 	{
-		if (builtinFunction->controlFlowSideEffects.canTerminate)
+		if (builtinFunction->data->controlFlowSideEffects.canTerminate)
 			connect(m_currentNode, m_transactionReturnNode);
-		if (builtinFunction->controlFlowSideEffects.canRevert)
+		if (builtinFunction->data->controlFlowSideEffects.canRevert)
 			connect(m_currentNode, m_revertNode);
-		if (!builtinFunction->controlFlowSideEffects.canContinue)
+		if (!builtinFunction->data->controlFlowSideEffects.canContinue)
 			m_currentNode = newLabel();
 	}
 }

libsolidity/analysis/PostTypeChecker.cpp

@@ -462,7 +462,8 @@ struct ReservedErrorSelector: public PostTypeChecker::Checker
 class YulLValueChecker : public solidity::yul::ASTWalker
 {
 public:
-	YulLValueChecker(ASTString const& _identifierName): m_identifierName(_identifierName) {}
+	YulLValueChecker(ASTString const& _identifierName, yul::YulNameRepository const& _yulNameRepository):
+		m_identifierName(_identifierName), m_yulNameRepository(_yulNameRepository) {}
 	bool willBeWrittenTo() const { return m_willBeWrittenTo; }
 	using solidity::yul::ASTWalker::operator();
 	void operator()(solidity::yul::Assignment const& _assignment) override
@@ -472,12 +473,13 @@ class YulLValueChecker : public solidity::yul::ASTWalker
 
 		if (ranges::any_of(
 			_assignment.variableNames,
-			[&](auto const& yulIdentifier) { return yulIdentifier.name.str() == m_identifierName; }
+			[&](auto const& yulIdentifier) { return m_yulNameRepository.labelOf(yulIdentifier.name) == m_identifierName; }
 		))
 			m_willBeWrittenTo = true;
 	}
 private:
 	ASTString const& m_identifierName;
+	yul::YulNameRepository const& m_yulNameRepository;
 	bool m_willBeWrittenTo = false;
 };
 
@@ -505,7 +507,7 @@ class LValueChecker: public ASTConstVisitor
 		if (m_willBeWrittenTo)
 			return;
 
-		YulLValueChecker yulChecker{m_declaration->name()};
+		YulLValueChecker yulChecker{m_declaration->name(), _inlineAssembly.nameRepository()};
 		yulChecker(_inlineAssembly.operations());
 		m_willBeWrittenTo = yulChecker.willBeWrittenTo();
 	}

libsolidity/analysis/ReferencesResolver.cpp

@@ -236,7 +236,9 @@ bool ReferencesResolver::visit(UsingForDirective const& _usingFor)
 bool ReferencesResolver::visit(InlineAssembly const& _inlineAssembly)
 {
 	m_yulAnnotation = &_inlineAssembly.annotation();
+	m_yulNameRepository = &_inlineAssembly.nameRepository();
 	(*this)(_inlineAssembly.operations());
+	m_yulNameRepository = nullptr;
 	m_yulAnnotation = nullptr;
 
 	return false;
@@ -270,12 +272,13 @@ bool ReferencesResolver::visit(BinaryOperation const& _binaryOperation)
 
 void ReferencesResolver::operator()(yul::FunctionDefinition const& _function)
 {
+	solAssert(m_yulNameRepository != nullptr);
 	solAssert(nativeLocationOf(_function) == originLocationOf(_function), "");
-	validateYulIdentifierName(_function.name, nativeLocationOf(_function));
+	validateYulIdentifierName(m_yulNameRepository->labelOf(_function.name), nativeLocationOf(_function));
 	for (yul::TypedName const& varName: _function.parameters + _function.returnVariables)
 	{
 		solAssert(nativeLocationOf(varName) == originLocationOf(varName), "");
-		validateYulIdentifierName(varName.name, nativeLocationOf(varName));
+		validateYulIdentifierName(m_yulNameRepository->labelOf(varName.name), nativeLocationOf(varName));
 	}
 
 	bool wasInsideFunction = m_yulInsideFunction;
@@ -286,12 +289,13 @@ void ReferencesResolver::operator()(yul::FunctionDefinition const& _function)
 
 void ReferencesResolver::operator()(yul::Identifier const& _identifier)
 {
+	solAssert(m_yulNameRepository != nullptr);
 	solAssert(nativeLocationOf(_identifier) == originLocationOf(_identifier), "");
-
+	auto const identifierLabel = m_yulNameRepository->labelOf(_identifier.name);
 	if (m_resolver.experimentalSolidity())
 	{
 		std::vector<std::string> splitName;
-		boost::split(splitName, _identifier.name.str(), boost::is_any_of("."));
+		boost::split(splitName, identifierLabel, boost::is_any_of("."));
 		solAssert(!splitName.empty());
 		if (splitName.size() > 2)
 		{
@@ -332,22 +336,22 @@ void ReferencesResolver::operator()(yul::Identifier const& _identifier)
 	static std::set<std::string> suffixes{"slot", "offset", "length", "address", "selector"};
 	std::string suffix;
 	for (std::string const& s: suffixes)
-		if (boost::algorithm::ends_with(_identifier.name.str(), "." + s))
+		if (boost::algorithm::ends_with(identifierLabel, "." + s))
 			suffix = s;
 
 	// Could also use `pathFromCurrentScope`, split by '.'.
 	// If we do that, suffix should only be set for when it has a special
 	// meaning, not for normal identifierPaths.
-	auto declarations = m_resolver.nameFromCurrentScope(_identifier.name.str());
+	auto declarations = m_resolver.nameFromCurrentScope(std::string(identifierLabel));
 	if (!suffix.empty())
 	{
 		// special mode to access storage variables
 		if (!declarations.empty())
 			// the special identifier exists itself, we should not allow that.
 			return;
-		std::string realName = _identifier.name.str().substr(0, _identifier.name.str().size() - suffix.size() - 1);
+		auto const realName = identifierLabel.substr(0, identifierLabel.size() - suffix.size() - 1);
 		solAssert(!realName.empty(), "Empty name.");
-		declarations = m_resolver.nameFromCurrentScope(realName);
+		declarations = m_resolver.nameFromCurrentScope(std::string(realName));
 		if (!declarations.empty())
 			// To support proper path resolution, we have to use pathFromCurrentScope.
 			solAssert(!util::contains(realName, '.'), "");
@@ -364,8 +368,8 @@ void ReferencesResolver::operator()(yul::Identifier const& _identifier)
 	else if (declarations.size() == 0)
 	{
 		if (
-			boost::algorithm::ends_with(_identifier.name.str(), "_slot") ||
-			boost::algorithm::ends_with(_identifier.name.str(), "_offset")
+			boost::algorithm::ends_with(identifierLabel, "_slot") ||
+			boost::algorithm::ends_with(identifierLabel, "_offset")
 		)
 			m_errorReporter.declarationError(
 				9467_error,
@@ -391,13 +395,14 @@ void ReferencesResolver::operator()(yul::Identifier const& _identifier)
 
 void ReferencesResolver::operator()(yul::VariableDeclaration const& _varDecl)
 {
+	solAssert(m_yulNameRepository != nullptr);
 	for (auto const& identifier: _varDecl.variables)
 	{
 		solAssert(nativeLocationOf(identifier) == originLocationOf(identifier), "");
-		validateYulIdentifierName(identifier.name, nativeLocationOf(identifier));
+		validateYulIdentifierName(m_yulNameRepository->labelOf(identifier.name), nativeLocationOf(identifier));
 
 		if (
-			auto declarations = m_resolver.nameFromCurrentScope(identifier.name.str());
+			auto declarations = m_resolver.nameFromCurrentScope(std::string(m_yulNameRepository->labelOf(identifier.name)));
 			!declarations.empty()
 		)
 		{
@@ -488,19 +493,19 @@ void ReferencesResolver::resolveInheritDoc(StructuredDocumentation const& _docum
 	}
 }
 
-void ReferencesResolver::validateYulIdentifierName(yul::YulString _name, SourceLocation const& _location)
+void ReferencesResolver::validateYulIdentifierName(std::string_view const _name, SourceLocation const& _location)
 {
-	if (util::contains(_name.str(), '.'))
+	if (util::contains(_name, '.'))
 		m_errorReporter.declarationError(
 			3927_error,
 			_location,
 			"User-defined identifiers in inline assembly cannot contain '.'."
 		);
 
-	if (std::set<std::string>{"this", "super", "_"}.count(_name.str()))
+	if (std::set<std::string, std::less<>>{"this", "super", "_"}.count(_name))
 		m_errorReporter.declarationError(
 			4113_error,
 			_location,
-			"The identifier name \"" + _name.str() + "\" is reserved."
+			fmt::format("The identifier name \"{}\" is reserved.", _name)
 		);
 }

libsolidity/analysis/ReferencesResolver.h

@@ -94,7 +94,7 @@ class ReferencesResolver: private ASTConstVisitor, private yul::ASTWalker
 	void resolveInheritDoc(StructuredDocumentation const& _documentation, StructurallyDocumentedAnnotation& _annotation);
 
 	/// Checks if the name contains a '.'.
-	void validateYulIdentifierName(yul::YulString _name, langutil::SourceLocation const& _location);
+	void validateYulIdentifierName(std::string_view _name, langutil::SourceLocation const& _location);
 
 	langutil::ErrorReporter& m_errorReporter;
 	NameAndTypeResolver& m_resolver;
@@ -104,6 +104,7 @@ class ReferencesResolver: private ASTConstVisitor, private yul::ASTWalker
 	bool const m_resolveInsideCode;
 
 	InlineAssemblyAnnotation* m_yulAnnotation = nullptr;
+	yul::YulNameRepository const* m_yulNameRepository = nullptr;
 	bool m_yulInsideFunction = false;
 	bool m_typeContext = false;
 };

libsolidity/analysis/SyntaxChecker.cpp

@@ -354,7 +354,7 @@ bool SyntaxChecker::visit(InlineAssembly const& _inlineAssembly)
 	if (!m_useYulOptimizer)
 		return false;
 
-	if (yul::MSizeFinder::containsMSize(_inlineAssembly.dialect(), _inlineAssembly.operations()))
+	if (yul::MSizeFinder::containsMSize(_inlineAssembly.nameRepository(), _inlineAssembly.operations()))
 		m_errorReporter.syntaxError(
 			6553_error,
 			_inlineAssembly.location(),

libsolidity/analysis/TypeChecker.cpp

@@ -944,7 +944,7 @@ bool TypeChecker::visit(InlineAssembly const& _inlineAssembly)
 	yul::AsmAnalyzer analyzer(
 		*_inlineAssembly.annotation().analysisInfo,
 		m_errorReporter,
-		_inlineAssembly.dialect(),
+		_inlineAssembly.nameRepository(),
 		identifierAccess
 	);
 	if (!analyzer.analyze(_inlineAssembly.operations()))

libsolidity/analysis/ViewPureChecker.cpp

@@ -38,10 +38,10 @@ class AssemblyViewPureChecker
 {
 public:
 	explicit AssemblyViewPureChecker(
-		yul::Dialect const& _dialect,
+		yul::YulNameRepository const& _yulNameRepository,
 		std::function<void(StateMutability, SourceLocation const&)> _reportMutability
 	):
-		m_dialect(_dialect),
+		m_yulNameRepository(_yulNameRepository),
 		m_reportMutability(std::move(_reportMutability)) {}
 
 	void operator()(yul::Literal const&) {}
@@ -65,10 +65,10 @@ class AssemblyViewPureChecker
 	}
 	void operator()(yul::FunctionCall const& _funCall)
 	{
-		if (yul::EVMDialect const* dialect = dynamic_cast<decltype(dialect)>(&m_dialect))
-			if (yul::BuiltinFunctionForEVM const* fun = dialect->builtin(_funCall.functionName.name))
-				if (fun->instruction)
-					checkInstruction(nativeLocationOf(_funCall), *fun->instruction);
+		if (yul::EVMDialect const* dialect = dynamic_cast<decltype(dialect)>(&m_yulNameRepository.dialect()))
+			if (auto const* fun = m_yulNameRepository.builtin(_funCall.functionName.name))
+				if (auto const* evmFun = dynamic_cast<yul::BuiltinFunctionForEVM const*>(fun->data); evmFun->instruction)
+					checkInstruction(nativeLocationOf(_funCall), *evmFun->instruction);
 
 		for (auto const& arg: _funCall.arguments)
 			std::visit(*this, arg);
@@ -119,7 +119,7 @@ class AssemblyViewPureChecker
 			m_reportMutability(StateMutability::View, _location);
 	}
 
-	yul::Dialect const& m_dialect;
+	yul::YulNameRepository const& m_yulNameRepository;
 	std::function<void(StateMutability, SourceLocation const&)> m_reportMutability;
 };
 
@@ -224,7 +224,7 @@ void ViewPureChecker::endVisit(Identifier const& _identifier)
 void ViewPureChecker::endVisit(InlineAssembly const& _inlineAssembly)
 {
 	AssemblyViewPureChecker{
-		_inlineAssembly.dialect(),
+		_inlineAssembly.nameRepository(),
 		[&](StateMutability _mutability, SourceLocation const& _location) { reportMutability(_mutability, _location); }
 	}(_inlineAssembly.operations());
 }

libsolidity/ast/AST.cpp

@@ -29,6 +29,7 @@
 #include <libsolidity/ast/TypeProvider.h>
 #include <libsolutil/FunctionSelector.h>
 #include <libsolutil/Keccak256.h>
+#include <libyul/YulName.h>
 
 #include <range/v3/range/conversion.hpp>
 #include <range/v3/view/tail.hpp>
@@ -38,6 +39,7 @@
 
 #include <functional>
 #include <utility>
+#include <memory>
 
 using namespace solidity;
 using namespace solidity::frontend;
@@ -1060,6 +1062,24 @@ TryCatchClause const* TryStatement::fallbackClause() const {
 	return findClause(m_clauses);
 }
 
+InlineAssembly::InlineAssembly(
+	int64_t _id,
+	SourceLocation const& _location,
+	ASTPointer<ASTString> const& _docString,
+	std::unique_ptr<yul::YulNameRepository> _yulNameRepository,
+	ASTPointer<std::vector<ASTPointer<ASTString>>> _flags,
+	std::shared_ptr<yul::Block> _operations
+):
+	Statement(_id, _location, _docString),
+	m_yulNameRepository(std::move(_yulNameRepository)),
+	m_flags(std::move(_flags)),
+	m_operations(std::move(_operations))
+{
+	solAssert(m_yulNameRepository != nullptr);
+}
+
+InlineAssembly::~InlineAssembly() = default;
+
 /// Experimental Solidity nodes
 /// @{
 TypeClassDefinitionAnnotation& TypeClassDefinition::annotation() const

libsolidity/ast/AST.h

@@ -49,7 +49,7 @@ namespace solidity::yul
 {
 // Forward-declaration to <yul/AST.h>
 struct Block;
-struct Dialect;
+class YulNameRepository;
 }
 
 namespace solidity::frontend
@@ -1567,26 +1567,22 @@ class InlineAssembly: public Statement
 		int64_t _id,
 		SourceLocation const& _location,
 		ASTPointer<ASTString> const& _docString,
-		yul::Dialect const& _dialect,
+		std::unique_ptr<yul::YulNameRepository> _yulNameRepository,
 		ASTPointer<std::vector<ASTPointer<ASTString>>> _flags,
 		std::shared_ptr<yul::Block> _operations
-	):
-		Statement(_id, _location, _docString),
-		m_dialect(_dialect),
-		m_flags(std::move(_flags)),
-		m_operations(std::move(_operations))
-	{}
+	);
+	~InlineAssembly() override;
 	void accept(ASTVisitor& _visitor) override;
 	void accept(ASTConstVisitor& _visitor) const override;
 
-	yul::Dialect const& dialect() const { return m_dialect; }
+	yul::YulNameRepository& nameRepository() const { return *m_yulNameRepository; }
 	yul::Block const& operations() const { return *m_operations; }
 	ASTPointer<std::vector<ASTPointer<ASTString>>> const& flags() const { return m_flags; }
 
 	InlineAssemblyAnnotation& annotation() const override;
 
 private:
-	yul::Dialect const& m_dialect;
+	std::unique_ptr<yul::YulNameRepository> mutable m_yulNameRepository;
 	ASTPointer<std::vector<ASTPointer<ASTString>>> m_flags;
 	std::shared_ptr<yul::Block> m_operations;
 };