solidity/tools/yulPhaser/Program.h

/*
	This file is part of solidity.

	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.

	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.

	You should have received a copy of the GNU General Public License
	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
*/

#pragma once

#include <libyul/optimiser/OptimiserStep.h>
#include <libyul/optimiser/NameDispenser.h>
#include <libyul/AsmData.h>

#include <boost/noncopyable.hpp>

#include <optional>
#include <ostream>
#include <set>
#include <string>
#include <vector>

namespace solidity::langutil
{

class CharStream;

}

namespace solidity::yul
{

struct AsmAnalysisInfo;
struct Dialect;
class YulString;

}

namespace solidity::phaser
{

/**
 * Class representing parsed and analysed Yul program that we can apply optimisations to.
 * The program is already disambiguated and has several prerequisite optimiser steps applied to it
 * so that the requirements of any possible step that could be later applied by the user are
 * already satisfied.
 *
 * The class allows the user to apply extra optimisations and obtain metrics and general
 * information about the resulting syntax tree.
 */
class Program: private boost::noncopyable
{
public:
	Program(Program&& program):
		m_ast(std::move(program.m_ast)),
		m_nameDispenser(std::move(program.m_nameDispenser)),
		// Creating a new instance because a copied one would have a dangling reference to the old dispenser
		m_optimiserStepContext{program.m_optimiserStepContext.dialect, m_nameDispenser, s_externallyUsedIdentifiers}
	{}
	Program operator=(Program&& program) = delete;

	static Program load(std::string const& _sourcePath);
	void optimise(std::vector<std::string> const& _optimisationSteps);

	size_t codeSize() const { return computeCodeSize(*m_ast); }
	yul::Block const& ast() const { return *m_ast; }

	friend std::ostream& operator<<(std::ostream& _stream, Program const& _program);
	std::string toJson() const;

private:
	Program(
		yul::Dialect const& _dialect,
		std::unique_ptr<yul::Block> _ast
	):
		m_ast(std::move(_ast)),
		m_nameDispenser(_dialect, *m_ast, s_externallyUsedIdentifiers),
		m_optimiserStepContext{_dialect, m_nameDispenser, s_externallyUsedIdentifiers}
	{}

	static langutil::CharStream loadSource(std::string const& _sourcePath);
	static std::unique_ptr<yul::Block> parseSource(
		yul::Dialect const& _dialect,
		langutil::CharStream _source
	);
	static std::unique_ptr<yul::AsmAnalysisInfo> analyzeAST(
		yul::Dialect const& _dialect,
		yul::Block const& _ast
	);
	static std::unique_ptr<yul::Block> disambiguateAST(
		yul::Dialect const& _dialect,
		yul::Block const& _ast,
		yul::AsmAnalysisInfo const& _analysisInfo
	);
	static void applyOptimisationSteps(
		yul::OptimiserStepContext& _context,
		yul::Block& _ast,
		std::vector<std::string> const& _optimisationSteps
	);
	static size_t computeCodeSize(yul::Block const& _ast);

	std::unique_ptr<yul::Block> m_ast;
	yul::NameDispenser m_nameDispenser;
	yul::OptimiserStepContext m_optimiserStepContext;

	// Always empty set of reserved identifiers. It could be a constructor parameter but I don't
	// think it would be useful in this tool. Other tools (like yulopti) have it empty too.
	// We need it to live as long as m_optimiserStepContext because it stores a reference
	// but since it's empty and read-only we can just have all objects share one static instance.
	static std::set<yul::YulString> const s_externallyUsedIdentifiers;
};

}