summaryrefslogtreecommitdiff
path: root/dhall_syntax/src
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--dhall_syntax/src/core/expr.rs64
-rw-r--r--dhall_syntax/src/core/visitor.rs9
-rw-r--r--dhall_syntax/src/parser.rs64
-rw-r--r--dhall_syntax/src/printer.rs6
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)
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-09 19:18:34 +0000