/src/solidity/libsolidity/interface/CompilerStack.cpp

Source
/*
  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/>.
*/
// SPDX-License-Identifier: GPL-3.0
/**
 * @author Christian <c@ethdev.com>
 * @author Gav Wood <g@ethdev.com>
 * @date 2014
 * Full-stack compiler that converts a source code string to bytecode.
 */


#include <libsolidity/interface/CompilerStack.h>
#include <libsolidity/interface/ImportRemapper.h>

#include <libsolidity/analysis/ControlFlowAnalyzer.h>
#include <libsolidity/analysis/ControlFlowGraph.h>
#include <libsolidity/analysis/ControlFlowRevertPruner.h>
#include <libsolidity/analysis/ContractLevelChecker.h>
#include <libsolidity/analysis/DeclarationTypeChecker.h>
#include <libsolidity/analysis/DocStringAnalyser.h>
#include <libsolidity/analysis/DocStringTagParser.h>
#include <libsolidity/analysis/GlobalContext.h>
#include <libsolidity/analysis/NameAndTypeResolver.h>
#include <libsolidity/analysis/PostTypeChecker.h>
#include <libsolidity/analysis/PostTypeContractLevelChecker.h>
#include <libsolidity/analysis/StaticAnalyzer.h>
#include <libsolidity/analysis/SyntaxChecker.h>
#include <libsolidity/analysis/Scoper.h>
#include <libsolidity/analysis/TypeChecker.h>
#include <libsolidity/analysis/ViewPureChecker.h>
#include <libsolidity/analysis/ImmutableValidator.h>

#include <libsolidity/ast/AST.h>
#include <libsolidity/ast/TypeProvider.h>
#include <libsolidity/ast/ASTJsonImporter.h>
#include <libsolidity/codegen/Compiler.h>
#include <libsolidity/formal/ModelChecker.h>
#include <libsolidity/interface/ABI.h>
#include <libsolidity/interface/Natspec.h>
#include <libsolidity/interface/GasEstimator.h>
#include <libsolidity/interface/StorageLayout.h>
#include <libsolidity/interface/UniversalCallback.h>
#include <libsolidity/interface/Version.h>
#include <libsolidity/parsing/Parser.h>

#include <libsolidity/experimental/analysis/Analysis.h>
#include <libsolidity/experimental/analysis/FunctionDependencyAnalysis.h>
#include <libsolidity/experimental/codegen/IRGenerator.h>

#include <libsolidity/codegen/ir/Common.h>
#include <libsolidity/codegen/ir/IRGenerator.h>

#include <libstdlib/stdlib.h>

#include <libyul/YulName.h>
#include <libyul/AsmPrinter.h>
#include <libyul/AsmJsonConverter.h>
#include <libyul/YulStack.h>
#include <libyul/AST.h>
#include <libyul/AsmParser.h>
#include <libyul/optimiser/Suite.h>

#include <liblangutil/Scanner.h>
#include <liblangutil/SemVerHandler.h>
#include <liblangutil/SourceReferenceFormatter.h>

#include <libsolutil/SwarmHash.h>
#include <libsolutil/IpfsHash.h>
#include <libsolutil/JSON.h>
#include <libsolutil/Algorithms.h>
#include <libsolutil/FunctionSelector.h>

#include <libevmasm/Ethdebug.h>

#include <boost/algorithm/string/replace.hpp>

#include <range/v3/algorithm/all_of.hpp>
#include <range/v3/view/concat.hpp>
#include <range/v3/view/map.hpp>

#include <fmt/format.h>

#include <utility>
#include <map>
#include <limits>
#include <string>

using namespace solidity;
using namespace solidity::langutil;
using namespace solidity::frontend;
using namespace solidity::stdlib;
using namespace solidity::yul;
using namespace std::string_literals;

using solidity::util::errinfo_comment;

static int g_compilerStackCounts = 0;

CompilerStack::CompilerStack(ReadCallback::Callback _readFile):
  m_readFile{std::move(_readFile)},
  m_objectOptimizer(std::make_shared<yul::ObjectOptimizer>()),
  m_errorReporter{m_errorList}
{
  // Because TypeProvider is currently a singleton API, we must ensure that
  // no more than one entity is actually using it at a time.
  solAssert(g_compilerStackCounts == 0, "You shall not have another CompilerStack aside me.");
  ++g_compilerStackCounts;
}

CompilerStack::~CompilerStack()
{
  --g_compilerStackCounts;
  TypeProvider::reset();
}

void CompilerStack::createAndAssignCallGraphs()
{
  for (Source const* source: m_sourceOrder)
  {
    if (!source->ast)
      continue;

    for (ContractDefinition const* contract: ASTNode::filteredNodes<ContractDefinition>(source->ast->nodes()))
    {
      ContractDefinitionAnnotation& annotation =
        m_contracts.at(contract->fullyQualifiedName()).contract->annotation();

      annotation.creationCallGraph = std::make_unique<CallGraph>(
        FunctionCallGraphBuilder::buildCreationGraph(*contract)
      );
      annotation.deployedCallGraph = std::make_unique<CallGraph>(
        FunctionCallGraphBuilder::buildDeployedGraph(
          *contract,
          **annotation.creationCallGraph
        )
      );

      solAssert(annotation.contractDependencies.empty(), "contractDependencies expected to be empty?!");

      annotation.contractDependencies = annotation.creationCallGraph->get()->bytecodeDependency;

      for (auto const& [dependencyContract, referencee]: annotation.deployedCallGraph->get()->bytecodeDependency)
        annotation.contractDependencies.emplace(dependencyContract, referencee);
    }
  }
}

void CompilerStack::findAndReportCyclicContractDependencies()
{
  // Cycles we found, used to avoid duplicate reports for the same reference
  std::set<ASTNode const*, ASTNode::CompareByID> foundCycles;

  for (Source const* source: m_sourceOrder)
  {
    if (!source->ast)
      continue;

    for (ContractDefinition const* contractDefinition: ASTNode::filteredNodes<ContractDefinition>(source->ast->nodes()))
    {
      util::CycleDetector<ContractDefinition> cycleDetector{[&](
        ContractDefinition const& _contract,
        util::CycleDetector<ContractDefinition>& _cycleDetector,
        size_t _depth
      )
      {
        // No specific reason for exactly that number, just a limit we're unlikely to hit.
        if (_depth >= 256)
          m_errorReporter.fatalTypeError(
            7864_error,
            _contract.location(),
            "Contract dependencies exhausting cyclic dependency validator"
          );

        for (auto& [dependencyContract, referencee]: _contract.annotation().contractDependencies)
          if (_cycleDetector.run(*dependencyContract))
            return;
      }};

      ContractDefinition const* cycle = cycleDetector.run(*contractDefinition);

      if (!cycle)
        continue;

      ASTNode const* referencee = contractDefinition->annotation().contractDependencies.at(cycle);

      if (foundCycles.find(referencee) != foundCycles.end())
        continue;

      SecondarySourceLocation secondaryLocation{};
      secondaryLocation.append("Referenced contract is here:"s, cycle->location());

      m_errorReporter.typeError(
        7813_error,
        referencee->location(),
        secondaryLocation,
        "Circular reference to contract bytecode either via \"new\" or \"type(...).creationCode\" / \"type(...).runtimeCode\"."
      );

      foundCycles.emplace(referencee);
    }
  }
}

void CompilerStack::setRemappings(std::vector<ImportRemapper::Remapping> _remappings)
{
  solAssert(m_stackState < ParsedAndImported, "Must set remappings before parsing.");
  for (auto const& remapping: _remappings)
    solAssert(!remapping.prefix.empty(), "");
  m_importRemapper.setRemappings(std::move(_remappings));
}

void CompilerStack::setViaIR(bool _viaIR)
{
  solAssert(m_stackState < ParsedAndImported, "Must set viaIR before parsing.");
  m_viaIR = _viaIR;
}

void CompilerStack::setExperimental(bool _experimental)
{
  solAssert(m_stackState < ParsedAndImported, "Must set experimental before parsing.");
  m_experimental = _experimental;
}

void CompilerStack::setViaSSACFG(bool _viaSSACFG)
{
  solAssert(m_stackState < CompilationSuccessful, "Must set SSA CFG codegen before compilation.");
  m_viaSSACFG = _viaSSACFG;
}

void CompilerStack::setEVMVersion(langutil::EVMVersion _version)
{
  solAssert(m_stackState < ParsedAndImported, "Must set EVM version before parsing.");
  m_evmVersion = _version;
  // GlobalContext depends on evmVersion since the Cancun hardfork.
  // Therefore, we reset it whenever we set a new EVM version, ensuring that the context is never reused with a mismatched version.
  m_globalContext.reset();
}

void CompilerStack::setModelCheckerSettings(ModelCheckerSettings _settings)
{
  solAssert(m_stackState < ParsedAndImported, "Must set model checking settings before parsing.");
  m_modelCheckerSettings = _settings;
}

void CompilerStack::selectContracts(ContractSelection const& _selectedContracts)
{
  solAssert(m_stackState < ParsedAndImported, "Must request outputs before parsing.");
  m_selectedContracts = _selectedContracts;
}

void CompilerStack::setLibraries(std::map<std::string, util::h160> const& _libraries)
{
  solAssert(m_stackState < ParsedAndImported, "Must set libraries before parsing.");
  m_libraries = _libraries;
}

void CompilerStack::setOptimiserSettings(bool _optimize, OptimiserSettings::ExecutionCount _runs)
{
  OptimiserSettings settings = _optimize ? OptimiserSettings::standard() : OptimiserSettings::minimal();
  settings.expectedExecutionsPerDeployment = _runs;
  setOptimiserSettings(std::move(settings));
}

