libsyntax: Make the parser mutable

Author: pcwalton

src/libsyntax/ext/asm.rs

@@ -39,9 +39,9 @@ fn next_state(s: State) -> Option<State> {
 
 pub fn expand_asm(cx: &mut ExtCtxt, sp: Span, tts: &[ast::token_tree])
                -> base::MacResult {
-    let p = parse::new_parser_from_tts(cx.parse_sess(),
-                                       cx.cfg(),
-                                       tts.to_owned());
+    let mut p = parse::new_parser_from_tts(cx.parse_sess(),
+                                           cx.cfg(),
+                                           tts.to_owned());
 
     let mut asm = @"";
     let mut asm_str_style = None;

src/libsyntax/ext/base.rs

@@ -442,9 +442,9 @@ pub fn get_single_str_from_tts(cx: &ExtCtxt,
 pub fn get_exprs_from_tts(cx: &ExtCtxt,
                           sp: Span,
                           tts: &[ast::token_tree]) -> ~[@ast::Expr] {
-    let p = parse::new_parser_from_tts(cx.parse_sess(),
-                                       cx.cfg(),
-                                       tts.to_owned());
+    let mut p = parse::new_parser_from_tts(cx.parse_sess(),
+                                           cx.cfg(),
+                                           tts.to_owned());
     let mut es = ~[];
     while *p.token != token::EOF {
         if es.len() != 0 && !p.eat(&token::COMMA) {

src/libsyntax/ext/cfg.rs

@@ -26,7 +26,9 @@ use parse::token;
 use parse::attr::parser_attr;
 
 pub fn expand_cfg(cx: &mut ExtCtxt, sp: Span, tts: &[ast::token_tree]) -> base::MacResult {
-    let p = parse::new_parser_from_tts(cx.parse_sess(), cx.cfg(), tts.to_owned());
+    let mut p = parse::new_parser_from_tts(cx.parse_sess(),
+                                           cx.cfg(),
+                                           tts.to_owned());
 
     let mut cfgs = ~[];
     // parse `cfg!(meta_item, meta_item(x,y), meta_item="foo", ...)`

src/libsyntax/ext/format.rs

@@ -53,11 +53,11 @@ struct Context<'a> {
 impl<'a> Context<'a> {
     /// Parses the arguments from the given list of tokens, returning None if
     /// there's a parse error so we can continue parsing other format! expressions.
-    fn parse_args(&mut self, sp: Span,
-                  tts: &[ast::token_tree]) -> (@ast::Expr, Option<@ast::Expr>) {
-        let p = rsparse::new_parser_from_tts(self.ecx.parse_sess(),
-                                             self.ecx.cfg(),
-                                             tts.to_owned());
+    fn parse_args(&mut self, sp: Span, tts: &[ast::token_tree])
+                  -> (@ast::Expr, Option<@ast::Expr>) {
+        let mut p = rsparse::new_parser_from_tts(self.ecx.parse_sess(),
+                                                 self.ecx.cfg(),
+                                                 tts.to_owned());
         // Parse the leading function expression (maybe a block, maybe a path)
         let extra = p.parse_expr();
         if !p.eat(&token::COMMA) {

src/libsyntax/ext/quote.rs

@@ -579,21 +579,17 @@ fn mk_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::token_tree])
     ss
 }
 
-fn expand_tts(cx: &ExtCtxt,
-              sp: Span,
-              tts: &[ast::token_tree]) -> (@ast::Expr, @ast::Expr) {
-
+fn expand_tts(cx: &ExtCtxt, sp: Span, tts: &[ast::token_tree])
+              -> (@ast::Expr, @ast::Expr) {
     // NB: It appears that the main parser loses its mind if we consider
     // $foo as a tt_nonterminal during the main parse, so we have to re-parse
     // under quote_depth > 0. This is silly and should go away; the _guess_ is
     // it has to do with transition away from supporting old-style macros, so
     // try removing it when enough of them are gone.
 
-    let p = parse::new_parser_from_tts(
-        cx.parse_sess(),
-        cx.cfg(),
-        tts.to_owned()
-    );
+    let mut p = parse::new_parser_from_tts(cx.parse_sess(),
+                                           cx.cfg(),
+                                           tts.to_owned());
     *p.quote_depth += 1u;
 
     let cx_expr = p.parse_expr();

src/libsyntax/ext/source_util.rs

@@ -81,9 +81,13 @@ pub fn expand_include(cx: &mut ExtCtxt, sp: Span, tts: &[ast::token_tree])
     -> base::MacResult {
     let file = get_single_str_from_tts(cx, sp, tts, "include!");
     // The file will be added to the code map by the parser
-    let p = parse::new_sub_parser_from_file(
-        cx.parse_sess(), cx.cfg(),
-        &res_rel_file(cx, sp, &Path::new(file)), sp);
+    let mut p =
+        parse::new_sub_parser_from_file(cx.parse_sess(),
+                                        cx.cfg(),
+                                        &res_rel_file(cx,
+                                                      sp,
+                                                      &Path::new(file)),
+                                        sp);
     base::MRExpr(p.parse_expr())
 }
 

src/libsyntax/ext/trace_macros.rs

@@ -26,7 +26,7 @@ pub fn expand_trace_macros(cx: &mut ExtCtxt,
                                None,
                                tt.to_owned());
     let rdr = tt_rdr as @mut reader;
-    let rust_parser = Parser(sess, cfg.clone(), rdr.dup());
+    let mut rust_parser = Parser(sess, cfg.clone(), rdr.dup());
 
     if rust_parser.is_keyword(keywords::True) {
         cx.set_trace_macros(true);
@@ -38,7 +38,7 @@ pub fn expand_trace_macros(cx: &mut ExtCtxt,
 
     rust_parser.bump();
 
-    let rust_parser = Parser(sess, cfg, rdr.dup());
+    let mut rust_parser = Parser(sess, cfg, rdr.dup());
     let result = rust_parser.parse_expr();
     base::MRExpr(result)
 }

src/libsyntax/ext/tt/macro_parser.rs

@@ -403,13 +403,13 @@ pub fn parse(
                 }
                 rdr.next_token();
             } else /* bb_eis.len() == 1 */ {
-                let rust_parser = Parser(sess, cfg.clone(), rdr.dup());
+                let mut rust_parser = Parser(sess, cfg.clone(), rdr.dup());
 
                 let mut ei = bb_eis.pop();
                 match ei.elts[ei.idx].node {
                   match_nonterminal(_, ref name, idx) => {
                     ei.matches[idx].push(@matched_nonterminal(
-                        parse_nt(&rust_parser, ident_to_str(name))));
+                        parse_nt(&mut rust_parser, ident_to_str(name))));
                     ei.idx += 1u;
                   }
                   _ => fail!()
@@ -426,7 +426,7 @@ pub fn parse(
     }
 }
 
-pub fn parse_nt(p: &Parser, name: &str) -> nonterminal {
+pub fn parse_nt(p: &mut Parser, name: &str) -> nonterminal {
     match name {
       "item" => match p.parse_item(~[]) {
         Some(i) => token::nt_item(i),

src/libsyntax/ext/tt/macro_rules.rs

@@ -24,10 +24,11 @@ use parse::attr::parser_attr;
 use parse::token::{get_ident_interner, special_idents, gensym_ident, ident_to_str};
 use parse::token::{FAT_ARROW, SEMI, nt_matchers, nt_tt, EOF};
 use print;
+use std::cell::RefCell;
 use util::small_vector::SmallVector;
 
 struct ParserAnyMacro {
-    parser: @Parser,
+    parser: RefCell<Parser>,
 }
 
 impl ParserAnyMacro {
@@ -38,28 +39,36 @@ impl ParserAnyMacro {
     /// fail!(); } )` doesn't get picked up by .parse_expr(), but it's
     /// allowed to be there.
     fn ensure_complete_parse(&self, allow_semi: bool) {
-        if allow_semi && *self.parser.token == SEMI {
-            self.parser.bump()
+        let mut parser = self.parser.borrow_mut();
+        if allow_semi && *parser.get().token == SEMI {
+            parser.get().bump()
         }
-        if *self.parser.token != EOF {
-            let msg = format!("macro expansion ignores token `{}` and any following",
-                              self.parser.this_token_to_str());
-            self.parser.span_err(*self.parser.span, msg);
+        if *parser.get().token != EOF {
+            let token_str = parser.get().this_token_to_str();
+            let msg = format!("macro expansion ignores token `{}` and any \
+                               following",
+                              token_str);
+            let span = *parser.get().span;
+            parser.get().span_err(span, msg);
         }
     }
 }
 
 impl AnyMacro for ParserAnyMacro {
     fn make_expr(&self) -> @ast::Expr {
-        let ret = self.parser.parse_expr();
+        let ret = {
+            let mut parser = self.parser.borrow_mut();
+            parser.get().parse_expr()
+        };
         self.ensure_complete_parse(true);
         ret
     }
     fn make_items(&self) -> SmallVector<@ast::item> {
         let mut ret = SmallVector::zero();
         loop {
-            let attrs = self.parser.parse_outer_attributes();
-            match self.parser.parse_item(attrs) {
+            let mut parser = self.parser.borrow_mut();
+            let attrs = parser.get().parse_outer_attributes();
+            match parser.get().parse_item(attrs) {
                 Some(item) => ret.push(item),
                 None => break
             }
@@ -68,8 +77,11 @@ impl AnyMacro for ParserAnyMacro {
         ret
     }
     fn make_stmt(&self) -> @ast::Stmt {
-        let attrs = self.parser.parse_outer_attributes();
-        let ret = self.parser.parse_stmt(attrs);
+        let ret = {
+            let mut parser = self.parser.borrow_mut();
+            let attrs = parser.get().parse_outer_attributes();
+            parser.get().parse_stmt(attrs)
+        };
         self.ensure_complete_parse(true);
         ret
     }
@@ -142,14 +154,14 @@ fn generic_extension(cx: &ExtCtxt,
                 // rhs has holes ( `$id` and `$(...)` that need filled)
                 let trncbr = new_tt_reader(s_d, Some(named_matches),
                                            rhs);
-                let p = @Parser(cx.parse_sess(),
-                                cx.cfg(),
-                                trncbr as @mut reader);
+                let p = Parser(cx.parse_sess(),
+                               cx.cfg(),
+                               trncbr as @mut reader);
 
                 // Let the context choose how to interpret the result.
                 // Weird, but useful for X-macros.
                 return MRAny(@ParserAnyMacro {
-                    parser: p,
+                    parser: RefCell::new(p),
                 } as @AnyMacro)
               }
               failure(sp, ref msg) => if sp.lo >= best_fail_spot.lo {

src/libsyntax/parse/attr.rs

@@ -17,19 +17,18 @@ use parse::token::INTERPOLATED;
 
 // a parser that can parse attributes.
 pub trait parser_attr {
-    fn parse_outer_attributes(&self) -> ~[ast::Attribute];
-    fn parse_attribute(&self, permit_inner: bool) -> ast::Attribute;
-    fn parse_inner_attrs_and_next(&self) ->
-        (~[ast::Attribute], ~[ast::Attribute]);
-    fn parse_meta_item(&self) -> @ast::MetaItem;
-    fn parse_meta_seq(&self) -> ~[@ast::MetaItem];
-    fn parse_optional_meta(&self) -> ~[@ast::MetaItem];
+    fn parse_outer_attributes(&mut self) -> ~[ast::Attribute];
+    fn parse_attribute(&mut self, permit_inner: bool) -> ast::Attribute;
+    fn parse_inner_attrs_and_next(&mut self)
+                                  -> (~[ast::Attribute], ~[ast::Attribute]);
+    fn parse_meta_item(&mut self) -> @ast::MetaItem;
+    fn parse_meta_seq(&mut self) -> ~[@ast::MetaItem];
+    fn parse_optional_meta(&mut self) -> ~[@ast::MetaItem];
 }
 
 impl parser_attr for Parser {
-
     // Parse attributes that appear before an item
-    fn parse_outer_attributes(&self) -> ~[ast::Attribute] {
+    fn parse_outer_attributes(&mut self) -> ~[ast::Attribute] {
         let mut attrs: ~[ast::Attribute] = ~[];
         loop {
             debug!("parse_outer_attributes: self.token={:?}",
@@ -66,7 +65,7 @@ impl parser_attr for Parser {
     //
     // if permit_inner is true, then a trailing `;` indicates an inner
     // attribute
-    fn parse_attribute(&self, permit_inner: bool) -> ast::Attribute {
+    fn parse_attribute(&mut self, permit_inner: bool) -> ast::Attribute {
         debug!("parse_attributes: permit_inner={:?} self.token={:?}",
                permit_inner, self.token);
         let (span, value) = match *self.token {
@@ -85,8 +84,9 @@ impl parser_attr for Parser {
                 (mk_sp(lo, hi), meta_item)
             }
             _ => {
+                let token_str = self.this_token_to_str();
                 self.fatal(format!("expected `\\#` but found `{}`",
-                                   self.this_token_to_str()));
+                                   token_str));
             }
         };
         let style = if permit_inner && *self.token == token::SEMI {
@@ -115,7 +115,7 @@ impl parser_attr for Parser {
     // matches inner_attrs* outer_attr?
     // you can make the 'next' field an Option, but the result is going to be
     // more useful as a vector.
-    fn parse_inner_attrs_and_next(&self)
+    fn parse_inner_attrs_and_next(&mut self)
                                   -> (~[ast::Attribute], ~[ast::Attribute]) {
         let mut inner_attrs: ~[ast::Attribute] = ~[];
         let mut next_outer_attrs: ~[ast::Attribute] = ~[];
@@ -154,9 +154,10 @@ impl parser_attr for Parser {
     // matches meta_item = IDENT
     // | IDENT = lit
     // | IDENT meta_seq
-    fn parse_meta_item(&self) -> @ast::MetaItem {
+    fn parse_meta_item(&mut self) -> @ast::MetaItem {
         let lo = self.span.lo;
-        let name = self.id_to_str(self.parse_ident());
+        let ident = self.parse_ident();
+        let name = self.id_to_str(ident);
         match *self.token {
             token::EQ => {
                 self.bump();
@@ -187,14 +188,14 @@ impl parser_attr for Parser {
     }
 
     // matches meta_seq = ( COMMASEP(meta_item) )
-    fn parse_meta_seq(&self) -> ~[@ast::MetaItem] {
+    fn parse_meta_seq(&mut self) -> ~[@ast::MetaItem] {
         self.parse_seq(&token::LPAREN,
                        &token::RPAREN,
                        seq_sep_trailing_disallowed(token::COMMA),
                        |p| p.parse_meta_item()).node
     }
 
-    fn parse_optional_meta(&self) -> ~[@ast::MetaItem] {
+    fn parse_optional_meta(&mut self) -> ~[@ast::MetaItem] {
         match *self.token {
             token::LPAREN => self.parse_meta_seq(),
             _ => ~[]