diff options
Diffstat (limited to '')
| -rw-r--r-- | dhall_generated_parser/Cargo.toml | 3 | ||||
| -rw-r--r-- | dhall_generated_parser/build.rs | 17 | ||||
| -rw-r--r-- | dhall_generated_parser/src/lib.rs | 7 | ||||
| -rw-r--r-- | dhall_proc_macros/src/lib.rs | 19 | ||||
| -rw-r--r-- | dhall_proc_macros/src/make_parser.rs | 334 | ||||
| -rw-r--r-- | dhall_proc_macros/src/parse_children.rs | 215 | ||||
| -rw-r--r-- | dhall_syntax/Cargo.toml | 1 | ||||
| -rw-r--r-- | dhall_syntax/src/core/expr.rs | 22 | ||||
| -rw-r--r-- | dhall_syntax/src/lib.rs | 2 | ||||
| -rw-r--r-- | dhall_syntax/src/parser.rs | 542 |
10 files changed, 241 insertions, 921 deletions
diff --git a/dhall_generated_parser/Cargo.toml b/dhall_generated_parser/Cargo.toml index 0730f60..b1f0d02 100644 --- a/dhall_generated_parser/Cargo.toml +++ b/dhall_generated_parser/Cargo.toml @@ -12,8 +12,7 @@ doctest = false [build-dependencies] abnf_to_pest = { version = "0.1.1", path = "../abnf_to_pest" } -pest_generator = "2.1" -quote = "1.0.2" [dependencies] pest = "2.1" +pest_derive = "2.1" diff --git a/dhall_generated_parser/build.rs b/dhall_generated_parser/build.rs index c562fad..68895dd 100644 --- a/dhall_generated_parser/build.rs +++ b/dhall_generated_parser/build.rs @@ -1,7 +1,5 @@ -use std::env; use std::fs::File; use std::io::{BufRead, BufReader, Read, Write}; -use std::path::Path; use abnf_to_pest::render_rules_to_pest; @@ -90,20 +88,5 @@ fn main() -> std::io::Result<()> { writeln!(&mut file)?; writeln!(&mut file, "{}", render_rules_to_pest(rules).pretty(80))?; - // Generate pest parser manually to avoid spurious recompilations - let derived = { - let pest_path = "dhall.pest"; - let pest = quote::quote! { - #[grammar = #pest_path] - pub struct DhallParser; - }; - pest_generator::derive_parser(pest, false) - }; - - let out_dir = env::var("OUT_DIR").unwrap(); - let grammar_path = Path::new(&out_dir).join("grammar.rs"); - let mut file = File::create(grammar_path)?; - writeln!(file, "pub struct DhallParser;\n{}", derived,)?; - Ok(()) } diff --git a/dhall_generated_parser/src/lib.rs b/dhall_generated_parser/src/lib.rs index 280b75e..fbb9ccd 100644 --- a/dhall_generated_parser/src/lib.rs +++ b/dhall_generated_parser/src/lib.rs @@ -14,4 +14,9 @@ // additional overrides are done in ../build.rs. // The lines that are commented out in ./dhall.pest.visibility are marked as // silent (see pest docs for what that means) in the generated pest file. -include!(concat!(env!("OUT_DIR"), "/grammar.rs")); + +use pest_derive::Parser; + +#[derive(Parser)] +#[grammar = "dhall.pest"] +pub struct DhallParser; diff --git a/dhall_proc_macros/src/lib.rs b/dhall_proc_macros/src/lib.rs index 37e8f9f..5304429 100644 --- a/dhall_proc_macros/src/lib.rs +++ b/dhall_proc_macros/src/lib.rs @@ -1,4 +1,3 @@ -#![feature(drain_filter)] //! This crate contains the code-generation primitives for the [dhall-rust][dhall-rust] crate. //! This is highly unstable and breaks regularly; use at your own risk. //! @@ -7,8 +6,6 @@ extern crate proc_macro; mod derive; -mod make_parser; -mod parse_children; use proc_macro::TokenStream; @@ -16,19 +13,3 @@ use proc_macro::TokenStream; pub fn derive_static_type(input: TokenStream) -> TokenStream { derive::derive_static_type(input) } - -#[proc_macro_attribute] -pub fn make_parser(attrs: TokenStream, input: TokenStream) -> TokenStream { - TokenStream::from(match make_parser::make_parser(attrs, input) { - Ok(tokens) => tokens, - Err(err) => err.to_compile_error(), - }) -} - -#[proc_macro] -pub fn parse_children(input: TokenStream) -> TokenStream { - TokenStream::from(match parse_children::parse_children(input) { - Ok(tokens) => tokens, - Err(err) => err.to_compile_error(), - }) -} diff --git a/dhall_proc_macros/src/make_parser.rs b/dhall_proc_macros/src/make_parser.rs deleted file mode 100644 index a17ab61..0000000 --- a/dhall_proc_macros/src/make_parser.rs +++ /dev/null @@ -1,334 +0,0 @@ -use std::collections::HashMap; -use std::iter; - -use quote::quote; -use syn::parse::{Parse, ParseStream, Result}; -use syn::spanned::Spanned; -use syn::{ - parse_quote, Error, Expr, FnArg, Ident, ImplItem, ImplItemMethod, ItemImpl, - LitBool, Pat, Token, -}; - -mod kw { - syn::custom_keyword!(shortcut); -} - -struct AliasArgs { - target: Ident, - is_shortcut: bool, -} - -struct PrecClimbArgs { - child_rule: Ident, - climber: Expr, -} - -struct AliasSrc { - ident: Ident, - is_shortcut: bool, -} - -struct ParsedFn<'a> { - // Body of the function - function: &'a mut ImplItemMethod, - // Name of the function. - fn_name: Ident, - // Name of the first argument of the function, which should be of type `ParseInput`. - input_arg: Ident, - // List of aliases pointing to this function - alias_srcs: Vec<AliasSrc>, -} - -impl Parse for AliasArgs { - fn parse(input: ParseStream) -> Result<Self> { - let target = input.parse()?; - let is_shortcut = if input.peek(Token![,]) { - // #[alias(rule, shortcut = true)] - let _: Token![,] = input.parse()?; - let _: kw::shortcut = input.parse()?; - let _: Token![=] = input.parse()?; - let b: LitBool = input.parse()?; - b.value - } else { - // #[alias(rule)] - false - }; - Ok(AliasArgs { - target, - is_shortcut, - }) - } -} - -impl Parse for PrecClimbArgs { - fn parse(input: ParseStream) -> Result<Self> { - let child_rule = input.parse()?; - let _: Token![,] = input.parse()?; - let climber = input.parse()?; - Ok(PrecClimbArgs { - child_rule, - climber, - }) - } -} - -fn collect_aliases( - imp: &mut ItemImpl, -) -> Result<HashMap<Ident, Vec<AliasSrc>>> { - let functions = imp.items.iter_mut().flat_map(|item| match item { - ImplItem::Method(m) => Some(m), - _ => None, - }); - - let mut alias_map = HashMap::new(); - for function in functions { - let fn_name = function.sig.ident.clone(); - let mut alias_attrs = function - .attrs - .drain_filter(|attr| attr.path.is_ident("alias")) - .collect::<Vec<_>>() - .into_iter(); - - if let Some(attr) = alias_attrs.next() { - let args: AliasArgs = attr.parse_args()?; - alias_map.entry(args.target).or_insert_with(Vec::new).push( - AliasSrc { - ident: fn_name, - is_shortcut: args.is_shortcut, - }, - ); - } - if let Some(attr) = alias_attrs.next() { - return Err(Error::new( - attr.span(), - "expected at most one alias attribute", - )); - } - } - - Ok(alias_map) -} - -fn parse_fn<'a>( - function: &'a mut ImplItemMethod, - alias_map: &mut HashMap<Ident, Vec<AliasSrc>>, -) -> Result<ParsedFn<'a>> { - let fn_name = function.sig.ident.clone(); - // Get the name of the first (`input`) function argument - let input_arg = function.sig.inputs.first().ok_or_else(|| { - Error::new( - function.sig.inputs.span(), - "a rule function needs an `input` argument", - ) - })?; - let input_arg = match &input_arg { - FnArg::Receiver(_) => return Err(Error::new( - input_arg.span(), - "a rule function should not have a `self` argument", - )), - FnArg::Typed(input_arg) => match &*input_arg.pat{ - Pat::Ident(ident) => ident.ident.clone(), - _ => return Err(Error::new( - input_arg.span(), - "this argument should be a plain identifier instead of a pattern", - )), - } - }; - - let alias_srcs = alias_map.remove(&fn_name).unwrap_or_else(Vec::new); - - Ok(ParsedFn { - function, - fn_name, - input_arg, - alias_srcs, - }) -} - -fn apply_special_attrs(f: &mut ParsedFn, rule_enum: &Ident) -> Result<()> { - let function = &mut *f.function; - let fn_name = &f.fn_name; - let input_arg = &f.input_arg; - - *function = parse_quote!( - #[allow(non_snake_case)] - #function - ); - - // `prec_climb` attr - let prec_climb_attrs: Vec<_> = function - .attrs - .drain_filter(|attr| attr.path.is_ident("prec_climb")) - .collect(); - - if prec_climb_attrs.len() > 1 { - return Err(Error::new( - prec_climb_attrs[1].span(), - "expected at most one prec_climb attribute", - )); - } else if prec_climb_attrs.is_empty() { - // do nothing - } else { - let attr = prec_climb_attrs.into_iter().next().unwrap(); - let PrecClimbArgs { - child_rule, - climber, - } = attr.parse_args()?; - - function.block = parse_quote!({ - #function - - #climber.climb( - #input_arg.pair.clone().into_inner(), - |p| Self::#child_rule(#input_arg.with_pair(p)), - |l, op, r| { - #fn_name(#input_arg.clone(), l?, op, r?) - }, - ) - }); - // Remove the 3 last arguments to keep only the `input` one - function.sig.inputs.pop(); - function.sig.inputs.pop(); - function.sig.inputs.pop(); - // Check that an argument remains - function.sig.inputs.first().ok_or_else(|| { - Error::new( - function.sig.inputs.span(), - "a prec_climb function needs 4 arguments", - ) - })?; - } - - // `alias` attr - if !f.alias_srcs.is_empty() { - let aliases = f.alias_srcs.iter().map(|src| &src.ident); - let block = &function.block; - function.block = parse_quote!({ - let mut #input_arg = #input_arg; - // While the current rule allows shortcutting, and there is a single child, and the - // child can still be parsed by the current function, then skip to that child. - while <Self as PestConsumer>::allows_shortcut(#input_arg.as_rule()) { - if let Some(child) = #input_arg.single_child() { - if &<Self as PestConsumer>::rule_alias(child.as_rule()) - == stringify!(#fn_name) { - #input_arg = child; - continue; - } - } - break - } - - match #input_arg.as_rule() { - #(#rule_enum::#aliases => Self::#aliases(#input_arg),)* - #rule_enum::#fn_name => #block, - r => unreachable!( - "make_parser: called {} on {:?}", - stringify!(#fn_name), - r - ) - } - }); - } - - Ok(()) -} - -pub fn make_parser( - attrs: proc_macro::TokenStream, - input: proc_macro::TokenStream, -) -> Result<proc_macro2::TokenStream> { - let rule_enum: Ident = syn::parse(attrs)?; - let mut imp: ItemImpl = syn::parse(input)?; - - let mut alias_map = collect_aliases(&mut imp)?; - let rule_alias_branches: Vec<_> = alias_map - .iter() - .flat_map(|(tgt, srcs)| iter::repeat(tgt).zip(srcs)) - .map(|(tgt, src)| { - let ident = &src.ident; - quote!( - #rule_enum::#ident => stringify!(#tgt).to_string(), - ) - }) - .collect(); - let shortcut_branches: Vec<_> = alias_map - .iter() - .flat_map(|(_tgt, srcs)| srcs) - .map(|AliasSrc { ident, is_shortcut }| { - quote!( - #rule_enum::#ident => #is_shortcut, - ) - }) - .collect(); - - let fn_map: HashMap<Ident, ParsedFn> = imp - .items - .iter_mut() - .flat_map(|item| match item { - ImplItem::Method(m) => Some(m), - _ => None, - }) - .map(|method| { - let mut f = parse_fn(method, &mut alias_map)?; - apply_special_attrs(&mut f, &rule_enum)?; - Ok((f.fn_name.clone(), f)) - }) - .collect::<Result<_>>()?; - - // Entries that remain in the alias map don't have a matching method, so we create one. - let extra_fns: Vec<_> = alias_map - .iter() - .map(|(tgt, srcs)| { - // Get the signature of one of the functions that has this alias. They should all have - // essentially the same signature anyways. - let f = fn_map.get(&srcs.first().unwrap().ident).unwrap(); - let input_arg = f.input_arg.clone(); - let mut sig = f.function.sig.clone(); - sig.ident = tgt.clone(); - let srcs = srcs.iter().map(|src| &src.ident); - - Ok(parse_quote!( - #sig { - match #input_arg.as_rule() { - #(#rule_enum::#srcs => Self::#srcs(#input_arg),)* - // We can't match on #rule_enum::#tgt since `tgt` might be an arbitrary - // identifier. - r if &format!("{:?}", r) == stringify!(#tgt) => - return Err(#input_arg.error(format!( - "make_parser: missing method for rule {}", - stringify!(#tgt), - ))), - r => unreachable!( - "make_parser: called {} on {:?}", - stringify!(#tgt), - r - ) - } - } - )) - }) - .collect::<Result<_>>()?; - imp.items.extend(extra_fns); - - let ty = &imp.self_ty; - let (impl_generics, _, where_clause) = imp.generics.split_for_impl(); - Ok(quote!( - impl #impl_generics PestConsumer for #ty #where_clause { - type Rule = #rule_enum; - fn rule_alias(rule: Self::Rule) -> String { - match rule { - #(#rule_alias_branches)* - r => format!("{:?}", r), - } - } - fn allows_shortcut(rule: Self::Rule) -> bool { - match rule { - #(#shortcut_branches)* - _ => false, - } - } - } - - #imp - )) -} diff --git a/dhall_proc_macros/src/parse_children.rs b/dhall_proc_macros/src/parse_children.rs deleted file mode 100644 index a35c03f..0000000 --- a/dhall_proc_macros/src/parse_children.rs +++ /dev/null @@ -1,215 +0,0 @@ -use proc_macro2::{Span, TokenStream}; -use quote::quote; -use syn::parse::{Parse, ParseStream, Result}; -use syn::punctuated::Punctuated; -use syn::spanned::Spanned; -use syn::{bracketed, parenthesized, token, Error, Expr, Ident, Pat, Token}; - -#[derive(Debug, Clone)] -struct ChildrenBranch { - pattern_span: Span, - pattern: Punctuated<ChildrenBranchPatternItem, Token![,]>, - body: Expr, -} - -#[derive(Debug, Clone)] -enum ChildrenBranchPatternItem { - Single { rule_name: Ident, binder: Pat }, - Multiple { rule_name: Ident, binder: Ident }, -} - -#[derive(Debug, Clone)] -struct ParseChildrenInput { - input_expr: Expr, - branches: Punctuated<ChildrenBranch, Token![,]>, -} - -impl Parse for ChildrenBranch { - fn parse(input: ParseStream) -> Result<Self> { - let contents; - let _: token::Bracket = bracketed!(contents in input); - let pattern_unparsed: TokenStream = contents.fork().parse()?; - let pattern_span = pattern_unparsed.span(); - let pattern = Punctuated::parse_terminated(&contents)?; - let _: Token![=>] = input.parse()?; - let body = input.parse()?; - - Ok(ChildrenBranch { - pattern_span, - pattern, - body, - }) - } -} - -impl Parse for ChildrenBranchPatternItem { - fn parse(input: ParseStream) -> Result<Self> { - let contents; - let rule_name = input.parse()?; - parenthesized!(contents in input); - if input.peek(Token![..]) { - let binder = contents.parse()?; - let _: Token![..] = input.parse()?; - Ok(ChildrenBranchPatternItem::Multiple { rule_name, binder }) - } else if input.is_empty() || input.peek(Token![,]) { - let binder = contents.parse()?; - Ok(ChildrenBranchPatternItem::Single { rule_name, binder }) - } else { - Err(input.error("expected `..` or nothing")) - } - } -} - -impl Parse for ParseChildrenInput { - fn parse(input: ParseStream) -> Result<Self> { - let input_expr = input.parse()?; - let _: Token![;] = input.parse()?; - let branches = Punctuated::parse_terminated(input)?; - - Ok(ParseChildrenInput { - input_expr, - branches, - }) - } -} - -fn make_parser_branch( - branch: &ChildrenBranch, - i_inputs: &Ident, -) -> Result<TokenStream> { - use ChildrenBranchPatternItem::{Multiple, Single}; - - let body = &branch.body; - - // Convert the input pattern into a pattern-match on the Rules of the children. This uses - // slice_patterns. - // A single pattern just checks that the rule matches; a variable-length pattern binds the - // subslice and checks, in the if-guard, that its elements all match the chosen Rule. - let i_variable_pattern = - Ident::new("___variable_pattern", Span::call_site()); - let match_pat = branch.pattern.iter().map(|item| match item { - Single { rule_name, .. } => quote!(stringify!(#rule_name)), - Multiple { .. } => quote!(#i_variable_pattern @ ..), - }); - let match_filter = branch.pattern.iter().map(|item| match item { - Single { .. } => quote!(), - Multiple { rule_name, .. } => quote!( - { - // We can't use .all() directly in the pattern guard; see - // https://github.com/rust-lang/rust/issues/59803. - let all_match = |slice: &[_]| { - slice.iter().all(|r| - *r == stringify!(#rule_name) - ) - }; - all_match(#i_variable_pattern) - } && - ), - }); - - // Once we have found a branch that matches, we need to parse the children. - let mut singles_before_multiple = Vec::new(); - let mut multiple = None; - let mut singles_after_multiple = Vec::new(); - for item in &branch.pattern { - match item { - Single { - rule_name, binder, .. - } => { - if multiple.is_none() { - singles_before_multiple.push((rule_name, binder)) - } else { - singles_after_multiple.push((rule_name, binder)) - } - } - Multiple { - rule_name, binder, .. - } => { - if multiple.is_none() { - multiple = Some((rule_name, binder)) - } else { - return Err(Error::new( - branch.pattern_span.clone(), - "multiple variable-length patterns are not allowed", - )); - } - } - } - } - let mut parses = Vec::new(); - for (rule_name, binder) in singles_before_multiple.into_iter() { - parses.push(quote!( - let #binder = Self::#rule_name( - #i_inputs.next().unwrap() - )?; - )) - } - // Note the `rev()`: we are taking inputs from the end of the iterator in reverse order, so that - // only the unmatched inputs are left for the variable-length pattern, if any. - for (rule_name, binder) in singles_after_multiple.into_iter().rev() { - parses.push(quote!( - let #binder = Self::#rule_name( - #i_inputs.next_back().unwrap() - )?; - )) - } - if let Some((rule_name, binder)) = multiple { - parses.push(quote!( - let #binder = #i_inputs - .map(|i| Self::#rule_name(i)) - .collect::<Result<Vec<_>, _>>()? - .into_iter(); - )) - } - - Ok(quote!( - [#(#match_pat),*] if #(#match_filter)* true => { - #(#parses)* - #body - } - )) -} - -pub fn parse_children( - input: proc_macro::TokenStream, -) -> Result<proc_macro2::TokenStream> { - let input: ParseChildrenInput = syn::parse(input)?; - - let i_children_rules = Ident::new("___children_rules", Span::call_site()); - let i_inputs = Ident::new("___inputs", Span::call_site()); - - let input_expr = &input.input_expr; - let branches = input - .branches - .iter() - .map(|br| make_parser_branch(br, &i_inputs)) - .collect::<Result<Vec<_>>>()?; - - Ok(quote!({ - let #i_children_rules: Vec<_> = #input_expr.pair - .clone() - .into_inner() - .map(|p| p.as_rule()) - .map(<Self as PestConsumer>::rule_alias) - .collect(); - let #i_children_rules: Vec<&str> = #i_children_rules - .iter() - .map(String::as_str) - .collect(); - - #[allow(unused_mut)] - let mut #i_inputs = #input_expr - .pair - .clone() - .into_inner() - .map(|p| #input_expr.with_pair(p)); - - #[allow(unreachable_code)] - match #i_children_rules.as_slice() { - #(#branches,)* - [..] => return Err(#input_expr.error( - format!("Unexpected children: {:?}", #i_children_rules) - )), - } - })) -} diff --git a/dhall_syntax/Cargo.toml b/dhall_syntax/Cargo.toml index eb492d0..b98c4a4 100644 --- a/dhall_syntax/Cargo.toml +++ b/dhall_syntax/Cargo.toml @@ -18,3 +18,4 @@ hex = "0.3.2" lazy_static = "1.4.0" dhall_generated_parser = { path = "../dhall_generated_parser" } dhall_proc_macros = { path = "../dhall_proc_macros" } +pest_consume = "1.0" diff --git a/dhall_syntax/src/core/expr.rs b/dhall_syntax/src/core/expr.rs index 2cb23c9..74b481f 100644 --- a/dhall_syntax/src/core/expr.rs +++ b/dhall_syntax/src/core/expr.rs @@ -37,6 +37,16 @@ impl Span { end: sp.end(), } } + /// Takes the union of the two spans. Assumes that the spans come from the same input. + /// This will also capture any input between the spans. + pub fn union(&self, other: &Span) -> Self { + use std::cmp::{max, min}; + Span { + input: self.input.clone(), + start: min(self.start, other.start), + end: max(self.start, other.start), + } + } } /// Double with bitwise equality @@ -324,8 +334,11 @@ impl<E> Expr<E> { pub fn as_mut(&mut self) -> &mut RawExpr<E> { &mut self.0.as_mut().0 } + pub fn span(&self) -> Option<Span> { + self.0.as_ref().1.clone() + } - pub fn new(x: RawExpr<E>, n: Span) -> Self { + pub(crate) fn new(x: RawExpr<E>, n: Span) -> Self { Expr(Box::new((x, Some(n)))) } @@ -384,13 +397,6 @@ pub fn rc<E>(x: RawExpr<E>) -> Expr<E> { Expr::from_expr_no_span(x) } -pub(crate) fn spanned<E>(span: Span, x: RawExpr<E>) -> Expr<E> { - Expr::new(x, span) -} -pub(crate) fn unspanned<E>(x: RawExpr<E>) -> Expr<E> { - Expr::from_expr_no_span(x) -} - /// Add an isize to an usize /// Panics on over/underflow fn add_ui(u: usize, i: isize) -> Option<usize> { diff --git a/dhall_syntax/src/lib.rs b/dhall_syntax/src/lib.rs index 95f40c2..b8fa19f 100644 --- a/dhall_syntax/src/lib.rs +++ b/dhall_syntax/src/lib.rs @@ -1,7 +1,5 @@ #![feature(trace_macros)] -#![feature(slice_patterns)] #![feature(never_type)] -#![feature(proc_macro_hygiene)] #![allow( clippy::many_single_char_names, clippy::should_implement_trait, diff --git a/dhall_syntax/src/parser.rs b/dhall_syntax/src/parser.rs index 3f961e8..71fab0f 100644 --- a/dhall_syntax/src/parser.rs +++ b/dhall_syntax/src/parser.rs @@ -1,13 +1,11 @@ use itertools::Itertools; -use pest::iterators::Pair; use pest::prec_climber as pcl; use pest::prec_climber::PrecClimber; -use pest::Parser; -use std::borrow::Cow; use std::rc::Rc; -use dhall_generated_parser::{DhallParser, Rule}; -use dhall_proc_macros::{make_parser, parse_children}; +use dgp::Rule; +use dhall_generated_parser as dgp; +use pest_consume::{match_nodes, Parser}; use crate::map::{DupTreeMap, DupTreeSet}; use crate::ExprF::*; @@ -20,115 +18,11 @@ use crate::*; type ParsedText<E> = InterpolatedText<Expr<E>>; type ParsedTextContents<E> = InterpolatedTextContents<Expr<E>>; +type ParseInput<'input> = pest_consume::Node<'input, Rule, Rc<str>>; pub type ParseError = pest::error::Error<Rule>; - pub type ParseResult<T> = Result<T, ParseError>; -#[derive(Debug, Clone)] -struct ParseInput<'input, Rule> -where - Rule: pest::RuleType, -{ - pair: Pair<'input, Rule>, - original_input_str: Rc<str>, -} - -impl<'input> ParseInput<'input, Rule> { - fn error(&self, message: String) -> ParseError { - let message = format!( - "{} while matching on:\n{}", - message, - debug_pair(self.pair.clone()) - ); - let e = pest::error::ErrorVariant::CustomError { message }; - pest::error::Error::new_from_span(e, self.pair.as_span()) - } - fn parse(input_str: &'input str, rule: Rule) -> ParseResult<Self> { - let mut pairs = DhallParser::parse(rule, input_str)?; - // TODO: proper errors - let pair = pairs.next().unwrap(); - assert_eq!(pairs.next(), None); - Ok(ParseInput { - original_input_str: input_str.to_string().into(), - pair, - }) - } - fn with_pair(&self, new_pair: Pair<'input, Rule>) -> Self { - ParseInput { - pair: new_pair, - original_input_str: self.original_input_str.clone(), - } - } - /// If the contained pair has exactly one child, return a new Self containing it. - fn single_child(&self) -> Option<Self> { - let mut children = self.pair.clone().into_inner(); - if let Some(child) = children.next() { - if children.next().is_none() { - return Some(self.with_pair(child)); - } - } - None - } - fn as_span(&self) -> Span { - Span::make(self.original_input_str.clone(), self.pair.as_span()) - } - fn as_str(&self) -> &'input str { - self.pair.as_str() - } - fn as_rule(&self) -> Rule { - self.pair.as_rule() - } -} - -// Used by the macros. -trait PestConsumer { - type Rule: pest::RuleType; - fn rule_alias(rule: Self::Rule) -> String; - fn allows_shortcut(rule: Self::Rule) -> bool; -} - -fn debug_pair(pair: Pair<Rule>) -> String { - use std::fmt::Write; - let mut s = String::new(); - fn aux(s: &mut String, indent: usize, prefix: String, pair: Pair<Rule>) { - let indent_str = "| ".repeat(indent); - let rule = pair.as_rule(); - let contents = pair.as_str(); - let mut inner = pair.into_inner(); - let mut first = true; - while let Some(p) = inner.next() { - if first { - first = false; - let last = inner.peek().is_none(); - if last && p.as_str() == contents { - let prefix = format!("{}{:?} > ", prefix, rule); - aux(s, indent, prefix, p); - continue; - } else { - writeln!( - s, - r#"{}{}{:?}: "{}""#, - indent_str, prefix, rule, contents - ) - .unwrap(); - } - } - aux(s, indent + 1, "".into(), p); - } - if first { - writeln!( - s, - r#"{}{}{:?}: "{}""#, - indent_str, prefix, rule, contents - ) - .unwrap(); - } - } - aux(&mut s, 0, "".into(), pair); - s -} - #[derive(Debug)] enum Either<A, B> { Left(A), @@ -173,6 +67,16 @@ impl crate::Builtin { } } +fn input_to_span(input: ParseInput) -> Span { + Span::make(input.user_data().clone(), input.as_pair().as_span()) +} +fn spanned<E>(input: ParseInput, x: RawExpr<E>) -> Expr<E> { + Expr::new(x, input_to_span(input)) +} +fn spanned_union<E>(span1: Span, span2: Span, x: RawExpr<E>) -> Expr<E> { + Expr::new(x, span1.union(&span2)) +} + // Trim the shared indent off of a vec of lines, as defined by the Dhall semantics of multiline // literals. fn trim_indent<E: Clone>(lines: &mut Vec<ParsedText<E>>) { @@ -242,27 +146,27 @@ lazy_static::lazy_static! { }; } -struct Parsers; +struct DhallParser; -#[make_parser(Rule)] -impl Parsers { - fn EOI(_input: ParseInput<Rule>) -> ParseResult<()> { +#[pest_consume::parser(parser = dgp::DhallParser, rule = dgp::Rule)] +impl DhallParser { + fn EOI(_input: ParseInput) -> ParseResult<()> { Ok(()) } #[alias(label)] - fn simple_label(input: ParseInput<Rule>) -> ParseResult<Label> { + fn simple_label(input: ParseInput) -> ParseResult<Label> { Ok(Label::from(input.as_str())) } #[alias(label)] - fn quoted_label(input: ParseInput<Rule>) -> ParseResult<Label> { + fn quoted_label(input: ParseInput) -> ParseResult<Label> { Ok(Label::from(input.as_str())) } fn double_quote_literal<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<ParsedText<E>> { - Ok(parse_children!(input; + Ok(match_nodes!(input.into_children(); [double_quote_chunk(chunks)..] => { chunks.collect() } @@ -270,9 +174,9 @@ impl Parsers { } fn double_quote_chunk<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<ParsedTextContents<E>> { - Ok(parse_children!(input; + Ok(match_nodes!(input.into_children(); [expression(e)] => { InterpolatedTextContents::Expr(e) }, @@ -282,7 +186,7 @@ impl Parsers { )) } #[alias(double_quote_char)] - fn double_quote_escaped(input: ParseInput<Rule>) -> ParseResult<String> { + fn double_quote_escaped(input: ParseInput) -> ParseResult<String> { Ok(match input.as_str() { "\"" => "\"".to_owned(), "$" => "$".to_owned(), @@ -352,16 +256,14 @@ impl Parsers { } }) } - fn double_quote_char<'a>( - input: ParseInput<'a, Rule>, - ) -> ParseResult<String> { + fn double_quote_char(input: ParseInput) -> ParseResult<String> { Ok(input.as_str().to_owned()) } fn single_quote_literal<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<ParsedText<E>> { - Ok(parse_children!(input; + Ok(match_nodes!(input.into_children(); [single_quote_continue(lines)] => { let newline: ParsedText<E> = "\n".to_string().into(); @@ -382,29 +284,23 @@ impl Parsers { } )) } - fn single_quote_char<'a>( - input: ParseInput<'a, Rule>, - ) -> ParseResult<&'a str> { + fn single_quote_char(input: ParseInput) -> ParseResult<&str> { Ok(input.as_str()) } #[alias(single_quote_char)] - fn escaped_quote_pair<'a>( - _input: ParseInput<'a, Rule>, - ) -> ParseResult<&'a str> { + fn escaped_quote_pair(_input: ParseInput) -> ParseResult<&str> { Ok("''") } #[alias(single_quote_char)] - fn escaped_interpolation<'a>( - _input: ParseInput<'a, Rule>, - ) -> ParseResult<&'a str> { + fn escaped_interpolation(_input: ParseInput) -> ParseResult<&str> { Ok("${") } // Returns a vec of lines in reversed order, where each line is also in reversed order. fn single_quote_continue<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<Vec<Vec<ParsedTextContents<E>>>> { - Ok(parse_children!(input; + Ok(match_nodes!(input.into_children(); [expression(e), single_quote_continue(lines)] => { let c = InterpolatedTextContents::Expr(e); let mut lines = lines; @@ -429,7 +325,7 @@ impl Parsers { } #[alias(expression)] - fn builtin<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> { + fn builtin<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> { let s = input.as_str(); let e = match crate::Builtin::parse(s) { Some(b) => Builtin(b), @@ -442,30 +338,24 @@ impl Parsers { _ => Err(input.error(format!("Unrecognized builtin: '{}'", s)))?, }, }; - Ok(spanned(input.as_span(), e)) + Ok(spanned(input, e)) } #[alias(double_literal)] - fn NaN(_input: ParseInput<Rule>) -> ParseResult<core::Double> { + fn NaN(_input: ParseInput) -> ParseResult<core::Double> { Ok(std::f64::NAN.into()) } #[alias(double_literal)] - fn minus_infinity_literal( - _input: ParseInput<Rule>, - ) -> ParseResult<core::Double> { + fn minus_infinity_literal(_input: ParseInput) -> ParseResult<core::Double> { Ok(std::f64::NEG_INFINITY.into()) } #[alias(double_literal)] - fn plus_infinity_literal( - _input: ParseInput<Rule>, - ) -> ParseResult<core::Double> { + fn plus_infinity_literal(_input: ParseInput) -> ParseResult<core::Double> { Ok(std::f64::INFINITY.into()) } #[alias(double_literal)] - fn numeric_double_literal( - input: ParseInput<Rule>, - ) -> ParseResult<core::Double> { + fn numeric_double_literal(input: ParseInput) -> ParseResult<core::Double> { let s = input.as_str().trim(); match s.parse::<f64>() { Ok(x) if x.is_infinite() => Err(input.error(format!( @@ -477,7 +367,7 @@ impl Parsers { } } - fn natural_literal(input: ParseInput<Rule>) -> ParseResult<core::Natural> { + fn natural_literal(input: ParseInput) -> ParseResult<core::Natural> { input .as_str() .trim() @@ -485,7 +375,7 @@ impl Parsers { .map_err(|e| input.error(format!("{}", e))) } - fn integer_literal(input: ParseInput<Rule>) -> ParseResult<core::Integer> { + fn integer_literal(input: ParseInput) -> ParseResult<core::Integer> { input .as_str() .trim() @@ -494,36 +384,26 @@ impl Parsers { } #[alias(expression, shortcut = true)] - fn identifier<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> { - Ok(parse_children!(input; - [variable(v)] => { - spanned(input.as_span(), Var(v)) - }, + fn identifier<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> { + Ok(match_nodes!(input.children(); + [variable(v)] => spanned(input, Var(v)), [expression(e)] => e, )) } - fn variable(input: ParseInput<Rule>) -> ParseResult<V<Label>> { - Ok(parse_children!(input; - [label(l), natural_literal(idx)] => { - V(l, idx) - }, - [label(l)] => { - V(l, 0) - }, + fn variable(input: ParseInput) -> ParseResult<V<Label>> { + Ok(match_nodes!(input.into_children(); + [label(l), natural_literal(idx)] => V(l, idx), + [label(l)] => V(l, 0), )) } #[alias(path_component)] - fn unquoted_path_component<'a>( - input: ParseInput<'a, Rule>, - ) -> ParseResult<String> { + fn unquoted_path_component(input: ParseInput) -> ParseResult<String> { Ok(input.as_str().to_string()) } #[alias(path_component)] - fn quoted_path_component<'a>( - input: ParseInput<'a, Rule>, - ) -> ParseResult<String> { + fn quoted_path_component(input: ParseInput) -> ParseResult<String> { #[rustfmt::skip] const RESERVED: &percent_encoding::AsciiSet = &percent_encoding::CONTROLS @@ -549,8 +429,8 @@ impl Parsers { }) .collect()) } - fn path(input: ParseInput<Rule>) -> ParseResult<Vec<String>> { - Ok(parse_children!(input; + fn path(input: ParseInput) -> ParseResult<Vec<String>> { + Ok(match_nodes!(input.into_children(); [path_component(components)..] => { components.collect() } @@ -559,47 +439,43 @@ impl Parsers { #[alias(import_type)] fn local<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<ImportLocation<Expr<E>>> { - Ok(parse_children!(input; + Ok(match_nodes!(input.into_children(); [local_path((prefix, p))] => ImportLocation::Local(prefix, p), )) } #[alias(local_path)] fn parent_path( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<(FilePrefix, Vec<String>)> { - Ok(parse_children!(input; + Ok(match_nodes!(input.into_children(); [path(p)] => (FilePrefix::Parent, p) )) } #[alias(local_path)] - fn here_path( - input: ParseInput<Rule>, - ) -> ParseResult<(FilePrefix, Vec<String>)> { - Ok(parse_children!(input; + fn here_path(input: ParseInput) -> ParseResult<(FilePrefix, Vec<String>)> { + Ok(match_nodes!(input.into_children(); [path(p)] => (FilePrefix::Here, p) )) } #[alias(local_path)] - fn home_path( - input: ParseInput<Rule>, - ) -> ParseResult<(FilePrefix, Vec<String>)> { - Ok(parse_children!(input; + fn home_path(input: ParseInput) -> ParseResult<(FilePrefix, Vec<String>)> { + Ok(match_nodes!(input.into_children(); [path(p)] => (FilePrefix::Home, p) )) } #[alias(local_path)] fn absolute_path( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<(FilePrefix, Vec<String>)> { - Ok(parse_children!(input; + Ok(match_nodes!(input.into_children(); [path(p)] => (FilePrefix::Absolute, p) )) } - fn scheme(input: ParseInput<Rule>) -> ParseResult<Scheme> { + fn scheme(input: ParseInput) -> ParseResult<Scheme> { Ok(match input.as_str() { "http" => Scheme::HTTP, "https" => Scheme::HTTPS, @@ -607,10 +483,8 @@ impl Parsers { }) } - fn http_raw<E: Clone>( - input: ParseInput<Rule>, - ) -> ParseResult<URL<Expr<E>>> { - Ok(parse_children!(input; + fn http_raw<E: Clone>(input: ParseInput) -> ParseResult<URL<Expr<E>>> { + Ok(match_nodes!(input.into_children(); [scheme(sch), authority(auth), path(p)] => URL { scheme: sch, authority: auth, @@ -628,19 +502,19 @@ impl Parsers { )) } - fn authority(input: ParseInput<Rule>) -> ParseResult<String> { + fn authority(input: ParseInput) -> ParseResult<String> { Ok(input.as_str().to_owned()) } - fn query(input: ParseInput<Rule>) -> ParseResult<String> { + fn query(input: ParseInput) -> ParseResult<String> { Ok(input.as_str().to_owned()) } #[alias(import_type)] fn http<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<ImportLocation<Expr<E>>> { - Ok(ImportLocation::Remote(parse_children!(input; + Ok(ImportLocation::Remote(match_nodes!(input.into_children(); [http_raw(url)] => url, [http_raw(url), expression(e)] => URL { headers: Some(e), ..url }, ))) @@ -648,53 +522,49 @@ impl Parsers { #[alias(import_type)] fn env<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<ImportLocation<Expr<E>>> { - Ok(parse_children!(input; + Ok(match_nodes!(input.into_children(); [environment_variable(v)] => ImportLocation::Env(v), )) } #[alias(environment_variable)] - fn bash_environment_variable( - input: ParseInput<Rule>, - ) -> ParseResult<String> { + fn bash_environment_variable(input: ParseInput) -> ParseResult<String> { Ok(input.as_str().to_owned()) } #[alias(environment_variable)] - fn posix_environment_variable( - input: ParseInput<Rule>, - ) -> ParseResult<String> { - Ok(parse_children!(input; + fn posix_environment_variable(input: ParseInput) -> ParseResult<String> { + Ok(match_nodes!(input.into_children(); [posix_environment_variable_character(chars)..] => { chars.collect() }, )) } - fn posix_environment_variable_character<'a>( - input: ParseInput<'a, Rule>, - ) -> ParseResult<Cow<'a, str>> { + fn posix_environment_variable_character( + input: ParseInput, + ) -> ParseResult<&str> { Ok(match input.as_str() { - "\\\"" => Cow::Owned("\"".to_owned()), - "\\\\" => Cow::Owned("\\".to_owned()), - "\\a" => Cow::Owned("\u{0007}".to_owned()), - "\\b" => Cow::Owned("\u{0008}".to_owned()), - "\\f" => Cow::Owned("\u{000C}".to_owned()), - "\\n" => Cow::Owned("\n".to_owned()), - "\\r" => Cow::Owned("\r".to_owned()), - "\\t" => Cow::Owned("\t".to_owned()), - "\\v" => Cow::Owned("\u{000B}".to_owned()), - s => Cow::Borrowed(s), + "\\\"" => "\"", + "\\\\" => "\\", + "\\a" => "\u{0007}", + "\\b" => "\u{0008}", + "\\f" => "\u{000C}", + "\\n" => "\n", + "\\r" => "\r", + "\\t" => "\t", + "\\v" => "\u{000B}", + s => s, }) } #[alias(import_type)] fn missing<E: Clone>( - _input: ParseInput<Rule>, + _input: ParseInput, ) -> ParseResult<ImportLocation<Expr<E>>> { Ok(ImportLocation::Missing) } - fn hash(input: ParseInput<Rule>) -> ParseResult<Hash> { + fn hash(input: ParseInput) -> ParseResult<Hash> { let s = input.as_str().trim(); let protocol = &s[..6]; let hash = &s[7..]; @@ -705,29 +575,29 @@ impl Parsers { } fn import_hashed<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<crate::Import<Expr<E>>> { use crate::Import; let mode = ImportMode::Code; - Ok(parse_children!(input; + Ok(match_nodes!(input.into_children(); [import_type(location)] => Import { mode, location, hash: None }, [import_type(location), hash(h)] => Import { mode, location, hash: Some(h) }, )) } #[alias(import_mode)] - fn Text(_input: ParseInput<Rule>) -> ParseResult<ImportMode> { + fn Text(_input: ParseInput) -> ParseResult<ImportMode> { Ok(ImportMode::RawText) } #[alias(import_mode)] - fn Location(_input: ParseInput<Rule>) -> ParseResult<ImportMode> { + fn Location(_input: ParseInput) -> ParseResult<ImportMode> { Ok(ImportMode::Location) } #[alias(expression)] - fn import<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> { + fn import<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> { use crate::Import; - let import = parse_children!(input; + let import = match_nodes!(input.children(); [import_hashed(imp)] => { Import { mode: ImportMode::Code, ..imp } }, @@ -735,97 +605,99 @@ impl Parsers { Import { mode, ..imp } }, ); - Ok(spanned(input.as_span(), Import(import))) + Ok(spanned(input, Import(import))) } - fn lambda(_input: ParseInput<Rule>) -> ParseResult<()> { + fn lambda(_input: ParseInput) -> ParseResult<()> { Ok(()) } - fn forall(_input: ParseInput<Rule>) -> ParseResult<()> { + fn forall(_input: ParseInput) -> ParseResult<()> { Ok(()) } - fn arrow(_input: ParseInput<Rule>) -> ParseResult<()> { + fn arrow(_input: ParseInput) -> ParseResult<()> { Ok(()) } - fn merge(_input: ParseInput<Rule>) -> ParseResult<()> { + fn merge(_input: ParseInput) -> ParseResult<()> { Ok(()) } - fn assert(_input: ParseInput<Rule>) -> ParseResult<()> { + fn assert(_input: ParseInput) -> ParseResult<()> { Ok(()) } - fn if_(_input: ParseInput<Rule>) -> ParseResult<()> { + fn if_(_input: ParseInput) -> ParseResult<()> { Ok(()) } - fn toMap(_input: ParseInput<Rule>) -> ParseResult<()> { + fn toMap(_input: ParseInput) -> ParseResult<()> { Ok(()) } #[alias(expression)] - fn empty_list_literal<E: Clone>( - input: ParseInput<Rule>, - ) -> ParseResult<Expr<E>> { - Ok(parse_children!(input; - [expression(e)] => spanned(input.as_span(), EmptyListLit(e)), + fn empty_list_literal<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> { + Ok(match_nodes!(input.children(); + [expression(e)] => spanned(input, EmptyListLit(e)), )) } - fn expression<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> { - let span = input.as_span(); - Ok(parse_children!(input; + fn expression<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> { + Ok(match_nodes!(input.children(); [lambda(()), label(l), expression(typ), arrow(()), expression(body)] => { - spanned(span, Lam(l, typ, body)) + spanned(input, Lam(l, typ, body)) }, [if_(()), expression(cond), expression(left), expression(right)] => { - spanned(span, BoolIf(cond, left, right)) + spanned(input, BoolIf(cond, left, right)) }, [let_binding(bindings).., expression(final_expr)] => { bindings.rev().fold( final_expr, - |acc, x| unspanned(Let(x.0, x.1, x.2, acc)) + |acc, x| { + spanned_union( + acc.span().unwrap(), + x.3, + Let(x.0, x.1, x.2, acc) + ) + } ) }, [forall(()), label(l), expression(typ), arrow(()), expression(body)] => { - spanned(span, Pi(l, typ, body)) + spanned(input, Pi(l, typ, body)) }, [expression(typ), arrow(()), expression(body)] => { - spanned(span, Pi("_".into(), typ, body)) + spanned(input, Pi("_".into(), typ, body)) }, [merge(()), expression(x), expression(y), expression(z)] => { - spanned(span, Merge(x, y, Some(z))) + spanned(input, Merge(x, y, Some(z))) }, [assert(()), expression(x)] => { - spanned(span, Assert(x)) + spanned(input, Assert(x)) }, [toMap(()), expression(x), expression(y)] => { - spanned(span, ToMap(x, Some(y))) + spanned(input, ToMap(x, Some(y))) }, [expression(e), expression(annot)] => { - spanned(span, Annot(e, annot)) + spanned(input, Annot(e, annot)) }, [expression(e)] => e, )) } fn let_binding<E: Clone>( - input: ParseInput<Rule>, - ) -> ParseResult<(Label, Option<Expr<E>>, Expr<E>)> { - Ok(parse_children!(input; + input: ParseInput, + ) -> ParseResult<(Label, Option<Expr<E>>, Expr<E>, Span)> { + Ok(match_nodes!(input.children(); [label(name), expression(annot), expression(expr)] => - (name, Some(annot), expr), + (name, Some(annot), expr, input_to_span(input)), [label(name), expression(expr)] => - (name, None, expr), + (name, None, expr, input_to_span(input)), )) } #[alias(expression, shortcut = true)] #[prec_climb(expression, PRECCLIMBER)] fn operator_expression<E: Clone>( - input: ParseInput<Rule>, l: Expr<E>, - op: Pair<Rule>, + op: ParseInput, r: Expr<E>, ) -> ParseResult<Expr<E>> { use crate::BinOp::*; @@ -844,42 +716,54 @@ impl Parsers { bool_eq => BoolEQ, bool_ne => BoolNE, equivalent => Equivalence, - r => Err(input.error(format!("Rule {:?} isn't an operator", r)))?, + r => Err(op.error(format!("Rule {:?} isn't an operator", r)))?, }; - Ok(unspanned(BinOp(op, l, r))) + Ok(spanned_union( + l.span().unwrap(), + r.span().unwrap(), + BinOp(op, l, r), + )) } - fn Some_(_input: ParseInput<Rule>) -> ParseResult<()> { + fn Some_(_input: ParseInput) -> ParseResult<()> { Ok(()) } #[alias(expression, shortcut = true)] fn application_expression<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<Expr<E>> { - Ok(parse_children!(input; + Ok(match_nodes!(input.children(); [expression(e)] => e, [expression(first), expression(rest)..] => { - rest.fold(first, |acc, e| unspanned(App(acc, e))) + rest.fold( + first, + |acc, e| { + spanned_union( + acc.span().unwrap(), + e.span().unwrap(), + App(acc, e) + ) + } + ) }, )) } #[alias(expression, shortcut = true)] fn first_application_expression<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<Expr<E>> { - let span = input.as_span(); - Ok(parse_children!(input; + Ok(match_nodes!(input.children(); [Some_(()), expression(e)] => { - spanned(span, SomeLit(e)) + spanned(input, SomeLit(e)) }, [merge(()), expression(x), expression(y)] => { - spanned(span, Merge(x, y, None)) + spanned(input, Merge(x, y, None)) }, [toMap(()), expression(x)] => { - spanned(span, ToMap(x, None)) + spanned(input, ToMap(x, None)) }, [expression(e)] => e, )) @@ -887,69 +771,75 @@ impl Parsers { #[alias(expression, shortcut = true)] fn selector_expression<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<Expr<E>> { - Ok(parse_children!(input; + Ok(match_nodes!(input.children(); [expression(e)] => e, [expression(first), selector(rest)..] => { - rest.fold(first, |acc, e| unspanned(match e { - Either::Left(l) => Field(acc, l), - Either::Right(ls) => Projection(acc, ls), - })) + rest.fold( + first, + |acc, e| { + spanned_union( + acc.span().unwrap(), + e.1, + match e.0 { + Either::Left(l) => Field(acc, l), + Either::Right(ls) => Projection(acc, ls), + } + ) + } + ) }, )) } fn selector( - input: ParseInput<Rule>, - ) -> ParseResult<Either<Label, DupTreeSet<Label>>> { - Ok(parse_children!(input; - [label(l)] => Either::Left(l), - [labels(ls)] => Either::Right(ls), + input: ParseInput, + ) -> ParseResult<(Either<Label, DupTreeSet<Label>>, Span)> { + Ok(match_nodes!(input.children(); + [label(l)] => (Either::Left(l), input_to_span(input)), + [labels(ls)] => (Either::Right(ls), input_to_span(input)), // [expression(_e)] => unimplemented!("selection by expression"), // TODO )) } - fn labels(input: ParseInput<Rule>) -> ParseResult<DupTreeSet<Label>> { - Ok(parse_children!(input; + fn labels(input: ParseInput) -> ParseResult<DupTreeSet<Label>> { + Ok(match_nodes!(input.into_children(); [label(ls)..] => ls.collect(), )) } #[alias(expression, shortcut = true)] fn primitive_expression<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<Expr<E>> { - let span = input.as_span(); - Ok(parse_children!(input; - [double_literal(n)] => spanned(span, DoubleLit(n)), - [natural_literal(n)] => spanned(span, NaturalLit(n)), - [integer_literal(n)] => spanned(span, IntegerLit(n)), - [double_quote_literal(s)] => spanned(span, TextLit(s)), - [single_quote_literal(s)] => spanned(span, TextLit(s)), + Ok(match_nodes!(input.children(); + [double_literal(n)] => spanned(input, DoubleLit(n)), + [natural_literal(n)] => spanned(input, NaturalLit(n)), + [integer_literal(n)] => spanned(input, IntegerLit(n)), + [double_quote_literal(s)] => spanned(input, TextLit(s)), + [single_quote_literal(s)] => spanned(input, TextLit(s)), [expression(e)] => e, )) } #[alias(expression)] fn empty_record_literal<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<Expr<E>> { - Ok(spanned(input.as_span(), RecordLit(Default::default()))) + Ok(spanned(input, RecordLit(Default::default()))) } #[alias(expression)] - fn empty_record_type<E: Clone>( - input: ParseInput<Rule>, - ) -> ParseResult<Expr<E>> { - Ok(spanned(input.as_span(), RecordType(Default::default()))) + fn empty_record_type<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> { + Ok(spanned(input, RecordType(Default::default()))) } #[alias(expression)] fn non_empty_record_type_or_literal<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<Expr<E>> { - let e = parse_children!(input; + let e = match_nodes!(input.children(); [label(first_label), non_empty_record_type(rest)] => { let (first_expr, mut map) = rest; map.insert(first_label, first_expr); @@ -961,13 +851,13 @@ impl Parsers { RecordLit(map) }, ); - Ok(spanned(input.as_span(), e)) + Ok(spanned(input, e)) } fn non_empty_record_type<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<(Expr<E>, DupTreeMap<Label, Expr<E>>)> { - Ok(parse_children!(input; + Ok(match_nodes!(input.into_children(); [expression(expr), record_type_entry(entries)..] => { (expr, entries.collect()) } @@ -975,17 +865,17 @@ impl Parsers { } fn record_type_entry<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<(Label, Expr<E>)> { - Ok(parse_children!(input; + Ok(match_nodes!(input.into_children(); [label(name), expression(expr)] => (name, expr) )) } fn non_empty_record_literal<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<(Expr<E>, DupTreeMap<Label, Expr<E>>)> { - Ok(parse_children!(input; + Ok(match_nodes!(input.into_children(); [expression(expr), record_literal_entry(entries)..] => { (expr, entries.collect()) } @@ -993,30 +883,30 @@ impl Parsers { } fn record_literal_entry<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<(Label, Expr<E>)> { - Ok(parse_children!(input; + Ok(match_nodes!(input.into_children(); [label(name), expression(expr)] => (name, expr) )) } #[alias(expression)] - fn union_type<E: Clone>(input: ParseInput<Rule>) -> ParseResult<Expr<E>> { - let map = parse_children!(input; + fn union_type<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> { + let map = match_nodes!(input.children(); [empty_union_type(_)] => Default::default(), [union_type_entry(entries)..] => entries.collect(), ); - Ok(spanned(input.as_span(), UnionType(map))) + Ok(spanned(input, UnionType(map))) } - fn empty_union_type(_input: ParseInput<Rule>) -> ParseResult<()> { + fn empty_union_type(_input: ParseInput) -> ParseResult<()> { Ok(()) } fn union_type_entry<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<(Label, Option<Expr<E>>)> { - Ok(parse_children!(input; + Ok(match_nodes!(input.children(); [label(name), expression(expr)] => (name, Some(expr)), [label(name)] => (name, None), )) @@ -1024,26 +914,32 @@ impl Parsers { #[alias(expression)] fn non_empty_list_literal<E: Clone>( - input: ParseInput<Rule>, + input: ParseInput, ) -> ParseResult<Expr<E>> { - Ok(parse_children!(input; + Ok(match_nodes!(input.children(); [expression(items)..] => spanned( - input.as_span(), + input, NEListLit(items.collect()) ) )) } - fn final_expression<E: Clone>( - input: ParseInput<Rule>, - ) -> ParseResult<Expr<E>> { - Ok(parse_children!(input; + #[alias(expression)] + fn final_expression<E: Clone>(input: ParseInput) -> ParseResult<Expr<E>> { + Ok(match_nodes!(input.into_children(); [expression(e), EOI(_)] => e )) } } -pub fn parse_expr<E: Clone>(s: &str) -> ParseResult<Expr<E>> { - let input = ParseInput::parse(s, Rule::final_expression)?; - Parsers::final_expression(input) +pub fn parse_expr<E: Clone>(input_str: &str) -> ParseResult<Expr<E>> { + let rc_input_str = input_str.to_string().into(); + let inputs = DhallParser::parse_with_userdata( + Rule::final_expression, + input_str, + rc_input_str, + )?; + Ok(match_nodes!(<DhallParser>; inputs; + [expression(e)] => e, + )) } |