Merge pull request #15253 from ethereum/const_function_call_finder

Yul: Add const version of FunctionCallFinder

Author: clonker

libyul/backends/evm/EVMObjectCompiler.cpp

@@ -90,8 +90,8 @@ void EVMObjectCompiler::run(Object& _object, bool _optimize)
 		);
 		if (!stackErrors.empty())
 		{
-			std::vector<FunctionCall*> memoryGuardCalls = FunctionCallFinder::run(
-				*_object.code,
+			std::vector<FunctionCall const*> memoryGuardCalls = findFunctionCalls(
+				std::as_const(*_object.code),
 				"memoryguard"_yulstring
 			);
 			auto stackError = stackErrors.front();

libyul/optimiser/FullInliner.cpp

@@ -83,7 +83,7 @@ FullInliner::FullInliner(Block& _ast, NameDispenser& _dispenser, Dialect const&
 	}
 
 	// Check for memory guard.
-	std::vector<FunctionCall*> memoryGuardCalls = FunctionCallFinder::run(
+	std::vector<FunctionCall*> memoryGuardCalls = findFunctionCalls(
 		_ast,
 		"memoryguard"_yulstring
 	);

libyul/optimiser/FunctionCallFinder.cpp

@@ -16,23 +16,46 @@
 */
 
 #include <libyul/optimiser/FunctionCallFinder.h>
+
+#include <libyul/optimiser/ASTWalker.h>
 #include <libyul/AST.h>
 
 using namespace solidity;
 using namespace solidity::yul;
 
-std::vector<FunctionCall*> FunctionCallFinder::run(Block& _block, YulString _functionName)
+namespace
+{
+template<typename Base, typename ResultType>
+class MaybeConstFunctionCallFinder: Base
 {
-	FunctionCallFinder functionCallFinder(_functionName);
-	functionCallFinder(_block);
-	return functionCallFinder.m_calls;
+public:
+	using MaybeConstBlock = std::conditional_t<std::is_const_v<ResultType>, Block const, Block>;
+	static std::vector<ResultType*> run(MaybeConstBlock& _block, YulString const _functionName)
+	{
+		MaybeConstFunctionCallFinder functionCallFinder(_functionName);
+		functionCallFinder(_block);
+		return functionCallFinder.m_calls;
+	}
+private:
+	explicit MaybeConstFunctionCallFinder(YulString const _functionName): m_functionName(_functionName), m_calls() {}
+	using Base::operator();
+	void operator()(ResultType& _functionCall) override
+	{
+		Base::operator()(_functionCall);
+		if (_functionCall.functionName.name == m_functionName)
+			m_calls.emplace_back(&_functionCall);
+	}
+	YulString m_functionName;
+	std::vector<ResultType*> m_calls;
+};
 }
 
-FunctionCallFinder::FunctionCallFinder(YulString _functionName): m_functionName(_functionName) {}
+std::vector<FunctionCall*> solidity::yul::findFunctionCalls(Block& _block, YulString _functionName)
+{
+	return MaybeConstFunctionCallFinder<ASTModifier, FunctionCall>::run(_block, _functionName);
+}
 
-void FunctionCallFinder::operator()(FunctionCall& _functionCall)
+std::vector<FunctionCall const*> solidity::yul::findFunctionCalls(Block const& _block, YulString _functionName)
 {
-	ASTModifier::operator()(_functionCall);
-	if (_functionCall.functionName.name == m_functionName)
-		m_calls.emplace_back(&_functionCall);
+	return MaybeConstFunctionCallFinder<ASTWalker, FunctionCall const>::run(_block, _functionName);
 }

libyul/optimiser/FunctionCallFinder.h

@@ -20,28 +20,26 @@
 
 #pragma once
 
-#include <libyul/optimiser/ASTWalker.h>
+#include <libyul/ASTForward.h>
+#include <libyul/YulString.h>
 
 #include <vector>
 
 namespace solidity::yul
 {
 
 /**
- * AST walker that finds all calls to a function of a given name.
+ * Finds all calls to a function of a given name using an ASTModifier.
  *
  * Prerequisite: Disambiguator
  */
-class FunctionCallFinder: ASTModifier
-{
-public:
-	static std::vector<FunctionCall*> run(Block& _block, YulString _functionName);
-private:
-	FunctionCallFinder(YulString _functionName);
-	using ASTModifier::operator();
-	void operator()(FunctionCall& _functionCall) override;
-	YulString m_functionName;
-	std::vector<FunctionCall*> m_calls;
-};
+std::vector<FunctionCall*> findFunctionCalls(Block& _block, YulString _functionName);
+
+/**
+ * Finds all calls to a function of a given name using an ASTWalker.
+ *
+ * Prerequisite: Disambiguator
+ */
+std::vector<FunctionCall const*> findFunctionCalls(Block const& _block, YulString _functionName);
 
 }

libyul/optimiser/StackLimitEvader.cpp

@@ -174,7 +174,7 @@ void StackLimitEvader::run(
 		"StackLimitEvader can only be run on objects using the EVMDialect with object access."
 	);
 
-	std::vector<FunctionCall*> memoryGuardCalls = FunctionCallFinder::run(
+	std::vector<FunctionCall*> memoryGuardCalls = findFunctionCalls(
 		*_object.code,
 		"memoryguard"_yulstring
 	);
@@ -206,7 +206,7 @@ void StackLimitEvader::run(
 	StackToMemoryMover::run(_context, reservedMemory, memoryOffsetAllocator.slotAllocations, requiredSlots, *_object.code);
 
 	reservedMemory += 32 * requiredSlots;
-	for (FunctionCall* memoryGuardCall: FunctionCallFinder::run(*_object.code, "memoryguard"_yulstring))
+	for (FunctionCall* memoryGuardCall: findFunctionCalls(*_object.code, "memoryguard"_yulstring))
 	{
 		Literal* literal = std::get_if<Literal>(&memoryGuardCall->arguments.front());
 		yulAssert(literal && literal->kind == LiteralKind::Number, "");

test/libsolidity/MemoryGuardTest.cpp

@@ -73,7 +73,7 @@ TestCase::TestResult MemoryGuardTest::run(std::ostream& _stream, std::string con
 		}
 
 		auto handleObject = [&](std::string const& _kind, Object const& _object) {
-			m_obtainedResult += contractName + "(" + _kind + ") " + (FunctionCallFinder::run(
+			m_obtainedResult += contractName + "(" + _kind + ") " + (findFunctionCalls(
 				*_object.code,
 				"memoryguard"_yulstring
 			).empty() ? "false" : "true") + "\n";