void CompilerStack::setOptimiserSettings(OptimiserSettings _settings)
{
  solAssert(m_stackState < ParsedAndImported, "Must set optimiser settings before parsing.");
  m_optimiserSettings = std::move(_settings);
}

void CompilerStack::setRevertStringBehaviour(RevertStrings _revertStrings)
{
  solAssert(m_stackState < ParsedAndImported, "Must set revert string settings before parsing.");
  solUnimplementedAssert(_revertStrings != RevertStrings::VerboseDebug);
  m_revertStrings = _revertStrings;
}

void CompilerStack::useMetadataLiteralSources(bool _metadataLiteralSources)
{
  solAssert(m_stackState < ParsedAndImported, "Must set use literal sources before parsing.");
  m_metadataLiteralSources = _metadataLiteralSources;
}

void CompilerStack::setMetadataHash(MetadataHash _metadataHash)
{
  solAssert(m_stackState < ParsedAndImported, "Must set metadata hash before parsing.");
  m_metadataHash = _metadataHash;
}

void CompilerStack::selectDebugInfo(DebugInfoSelection _debugInfoSelection)
{
  solAssert(m_stackState < CompilationSuccessful, "Must select debug info components before compilation.");
  m_debugInfoSelection = _debugInfoSelection;
}

void CompilerStack::addSMTLib2Response(h256 const& _hash, std::string const& _response)
{
  solAssert(m_stackState < ParsedAndImported, "Must add SMTLib2 responses before parsing.");
  m_smtlib2Responses[_hash] = _response;
}

void CompilerStack::reset(bool _keepSettings)
{
  m_stackState = Empty;
  m_sources.clear();
  m_maxAstId.reset();
  m_smtlib2Responses.clear();
  m_unhandledSMTLib2Queries.clear();
  if (!_keepSettings)
  {
    m_importRemapper.clear();
    m_libraries.clear();
    m_viaIR = false;
    m_viaSSACFG = false;
    m_evmVersion = langutil::EVMVersion();
    m_modelCheckerSettings = ModelCheckerSettings{};
    m_selectedContracts.clear();
    m_revertStrings = RevertStrings::Default;
    m_optimiserSettings = OptimiserSettings::minimal();
    m_metadataLiteralSources = false;
    m_metadataFormat = defaultMetadataFormat();
    m_metadataHash = MetadataHash::IPFS;
    m_stopAfter = State::CompilationSuccessful;
    m_compilationSourceType = CompilationSourceType::Solidity;
  }
  m_experimentalAnalysis.reset();
  m_globalContext.reset();
  m_sourceOrder.clear();
  m_contracts.clear();
  m_errorReporter.clear();
  TypeProvider::reset();
}

void CompilerStack::setSources(StringMap _sources)
{
  solAssert(m_stackState != SourcesSet, "Cannot change sources once set.");
  solAssert(m_stackState == Empty, "Must set sources before parsing.");
  for (auto source: _sources)
    m_sources[source.first].charStream = std::make_unique<CharStream>(/*content*/std::move(source.second), /*name*/source.first);
  m_stackState = SourcesSet;
}

bool CompilerStack::parse()
{
  solAssert(m_stackState == SourcesSet, "Must call parse only after the SourcesSet state.");
  m_errorReporter.clear();

  if (SemVerVersion{std::string(VersionString)}.isPrerelease())
    m_errorReporter.warning(3805_error, "This is a pre-release compiler version, please do not use it in production.");

  try
  {
    Parser parser{m_errorReporter, m_evmVersion};

    std::vector<std::string> sourcesToParse;
    for (auto const& s: m_sources)
      sourcesToParse.push_back(s.first);

    for (size_t i = 0; i < sourcesToParse.size(); ++i)
    {
      std::string const path = sourcesToParse[i];
      Source& source = m_sources[path];
      source.ast = parser.parse(*source.charStream);
      if (!source.ast)
        solAssert(Error::containsErrors(m_errorReporter.errors()), "Parser returned null but did not report error.");
      else
      {
        source.ast->annotation().path = path;

        for (auto const& import: ASTNode::filteredNodes<ImportDirective>(source.ast->nodes()))
        {
          solAssert(!import->path().empty(), "Import path cannot be empty.");
          // Check whether the import directive is for the standard library,
          // and if yes, add specified file to source units to be parsed.
          auto it = stdlib::sources.find(import->path());
          if (it != stdlib::sources.end())
          {
            auto [name, content] = *it;
            m_sources[name].charStream = std::make_unique<CharStream>(content, name);
            sourcesToParse.push_back(name);
          }

          // The current value of `path` is the absolute path as seen from this source file.
          // We first have to apply remappings before we can store the actual absolute path
          // as seen globally.
          import->annotation().absolutePath = applyRemapping(util::absolutePath(
            import->path(),
            path
          ), path);
        }

        if (m_stopAfter >= ParsedAndImported)
          for (auto const& newSource: loadMissingSources(*source.ast))
          {
            std::string const& newPath = newSource.first;
            std::string const& newContents = newSource.second;
            m_sources[newPath].charStream = std::make_shared<CharStream>(newContents, newPath);
            sourcesToParse.push_back(newPath);
          }
      }
    }

    if (Error::containsErrors(m_errorReporter.errors()))
      return false;

    m_stackState = (m_stopAfter <= Parsed ? Parsed : ParsedAndImported);
    storeContractDefinitions();

    solAssert(!m_maxAstId.has_value());
    m_maxAstId = parser.maxID();
  }
  catch (UnimplementedFeatureError const& _error)
  {
    reportUnimplementedFeatureError(_error);
    return false;
  }

  return true;
}

void CompilerStack::importASTs(std::map<std::string, Json> const& _sources)
{
  solAssert(m_stackState == Empty, "Must call importASTs only before the SourcesSet state.");
  std::map<std::string, ASTPointer<SourceUnit>> reconstructedSources =
    ASTJsonImporter(m_evmVersion).jsonToSourceUnit(_sources);
  for (auto& src: reconstructedSources)
  {
    solUnimplementedAssert(!src.second->experimentalSolidity());
    std::string const& path = src.first;
    Source source;
    source.ast = src.second;
    source.charStream = std::make_shared<CharStream>(
      util::jsonCompactPrint(_sources.at(src.first)),
      src.first,
      true // imported from AST
    );
    m_sources[path] = std::move(source);
  }
  m_stackState = ParsedAndImported;
  m_compilationSourceType = CompilationSourceType::SolidityAST;

  storeContractDefinitions();
}

namespace
{

bool onlySafeExperimentalFeaturesActivated(std::set<ExperimentalFeature> const& _features)
{
  for (auto const feature: _features)
    if (!ExperimentalFeatureWithoutWarning.contains(feature))
      return false;
  return true;
}

}

bool CompilerStack::analyze()
{
  solAssert(m_stackState == ParsedAndImported, "Must call analyze only after parsing was successful.");

  if (!resolveImports())
    return false;

  for (Source const* source: m_sourceOrder)
    if (source->ast)
      Scoper::assignScopes(*source->ast);

  bool noErrors = true;

  try
  {
    bool experimentalSolidity = isExperimentalSolidity();

    SyntaxChecker syntaxChecker(m_errorReporter, m_optimiserSettings.runYulOptimiser, m_experimental);
    for (Source const* source: m_sourceOrder)
      if (source->ast && !syntaxChecker.checkSyntax(*source->ast))
        noErrors = false;

    m_globalContext = std::make_shared<GlobalContext>(m_evmVersion);
    // We need to keep the same resolver during the whole process.
    NameAndTypeResolver resolver(*m_globalContext, m_evmVersion, m_errorReporter, experimentalSolidity);
    for (Source const* source: m_sourceOrder)
      if (source->ast && !resolver.registerDeclarations(*source->ast))
        return false;

    std::map<std::string, SourceUnit const*> sourceUnitsByName;
    for (auto& source: m_sources)
      sourceUnitsByName[source.first] = source.second.ast.get();
    for (Source const* source: m_sourceOrder)
      if (source->ast && !resolver.performImports(*source->ast, sourceUnitsByName))
        return false;

    resolver.warnHomonymDeclarations();

    {
      DocStringTagParser docStringTagParser(m_errorReporter);
      for (Source const* source: m_sourceOrder)
        if (source->ast && !docStringTagParser.parseDocStrings(*source->ast))
          noErrors = false;
    }

    // Requires DocStringTagParser
    for (Source const* source: m_sourceOrder)
      if (source->ast && !resolver.resolveNamesAndTypes(*source->ast))
        return false;

    if (experimentalSolidity)
    {
      if (!analyzeExperimental())
        noErrors = false;
    }
    else if (!analyzeLegacy(noErrors))
      noErrors = false;
  }
  catch (FatalError const&)
  {
    if (!m_errorReporter.hasErrors())
    {
      std::cerr << "Unreported fatal error:" << std::endl;
      std::cerr << boost::current_exception_diagnostic_information() << std::endl;
      solAssert(false, "Unreported fatal error.");
    }
    noErrors = false;
  }
  catch (UnimplementedFeatureError const& _error)
  {
    reportUnimplementedFeatureError(_error);
    noErrors = false;
  }

  if (!noErrors)
    return false;

  for (Source const* source: m_sourceOrder)
    if (source->ast && !m_experimental)
      solAssert(onlySafeExperimentalFeaturesActivated(source->ast->annotation().experimentalFeatures));

  m_stackState = AnalysisSuccessful;
  return true;
}


