summaryrefslogtreecommitdiff
path: root/dhall_syntax
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--dhall_syntax/src/core.rs93
-rw-r--r--dhall_syntax/src/parser.rs162
-rw-r--r--dhall_syntax/src/visitor.rs11
3 files changed, 139 insertions, 127 deletions
diff --git a/dhall_syntax/src/core.rs b/dhall_syntax/src/core.rs
index a81f96c..a186d19 100644
--- a/dhall_syntax/src/core.rs
+++ b/dhall_syntax/src/core.rs
@@ -141,12 +141,13 @@ pub type ParsedExpr = SubExpr<X, Import>;
pub type ResolvedExpr = SubExpr<X, X>;
pub type DhallExpr = ResolvedExpr;
+// Each node carries an annotation. In practice it's either X (no annotation) or a Span.
#[derive(Debug)]
-pub struct SubExpr<Note, Embed>(Rc<Expr<Note, Embed>>, Option<Note>);
+pub struct SubExpr<Note, Embed>(Rc<(Expr<Note, Embed>, Option<Note>)>);
impl<Note, Embed: PartialEq> std::cmp::PartialEq for SubExpr<Note, Embed> {
fn eq(&self, other: &Self) -> bool {
- self.0 == other.0
+ self.0.as_ref().0 == other.0.as_ref().0
}
}
@@ -345,14 +346,6 @@ impl<N, E> Expr<N, E> {
trivial_result(self.traverse_embed(|x| Ok(map_embed(x))))
}
- pub fn roll(&self) -> SubExpr<N, E>
- where
- N: Clone,
- E: Clone,
- {
- rc(ExprF::clone(self))
- }
-
pub fn squash_embed<E2>(
&self,
f: impl FnMut(&E) -> SubExpr<N, E2>,
@@ -378,7 +371,33 @@ impl<N: Clone> Expr<N, X> {
impl<N, E> SubExpr<N, E> {
pub fn as_ref(&self) -> &Expr<N, E> {
- self.0.as_ref()
+ &self.0.as_ref().0
+ }
+
+ pub fn new(x: Expr<N, E>, n: N) -> Self {
+ SubExpr(Rc::new((x, Some(n))))
+ }
+
+ pub fn from_expr_no_note(x: Expr<N, E>) -> Self {
+ SubExpr(Rc::new((x, None)))
+ }
+
+ pub fn unnote(&self) -> SubExpr<X, E>
+ where
+ E: Clone,
+ {
+ SubExpr::from_expr_no_note(
+ self.as_ref().visit(&mut visitor::UnNoteVisitor),
+ )
+ }
+}
+
+impl<N: Clone, E> SubExpr<N, E> {
+ pub fn rewrap<E2>(&self, x: Expr<N, E2>) -> SubExpr<N, E2>
+ where
+ N: Clone,
+ {
+ SubExpr(Rc::new((x, (self.0).1.clone())))
}
pub fn traverse_embed<E2, Err>(
@@ -388,7 +407,7 @@ impl<N, E> SubExpr<N, E> {
where
N: Clone,
{
- Ok(rc(self.as_ref().traverse_embed(visit_embed)?))
+ Ok(self.rewrap(self.as_ref().traverse_embed(visit_embed)?))
}
pub fn map_embed<E2>(
@@ -398,7 +417,7 @@ impl<N, E> SubExpr<N, E> {
where
N: Clone,
{
- rc(self.as_ref().map_embed(map_embed))
+ self.rewrap(self.as_ref().map_embed(map_embed))
}
pub fn map_subexprs_with_special_handling_of_binders<'a>(
@@ -409,7 +428,7 @@ impl<N, E> SubExpr<N, E> {
match self.as_ref() {
ExprF::Embed(_) => SubExpr::clone(self),
// This calls ExprF::map_ref
- e => rc(e.map_ref_with_special_handling_of_binders(
+ e => self.rewrap(e.map_ref_with_special_handling_of_binders(
map_expr,
map_under_binder,
|_| unreachable!(),
@@ -418,28 +437,13 @@ impl<N, E> SubExpr<N, E> {
}
}
- pub fn unroll(&self) -> Expr<N, E>
- where
- N: Clone,
- E: Clone,
- {
- ExprF::clone(self.as_ref())
- }
-
- pub fn unnote(&self) -> SubExpr<X, E>
- where
- E: Clone,
- {
- rc(self.as_ref().visit(&mut visitor::UnNoteVisitor))
- }
-
/// `shift` is used by both normalization and type-checking to avoid variable
/// capture by shifting variable indices
/// See https://github.com/dhall-lang/dhall-lang/blob/master/standard/semantics.md#shift
/// for details
pub fn shift(&self, delta: isize, var: &V<Label>) -> Self {
match self.as_ref() {
- ExprF::Var(v) => rc(ExprF::Var(v.shift(delta, var))),
+ ExprF::Var(v) => self.rewrap(ExprF::Var(v.shift(delta, var))),
_ => self.map_subexprs_with_special_handling_of_binders(
|e| e.shift(delta, var),
|x: &Label, e| e.shift(delta, &var.shift(1, &x.into())),
@@ -450,7 +454,7 @@ impl<N, E> SubExpr<N, E> {
pub fn subst_shift(&self, var: &V<Label>, val: &Self) -> Self {
match self.as_ref() {
ExprF::Var(v) if v == var => val.clone(),
- ExprF::Var(v) => rc(ExprF::Var(v.shift(-1, var))),
+ ExprF::Var(v) => self.rewrap(ExprF::Var(v.shift(-1, var))),
_ => self.map_subexprs_with_special_handling_of_binders(
|e| e.subst_shift(var, val),
|x: &Label, e| {
@@ -466,25 +470,25 @@ impl<N, E> SubExpr<N, E> {
impl<N: Clone> SubExpr<N, X> {
pub fn embed_absurd<T>(&self) -> SubExpr<N, T> {
- rc(self.as_ref().embed_absurd())
+ self.rewrap(self.as_ref().embed_absurd())
}
}
impl<E: Clone> SubExpr<X, E> {
pub fn note_absurd<N>(&self) -> SubExpr<N, E> {
- rc(self.as_ref().note_absurd())
+ SubExpr::from_expr_no_note(self.as_ref().note_absurd())
}
}
impl<N, E> Clone for SubExpr<N, E> {
fn clone(&self) -> Self {
- SubExpr(Rc::clone(&self.0), None)
+ SubExpr(Rc::clone(&self.0))
}
}
// Should probably rename this
-pub fn rc<N, E>(x: Expr<N, E>) -> SubExpr<N, E> {
- SubExpr(Rc::new(x), None)
+pub fn rc<E>(x: Expr<X, E>) -> SubExpr<X, E> {
+ SubExpr::from_expr_no_note(x)
}
/// Add an isize to an usize
@@ -518,14 +522,20 @@ pub fn shift<N, E>(
delta: isize,
var: &V<Label>,
in_expr: &SubExpr<N, E>,
-) -> SubExpr<N, E> {
+) -> SubExpr<N, E>
+where
+ N: Clone,
+{
in_expr.shift(delta, var)
}
pub fn shift0_multiple<N, E>(
deltas: &HashMap<Label, isize>,
in_expr: &SubExpr<N, E>,
-) -> SubExpr<N, E> {
+) -> SubExpr<N, E>
+where
+ N: Clone,
+{
shift0_multiple_inner(&Context::new(), deltas, in_expr)
}
@@ -533,12 +543,15 @@ fn shift0_multiple_inner<N, E>(
ctx: &Context<Label, ()>,
deltas: &HashMap<Label, isize>,
in_expr: &SubExpr<N, E>,
-) -> SubExpr<N, E> {
+) -> SubExpr<N, E>
+where
+ N: Clone,
+{
use crate::ExprF::*;
match in_expr.as_ref() {
Var(V(y, m)) if ctx.lookup(y, *m).is_none() => {
let delta = deltas.get(y).unwrap_or(&0);
- rc(Var(V(y.clone(), add_ui(*m, *delta))))
+ in_expr.rewrap(Var(V(y.clone(), add_ui(*m, *delta))))
}
_ => in_expr.map_subexprs_with_special_handling_of_binders(
|e| shift0_multiple_inner(ctx, deltas, e),
diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs
index b5bf09d..83ccc1e 100644
--- a/dhall_syntax/src/parser.rs
+++ b/dhall_syntax/src/parser.rs
@@ -25,8 +25,8 @@ pub type ParseError = pest::error::Error<Rule>;
pub type ParseResult<T> = Result<T, ParseError>;
-fn rc(x: ParsedExpr) -> ParsedSubExpr {
- crate::rc(x)
+fn unspanned(x: ParsedExpr) -> ParsedSubExpr {
+ SubExpr::from_expr_no_note(x)
}
#[derive(Debug, Clone)]
@@ -52,10 +52,8 @@ impl Span {
}
}
-fn spanned(_span: Span, x: ParsedExpr) -> ParsedExpr {
- x
- // This breaks equality testing; I need to fix that first
- // Note(span, rc(x))
+fn spanned(span: Span, x: ParsedExpr) -> ParsedSubExpr {
+ SubExpr::new(x, span)
}
#[derive(Debug)]
@@ -343,7 +341,7 @@ make_parser! {
rule!(double_quote_chunk<ParsedTextContents>; children!(
[interpolation(e)] => {
- InterpolatedTextContents::Expr(rc(e))
+ InterpolatedTextContents::Expr(e)
},
[double_quote_escaped(s)] => {
InterpolatedTextContents::Text(s)
@@ -408,13 +406,13 @@ make_parser! {
rule!(escaped_interpolation<&'a str>;
captured_str!(_) => "${"
);
- rule!(interpolation<ParsedExpr>; children!(
+ rule!(interpolation<ParsedSubExpr>; children!(
[expression(e)] => e
));
rule!(single_quote_continue<Vec<Vec<ParsedTextContents>>>; children!(
[interpolation(c), single_quote_continue(lines)] => {
- let c = InterpolatedTextContents::Expr(rc(c));
+ let c = InterpolatedTextContents::Expr(c);
let mut lines = lines;
lines.last_mut().unwrap().push(c);
lines
@@ -447,7 +445,7 @@ make_parser! {
},
));
- rule!(builtin<ParsedExpr>; span;
+ rule!(builtin<ParsedSubExpr>; span;
captured_str!(s) => {
spanned(span, match crate::Builtin::parse(s) {
Some(b) => Builtin(b),
@@ -504,7 +502,7 @@ make_parser! {
}
);
- rule!(identifier<ParsedExpr> as expression; span; children!(
+ rule!(identifier<ParsedSubExpr> as expression; span; children!(
[variable(v)] => {
spanned(span, Var(v))
},
@@ -644,7 +642,7 @@ make_parser! {
token_rule!(Text<()>);
- rule!(import<ParsedExpr> as expression; span; children!(
+ rule!(import<ParsedSubExpr> as expression; span; children!(
[import_hashed(location_hashed)] => {
spanned(span, Embed(Import {
mode: ImportMode::Code,
@@ -666,29 +664,29 @@ make_parser! {
token_rule!(if_<()>);
token_rule!(in_<()>);
- rule!(expression<ParsedExpr> as expression; span; children!(
+ rule!(expression<ParsedSubExpr> as expression; span; children!(
[lambda(()), label(l), expression(typ),
arrow(()), expression(body)] => {
- spanned(span, Lam(l, rc(typ), rc(body)))
+ spanned(span, Lam(l, typ, body))
},
[if_(()), expression(cond), expression(left), expression(right)] => {
- spanned(span, BoolIf(rc(cond), rc(left), rc(right)))
+ spanned(span, BoolIf(cond, left, right))
},
[let_binding(bindings).., in_(()), expression(final_expr)] => {
bindings.rev().fold(
final_expr,
- |acc, x| Let(x.0, x.1, x.2, rc(acc))
+ |acc, x| unspanned(Let(x.0, x.1, x.2, acc))
)
},
[forall(()), label(l), expression(typ),
arrow(()), expression(body)] => {
- spanned(span, Pi(l, rc(typ), rc(body)))
+ spanned(span, Pi(l, typ, body))
},
[expression(typ), arrow(()), expression(body)] => {
- spanned(span, Pi("_".into(), rc(typ), rc(body)))
+ spanned(span, Pi("_".into(), typ, body))
},
[merge(()), expression(x), expression(y), expression(z)] => {
- spanned(span, Merge(rc(x), rc(y), Some(rc(z))))
+ spanned(span, Merge(x, y, Some(z)))
},
[expression(e)] => e,
));
@@ -696,148 +694,148 @@ make_parser! {
rule!(let_binding<(Label, Option<ParsedSubExpr>, ParsedSubExpr)>;
children!(
[label(name), expression(annot), expression(expr)] =>
- (name, Some(rc(annot)), rc(expr)),
+ (name, Some(annot), expr),
[label(name), expression(expr)] =>
- (name, None, rc(expr)),
+ (name, None, expr),
));
token_rule!(List<()>);
token_rule!(Optional<()>);
- rule!(empty_collection<ParsedExpr> as expression; span; children!(
+ rule!(empty_collection<ParsedSubExpr> as expression; span; children!(
[List(_), expression(t)] => {
- spanned(span, EmptyListLit(rc(t)))
+ spanned(span, EmptyListLit(t))
},
[Optional(_), expression(t)] => {
- spanned(span, OldOptionalLit(None, rc(t)))
+ spanned(span, OldOptionalLit(None, t))
},
));
- rule!(non_empty_optional<ParsedExpr> as expression; span; children!(
+ rule!(non_empty_optional<ParsedSubExpr> as expression; span; children!(
[expression(x), Optional(_), expression(t)] => {
- spanned(span, OldOptionalLit(Some(rc(x)), rc(t)))
+ spanned(span, OldOptionalLit(Some(x), t))
}
));
- rule!(import_alt_expression<ParsedExpr> as expression; children!(
+ rule!(import_alt_expression<ParsedSubExpr> as expression; children!(
[expression(e)] => e,
[expression(first), expression(rest)..] => {
let o = crate::BinOp::ImportAlt;
- rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
+ rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
},
));
- rule!(or_expression<ParsedExpr> as expression; children!(
+ rule!(or_expression<ParsedSubExpr> as expression; children!(
[expression(e)] => e,
[expression(first), expression(rest)..] => {
let o = crate::BinOp::BoolOr;
- rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
+ rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
},
));
- rule!(plus_expression<ParsedExpr> as expression; children!(
+ rule!(plus_expression<ParsedSubExpr> as expression; children!(
[expression(e)] => e,
[expression(first), expression(rest)..] => {
let o = crate::BinOp::NaturalPlus;
- rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
+ rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
},
));
- rule!(text_append_expression<ParsedExpr> as expression; children!(
+ rule!(text_append_expression<ParsedSubExpr> as expression; children!(
[expression(e)] => e,
[expression(first), expression(rest)..] => {
let o = crate::BinOp::TextAppend;
- rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
+ rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
},
));
- rule!(list_append_expression<ParsedExpr> as expression; children!(
+ rule!(list_append_expression<ParsedSubExpr> as expression; children!(
[expression(e)] => e,
[expression(first), expression(rest)..] => {
let o = crate::BinOp::ListAppend;
- rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
+ rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
},
));
- rule!(and_expression<ParsedExpr> as expression; children!(
+ rule!(and_expression<ParsedSubExpr> as expression; children!(
[expression(e)] => e,
[expression(first), expression(rest)..] => {
let o = crate::BinOp::BoolAnd;
- rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
+ rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
},
));
- rule!(combine_expression<ParsedExpr> as expression; children!(
+ rule!(combine_expression<ParsedSubExpr> as expression; children!(
[expression(e)] => e,
[expression(first), expression(rest)..] => {
let o = crate::BinOp::Combine;
- rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
+ rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
},
));
- rule!(prefer_expression<ParsedExpr> as expression; children!(
+ rule!(prefer_expression<ParsedSubExpr> as expression; children!(
[expression(e)] => e,
[expression(first), expression(rest)..] => {
let o = crate::BinOp::Prefer;
- rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
+ rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
},
));
- rule!(combine_types_expression<ParsedExpr> as expression; children!(
+ rule!(combine_types_expression<ParsedSubExpr> as expression; children!(
[expression(e)] => e,
[expression(first), expression(rest)..] => {
let o = crate::BinOp::CombineTypes;
- rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
+ rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
},
));
- rule!(times_expression<ParsedExpr> as expression; children!(
+ rule!(times_expression<ParsedSubExpr> as expression; children!(
[expression(e)] => e,
[expression(first), expression(rest)..] => {
let o = crate::BinOp::NaturalTimes;
- rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
+ rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
},
));
- rule!(equal_expression<ParsedExpr> as expression; children!(
+ rule!(equal_expression<ParsedSubExpr> as expression; children!(
[expression(e)] => e,
[expression(first), expression(rest)..] => {
let o = crate::BinOp::BoolEQ;
- rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
+ rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
},
));
- rule!(not_equal_expression<ParsedExpr> as expression; children!(
+ rule!(not_equal_expression<ParsedSubExpr> as expression; children!(
[expression(e)] => e,
[expression(first), expression(rest)..] => {
let o = crate::BinOp::BoolNE;
- rest.fold(first, |acc, e| BinOp(o, rc(acc), rc(e)))
+ rest.fold(first, |acc, e| unspanned(BinOp(o, acc, e)))
},
));
- rule!(annotated_expression<ParsedExpr> as expression; span; children!(
+ rule!(annotated_expression<ParsedSubExpr> as expression; span; children!(
[expression(e)] => e,
[expression(e), expression(annot)] => {
- spanned(span, Annot(rc(e), rc(annot)))
+ spanned(span, Annot(e, annot))
},
));
token_rule!(Some_<()>);
- rule!(application_expression<ParsedExpr> as expression; children!(
+ rule!(application_expression<ParsedSubExpr> as expression; children!(
[expression(e)] => e,
[expression(first), expression(rest)..] => {
- rest.fold(first, |acc, e| App(rc(acc), rc(e)))
+ rest.fold(first, |acc, e| unspanned(App(acc, e)))
},
));
- rule!(first_application_expression<ParsedExpr> as expression; span;
+ rule!(first_application_expression<ParsedSubExpr> as expression; span;
children!(
[expression(e)] => e,
[Some_(()), expression(e)] => {
- spanned(span, SomeLit(rc(e)))
+ spanned(span, SomeLit(e))
},
[merge(()), expression(x), expression(y)] => {
- spanned(span, Merge(rc(x), rc(y), None))
+ spanned(span, Merge(x, y, None))
},
));
- rule!(selector_expression<ParsedExpr> as expression; children!(
+ rule!(selector_expression<ParsedSubExpr> as expression; children!(
[expression(e)] => e,
[expression(first), selector(rest)..] => {
- rest.fold(first, |acc, e| match e {
- Either::Left(l) => Field(rc(acc), l),
- Either::Right(ls) => Projection(rc(acc), ls),
- })
+ rest.fold(first, |acc, e| unspanned(match e {
+ Either::Left(l) => Field(acc, l),
+ Either::Right(ls) => Projection(acc, ls),
+ }))
}
));
@@ -850,7 +848,7 @@ make_parser! {
[label(ls)..] => ls.collect(),
));
- rule!(primitive_expression<ParsedExpr> as expression; span; children!(
+ rule!(primitive_expression<ParsedSubExpr> as expression; span; children!(
[double_literal(n)] => spanned(span, DoubleLit(n)),
[natural_literal(n)] => spanned(span, NaturalLit(n)),
[integer_literal(n)] => spanned(span, IntegerLit(n)),
@@ -859,51 +857,51 @@ make_parser! {
[expression(e)] => e,
));
- rule!(empty_record_literal<ParsedExpr> as expression; span;
+ rule!(empty_record_literal<ParsedSubExpr> as expression; span;
captured_str!(_) => spanned(span, RecordLit(BTreeMap::new()))
);
- rule!(empty_record_type<ParsedExpr> as expression; span;
+ rule!(empty_record_type<ParsedSubExpr> as expression; span;
captured_str!(_) => spanned(span, RecordType(BTreeMap::new()))
);
- rule!(non_empty_record_type_or_literal<ParsedExpr> as expression; span;
+ rule!(non_empty_record_type_or_literal<ParsedSubExpr> as expression; span;
children!(
[label(first_label), non_empty_record_type(rest)] => {
let (first_expr, mut map) = rest;
- map.insert(first_label, rc(first_expr));
+ map.insert(first_label, first_expr);
spanned(span, RecordType(map))
},
[label(first_label), non_empty_record_literal(rest)] => {
let (first_expr, mut map) = rest;
- map.insert(first_label, rc(first_expr));
+ map.insert(first_label, first_expr);
spanned(span, RecordLit(map))
},
));
rule!(non_empty_record_type
- <(ParsedExpr, BTreeMap<Label, ParsedSubExpr>)>; children!(
+ <(ParsedSubExpr, BTreeMap<Label, ParsedSubExpr>)>; children!(
[expression(expr), record_type_entry(entries)..] => {
(expr, entries.collect())
}
));
rule!(record_type_entry<(Label, ParsedSubExpr)>; children!(
- [label(name), expression(expr)] => (name, rc(expr))
+ [label(name), expression(expr)] => (name, expr)
));
rule!(non_empty_record_literal
- <(ParsedExpr, BTreeMap<Label, ParsedSubExpr>)>; children!(
+ <(ParsedSubExpr, BTreeMap<Label, ParsedSubExpr>)>; children!(
[expression(expr), record_literal_entry(entries)..] => {
(expr, entries.collect())
}
));
rule!(record_literal_entry<(Label, ParsedSubExpr)>; children!(
- [label(name), expression(expr)] => (name, rc(expr))
+ [label(name), expression(expr)] => (name, expr)
));
- rule!(union_type_or_literal<ParsedExpr> as expression; span; children!(
+ rule!(union_type_or_literal<ParsedSubExpr> as expression; span; children!(
[empty_union_type(_)] => {
spanned(span, UnionType(BTreeMap::new()))
},
@@ -935,12 +933,12 @@ make_parser! {
<(ParsedSubExpr, BTreeMap<Label, Option<ParsedSubExpr>>)>;
children!(
[expression(e), union_type_entry(entries)..] => {
- (rc(e), entries.collect())
+ (e, entries.collect())
},
));
rule!(union_type_entry<(Label, Option<ParsedSubExpr>)>; children!(
- [label(name), expression(expr)] => (name, Some(rc(expr))),
+ [label(name), expression(expr)] => (name, Some(expr)),
[label(name)] => (name, None),
));
@@ -951,10 +949,10 @@ make_parser! {
BTreeMap<Label, Option<ParsedSubExpr>>))>;
children!(
[expression(e), non_empty_union_type_or_literal(rest)] => {
- (Some(rc(e)), rest)
+ (Some(e), rest)
},
[expression(e)] => {
- (Some(rc(e)), (None, BTreeMap::new()))
+ (Some(e), (None, BTreeMap::new()))
},
[non_empty_union_type_or_literal(rest)] => {
(None, rest)
@@ -964,15 +962,15 @@ make_parser! {
},
));
- rule!(non_empty_list_literal<ParsedExpr> as expression; span;
+ rule!(non_empty_list_literal<ParsedSubExpr> as expression; span;
children!(
[expression(items)..] => spanned(
span,
- NEListLit(items.map(rc).collect())
+ NEListLit(items.collect())
)
));
- rule!(final_expression<ParsedExpr> as expression; children!(
+ rule!(final_expression<ParsedSubExpr> as expression; children!(
[expression(e), EOI(_eoi)] => e
));
}
@@ -983,10 +981,10 @@ pub fn parse_expr<'a>(s: &'a str) -> ParseResult<ParsedSubExpr> {
let expr = do_parse(rc_input, pairs.next().unwrap())?;
assert_eq!(pairs.next(), None);
match expr {
- ParsedValue::expression(e) => Ok(rc(e)),
+ ParsedValue::expression(e) => Ok(e),
_ => unreachable!(),
}
- // Ok(rc(BoolLit(false)))
+ // Ok(BoolLit(false))
}
#[test]
diff --git a/dhall_syntax/src/visitor.rs b/dhall_syntax/src/visitor.rs
index cbaa21e..7fdf217 100644
--- a/dhall_syntax/src/visitor.rs
+++ b/dhall_syntax/src/visitor.rs
@@ -411,7 +411,7 @@ where
&mut self,
subexpr: &'a SubExpr<N, E>,
) -> Result<SubExpr<N, E2>, Self::Error> {
- Ok(rc(subexpr.as_ref().visit(&mut **self)?))
+ Ok(subexpr.rewrap(subexpr.as_ref().visit(&mut **self)?))
}
fn visit_embed(self, embed: &'a E) -> Result<E2, Self::Error> {
(self.0)(embed)
@@ -469,7 +469,8 @@ where
fn visit_resulting_exprf(
result: ExprF<Self::SE2, Self::L2, Self::E2>,
) -> Result<SubExpr<N, E2>, Self::Error> {
- Ok(rc(result))
+ // TODO: don't lose note
+ Ok(SubExpr::from_expr_no_note(result))
}
}
@@ -482,7 +483,7 @@ where
E: Clone + 'a,
{
fn visit_subexpr(&mut self, subexpr: &'a SubExpr<N, E>) -> SubExpr<X, E> {
- rc(subexpr.as_ref().visit(&mut **self))
+ SubExpr::from_expr_no_note(subexpr.as_ref().visit(&mut **self))
}
fn visit_embed(self, embed: &'a E) -> E {
E::clone(embed)
@@ -501,7 +502,7 @@ where
E: Clone + 'a,
{
fn visit_subexpr(&mut self, subexpr: &'a SubExpr<X, E>) -> SubExpr<N, E> {
- rc(subexpr.as_ref().visit(&mut **self))
+ SubExpr::from_expr_no_note(subexpr.as_ref().visit(&mut **self))
}
fn visit_embed(self, embed: &'a E) -> E {
E::clone(embed)
@@ -520,7 +521,7 @@ where
N: Clone + 'a,
{
fn visit_subexpr(&mut self, subexpr: &'a SubExpr<N, X>) -> SubExpr<N, E> {
- rc(subexpr.as_ref().visit(&mut **self))
+ subexpr.rewrap(subexpr.as_ref().visit(&mut **self))
}
fn visit_embed(self, embed: &'a X) -> E {
match *embed {}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 18:22:13 +0000