81 lines
2.2 KiB
Rust
81 lines
2.2 KiB
Rust
use crate::schemas::dataspace_patterns::*;
|
|
|
|
use preserves::value::NestedValue;
|
|
|
|
use std::convert::TryFrom;
|
|
|
|
#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq)]
|
|
pub enum PathStep {
|
|
Index(usize),
|
|
Key(_Any),
|
|
}
|
|
|
|
pub type Path = Vec<PathStep>;
|
|
pub type Paths = Vec<Path>;
|
|
|
|
struct Analyzer {
|
|
pub const_paths: Paths,
|
|
pub const_values: Vec<_Any>,
|
|
pub capture_paths: Paths,
|
|
}
|
|
|
|
pub struct PatternAnalysis {
|
|
pub const_paths: Paths,
|
|
pub const_values: _Any,
|
|
pub capture_paths: Paths,
|
|
}
|
|
|
|
impl PatternAnalysis {
|
|
pub fn new(p: &Pattern) -> Self {
|
|
let mut analyzer = Analyzer {
|
|
const_paths: Vec::new(),
|
|
const_values: Vec::new(),
|
|
capture_paths: Vec::new(),
|
|
};
|
|
analyzer.walk(&mut Vec::new(), p);
|
|
PatternAnalysis {
|
|
const_paths: analyzer.const_paths,
|
|
const_values: _Any::new(analyzer.const_values),
|
|
capture_paths: analyzer.capture_paths,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Analyzer {
|
|
fn walk_step(&mut self, path: &mut Path, s: PathStep, p: &Pattern) {
|
|
path.push(s);
|
|
self.walk(path, p);
|
|
path.pop();
|
|
}
|
|
|
|
fn walk(&mut self, path: &mut Path, p: &Pattern) {
|
|
match p {
|
|
Pattern::DCompound(b) => match &**b {
|
|
DCompound::Rec { members, .. } |
|
|
DCompound::Arr { members, .. } => {
|
|
for (i, p) in members {
|
|
self.walk_step(path, PathStep::Index(usize::try_from(i).unwrap_or(0)), p);
|
|
}
|
|
}
|
|
DCompound::Dict { members, .. } => {
|
|
for (k, p) in members {
|
|
self.walk_step(path, PathStep::Key(k.clone()), p);
|
|
}
|
|
}
|
|
}
|
|
Pattern::DBind(b) => {
|
|
let DBind { pattern, .. } = &**b;
|
|
self.capture_paths.push(path.clone());
|
|
self.walk(path, pattern)
|
|
}
|
|
Pattern::DDiscard(_) =>
|
|
(),
|
|
Pattern::DLit(b) => {
|
|
let DLit { value } = &**b;
|
|
self.const_paths.push(path.clone());
|
|
self.const_values.push(value.clone());
|
|
}
|
|
}
|
|
}
|
|
}
|