bool CompilerStack::analyzeLegacy(bool _noErrorsSoFar)
{
  bool noErrors = _noErrorsSoFar;

  DeclarationTypeChecker declarationTypeChecker(m_errorReporter, m_evmVersion);
  for (Source const* source: m_sourceOrder)
    if (source->ast && !declarationTypeChecker.check(*source->ast))
      return false;

  // Requires DeclarationTypeChecker to have run
  DocStringTagParser docStringTagParser(m_errorReporter);
  for (Source const* source: m_sourceOrder)
    if (source->ast && !docStringTagParser.validateDocStringsUsingTypes(*source->ast))
      noErrors = false;

  // Next, we check inheritance, overrides, function collisions and other things at
  // contract or function level.
  // This also calculates whether a contract is abstract, which is needed by the
  // type checker.
  ContractLevelChecker contractLevelChecker(m_errorReporter);

  for (Source const* source: m_sourceOrder)
    if (auto sourceAst = source->ast)
      noErrors = contractLevelChecker.check(*sourceAst);

  // Now we run full type checks that go down to the expression level. This
  // cannot be done earlier, because we need cross-contract types and information
  // about whether a contract is abstract for the `new` expression.
  // This populates the `type` annotation for all expressions.
  //
  // Note: this does not resolve overloaded functions. In order to do that, types of arguments are needed,
  // which is only done one step later.
  TypeChecker typeChecker(m_evmVersion, m_errorReporter);
  for (Source const* source: m_sourceOrder)
    if (source->ast && !typeChecker.checkTypeRequirements(*source->ast))
      noErrors = false;

  if (noErrors)
  {
    // Requires ContractLevelChecker and TypeChecker
    DocStringAnalyser docStringAnalyser(m_errorReporter);
    for (Source const* source: m_sourceOrder)
      if (source->ast && !docStringAnalyser.analyseDocStrings(*source->ast))
        noErrors = false;
  }

  if (noErrors)
  {
    // Checks that can only be done when all types of all AST nodes are known.
    PostTypeChecker postTypeChecker(m_errorReporter);
    for (Source const* source: m_sourceOrder)
      if (source->ast && !postTypeChecker.check(*source->ast))
        noErrors = false;
    if (!postTypeChecker.finalize())
      noErrors = false;
  }

  // Create & assign callgraphs and check for contract dependency cycles
  if (noErrors)
  {
    createAndAssignCallGraphs();
    annotateInternalFunctionIDs();
    findAndReportCyclicContractDependencies();
  }

  if (noErrors)
    for (Source const* source: m_sourceOrder)
      if (source->ast && !PostTypeContractLevelChecker{m_errorReporter}.check(*source->ast))
        noErrors = false;

  // Check that immutable variables are never read in c'tors and assigned
  // exactly once
  if (noErrors)
    for (Source const* source: m_sourceOrder)
      if (source->ast)
        for (ASTPointer<ASTNode> const& node: source->ast->nodes())
          if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get()))
            ImmutableValidator(m_errorReporter, *contract).analyze();

  if (noErrors)
  {
    // Control flow graph generator and analyzer. It can check for issues such as
    // variable is used before it is assigned to.
    CFG cfg(m_errorReporter);
    for (Source const* source: m_sourceOrder)
      if (source->ast && !cfg.constructFlow(*source->ast))
        noErrors = false;

    if (noErrors)
    {
      ControlFlowRevertPruner pruner(cfg);
      pruner.run();

      ControlFlowAnalyzer controlFlowAnalyzer(cfg, m_errorReporter);
      if (!controlFlowAnalyzer.run())
        noErrors = false;
    }
  }

  if (noErrors)
  {
    // Checks for common mistakes. Only generates warnings.
    StaticAnalyzer staticAnalyzer(m_errorReporter);
    for (Source const* source: m_sourceOrder)
      if (source->ast && !staticAnalyzer.analyze(*source->ast))
        noErrors = false;
  }

  if (noErrors)
  {
    // Check for state mutability in every function.
    std::vector<ASTPointer<ASTNode>> ast;
    for (Source const* source: m_sourceOrder)
      if (source->ast)
        ast.push_back(source->ast);

    if (!ViewPureChecker(ast, m_errorReporter).check())
      noErrors = false;
  }

  if (noErrors)
  {
    // Run SMTChecker

    auto allSources = util::applyMap(m_sourceOrder, [](Source const* _source) { return _source->ast; });
    if (ModelChecker::isPragmaPresent(allSources))
      m_modelCheckerSettings.engine = ModelCheckerEngine::All();

    // m_modelCheckerSettings is spread to engines and solver interfaces,
    // so we need to check whether the enabled ones are available before building the classes.
    if (m_modelCheckerSettings.engine.any())
      m_modelCheckerSettings.solvers = ModelChecker::checkRequestedSolvers(m_modelCheckerSettings.solvers, m_errorReporter);

    ModelChecker modelChecker(m_errorReporter, *this, m_smtlib2Responses, m_modelCheckerSettings, m_readFile);
    modelChecker.checkRequestedSourcesAndContracts(allSources);
    for (Source const* source: m_sourceOrder)
      if (source->ast)
        modelChecker.analyze(*source->ast);
    m_unhandledSMTLib2Queries += modelChecker.unhandledQueries();
  }

  return noErrors;
}

bool CompilerStack::analyzeExperimental()
{
  solAssert(!m_experimentalAnalysis);
  solAssert(m_maxAstId && *m_maxAstId >= 0);
  m_experimentalAnalysis = std::make_unique<experimental::Analysis>(m_errorReporter, static_cast<std::uint64_t>(*m_maxAstId));
  std::vector<std::shared_ptr<SourceUnit const>> sourceAsts;
  for (Source const* source: m_sourceOrder)
    if (source->ast)
      sourceAsts.emplace_back(source->ast);
  return m_experimentalAnalysis->check(sourceAsts);
}

bool CompilerStack::parseAndAnalyze(State _stopAfter)
{
  m_stopAfter = _stopAfter;

  bool success = parse();
  if (m_stackState >= m_stopAfter)
    return success;
  if (success)
    success = analyze();
  return success;
}

bool CompilerStack::isRequestedSource(std::string const& _sourceName) const
{
  return
    m_selectedContracts.empty() ||
    m_selectedContracts.count("") ||
    m_selectedContracts.count(_sourceName);
}

bool CompilerStack::isRequestedContract(ContractDefinition const& _contract) const
{
  /// In case nothing was specified in selectedContracts.
  if (m_selectedContracts.empty())
    return true;

  for (auto const& key: std::vector<std::string>{"", _contract.sourceUnitName()})
  {
    auto const& it = m_selectedContracts.find(key);
    if (it != m_selectedContracts.end())
      if (it->second.count(_contract.name()) || it->second.count(""))
        return true;
  }

  return false;
}

CompilerStack::PipelineConfig CompilerStack::requestedPipelineConfig(ContractDefinition const& _contract) const
{
  static PipelineConfig constexpr defaultPipelineConfig = PipelineConfig{
    false, // irCodegen
    false, // irOptimization
    true,  // bytecode
  };

  // If nothing was explicitly selected, all contracts are selected by default.
  if (m_selectedContracts.empty())
    return defaultPipelineConfig;

  PipelineConfig combinedConfig;
  for (std::string const& sourceUnitName: {""s, _contract.sourceUnitName()})
    if (m_selectedContracts.count(sourceUnitName) != 0)
      for (std::string const& contractName: {""s, _contract.name()})
        if (m_selectedContracts.at(sourceUnitName).count(contractName) != 0)
          combinedConfig = combinedConfig | m_selectedContracts.at(sourceUnitName).at(contractName);

  return combinedConfig;
}

bool CompilerStack::compile(State _stopAfter)
{
  m_stopAfter = _stopAfter;

  solAssert(!m_viaSSACFG || m_experimental, "SSA CFG code generation is an experimental feature. It requires experimental mode to be enabled.");

  if (m_stackState < AnalysisSuccessful)
    if (!parseAndAnalyze(_stopAfter))
      return false;

  if (m_stackState >= m_stopAfter)
    return true;

  // Only compile contracts individually which have been requested.
  std::map<ContractDefinition const*, std::shared_ptr<Compiler const>> otherCompilers;
  bool requiresFullCompilation = false;

  for (Source const* source: m_sourceOrder)
    for (ASTPointer<ASTNode> const& node: source->ast->nodes())
      if (auto contract = dynamic_cast<ContractDefinition const*>(node.get()))
        if (isRequestedContract(*contract))
        {
          PipelineConfig pipelineConfig = requestedPipelineConfig(*contract);

          try
          {
            // Skip if full compilation is not needed (i.e. no IR/bytecode requested)
            if (!pipelineConfig.needsFullCompilation())
              continue;
            requiresFullCompilation = true;

            if (pipelineConfig.needIR(m_viaIR))
              generateIR(*contract, pipelineConfig.needIRCodegenOnly(m_viaIR));
            if (pipelineConfig.needBytecode())
            {
              if (m_viaIR)
                generateEVMFromIR(*contract);
              else
              {
                if (m_experimentalAnalysis)
                  solThrow(CompilerError, "Legacy codegen after experimental analysis is unsupported.");
                compileContract(*contract, otherCompilers);
              }
            }
          }
          catch (Error const& _error)
          {
            reportCodeGenerationError(_error, contract);
          }
          catch (UnimplementedFeatureError const& _error)
          {
            reportUnimplementedFeatureError(_error, contract);
          }

          if (m_errorReporter.hasErrors())
            return false;
        }

  solAssert(!m_errorReporter.hasErrors());
  m_stackState = CompilationSuccessful;
  if (requiresFullCompilation)
    this->link();
  return true;
}

