From a7363042a16364a6dafdd545f4069dcf04a4197e Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Tue, 27 Aug 2019 23:18:13 +0200 Subject: Rename SubExpr to Expr, and Expr to RawExpr For clarity, and consistency with Value --- dhall/src/core/value.rs | 8 ++--- dhall/src/core/valuef.rs | 6 ++-- dhall/src/error/mod.rs | 8 ++--- dhall/src/phase/binary.rs | 49 ++++++++++++++---------------- dhall/src/phase/mod.rs | 22 +++++++------- dhall/src/phase/resolve.rs | 4 +-- dhall/src/phase/typecheck.rs | 16 +++++----- dhall_syntax/src/core/expr.rs | 64 ++++++++++++++++++++-------------------- dhall_syntax/src/core/visitor.rs | 9 +++--- dhall_syntax/src/parser.rs | 64 ++++++++++++++++++++-------------------- dhall_syntax/src/printer.rs | 6 ++-- serde_dhall/src/lib.rs | 4 +-- serde_dhall/src/serde.rs | 4 +-- 13 files changed, 129 insertions(+), 135 deletions(-) diff --git a/dhall/src/core/value.rs b/dhall/src/core/value.rs index 21ac288..49e30cd 100644 --- a/dhall/src/core/value.rs +++ b/dhall/src/core/value.rs @@ -9,7 +9,7 @@ use crate::core::var::{AlphaVar, Shift, Subst}; use crate::error::{TypeError, TypeMessage}; use crate::phase::normalize::{apply_any, normalize_whnf}; use crate::phase::typecheck::{builtin_to_value, const_to_value}; -use crate::phase::{NormalizedSubExpr, Typed}; +use crate::phase::{NormalizedExpr, Typed}; #[derive(Debug, Clone, Copy)] pub(crate) enum Form { @@ -166,11 +166,11 @@ impl Value { } // TODO: rename `normalize_to_expr` - pub(crate) fn to_expr(&self) -> NormalizedSubExpr { + pub(crate) fn to_expr(&self) -> NormalizedExpr { self.as_whnf().normalize_to_expr() } // TODO: rename `normalize_to_expr_maybe_alpha` - pub(crate) fn to_expr_alpha(&self) -> NormalizedSubExpr { + pub(crate) fn to_expr_alpha(&self) -> NormalizedExpr { self.as_whnf().normalize_to_expr_maybe_alpha(true) } pub(crate) fn to_whnf_ignore_type(&self) -> ValueF { @@ -226,7 +226,7 @@ impl Value { pub(crate) fn normalize_to_expr_maybe_alpha( &self, alpha: bool, - ) -> NormalizedSubExpr { + ) -> NormalizedExpr { self.as_nf().normalize_to_expr_maybe_alpha(alpha) } diff --git a/dhall/src/core/valuef.rs b/dhall/src/core/valuef.rs index 9ea2467..959f299 100644 --- a/dhall/src/core/valuef.rs +++ b/dhall/src/core/valuef.rs @@ -7,7 +7,7 @@ use dhall_syntax::{ use crate::core::value::Value; use crate::core::var::{AlphaLabel, AlphaVar, Shift, Subst}; -use crate::phase::{Normalized, NormalizedSubExpr}; +use crate::phase::{Normalized, NormalizedExpr}; /// A semantic value. Subexpressions are Values, which are partially evaluated expressions that are /// normalized on-demand. @@ -52,7 +52,7 @@ impl ValueF { } /// Convert the value to a fully normalized syntactic expression - pub(crate) fn normalize_to_expr(&self) -> NormalizedSubExpr { + pub(crate) fn normalize_to_expr(&self) -> NormalizedExpr { self.normalize_to_expr_maybe_alpha(false) } /// Convert the value to a fully normalized syntactic expression. Also alpha-normalize @@ -60,7 +60,7 @@ impl ValueF { pub(crate) fn normalize_to_expr_maybe_alpha( &self, alpha: bool, - ) -> NormalizedSubExpr { + ) -> NormalizedExpr { match self { ValueF::Lam(x, t, e) => rc(ExprF::Lam( x.to_label_maybe_alpha(alpha), diff --git a/dhall/src/error/mod.rs b/dhall/src/error/mod.rs index 2ddaf3d..6d4e120 100644 --- a/dhall/src/error/mod.rs +++ b/dhall/src/error/mod.rs @@ -5,7 +5,7 @@ use dhall_syntax::{BinOp, Import, Label, ParseError, V}; use crate::core::context::TypecheckContext; use crate::core::value::Value; use crate::phase::resolve::ImportStack; -use crate::phase::NormalizedSubExpr; +use crate::phase::NormalizedExpr; pub type Result = std::result::Result; @@ -22,9 +22,9 @@ pub enum Error { #[derive(Debug)] pub enum ImportError { - Recursive(Import, Box), - UnexpectedImport(Import), - ImportCycle(ImportStack, Import), + Recursive(Import, Box), + UnexpectedImport(Import), + ImportCycle(ImportStack, Import), } #[derive(Debug)] diff --git a/dhall/src/phase/binary.rs b/dhall/src/phase/binary.rs index 3746635..7dc9be2 100644 --- a/dhall/src/phase/binary.rs +++ b/dhall/src/phase/binary.rs @@ -4,28 +4,26 @@ use std::iter::FromIterator; use dhall_syntax::map::DupTreeMap; use dhall_syntax::{ - rc, ExprF, FilePrefix, Hash, Import, ImportLocation, ImportMode, Integer, - InterpolatedText, Label, Natural, Scheme, SubExpr, URL, V, + rc, Expr, ExprF, FilePrefix, Hash, Import, ImportLocation, ImportMode, + Integer, InterpolatedText, Label, Natural, Scheme, URL, V, }; use crate::error::{DecodeError, EncodeError}; -use crate::phase::DecodedSubExpr; +use crate::phase::DecodedExpr; -pub(crate) fn decode(data: &[u8]) -> Result { +pub(crate) fn decode(data: &[u8]) -> Result { match serde_cbor::de::from_slice(data) { Ok(v) => cbor_value_to_dhall(&v), Err(e) => Err(DecodeError::CBORError(e)), } } -pub(crate) fn encode(expr: &SubExpr) -> Result, EncodeError> { +pub(crate) fn encode(expr: &Expr) -> Result, EncodeError> { serde_cbor::ser::to_vec(&Serialize::Expr(expr)) .map_err(|e| EncodeError::CBORError(e)) } -fn cbor_value_to_dhall( - data: &cbor::Value, -) -> Result { +fn cbor_value_to_dhall(data: &cbor::Value) -> Result { use cbor::Value::*; use dhall_syntax::{BinOp, Builtin, Const}; use ExprF::*; @@ -382,7 +380,7 @@ fn cbor_map_to_dhall_map<'a, T>( map: impl IntoIterator, ) -> Result where - T: FromIterator<(Label, DecodedSubExpr)>, + T: FromIterator<(Label, DecodedExpr)>, { map.into_iter() .map(|(k, v)| -> Result<(_, _), _> { @@ -399,7 +397,7 @@ fn cbor_map_to_dhall_opt_map<'a, T>( map: impl IntoIterator, ) -> Result where - T: FromIterator<(Label, Option)>, + T: FromIterator<(Label, Option)>, { map.into_iter() .map(|(k, v)| -> Result<(_, _), _> { @@ -416,10 +414,10 @@ where } enum Serialize<'a, E> { - Expr(&'a SubExpr), + Expr(&'a Expr), CBOR(cbor::Value), - RecordMap(&'a DupTreeMap>), - UnionMap(&'a DupTreeMap>>), + RecordMap(&'a DupTreeMap>), + UnionMap(&'a DupTreeMap>>), } macro_rules! count { @@ -439,7 +437,7 @@ macro_rules! ser_seq { }}; } -fn serialize_subexpr(ser: S, e: &SubExpr) -> Result +fn serialize_subexpr(ser: S, e: &Expr) -> Result where S: serde::ser::Serializer, { @@ -449,7 +447,7 @@ where use std::iter::once; use self::Serialize::{RecordMap, UnionMap}; - fn expr(x: &SubExpr) -> self::Serialize<'_, E> { + fn expr(x: &Expr) -> self::Serialize<'_, E> { self::Serialize::Expr(x) } let cbor = @@ -566,7 +564,7 @@ where fn serialize_import( ser: S, - import: &Import>, + import: &Import>, ) -> Result where S: serde::ser::Serializer, @@ -675,12 +673,9 @@ impl<'a, E> serde::ser::Serialize for Serialize<'a, E> { } fn collect_nested_applications<'a, E>( - e: &'a SubExpr, -) -> (&'a SubExpr, Vec<&'a SubExpr>) { - fn go<'a, E>( - e: &'a SubExpr, - vec: &mut Vec<&'a SubExpr>, - ) -> &'a SubExpr { + e: &'a Expr, +) -> (&'a Expr, Vec<&'a Expr>) { + fn go<'a, E>(e: &'a Expr, vec: &mut Vec<&'a Expr>) -> &'a Expr { match e.as_ref() { ExprF::App(f, a) => { vec.push(a); @@ -694,15 +689,15 @@ fn collect_nested_applications<'a, E>( (e, vec) } -type LetBinding<'a, E> = (&'a Label, &'a Option>, &'a SubExpr); +type LetBinding<'a, E> = (&'a Label, &'a Option>, &'a Expr); fn collect_nested_lets<'a, E>( - e: &'a SubExpr, -) -> (&'a SubExpr, Vec>) { + e: &'a Expr, +) -> (&'a Expr, Vec>) { fn go<'a, E>( - e: &'a SubExpr, + e: &'a Expr, vec: &mut Vec>, - ) -> &'a SubExpr { + ) -> &'a Expr { match e.as_ref() { ExprF::Let(l, t, v, e) => { vec.push((l, t, v)); diff --git a/dhall/src/phase/mod.rs b/dhall/src/phase/mod.rs index bd8853a..ecc9213 100644 --- a/dhall/src/phase/mod.rs +++ b/dhall/src/phase/mod.rs @@ -1,7 +1,7 @@ use std::fmt::Display; use std::path::Path; -use dhall_syntax::{Builtin, Const, SubExpr}; +use dhall_syntax::{Builtin, Const, Expr}; use crate::core::value::Value; use crate::core::valuef::ValueF; @@ -16,19 +16,19 @@ pub(crate) mod parse; pub(crate) mod resolve; pub(crate) mod typecheck; -pub type ParsedSubExpr = SubExpr; -pub type DecodedSubExpr = SubExpr; -pub type ResolvedSubExpr = SubExpr; -pub type NormalizedSubExpr = SubExpr; +pub type ParsedExpr = Expr; +pub type DecodedExpr = Expr; +pub type ResolvedExpr = Expr; +pub type NormalizedExpr = Expr; #[derive(Debug, Clone)] -pub struct Parsed(ParsedSubExpr, ImportRoot); +pub struct Parsed(ParsedExpr, ImportRoot); /// An expression where all imports have been resolved /// /// Invariant: there must be no `Import` nodes or `ImportAlt` operations left. #[derive(Debug, Clone)] -pub struct Resolved(ResolvedSubExpr); +pub struct Resolved(ResolvedExpr); /// A typed expression #[derive(Debug, Clone)] @@ -102,10 +102,10 @@ impl Typed { Typed::from_const(Const::Type) } - pub fn to_expr(&self) -> NormalizedSubExpr { + pub fn to_expr(&self) -> NormalizedExpr { self.0.to_expr() } - pub(crate) fn to_expr_alpha(&self) -> NormalizedSubExpr { + pub(crate) fn to_expr_alpha(&self) -> NormalizedExpr { self.0.to_expr_alpha() } pub(crate) fn to_value(&self) -> Value { @@ -162,10 +162,10 @@ impl Normalized { crate::phase::binary::encode(&self.to_expr()) } - pub(crate) fn to_expr(&self) -> NormalizedSubExpr { + pub(crate) fn to_expr(&self) -> NormalizedExpr { self.0.to_expr() } - pub(crate) fn to_expr_alpha(&self) -> NormalizedSubExpr { + pub(crate) fn to_expr_alpha(&self) -> NormalizedExpr { self.0.to_expr_alpha() } pub(crate) fn into_typed(self) -> Typed { diff --git a/dhall/src/phase/resolve.rs b/dhall/src/phase/resolve.rs index 27ae7a3..b715e72 100644 --- a/dhall/src/phase/resolve.rs +++ b/dhall/src/phase/resolve.rs @@ -2,9 +2,9 @@ use std::collections::HashMap; use std::path::{Path, PathBuf}; use crate::error::{Error, ImportError}; -use crate::phase::{Normalized, NormalizedSubExpr, Parsed, Resolved}; +use crate::phase::{Normalized, NormalizedExpr, Parsed, Resolved}; -type Import = dhall_syntax::Import; +type Import = dhall_syntax::Import; /// A root from which to resolve relative imports. #[derive(Debug, Clone, PartialEq, Eq)] diff --git a/dhall/src/phase/typecheck.rs b/dhall/src/phase/typecheck.rs index ab6d882..52a4e47 100644 --- a/dhall/src/phase/typecheck.rs +++ b/dhall/src/phase/typecheck.rs @@ -2,7 +2,7 @@ use std::cmp::max; use std::collections::HashMap; use dhall_syntax::{ - rc, Builtin, Const, Expr, ExprF, InterpolatedTextContents, Label, SubExpr, + rc, Builtin, Const, Expr, ExprF, InterpolatedTextContents, Label, }; use crate::core::context::TypecheckContext; @@ -200,7 +200,7 @@ macro_rules! make_type { fn type_of_builtin(b: Builtin) -> Expr { use dhall_syntax::Builtin::*; - match b { + rc(match b { Bool | Natural | Integer | Double | Text => make_type!(Type), List | Optional => make_type!( Type -> Type @@ -280,14 +280,14 @@ fn type_of_builtin(b: Builtin) -> Expr { OptionalNone => make_type!( forall (a: Type) -> Optional a ), - } + }) } pub(crate) fn builtin_to_value(b: Builtin) -> Value { let ctx = TypecheckContext::new(); Value::from_valuef_and_type( ValueF::from_builtin(b), - type_with(&ctx, rc(type_of_builtin(b))).unwrap(), + type_with(&ctx, type_of_builtin(b)).unwrap(), ) } @@ -297,7 +297,7 @@ pub(crate) fn builtin_to_value(b: Builtin) -> Value { /// normalized as well. fn type_with( ctx: &TypecheckContext, - e: SubExpr, + e: Expr, ) -> Result { use dhall_syntax::ExprF::{Annot, Embed, Lam, Let, Pi, Var}; @@ -791,13 +791,13 @@ fn type_last_layer( /// `type_of` is the same as `type_with` with an empty context, meaning that the /// expression must be closed (i.e. no free variables), otherwise type-checking /// will fail. -pub(crate) fn typecheck(e: SubExpr) -> Result { +pub(crate) fn typecheck(e: Expr) -> Result { type_with(&TypecheckContext::new(), e) } pub(crate) fn typecheck_with( - expr: SubExpr, - ty: SubExpr, + expr: Expr, + ty: Expr, ) -> Result { typecheck(expr.rewrap(ExprF::Annot(expr.clone(), ty))) } 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(Box<(Expr, Option)>); +pub struct Expr(Box<(RawExpr, Option)>); -impl std::cmp::PartialEq for SubExpr { +pub type RawExpr = ExprF, Embed>; + +impl std::cmp::PartialEq for Expr { fn eq(&self, other: &Self) -> bool { self.0.as_ref().0 == other.0.as_ref().0 } } -impl std::cmp::Eq for SubExpr {} +impl std::cmp::Eq for Expr {} -impl std::hash::Hash for SubExpr { +impl std::hash::Hash for Expr { fn hash(&self, state: &mut H) where H: std::hash::Hasher, @@ -187,8 +189,6 @@ impl std::hash::Hash for SubExpr { } } -pub type Expr = ExprF, 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 ExprF { } } -impl Expr { +impl RawExpr { pub fn traverse_resolve( &self, - visit_import: impl FnMut(&Import>) -> Result, - ) -> Result, Err> { + visit_import: impl FnMut(&Import>) -> Result, + ) -> Result, Err> { self.traverse_resolve_with_visitor(&mut visitor::ResolveVisitor( visit_import, )) @@ -323,9 +323,9 @@ impl Expr { pub(crate) fn traverse_resolve_with_visitor( &self, visitor: &mut visitor::ResolveVisitor, - ) -> Result, Err> + ) -> Result, Err> where - F1: FnMut(&Import>) -> Result, + F1: FnMut(&Import>) -> Result, { match self { ExprF::BinOp(BinOp::ImportAlt, l, r) => l @@ -343,52 +343,52 @@ impl Expr { } } -impl SubExpr { - pub fn as_ref(&self) -> &Expr { +impl Expr { + pub fn as_ref(&self) -> &RawExpr { &self.0.as_ref().0 } - pub fn new(x: Expr, n: Span) -> Self { - SubExpr(Box::new((x, Some(n)))) + pub fn new(x: RawExpr, n: Span) -> Self { + Expr(Box::new((x, Some(n)))) } - pub fn from_expr_no_span(x: Expr) -> Self { - SubExpr(Box::new((x, None))) + pub fn from_expr_no_span(x: RawExpr) -> 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(&self, x: Expr) -> SubExpr { - SubExpr(Box::new((x, (self.0).1.clone()))) + pub fn rewrap(&self, x: RawExpr) -> Expr { + Expr(Box::new((x, (self.0).1.clone()))) } } -impl SubExpr { +impl Expr { pub fn traverse_resolve( &self, - visit_import: impl FnMut(&Import>) -> Result, - ) -> Result, Err> { + visit_import: impl FnMut(&Import>) -> Result, + ) -> Result, Err> { Ok(self.rewrap(self.as_ref().traverse_resolve(visit_import)?)) } } // Should probably rename this -pub fn rc(x: Expr) -> SubExpr { - SubExpr::from_expr_no_span(x) +pub fn rc(x: RawExpr) -> Expr { + 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(pub F1); -impl<'a, 'b, E, E2, Err, F1> - ExprFFallibleVisitor<'a, SubExpr, SubExpr, E, E2> +impl<'a, 'b, E, E2, Err, F1> ExprFFallibleVisitor<'a, Expr, Expr, E, E2> for &'b mut ResolveVisitor where - F1: FnMut(&Import>) -> Result, + F1: FnMut(&Import>) -> Result, { type Error = Err; fn visit_subexpr( &mut self, - subexpr: &'a SubExpr, - ) -> Result, Self::Error> { + subexpr: &'a Expr, + ) -> Result, 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; -type ParsedTextContents = InterpolatedTextContents; +type ParsedText = InterpolatedText; +type ParsedTextContents = InterpolatedTextContents; pub type ParseError = pest::error::Error; @@ -551,7 +551,7 @@ make_parser! { rule!(escaped_interpolation<&'a str>; captured_str!(_) => "${" ); - rule!(interpolation; children!( + rule!(interpolation; children!( [expression(e)] => e )); @@ -593,7 +593,7 @@ make_parser! { }, )); - rule!(builtin; span; + rule!(builtin; span; captured_str!(s) => { spanned(span, match crate::Builtin::parse(s) { Some(b) => Builtin(b), @@ -650,7 +650,7 @@ make_parser! { } ); - rule!(identifier; span; children!( + rule!(identifier; span; children!( [variable(v)] => { spanned(span, Var(v)) }, @@ -708,7 +708,7 @@ make_parser! { _ => unreachable!(), }); - rule!(http_raw>; children!( + rule!(http_raw>; children!( [scheme(sch), authority(auth), path(p)] => URL { scheme: sch, authority: auth, @@ -729,7 +729,7 @@ make_parser! { rule!(query; captured_str!(s) => s.to_owned()); - rule!(http>; children!( + rule!(http>; 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>; children!( + rule!(import_type>; children!( [missing(_)] => { ImportLocation::Missing }, @@ -789,7 +789,7 @@ make_parser! { Hash::SHA256(hex::decode(hash).unwrap()) }); - rule!(import_hashed>; children!( + rule!(import_hashed>; 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; span; children!( + rule!(import; 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; span; children!( + rule!(empty_list_literal; span; children!( [application_expression(e)] => { spanned(span, EmptyListLit(e)) }, )); - rule!(expression; span; children!( + rule!(expression; 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)>; + rule!(let_binding<(Label, Option, 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; prec_climb!( + rule!(operator_expression; prec_climb!( application_expression, { use Rule::*; @@ -936,14 +936,14 @@ make_parser! { rule!(Some_<()>); rule!(toMap<()>); - rule!(application_expression; children!( + rule!(application_expression; 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; span; + rule!(first_application_expression; span; children!( [Some_(()), import_expression(e)] => { spanned(span, SomeLit(e)) @@ -954,13 +954,13 @@ make_parser! { [import_expression(e)] => e, )); - rule!(import_expression; span; + rule!(import_expression; span; children!( [selector_expression(e)] => e, [import(e)] => e, )); - rule!(selector_expression; children!( + rule!(selector_expression; 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; span; children!( + rule!(primitive_expression; 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; span; + rule!(empty_record_literal; span; captured_str!(_) => spanned(span, RecordLit(Default::default())) ); - rule!(empty_record_type; span; + rule!(empty_record_type; span; captured_str!(_) => spanned(span, RecordType(Default::default())) ); - rule!(non_empty_record_type_or_literal; span; + rule!(non_empty_record_type_or_literal; 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)>; children!( + <(ParsedExpr, DupTreeMap)>; 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)>; children!( + <(ParsedExpr, DupTreeMap)>; 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; span; children!( + rule!(union_type; 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)>; children!( + rule!(union_type_entry<(Label, Option)>; children!( [label(name), expression(expr)] => (name, Some(expr)), [label(name)] => (name, None), )); - rule!(non_empty_list_literal; span; + rule!(non_empty_list_literal; span; children!( [expression(items)..] => spanned( span, @@ -1063,12 +1063,12 @@ make_parser! { ) )); - rule!(final_expression; children!( + rule!(final_expression; children!( [expression(e), EOI(_)] => e )); } -pub fn parse_expr(s: &str) -> ParseResult { +pub fn parse_expr(s: &str) -> ParseResult { 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, PrintPhase); +struct PhasedExpr<'a, A>(&'a Expr, 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 Expr { +impl RawExpr { fn fmt_phase( &self, f: &mut fmt::Formatter, @@ -202,7 +202,7 @@ impl Expr { } } -impl Display for SubExpr { +impl Display for Expr { fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { self.as_ref().fmt_phase(f, PrintPhase::Base) } diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs index ce3468f..9fce42d 100644 --- a/serde_dhall/src/lib.rs +++ b/serde_dhall/src/lib.rs @@ -124,7 +124,7 @@ pub use value::Value; // A Dhall value. pub mod value { - use dhall::phase::{NormalizedSubExpr, Parsed, Typed}; + use dhall::phase::{NormalizedExpr, Parsed, Typed}; use dhall_syntax::Builtin; use super::de::{Error, Result}; @@ -148,7 +148,7 @@ pub mod value { }; Ok(Value(typed)) } - pub(crate) fn to_expr(&self) -> NormalizedSubExpr { + pub(crate) fn to_expr(&self) -> NormalizedExpr { self.0.to_expr() } pub(crate) fn as_typed(&self) -> &Typed { diff --git a/serde_dhall/src/serde.rs b/serde_dhall/src/serde.rs index 94b7e6c..26708c1 100644 --- a/serde_dhall/src/serde.rs +++ b/serde_dhall/src/serde.rs @@ -1,6 +1,6 @@ use std::borrow::Cow; -use dhall::phase::NormalizedSubExpr; +use dhall::phase::NormalizedExpr; use dhall_syntax::ExprF; use crate::de::{Deserialize, Error, Result}; @@ -15,7 +15,7 @@ where } } -struct Deserializer<'a>(Cow<'a, NormalizedSubExpr>); +struct Deserializer<'a>(Cow<'a, NormalizedExpr>); impl<'de: 'a, 'a> serde::de::IntoDeserializer<'de, Error> for Deserializer<'a> { type Deserializer = Deserializer<'a>; -- cgit v1.2.3