2020-06-04 16:39:33 -04:00
|
|
|
use quote::quote;
|
|
|
|
use syn::parse::{Parse, ParseStream, Result as ParseResult};
|
|
|
|
use syn::visit_mut::VisitMut;
|
2020-12-16 23:26:49 -05:00
|
|
|
use syn::{Block, Expr, ExprBreak, ExprContinue, ExprMacro, Ident, LitStr, Stmt, Token};
|
2020-06-04 16:39:33 -04:00
|
|
|
|
2020-12-18 09:00:40 -05:00
|
|
|
pub struct Optimizer {
|
|
|
|
rm_whitespace: bool,
|
2020-06-04 16:39:33 -04:00
|
|
|
}
|
|
|
|
|
2020-12-18 09:00:40 -05:00
|
|
|
impl Optimizer {
|
|
|
|
#[inline]
|
|
|
|
pub fn new() -> Self {
|
|
|
|
Self {
|
|
|
|
rm_whitespace: false,
|
2020-06-04 16:39:33 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-18 09:00:40 -05:00
|
|
|
#[inline]
|
|
|
|
pub fn rm_whitespace(mut self, new: bool) -> Self {
|
|
|
|
self.rm_whitespace = new;
|
|
|
|
self
|
2020-12-16 23:26:49 -05:00
|
|
|
}
|
|
|
|
|
2020-12-18 09:00:40 -05:00
|
|
|
#[inline]
|
|
|
|
pub fn optimize(&self, i: &mut Block) {
|
|
|
|
OptmizerImpl {
|
|
|
|
rm_whitespace: self.rm_whitespace,
|
|
|
|
}
|
|
|
|
.visit_block_mut(i);
|
2020-12-16 23:26:49 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-06 18:01:15 -04:00
|
|
|
struct OptmizerImpl {
|
|
|
|
rm_whitespace: bool,
|
|
|
|
}
|
2020-06-04 16:39:33 -04:00
|
|
|
|
|
|
|
impl VisitMut for OptmizerImpl {
|
|
|
|
fn visit_expr_mut(&mut self, i: &mut Expr) {
|
|
|
|
let fl = if let Expr::ForLoop(ref mut fl) = *i {
|
|
|
|
fl
|
|
|
|
} else {
|
|
|
|
syn::visit_mut::visit_expr_mut(self, i);
|
|
|
|
return;
|
|
|
|
};
|
|
|
|
|
2020-12-16 23:26:49 -05:00
|
|
|
// process inner block in advance
|
2020-06-04 16:39:33 -04:00
|
|
|
syn::visit_mut::visit_block_mut(self, &mut fl.body);
|
|
|
|
|
2020-12-16 23:26:49 -05:00
|
|
|
if block_has_continue_or_break(&mut fl.body) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2020-06-04 16:39:33 -04:00
|
|
|
let (mf, ml) = match (fl.body.stmts.first(), fl.body.stmts.last()) {
|
|
|
|
(
|
|
|
|
Some(Stmt::Semi(Expr::Macro(ref mf), ..)),
|
|
|
|
Some(Stmt::Semi(Expr::Macro(ref ml), ..)),
|
|
|
|
) => (mf, ml),
|
2020-12-16 23:26:49 -05:00
|
|
|
_ => return,
|
2020-06-04 16:39:33 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
let (sf, sl) = match (get_rendertext_value(mf), get_rendertext_value(ml)) {
|
|
|
|
(Some(sf), Some(sl)) => (sf, sl),
|
2020-12-16 23:26:49 -05:00
|
|
|
_ => return,
|
2020-06-04 16:39:33 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
let sf_len = sf.len();
|
|
|
|
let concat = sl + &*sf;
|
|
|
|
|
|
|
|
fl.body.stmts.remove(0);
|
|
|
|
*fl.body.stmts.last_mut().unwrap() = syn::parse2(quote! {
|
2020-07-14 11:02:54 -04:00
|
|
|
__sf_rt::render_text!(__sf_buf, #concat);
|
2020-06-04 16:39:33 -04:00
|
|
|
})
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
let new_expr = syn::parse2(quote! {{
|
2020-07-14 11:02:54 -04:00
|
|
|
__sf_rt::render_text!(__sf_buf, #sf);
|
2020-06-04 16:39:33 -04:00
|
|
|
#fl;
|
2020-07-15 06:49:35 -04:00
|
|
|
unsafe { __sf_buf._set_len(__sf_buf.len() - #sf_len); }
|
2020-06-04 16:39:33 -04:00
|
|
|
}})
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
*i = new_expr;
|
|
|
|
}
|
2020-06-06 18:01:15 -04:00
|
|
|
|
|
|
|
fn visit_expr_macro_mut(&mut self, i: &mut ExprMacro) {
|
|
|
|
if self.rm_whitespace {
|
|
|
|
if let Some(v) = get_rendertext_value(i) {
|
|
|
|
let mut buffer = String::new();
|
|
|
|
let mut it = v.lines().peekable();
|
|
|
|
|
|
|
|
if let Some(line) = it.next() {
|
|
|
|
if it.peek().is_some() {
|
|
|
|
buffer.push_str(line.trim_end());
|
|
|
|
buffer.push('\n');
|
|
|
|
} else {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
while let Some(line) = it.next() {
|
|
|
|
if it.peek().is_some() {
|
|
|
|
if !line.is_empty() {
|
|
|
|
buffer.push_str(line.trim());
|
|
|
|
buffer.push('\n');
|
|
|
|
} else {
|
|
|
|
// ignore empty line
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// last line
|
|
|
|
buffer.push_str(line.trim_start());
|
|
|
|
}
|
|
|
|
}
|
2020-07-14 11:02:54 -04:00
|
|
|
i.mac.tokens = quote! { __sf_buf, #buffer };
|
2020-06-06 18:01:15 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
syn::visit_mut::visit_expr_macro_mut(self, i);
|
|
|
|
}
|
2020-06-04 16:39:33 -04:00
|
|
|
}
|
|
|
|
|
2020-12-18 09:00:40 -05:00
|
|
|
fn get_rendertext_value(i: &ExprMacro) -> Option<String> {
|
|
|
|
struct RenderTextMacroArgument {
|
|
|
|
#[allow(dead_code)]
|
|
|
|
context: Ident,
|
|
|
|
arg: LitStr,
|
|
|
|
}
|
2020-06-04 16:39:33 -04:00
|
|
|
|
2020-12-18 09:00:40 -05:00
|
|
|
impl Parse for RenderTextMacroArgument {
|
|
|
|
fn parse(s: ParseStream) -> ParseResult<Self> {
|
|
|
|
let context = s.parse()?;
|
|
|
|
s.parse::<Token![,]>()?;
|
|
|
|
let arg = s.parse()?;
|
|
|
|
|
|
|
|
Ok(Self { context, arg })
|
2020-06-06 18:01:15 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-18 09:00:40 -05:00
|
|
|
let mut it = i.mac.path.segments.iter();
|
|
|
|
|
|
|
|
if it.next().map_or(false, |s| s.ident == "__sf_rt")
|
|
|
|
&& it.next().map_or(false, |s| s.ident == "render_text")
|
|
|
|
&& it.next().is_none()
|
|
|
|
{
|
|
|
|
let tokens = i.mac.tokens.clone();
|
|
|
|
if let Ok(macro_arg) = syn::parse2::<RenderTextMacroArgument>(tokens) {
|
|
|
|
return Some(macro_arg.arg.value());
|
|
|
|
}
|
2020-06-04 16:39:33 -04:00
|
|
|
}
|
|
|
|
|
2020-12-18 09:00:40 -05:00
|
|
|
None
|
|
|
|
}
|
|
|
|
|
|
|
|
fn block_has_continue_or_break(i: &mut Block) -> bool {
|
|
|
|
#[derive(Default)]
|
|
|
|
struct ContinueBreakFinder {
|
|
|
|
found: bool,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl VisitMut for ContinueBreakFinder {
|
|
|
|
fn visit_expr_continue_mut(&mut self, _: &mut ExprContinue) {
|
|
|
|
self.found = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
fn visit_expr_break_mut(&mut self, _: &mut ExprBreak) {
|
|
|
|
self.found = true;
|
2020-06-06 18:01:15 -04:00
|
|
|
}
|
2020-06-04 16:39:33 -04:00
|
|
|
}
|
2020-12-18 09:00:40 -05:00
|
|
|
|
|
|
|
let mut finder = ContinueBreakFinder::default();
|
|
|
|
finder.visit_block_mut(i);
|
|
|
|
finder.found
|
2020-06-04 16:39:33 -04:00
|
|
|
}
|