From 35d735e3e1404fa917c95cbd914bccf0b3908ba0 Mon Sep 17 00:00:00 2001 From: Nadrieril Date: Sat, 6 Apr 2019 11:46:27 +0200 Subject: Split dhall_expr!() into 2 --- dhall_generator/src/dhall_expr.rs | 57 ++++++++++++++++++++++++++++++++++----- dhall_generator/src/dhall_type.rs | 4 +-- dhall_generator/src/lib.rs | 13 ++++++++- 3 files changed, 65 insertions(+), 9 deletions(-) (limited to 'dhall_generator') diff --git a/dhall_generator/src/dhall_expr.rs b/dhall_generator/src/dhall_expr.rs index 9da23b6..d0c5733 100644 --- a/dhall_generator/src/dhall_expr.rs +++ b/dhall_generator/src/dhall_expr.rs @@ -5,19 +5,29 @@ use proc_macro2::TokenStream; use quote::quote; use std::collections::BTreeMap; -pub fn dhall_expr(input: proc_macro::TokenStream) -> proc_macro::TokenStream { +pub fn expr(input: proc_macro::TokenStream) -> proc_macro::TokenStream { let input_str = input.to_string(); let expr: SubExpr = parse_expr(&input_str).unwrap(); let no_import = - |_: &Import| -> X { panic!("Don't use import in dhall!()") }; - let expr = rc(expr.as_ref().map_embed(&no_import)); - let output = quote_subexpr(&expr, &Context::new()); + |_: &Import| -> X { panic!("Don't use import in dhall::expr!()") }; + let expr = expr.as_ref().map_embed(&no_import); + let output = quote_expr(&expr, &Context::new()); + output.into() +} + +pub fn subexpr(input: proc_macro::TokenStream) -> proc_macro::TokenStream { + let input_str = input.to_string(); + let expr: SubExpr = parse_expr(&input_str).unwrap(); + let no_import = + |_: &Import| -> X { panic!("Don't use import in dhall::subexpr!()") }; + let expr = expr.as_ref().map_embed(&no_import); + let output = quote_subexpr(&rc(expr), &Context::new()); output.into() } // Returns an expression of type ExprF, where T is the // type of the subexpressions after interpolation. -pub fn quote_expr(expr: ExprF) -> TokenStream +pub fn quote_exprf(expr: ExprF) -> TokenStream where TS: quote::ToTokens + std::fmt::Debug, { @@ -134,7 +144,42 @@ fn quote_subexpr( } } } - e => bx(quote_expr(e)), + e => bx(quote_exprf(e)), + } +} + +// Returns an expression of type Expr<_, _>. Expects interpolated variables +// to be of type SubExpr<_, _>. +fn quote_expr(expr: &Expr, ctx: &Context) -> TokenStream { + use dhall_core::ExprF::*; + match expr.map_ref( + |e| quote_subexpr(e, ctx), + |l, e| quote_subexpr(e, &ctx.insert(l.clone(), ())), + |_| unreachable!(), + |_| unreachable!(), + |l| l.clone(), + ) { + Var(V(ref s, n)) => { + match ctx.lookup(s, n) { + // Non-free variable; interpolates as itself + Some(()) => { + let s: String = s.into(); + let var = quote! { dhall_core::V(#s.into(), #n) }; + quote! { dhall_core::ExprF::Var(#var) } + } + // Free variable; interpolates as a rust variable + None => { + let s: String = s.into(); + // TODO: insert appropriate shifts ? + let v: TokenStream = s.parse().unwrap(); + quote! { { + let x: dhall_core::SubExpr<_, _> = #v.clone(); + x.unroll() + } } + } + } + } + e => quote_exprf(e), } } diff --git a/dhall_generator/src/dhall_type.rs b/dhall_generator/src/dhall_type.rs index ec023bc..3b1d1c9 100644 --- a/dhall_generator/src/dhall_type.rs +++ b/dhall_generator/src/dhall_type.rs @@ -48,7 +48,7 @@ pub fn derive_for_struct( }) .collect(); let record = - crate::dhall_expr::quote_expr(dhall_core::ExprF::RecordType(fields)); + crate::dhall_expr::quote_exprf(dhall_core::ExprF::RecordType(fields)); Ok(quote! { dhall_core::rc(#record) }) } @@ -93,7 +93,7 @@ pub fn derive_for_enum( .collect::>()?; let union = - crate::dhall_expr::quote_expr(dhall_core::ExprF::UnionType(variants)); + crate::dhall_expr::quote_exprf(dhall_core::ExprF::UnionType(variants)); Ok(quote! { dhall_core::rc(#union) }) } diff --git a/dhall_generator/src/lib.rs b/dhall_generator/src/lib.rs index d720b67..f31faa4 100644 --- a/dhall_generator/src/lib.rs +++ b/dhall_generator/src/lib.rs @@ -5,9 +5,20 @@ mod dhall_type; use proc_macro::TokenStream; +// Deprecated #[proc_macro] pub fn dhall_expr(input: TokenStream) -> TokenStream { - dhall_expr::dhall_expr(input) + subexpr(input) +} + +#[proc_macro] +pub fn expr(input: TokenStream) -> TokenStream { + dhall_expr::expr(input) +} + +#[proc_macro] +pub fn subexpr(input: TokenStream) -> TokenStream { + dhall_expr::subexpr(input) } #[proc_macro_derive(Type)] -- cgit v1.2.3