Struct foundry_compilers::resolver::Graph

pub struct Graph<D = SolData> { /* private fields */ }

Represents a fully-resolved solidity dependency graph. Each node in the graph is a file and edges represent dependencies between them. See also https://docs.soliditylang.org/en/latest/layout-of-source-files.html?highlight=import#importing-other-source-files

Implementations

impl<D: ParsedSource> Graph<D>

pub fn print(&self)

Print the graph to StdOut

pub fn print_with_options(&self, opts: TreeOptions)

Print the graph to StdOut using the provided TreeOptions

pub fn imported_nodes(&self, from: usize) -> &[usize]

Returns a list of nodes the given node index points to for the given kind.

pub fn all_imported_nodes( &self, from: usize, ) -> impl Iterator<Item = usize> + '_

Returns an iterator that yields all imports of a node and all their imports

pub fn files(&self) -> &HashMap<PathBuf, usize>

Returns all the resolved files and their index in the graph

pub fn node(&self, index: usize) -> &Node<D>

Gets a node by index.

Panics

if the index node id is not included in the graph

pub fn node_ids(&self, start: usize) -> impl Iterator<Item = usize> + '_

Returns an iterator that yields all nodes of the dependency tree that the given node id spans, starting with the node itself.

Panics

if the start node id is not included in the graph

pub fn nodes(&self, start: usize) -> impl Iterator<Item = &Node<D>> + '_

Same as Self::node_ids but returns the actual Node

pub fn into_sources(self) -> (Sources, GraphEdges<D>)

Consumes the Graph, effectively splitting the nodes and the GraphEdges off and returning the nodes converted to Sources

pub fn input_nodes(&self) -> impl Iterator<Item = &Node<D>>

Returns an iterator that yields only those nodes that represent input files. See Self::resolve_sources This won’t yield any resolved library nodes

pub fn imports(&self, path: &Path) -> HashSet<&PathBuf>

Returns all files imported by the given file

pub fn resolve_sources( paths: &ProjectPathsConfig<D::Language>, sources: Sources, ) -> Result<Self>

Resolves a number of sources within the given config

pub fn resolve(paths: &ProjectPathsConfig<D::Language>) -> Result<Self>

Resolves the dependencies of a project’s source contracts

impl<L: Language, D: ParsedSource<Language = L>> Graph<D>

pub fn into_sources_by_version<C: Compiler<ParsedSource = D, Language = L>>( self, offline: bool, locked_versions: &HashMap<L, Version>, compiler: &C, ) -> Result<(HashMap<C::Language, HashMap<Version, Sources>>, GraphEdges<D>)>

Consumes the nodes of the graph and returns all input files together with their appropriate version and the edges of the graph

First we determine the compatible version for each input file (from sources and test folder, see Self::resolve) and then we add all resolved library imports.

Trait Implementations

impl<D: Debug> Debug for Graph<D>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.