103 lines
3.0 KiB
Rust
103 lines
3.0 KiB
Rust
|
//! The [ModuleInliner] reads files described in the module structure of the
|
||
|
|
|
||
|
|
use crate::Parser;
|
||
|
|
use cl_ast::{ast_visitor::Fold, *};
|
||
|
|
use cl_lexer::Lexer;
|
||
|
|
use std::{
|
||
|
|
ops::{Deref, DerefMut},
|
||
|
|
path::{Path, PathBuf},
|
||
|
|
};
|
||
|
|
|
||
|
|
type IoErrs = Vec<(PathBuf, std::io::Error)>;
|
||
|
|
type ParseErrs = Vec<(PathBuf, crate::error::Error)>;
|
||
|
|
|
||
|
|
pub struct ModuleInliner {
|
||
|
|
path: PathBuf,
|
||
|
|
io_errs: IoErrs,
|
||
|
|
parse_errs: ParseErrs,
|
||
|
|
}
|
||
|
|
|
||
|
|
impl ModuleInliner {
|
||
|
|
/// Creates a new [ModuleInliner]
|
||
|
|
pub fn new(root: impl AsRef<Path>) -> Self {
|
||
|
|
Self {
|
||
|
|
path: root.as_ref().to_path_buf(),
|
||
|
|
io_errs: Default::default(),
|
||
|
|
parse_errs: Default::default(),
|
||
|
|
}
|
||
|
|
}
|
||
|
|
pub fn inline(mut self, file: File) -> Result<File, (File, IoErrs, ParseErrs)> {
|
||
|
|
let file = self.fold_file(file);
|
||
|
|
|
||
|
|
if self.io_errs.is_empty() && self.parse_errs.is_empty() {
|
||
|
|
Ok(file)
|
||
|
|
} else {
|
||
|
|
Err((file, self.io_errs, self.parse_errs))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/// Records an [I/O error](std::io::Error), and rebuilds the outline [Module]
|
||
|
|
fn io_oops(&mut self, name: Identifier, error: std::io::Error) -> Module {
|
||
|
|
self.io_errs.push((self.path.clone(), error));
|
||
|
|
Module { name, kind: ModuleKind::Outline }
|
||
|
|
}
|
||
|
|
/// Records a [parse error](crate::error::Error), and rebuilds the outline [Module]
|
||
|
|
fn parse_oops(&mut self, name: Identifier, error: crate::error::Error) -> Module {
|
||
|
|
self.parse_errs.push((self.path.clone(), error));
|
||
|
|
Module { name, kind: ModuleKind::Outline }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
impl Fold for ModuleInliner {
|
||
|
|
fn fold_module(&mut self, m: Module) -> cl_ast::Module {
|
||
|
|
let Module { name, kind } = m;
|
||
|
|
let mut inliner = PathMiser::new(self, &name.0);
|
||
|
|
|
||
|
|
let kind = inliner.fold_module_kind(kind);
|
||
|
|
|
||
|
|
let ModuleKind::Outline = kind else {
|
||
|
|
return Module { name, kind };
|
||
|
|
};
|
||
|
|
|
||
|
|
inliner.path.set_extension("cl");
|
||
|
|
let file = match std::fs::read_to_string(&inliner.path) {
|
||
|
|
Err(e) => return inliner.io_oops(name, e),
|
||
|
|
Ok(s) => s,
|
||
|
|
};
|
||
|
|
|
||
|
|
let kind = match Parser::new(Lexer::new(&file)).file() {
|
||
|
|
Err(e) => return inliner.parse_oops(name, e),
|
||
|
|
Ok(file) => ModuleKind::Inline(file),
|
||
|
|
};
|
||
|
|
|
||
|
|
inliner.path.set_extension("");
|
||
|
|
Module { name, kind: inliner.fold_module_kind(kind) }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/// I am the [Path] miser. Whatever I touch turns to [Path] in my clutch.
|
||
|
|
pub struct PathMiser<'mi> {
|
||
|
|
mi: &'mi mut ModuleInliner,
|
||
|
|
}
|
||
|
|
impl<'mi> PathMiser<'mi> {
|
||
|
|
pub fn new(mi: &'mi mut ModuleInliner, name: &str) -> Self {
|
||
|
|
mi.path.push(name);
|
||
|
|
Self { mi }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<'mi> Deref for PathMiser<'mi> {
|
||
|
|
type Target = ModuleInliner;
|
||
|
|
fn deref(&self) -> &Self::Target {
|
||
|
|
self.mi
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<'mi> DerefMut for PathMiser<'mi> {
|
||
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
||
|
|
self.mi
|
||
|
|
}
|
||
|
|
}
|
||
|
|
impl<'mi> Drop for PathMiser<'mi> {
|
||
|
|
fn drop(&mut self) {
|
||
|
|
self.mi.path.pop();
|
||
|
|
}
|
||
|
|
}
|