regex_macros: simplify using AstBuilder & the improved quoting.

char literals now work in a quotation.

There were several instances of duplicated functionality in regex_macros
compared to AstBuilder so refactor those out.

Author: huonw

src/libregex_macros/lib.rs

@@ -24,8 +24,11 @@
 extern crate regex;
 extern crate syntax;
 
+use std::rc::Rc;
+
 use syntax::ast;
 use syntax::codemap;
+use syntax::ext::build::AstBuilder;
 use syntax::ext::base::{
     SyntaxExtension, ExtCtxt, MacResult, MacExpr, DummyResult,
     NormalTT, BasicMacroExpander,
@@ -112,24 +115,26 @@ impl<'a> NfaGen<'a> {
         // expression returned.
         let num_cap_locs = 2 * self.prog.num_captures();
         let num_insts = self.prog.insts.len();
-        let cap_names = self.vec_expr(self.names.as_slice(),
-            |cx, name| match name {
-                &Some(ref name) => {
+        let cap_names = self.vec_expr(self.names.as_slice().iter(),
+            |cx, name| match *name {
+                Some(ref name) => {
                     let name = name.as_slice();
                     quote_expr!(cx, Some(~$name))
                 }
-                &None => quote_expr!(cx, None),
+                None => cx.expr_none(self.sp),
             }
         );
         let prefix_anchor =
             match self.prog.insts.as_slice()[1] {
                 EmptyBegin(flags) if flags & FLAG_MULTI == 0 => true,
                 _ => false,
             };
-        let init_groups = self.vec_from_fn(num_cap_locs,
-                                           |cx| quote_expr!(cx, None));
-        let prefix_bytes = self.vec_expr(self.prog.prefix.as_slice().as_bytes(),
-                                         |cx, b| quote_expr!(cx, $b));
+        let init_groups = self.vec_expr(range(0, num_cap_locs),
+                                        |cx, _| cx.expr_none(self.sp));
+
+        let prefix_lit = Rc::new(Vec::from_slice(self.prog.prefix.as_slice().as_bytes()));
+        let prefix_bytes = self.cx.expr_lit(self.sp, ast::LitBinary(prefix_lit));
+
         let check_prefix = self.check_prefix();
         let step_insts = self.step_insts();
         let add_insts = self.add_insts();
@@ -320,12 +325,11 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str,
             let nextpc = pc + 1;
             let body = match *inst {
                 EmptyBegin(flags) => {
-                    let nl = '\n';
                     let cond =
                         if flags & FLAG_MULTI > 0 {
                             quote_expr!(self.cx,
                                 self.chars.is_begin()
-                                || self.chars.prev == Some($nl)
+                                || self.chars.prev == Some('\n')
                             )
                         } else {
                             quote_expr!(self.cx, self.chars.is_begin())
@@ -336,12 +340,11 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str,
                     })
                 }
                 EmptyEnd(flags) => {
-                    let nl = '\n';
                     let cond =
                         if flags & FLAG_MULTI > 0 {
                             quote_expr!(self.cx,
                                 self.chars.is_end()
-                                || self.chars.cur == Some($nl)
+                                || self.chars.cur == Some('\n')
                             )
                         } else {
                             quote_expr!(self.cx, self.chars.is_end())
@@ -489,16 +492,16 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str,
                     if flags & FLAG_DOTNL > 0 {
                         quote_expr!(self.cx, self.add(nlist, $nextpc, caps))
                     } else {
-                        let nl = '\n'; // no char lits allowed? wtf?
                         quote_expr!(self.cx, {
-                            if self.chars.prev != Some($nl) {
+                            if self.chars.prev != Some('\n') {
                                 self.add(nlist, $nextpc, caps)
                             }
+                            ()
                         })
                     }
                 }
                 // EmptyBegin, EmptyEnd, EmptyWordBoundary, Save, Jump, Split
-                _ => quote_expr!(self.cx, {}),
+                _ => self.empty_block(),
             };
             self.arm_inst(pc, body)
         }).collect::<Vec<ast::Arm>>();
@@ -510,36 +513,30 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str,
     // This avoids a binary search (and is hopefully replaced by a jump
     // table).
     fn match_class(&self, casei: bool, ranges: &[(char, char)]) -> @ast::Expr {
+        let expr_true = quote_expr!(self.cx, true);
+
         let mut arms = ranges.iter().map(|&(mut start, mut end)| {
             if casei {
                 start = start.to_uppercase();
                 end = end.to_uppercase();
             }
-            ast::Arm {
-                attrs: vec!(),
-                pats: vec!(@ast::Pat{
-                    id: ast::DUMMY_NODE_ID,
-                    span: self.sp,
-                    node: ast::PatRange(quote_expr!(self.cx, $start),
-                                        quote_expr!(self.cx, $end)),
-                }),
-                guard: None,
-                body: quote_expr!(self.cx, true),
-            }
+            let pat = self.cx.pat(self.sp, ast::PatRange(quote_expr!(self.cx, $start),
+                                                         quote_expr!(self.cx, $end)));
+            self.cx.arm(self.sp, vec!(pat), expr_true)
         }).collect::<Vec<ast::Arm>>();
 
         arms.push(self.wild_arm_expr(quote_expr!(self.cx, false)));
 
         let match_on = quote_expr!(self.cx, c);
-        self.dummy_expr(ast::ExprMatch(match_on, arms))
+        self.cx.expr_match(self.sp, match_on, arms)
     }
 
     // Generates code for checking a literal prefix of the search string.
     // The code is only generated if the regex *has* a literal prefix.
     // Otherwise, a no-op is returned.
     fn check_prefix(&self) -> @ast::Expr {
         if self.prog.prefix.len() == 0 {
-            quote_expr!(self.cx, {})
+            self.empty_block()
         } else {
             quote_expr!(self.cx,
                 if clist.size == 0 {
@@ -562,24 +559,20 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str,
     // never be used, but is added to satisfy the compiler complaining about
     // non-exhaustive patterns.
     fn match_insts(&self, mut arms: Vec<ast::Arm>) -> @ast::Expr {
-        let mat_pc = quote_expr!(self.cx, pc);
-        arms.push(self.wild_arm_expr(quote_expr!(self.cx, {})));
-        self.dummy_expr(ast::ExprMatch(mat_pc, arms))
+        arms.push(self.wild_arm_expr(self.empty_block()));
+        self.cx.expr_match(self.sp, quote_expr!(self.cx, pc), arms)
+    }
+
+    fn empty_block(&self) -> @ast::Expr {
+        quote_expr!(self.cx, {})
     }
 
     // Creates a match arm for the instruction at `pc` with the expression
     // `body`.
     fn arm_inst(&self, pc: uint, body: @ast::Expr) -> ast::Arm {
-        ast::Arm {
-            attrs: vec!(),
-            pats: vec!(@ast::Pat{
-                id: ast::DUMMY_NODE_ID,
-                span: self.sp,
-                node: ast::PatLit(quote_expr!(self.cx, $pc)),
-            }),
-            guard: None,
-            body: body,
-        }
+        let pc_pat = self.cx.pat_lit(self.sp, quote_expr!(self.cx, $pc));
+
+        self.cx.arm(self.sp, vec!(pc_pat), body)
     }
 
     // Creates a wild-card match arm with the expression `body`.
@@ -596,56 +589,13 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str,
         }
     }
 
-    // Builds a `[a, b, .., len]` expression where each element is the result
-    // of executing `to_expr`.
-    fn vec_from_fn(&self, len: uint, to_expr: |&ExtCtxt| -> @ast::Expr)
-                  -> @ast::Expr {
-        self.vec_expr(Vec::from_elem(len, ()).as_slice(),
-                      |cx, _| to_expr(cx))
-    }
 
     // Converts `xs` to a `[x1, x2, .., xN]` expression by calling `to_expr`
     // on each element in `xs`.
-    fn vec_expr<T>(&self, xs: &[T], to_expr: |&ExtCtxt, &T| -> @ast::Expr)
+    fn vec_expr<T, It: Iterator<T>>(&self, xs: It, to_expr: |&ExtCtxt, T| -> @ast::Expr)
                   -> @ast::Expr {
-        let mut exprs = vec!();
-        for x in xs.iter() {
-            exprs.push(to_expr(self.cx, x))
-        }
-        let vec_exprs = self.dummy_expr(ast::ExprVec(exprs));
-        quote_expr!(self.cx, $vec_exprs)
-    }
-
-    // Creates an expression with a dummy node ID given an underlying
-    // `ast::Expr_`.
-    fn dummy_expr(&self, e: ast::Expr_) -> @ast::Expr {
-        @ast::Expr {
-            id: ast::DUMMY_NODE_ID,
-            node: e,
-            span: self.sp,
-        }
-    }
-}
-
-// This trait is defined in the quote module in the syntax crate, but I
-// don't think it's exported.
-// Interestingly, quote_expr! only requires that a 'to_tokens' method be
-// defined rather than satisfying a particular trait.
-#[doc(hidden)]
-trait ToTokens {
-    fn to_tokens(&self, cx: &ExtCtxt) -> Vec<ast::TokenTree>;
-}
-
-impl ToTokens for char {
-    fn to_tokens(&self, _: &ExtCtxt) -> Vec<ast::TokenTree> {
-        vec!(ast::TTTok(codemap::DUMMY_SP, token::LIT_CHAR((*self) as u32)))
-    }
-}
-
-impl ToTokens for bool {
-    fn to_tokens(&self, _: &ExtCtxt) -> Vec<ast::TokenTree> {
-        let ident = token::IDENT(token::str_to_ident(self.to_str()), false);
-        vec!(ast::TTTok(codemap::DUMMY_SP, ident))
+        let exprs = xs.map(|x| to_expr(self.cx, x)).collect();
+        self.cx.expr_vec(self.sp, exprs)
     }
 }