void CompilerStack::link()
{
  solAssert(m_stackState >= CompilationSuccessful, "");
  for (auto& contract: m_contracts)
  {
    contract.second.object.link(m_libraries);
    contract.second.runtimeObject.link(m_libraries);
  }
}

YulStack CompilerStack::loadGeneratedIR(std::string const& _ir) const
{
  YulStack stack(
    m_evmVersion,
    m_optimiserSettings,
    m_debugInfoSelection,
    this, // _soliditySourceProvider
    m_objectOptimizer
  );
  bool yulAnalysisSuccessful = stack.parseAndAnalyze("", _ir);
  solAssert(
    yulAnalysisSuccessful,
    _ir + "\n\n"
    "Invalid IR generated:\n" +
    SourceReferenceFormatter::formatErrorInformation(
      stack.errors(),
      stack, // _charStreamProvider
      false, // _colored
      true   // _withErrorIds
    ) + "\n"
  );

  return stack;
}

std::vector<std::string> CompilerStack::contractNames() const
{
  solAssert(m_stackState >= Parsed, "Parsing was not successful.");
  std::vector<std::string> contractNames;
  for (auto const& contract: m_contracts)
    contractNames.push_back(contract.first);
  return contractNames;
}

std::string const CompilerStack::lastContractName(std::optional<std::string> const& _sourceName) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Parsing was not successful.");
  // try to find some user-supplied contract
  std::string contractName;
  for (auto const& it: m_sources)
    if (_sourceName.value_or(it.first) == it.first)
      for (auto const* contract: ASTNode::filteredNodes<ContractDefinition>(it.second.ast->nodes()))
        contractName = contract->fullyQualifiedName();
  return contractName;
}

evmasm::AssemblyItems const* CompilerStack::assemblyItems(std::string const& _contractName) const
{
  solAssert(m_stackState == CompilationSuccessful, "Compilation was not successful.");

  Contract const& currentContract = contract(_contractName);
  if (!currentContract.evmAssembly)
    return nullptr;
  return &currentContract.evmAssembly->items();
}

evmasm::AssemblyItems const* CompilerStack::runtimeAssemblyItems(std::string const& _contractName) const
{
  solAssert(m_stackState == CompilationSuccessful, "Compilation was not successful.");

  Contract const& currentContract = contract(_contractName);

  if (!currentContract.evmRuntimeAssembly)
    return nullptr;
  return &currentContract.evmRuntimeAssembly->items();
}

Json CompilerStack::generatedSources(std::string const& _contractName, bool _runtime) const
{
  solAssert(m_stackState == CompilationSuccessful, "Compilation was not successful.");

  Contract const& c = contract(_contractName);
  Json sources = Json::array();
  // If there is no compiler, then no bytecode was generated and thus no
  // sources were generated (or we compiled "via IR").
  if (c.runtimeGeneratedYulUtilityCode.has_value())
  {
    solAssert(c.generatedYulUtilityCode.has_value() == c.runtimeGeneratedYulUtilityCode.has_value());
    solAssert(!m_viaIR);
    std::string source =
      _runtime ?
      *c.runtimeGeneratedYulUtilityCode :
      *c.generatedYulUtilityCode;
    if (!source.empty())
    {
      std::string sourceName = CompilerContext::yulUtilityFileName();
      unsigned sourceIndex = sourceIndices()[sourceName];
      ErrorList errors;
      ErrorReporter errorReporter(errors);
      CharStream charStream(source, sourceName);
      yul::EVMDialect const& dialect = yul::EVMDialect::strictAssemblyForEVM(m_evmVersion);
      std::shared_ptr<yul::AST> parserResult = yul::Parser{errorReporter, dialect}.parse(charStream);
      solAssert(parserResult);
      sources[0]["ast"] = yul::AsmJsonConverter{dialect, sourceIndex}(parserResult->root());
      sources[0]["name"] = sourceName;
      sources[0]["id"] = sourceIndex;
      sources[0]["language"] = "Yul";
      sources[0]["contents"] = std::move(source);
    }
  }
  return sources;
}

std::string const* CompilerStack::sourceMapping(std::string const& _contractName) const
{
  solAssert(m_stackState == CompilationSuccessful, "Compilation was not successful.");

  Contract const& c = contract(_contractName);
  if (!c.sourceMapping)
  {
    if (auto items = assemblyItems(_contractName))
      c.sourceMapping.emplace(evmasm::AssemblyItem::computeSourceMapping(*items, sourceIndices()));
  }
  return c.sourceMapping ? &*c.sourceMapping : nullptr;
}

std::string const* CompilerStack::runtimeSourceMapping(std::string const& _contractName) const
{
  solAssert(m_stackState == CompilationSuccessful, "Compilation was not successful.");

  Contract const& c = contract(_contractName);
  if (!c.runtimeSourceMapping)
  {
    if (auto items = runtimeAssemblyItems(_contractName))
      c.runtimeSourceMapping.emplace(
        evmasm::AssemblyItem::computeSourceMapping(*items, sourceIndices())
      );
  }
  return c.runtimeSourceMapping ? &*c.runtimeSourceMapping : nullptr;
}

std::string const CompilerStack::filesystemFriendlyName(std::string const& _contractName) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "No compiled contracts found.");

  // Look up the contract (by its fully-qualified name)
  Contract const& matchContract = m_contracts.at(_contractName);
  // Check to see if it could collide on name
  for (auto const& contract: m_contracts)
  {
    if (contract.second.contract->name() == matchContract.contract->name() &&
        contract.second.contract != matchContract.contract)
    {
      // If it does, then return its fully-qualified name, made fs-friendly
      std::string friendlyName = boost::algorithm::replace_all_copy(_contractName, "/", "_");
      boost::algorithm::replace_all(friendlyName, ":", "_");
      boost::algorithm::replace_all(friendlyName, ".", "_");
      return friendlyName;
    }
  }
  // If no collision, return the contract's name
  return matchContract.contract->name();
}

std::optional<std::string> const& CompilerStack::yulIR(std::string const& _contractName) const
{
  solAssert(m_stackState == CompilationSuccessful, "Compilation was not successful.");
  return contract(_contractName).yulIR;
}

std::optional<Json> CompilerStack::yulIRAst(std::string const& _contractName) const
{
  solAssert(m_stackState == CompilationSuccessful, "Compilation was not successful.");
  solUnimplementedAssert(!isExperimentalSolidity());

  // NOTE: Intentionally not using LazyInit. The artifact can get very large and we don't want to
  // keep it around when compiling a large project containing many contracts.
  Contract const& currentContract = contract(_contractName);
  yulAssert(currentContract.contract);
  yulAssert(currentContract.yulIR.has_value() == currentContract.contract->canBeDeployed());
  if (!currentContract.yulIR)
    return std::nullopt;
  return loadGeneratedIR(*currentContract.yulIR).astJson();
}

std::optional<Json> CompilerStack::yulCFGJson(std::string const& _contractName) const
{
  solAssert(m_stackState == CompilationSuccessful, "Compilation was not successful.");
  solUnimplementedAssert(!isExperimentalSolidity());

  // NOTE: Intentionally not using LazyInit. The artifact can get very large and we don't want to
  // keep it around when compiling a large project containing many contracts.
  Contract const& currentContract = contract(_contractName);
  yulAssert(currentContract.contract);
  yulAssert(currentContract.yulIROptimized.has_value() == currentContract.contract->canBeDeployed());
  if (!currentContract.yulIROptimized)
    return std::nullopt;
  return loadGeneratedIR(*currentContract.yulIROptimized).cfgJson();
}

std::optional<std::string> const& CompilerStack::yulIROptimized(std::string const& _contractName) const
{
  solAssert(m_stackState == CompilationSuccessful, "Compilation was not successful.");
  return contract(_contractName).yulIROptimized;
}

std::optional<Json> CompilerStack::yulIROptimizedAst(std::string const& _contractName) const
{
  solAssert(m_stackState == CompilationSuccessful, "Compilation was not successful.");
  solUnimplementedAssert(!isExperimentalSolidity());

  // NOTE: Intentionally not using LazyInit. The artifact can get very large and we don't want to
  // keep it around when compiling a large project containing many contracts.
  Contract const& currentContract = contract(_contractName);
  yulAssert(currentContract.contract);
  yulAssert(currentContract.yulIROptimized.has_value() == currentContract.contract->canBeDeployed());
  if (!currentContract.yulIROptimized)
    return std::nullopt;
  return loadGeneratedIR(*currentContract.yulIROptimized).astJson();
}

evmasm::LinkerObject const& CompilerStack::object(std::string const& _contractName) const
{
  solAssert(m_stackState == CompilationSuccessful, "Compilation was not successful.");
  return contract(_contractName).object;
}

evmasm::LinkerObject const& CompilerStack::runtimeObject(std::string const& _contractName) const
{
  solAssert(m_stackState == CompilationSuccessful, "Compilation was not successful.");
  return contract(_contractName).runtimeObject;
}

/// TODO: cache this string
std::string CompilerStack::assemblyString(std::string const& _contractName, StringMap const& _sourceCodes) const
{
  solAssert(m_stackState == CompilationSuccessful, "Compilation was not successful.");

  Contract const& currentContract = contract(_contractName);
  if (currentContract.evmAssembly)
    return currentContract.evmAssembly->assemblyString(m_debugInfoSelection, _sourceCodes);
  else
    return std::string();
}

