Method performInline

libyul/optimiser/FullInliner.cpp:296–357

}

std::vector<Statement> InlineModifier::performInline(Statement& _statement, FunctionCall& _funCall)
{
	std::vector<Statement> newStatements;
	std::map<YulName, YulName> variableReplacements;

	yulAssert(std::holds_alternative<Identifier>(_funCall.functionName));
	FunctionDefinition* function = m_driver.function(std::get<Identifier>(_funCall.functionName).name);
	assertThrow(!!function, OptimizerException, "Attempt to inline invalid function.");

	m_driver.tentativelyUpdateCodeSize(function->name, m_currentFunction);

	// helper function to create a new variable that is supposed to model
	// an existing variable.
	auto newVariable = [&](NameWithDebugData const& _existingVariable, Expression* _value) {
		YulName newName = m_nameDispenser.newName(_existingVariable.name);
		variableReplacements[_existingVariable.name] = newName;
		VariableDeclaration varDecl{_funCall.debugData, {{_funCall.debugData, newName}}, {}};
		if (_value)
			varDecl.value = std::make_unique<Expression>(std::move(*_value));
		else
			varDecl.value = std::make_unique<Expression>(m_dialect.zeroLiteral());
		newStatements.emplace_back(std::move(varDecl));
	};

	for (auto&& [parameter, argument]: ranges::views::zip(function->parameters, _funCall.arguments) | ranges::views::reverse)
		newVariable(parameter, &argument);
	for (auto const& var: function->returnVariables)
		newVariable(var, nullptr);

	Statement newBody = BodyCopier(m_nameDispenser, variableReplacements)(function->body);
	newStatements += std::move(std::get<Block>(newBody).statements);

	std::visit(util::GenericVisitor{
		util::VisitorFallback<>{},
		[&](Assignment& _assignment)
		{
			for (size_t i = 0; i < _assignment.variableNames.size(); ++i)
				newStatements.emplace_back(Assignment{
					_assignment.debugData,
					{_assignment.variableNames[i]},
					std::make_unique<Expression>(Identifier{
						_assignment.debugData,
						variableReplacements.at(function->returnVariables[i].name)
					})
				});
		},
		[&](VariableDeclaration& _varDecl)
		{
			for (size_t i = 0; i < _varDecl.variables.size(); ++i)
				newStatements.emplace_back(VariableDeclaration{
					_varDecl.debugData,
					{std::move(_varDecl.variables[i])},
					std::make_unique<Expression>(Identifier{
						_varDecl.debugData,
						variableReplacements.at(function->returnVariables[i].name)
					})
				});
		}