Clean up macro parsing

genco-macros/src/encoder.rs

@@ -3,14 +3,15 @@ use crate::cursor::Cursor;
 use crate::fake::LineColumn;
 use crate::requirements::Requirements;
 use crate::static_buffer::StaticBuffer;
+use crate::Ctxt;
 
 use proc_macro2::{Span, TokenStream};
 use syn::Result;
 
 /// Struct to deal with emitting the necessary spacing.
 pub(crate) struct Encoder<'a> {
-    /// The identifier that received the input.
-    receiver: &'a syn::Ident,
+    /// Context for encoding.
+    cx: &'a Ctxt,
     /// Use to modify the initial line/column in case something was processed
     /// before the input was handed off to the quote parser.
     ///
@@ -38,15 +39,15 @@ pub(crate) struct Encoder<'a> {
 
 impl<'a> Encoder<'a> {
     pub(crate) fn new(
-        receiver: &'a syn::Ident,
+        cx: &'a Ctxt,
         span_start: Option<LineColumn>,
         span_end: Option<LineColumn>,
     ) -> Self {
         Self {
-            receiver,
+            cx,
             span_start,
             span_end,
-            item_buffer: StaticBuffer::new(receiver),
+            item_buffer: StaticBuffer::new(cx),
             output: TokenStream::new(),
             last: None,
             last_start_column: None,
@@ -151,29 +152,32 @@ impl<'a> Encoder<'a> {
     }
 
     pub(crate) fn encode_string(&mut self, has_eval: bool, stream: TokenStream) {
+        let Ctxt { receiver, module } = self.cx;
+
         self.item_buffer.flush(&mut self.output);
-        let receiver = self.receiver;
 
         self.output.extend(q::quote! {
-            #receiver.append(genco::tokens::Item::OpenQuote(#has_eval));
+            #receiver.append(#module::tokens::Item::OpenQuote(#has_eval));
             #stream
-            #receiver.append(genco::tokens::Item::CloseQuote);
+            #receiver.append(#module::tokens::Item::CloseQuote);
         });
     }
 
     pub(crate) fn encode_quoted(&mut self, s: syn::LitStr) {
-        let receiver = self.receiver;
+        let Ctxt { receiver, module } = self.cx;
+
         self.item_buffer.flush(&mut self.output);
 
         self.output.extend(q::quote! {
-            #receiver.append(genco::tokens::Item::OpenQuote(false));
-            #receiver.append(genco::tokens::ItemStr::Static(#s));
-            #receiver.append(genco::tokens::Item::CloseQuote);
+            #receiver.append(#module::tokens::Item::OpenQuote(false));
+            #receiver.append(#module::tokens::ItemStr::Static(#s));
+            #receiver.append(#module::tokens::Item::CloseQuote);
         });
     }
 
     pub(crate) fn encode_control(&mut self, control: Control) {
-        let receiver = self.receiver;
+        let Ctxt { receiver, .. } = self.cx;
+
         self.item_buffer.flush(&mut self.output);
 
         match control.kind {
@@ -193,7 +197,7 @@ impl<'a> Encoder<'a> {
     }
 
     pub(crate) fn encode_scope(&mut self, binding: Option<syn::Ident>, content: TokenStream) {
-        let receiver = self.receiver;
+        let Ctxt { receiver, .. } = self.cx;
 
         if binding.is_some() {
             self.item_buffer.flush(&mut self.output);
@@ -209,7 +213,8 @@ impl<'a> Encoder<'a> {
 
     /// Encode an evaluation of the given expression.
     pub(crate) fn encode_eval_ident(&mut self, ident: syn::Ident) {
-        let receiver = self.receiver;
+        let Ctxt { receiver, .. } = self.cx;
+
         self.item_buffer.flush(&mut self.output);
         self.output.extend(q::quote! {
             #receiver.append(#ident);
@@ -218,7 +223,8 @@ impl<'a> Encoder<'a> {
 
     /// Encode an evaluation of the given expression.
     pub(crate) fn encode_eval(&mut self, expr: syn::Expr) {
-        let receiver = self.receiver;
+        let Ctxt { receiver, .. } = self.cx;
+
         self.item_buffer.flush(&mut self.output);
         self.output.extend(q::quote! {
             #receiver.append(#expr);
@@ -335,6 +341,8 @@ impl<'a> Encoder<'a> {
 
     /// Finalize the encoder.
     fn finalize(&mut self) -> Result<()> {
+        let Ctxt { receiver, .. } = self.cx;
+
         // evaluate whitespace in case we have an explicit end span.
         while let Some(to) = self.span_end.take() {
             if let Some(from) = self.from() {
@@ -345,8 +353,6 @@ impl<'a> Encoder<'a> {
 
         self.item_buffer.flush(&mut self.output);
 
-        let receiver = self.receiver;
-
         while self.indents.pop().is_some() {
             self.output.extend(q::quote!(#receiver.unindent();));
         }
@@ -362,7 +368,7 @@ impl<'a> Encoder<'a> {
         to: LineColumn,
         to_span: Option<Span>,
     ) -> Result<()> {
-        let r = self.receiver;
+        let Ctxt { receiver: r, .. } = self.cx;
 
         // Do nothing if empty span.
         if from == to {

genco-macros/src/lib.rs

@@ -11,6 +11,29 @@ extern crate proc_macro;
 use proc_macro2::Span;
 use syn::parse::{ParseStream, Parser as _};
 
+struct Ctxt {
+    receiver: syn::Ident,
+    module: syn::Path,
+}
+
+impl Default for Ctxt {
+    fn default() -> Self {
+        let mut module = syn::Path {
+            leading_colon: None,
+            segments: syn::punctuated::Punctuated::default(),
+        };
+
+        module
+            .segments
+            .push(syn::Ident::new("genco", Span::call_site()).into());
+
+        Self {
+            receiver: syn::Ident::new("__genco_macros_toks", Span::call_site()),
+            module,
+        }
+    }
+}
+
 mod ast;
 mod cursor;
 mod encoder;
@@ -659,9 +682,8 @@ mod token;
 /// [escape]: #escape-sequences
 #[proc_macro]
 pub fn quote(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    let receiver = &syn::Ident::new("__genco_macros_toks", Span::call_site());
-
-    let parser = crate::quote::Quote::new(receiver);
+    let cx = Ctxt::default();
+    let parser = crate::quote::Quote::new(&cx);
 
     let parser = move |stream: ParseStream| parser.parse(stream);
 
@@ -670,10 +692,12 @@ pub fn quote(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
         Err(e) => return proc_macro::TokenStream::from(e.to_compile_error()),
     };
 
-    let check = req.into_check(receiver);
+    let check = req.into_check(&cx.receiver);
+
+    let Ctxt { receiver, module } = &cx;
 
     let gen = q::quote! {{
-        let mut #receiver = genco::tokens::Tokens::new();
+        let mut #receiver = #module::tokens::Tokens::new();
 
         {
             let mut #receiver = &mut #receiver;

genco-macros/src/quote.rs

@@ -9,11 +9,11 @@ use crate::fake::Buf;
 use crate::fake::LineColumn;
 use crate::requirements::Requirements;
 use crate::string_parser::StringParser;
+use crate::Ctxt;
 
 pub(crate) struct Quote<'a> {
-    /// Used to set the receiver identifier which is being modified by this
-    /// macro.
-    receiver: &'a syn::Ident,
+    /// Context variables.
+    cx: &'a Ctxt,
     /// Use to modify the initial line/column in case something was processed
     /// before the input was handed off to the quote parser.
     ///
@@ -32,9 +32,9 @@ pub(crate) struct Quote<'a> {
 
 impl<'a> Quote<'a> {
     /// Construct a new quote parser.
-    pub(crate) fn new(receiver: &'a syn::Ident) -> Self {
+    pub(crate) fn new(cx: &'a Ctxt) -> Self {
         Self {
-            receiver,
+            cx,
             span_start: None,
             span_end: None,
             until_comma: false,
@@ -43,9 +43,9 @@ impl<'a> Quote<'a> {
     }
 
     /// Construct a new quote parser that will only parse until the given token.
-    pub(crate) fn new_until_comma(receiver: &'a syn::Ident) -> Self {
+    pub(crate) fn new_until_comma(cx: &'a Ctxt) -> Self {
         Self {
-            receiver,
+            cx,
             span_start: None,
             span_end: None,
             until_comma: true,
@@ -78,7 +78,7 @@ impl<'a> Quote<'a> {
 
     /// Parse until end of stream.
     pub(crate) fn parse(mut self, input: ParseStream) -> Result<(Requirements, TokenStream)> {
-        let mut encoder = Encoder::new(self.receiver, self.span_start, self.span_end);
+        let mut encoder = Encoder::new(self.cx, self.span_start, self.span_end);
         self.parse_inner(&mut encoder, input, 0)?;
         encoder.into_output()
     }
@@ -90,7 +90,7 @@ impl<'a> Quote<'a> {
 
         if input.peek(Token![=>]) {
             input.parse::<Token![=>]>()?;
-            let (req, then_branch) = Quote::new(self.receiver).parse(input)?;
+            let (req, then_branch) = Quote::new(self.cx).parse(input)?;
 
             return Ok((
                 req,
@@ -107,7 +107,7 @@ impl<'a> Quote<'a> {
         let content;
         syn::braced!(content in input);
 
-        let (r, then_branch) = Quote::new(self.receiver).parse(&content)?;
+        let (r, then_branch) = Quote::new(self.cx).parse(&content)?;
         req.merge_with(r);
 
         let else_branch = if input.peek(Token![else]) {
@@ -116,7 +116,7 @@ impl<'a> Quote<'a> {
             let content;
             syn::braced!(content in input);
 
-            let (r, else_branch) = Quote::new(self.receiver).parse(&content)?;
+            let (r, else_branch) = Quote::new(self.cx).parse(&content)?;
             req.merge_with(r);
 
             Some(else_branch)
@@ -151,9 +151,7 @@ impl<'a> Quote<'a> {
             let content;
             let paren = syn::parenthesized!(content in input);
 
-            let (r, join) = Quote::new(self.receiver)
-                .with_span(paren.span)?
-                .parse(&content)?;
+            let (r, join) = Quote::new(self.cx).with_span(paren.span)?.parse(&content)?;
             req.merge_with(r);
 
             Some(join)
@@ -171,7 +169,7 @@ impl<'a> Quote<'a> {
             &content
         };
 
-        let parser = Quote::new(self.receiver);
+        let parser = Quote::new(self.cx);
         let (r, stream) = parser.parse(input)?;
         req.merge_with(r);
 
@@ -213,17 +211,15 @@ impl<'a> Quote<'a> {
                 let block;
                 syn::braced!(block in body);
 
-                let parser = Quote::new(self.receiver);
+                let parser = Quote::new(self.cx);
                 parser.parse(&block)?
             } else if body.peek(token::Paren) {
                 let block;
                 let paren = syn::parenthesized!(block in body);
 
-                Quote::new(self.receiver)
-                    .with_span(paren.span)?
-                    .parse(&block)?
+                Quote::new(self.cx).with_span(paren.span)?.parse(&block)?
             } else {
-                let parser = Quote::new_until_comma(self.receiver);
+                let parser = Quote::new_until_comma(self.cx);
                 parser.parse(&body)?
             };
 
@@ -348,7 +344,7 @@ impl<'a> Quote<'a> {
                         ));
                     }
                     (LiteralName::Ident("str"), Some(content)) => {
-                        let parser = StringParser::new(self.receiver, &self.buf, end)?;
+                        let parser = StringParser::new(self.cx, &self.buf, end)?;
 
                         let (options, r, stream) = parser.parse(&content)?;
                         encoder.requirements.merge_with(r);
@@ -358,7 +354,7 @@ impl<'a> Quote<'a> {
                         encoder.encode(
                             cursor,
                             Ast::String {
-                                has_eval: options.has_eval,
+                                has_eval: options.has_eval.get(),
                                 stream,
                             },
                         )?;

genco-macros/src/quote_fn.rs

@@ -2,20 +2,25 @@ use proc_macro2::TokenStream;
 use syn::parse::{Parse, ParseStream};
 use syn::Result;
 
+use crate::Ctxt;
+
 pub(crate) struct QuoteFn {
     pub(crate) stream: TokenStream,
 }
 
 impl Parse for QuoteFn {
     fn parse(input: ParseStream) -> Result<Self> {
-        let receiver = &syn::Ident::new("__genco_macros_toks", input.span());
-        let parser = crate::quote::Quote::new(receiver);
+        let cx = Ctxt::default();
+
+        let parser = crate::quote::Quote::new(&cx);
         let (req, output) = parser.parse(input)?;
 
-        let check = req.into_check(receiver);
+        let check = req.into_check(&cx.receiver);
+
+        let Ctxt { receiver, module } = &cx;
 
         let stream = q::quote! {
-            genco::tokens::from_fn(move |#receiver| {
+            #module::tokens::from_fn(move |#receiver| {
                 #output
                 #check
             })

genco-macros/src/quote_in.rs

@@ -3,6 +3,8 @@ use syn::parse::{Parse, ParseStream};
 use syn::spanned::Spanned as _;
 use syn::{Result, Token};
 
+use crate::Ctxt;
+
 pub(crate) struct QuoteIn {
     pub(crate) stream: TokenStream,
 }
@@ -13,15 +15,18 @@ impl Parse for QuoteIn {
         let expr = input.parse::<syn::Expr>()?;
         input.parse::<Token![=>]>()?;
 
-        let receiver = &syn::Ident::new("__genco_macros_toks", expr.span());
-        let parser = crate::quote::Quote::new(receiver);
+        let cx = Ctxt::default();
+
+        let parser = crate::quote::Quote::new(&cx);
         let (req, output) = parser.parse(input)?;
 
-        let check = req.into_check(receiver);
+        let check = req.into_check(&cx.receiver);
+
+        let Ctxt { receiver, module } = &cx;
 
         // Give the assignment its own span to improve diagnostics.
         let assign_mut = q::quote_spanned! { expr.span() =>
-            let #receiver: &mut genco::tokens::Tokens<_> = &mut #expr;
+            let #receiver: &mut #module::tokens::Tokens<_> = &mut #expr;
         };
 
         let stream = q::quote! {{