just/src/assignment_resolver.rs

137 lines
3.4 KiB
Rust
Raw Normal View History

use crate::common::*;
2017-11-16 23:30:08 -08:00
2017-11-17 17:28:06 -08:00
use CompilationErrorKind::*;
pub(crate) struct AssignmentResolver<'a: 'b, 'b> {
assignments: &'b BTreeMap<&'a str, Expression<'a>>,
assignment_tokens: &'b BTreeMap<&'a str, Token<'a>>,
stack: Vec<&'a str>,
seen: BTreeSet<&'a str>,
evaluated: BTreeSet<&'a str>,
2017-11-16 23:30:08 -08:00
}
impl<'a: 'b, 'b> AssignmentResolver<'a, 'b> {
pub(crate) fn resolve_assignments(
assignments: &BTreeMap<&'a str, Expression<'a>>,
assignment_tokens: &BTreeMap<&'a str, Token<'a>>,
) -> CompilationResult<'a, ()> {
let mut resolver = AssignmentResolver {
stack: empty(),
seen: empty(),
2018-03-05 13:21:35 -08:00
evaluated: empty(),
assignments,
assignment_tokens,
};
for name in assignments.keys() {
resolver.resolve_assignment(name)?;
}
Ok(())
}
2017-11-17 17:28:06 -08:00
fn resolve_assignment(&mut self, name: &'a str) -> CompilationResult<'a, ()> {
2017-11-16 23:30:08 -08:00
if self.evaluated.contains(name) {
return Ok(());
}
self.seen.insert(name);
self.stack.push(name);
if let Some(expression) = self.assignments.get(name) {
self.resolve_expression(expression)?;
self.evaluated.insert(name);
} else {
let message = format!("attempted to resolve unknown assignment `{}`", name);
return Err(CompilationError {
text: "",
offset: 0,
line: 0,
2017-11-16 23:30:08 -08:00
column: 0,
width: 0,
kind: Internal { message },
2017-11-16 23:30:08 -08:00
});
}
Ok(())
}
fn resolve_expression(&mut self, expression: &Expression<'a>) -> CompilationResult<'a, ()> {
match expression {
Expression::Variable { name, ref token } => {
2017-11-16 23:30:08 -08:00
if self.evaluated.contains(name) {
return Ok(());
} else if self.seen.contains(name) {
let token = &self.assignment_tokens[name];
self.stack.push(name);
2017-11-17 17:28:06 -08:00
return Err(token.error(CircularVariableDependency {
2017-11-16 23:30:08 -08:00
variable: name,
circle: self.stack.clone(),
2017-11-16 23:30:08 -08:00
}));
} else if self.assignments.contains_key(name) {
self.resolve_assignment(name)?;
} else {
return Err(token.error(UndefinedVariable { variable: name }));
2017-11-16 23:30:08 -08:00
}
}
Expression::Call {
ref token,
ref arguments,
..
} => Function::resolve(token, arguments.len())?,
Expression::Concatination { ref lhs, ref rhs } => {
2017-11-16 23:30:08 -08:00
self.resolve_expression(lhs)?;
self.resolve_expression(rhs)?;
}
Expression::String { .. } | Expression::Backtick { .. } => {}
Expression::Group { expression } => self.resolve_expression(expression)?,
2017-11-16 23:30:08 -08:00
}
Ok(())
}
}
#[cfg(test)]
mod test {
use super::*;
2019-04-19 02:17:43 -07:00
error_test! {
name: circular_variable_dependency,
input: "a = b\nb = a",
offset: 0,
line: 0,
column: 0,
width: 1,
kind: CircularVariableDependency{variable: "a", circle: vec!["a", "b", "a"]},
2017-11-17 17:28:06 -08:00
}
2017-11-16 23:30:08 -08:00
2019-04-19 02:17:43 -07:00
error_test! {
name: self_variable_dependency,
input: "a = a",
offset: 0,
line: 0,
column: 0,
width: 1,
kind: CircularVariableDependency{variable: "a", circle: vec!["a", "a"]},
}
2019-04-19 02:17:43 -07:00
error_test! {
name: unknown_expression_variable,
input: "x = yy",
offset: 4,
line: 0,
column: 4,
width: 2,
kind: UndefinedVariable{variable: "yy"},
2017-11-17 17:28:06 -08:00
}
2019-04-19 02:17:43 -07:00
error_test! {
name: unknown_function,
input: "a = foo()",
offset: 4,
line: 0,
column: 4,
width: 3,
kind: UnknownFunction{function: "foo"},
}
2017-11-16 23:30:08 -08:00
}