break: remove runtime::Context API

sailfish-compiler/src/optimizer.rs

@@ -74,14 +74,14 @@ impl VisitMut for OptmizerImpl {
 
         fl.body.stmts.remove(0);
         *fl.body.stmts.last_mut().unwrap() = syn::parse2(quote! {
-            __sf_rt::render_text!(_ctx, #concat);
+            __sf_rt::render_text!(__sf_buf, #concat);
         })
         .unwrap();
 
         let new_expr = syn::parse2(quote! {{
-            __sf_rt::render_text!(_ctx, #sf);
+            __sf_rt::render_text!(__sf_buf, #sf);
             #fl;
-            unsafe { _ctx.buf.set_len(_ctx.buf.len() - #sf_len); }
+            unsafe { __sf_buf.set_len(__sf_buf.len() - #sf_len); }
         }})
         .unwrap();
 
@@ -116,7 +116,7 @@ impl VisitMut for OptmizerImpl {
                         buffer.push_str(line.trim_start());
                     }
                 }
-                i.mac.tokens = quote! { _ctx, #buffer };
+                i.mac.tokens = quote! { __sf_buf, #buffer };
                 return;
             }
         }

sailfish-compiler/src/procmacro.rs

@@ -274,18 +274,16 @@ fn derive_template_impl(tokens: TokenStream) -> Result<TokenStream, syn::Error>
 
                 static SIZE_HINT: __sf_rt::SizeHint = __sf_rt::SizeHint::new();
 
-                let mut _ctx = __sf_rt::Context {
-                    buf: __sf_rt::Buffer::from(std::mem::take(buf))
-                };
+                let mut __sf_buf = __sf_rt::Buffer::from(std::mem::take(buf));
 
                 let _size_hint = SIZE_HINT.get();
-                _ctx.buf.reserve(_size_hint);
+                __sf_buf.reserve(_size_hint);
 
                 let #name { #field_names } = self;
                 include!(#output_file_string);
 
-                SIZE_HINT.update(_ctx.buf.len());
-                *buf = _ctx.buf.into_string();
+                SIZE_HINT.update(__sf_buf.len());
+                *buf = __sf_buf.into_string();
                 Ok(())
             }
         }

sailfish-compiler/src/translator.rs

@@ -106,7 +106,7 @@ impl SourceBuilder {
     fn write_text<'a>(&mut self, token: &Token<'a>) {
         use std::fmt::Write;
 
-        self.source.push_str("__sf_rt::render_text!(_ctx, ");
+        self.source.push_str("__sf_rt::render_text!(__sf_buf, ");
 
         // write text token with Debug::fmt
         write!(self.source, "{:?}", token.as_str()).unwrap();
@@ -123,7 +123,7 @@ impl SourceBuilder {
 
         self.source.push_str("__sf_rt::");
         self.source.push_str(method);
-        self.source.push_str("!(_ctx, ");
+        self.source.push_str("!(__sf_buf, ");
         self.write_token(token);
         self.source.push_str(");\n");
     }

sailfish/src/runtime/macros.rs

@@ -1,29 +1,29 @@
 #[macro_export]
 #[doc(hidden)]
 macro_rules! render {
-    ($ctx:ident, $value:expr) => {
-        $crate::runtime::Render::render(&($value), &mut $ctx.buf)?
+    ($buf:ident, $value:expr) => {
+        $crate::runtime::Render::render(&($value), &mut $buf)?
     };
 }
 
 #[macro_export]
 #[doc(hidden)]
 macro_rules! render_escaped {
-    ($ctx:ident, $value:expr) => {
-        $crate::runtime::Render::render_escaped(&($value), &mut $ctx.buf)?
+    ($buf:ident, $value:expr) => {
+        $crate::runtime::Render::render_escaped(&($value), &mut $buf)?
     };
 }
 
 #[macro_export]
 #[doc(hidden)]
 macro_rules! render_text {
-    ($ctx:ident, $value:expr) => {
-        $ctx.buf.push_str($value)
+    ($buf:ident, $value:expr) => {
+        $buf.push_str($value)
     };
 }
 
 #[macro_export]
 #[doc(hidden)]
 macro_rules! render_noop {
-    ($ctx:ident, $value:expr) => {};
+    ($buf:ident, $value:expr) => {};
 }

sailfish/src/runtime/mod.rs

@@ -69,19 +69,6 @@ impl From<fmt::Error> for RenderError {
 
 pub type RenderResult = Result<String, RenderError>;
 
-#[doc(hidden)]
-pub struct Context {
-    #[doc(hidden)]
-    pub buf: Buffer,
-}
-
-impl Context {
-    #[inline]
-    pub fn into_result(self) -> RenderResult {
-        Ok(self.buf.into_string())
-    }
-}
-
 // #[inline(never)]
 // pub fn _instantiate(table: Vec<Vec<usize>>) -> String {
 //     let mut buffer = Buffer::with_capacity(130000);