rename expr to ast

This commit is contained in:
elkowar 2021-07-12 11:57:02 +02:00
parent 641796d38f
commit 5899489250
No known key found for this signature in database
GPG key ID: E321AD71B1D1F27F
6 changed files with 71 additions and 70 deletions

View file

@ -1,4 +1,4 @@
use eww_config::{config::*, expr::*};
use eww_config::{ast::*, config::*};
fn main() {
let mut files = codespan_reporting::files::SimpleFiles::new();
@ -7,7 +7,7 @@ fn main() {
let file_id = files.add("foo.eww", input);
let ast = eww_config::parse_string(file_id, input);
match ast.and_then(Element::<Expr, Expr>::from_expr) {
match ast.and_then(Element::<Ast, Ast>::from_ast) {
Ok(ast) => {
println!("{:?}", ast);
}

View file

@ -1,7 +1,7 @@
use itertools::Itertools;
use std::collections::HashMap;
use crate::{config::FromExpr, error::*};
use crate::{config::FromAst, error::*};
use std::fmt::Display;
#[derive(Eq, PartialEq, Clone, Copy)]
@ -20,7 +20,7 @@ impl std::fmt::Debug for Span {
}
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum ExprType {
pub enum AstType {
List,
Keyword,
Symbol,
@ -28,15 +28,16 @@ pub enum ExprType {
Comment,
}
impl Display for ExprType {
impl Display for AstType {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{:?}", self)
}
}
#[derive(PartialEq, Eq, Clone)]
pub enum Expr {
List(Span, Vec<Expr>),
pub enum Ast {
List(Span, Vec<Ast>),
// ArgList(Span, Vec<Ast>),
Keyword(Span, String),
Symbol(Span, String),
Value(Span, String),
@ -61,46 +62,46 @@ macro_rules! as_func {
};
}
impl Expr {
as_func!(ExprType::Value, as_value as_value_ref<String> = Expr::Value(_, x) => x);
impl Ast {
as_func!(AstType::Value, as_value as_value_ref<String> = Ast::Value(_, x) => x);
as_func!(ExprType::Symbol, as_symbol as_symbol_ref<String> = Expr::Symbol(_, x) => x);
as_func!(AstType::Symbol, as_symbol as_symbol_ref<String> = Ast::Symbol(_, x) => x);
as_func!(ExprType::Keyword, as_keyword as_keyword_ref<String> = Expr::Keyword(_, x) => x);
as_func!(AstType::Keyword, as_keyword as_keyword_ref<String> = Ast::Keyword(_, x) => x);
as_func!(ExprType::List, as_list as_list_ref<Vec<Expr>> = Expr::List(_, x) => x);
as_func!(AstType::List, as_list as_list_ref<Vec<Ast>> = Ast::List(_, x) => x);
pub fn expr_type(&self) -> ExprType {
pub fn expr_type(&self) -> AstType {
match self {
Expr::List(..) => ExprType::List,
Expr::Keyword(..) => ExprType::Keyword,
Expr::Symbol(..) => ExprType::Symbol,
Expr::Value(..) => ExprType::Value,
Expr::Comment(_) => ExprType::Comment,
Ast::List(..) => AstType::List,
Ast::Keyword(..) => AstType::Keyword,
Ast::Symbol(..) => AstType::Symbol,
Ast::Value(..) => AstType::Value,
Ast::Comment(_) => AstType::Comment,
}
}
pub fn span(&self) -> Span {
match self {
Expr::List(span, _) => *span,
Expr::Keyword(span, _) => *span,
Expr::Symbol(span, _) => *span,
Expr::Value(span, _) => *span,
Expr::Comment(span) => *span,
Ast::List(span, _) => *span,
Ast::Keyword(span, _) => *span,
Ast::Symbol(span, _) => *span,
Ast::Value(span, _) => *span,
Ast::Comment(span) => *span,
}
}
pub fn first_list_elem(&self) -> Option<&Expr> {
pub fn first_list_elem(&self) -> Option<&Ast> {
match self {
Expr::List(_, list) => list.first(),
Ast::List(_, list) => list.first(),
_ => None,
}
}
}
impl std::fmt::Display for Expr {
impl std::fmt::Display for Ast {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
use Expr::*;
use Ast::*;
match self {
List(_, x) => write!(f, "({})", x.iter().map(|e| format!("{}", e)).join(" ")),
Keyword(_, x) => write!(f, "{}", x),
@ -110,9 +111,9 @@ impl std::fmt::Display for Expr {
}
}
}
impl std::fmt::Debug for Expr {
impl std::fmt::Debug for Ast {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
use Expr::*;
use Ast::*;
match self {
List(span, x) => f.debug_tuple(&format!("List<{}>", span)).field(x).finish(),
Keyword(span, x) => write!(f, "Number<{}>({})", span, x),
@ -123,7 +124,7 @@ impl std::fmt::Debug for Expr {
}
}
pub struct ExprIterator<I: Iterator<Item = Expr>> {
pub struct AstIterator<I: Iterator<Item = Ast>> {
iter: itertools::PutBack<I>,
}
@ -145,24 +146,24 @@ macro_rules! return_or_put_back {
};
}
impl<I: Iterator<Item = Expr>> ExprIterator<I> {
return_or_put_back!(expect_symbol, ExprType::Symbol, (Span, String) = Expr::Symbol(span, x) => (span, x));
impl<I: Iterator<Item = Ast>> AstIterator<I> {
return_or_put_back!(expect_symbol, AstType::Symbol, (Span, String) = Ast::Symbol(span, x) => (span, x));
return_or_put_back!(expect_string, ExprType::Value, (Span, String) = Expr::Value(span, x) => (span, x));
return_or_put_back!(expect_string, AstType::Value, (Span, String) = Ast::Value(span, x) => (span, x));
return_or_put_back!(expect_list, ExprType::List, (Span, Vec<Expr>) = Expr::List(span, x) => (span, x));
return_or_put_back!(expect_list, AstType::List, (Span, Vec<Ast>) = Ast::List(span, x) => (span, x));
pub fn new(iter: I) -> Self {
ExprIterator { iter: itertools::put_back(iter) }
AstIterator { iter: itertools::put_back(iter) }
}
pub fn expect_key_values<T: FromExpr>(&mut self) -> AstResult<HashMap<String, T>> {
pub fn expect_key_values<T: FromAst>(&mut self) -> AstResult<HashMap<String, T>> {
parse_key_values(&mut self.iter)
}
}
impl<I: Iterator<Item = Expr>> Iterator for ExprIterator<I> {
type Item = Expr;
impl<I: Iterator<Item = Ast>> Iterator for AstIterator<I> {
type Item = Ast;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next()
@ -170,16 +171,16 @@ impl<I: Iterator<Item = Expr>> Iterator for ExprIterator<I> {
}
/// Parse consecutive `:keyword value` pairs from an expression iterator into a HashMap. Transforms the keys using the FromExpr trait.
fn parse_key_values<T: FromExpr, I: Iterator<Item = Expr>>(iter: &mut itertools::PutBack<I>) -> AstResult<HashMap<String, T>> {
fn parse_key_values<T: FromAst, I: Iterator<Item = Ast>>(iter: &mut itertools::PutBack<I>) -> AstResult<HashMap<String, T>> {
let mut data = HashMap::new();
loop {
match iter.next() {
Some(Expr::Keyword(span, kw)) => match iter.next() {
Some(Ast::Keyword(span, kw)) => match iter.next() {
Some(value) => {
data.insert(kw, T::from_expr(value)?);
data.insert(kw, T::from_ast(value)?);
}
None => {
iter.put_back(Expr::Keyword(span, kw));
iter.put_back(Ast::Keyword(span, kw));
return Ok(data);
}
},

View file

@ -1,6 +1,6 @@
use crate::{
ast::{Ast, AstIterator, AstType, Span},
error::*,
expr::{Expr, ExprIterator, ExprType, Span},
parser, spanned,
};
use itertools::Itertools;
@ -14,12 +14,12 @@ type VarName = String;
type AttrValue = String;
type AttrName = String;
pub trait FromExpr: Sized {
fn from_expr(e: Expr) -> AstResult<Self>;
pub trait FromAst: Sized {
fn from_ast(e: Ast) -> AstResult<Self>;
}
impl FromExpr for Expr {
fn from_expr(e: Expr) -> AstResult<Self> {
impl FromAst for Ast {
fn from_ast(e: Ast) -> AstResult<Self> {
Ok(e)
}
}
@ -32,15 +32,15 @@ pub struct Element<C, A> {
span: Span,
}
impl<C: FromExpr, A: FromExpr> FromExpr for Element<C, A> {
fn from_expr(e: Expr) -> AstResult<Self> {
impl<C: FromAst, A: FromAst> FromAst for Element<C, A> {
fn from_ast(e: Ast) -> AstResult<Self> {
let span = e.span();
spanned!(e.span(), {
let list = e.as_list()?;
let mut iter = ExprIterator::new(list.into_iter());
let mut iter = AstIterator::new(list.into_iter());
let (_, name) = iter.expect_symbol()?;
let attrs = iter.expect_key_values()?;
let children = iter.map(C::from_expr).collect::<AstResult<Vec<_>>>()?;
let children = iter.map(C::from_ast).collect::<AstResult<Vec<_>>>()?;
Element { span, name, attrs, children }
})
}
@ -55,11 +55,11 @@ mod test {
#[test]
fn test() {
let parser = parser::ExprParser::new();
let parser = parser::AstParser::new();
insta::with_settings!({sort_maps => true}, {
let lexer = lexer::Lexer::new("(box :bar 12 :baz \"hi\" foo (bar))");
insta::assert_debug_snapshot!(
Element::<Expr, Expr>::from_expr(parser.parse(0, lexer).unwrap()).unwrap()
Element::<Ast, Ast>::from_ast(parser.parse(0, lexer).unwrap()).unwrap()
);
});
}

View file

@ -1,5 +1,5 @@
use crate::{
expr::{Expr, ExprType, Span},
ast::{Ast, AstType, Span},
lexer,
};
use codespan_reporting::{diagnostic, files};
@ -12,9 +12,9 @@ pub enum AstError {
#[error("Definition invalid")]
InvalidDefinition(Option<Span>),
#[error("Expected a {1}, but got nothing")]
MissingNode(Option<Span>, ExprType),
MissingNode(Option<Span>, AstType),
#[error("Wrong type of expression: Expected {1} but got {2}")]
WrongExprType(Option<Span>, ExprType, ExprType),
WrongExprType(Option<Span>, AstType, AstType),
#[error("Parse error: {source}")]
ParseError { file_id: Option<usize>, source: lalrpop_util::ParseError<usize, lexer::Token, lexer::LexicalError> },
@ -68,10 +68,10 @@ pub fn spanned(span: Span, err: impl Into<AstError>) -> AstError {
}
pub trait OptionAstErrorExt<T> {
fn or_missing(self, t: ExprType) -> Result<T, AstError>;
fn or_missing(self, t: AstType) -> Result<T, AstError>;
}
impl<T> OptionAstErrorExt<T> for Option<T> {
fn or_missing(self, t: ExprType) -> Result<T, AstError> {
fn or_missing(self, t: AstType) -> Result<T, AstError> {
self.ok_or(AstError::MissingNode(None, t))
}
}

View file

@ -2,12 +2,12 @@
#![allow(unused)]
#![feature(try_blocks)]
pub mod ast;
pub mod config;
pub mod error;
pub mod expr;
mod lexer;
use ast::Ast;
use error::{AstError, AstResult};
use expr::Expr;
use std::{fmt::Display, ops::Deref};
@ -17,15 +17,15 @@ use lalrpop_util::lalrpop_mod;
lalrpop_mod!(pub parser);
pub fn parse_string(file_id: usize, s: &str) -> AstResult<Expr> {
pub fn parse_string(file_id: usize, s: &str) -> AstResult<Ast> {
let lexer = lexer::Lexer::new(s);
let parser = parser::ExprParser::new();
let parser = parser::AstParser::new();
Ok(parser.parse(file_id, lexer).map_err(|e| AstError::from_parse_error(file_id, e))?)
}
macro_rules! test_parser {
($($text:literal),*) => {{
let p = crate::parser::ExprParser::new();
let p = crate::parser::AstParser::new();
use crate::lexer::Lexer;
::insta::with_settings!({sort_maps => true}, {

View file

@ -1,6 +1,6 @@
use std::str::FromStr;
use crate::lexer::{Token, LexicalError};
use crate::expr::{Expr, Span};
use crate::ast::{Ast, Span};
grammar(file_id: usize);
@ -22,16 +22,16 @@ extern {
}
pub Expr: Expr = {
<l:@L> "(" <elems:(<Expr>)+> ")" <r:@R> => Expr::List(Span(l, r, file_id), elems),
pub Ast: Ast = {
<l:@L> "(" <elems:(<Ast>)+> ")" <r:@R> => Ast::List(Span(l, r, file_id), elems),
<x:Keyword> => x,
<x:Symbol> => x,
<l:@L> <x:Value> <r:@R> => Expr::Value(Span(l, r, file_id), x),
<l:@L> "comment" <r:@R> => Expr::Comment(Span(l, r, file_id)),
<l:@L> <x:Value> <r:@R> => Ast::Value(Span(l, r, file_id), x),
<l:@L> "comment" <r:@R> => Ast::Comment(Span(l, r, file_id)),
};
Keyword: Expr = <l:@L> <x:"keyword"> <r:@R> => Expr::Keyword(Span(l, r, file_id), x.to_string());
Symbol: Expr = <l:@L> <x:"symbol"> <r:@R> => Expr::Symbol(Span(l, r, file_id), x.to_string());
Keyword: Ast = <l:@L> <x:"keyword"> <r:@R> => Ast::Keyword(Span(l, r, file_id), x.to_string());
Symbol: Ast = <l:@L> <x:"symbol"> <r:@R> => Ast::Symbol(Span(l, r, file_id), x.to_string());
Value: String = {
<StrLit> => <>,