/// TODO: cache the JSON
Json CompilerStack::assemblyJSON(std::string const& _contractName) const
{
  solAssert(m_stackState == CompilationSuccessful, "Compilation was not successful.");
  solUnimplementedAssert(!isExperimentalSolidity());

  Contract const& currentContract = contract(_contractName);
  if (currentContract.evmAssembly)
    return currentContract.evmAssembly->assemblyJSON(sourceIndices());
  else
    return Json();
}

std::vector<std::string> CompilerStack::sourceNames() const
{
  return ranges::to<std::vector>(m_sources | ranges::views::keys);
}

std::map<std::string, unsigned> CompilerStack::sourceIndices() const
{
  std::map<std::string, unsigned> indices;
  unsigned index = 0;
  for (auto const& s: m_sources)
    indices[s.first] = index++;
  solAssert(!indices.count(CompilerContext::yulUtilityFileName()), "");
  indices[CompilerContext::yulUtilityFileName()] = index++;
  return indices;
}

Json const& CompilerStack::contractABI(std::string const& _contractName) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
  return contractABI(contract(_contractName));
}

Json const& CompilerStack::contractABI(Contract const& _contract) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
  solAssert(_contract.contract);
  solUnimplementedAssert(!isExperimentalSolidity());
  return _contract.abi.init([&]{ return ABI::generate(*_contract.contract); });
}

Json const& CompilerStack::storageLayout(std::string const& _contractName) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
  return storageLayout(contract(_contractName));
}

Json const& CompilerStack::storageLayout(Contract const& _contract) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
  solAssert(_contract.contract);
  solUnimplementedAssert(!isExperimentalSolidity());

  return _contract.storageLayout.init([&]{ return StorageLayout().generate(*_contract.contract, DataLocation::Storage); });
}

Json const& CompilerStack::transientStorageLayout(std::string const& _contractName) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
  return transientStorageLayout(contract(_contractName));
}

Json const& CompilerStack::transientStorageLayout(Contract const& _contract) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
  solAssert(_contract.contract);
  solUnimplementedAssert(!isExperimentalSolidity());

  return _contract.transientStorageLayout.init([&]{ return StorageLayout().generate(*_contract.contract, DataLocation::Transient); });
}

Json const& CompilerStack::natspecUser(std::string const& _contractName) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
  return natspecUser(contract(_contractName));
}

Json const& CompilerStack::natspecUser(Contract const& _contract) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
  solAssert(_contract.contract);
  solUnimplementedAssert(!isExperimentalSolidity());
  return _contract.userDocumentation.init([&]{ return Natspec::userDocumentation(*_contract.contract); });
}

Json const& CompilerStack::natspecDev(std::string const& _contractName) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
  return natspecDev(contract(_contractName));
}

Json const& CompilerStack::natspecDev(Contract const& _contract) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
  solAssert(_contract.contract);
  solUnimplementedAssert(!isExperimentalSolidity());
  return _contract.devDocumentation.init([&]{ return Natspec::devDocumentation(*_contract.contract); });
}

Json CompilerStack::interfaceSymbols(std::string const& _contractName) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
  solUnimplementedAssert(!isExperimentalSolidity());

  Json interfaceSymbols;
  // Always have a methods object
  interfaceSymbols["methods"] = Json::object();

  for (auto const& it: contractDefinition(_contractName).interfaceFunctions())
    interfaceSymbols["methods"][it.second->externalSignature()] = it.first.hex();
  for (ErrorDefinition const* error: contractDefinition(_contractName).interfaceErrors())
  {
    std::string signature = error->functionType(true)->externalSignature();
    interfaceSymbols["errors"][signature] = util::toHex(toCompactBigEndian(util::selectorFromSignatureU32(signature), 4));
  }

  for (EventDefinition const* event: ranges::concat_view(
    contractDefinition(_contractName).definedInterfaceEvents(),
    contractDefinition(_contractName).usedInterfaceEvents()
  ))
    if (!event->isAnonymous())
    {
      std::string signature = event->functionType(true)->externalSignature();
      interfaceSymbols["events"][signature] = toHex(u256(h256::Arith(util::keccak256(signature))));
    }

  return interfaceSymbols;
}

Json CompilerStack::ethdebug() const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
  return evmasm::ethdebug::resources(ethdebugSources(), VersionString);
}

Json CompilerStack::ethdebugCompilation() const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
  return evmasm::ethdebug::compilation(ethdebugSources(), VersionString);
}

std::vector<evmasm::ethdebug::Source> CompilerStack::ethdebugSources() const
{
  auto const sourceIDs = sourceIndices();
  std::vector<evmasm::ethdebug::Source> sources;
  sources.reserve(m_sources.size());
  for (auto const& [sourceName, source]: m_sources)
    sources.push_back({
      .id = sourceIDs.at(sourceName),
      .path = sourceName,
      .contents = source.charStream->source(),
      .language = "Solidity"
    });
  return sources;
}

Json CompilerStack::ethdebug(std::string const& _contractName) const
{
  return ethdebug(contract(_contractName), /* runtime */ false);
}

Json CompilerStack::ethdebugRuntime(std::string const& _contractName) const
{
  return ethdebug(contract(_contractName), /* runtime */ true);
}

Json CompilerStack::ethdebug(Contract const& _contract, bool _runtime) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
  solAssert(_contract.contract);
  solUnimplementedAssert(!isExperimentalSolidity());
  evmasm::LinkerObject const& object = _runtime ? _contract.runtimeObject : _contract.object;
  std::shared_ptr<evmasm::Assembly> const& assembly = _runtime ? _contract.evmRuntimeAssembly : _contract.evmAssembly;
  if (!assembly)
    return {};

  solAssert(sourceIndices().contains(_contract.contract->sourceUnitName()));
  return evmasm::ethdebug::program(_contract.contract->name(), sourceIndices()[_contract.contract->sourceUnitName()], *assembly, object);
}

bytes CompilerStack::cborMetadata(std::string const& _contractName, bool _forIR) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
  return createCBORMetadata(contract(_contractName), _forIR);
}

std::string const& CompilerStack::metadata(Contract const& _contract) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");
  solAssert(_contract.contract);
  solUnimplementedAssert(!isExperimentalSolidity());
  return _contract.metadata.init([&]{ return createMetadata(_contract, m_viaIR); });
}

CharStream const& CompilerStack::charStream(std::string const& _sourceName) const
{
  solAssert(m_stackState >= SourcesSet, "No sources set.");
  solAssert(source(_sourceName).charStream);
  return *source(_sourceName).charStream;
}

SourceUnit const& CompilerStack::ast(std::string const& _sourceName) const
{
  solAssert(m_stackState >= Parsed, "Parsing not yet performed.");
  solAssert(source(_sourceName).ast, "Parsing was not successful.");
  solUnimplementedAssert(!isExperimentalSolidity());
  return *source(_sourceName).ast;
}

ContractDefinition const& CompilerStack::contractDefinition(std::string const& _contractName) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "Analysis was not successful.");

  return *contract(_contractName).contract;
}

size_t CompilerStack::functionEntryPoint(
  std::string const& _contractName,
  FunctionDefinition const& _function
) const
{
  solAssert(m_stackState == CompilationSuccessful, "Compilation was not successful.");

  for (auto&& [name, data]: contract(_contractName).runtimeObject.functionDebugData)
    if (data.sourceID == _function.id())
      if (data.instructionIndex)
        return *data.instructionIndex;
  return 0;
}

h256 const& CompilerStack::Source::keccak256() const
{
  if (keccak256HashCached == h256{})
    keccak256HashCached = util::keccak256(charStream->source());
  return keccak256HashCached;
}

h256 const& CompilerStack::Source::swarmHash() const
{
  if (swarmHashCached == h256{})
    swarmHashCached = util::bzzr1Hash(charStream->source());
  return swarmHashCached;
}

std::string const& CompilerStack::Source::ipfsUrl() const
{
  if (ipfsUrlCached.empty())
    ipfsUrlCached = "dweb:/ipfs/" + util::ipfsHashBase58(charStream->source());
  return ipfsUrlCached;
}

StringMap CompilerStack::loadMissingSources(SourceUnit const& _ast)
{
  solAssert(m_stackState < ParsedAndImported, "");
  StringMap newSources;
  try
  {
    for (auto const& node: _ast.nodes())
      if (ImportDirective const* import = dynamic_cast<ImportDirective*>(node.get()))
      {
        std::string const& importPath = *import->annotation().absolutePath;

        if (m_sources.count(importPath) || newSources.count(importPath))
          continue;

        ReadCallback::Result result{false, std::string("File not supplied initially.")};
        if (m_readFile)
          result = m_readFile(ReadCallback::kindString(ReadCallback::Kind::ReadFile), importPath);

        if (result.success)
          newSources[importPath] = result.responseOrErrorMessage;
        else
        {
          m_errorReporter.parserError(
            6275_error,
            import->location(),
            std::string("Source \"" + importPath + "\" not found: " + result.responseOrErrorMessage)
          );
          continue;
        }
      }
  }
  catch (FatalError const&)
  {
    if (!m_errorReporter.hasErrors())
    {
      std::cerr << "Unreported fatal error:" << std::endl;
      std::cerr << boost::current_exception_diagnostic_information() << std::endl;
      solAssert(false, "Unreported fatal error.");
    }
  }
  return newSources;
}

std::string CompilerStack::applyRemapping(std::string const& _path, std::string const& _context)
{
  solAssert(m_stackState < ParsedAndImported, "");
  return m_importRemapper.apply(_path, _context);
}

