renaming to adhere to conventions

Author: jbclements

src/libsyntax/ast.rs

@@ -33,8 +33,6 @@ macro_rules! interner_key (
         (-3 as uint, 0u)))
 )
 
-// FIXME(#3534): Replace with the struct-based newtype when it's been
-// implemented.
 struct ident { repr: uint }
 
 impl<S: Encoder> ident: Encodable<S> {

src/libsyntax/ext/base.rs

@@ -25,65 +25,65 @@ use std::map::HashMap;
 
 // new-style macro! tt code:
 //
-//    syntax_expander_tt, syntax_expander_tt_item, mac_result,
-//    normal_tt, item_tt
+//    SyntaxExpanderTT, SyntaxExpanderTTItem, MacResult,
+//    NormalTT, ItemTT
 //
 // also note that ast::mac used to have a bunch of extraneous cases and
 // is now probably a redundant AST node, can be merged with
 // ast::mac_invoc_tt.
 
-struct macro_def {
+struct MacroDef {
     name: ~str,
-    ext: syntax_extension,
+    ext: SyntaxExtension
 }
 
-type item_decorator =
+type ItemDecorator =
     fn@(ext_ctxt, span, ast::meta_item, ~[@ast::item]) -> ~[@ast::item];
 
-struct syntax_expander_tt {
-    expander: syntax_expander_tt_,
-    span: Option<span>,
+struct SyntaxExpanderTT {
+    expander: SyntaxExpanderTTFun,
+    span: Option<span>
 }
 
-type syntax_expander_tt_ = fn@(ext_ctxt, span, ~[ast::token_tree])
-    -> mac_result;
+type SyntaxExpanderTTFun = fn@(ext_ctxt, span, ~[ast::token_tree])
+    -> MacResult;
 
-struct syntax_expander_tt_item {
-    expander: syntax_expander_tt_item_,
-    span: Option<span>,
+struct SyntaxExpanderTTItem {
+    expander: SyntaxExpanderTTItemFun,
+    span: Option<span>
 }
 
-type syntax_expander_tt_item_
-    = fn@(ext_ctxt, span, ast::ident, ~[ast::token_tree]) -> mac_result;
+type SyntaxExpanderTTItemFun
+    = fn@(ext_ctxt, span, ast::ident, ~[ast::token_tree]) -> MacResult;
 
-enum mac_result {
-    mr_expr(@ast::expr),
-    mr_item(@ast::item),
-    mr_any(fn@()-> @ast::expr, fn@()-> Option<@ast::item>, fn@()->@ast::stmt),
-    mr_def(macro_def)
+enum MacResult {
+    MRExpr(@ast::expr),
+    MRItem(@ast::item),
+    MRAny(fn@()-> @ast::expr, fn@()-> Option<@ast::item>, fn@()->@ast::stmt),
+    MRDef(MacroDef)
 }
 
-enum syntax_extension {
+enum SyntaxExtension {
 
     // #[auto_encode] and such
-    item_decorator(item_decorator),
+    ItemDecorator(ItemDecorator),
 
     // Token-tree expanders
-    normal_tt(syntax_expander_tt),
+    NormalTT(SyntaxExpanderTT),
 
     // perhaps macro_rules! will lose its odd special identifier argument,
     // and this can go away also
-    item_tt(syntax_expander_tt_item),
+    ItemTT(SyntaxExpanderTTItem),
 }
 
 // A temporary hard-coded map of methods for expanding syntax extension
 // AST nodes into full ASTs
-fn syntax_expander_table() -> HashMap<~str, syntax_extension> {
-    fn builtin_normal_tt(f: syntax_expander_tt_) -> syntax_extension {
-        normal_tt(syntax_expander_tt {expander: f, span: None})
+fn syntax_expander_table() -> HashMap<~str, SyntaxExtension> {
+    fn builtin_normal_tt(f: SyntaxExpanderTTFun) -> SyntaxExtension {
+        NormalTT(SyntaxExpanderTT{expander: f, span: None})
     }
-    fn builtin_item_tt(f: syntax_expander_tt_item_) -> syntax_extension {
-        item_tt(syntax_expander_tt_item {expander: f, span: None})
+    fn builtin_item_tt(f: SyntaxExpanderTTItemFun) -> SyntaxExtension {
+        ItemTT(SyntaxExpanderTTItem{expander: f, span: None})
     }
     let syntax_expanders = HashMap();
     syntax_expanders.insert(~"macro_rules",
@@ -93,10 +93,10 @@ fn syntax_expander_table() -> HashMap<~str, syntax_extension> {
                             builtin_normal_tt(ext::fmt::expand_syntax_ext));
     syntax_expanders.insert(
         ~"auto_encode",
-        item_decorator(ext::auto_encode::expand_auto_encode));
+        ItemDecorator(ext::auto_encode::expand_auto_encode));
     syntax_expanders.insert(
         ~"auto_decode",
-        item_decorator(ext::auto_encode::expand_auto_decode));
+        ItemDecorator(ext::auto_encode::expand_auto_decode));
     syntax_expanders.insert(~"env",
                             builtin_normal_tt(ext::env::expand_syntax_ext));
     syntax_expanders.insert(~"concat_idents",
@@ -106,10 +106,10 @@ fn syntax_expander_table() -> HashMap<~str, syntax_extension> {
                             builtin_normal_tt(
                                 ext::log_syntax::expand_syntax_ext));
     syntax_expanders.insert(~"deriving_eq",
-                            item_decorator(
+                            ItemDecorator(
                                 ext::deriving::expand_deriving_eq));
     syntax_expanders.insert(~"deriving_iter_bytes",
-                            item_decorator(
+                            ItemDecorator(
                                 ext::deriving::expand_deriving_iter_bytes));
 
     // Quasi-quoting expanders

src/libsyntax/ext/concat_idents.rs

@@ -14,7 +14,7 @@ use ext::base::*;
 use ext::base;
 
 fn expand_syntax_ext(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
-    -> base::mac_result {
+    -> base::MacResult {
     let mut res_str = ~"";
     for tts.eachi |i, e| {
         if i & 1 == 1 {
@@ -48,5 +48,5 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
         ),
         span: sp,
     };
-    mr_expr(e)
+    MRExpr(e)
 }

src/libsyntax/ext/env.rs

@@ -25,7 +25,7 @@ use core::os;
 export expand_syntax_ext;
 
 fn expand_syntax_ext(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
-    -> base::mac_result {
+    -> base::MacResult {
 
     let var = get_single_str_from_tts(cx, sp, tts, "env!");
 
@@ -36,7 +36,7 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
       option::None => mk_uniq_str(cx, sp, ~""),
       option::Some(ref s) => mk_uniq_str(cx, sp, (*s))
     };
-    mr_expr(e)
+    MRExpr(e)
 }
 
 //

src/libsyntax/ext/expand.rs

@@ -22,7 +22,7 @@ use core::option;
 use core::vec;
 use std::map::HashMap;
 
-fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
+fn expand_expr(exts: HashMap<~str, SyntaxExtension>, cx: ext_ctxt,
                e: expr_, s: span, fld: ast_fold,
                orig: fn@(expr_, span, ast_fold) -> (expr_, span))
     -> (expr_, span)
@@ -46,15 +46,13 @@ fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
                     cx.span_fatal(pth.span,
                                   fmt!("macro undefined: '%s'", *extname))
                   }
-                  Some(normal_tt(
-                    syntax_expander_tt { expander: exp, span: exp_sp }
-                  )) => {
+                  Some(NormalTT(SyntaxExpanderTT{expander: exp, span: exp_sp})) => {
                     cx.bt_push(ExpandedFrom({call_site: s,
                                 callie: {name: *extname, span: exp_sp}}));
 
                     let expanded = match exp(cx, (*mac).span, (*tts)) {
-                      mr_expr(e) => e,
-                      mr_any(expr_maker,_,_) => expr_maker(),
+                      MRExpr(e) => e,
+                      MRAny(expr_maker,_,_) => expr_maker(),
                       _ => cx.span_fatal(
                           pth.span, fmt!("non-expr macro in expr pos: %s",
                                          *extname))
@@ -85,11 +83,11 @@ fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
 // attribute prefixing an item, and are interpreted by feeding the item
 // through the named attribute _as a syntax extension_ and splicing in the
 // resulting item vec into place in favour of the decorator. Note that
-// these do _not_ work for macro extensions, just item_decorator ones.
+// these do _not_ work for macro extensions, just ItemDecorator ones.
 //
 // NB: there is some redundancy between this and expand_item, below, and
 // they might benefit from some amount of semantic and language-UI merger.
-fn expand_mod_items(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
+fn expand_mod_items(exts: HashMap<~str, SyntaxExtension>, cx: ext_ctxt,
                     module_: ast::_mod, fld: ast_fold,
                     orig: fn@(ast::_mod, ast_fold) -> ast::_mod)
     -> ast::_mod
@@ -108,8 +106,8 @@ fn expand_mod_items(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
               ast::meta_list(ref n, _) => (*n)
             };
             match exts.find(mname) {
-              None | Some(normal_tt(_)) | Some(item_tt(*)) => items,
-              Some(item_decorator(dec_fn)) => {
+              None | Some(NormalTT(_)) | Some(ItemTT(*)) => items,
+              Some(ItemDecorator(dec_fn)) => {
                   cx.bt_push(ExpandedFrom({call_site: attr.span,
                                            callie: {name: copy mname,
                                                     span: None}}));
@@ -126,7 +124,7 @@ fn expand_mod_items(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
 
 
 // When we enter a module, record it, for the sake of `module!`
-fn expand_item(exts: HashMap<~str, syntax_extension>,
+fn expand_item(exts: HashMap<~str, SyntaxExtension>,
                cx: ext_ctxt, &&it: @ast::item, fld: ast_fold,
                orig: fn@(&&v: @ast::item, ast_fold) -> Option<@ast::item>)
     -> Option<@ast::item>
@@ -153,7 +151,7 @@ fn expand_item(exts: HashMap<~str, syntax_extension>,
 
 // Support for item-position macro invocations, exactly the same
 // logic as for expression-position macro invocations.
-fn expand_item_mac(exts: HashMap<~str, syntax_extension>,
+fn expand_item_mac(exts: HashMap<~str, SyntaxExtension>,
                    cx: ext_ctxt, &&it: @ast::item,
                    fld: ast_fold) -> Option<@ast::item> {
 
@@ -169,7 +167,7 @@ fn expand_item_mac(exts: HashMap<~str, syntax_extension>,
         None => cx.span_fatal(pth.span,
                               fmt!("macro undefined: '%s!'", *extname)),
 
-        Some(normal_tt(ref expand)) => {
+        Some(NormalTT(ref expand)) => {
             if it.ident != parse::token::special_idents::invalid {
                 cx.span_fatal(pth.span,
                               fmt!("macro %s! expects no ident argument, \
@@ -181,7 +179,7 @@ fn expand_item_mac(exts: HashMap<~str, syntax_extension>,
                                               span: (*expand).span}}));
             ((*expand).expander)(cx, it.span, tts)
         }
-        Some(item_tt(ref expand)) => {
+        Some(ItemTT(ref expand)) => {
             if it.ident == parse::token::special_idents::invalid {
                 cx.span_fatal(pth.span,
                               fmt!("macro %s! expects an ident argument",
@@ -197,13 +195,13 @@ fn expand_item_mac(exts: HashMap<~str, syntax_extension>,
     };
 
     let maybe_it = match expanded {
-        mr_item(it) => fld.fold_item(it),
-        mr_expr(_) => cx.span_fatal(pth.span,
+        MRItem(it) => fld.fold_item(it),
+        MRExpr(_) => cx.span_fatal(pth.span,
                                     ~"expr macro in item position: "
                                     + *extname),
-        mr_any(_, item_maker, _) =>
+        MRAny(_, item_maker, _) =>
             option::chain(item_maker(), |i| {fld.fold_item(i)}),
-        mr_def(ref mdef) => {
+        MRDef(ref mdef) => {
             exts.insert((*mdef).name, (*mdef).ext);
             None
         }
@@ -212,7 +210,7 @@ fn expand_item_mac(exts: HashMap<~str, syntax_extension>,
     return maybe_it;
 }
 
-fn expand_stmt(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
+fn expand_stmt(exts: HashMap<~str, SyntaxExtension>, cx: ext_ctxt,
                && s: stmt_, sp: span, fld: ast_fold,
                orig: fn@(&&s: stmt_, span, ast_fold) -> (stmt_, span))
     -> (stmt_, span)
@@ -233,16 +231,15 @@ fn expand_stmt(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
         None =>
             cx.span_fatal(pth.span, fmt!("macro undefined: '%s'", *extname)),
 
-        Some(normal_tt(
-            syntax_expander_tt { expander: exp, span: exp_sp }
-        )) => {
+        Some(NormalTT(
+            SyntaxExpanderTT{expander: exp, span: exp_sp})) => {
             cx.bt_push(ExpandedFrom(
                 {call_site: sp, callie: {name: *extname, span: exp_sp}}));
             let expanded = match exp(cx, mac.span, tts) {
-                mr_expr(e) =>
+                MRExpr(e) =>
                     @ast::spanned { node: stmt_expr(e, cx.next_id()),
                                     span: e.span},
-                mr_any(_,_,stmt_mkr) => stmt_mkr(),
+                MRAny(_,_,stmt_mkr) => stmt_mkr(),
                 _ => cx.span_fatal(
                     pth.span,
                     fmt!("non-stmt macro in stmt pos: %s", *extname))

src/libsyntax/ext/fmt.rs

@@ -28,7 +28,7 @@ use extfmt::ct::*;
 export expand_syntax_ext;
 
 fn expand_syntax_ext(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
-    -> base::mac_result {
+    -> base::MacResult {
     let args = get_exprs_from_tts(cx, copy tts);
     if args.len() == 0 {
         cx.span_fatal(sp, "fmt! takes at least 1 argument.");
@@ -46,7 +46,7 @@ fn expand_syntax_ext(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
         parse_fmt_err_(cx, fmtspan, s)
     };
     let pieces = parse_fmt_string(fmt, parse_fmt_err);
-    mr_expr(pieces_to_expr(cx, sp, pieces, args))
+    MRExpr(pieces_to_expr(cx, sp, pieces, args))
 }
 
 // FIXME (#2249): A lot of these functions for producing expressions can

src/libsyntax/ext/log_syntax.rs

@@ -18,14 +18,14 @@ use core::io::WriterUtil;
 use core::option;
 
 fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, tt: ~[ast::token_tree])
-    -> base::mac_result {
+    -> base::MacResult {
 
     cx.print_backtrace();
     io::stdout().write_line(
         print::pprust::tt_to_str(ast::tt_delim(tt),cx.parse_sess().interner));
 
     //trivial expression
-    mr_expr(@ast::expr {
+    MRExpr(@ast::expr {
         id: cx.next_id(),
         callee_id: cx.next_id(),
         node: ast::expr_rec(~[], option::None),

src/libsyntax/ext/pipes/mod.rs

@@ -70,7 +70,7 @@ mod liveness;
 
 
 fn expand_proto(cx: ext_ctxt, _sp: span, id: ast::ident,
-                tt: ~[ast::token_tree]) -> base::mac_result
+                tt: ~[ast::token_tree]) -> base::MacResult
 {
     let sess = cx.parse_sess();
     let cfg = cx.cfg();
@@ -88,6 +88,6 @@ fn expand_proto(cx: ext_ctxt, _sp: span, id: ast::ident,
     liveness::analyze(proto, cx);
 
     // compile
-    base::mr_item(proto.compile(cx))
+    base::MRItem(proto.compile(cx))
 }