just/src/node.rs

250 lines
6.3 KiB
Rust
Raw Normal View History

use crate::common::*;
/// Methods commmon to all AST nodes. Currently only used in parser unit tests.
pub(crate) trait Node<'src> {
/// Construct an untyped tree of atoms representing this Node. This function,
/// and `Tree` type, are only used in parser unit tests.
fn tree(&self) -> Tree<'src>;
}
2021-07-23 20:26:27 -07:00
impl<'src> Node<'src> for Ast<'src> {
fn tree(&self) -> Tree<'src> {
Tree::atom("justfile")
.extend(self.items.iter().map(|item| item.tree()))
.extend(self.warnings.iter().map(|warning| warning.tree()))
}
}
impl<'src> Node<'src> for Item<'src> {
fn tree(&self) -> Tree<'src> {
match self {
Item::Alias(alias) => alias.tree(),
Item::Assignment(assignment) => assignment.tree(),
2021-06-08 01:01:27 -07:00
Item::Comment(comment) => comment.tree(),
Item::Recipe(recipe) => recipe.tree(),
Item::Set(set) => set.tree(),
}
}
}
impl<'src> Node<'src> for Alias<'src, Name<'src>> {
fn tree(&self) -> Tree<'src> {
Tree::atom(Keyword::Alias.lexeme())
.push(self.name.lexeme())
.push(self.target.lexeme())
}
}
impl<'src> Node<'src> for Assignment<'src> {
fn tree(&self) -> Tree<'src> {
if self.export {
Tree::atom("assignment")
.push("#")
.push(Keyword::Export.lexeme())
} else {
Tree::atom("assignment")
}
.push(self.name.lexeme())
.push(self.value.tree())
}
}
impl<'src> Node<'src> for Expression<'src> {
fn tree(&self) -> Tree<'src> {
match self {
Expression::Concatination { lhs, rhs } => Tree::atom("+").push(lhs.tree()).push(rhs.tree()),
Expression::Conditional {
lhs,
rhs,
then,
otherwise,
operator,
} => {
let mut tree = Tree::atom(Keyword::If.lexeme());
tree.push_mut(lhs.tree());
tree.push_mut(operator.to_string());
tree.push_mut(rhs.tree());
tree.push_mut(then.tree());
tree.push_mut(otherwise.tree());
tree
}
Expression::Call { thunk } => {
use Thunk::*;
let mut tree = Tree::atom("call");
match thunk {
Nullary { name, .. } => tree.push_mut(name.lexeme()),
Unary { name, arg, .. } => {
tree.push_mut(name.lexeme());
tree.push_mut(arg.tree());
}
Binary {
name, args: [a, b], ..
} => {
tree.push_mut(name.lexeme());
tree.push_mut(a.tree());
tree.push_mut(b.tree());
}
BinaryPlus {
name,
args: ([a, b], rest),
..
} => {
tree.push_mut(name.lexeme());
tree.push_mut(a.tree());
tree.push_mut(b.tree());
for arg in rest {
tree.push_mut(arg.tree());
}
}
Ternary {
name,
args: [a, b, c],
..
} => {
tree.push_mut(name.lexeme());
tree.push_mut(a.tree());
tree.push_mut(b.tree());
tree.push_mut(c.tree());
}
}
tree
}
Expression::Variable { name } => Tree::atom(name.lexeme()),
Expression::StringLiteral {
string_literal: StringLiteral { cooked, .. },
} => Tree::string(cooked),
Expression::Backtick { contents, .. } => Tree::atom("backtick").push(Tree::string(contents)),
Expression::Group { contents } => Tree::List(vec![contents.tree()]),
}
}
}
impl<'src> Node<'src> for UnresolvedRecipe<'src> {
fn tree(&self) -> Tree<'src> {
let mut t = Tree::atom("recipe");
if self.quiet {
t.push_mut("#");
t.push_mut("quiet");
}
if let Some(doc) = self.doc {
t.push_mut(Tree::string(doc));
}
t.push_mut(self.name.lexeme());
if !self.parameters.is_empty() {
let mut params = Tree::atom("params");
for parameter in &self.parameters {
if let Some(prefix) = parameter.kind.prefix() {
params.push_mut(prefix);
}
params.push_mut(parameter.tree());
}
t.push_mut(params);
}
if !self.dependencies.is_empty() {
let mut dependencies = Tree::atom("deps");
let mut subsequents = Tree::atom("sups");
for (i, dependency) in self.dependencies.iter().enumerate() {
let mut d = Tree::atom(dependency.recipe.lexeme());
for argument in &dependency.arguments {
d.push_mut(argument.tree());
}
if i < self.priors {
dependencies.push_mut(d);
} else {
subsequents.push_mut(d);
}
}
if let Tree::List(_) = dependencies {
t.push_mut(dependencies);
}
if let Tree::List(_) = subsequents {
t.push_mut(subsequents);
}
}
if !self.body.is_empty() {
t.push_mut(Tree::atom("body").extend(self.body.iter().map(|line| line.tree())));
}
t
}
}
impl<'src> Node<'src> for Parameter<'src> {
fn tree(&self) -> Tree<'src> {
let mut children = vec![Tree::atom(self.name.lexeme())];
if let Some(default) = &self.default {
children.push(default.tree());
}
Tree::List(children)
}
}
impl<'src> Node<'src> for Line<'src> {
fn tree(&self) -> Tree<'src> {
Tree::list(self.fragments.iter().map(|fragment| fragment.tree()))
}
}
impl<'src> Node<'src> for Fragment<'src> {
fn tree(&self) -> Tree<'src> {
match self {
Fragment::Text { token } => Tree::string(token.lexeme()),
Fragment::Interpolation { expression } => Tree::List(vec![expression.tree()]),
}
}
}
impl<'src> Node<'src> for Set<'src> {
fn tree(&self) -> Tree<'src> {
use Setting::*;
let mut set = Tree::atom(Keyword::Set.lexeme());
set.push_mut(self.name.lexeme().replace('-', "_"));
match &self.value {
2022-01-18 11:02:15 -08:00
DotenvLoad(value) | Export(value) | PositionalArguments(value) | WindowsPowerShell(value) => {
set.push_mut(value.to_string());
}
Shell(setting::Shell { command, arguments }) => {
set.push_mut(Tree::string(&command.cooked));
for argument in arguments {
set.push_mut(Tree::string(&argument.cooked));
}
}
}
set
}
}
impl<'src> Node<'src> for Warning {
fn tree(&self) -> Tree<'src> {
unreachable!()
}
}
2021-06-08 01:01:27 -07:00
impl<'src> Node<'src> for str {
fn tree(&self) -> Tree<'src> {
Tree::atom("comment").push(["\"", self, "\""].concat())
}
}