bool CompilerStack::resolveImports()
{
  solAssert(m_stackState == ParsedAndImported, "");

  // topological sorting (depth first search) of the import graph, cutting potential cycles
  std::vector<Source const*> sourceOrder;
  std::set<Source const*> sourcesSeen;

  std::function<void(Source const*)> toposort = [&](Source const* _source)
  {
    if (sourcesSeen.count(_source))
      return;
    sourcesSeen.insert(_source);
    solAssert(_source->ast);
    for (ASTPointer<ASTNode> const& node: _source->ast->nodes())
      if (ImportDirective const* import = dynamic_cast<ImportDirective*>(node.get()))
      {
        std::string const& path = *import->annotation().absolutePath;
        solAssert(m_sources.count(path), "");
        import->annotation().sourceUnit = m_sources[path].ast.get();
        toposort(&m_sources[path]);
      }
    sourceOrder.push_back(_source);
  };

  std::vector<PragmaDirective const*> experimentalPragmaDirectives;
  for (auto const& sourcePair: m_sources)
  {
    if (isRequestedSource(sourcePair.first))
      toposort(&sourcePair.second);
    if (sourcePair.second.ast && sourcePair.second.ast->experimentalSolidity())
      for (ASTPointer<ASTNode> const& node: sourcePair.second.ast->nodes())
        if (PragmaDirective const* pragma = dynamic_cast<PragmaDirective*>(node.get()))
          if (pragma->literals().size() >=2 && pragma->literals()[0] == "experimental" && pragma->literals()[1] == "solidity")
          {
            experimentalPragmaDirectives.push_back(pragma);
            break;
          }
  }

  if (!experimentalPragmaDirectives.empty() && experimentalPragmaDirectives.size() != m_sources.size())
  {
    for (auto &&pragma: experimentalPragmaDirectives)
      m_errorReporter.parserError(
          2141_error,
          pragma->location(),
          "File declares \"pragma experimental solidity\". If you want to enable the experimental mode, all source units must include the pragma."
      );
    return false;
  }

  swap(m_sourceOrder, sourceOrder);
  return true;
}

void CompilerStack::storeContractDefinitions()
{
  for (auto const& pair: m_sources)
    if (pair.second.ast)
      for (
        ContractDefinition const* contract:
        ASTNode::filteredNodes<ContractDefinition>(pair.second.ast->nodes())
      )
      {
        std::string fullyQualifiedName = *pair.second.ast->annotation().path + ":" + contract->name();
        // Note that we now reference contracts by their fully qualified names, and
        // thus contracts can only conflict if declared in the same source file. This
        // should already cause a double-declaration error elsewhere.
        if (!m_contracts.count(fullyQualifiedName))
          m_contracts[fullyQualifiedName].contract = contract;
      }
}

void CompilerStack::annotateInternalFunctionIDs()
{
  for (Source const* source: m_sourceOrder)
  {
    if (!source->ast)
      continue;

    for (ContractDefinition const* contract: ASTNode::filteredNodes<ContractDefinition>(source->ast->nodes()))
    {
      uint64_t internalFunctionID = 1;
      ContractDefinitionAnnotation& annotation = contract->annotation();

      if (auto const* deployTimeInternalDispatch = util::valueOrNullptr((*annotation.deployedCallGraph)->edges, CallGraph::SpecialNode::InternalDispatch))
        for (auto const& node: *deployTimeInternalDispatch)
          if (auto const* callable = std::get_if<CallableDeclaration const*>(&node))
            if (auto const* function = dynamic_cast<FunctionDefinition const*>(*callable))
            {
              solAssert(contract->annotation().internalFunctionIDs.count(function) == 0);
              contract->annotation().internalFunctionIDs[function] = internalFunctionID++;
            }
      if (auto const* creationTimeInternalDispatch = util::valueOrNullptr((*annotation.creationCallGraph)->edges, CallGraph::SpecialNode::InternalDispatch))
        for (auto const& node: *creationTimeInternalDispatch)
          if (auto const* callable = std::get_if<CallableDeclaration const*>(&node))
            if (auto const* function = dynamic_cast<FunctionDefinition const*>(*callable))
              // Make sure the function already got an ID since it also occurs in the deploy-time internal dispatch.
              solAssert(contract->annotation().internalFunctionIDs.count(function) != 0);
    }
  }
}

void CompilerStack::assembleYul(
  ContractDefinition const& _contract,
  std::shared_ptr<evmasm::Assembly> _assembly,
  std::shared_ptr<evmasm::Assembly> _runtimeAssembly
)
{
  solAssert(m_stackState >= AnalysisSuccessful, "");

  Contract& compiledContract = m_contracts.at(_contract.fullyQualifiedName());

  compiledContract.evmAssembly = _assembly;
  solAssert(compiledContract.evmAssembly, "");
  try
  {
    // Assemble deployment (incl. runtime)  object.
    compiledContract.object = compiledContract.evmAssembly->assemble();
  }
  catch (evmasm::AssemblyException const& error)
  {
    solAssert(false, "Assembly exception for bytecode: "s + error.what());
  }
  solAssert(compiledContract.object.immutableReferences.empty(), "Leftover immutables.");

  compiledContract.evmRuntimeAssembly = _runtimeAssembly;
  solAssert(compiledContract.evmRuntimeAssembly, "");
  try
  {
    // Assemble runtime object.
    compiledContract.runtimeObject = compiledContract.evmRuntimeAssembly->assemble();
  }
  catch (evmasm::AssemblyException const& error)
  {
    solAssert(false, "Assembly exception for deployed bytecode"s + error.what());
  }

  // Throw a warning if EIP-170 limits are exceeded:
  //   If contract creation returns data with length greater than 0x6000 (2^14 + 2^13) bytes,
  //   contract creation fails with an out of gas error.
  if (
    m_evmVersion >= langutil::EVMVersion::spuriousDragon() &&
    compiledContract.runtimeObject.bytecode.size() > 0x6000
  )
    m_errorReporter.warning(
      5574_error,
      _contract.location(),
      "Contract code size is "s +
      std::to_string(compiledContract.runtimeObject.bytecode.size()) +
      " bytes and exceeds 24576 bytes (a limit introduced in Spurious Dragon). "
      "This contract may not be deployable on Mainnet. "
      "Consider enabling the optimizer (with a low \"runs\" value!), "
      "turning off revert strings, or using libraries."
    );

  // Throw a warning if EIP-3860 limits are exceeded:
  //   If initcode is larger than 0xC000 bytes (twice the runtime code limit),
  //   then contract creation fails with an out of gas error.
  if (
    m_evmVersion >= langutil::EVMVersion::shanghai() &&
    compiledContract.object.bytecode.size() > 0xC000
  )
    m_errorReporter.warning(
      3860_error,
      _contract.location(),
      "Contract initcode size is "s +
      std::to_string(compiledContract.object.bytecode.size()) +
      " bytes and exceeds 49152 bytes (a limit introduced in Shanghai). "
      "This contract may not be deployable on Mainnet. "
      "Consider enabling the optimizer (with a low \"runs\" value!), "
      "turning off revert strings, or using libraries."
    );
}

void CompilerStack::compileContract(
  ContractDefinition const& _contract,
  std::map<ContractDefinition const*, std::shared_ptr<Compiler const>>& _otherCompilers
)
{
  solAssert(!m_viaIR, "");
  solAssert(m_stackState >= AnalysisSuccessful, "");

  if (_otherCompilers.count(&_contract))
    return;

  for (auto const& [dependency, referencee]: _contract.annotation().contractDependencies)
    compileContract(*dependency, _otherCompilers);

  if (!_contract.canBeDeployed())
    return;

  Contract& compiledContract = m_contracts.at(_contract.fullyQualifiedName());

  std::shared_ptr<Compiler> compiler = std::make_shared<Compiler>(
    m_evmVersion,
    m_revertStrings,
    m_optimiserSettings
  );

  solAssert(!m_viaIR, "");
  bytes cborEncodedMetadata = createCBORMetadata(compiledContract, /* _forIR */ false);

  // Run optimiser and compile the contract.
  compiler->compileContract(_contract, _otherCompilers, cborEncodedMetadata);
  compiledContract.generatedYulUtilityCode = compiler->generatedYulUtilityCode();
  compiledContract.runtimeGeneratedYulUtilityCode = compiler->runtimeGeneratedYulUtilityCode();

  _otherCompilers[compiledContract.contract] = compiler;

  assembleYul(_contract, compiler->assemblyPtr(), compiler->runtimeAssemblyPtr());
}

