Struct ModuleInliner 

pub struct ModuleInliner {
    path: PathBuf,
    io_errs: IoErrs,
    parse_errs: ParseErrs,
}

Fields

path: PathBuf

io_errs: IoErrs

parse_errs: ParseErrs

Implementations

impl ModuleInliner

pub fn new(root: impl AsRef<Path>) -> Self

Creates a new ModuleInliner

pub fn fork(&self, path: impl AsRef<Path>) -> Self

pub fn join(&mut self, other: ModuleInliner) -> &mut Self

pub fn main_path(&self) -> PathBuf

pub fn fallback_path(&self) -> Option<PathBuf>

pub fn has_errors(&self) -> bool

Returns true when the ModuleInliner has errors to report

pub fn into_errs(self) -> Option<(IoErrs, ParseErrs)>

Returns the IO Errors and parse Errors

pub fn inline(self, expr: Expr) -> Result<Expr, (Expr, IoErrs, ParseErrs)>

Traverses an Expr, attempting to inline all submodules.

This is a simple wrapper around ModuleInliner::fold_expr() and ModuleInliner::into_errs()

fn handle_io_error<T>(&mut self, path: PathBuf, error: Error) -> Option<T>

Records an I/O error for later

fn handle_parse_error<T>( &mut self, path: PathBuf, error: ParseError, ) -> Option<T>

Records a ParseError for later

impl ModuleInliner

fn inline_file(&mut self) -> Option<Result<At<Expr>, Infallible>>

fn inline_file_at(&mut self, path: &str) -> Option<Result<At<Expr>, Infallible>>

Inlines a file at the given path,

Trait Implementations

impl Fold<DefaultTypes> for ModuleInliner

fn fold_bind( &mut self, bind: Bind<DefaultTypes>, ) -> Result<Bind<DefaultTypes>, Self::Error>

Traverses down the module tree, entering ever nested directories

type Error = Infallible

fn fold_annotation(&mut self, span: Span) -> Result<Span, Self::Error>

Consumes an Annotation in A, possibly transforms it, and produces a replacement Annotation in B

fn fold_macro_id(&mut self, name: Symbol) -> Result<Symbol, Self::Error>

Consumes a MacroId in A, possibly transforms it, and produces a replacement MacroId in B

fn fold_symbol(&mut self, name: Symbol) -> Result<Symbol, Self::Error>

Consumes a Symbol in A, possibly transforms it, and produces a replacement Symbol in B

fn fold_path(&mut self, path: AstPath) -> Result<AstPath, Self::Error>

Consumes a Path in A, possibly transforms it, and produces a replacement Path in B

fn fold_literal(&mut self, lit: Literal) -> Result<Literal, Self::Error>

Consumes a Literal in A, possibly transforms it, and produces a replacement Literal in B

fn fold_at_expr( &mut self, expr: At<Expr<From>, From>, ) -> Result<At<Expr<To>, To>, Self::Error>

Folds an annotated expression, so the expression and annotation can be seen at once.

fn fold_expr(&mut self, expr: Expr<From>) -> Result<Expr<To>, Self::Error>

Consumes an Expr, possibly transforms it, and produces a replacement Expr

fn fold_use(&mut self, item: Use<From>) -> Result<Use<To>, Self::Error>

Consumes a Use, possibly transforms it, and produces a replacement Use

fn fold_pat(&mut self, pat: Pat<From>) -> Result<Pat<To>, Self::Error>

Consumes a Pat, possibly transforms it, and produces a replacement Pat

fn fold_make(&mut self, make: Make<From>) -> Result<Make<To>, Self::Error>

Consumes a Make, possibly transforms it, and produces a replacement Make

fn fold_makearm( &mut self, arm: MakeArm<From>, ) -> Result<MakeArm<To>, Self::Error>

Consumes a MakeArm, possibly transforms it, and produces a replacement MakeArm

fn fold_match(&mut self, mtch: Match<From>) -> Result<Match<To>, Self::Error>

Consumes a Make, possibly transforms it, and produces a replacement Make

fn fold_matcharm( &mut self, arm: MatchArm<From>, ) -> Result<MatchArm<To>, Self::Error>

Consumes a MakeArm, possibly transforms it, and produces a replacement MakeArm