Get rid of structural records in libsyntax and the last bit in librustc.

10 files changed, 120 insertions, 82 deletions

diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index fc55fd84a87..38134d4321a 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -13,6 +13,7 @@ use core::prelude::*;
 use ast;
 use codemap;
 use codemap::{CodeMap, span, ExpnInfo, ExpandedFrom, dummy_sp};
+use codemap::{CallInfo, NameAndSpan};
 use diagnostic::span_handler;
 use ext;
 use parse;
@@ -166,7 +167,7 @@ pub fn syntax_expander_table() -> SyntaxExtensions {
 // -> expn_info of their expansion context stored into their span.
 pub trait ext_ctxt {
     fn codemap(@mut self) -> @CodeMap;
-    fn parse_sess(@mut self) -> parse::parse_sess;
+    fn parse_sess(@mut self) -> @mut parse::ParseSess;
     fn cfg(@mut self) -> ast::crate_cfg;
     fn call_site(@mut self) -> span;
     fn print_backtrace(@mut self);
@@ -190,10 +191,10 @@ pub trait ext_ctxt {
     fn ident_of(@mut self, st: ~str) -> ast::ident;
 }
 
-pub fn mk_ctxt(parse_sess: parse::parse_sess,
+pub fn mk_ctxt(parse_sess: @mut parse::ParseSess,
                cfg: ast::crate_cfg) -> ext_ctxt {
     struct CtxtRepr {
-        parse_sess: parse::parse_sess,
+        parse_sess: @mut parse::ParseSess,
         cfg: ast::crate_cfg,
         backtrace: Option<@ExpnInfo>,
         mod_path: ~[ast::ident],
@@ -201,11 +202,11 @@ pub fn mk_ctxt(parse_sess: parse::parse_sess,
     }
     impl ext_ctxt for CtxtRepr {
         fn codemap(@mut self) -> @CodeMap { self.parse_sess.cm }
-        fn parse_sess(@mut self) -> parse::parse_sess { self.parse_sess }
+        fn parse_sess(@mut self) -> @mut parse::ParseSess { self.parse_sess }
         fn cfg(@mut self) -> ast::crate_cfg { self.cfg }
         fn call_site(@mut self) -> span {
             match self.backtrace {
-                Some(@ExpandedFrom({call_site: cs, _})) => cs,
+                Some(@ExpandedFrom(CallInfo {call_site: cs, _})) => cs,
                 None => self.bug(~"missing top span")
             }
         }
@@ -216,18 +217,18 @@ pub fn mk_ctxt(parse_sess: parse::parse_sess,
         fn mod_path(@mut self) -> ~[ast::ident] { return self.mod_path; }
         fn bt_push(@mut self, ei: codemap::ExpnInfo) {
             match ei {
-              ExpandedFrom({call_site: cs, callie: ref callie}) => {
+              ExpandedFrom(CallInfo {call_site: cs, callee: ref callee}) => {
                 self.backtrace =
-                    Some(@ExpandedFrom({
+                    Some(@ExpandedFrom(CallInfo {
                         call_site: span {lo: cs.lo, hi: cs.hi,
                                          expn_info: self.backtrace},
-                        callie: (*callie)}));
+                        callee: (*callee)}));
               }
             }
         }
         fn bt_pop(@mut self) {
             match self.backtrace {
-              Some(@ExpandedFrom({
+              Some(@ExpandedFrom(CallInfo {
                   call_site: span {expn_info: prev, _}, _
               })) => {
                 self.backtrace = prev
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 0a6840ceea0..55e5d5fbe17 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -19,6 +19,11 @@ use ext::build;
 use core::dvec;
 use core::option;
 
+pub struct Field {
+    ident: ast::ident,
+    ex: @ast::expr
+}
+
 pub fn mk_expr(cx: ext_ctxt,
                sp: codemap::span,
                expr: ast::expr_)
@@ -147,47 +152,37 @@ pub fn mk_base_str(cx: ext_ctxt, sp: span, s: ~str) -> @ast::expr {
 pub fn mk_uniq_str(cx: ext_ctxt, sp: span, s: ~str) -> @ast::expr {
     mk_vstore_e(cx, sp, mk_base_str(cx, sp, s), ast::expr_vstore_uniq)
 }
-pub fn mk_field(sp: span, f: &{ident: ast::ident, ex: @ast::expr})
-             -> ast::field {
+pub fn mk_field(sp: span, f: &Field) -> ast::field {
     codemap::spanned {
         node: ast::field_ { mutbl: ast::m_imm, ident: f.ident, expr: f.ex },
         span: sp,
     }
 }
-pub fn mk_fields(sp: span, fields: ~[{ident: ast::ident, ex: @ast::expr}])
-              -> ~[ast::field] {
+pub fn mk_fields(sp: span, fields: ~[Field]) -> ~[ast::field] {
     fields.map(|f| mk_field(sp, f))
 }
-pub fn mk_rec_e(cx: ext_ctxt,
-                sp: span,
-                fields: ~[{ident: ast::ident, ex: @ast::expr}])
-             -> @ast::expr {
+pub fn mk_rec_e(cx: ext_ctxt, sp: span, fields: ~[Field]) -> @ast::expr {
     mk_expr(cx, sp, ast::expr_rec(mk_fields(sp, fields),
                                   option::None::<@ast::expr>))
 }
-pub fn mk_struct_e(cx: ext_ctxt,
-                   sp: span,
-                   ctor_path: ~[ast::ident],
-                   fields: ~[{ident: ast::ident, ex: @ast::expr}])
-                -> @ast::expr {
+pub fn mk_struct_e(cx: ext_ctxt, sp: span, ctor_path: ~[ast::ident],
+                   fields: ~[Field]) -> @ast::expr {
     mk_expr(cx, sp,
             ast::expr_struct(mk_raw_path(sp, ctor_path),
                              mk_fields(sp, fields),
                                     option::None::<@ast::expr>))
 }
-pub fn mk_global_struct_e(cx: ext_ctxt,
-                          sp: span,
+pub fn mk_global_struct_e(cx: ext_ctxt, sp: span,
                           ctor_path: ~[ast::ident],
-                          fields: ~[{ident: ast::ident, ex: @ast::expr}])
+                          fields: ~[Field])
                        -> @ast::expr {
     mk_expr(cx, sp,
             ast::expr_struct(mk_raw_path_global(sp, ctor_path),
                              mk_fields(sp, fields),
                                     option::None::<@ast::expr>))
 }
-pub fn mk_glob_use(cx: ext_ctxt,
-                   sp: span,
-                   path: ~[ast::ident]) -> @ast::view_item {
+pub fn mk_glob_use(cx: ext_ctxt, sp: span, path: ~[ast::ident])
+            -> @ast::view_item {
     let glob = @codemap::spanned {
         node: ast::view_path_glob(mk_raw_path(sp, path), cx.next_id()),
         span: sp,
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index f9a0de6535b..0b2aaa89d9b 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -14,7 +14,7 @@ use ast::{crate, expr_, expr_mac, mac_invoc_tt};
 use ast::{tt_delim, tt_tok, item_mac, stmt_, stmt_mac, stmt_expr, stmt_semi};
 use ast;
 use attr;
-use codemap::{span, ExpandedFrom};
+use codemap::{span, CallInfo, ExpandedFrom, NameAndSpan};
 use ext::base::*;
 use fold::*;
 use parse::{parser, parse_expr_from_source_str, new_parser_from_tts};
@@ -48,8 +48,12 @@ pub fn expand_expr(exts: SyntaxExtensions, cx: ext_ctxt,
                   }
                   Some(NormalTT(SyntaxExpanderTT{expander: exp,
                                                  span: exp_sp})) => {
-                    cx.bt_push(ExpandedFrom({call_site: s,
-                                callie: {name: *extname, span: exp_sp}}));
+                    cx.bt_push(ExpandedFrom(CallInfo{
+                        call_site: s,
+                        callee: NameAndSpan {
+                            name: *extname, span: exp_sp
+                        }
+                    }));
 
                     let expanded = match exp(cx, (*mac).span, (*tts)) {
                       MRExpr(e) => e,
@@ -105,9 +109,13 @@ pub fn expand_mod_items(exts: SyntaxExtensions, cx: ext_ctxt,
             match exts.find(&mname) {
               None | Some(NormalTT(_)) | Some(ItemTT(*)) => items,
               Some(ItemDecorator(dec_fn)) => {
-                  cx.bt_push(ExpandedFrom({call_site: attr.span,
-                                           callie: {name: /*bad*/ copy *mname,
-                                                    span: None}}));
+                  cx.bt_push(ExpandedFrom(CallInfo {
+                      call_site: attr.span,
+                      callee: NameAndSpan {
+                          name: /*bad*/ copy *mname,
+                          span: None
+                      }
+                  }));
                   let r = dec_fn(cx, attr.span, attr.node.value, items);
                   cx.bt_pop();
                   r
@@ -170,9 +178,13 @@ pub fn expand_item_mac(exts: SyntaxExtensions,
                                     given '%s'", *extname,
                                    *cx.parse_sess().interner.get(it.ident)));
             }
-            cx.bt_push(ExpandedFrom({call_site: it.span,
-                                     callie: {name: *extname,
-                                              span: (*expand).span}}));
+            cx.bt_push(ExpandedFrom(CallInfo {
+                call_site: it.span,
+                callee: NameAndSpan {
+                    name: *extname,
+                    span: (*expand).span
+                }
+            }));
             ((*expand).expander)(cx, it.span, tts)
         }
         Some(ItemTT(ref expand)) => {
@@ -181,9 +193,13 @@ pub fn expand_item_mac(exts: SyntaxExtensions,
                               fmt!("macro %s! expects an ident argument",
                                    *extname));
             }
-            cx.bt_push(ExpandedFrom({call_site: it.span,
-                                     callie: {name: *extname,
-                                              span: (*expand).span}}));
+            cx.bt_push(ExpandedFrom(CallInfo {
+                call_site: it.span,
+                callee: NameAndSpan {
+                    name: *extname,
+                    span: (*expand).span
+                }
+            }));
             ((*expand).expander)(cx, it.span, it.ident, tts)
         }
         _ => cx.span_fatal(
@@ -228,8 +244,10 @@ pub fn expand_stmt(exts: SyntaxExtensions, cx: ext_ctxt,
 
         Some(NormalTT(
             SyntaxExpanderTT{expander: exp, span: exp_sp})) => {
-            cx.bt_push(ExpandedFrom(
-                {call_site: sp, callie: {name: *extname, span: exp_sp}}));
+            cx.bt_push(ExpandedFrom(CallInfo {
+                call_site: sp,
+                callee: NameAndSpan { name: *extname, span: exp_sp }
+            }));
             let expanded = match exp(cx, mac.span, tts) {
                 MRExpr(e) =>
                     @codemap::spanned { node: stmt_expr(e, cx.next_id()),
@@ -321,7 +339,7 @@ pub fn core_macros() -> ~str {
 }";
 }
 
-pub fn expand_crate(parse_sess: parse::parse_sess,
+pub fn expand_crate(parse_sess: @mut parse::ParseSess,
                     cfg: ast::crate_cfg, c: @crate) -> @crate {
     let exts = syntax_expander_table();
     let afp = default_ast_fold();
diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs
index d967912221d..e1e142d06eb 100644
--- a/src/libsyntax/ext/fmt.rs
+++ b/src/libsyntax/ext/fmt.rs
@@ -118,10 +118,18 @@ fn pieces_to_expr(cx: ext_ctxt, sp: span,
                 sp,
                 make_path_vec(cx, @~"Conv"),
                 ~[
-                    {ident: intr.intern(@~"flags"), ex: flags_expr},
-                    {ident: intr.intern(@~"width"), ex: width_expr},
-                    {ident: intr.intern(@~"precision"), ex: precision_expr},
-                    {ident: intr.intern(@~"ty"), ex: ty_expr},
+                    build::Field {
+                        ident: intr.intern(@~"flags"), ex: flags_expr
+                    },
+                    build::Field {
+                        ident: intr.intern(@~"width"), ex: width_expr
+                    },
+                    build::Field {
+                        ident: intr.intern(@~"precision"), ex: precision_expr
+                    },
+                    build::Field {
+                        ident: intr.intern(@~"ty"), ex: ty_expr
+                    },
                 ]
             )
         }
diff --git a/src/libsyntax/ext/pipes/mod.rs b/src/libsyntax/ext/pipes/mod.rs
index 8f0f00f42c0..6d117f5ad23 100644
--- a/src/libsyntax/ext/pipes/mod.rs
+++ b/src/libsyntax/ext/pipes/mod.rs
@@ -68,7 +68,7 @@ pub fn expand_proto(cx: ext_ctxt, _sp: span, id: ast::ident,
                 tt: ~[ast::token_tree]) -> base::MacResult {
     let sess = cx.parse_sess();
     let cfg = cx.cfg();
-    let tt_rdr = new_tt_reader(cx.parse_sess().span_diagnostic,
+    let tt_rdr = new_tt_reader(copy cx.parse_sess().span_diagnostic,
                                cx.parse_sess().interner, None, tt);
     let rdr = tt_rdr as reader;
     let rust_parser = Parser(sess, cfg, rdr.dup());
diff --git a/src/libsyntax/ext/pipes/parse_proto.rs b/src/libsyntax/ext/pipes/parse_proto.rs
index 7c17660cea7..a2f881fc19f 100644
--- a/src/libsyntax/ext/pipes/parse_proto.rs
+++ b/src/libsyntax/ext/pipes/parse_proto.rs
@@ -11,6 +11,7 @@
 // Parsing pipes protocols from token trees.
 
 use ext::pipes::pipec::*;
+use parse::common::SeqSep;
 use parse::parser;
 use parse::token;
 
@@ -26,9 +27,10 @@ pub impl proto_parser for parser::Parser {
     fn parse_proto(&self, id: ~str) -> protocol {
         let proto = protocol(id, self.span);
 
-        self.parse_seq_to_before_end(token::EOF,
-                                     {sep: None, trailing_sep_allowed: false},
-                                     |self| self.parse_state(proto));
+        self.parse_seq_to_before_end(token::EOF, SeqSep {
+                                        sep: None,
+                                        trailing_sep_allowed: false
+                                     }, |self| self.parse_state(proto));
 
         return proto;
     }
@@ -58,9 +60,10 @@ pub impl proto_parser for parser::Parser {
 
         // parse the messages
         self.parse_unspanned_seq(
-            token::LBRACE, token::RBRACE,
-            {sep: Some(token::COMMA), trailing_sep_allowed: true},
-            |self| self.parse_message(state));
+            token::LBRACE, token::RBRACE, SeqSep {
+                sep: Some(token::COMMA),
+                trailing_sep_allowed: true
+            }, |self| self.parse_message(state));
     }
 
     fn parse_message(&self, state: state) {
@@ -68,10 +71,10 @@ pub impl proto_parser for parser::Parser {
 
         let args = if self.token == token::LPAREN {
             self.parse_unspanned_seq(token::LPAREN,
-                                     token::RPAREN,
-                                     {sep: Some(token::COMMA),
-                                      trailing_sep_allowed: true},
-                                     |p| p.parse_ty(false))
+                                     token::RPAREN, SeqSep {
+                                        sep: Some(token::COMMA),
+                                        trailing_sep_allowed: true
+                                     }, |p| p.parse_ty(false))
         }
         else { ~[] };
 
@@ -82,10 +85,10 @@ pub impl proto_parser for parser::Parser {
             let name = *self.interner.get(self.parse_ident());
             let ntys = if self.token == token::LT {
                 self.parse_unspanned_seq(token::LT,
-                                         token::GT,
-                                         {sep: Some(token::COMMA),
-                                          trailing_sep_allowed: true},
-                                         |p| p.parse_ty(false))
+                                         token::GT, SeqSep {
+                                            sep: Some(token::COMMA),
+                                            trailing_sep_allowed: true
+                                         }, |p| p.parse_ty(false))
             }
             else { ~[] };
             Some(next_state {state: name, tys: ntys})
diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
index dadc2e527b6..26c38c945c7 100644
--- a/src/libsyntax/ext/source_util.rs
+++ b/src/libsyntax/ext/source_util.rs
@@ -10,6 +10,7 @@
 
 use codemap;
 use codemap::{FileMap, Loc, Pos, ExpandedFrom, span};
+use codemap::{CallInfo, NameAndSpan};
 use ext::base::*;
 use ext::base;
 use ext::build::{mk_base_vec_e, mk_uint, mk_u8, mk_base_str};
@@ -22,10 +23,13 @@ use core::str;
 use core::vec;
 
 fn topmost_expn_info(expn_info: @codemap::ExpnInfo) -> @codemap::ExpnInfo {
-    let ExpandedFrom({call_site, _}) = *expn_info;
+    let ExpandedFrom(CallInfo { call_site, _ }) = *expn_info;
     match call_site.expn_info {
         Some(next_expn_info) => {
-            let ExpandedFrom({callie: {name, _}, _}) = *next_expn_info;
+            let ExpandedFrom(CallInfo {
+                callee: NameAndSpan {name, _},
+                _
+            }) = *next_expn_info;
             // Don't recurse into file using "include!"
             if name == ~"include" { return expn_info; }
 
diff --git a/src/libsyntax/ext/trace_macros.rs b/src/libsyntax/ext/trace_macros.rs
index a87882c4f20..f662f0337bf 100644
--- a/src/libsyntax/ext/trace_macros.rs
+++ b/src/libsyntax/ext/trace_macros.rs
@@ -22,7 +22,7 @@ pub fn expand_trace_macros(cx: ext_ctxt, sp: span,
                            tt: ~[ast::token_tree]) -> base::MacResult {
     let sess = cx.parse_sess();
     let cfg = cx.cfg();
-    let tt_rdr = new_tt_reader(cx.parse_sess().span_diagnostic,
+    let tt_rdr = new_tt_reader(copy cx.parse_sess().span_diagnostic,
                                cx.parse_sess().interner, None, tt);
     let rdr = tt_rdr as reader;
     let rust_parser = Parser(sess, cfg, rdr.dup());
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index df10f15c709..d51ddae6db2 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -14,7 +14,7 @@ use codemap::{BytePos, mk_sp};
 use codemap;
 use parse::common::*; //resolve bug?
 use parse::lexer::*; //resolve bug?
-use parse::parse_sess;
+use parse::ParseSess;
 use parse::parser::Parser;
 use parse::token::{Token, EOF, to_str, nonterminal};
 use parse::token;
@@ -101,7 +101,7 @@ eof: [a $( a )* a b ·]
 nonempty body. */
 
 pub enum matcher_pos_up { /* to break a circularity */
-    matcher_pos_up(Option<matcher_pos>)
+    matcher_pos_up(Option<~MatcherPos>)
 }
 
 pub fn is_some(&&mpu: matcher_pos_up) -> bool {
@@ -111,7 +111,7 @@ pub fn is_some(&&mpu: matcher_pos_up) -> bool {
     }
 }
 
-pub type matcher_pos = ~{
+pub struct MatcherPos {
     elts: ~[ast::matcher], // maybe should be /&? Need to understand regions.
     sep: Option<Token>,
     mut idx: uint,
@@ -119,9 +119,9 @@ pub type matcher_pos = ~{
     matches: ~[DVec<@named_match>],
     match_lo: uint, match_hi: uint,
     sp_lo: BytePos,
-};
+}
 
-pub fn copy_up(&& mpu: matcher_pos_up) -> matcher_pos {
+pub fn copy_up(&& mpu: matcher_pos_up) -> ~MatcherPos {
     match &mpu {
       &matcher_pos_up(Some(ref mp)) => copy (*mp),
       _ => fail!()
@@ -139,7 +139,7 @@ pub fn count_names(ms: &[matcher]) -> uint {
 
 #[allow(non_implicitly_copyable_typarams)]
 pub fn initial_matcher_pos(ms: ~[matcher], sep: Option<Token>, lo: BytePos)
-                        -> matcher_pos {
+                        -> ~MatcherPos {
     let mut match_idx_hi = 0u;
     for ms.each() |elt| {
         match elt.node {
@@ -152,9 +152,16 @@ pub fn initial_matcher_pos(ms: ~[matcher], sep: Option<Token>, lo: BytePos)
           }
         }
     }
-    ~{elts: ms, sep: sep, mut idx: 0u, mut up: matcher_pos_up(None),
-      matches: copy vec::from_fn(count_names(ms), |_i| dvec::DVec()),
-      match_lo: 0u, match_hi: match_idx_hi, sp_lo: lo}
+    ~MatcherPos {
+        elts: ms,
+        sep: sep,
+        mut idx: 0u,
+        mut up: matcher_pos_up(None),
+        matches: copy vec::from_fn(count_names(ms), |_i| dvec::DVec()),
+        match_lo: 0u,
+        match_hi: match_idx_hi,
+        sp_lo: lo
+    }
 }
 
 // named_match is a pattern-match result for a single ast::match_nonterminal:
@@ -181,11 +188,11 @@ pub enum named_match {
     matched_nonterminal(nonterminal)
 }
 
-pub type earley_item = matcher_pos;
+pub type earley_item = ~MatcherPos;
 
-pub fn nameize(p_s: parse_sess, ms: ~[matcher], res: ~[@named_match])
+pub fn nameize(p_s: @mut ParseSess, ms: ~[matcher], res: ~[@named_match])
             -> HashMap<ident,@named_match> {
-    fn n_rec(p_s: parse_sess, m: matcher, res: ~[@named_match],
+    fn n_rec(p_s: @mut ParseSess, m: matcher, res: ~[@named_match],
              ret_val: HashMap<ident, @named_match>) {
         match m {
           codemap::spanned {node: match_tok(_), _} => (),
@@ -216,7 +223,7 @@ pub enum parse_result {
     error(codemap::span, ~str)
 }
 
-pub fn parse_or_else(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader,
+pub fn parse_or_else(sess: @mut ParseSess, cfg: ast::crate_cfg, rdr: reader,
                      ms: ~[matcher]) -> HashMap<ident, @named_match> {
     match parse(sess, cfg, rdr, ms) {
       success(m) => m,
@@ -225,7 +232,7 @@ pub fn parse_or_else(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader,
     }
 }
 
-pub fn parse(sess: parse_sess,
+pub fn parse(sess: @mut ParseSess,
              cfg: ast::crate_cfg,
              rdr: reader,
              ms: ~[matcher])
@@ -321,8 +328,10 @@ pub fn parse(sess: parse_sess,
                     let matches = vec::map(ei.matches, // fresh, same size:
                                            |_m| DVec::<@named_match>());
                     let ei_t = ei;
-                    cur_eis.push(~{
-                        elts: (*matchers), sep: (*sep), mut idx: 0u,
+                    cur_eis.push(~MatcherPos {
+                        elts: (*matchers),
+                        sep: (*sep),
+                        mut idx: 0u,
                         mut up: matcher_pos_up(Some(ei_t)),
                         matches: matches,
                         match_lo: match_idx_lo, match_hi: match_idx_hi,
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index dd0dfd8e443..f42bb01f7c2 100644
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -53,7 +53,7 @@ pub fn add_new_extension(cx: ext_ctxt, sp: span, name: ident,
 
 
     // Parse the macro_rules! invocation (`none` is for no interpolations):
-    let arg_reader = new_tt_reader(cx.parse_sess().span_diagnostic,
+    let arg_reader = new_tt_reader(copy cx.parse_sess().span_diagnostic,
                                    cx.parse_sess().interner, None, arg);
     let argument_map = parse_or_else(cx.parse_sess(), cx.cfg(),
                                      arg_reader as reader, argument_gram);