void CompilerStack::generateIR(ContractDefinition const& _contract, bool _unoptimizedOnly)
{
  solAssert(m_stackState >= AnalysisSuccessful, "");
  Contract& compiledContract = m_contracts.at(_contract.fullyQualifiedName());
  if (compiledContract.yulIR)
  {
    solAssert(!compiledContract.yulIR->empty());
    return;
  }

  if (!*_contract.sourceUnit().annotation().useABICoderV2)
    m_errorReporter.warning(
      2066_error,
      _contract.location(),
      "Contract requests the ABI coder v1, which is incompatible with the IR. "
      "Using ABI coder v2 instead."
    );

  std::string dependenciesSource;
  for (auto const& [dependency, referencee]: _contract.annotation().contractDependencies)
    generateIR(*dependency, _unoptimizedOnly);

  if (!_contract.canBeDeployed())
    return;

  std::map<ContractDefinition const*, std::string_view const> otherYulSources;
  for (auto const& pair: m_contracts)
    otherYulSources.emplace(pair.second.contract, pair.second.yulIR ? *pair.second.yulIR : std::string_view{});

  if (m_experimentalAnalysis)
  {
    experimental::IRGenerator generator(
      m_evmVersion,
      m_revertStrings,
      sourceIndices(),
      m_debugInfoSelection,
      this,
      *m_experimentalAnalysis
    );
    compiledContract.yulIR = generator.run(
      _contract,
      {}, // TODO: createCBORMetadata(compiledContract, /* _forIR */ true),
      otherYulSources
    );
  }
  else
  {
    IRGenerator generator(
      m_evmVersion,
      m_revertStrings,
      sourceIndices(),
      m_debugInfoSelection,
      this,
      m_optimiserSettings
    );
    compiledContract.yulIR = generator.run(
      _contract,
      createCBORMetadata(compiledContract, /* _forIR */ true),
      otherYulSources
    );
  }

  yulAssert(compiledContract.yulIR);
  YulStack stack = loadGeneratedIR(*compiledContract.yulIR);
  if (!_unoptimizedOnly)
  {
    stack.optimize();
    compiledContract.yulIROptimized = stack.print();
  }
}

void CompilerStack::generateEVMFromIR(ContractDefinition const& _contract)
{
  solAssert(m_stackState >= AnalysisSuccessful, "");

  if (!_contract.canBeDeployed())
    return;

  Contract& compiledContract = m_contracts.at(_contract.fullyQualifiedName());
  solAssert(compiledContract.yulIROptimized);
  solAssert(!compiledContract.yulIROptimized->empty());
  if (!compiledContract.object.bytecode.empty())
    return;

  // Re-parse the Yul IR in EVM dialect
  YulStack stack = loadGeneratedIR(*compiledContract.yulIROptimized);

  std::string deployedName = IRNames::deployedObject(_contract);
  solAssert(!deployedName.empty(), "");
  tie(compiledContract.evmAssembly, compiledContract.evmRuntimeAssembly) = stack.assembleEVMWithDeployed(deployedName, m_viaSSACFG);

  if (stack.hasErrors())
  {
    for (std::shared_ptr<Error const> const& error: stack.errors())
      reportIRPostAnalysisError(error.get(), compiledContract.contract);
    return;
  }

  assembleYul(_contract, compiledContract.evmAssembly, compiledContract.evmRuntimeAssembly);
}

CompilerStack::Contract const& CompilerStack::contract(std::string const& _contractName) const
{
  solAssert(m_stackState >= AnalysisSuccessful, "");

  auto it = m_contracts.find(_contractName);
  if (it != m_contracts.end())
    return it->second;

  // To provide a measure of backward-compatibility, if a contract is not located by its
  // fully-qualified name, a lookup will be attempted purely on the contract's name to see
  // if anything will satisfy.
  if (_contractName.find(':') == std::string::npos)
  {
    for (auto const& contractEntry: m_contracts)
    {
      std::stringstream ss;
      ss.str(contractEntry.first);
      // All entries are <source>:<contract>
      std::string source;
      std::string foundName;
      getline(ss, source, ':');
      getline(ss, foundName, ':');
      if (foundName == _contractName)
        return contractEntry.second;
    }
  }

  // If we get here, both lookup methods failed.
  solAssert(false, "Contract \"" + _contractName + "\" not found.");
}

CompilerStack::Source const& CompilerStack::source(std::string const& _sourceName) const
{
  auto it = m_sources.find(_sourceName);
  solAssert(it != m_sources.end(), "Given source file not found: " + _sourceName);

  return it->second;
}

std::string CompilerStack::createMetadata(Contract const& _contract, bool _forIR) const
{
  Json meta;
  meta["version"] = 1;
  std::string sourceType;
  switch (m_compilationSourceType)
  {
  case CompilationSourceType::Solidity:
    sourceType = "Solidity";
    break;
  case CompilationSourceType::SolidityAST:
    sourceType = "SolidityAST";
    break;
  }
  meta["language"] = sourceType;
  meta["compiler"]["version"] = VersionStringStrict;

  /// All the source files (including self), which should be included in the metadata.
  std::set<std::string> referencedSources;
  referencedSources.insert(*_contract.contract->sourceUnit().annotation().path);
  for (auto const sourceUnit: _contract.contract->sourceUnit().referencedSourceUnits(true))
    referencedSources.insert(*sourceUnit->annotation().path);

  meta["sources"] = Json::object();
  for (auto const& s: m_sources)
  {
    if (!referencedSources.count(s.first))
      continue;

    solAssert(s.second.charStream, "Character stream not available");
    meta["sources"][s.first]["keccak256"] = "0x" + util::toHex(s.second.keccak256().asBytes());
    if (std::optional<std::string> licenseString = s.second.ast->licenseString())
      meta["sources"][s.first]["license"] = *licenseString;
    if (m_metadataLiteralSources)
      meta["sources"][s.first]["content"] = s.second.charStream->source();
    else
    {
      meta["sources"][s.first]["urls"] = Json::array();
      meta["sources"][s.first]["urls"].emplace_back("bzz-raw://" + util::toHex(s.second.swarmHash().asBytes()));
      meta["sources"][s.first]["urls"].emplace_back(s.second.ipfsUrl());
    }
  }

  static_assert(std::is_same_v<decltype(m_optimiserSettings.expectedExecutionsPerDeployment), Json::number_unsigned_t>);
  meta["settings"]["optimizer"]["runs"] = m_optimiserSettings.expectedExecutionsPerDeployment;

  /// Backwards compatibility: If set to one of the default settings, do not provide details.
  OptimiserSettings settingsWithoutRuns = m_optimiserSettings;
  // reset to default
  settingsWithoutRuns.expectedExecutionsPerDeployment = OptimiserSettings::minimal().expectedExecutionsPerDeployment;
  if (settingsWithoutRuns == OptimiserSettings::minimal())
    meta["settings"]["optimizer"]["enabled"] = false;
  else if (settingsWithoutRuns == OptimiserSettings::standard())
    meta["settings"]["optimizer"]["enabled"] = true;
  else
  {
    Json details = Json::object();

    details["orderLiterals"] = m_optimiserSettings.runOrderLiterals;
    details["inliner"] = m_optimiserSettings.runInliner;
    details["jumpdestRemover"] = m_optimiserSettings.runJumpdestRemover;
    details["peephole"] = m_optimiserSettings.runPeephole;
    details["deduplicate"] = m_optimiserSettings.runDeduplicate;
    details["cse"] = m_optimiserSettings.runCSE;
    details["constantOptimizer"] = m_optimiserSettings.runConstantOptimiser;
    details["simpleCounterForLoopUncheckedIncrement"] = m_optimiserSettings.simpleCounterForLoopUncheckedIncrement;
    details["yul"] = m_optimiserSettings.runYulOptimiser;
    if (m_optimiserSettings.runYulOptimiser)
    {
      details["yulDetails"] = Json::object();
      details["yulDetails"]["stackAllocation"] = m_optimiserSettings.optimizeStackAllocation;
      details["yulDetails"]["optimizerSteps"] = m_optimiserSettings.yulOptimiserSteps + ":" + m_optimiserSettings.yulOptimiserCleanupSteps;
    }
    else if (OptimiserSuite::isEmptyOptimizerSequence(m_optimiserSettings.yulOptimiserSteps + ":" + m_optimiserSettings.yulOptimiserCleanupSteps))
    {
      solAssert(m_optimiserSettings.optimizeStackAllocation == false);
      details["yulDetails"] = Json::object();
      details["yulDetails"]["optimizerSteps"] = ":";
    }
    else
    {
      solAssert(m_optimiserSettings.optimizeStackAllocation == false);
      solAssert(m_optimiserSettings.yulOptimiserSteps == OptimiserSettings::DefaultYulOptimiserSteps);
      solAssert(m_optimiserSettings.yulOptimiserCleanupSteps == OptimiserSettings::DefaultYulOptimiserCleanupSteps);
    }

    meta["settings"]["optimizer"]["details"] = std::move(details);
  }

  if (m_revertStrings != RevertStrings::Default)
    meta["settings"]["debug"]["revertStrings"] = revertStringsToString(m_revertStrings);

  if (m_metadataFormat == MetadataFormat::NoMetadata)
    meta["settings"]["metadata"]["appendCBOR"] = false;

  if (m_metadataLiteralSources)
    meta["settings"]["metadata"]["useLiteralContent"] = true;

  static std::vector<std::string> hashes{"ipfs", "bzzr1", "none"};
  meta["settings"]["metadata"]["bytecodeHash"] = hashes.at(unsigned(m_metadataHash));

  if (_forIR)
    meta["settings"]["viaIR"] = _forIR;
  meta["settings"]["evmVersion"] = m_evmVersion.name();
  if (m_experimental)
    meta["settings"]["experimental"] = m_experimental;
  if (m_viaSSACFG)
    meta["settings"]["viaSSACFG"] = m_viaSSACFG;
  meta["settings"]["compilationTarget"][_contract.contract->sourceUnitName()] =
    *_contract.contract->annotation().canonicalName;

  meta["settings"]["remappings"] = Json::array();
  std::set<std::string> remappings;
  for (auto const& r: m_importRemapper.remappings())
    remappings.insert(r.context + ":" + r.prefix + "=" + r.target);
  for (auto const& r: remappings)
    meta["settings"]["remappings"].emplace_back(r);

  meta["settings"]["libraries"] = Json::object();
  for (auto const& library: m_libraries)
    meta["settings"]["libraries"][library.first] = "0x" + util::toHex(library.second.asBytes());

  meta["output"]["abi"] = contractABI(_contract);
  meta["output"]["userdoc"] = natspecUser(_contract);
  meta["output"]["devdoc"] = natspecDev(_contract);

  return util::jsonCompactPrint(meta);
}

