diff options
author | Nadrieril Feneanar | 2019-08-30 19:17:07 +0200 |
---|---|---|
committer | GitHub | 2019-08-30 19:17:07 +0200 |
commit | ddecd2c40b91ea6aa4e23ccb2f6817ad5d1df3de (patch) | |
tree | fc915b8f5e5f41eb20571c4ad67dd4bb9ace72bc /dhall_syntax | |
parent | a981afc465f4279a7a4d6ce3ac5844e04846613b (diff) | |
parent | a7363042a16364a6dafdd545f4069dcf04a4197e (diff) |
Merge pull request #108 from Nadrieril/rename-subexpr
Rename SubExpr to Expr
Diffstat (limited to 'dhall_syntax')
-rw-r--r-- | dhall_syntax/src/core/expr.rs | 64 | ||||
-rw-r--r-- | dhall_syntax/src/core/visitor.rs | 9 | ||||
-rw-r--r-- | dhall_syntax/src/parser.rs | 64 | ||||
-rw-r--r-- | dhall_syntax/src/printer.rs | 6 |
4 files changed, 71 insertions, 72 deletions
diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs index 32166a6..2d73a64 100644 --- a/dhall_syntax/src/core/expr.rs +++ b/dhall_syntax/src/core/expr.rs @@ -166,19 +166,21 @@ pub enum Builtin { TextShow, } -// Each node carries an annotation. In practice it's either X (no annotation) or a Span. +// Each node carries an annotation. #[derive(Debug, Clone)] -pub struct SubExpr<Embed>(Box<(Expr<Embed>, Option<Span>)>); +pub struct Expr<Embed>(Box<(RawExpr<Embed>, Option<Span>)>); -impl<Embed: PartialEq> std::cmp::PartialEq for SubExpr<Embed> { +pub type RawExpr<Embed> = ExprF<Expr<Embed>, Embed>; + +impl<Embed: PartialEq> std::cmp::PartialEq for Expr<Embed> { fn eq(&self, other: &Self) -> bool { self.0.as_ref().0 == other.0.as_ref().0 } } -impl<Embed: Eq> std::cmp::Eq for SubExpr<Embed> {} +impl<Embed: Eq> std::cmp::Eq for Expr<Embed> {} -impl<Embed: std::hash::Hash> std::hash::Hash for SubExpr<Embed> { +impl<Embed: std::hash::Hash> std::hash::Hash for Expr<Embed> { fn hash<H>(&self, state: &mut H) where H: std::hash::Hasher, @@ -187,8 +189,6 @@ impl<Embed: std::hash::Hash> std::hash::Hash for SubExpr<Embed> { } } -pub type Expr<Embed> = ExprF<SubExpr<Embed>, Embed>; - /// Syntax tree for expressions // Having the recursion out of the enum definition enables writing // much more generic code and improves pattern-matching behind @@ -310,11 +310,11 @@ impl<SE, E> ExprF<SE, E> { } } -impl<E> Expr<E> { +impl<E> RawExpr<E> { pub fn traverse_resolve<E2, Err>( &self, - visit_import: impl FnMut(&Import<SubExpr<E2>>) -> Result<E2, Err>, - ) -> Result<Expr<E2>, Err> { + visit_import: impl FnMut(&Import<Expr<E2>>) -> Result<E2, Err>, + ) -> Result<RawExpr<E2>, Err> { self.traverse_resolve_with_visitor(&mut visitor::ResolveVisitor( visit_import, )) @@ -323,9 +323,9 @@ impl<E> Expr<E> { pub(crate) fn traverse_resolve_with_visitor<E2, Err, F1>( &self, visitor: &mut visitor::ResolveVisitor<F1>, - ) -> Result<Expr<E2>, Err> + ) -> Result<RawExpr<E2>, Err> where - F1: FnMut(&Import<SubExpr<E2>>) -> Result<E2, Err>, + F1: FnMut(&Import<Expr<E2>>) -> Result<E2, Err>, { match self { ExprF::BinOp(BinOp::ImportAlt, l, r) => l @@ -343,52 +343,52 @@ impl<E> Expr<E> { } } -impl<E> SubExpr<E> { - pub fn as_ref(&self) -> &Expr<E> { +impl<E> Expr<E> { + pub fn as_ref(&self) -> &RawExpr<E> { &self.0.as_ref().0 } - pub fn new(x: Expr<E>, n: Span) -> Self { - SubExpr(Box::new((x, Some(n)))) + pub fn new(x: RawExpr<E>, n: Span) -> Self { + Expr(Box::new((x, Some(n)))) } - pub fn from_expr_no_span(x: Expr<E>) -> Self { - SubExpr(Box::new((x, None))) + pub fn from_expr_no_span(x: RawExpr<E>) -> Self { + Expr(Box::new((x, None))) } pub fn from_builtin(b: Builtin) -> Self { - SubExpr::from_expr_no_span(ExprF::Builtin(b)) + Expr::from_expr_no_span(ExprF::Builtin(b)) } - pub fn rewrap<E2>(&self, x: Expr<E2>) -> SubExpr<E2> { - SubExpr(Box::new((x, (self.0).1.clone()))) + pub fn rewrap<E2>(&self, x: RawExpr<E2>) -> Expr<E2> { + Expr(Box::new((x, (self.0).1.clone()))) } } -impl<E> SubExpr<E> { +impl<E> Expr<E> { pub fn traverse_resolve<E2, Err>( &self, - visit_import: impl FnMut(&Import<SubExpr<E2>>) -> Result<E2, Err>, - ) -> Result<SubExpr<E2>, Err> { + visit_import: impl FnMut(&Import<Expr<E2>>) -> Result<E2, Err>, + ) -> Result<Expr<E2>, Err> { Ok(self.rewrap(self.as_ref().traverse_resolve(visit_import)?)) } } // Should probably rename this -pub fn rc<E>(x: Expr<E>) -> SubExpr<E> { - SubExpr::from_expr_no_span(x) +pub fn rc<E>(x: RawExpr<E>) -> Expr<E> { + Expr::from_expr_no_span(x) } pub(crate) fn spanned( span: Span, - x: crate::parser::ParsedExpr, -) -> crate::parser::ParsedSubExpr { - SubExpr::new(x, span) + x: crate::parser::ParsedRawExpr, +) -> crate::parser::ParsedExpr { + Expr::new(x, span) } pub(crate) fn unspanned( - x: crate::parser::ParsedExpr, -) -> crate::parser::ParsedSubExpr { - SubExpr::from_expr_no_span(x) + x: crate::parser::ParsedRawExpr, +) -> crate::parser::ParsedExpr { + Expr::from_expr_no_span(x) } /// Add an isize to an usize diff --git a/dhall_syntax/src/core/visitor.rs b/dhall_syntax/src/core/visitor.rs index 5a5fcc9..49fff60 100644 --- a/dhall_syntax/src/core/visitor.rs +++ b/dhall_syntax/src/core/visitor.rs @@ -247,18 +247,17 @@ where pub struct ResolveVisitor<F1>(pub F1); -impl<'a, 'b, E, E2, Err, F1> - ExprFFallibleVisitor<'a, SubExpr<E>, SubExpr<E2>, E, E2> +impl<'a, 'b, E, E2, Err, F1> ExprFFallibleVisitor<'a, Expr<E>, Expr<E2>, E, E2> for &'b mut ResolveVisitor<F1> where - F1: FnMut(&Import<SubExpr<E2>>) -> Result<E2, Err>, + F1: FnMut(&Import<Expr<E2>>) -> Result<E2, Err>, { type Error = Err; fn visit_subexpr( &mut self, - subexpr: &'a SubExpr<E>, - ) -> Result<SubExpr<E2>, Self::Error> { + subexpr: &'a Expr<E>, + ) -> Result<Expr<E2>, Self::Error> { Ok(subexpr.rewrap( subexpr .as_ref() diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs index d631a19..defa79b 100644 --- a/dhall_syntax/src/parser.rs +++ b/dhall_syntax/src/parser.rs @@ -18,10 +18,10 @@ use crate::*; // their own crate because they are quite general and useful. For now they // are here and hopefully you can figure out how they work. +pub(crate) type ParsedRawExpr = RawExpr<!>; pub(crate) type ParsedExpr = Expr<!>; -pub(crate) type ParsedSubExpr = SubExpr<!>; -type ParsedText = InterpolatedText<ParsedSubExpr>; -type ParsedTextContents = InterpolatedTextContents<ParsedSubExpr>; +type ParsedText = InterpolatedText<ParsedExpr>; +type ParsedTextContents = InterpolatedTextContents<ParsedExpr>; pub type ParseError = pest::error::Error<Rule>; @@ -551,7 +551,7 @@ make_parser! { rule!(escaped_interpolation<&'a str>; captured_str!(_) => "${" ); - rule!(interpolation<ParsedSubExpr>; children!( + rule!(interpolation<ParsedExpr>; children!( [expression(e)] => e )); @@ -593,7 +593,7 @@ make_parser! { }, )); - rule!(builtin<ParsedSubExpr>; span; + rule!(builtin<ParsedExpr>; span; captured_str!(s) => { spanned(span, match crate::Builtin::parse(s) { Some(b) => Builtin(b), @@ -650,7 +650,7 @@ make_parser! { } ); - rule!(identifier<ParsedSubExpr>; span; children!( + rule!(identifier<ParsedExpr>; span; children!( [variable(v)] => { spanned(span, Var(v)) }, @@ -708,7 +708,7 @@ make_parser! { _ => unreachable!(), }); - rule!(http_raw<URL<ParsedSubExpr>>; children!( + rule!(http_raw<URL<ParsedExpr>>; children!( [scheme(sch), authority(auth), path(p)] => URL { scheme: sch, authority: auth, @@ -729,7 +729,7 @@ make_parser! { rule!(query<String>; captured_str!(s) => s.to_owned()); - rule!(http<URL<ParsedSubExpr>>; children!( + rule!(http<URL<ParsedExpr>>; children!( [http_raw(url)] => url, [http_raw(url), import_expression(e)] => URL { headers: Some(e), ..url }, @@ -764,7 +764,7 @@ make_parser! { rule!(missing<()>); - rule!(import_type<ImportLocation<ParsedSubExpr>>; children!( + rule!(import_type<ImportLocation<ParsedExpr>>; children!( [missing(_)] => { ImportLocation::Missing }, @@ -789,7 +789,7 @@ make_parser! { Hash::SHA256(hex::decode(hash).unwrap()) }); - rule!(import_hashed<crate::Import<ParsedSubExpr>>; children!( + rule!(import_hashed<crate::Import<ParsedExpr>>; children!( [import_type(location)] => crate::Import {mode: ImportMode::Code, location, hash: None }, [import_type(location), hash(h)] => @@ -799,7 +799,7 @@ make_parser! { rule!(Text<()>); rule!(Location<()>); - rule!(import<ParsedSubExpr>; span; children!( + rule!(import<ParsedExpr>; span; children!( [import_hashed(imp)] => { spanned(span, Import(crate::Import { mode: ImportMode::Code, @@ -828,13 +828,13 @@ make_parser! { rule!(if_<()>); rule!(in_<()>); - rule!(empty_list_literal<ParsedSubExpr>; span; children!( + rule!(empty_list_literal<ParsedExpr>; span; children!( [application_expression(e)] => { spanned(span, EmptyListLit(e)) }, )); - rule!(expression<ParsedSubExpr>; span; children!( + rule!(expression<ParsedExpr>; span; children!( [lambda(()), label(l), expression(typ), arrow(()), expression(body)] => { spanned(span, Lam(l, typ, body)) @@ -869,7 +869,7 @@ make_parser! { }, )); - rule!(let_binding<(Label, Option<ParsedSubExpr>, ParsedSubExpr)>; + rule!(let_binding<(Label, Option<ParsedExpr>, ParsedExpr)>; children!( [label(name), expression(annot), expression(expr)] => (name, Some(annot), expr), @@ -880,7 +880,7 @@ make_parser! { rule!(List<()>); rule!(Optional<()>); - rule!(operator_expression<ParsedSubExpr>; prec_climb!( + rule!(operator_expression<ParsedExpr>; prec_climb!( application_expression, { use Rule::*; @@ -936,14 +936,14 @@ make_parser! { rule!(Some_<()>); rule!(toMap<()>); - rule!(application_expression<ParsedSubExpr>; children!( + rule!(application_expression<ParsedExpr>; children!( [first_application_expression(e)] => e, [first_application_expression(first), import_expression(rest)..] => { rest.fold(first, |acc, e| unspanned(App(acc, e))) }, )); - rule!(first_application_expression<ParsedSubExpr>; span; + rule!(first_application_expression<ParsedExpr>; span; children!( [Some_(()), import_expression(e)] => { spanned(span, SomeLit(e)) @@ -954,13 +954,13 @@ make_parser! { [import_expression(e)] => e, )); - rule!(import_expression<ParsedSubExpr>; span; + rule!(import_expression<ParsedExpr>; span; children!( [selector_expression(e)] => e, [import(e)] => e, )); - rule!(selector_expression<ParsedSubExpr>; children!( + rule!(selector_expression<ParsedExpr>; children!( [primitive_expression(e)] => e, [primitive_expression(first), selector(rest)..] => { rest.fold(first, |acc, e| unspanned(match e { @@ -980,7 +980,7 @@ make_parser! { [label(ls)..] => ls.collect(), )); - rule!(primitive_expression<ParsedSubExpr>; span; children!( + rule!(primitive_expression<ParsedExpr>; span; children!( [double_literal(n)] => spanned(span, DoubleLit(n)), [natural_literal(n)] => spanned(span, NaturalLit(n)), [integer_literal(n)] => spanned(span, IntegerLit(n)), @@ -995,15 +995,15 @@ make_parser! { [expression(e)] => e, )); - rule!(empty_record_literal<ParsedSubExpr>; span; + rule!(empty_record_literal<ParsedExpr>; span; captured_str!(_) => spanned(span, RecordLit(Default::default())) ); - rule!(empty_record_type<ParsedSubExpr>; span; + rule!(empty_record_type<ParsedExpr>; span; captured_str!(_) => spanned(span, RecordType(Default::default())) ); - rule!(non_empty_record_type_or_literal<ParsedSubExpr>; span; + rule!(non_empty_record_type_or_literal<ParsedExpr>; span; children!( [label(first_label), non_empty_record_type(rest)] => { let (first_expr, mut map) = rest; @@ -1018,28 +1018,28 @@ make_parser! { )); rule!(non_empty_record_type - <(ParsedSubExpr, DupTreeMap<Label, ParsedSubExpr>)>; children!( + <(ParsedExpr, DupTreeMap<Label, ParsedExpr>)>; children!( [expression(expr), record_type_entry(entries)..] => { (expr, entries.collect()) } )); - rule!(record_type_entry<(Label, ParsedSubExpr)>; children!( + rule!(record_type_entry<(Label, ParsedExpr)>; children!( [label(name), expression(expr)] => (name, expr) )); rule!(non_empty_record_literal - <(ParsedSubExpr, DupTreeMap<Label, ParsedSubExpr>)>; children!( + <(ParsedExpr, DupTreeMap<Label, ParsedExpr>)>; children!( [expression(expr), record_literal_entry(entries)..] => { (expr, entries.collect()) } )); - rule!(record_literal_entry<(Label, ParsedSubExpr)>; children!( + rule!(record_literal_entry<(Label, ParsedExpr)>; children!( [label(name), expression(expr)] => (name, expr) )); - rule!(union_type<ParsedSubExpr>; span; children!( + rule!(union_type<ParsedExpr>; span; children!( [empty_union_type(_)] => { spanned(span, UnionType(Default::default())) }, @@ -1050,12 +1050,12 @@ make_parser! { rule!(empty_union_type<()>); - rule!(union_type_entry<(Label, Option<ParsedSubExpr>)>; children!( + rule!(union_type_entry<(Label, Option<ParsedExpr>)>; children!( [label(name), expression(expr)] => (name, Some(expr)), [label(name)] => (name, None), )); - rule!(non_empty_list_literal<ParsedSubExpr>; span; + rule!(non_empty_list_literal<ParsedExpr>; span; children!( [expression(items)..] => spanned( span, @@ -1063,12 +1063,12 @@ make_parser! { ) )); - rule!(final_expression<ParsedSubExpr>; children!( + rule!(final_expression<ParsedExpr>; children!( [expression(e), EOI(_)] => e )); } -pub fn parse_expr(s: &str) -> ParseResult<ParsedSubExpr> { +pub fn parse_expr(s: &str) -> ParseResult<ParsedExpr> { let mut pairs = DhallParser::parse(Rule::final_expression, s)?; let rc_input = s.to_string().into(); let expr = EntryPoint::final_expression(rc_input, pairs.next().unwrap())?; diff --git a/dhall_syntax/src/printer.rs b/dhall_syntax/src/printer.rs index 256ea65..276590e 100644 --- a/dhall_syntax/src/printer.rs +++ b/dhall_syntax/src/printer.rs @@ -112,7 +112,7 @@ enum PrintPhase { // Wraps an Expr with a phase, so that phase selsction can be done // separate from the actual printing #[derive(Clone)] -struct PhasedExpr<'a, A>(&'a SubExpr<A>, PrintPhase); +struct PhasedExpr<'a, A>(&'a Expr<A>, PrintPhase); impl<'a, A: Display + Clone> Display for PhasedExpr<'a, A> { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { @@ -126,7 +126,7 @@ impl<'a, A: Display + Clone> PhasedExpr<'a, A> { } } -impl<A: Display + Clone> Expr<A> { +impl<A: Display + Clone> RawExpr<A> { fn fmt_phase( &self, f: &mut fmt::Formatter, @@ -202,7 +202,7 @@ impl<A: Display + Clone> Expr<A> { } } -impl<A: Display + Clone> Display for SubExpr<A> { +impl<A: Display + Clone> Display for Expr<A> { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { self.as_ref().fmt_phase(f, PrintPhase::Base) } |