#[macro_export]
#[deprecated(since = "0.5.0", note = "Use the quote! procedural macro instead.")]
macro_rules! toks {
($($x:expr),*) => {
{
let mut _t = $crate::Tokens::new();
$(_t.append($x);)*
_t
}
};
($($x:expr,)*) => {toks!($($x),*)}
}
#[macro_export]
#[deprecated(since = "0.5.0", note = "Use the quote! procedural macro instead.")]
macro_rules! push {
($dest:expr, |$t:ident| $code:block) => {
$dest.push({
let mut $t = $crate::Tokens::new();
$code
$t
})
};
($dest:expr, $($x:expr),*) => {
$dest.push({
let mut _t = $crate::Tokens::new();
$(_t.append(Clone::clone(&$x));)*
_t
})
};
($dest:expr, $($x:expr,)*) => {push!($dest, $($x),*)};
}
#[macro_export]
#[deprecated(since = "0.5.0", note = "Use the quote! procedural macro instead.")]
macro_rules! nested {
($dest:expr, |$t:ident| $code:block) => {
$dest.nested({
let mut $t = $crate::Tokens::new();
$code
$t
})
};
($dest:expr, $($x:expr),*) => {
$dest.nested({
let mut _t = $crate::Tokens::new();
$(_t.append(Clone::clone(&$x));)*
_t
})
};
($dest:expr, $($x:expr,)*) => {nested!($dest, $($x),*)};
}
macro_rules! impl_lang_item {
($ty:ident, $lang:ty) => {
impl<'el> crate::FormatTokens<'el, $lang> for $ty {
fn format_tokens(self, tokens: &mut crate::Tokens<'el, $lang>) {
tokens.elements.push(crate::Element::LangBox(self.into()));
}
}
impl<'el> crate::FormatTokens<'el, $lang> for &'el $ty {
fn format_tokens(self, tokens: &mut crate::Tokens<'el, $lang>) {
tokens.elements.push(crate::Element::LangBox(self.into()));
}
}
impl<'el> From<$ty> for crate::LangBox<'el, $lang> {
fn from(value: $ty) -> Self {
use std::rc::Rc;
crate::LangBox::Rc(Rc::new(value) as Rc<dyn LangItem<$lang>>)
}
}
impl<'el> From<&'el $ty> for crate::LangBox<'el, $lang> {
fn from(value: &'el $ty) -> Self {
crate::LangBox::Ref(value)
}
}
};
}
macro_rules! impl_args {
($args:ty, $ty:ident, $type_box:ident, $($ident:ident => $var:ident),*) => {
impl<$($ident,)*> $args for ($($ident,)*) where $($ident: 'static + $ty,)* {
fn into_args(self) -> Vec<$type_box> {
let ($($var,)*) = self;
vec![$($type_box::new($var),)*]
}
}
}
}
macro_rules! impl_variadic_type_args {
($args:ident, $ty:ident, $type_box:ident) => {
pub trait $args {
fn into_args(self) -> Vec<$type_box>;
}
impl<T> $args for T
where
T: 'static + $ty,
{
fn into_args(self) -> Vec<$type_box> {
vec![$type_box::new(self)]
}
}
impl_args!($args, $ty, $type_box, A => a);
impl_args!($args, $ty, $type_box, A => a, B => b);
impl_args!($args, $ty, $type_box, A => a, B => b, C => c);
impl_args!($args, $ty, $type_box, A => a, B => b, C => c, D => d);
impl_args!($args, $ty, $type_box, A => a, B => b, C => c, D => d, E => e);
};
}
macro_rules! impl_type_basics {
($lang:ty, $enum:ident<$lt:lifetime>, $trait:ident, $type_box:ident, $args:ident, {$($ty:ident),*}) => {
#[derive(Clone)]
#[doc = "Boxed type container"]
pub struct $type_box {
inner: std::rc::Rc<dyn $trait>,
}
impl std::ops::Deref for $type_box {
type Target = dyn $trait;
fn deref(&self) -> &Self::Target {
&*self.inner
}
}
impl $type_box {
pub fn new<T>(inner: T) -> Self where T: 'static + $trait {
Self {
inner: std::rc::Rc::new(inner),
}
}
}
impl std::fmt::Debug for $type_box {
fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
self.inner.as_enum().fmt(fmt)
}
}
impl std::cmp::PartialEq for $type_box {
fn eq(&self, other: &Self) -> bool {
self.inner.as_enum() == other.inner.as_enum()
}
}
impl std::cmp::Eq for $type_box {}
impl std::hash::Hash for $type_box {
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
self.as_enum().hash(state);
}
}
impl std::cmp::PartialOrd for $type_box {
fn partial_cmp(&self, other: &$type_box) -> Option<std::cmp::Ordering> {
Some(self.cmp(other))
}
}
impl std::cmp::Ord for $type_box {
fn cmp(&self, other: &$type_box) -> std::cmp::Ordering {
self.inner.as_enum().cmp(&other.inner.as_enum())
}
}
#[doc = "Enum that can be used for casting between variants of the same type"]
#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub enum $enum<$lt> {
$(
#[doc = "Type variant"]
$ty(&$lt $ty),
)*
}
$(
impl From<$ty> for $type_box {
fn from(value: $ty) -> $type_box {
$type_box::new(value)
}
}
impl_lang_item!($ty, $lang);
)*
impl_variadic_type_args!($args, $trait, $type_box);
}
}
#[cfg(test)]
mod tests {
use crate::{JavaScript, Quoted, Tokens};
#[test]
fn test_quoted() {
let n1: Tokens<JavaScript> = toks!("var v = ", "bar".quoted(), ";");
assert_eq!("var v = \"bar\";", n1.to_string().unwrap().as_str());
}
#[test]
fn test_macros() {
let mut t = Tokens::<JavaScript>::new();
push!(t, |t| {
push!(t, "function bar(a, b) {");
nested!(t, |t| {
push!(t, "var v = a + b;");
push!(t, "return v;");
});
push!(t, "}");
});
push!(t, "var foo = bar();");
let expected = vec![
"function bar(a, b) {",
" var v = a + b;",
" return v;",
"}",
"var foo = bar();",
"",
];
assert_eq!(expected, t.to_file_vec().unwrap());
}
}