class MetadataCBOREncoder
{
public:
  void pushBytes(std::string const& key, bytes const& value)
  {
    m_entryCount++;
    pushTextString(key);
    pushByteString(value);
  }

  void pushString(std::string const& key, std::string const& value)
  {
    m_entryCount++;
    pushTextString(key);
    pushTextString(value);
  }

  void pushBool(std::string const& key, bool value)
  {
    m_entryCount++;
    pushTextString(key);
    pushBool(value);
  }

  bytes serialise() const
  {
    size_t size = m_data.size() + 1;
    solAssert(size <= 0xffff, "Metadata too large.");
    solAssert(m_entryCount <= 0x1f, "Too many map entries.");

    // CBOR fixed-length map
    bytes ret{static_cast<unsigned char>(0xa0 + m_entryCount)};
    // The already encoded key-value pairs
    ret += m_data;
    // 16-bit big endian length
    ret += toCompactBigEndian(size, 2);
    return ret;
  }

private:
  void pushTextString(std::string const& key)
  {
    size_t length = key.size();
    if (length < 24)
    {
      m_data += bytes{static_cast<unsigned char>(0x60 + length)};
      m_data += key;
    }
    else if (length <= 256)
    {
      m_data += bytes{0x78, static_cast<unsigned char>(length)};
      m_data += key;
    }
    else
      solAssert(false, "Text std::string too large.");
  }
  void pushByteString(bytes const& key)
  {
    size_t length = key.size();
    if (length < 24)
    {
      m_data += bytes{static_cast<unsigned char>(0x40 + length)};
      m_data += key;
    }
    else if (length <= 256)
    {
      m_data += bytes{0x58, static_cast<unsigned char>(length)};
      m_data += key;
    }
    else
      solAssert(false, "Byte std::string too large.");
  }
  void pushBool(bool value)
  {
    if (value)
      m_data += bytes{0xf5};
    else
      m_data += bytes{0xf4};
  }
  unsigned m_entryCount = 0;
  bytes m_data;
};

bytes CompilerStack::createCBORMetadata(Contract const& _contract, bool _forIR) const
{
  if (m_metadataFormat == MetadataFormat::NoMetadata)
    return bytes{};

  bool const usesExperimentalSyntax = !_contract.contract->sourceUnit().annotation().experimentalFeatures.empty();
  bool const onlySafeExperimentalFeatures = onlySafeExperimentalFeaturesActivated(
    _contract.contract->sourceUnit().annotation().experimentalFeatures
  );

  if (usesExperimentalSyntax && !onlySafeExperimentalFeatures)
    solAssert(m_experimental, "Experimental mode not enabled");

  std::string meta = (_forIR == m_viaIR ? metadata(_contract) : createMetadata(_contract, _forIR));

  MetadataCBOREncoder encoder;

  if (m_metadataHash == MetadataHash::IPFS)
    encoder.pushBytes("ipfs", util::ipfsHash(meta));
  else if (m_metadataHash == MetadataHash::Bzzr1)
    encoder.pushBytes("bzzr1", util::bzzr1Hash(meta).asBytes());
  else
    solAssert(m_metadataHash == MetadataHash::None, "Invalid metadata hash");

  if (m_experimental)
    encoder.pushBool("experimental", true);
  if (m_metadataFormat == MetadataFormat::WithReleaseVersionTag)
    encoder.pushBytes("solc", VersionCompactBytes);
  else
  {
    solAssert(
      m_metadataFormat == MetadataFormat::WithPrereleaseVersionTag,
      "Invalid metadata format."
    );
    encoder.pushString("solc", VersionStringStrict);
  }
  return encoder.serialise();
}

namespace
{

Json gasToJson(GasEstimator::GasConsumption const& _gas)
{
  if (_gas.isInfinite)
    return Json("infinite");
  else
    return Json(util::toString(_gas.value));
}

}

Json CompilerStack::gasEstimates(std::string const& _contractName) const
{
  solAssert(m_stackState == CompilationSuccessful, "Compilation was not successful.");
  solUnimplementedAssert(!isExperimentalSolidity());

  if (!assemblyItems(_contractName) && !runtimeAssemblyItems(_contractName))
    return Json();

  using Gas = GasEstimator::GasConsumption;
  GasEstimator gasEstimator(m_evmVersion);
  Json output = Json::object();

  if (evmasm::AssemblyItems const* items = assemblyItems(_contractName))
  {
    Gas executionGas = gasEstimator.functionalEstimation(*items);
    Gas codeDepositGas{evmasm::GasMeter::dataGas(runtimeObject(_contractName).bytecode, false, m_evmVersion)};

    Json creation = Json::object();
    creation["codeDepositCost"] = gasToJson(codeDepositGas);
    creation["executionCost"] = gasToJson(executionGas);
    /// TODO: implement + overload to avoid the need of +=
    executionGas += codeDepositGas;
    creation["totalCost"] = gasToJson(executionGas);
    output["creation"] = creation;
  }

  if (evmasm::AssemblyItems const* items = runtimeAssemblyItems(_contractName))
  {
    /// External functions
    ContractDefinition const& contract = contractDefinition(_contractName);
    Json externalFunctions = Json::object();
    for (auto it: contract.interfaceFunctions())
    {
      std::string sig = it.second->externalSignature();
      externalFunctions[sig] = gasToJson(gasEstimator.functionalEstimation(*items, sig));
    }

    if (contract.fallbackFunction())
      /// This needs to be set to an invalid signature in order to trigger the fallback,
      /// without the shortcut (of CALLDATSIZE == 0), and therefore to receive the upper bound.
      /// An empty string ("") would work to trigger the shortcut only.
      externalFunctions[""] = gasToJson(gasEstimator.functionalEstimation(*items, "INVALID"));

    if (!externalFunctions.empty())
      output["external"] = externalFunctions;

    /// Internal functions
    Json internalFunctions = Json::object();
    for (auto const& it: contract.definedFunctions())
    {
      /// Exclude externally visible functions, constructor, fallback and receive ether function
      if (it->isPartOfExternalInterface() || !it->isOrdinary())
        continue;

      size_t entry = functionEntryPoint(_contractName, *it);
      GasEstimator::GasConsumption gas = GasEstimator::GasConsumption::infinite();
      if (entry > 0)
        gas = gasEstimator.functionalEstimation(*items, entry, *it);

      /// TODO: This could move into a method shared with externalSignature()
      FunctionType type(*it);
      std::string sig = it->name() + "(";
      auto paramTypes = type.parameterTypes();
      for (auto it = paramTypes.begin(); it != paramTypes.end(); ++it)
        sig += (*it)->toString() + (it + 1 == paramTypes.end() ? "" : ",");
      sig += ")";

      internalFunctions[sig] = gasToJson(gas);
    }

    if (!internalFunctions.empty())
      output["internal"] = internalFunctions;
  }

  return output;
}

bool CompilerStack::isExperimentalSolidity() const
{
  return
    !m_sourceOrder.empty() &&
    ranges::all_of(m_sourceOrder, [](auto const* _source) { return _source->ast->experimentalSolidity(); } )
  ;
}

experimental::Analysis const& CompilerStack::experimentalAnalysis() const
{
  solAssert(!!m_experimentalAnalysis);
  return *m_experimentalAnalysis;
}

void CompilerStack::reportUnimplementedFeatureError(
  UnimplementedFeatureError const& _error,
  ContractDefinition const* _contractDefinition
)
{
  solAssert(_error.comment(), "Errors must include a message for the user.");
  if (_error.sourceLocation().sourceName)
    solAssert(m_sources.count(*_error.sourceLocation().sourceName) != 0);

  m_errorReporter.unimplementedFeatureError(
    1834_error,
    (_error.sourceLocation().sourceName || !_contractDefinition) ?
      _error.sourceLocation() :
      _contractDefinition->location(),
    *_error.comment()
  );
}

void CompilerStack::reportCodeGenerationError(Error const& _error, ContractDefinition const* _contractDefinition)
{
  solAssert(_error.type() == Error::Type::CodeGenerationError);
  solAssert(_error.comment(), "Errors must include a message for the user.");
  if (_error.sourceLocation() && _error.sourceLocation()->sourceName)
    solAssert(m_sources.count(*_error.sourceLocation()->sourceName) != 0);
  solAssert(_contractDefinition);

  m_errorReporter.codeGenerationError(
    _error.errorId(),
    (_error.sourceLocation() && _error.sourceLocation()->sourceName) ?
      *_error.sourceLocation() :
      _contractDefinition->location(),
    *_error.comment()
  );
}

void CompilerStack::reportIRPostAnalysisError(Error const* _error, ContractDefinition const* _contractDefinition)
{
  solAssert(_error);
  solAssert(_error->comment(), "Errors must include a message for the user.");
  solAssert(!_error->secondarySourceLocation());
  solAssert(_contractDefinition);

  // Do not report Yul warnings and infos. These are only reported in pure Yul compilation.
  if (!Error::isError(_error->severity()))
    return;

  m_errorReporter.error(
    _error->errorId(),
    _error->type(),
    // Ignore the original location. It's likely missing, but even if not, it points at Yul source.
    // CompilerStack can only point at locations in Solidity sources.
    _contractDefinition->location(),
    *_error->comment()
  );
}

Coverage Report

Created: 2026-06-30 07:08