Method compileContract

libsolidity/interface/CompilerStack.cpp:1564–1602

}

void CompilerStack::compileContract(
	ContractDefinition const& _contract,
	std::map<ContractDefinition const*, std::shared_ptr<Compiler const>>& _otherCompilers
)
{
	solAssert(!m_viaIR, "");
	solUnimplementedAssert(!m_eofVersion.has_value(), "Experimental EOF support is only available for via-IR compilation.");
	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_eofVersion,
		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)
{