libsyntax: De-export libsyntax. rs=deexporting

15 files changed, 229 insertions, 231 deletions

diff --git a/src/libsyntax/ext/auto_encode.rs b/src/libsyntax/ext/auto_encode.rs
index 1bb516e831f..e4ad518cc80 100644
--- a/src/libsyntax/ext/auto_encode.rs
+++ b/src/libsyntax/ext/auto_encode.rs
@@ -101,16 +101,13 @@ use core::vec;
 use std::map;
 use std::map::HashMap;
 
-export expand_auto_encode;
-export expand_auto_decode;
-
 // Transitional reexports so qquote can find the paths it is looking for
 mod syntax {
     pub use ext;
     pub use parse;
 }
 
-fn expand_auto_encode(
+pub fn expand_auto_encode(
     cx: ext_ctxt,
     span: span,
     _mitem: ast::meta_item,
@@ -165,7 +162,7 @@ fn expand_auto_encode(
     }
 }
 
-fn expand_auto_decode(
+pub fn expand_auto_decode(
     cx: ext_ctxt,
     span: span,
     _mitem: ast::meta_item,
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index a8c05296390..d0974e0654c 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -32,38 +32,38 @@ use std::map::HashMap;
 // is now probably a redundant AST node, can be merged with
 // ast::mac_invoc_tt.
 
-struct MacroDef {
+pub struct MacroDef {
     name: ~str,
     ext: SyntaxExtension
 }
 
-type ItemDecorator =
+pub type ItemDecorator =
     fn@(ext_ctxt, span, ast::meta_item, ~[@ast::item]) -> ~[@ast::item];
 
-struct SyntaxExpanderTT {
+pub struct SyntaxExpanderTT {
     expander: SyntaxExpanderTTFun,
     span: Option<span>
 }
 
-type SyntaxExpanderTTFun = fn@(ext_ctxt, span, ~[ast::token_tree])
-    -> MacResult;
+pub type SyntaxExpanderTTFun = fn@(ext_ctxt, span, ~[ast::token_tree])
+                                -> MacResult;
 
-struct SyntaxExpanderTTItem {
+pub struct SyntaxExpanderTTItem {
     expander: SyntaxExpanderTTItemFun,
     span: Option<span>
 }
 
-type SyntaxExpanderTTItemFun
+pub type SyntaxExpanderTTItemFun
     = fn@(ext_ctxt, span, ast::ident, ~[ast::token_tree]) -> MacResult;
 
-enum MacResult {
+pub enum MacResult {
     MRExpr(@ast::expr),
     MRItem(@ast::item),
     MRAny(fn@()-> @ast::expr, fn@()-> Option<@ast::item>, fn@()->@ast::stmt),
     MRDef(MacroDef)
 }
 
-enum SyntaxExtension {
+pub enum SyntaxExtension {
 
     // #[auto_encode] and such
     ItemDecorator(ItemDecorator),
@@ -78,7 +78,7 @@ enum SyntaxExtension {
 
 // A temporary hard-coded map of methods for expanding syntax extension
 // AST nodes into full ASTs
-fn syntax_expander_table() -> HashMap<~str, SyntaxExtension> {
+pub fn syntax_expander_table() -> HashMap<~str, SyntaxExtension> {
     fn builtin_normal_tt(f: SyntaxExpanderTTFun) -> SyntaxExtension {
         NormalTT(SyntaxExpanderTT{expander: f, span: None})
     }
@@ -161,7 +161,7 @@ fn syntax_expander_table() -> HashMap<~str, SyntaxExtension> {
 // One of these is made during expansion and incrementally updated as we go;
 // when a macro expansion occurs, the resulting nodes have the backtrace()
 // -> expn_info of their expansion context stored into their span.
-trait ext_ctxt {
+pub trait ext_ctxt {
     fn codemap() -> @CodeMap;
     fn parse_sess() -> parse::parse_sess;
     fn cfg() -> ast::crate_cfg;
@@ -187,8 +187,8 @@ trait ext_ctxt {
     fn ident_of(st: ~str) -> ast::ident;
 }
 
-fn mk_ctxt(parse_sess: parse::parse_sess,
-           cfg: ast::crate_cfg) -> ext_ctxt {
+pub fn mk_ctxt(parse_sess: parse::parse_sess,
+               cfg: ast::crate_cfg) -> ext_ctxt {
     type ctxt_repr = {parse_sess: parse::parse_sess,
                       cfg: ast::crate_cfg,
                       mut backtrace: Option<@ExpnInfo>,
@@ -281,7 +281,7 @@ fn mk_ctxt(parse_sess: parse::parse_sess,
     move ((move imp) as ext_ctxt)
 }
 
-fn expr_to_str(cx: ext_ctxt, expr: @ast::expr, err_msg: ~str) -> ~str {
+pub fn expr_to_str(cx: ext_ctxt, expr: @ast::expr, err_msg: ~str) -> ~str {
     match expr.node {
       ast::expr_lit(l) => match l.node {
         ast::lit_str(s) => return *s,
@@ -291,9 +291,9 @@ fn expr_to_str(cx: ext_ctxt, expr: @ast::expr, err_msg: ~str) -> ~str {
     }
 }
 
-fn expr_to_ident(cx: ext_ctxt,
-                 expr: @ast::expr,
-                 err_msg: ~str) -> ast::ident {
+pub fn expr_to_ident(cx: ext_ctxt,
+                     expr: @ast::expr,
+                     err_msg: ~str) -> ast::ident {
     match expr.node {
       ast::expr_path(p) => {
         if vec::len(p.types) > 0u || vec::len(p.idents) != 1u {
@@ -305,15 +305,17 @@ fn expr_to_ident(cx: ext_ctxt,
     }
 }
 
-fn check_zero_tts(cx: ext_ctxt, sp: span, tts: &[ast::token_tree],
-                  name: &str) {
+pub fn check_zero_tts(cx: ext_ctxt, sp: span, tts: &[ast::token_tree],
+                      name: &str) {
     if tts.len() != 0 {
         cx.span_fatal(sp, fmt!("%s takes no arguments", name));
     }
 }
 
-fn get_single_str_from_tts(cx: ext_ctxt, sp: span, tts: &[ast::token_tree],
-                           name: &str) -> ~str {
+pub fn get_single_str_from_tts(cx: ext_ctxt,
+                               sp: span,
+                               tts: &[ast::token_tree],
+                               name: &str) -> ~str {
     if tts.len() != 1 {
         cx.span_fatal(sp, fmt!("%s takes 1 argument.", name));
     }
@@ -325,8 +327,8 @@ fn get_single_str_from_tts(cx: ext_ctxt, sp: span, tts: &[ast::token_tree],
     }
 }
 
-fn get_exprs_from_tts(cx: ext_ctxt, tts: ~[ast::token_tree])
-    -> ~[@ast::expr] {
+pub fn get_exprs_from_tts(cx: ext_ctxt, tts: ~[ast::token_tree])
+                       -> ~[@ast::expr] {
     let p = parse::new_parser_from_tts(cx.parse_sess(),
                                        cx.cfg(),
                                        tts);
diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs
index 5ff69539606..d4da5a2034e 100644
--- a/src/libsyntax/ext/build.rs
+++ b/src/libsyntax/ext/build.rs
@@ -19,7 +19,10 @@ use ext::build;
 use core::dvec;
 use core::option;
 
-fn mk_expr(cx: ext_ctxt, sp: codemap::span, expr: ast::expr_) -> @ast::expr {
+pub fn mk_expr(cx: ext_ctxt,
+               sp: codemap::span,
+               expr: ast::expr_)
+            -> @ast::expr {
     @ast::expr {
         id: cx.next_id(),
         callee_id: cx.next_id(),
@@ -28,34 +31,33 @@ fn mk_expr(cx: ext_ctxt, sp: codemap::span, expr: ast::expr_) -> @ast::expr {
     }
 }
 
-fn mk_lit(cx: ext_ctxt, sp: span, lit: ast::lit_) -> @ast::expr {
+pub fn mk_lit(cx: ext_ctxt, sp: span, lit: ast::lit_) -> @ast::expr {
     let sp_lit = @ast::spanned { node: lit, span: sp };
     mk_expr(cx, sp, ast::expr_lit(sp_lit))
 }
-fn mk_int(cx: ext_ctxt, sp: span, i: int) -> @ast::expr {
+pub fn mk_int(cx: ext_ctxt, sp: span, i: int) -> @ast::expr {
     let lit = ast::lit_int(i as i64, ast::ty_i);
     return mk_lit(cx, sp, lit);
 }
-fn mk_uint(cx: ext_ctxt, sp: span, u: uint) -> @ast::expr {
+pub fn mk_uint(cx: ext_ctxt, sp: span, u: uint) -> @ast::expr {
     let lit = ast::lit_uint(u as u64, ast::ty_u);
     return mk_lit(cx, sp, lit);
 }
-fn mk_u8(cx: ext_ctxt, sp: span, u: u8) -> @ast::expr {
+pub fn mk_u8(cx: ext_ctxt, sp: span, u: u8) -> @ast::expr {
     let lit = ast::lit_uint(u as u64, ast::ty_u8);
     return mk_lit(cx, sp, lit);
 }
-fn mk_binary(cx: ext_ctxt, sp: span, op: ast::binop,
-             lhs: @ast::expr, rhs: @ast::expr)
-   -> @ast::expr {
+pub fn mk_binary(cx: ext_ctxt, sp: span, op: ast::binop,
+                 lhs: @ast::expr, rhs: @ast::expr) -> @ast::expr {
     cx.next_id(); // see ast_util::op_expr_callee_id
     mk_expr(cx, sp, ast::expr_binary(op, lhs, rhs))
 }
-fn mk_unary(cx: ext_ctxt, sp: span, op: ast::unop, e: @ast::expr)
-    -> @ast::expr {
+pub fn mk_unary(cx: ext_ctxt, sp: span, op: ast::unop, e: @ast::expr)
+             -> @ast::expr {
     cx.next_id(); // see ast_util::op_expr_callee_id
     mk_expr(cx, sp, ast::expr_unary(op, e))
 }
-fn mk_raw_path(sp: span, idents: ~[ast::ident]) -> @ast::path {
+pub fn mk_raw_path(sp: span, idents: ~[ast::ident]) -> @ast::path {
     let p = @ast::path { span: sp,
                          global: false,
                          idents: idents,
@@ -63,126 +65,129 @@ fn mk_raw_path(sp: span, idents: ~[ast::ident]) -> @ast::path {
                          types: ~[] };
     return p;
 }
-fn mk_raw_path_(sp: span,
-                idents: ~[ast::ident],
-                +types: ~[@ast::Ty])
-             -> @ast::path {
+pub fn mk_raw_path_(sp: span,
+                    idents: ~[ast::ident],
+                    +types: ~[@ast::Ty])
+                 -> @ast::path {
     @ast::path { span: sp,
                  global: false,
                  idents: idents,
                  rp: None,
                  types: move types }
 }
-fn mk_raw_path_global(sp: span, idents: ~[ast::ident]) -> @ast::path {
+pub fn mk_raw_path_global(sp: span, idents: ~[ast::ident]) -> @ast::path {
     @ast::path { span: sp,
                  global: true,
                  idents: idents,
                  rp: None,
                  types: ~[] }
 }
-fn mk_path(cx: ext_ctxt, sp: span, idents: ~[ast::ident]) ->
-    @ast::expr {
+pub fn mk_path(cx: ext_ctxt, sp: span, idents: ~[ast::ident]) -> @ast::expr {
     mk_expr(cx, sp, ast::expr_path(mk_raw_path(sp, idents)))
 }
-fn mk_path_global(cx: ext_ctxt, sp: span, idents: ~[ast::ident]) ->
-    @ast::expr {
+pub fn mk_path_global(cx: ext_ctxt, sp: span, idents: ~[ast::ident])
+                   -> @ast::expr {
     mk_expr(cx, sp, ast::expr_path(mk_raw_path_global(sp, idents)))
 }
-fn mk_access_(cx: ext_ctxt, sp: span, p: @ast::expr, m: ast::ident)
-    -> @ast::expr {
+pub fn mk_access_(cx: ext_ctxt, sp: span, p: @ast::expr, m: ast::ident)
+               -> @ast::expr {
     mk_expr(cx, sp, ast::expr_field(p, m, ~[]))
 }
-fn mk_access(cx: ext_ctxt, sp: span, p: ~[ast::ident], m: ast::ident)
-    -> @ast::expr {
+pub fn mk_access(cx: ext_ctxt, sp: span, p: ~[ast::ident], m: ast::ident)
+              -> @ast::expr {
     let pathexpr = mk_path(cx, sp, p);
     return mk_access_(cx, sp, pathexpr, m);
 }
-fn mk_addr_of(cx: ext_ctxt, sp: span, e: @ast::expr) -> @ast::expr {
+pub fn mk_addr_of(cx: ext_ctxt, sp: span, e: @ast::expr) -> @ast::expr {
     return mk_expr(cx, sp, ast::expr_addr_of(ast::m_imm, e));
 }
-fn mk_call_(cx: ext_ctxt, sp: span, fn_expr: @ast::expr,
-            args: ~[@ast::expr]) -> @ast::expr {
+pub fn mk_call_(cx: ext_ctxt, sp: span, fn_expr: @ast::expr,
+                args: ~[@ast::expr]) -> @ast::expr {
     mk_expr(cx, sp, ast::expr_call(fn_expr, args, false))
 }
-fn mk_call(cx: ext_ctxt, sp: span, fn_path: ~[ast::ident],
-             args: ~[@ast::expr]) -> @ast::expr {
+pub fn mk_call(cx: ext_ctxt, sp: span, fn_path: ~[ast::ident],
+               args: ~[@ast::expr]) -> @ast::expr {
     let pathexpr = mk_path(cx, sp, fn_path);
     return mk_call_(cx, sp, pathexpr, args);
 }
-fn mk_call_global(cx: ext_ctxt, sp: span, fn_path: ~[ast::ident],
-                  args: ~[@ast::expr]) -> @ast::expr {
+pub fn mk_call_global(cx: ext_ctxt, sp: span, fn_path: ~[ast::ident],
+                      args: ~[@ast::expr]) -> @ast::expr {
     let pathexpr = mk_path_global(cx, sp, fn_path);
     return mk_call_(cx, sp, pathexpr, args);
 }
 // e = expr, t = type
-fn mk_base_vec_e(cx: ext_ctxt, sp: span, exprs: ~[@ast::expr]) ->
-   @ast::expr {
+pub fn mk_base_vec_e(cx: ext_ctxt, sp: span, exprs: ~[@ast::expr])
+                  -> @ast::expr {
     let vecexpr = ast::expr_vec(exprs, ast::m_imm);
     mk_expr(cx, sp, vecexpr)
 }
-fn mk_vstore_e(cx: ext_ctxt, sp: span, expr: @ast::expr,
-               vst: ast::expr_vstore) ->
+pub fn mk_vstore_e(cx: ext_ctxt, sp: span, expr: @ast::expr,
+                   vst: ast::expr_vstore) ->
    @ast::expr {
     mk_expr(cx, sp, ast::expr_vstore(expr, vst))
 }
-fn mk_uniq_vec_e(cx: ext_ctxt, sp: span, exprs: ~[@ast::expr]) ->
-   @ast::expr {
+pub fn mk_uniq_vec_e(cx: ext_ctxt, sp: span, exprs: ~[@ast::expr])
+                  -> @ast::expr {
     mk_vstore_e(cx, sp, mk_base_vec_e(cx, sp, exprs), ast::expr_vstore_uniq)
 }
-fn mk_slice_vec_e(cx: ext_ctxt, sp: span, exprs: ~[@ast::expr]) ->
-   @ast::expr {
+pub fn mk_slice_vec_e(cx: ext_ctxt, sp: span, exprs: ~[@ast::expr])
+                   -> @ast::expr {
     mk_vstore_e(cx, sp, mk_base_vec_e(cx, sp, exprs),
                 ast::expr_vstore_slice)
 }
-fn mk_fixed_vec_e(cx: ext_ctxt, sp: span, exprs: ~[@ast::expr]) ->
-   @ast::expr {
+pub fn mk_fixed_vec_e(cx: ext_ctxt, sp: span, exprs: ~[@ast::expr])
+                   -> @ast::expr {
     mk_vstore_e(cx, sp, mk_base_vec_e(cx, sp, exprs),
                 ast::expr_vstore_fixed(None))
 }
-fn mk_base_str(cx: ext_ctxt, sp: span, s: ~str) -> @ast::expr {
+pub fn mk_base_str(cx: ext_ctxt, sp: span, s: ~str) -> @ast::expr {
     let lit = ast::lit_str(@s);
     return mk_lit(cx, sp, lit);
 }
-fn mk_uniq_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)
 }
-fn mk_field(sp: span, f: &{ident: ast::ident, ex: @ast::expr})
-    -> ast::field {
+pub fn mk_field(sp: span, f: &{ident: ast::ident, ex: @ast::expr})
+             -> ast::field {
     ast::spanned {
         node: ast::field_ { mutbl: ast::m_imm, ident: f.ident, expr: f.ex },
         span: sp,
     }
 }
-fn mk_fields(sp: span, fields: ~[{ident: ast::ident, ex: @ast::expr}]) ->
-    ~[ast::field] {
+pub fn mk_fields(sp: span, fields: ~[{ident: ast::ident, ex: @ast::expr}])
+              -> ~[ast::field] {
     move fields.map(|f| mk_field(sp, f))
 }
-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: ~[{ident: ast::ident, ex: @ast::expr}])
+             -> @ast::expr {
     mk_expr(cx, sp, ast::expr_rec(mk_fields(sp, fields),
                                   option::None::<@ast::expr>))
 }
-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: ~[{ident: ast::ident, ex: @ast::expr}])
+                -> @ast::expr {
     mk_expr(cx, sp,
             ast::expr_struct(mk_raw_path(sp, ctor_path),
                              mk_fields(sp, fields),
                                     option::None::<@ast::expr>))
 }
-fn mk_global_struct_e(cx: ext_ctxt, sp: span,
-               ctor_path: ~[ast::ident],
-               fields: ~[{ident: ast::ident, ex: @ast::expr}]) ->
-    @ast::expr {
+pub fn mk_global_struct_e(cx: ext_ctxt,
+                          sp: span,
+                          ctor_path: ~[ast::ident],
+                          fields: ~[{ident: ast::ident, ex: @ast::expr}])
+                       -> @ast::expr {
     mk_expr(cx, sp,
             ast::expr_struct(mk_raw_path_global(sp, ctor_path),
                              mk_fields(sp, fields),
                                     option::None::<@ast::expr>))
 }
-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 = @ast::spanned {
         node: ast::view_path_glob(mk_raw_path(sp, path), cx.next_id()),
         span: sp,
@@ -192,8 +197,8 @@ fn mk_glob_use(cx: ext_ctxt, sp: span,
                       vis: ast::private,
                       span: sp }
 }
-fn mk_local(cx: ext_ctxt, sp: span, mutbl: bool,
-            ident: ast::ident, ex: @ast::expr) -> @ast::stmt {
+pub fn mk_local(cx: ext_ctxt, sp: span, mutbl: bool,
+                ident: ast::ident, ex: @ast::expr) -> @ast::stmt {
 
     let pat = @ast::pat {
         id: cx.next_id(),
@@ -217,10 +222,10 @@ fn mk_local(cx: ext_ctxt, sp: span, mutbl: bool,
     let decl = ast::spanned {node: ast::decl_local(~[local]), span: sp};
     @ast::spanned { node: ast::stmt_decl(@decl, cx.next_id()), span: sp }
 }
-fn mk_block(cx: ext_ctxt, span: span,
-            view_items: ~[@ast::view_item],
-            stmts: ~[@ast::stmt],
-            expr: Option<@ast::expr>) -> @ast::expr {
+pub fn mk_block(cx: ext_ctxt, span: span,
+                view_items: ~[@ast::view_item],
+                stmts: ~[@ast::stmt],
+                expr: Option<@ast::expr>) -> @ast::expr {
     let blk = ast::spanned {
         node: ast::blk_ {
              view_items: view_items,
@@ -233,7 +238,10 @@ fn mk_block(cx: ext_ctxt, span: span,
     };
     mk_expr(cx, span, ast::expr_block(blk))
 }
-fn mk_block_(cx: ext_ctxt, span: span, +stmts: ~[@ast::stmt]) -> ast::blk {
+pub fn mk_block_(cx: ext_ctxt,
+                 span: span,
+                 +stmts: ~[@ast::stmt])
+              -> ast::blk {
     ast::spanned {
         node: ast::blk_ {
             view_items: ~[],
@@ -245,7 +253,10 @@ fn mk_block_(cx: ext_ctxt, span: span, +stmts: ~[@ast::stmt]) -> ast::blk {
         span: span,
     }
 }
-fn mk_simple_block(cx: ext_ctxt, span: span, expr: @ast::expr) -> ast::blk {
+pub fn mk_simple_block(cx: ext_ctxt,
+                       span: span,
+                       expr: @ast::expr)
+                    -> ast::blk {
     ast::spanned {
         node: ast::blk_ {
             view_items: ~[],
@@ -257,80 +268,83 @@ fn mk_simple_block(cx: ext_ctxt, span: span, expr: @ast::expr) -> ast::blk {
         span: span,
     }
 }
-fn mk_copy(cx: ext_ctxt, sp: span, e: @ast::expr) -> @ast::expr {
+pub fn mk_copy(cx: ext_ctxt, sp: span, e: @ast::expr) -> @ast::expr {
     mk_expr(cx, sp, ast::expr_copy(e))
 }
-fn mk_managed(cx: ext_ctxt, sp: span, e: @ast::expr) -> @ast::expr {
+pub fn mk_managed(cx: ext_ctxt, sp: span, e: @ast::expr) -> @ast::expr {
     mk_expr(cx, sp, ast::expr_unary(ast::box(ast::m_imm), e))
 }
-fn mk_pat(cx: ext_ctxt, span: span, +pat: ast::pat_) -> @ast::pat {
+pub fn mk_pat(cx: ext_ctxt, span: span, +pat: ast::pat_) -> @ast::pat {
     @ast::pat { id: cx.next_id(), node: pat, span: span }
 }
-fn mk_pat_ident(cx: ext_ctxt, span: span, ident: ast::ident) -> @ast::pat {
+pub fn mk_pat_ident(cx: ext_ctxt,
+                    span: span,
+                    ident: ast::ident)
+                 -> @ast::pat {
     mk_pat_ident_with_binding_mode(cx, span, ident, ast::bind_by_value)
 }
-fn mk_pat_ident_with_binding_mode(cx: ext_ctxt,
-                                  span: span,
-                                  ident: ast::ident,
-                                  bm: ast::binding_mode) -> @ast::pat {
+pub fn mk_pat_ident_with_binding_mode(cx: ext_ctxt,
+                                      span: span,
+                                      ident: ast::ident,
+                                      bm: ast::binding_mode) -> @ast::pat {
     let path = mk_raw_path(span, ~[ ident ]);
     let pat = ast::pat_ident(bm, path, None);
     mk_pat(cx, span, move pat)
 }
-fn mk_pat_enum(cx: ext_ctxt,
-               span: span,
-               path: @ast::path,
-               +subpats: ~[@ast::pat])
-            -> @ast::pat {
+pub fn mk_pat_enum(cx: ext_ctxt,
+                   span: span,
+                   path: @ast::path,
+                   +subpats: ~[@ast::pat])
+                -> @ast::pat {
     let pat = ast::pat_enum(path, Some(move subpats));
     mk_pat(cx, span, move pat)
 }
-fn mk_pat_struct(cx: ext_ctxt,
-                 span: span,
-                 path: @ast::path,
-                 +field_pats: ~[ast::field_pat])
-              -> @ast::pat {
+pub fn mk_pat_struct(cx: ext_ctxt,
+                     span: span,
+                     path: @ast::path,
+                     +field_pats: ~[ast::field_pat])
+                  -> @ast::pat {
     let pat = ast::pat_struct(path, move field_pats, false);
     mk_pat(cx, span, move pat)
 }
-fn mk_bool(cx: ext_ctxt, span: span, value: bool) -> @ast::expr {
+pub fn mk_bool(cx: ext_ctxt, span: span, value: bool) -> @ast::expr {
     let lit_expr = ast::expr_lit(@ast::spanned { node: ast::lit_bool(value),
                                                  span: span });
     build::mk_expr(cx, span, move lit_expr)
 }
-fn mk_stmt(cx: ext_ctxt, span: span, expr: @ast::expr) -> @ast::stmt {
+pub fn mk_stmt(cx: ext_ctxt, span: span, expr: @ast::expr) -> @ast::stmt {
     let stmt_ = ast::stmt_semi(expr, cx.next_id());
     @ast::spanned { node: move stmt_, span: span }
 }
-fn mk_ty_path(cx: ext_ctxt,
-              span: span,
-              idents: ~[ ast::ident ])
-           -> @ast::Ty {
+pub fn mk_ty_path(cx: ext_ctxt,
+                  span: span,
+                  idents: ~[ ast::ident ])
+               -> @ast::Ty {
     let ty = build::mk_raw_path(span, idents);
     let ty = ast::ty_path(ty, cx.next_id());
     let ty = @ast::Ty { id: cx.next_id(), node: move ty, span: span };
     ty
 }
-fn mk_ty_path_global(cx: ext_ctxt,
-                     span: span,
-                     idents: ~[ ast::ident ])
-                  -> @ast::Ty {
+pub fn mk_ty_path_global(cx: ext_ctxt,
+                         span: span,
+                         idents: ~[ ast::ident ])
+                      -> @ast::Ty {
     let ty = build::mk_raw_path_global(span, idents);
     let ty = ast::ty_path(ty, cx.next_id());
     let ty = @ast::Ty { id: cx.next_id(), node: move ty, span: span };
     ty
 }
-fn mk_simple_ty_path(cx: ext_ctxt,
-                     span: span,
-                     ident: ast::ident)
-                  -> @ast::Ty {
+pub fn mk_simple_ty_path(cx: ext_ctxt,
+                         span: span,
+                         ident: ast::ident)
+                      -> @ast::Ty {
     mk_ty_path(cx, span, ~[ ident ])
 }
-fn mk_arg(cx: ext_ctxt,
-          span: span,
-          ident: ast::ident,
-          ty: @ast::Ty)
-       -> ast::arg {
+pub fn mk_arg(cx: ext_ctxt,
+              span: span,
+              ident: ast::ident,
+              ty: @ast::Ty)
+           -> ast::arg {
     let arg_pat = mk_pat_ident(cx, span, ident);
     ast::arg {
         mode: ast::infer(cx.next_id()),
@@ -340,13 +354,13 @@ fn mk_arg(cx: ext_ctxt,
         id: cx.next_id()
     }
 }
-fn mk_fn_decl(+inputs: ~[ast::arg], output: @ast::Ty) -> ast::fn_decl {
+pub fn mk_fn_decl(+inputs: ~[ast::arg], output: @ast::Ty) -> ast::fn_decl {
     ast::fn_decl { inputs: inputs, output: output, cf: ast::return_val }
 }
-fn mk_ty_param(cx: ext_ctxt,
-               ident: ast::ident,
-               bounds: @~[ast::ty_param_bound])
-            -> ast::ty_param {
+pub fn mk_ty_param(cx: ext_ctxt,
+                   ident: ast::ident,
+                   bounds: @~[ast::ty_param_bound])
+                -> ast::ty_param {
     ast::ty_param { ident: ident, id: cx.next_id(), bounds: bounds }
 }
 
diff --git a/src/libsyntax/ext/concat_idents.rs b/src/libsyntax/ext/concat_idents.rs
index 3d5d0b42cd0..d83a9f39c5b 100644
--- a/src/libsyntax/ext/concat_idents.rs
+++ b/src/libsyntax/ext/concat_idents.rs
@@ -13,7 +13,7 @@ use core::prelude::*;
 use ext::base::*;
 use ext::base;
 
-fn expand_syntax_ext(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
+pub fn expand_syntax_ext(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     -> base::MacResult {
     let mut res_str = ~"";
     for tts.eachi |i, e| {
diff --git a/src/libsyntax/ext/env.rs b/src/libsyntax/ext/env.rs
index ad827377ac4..4420c020a0b 100644
--- a/src/libsyntax/ext/env.rs
+++ b/src/libsyntax/ext/env.rs
@@ -22,9 +22,7 @@ use ext::build::mk_uniq_str;
 use core::option;
 use core::os;
 
-export expand_syntax_ext;
-
-fn expand_syntax_ext(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
+pub fn expand_syntax_ext(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     -> base::MacResult {
 
     let var = get_single_str_from_tts(cx, sp, tts, "env!");
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 068b372c069..0ab94710f40 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -22,11 +22,10 @@ use core::option;
 use core::vec;
 use std::map::HashMap;
 
-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)
-{
+pub 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) {
     return match e {
       // expr_mac should really be expr_ext or something; it's the
       // entry-point for all syntax extensions.
@@ -88,11 +87,10 @@ fn expand_expr(exts: HashMap<~str, SyntaxExtension>, cx: ext_ctxt,
 //
 // 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, SyntaxExtension>, cx: ext_ctxt,
-                    module_: ast::_mod, fld: ast_fold,
-                    orig: fn@(ast::_mod, ast_fold) -> ast::_mod)
-    -> ast::_mod
-{
+pub 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 {
     // Fold the contents first:
     let module_ = orig(module_, fld);
 
@@ -125,11 +123,10 @@ fn expand_mod_items(exts: HashMap<~str, SyntaxExtension>, cx: ext_ctxt,
 
 
 // When we enter a module, record it, for the sake of `module!`
-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>
-{
+pub 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> {
     let is_mod = match it.node {
       ast::item_mod(_) | ast::item_foreign_mod(_) => true,
       _ => false
@@ -152,9 +149,9 @@ fn expand_item(exts: HashMap<~str, SyntaxExtension>,
 
 // Support for item-position macro invocations, exactly the same
 // logic as for expression-position macro invocations.
-fn expand_item_mac(exts: HashMap<~str, SyntaxExtension>,
-                   cx: ext_ctxt, &&it: @ast::item,
-                   fld: ast_fold) -> Option<@ast::item> {
+pub fn expand_item_mac(exts: HashMap<~str, SyntaxExtension>,
+                       cx: ext_ctxt, &&it: @ast::item,
+                       fld: ast_fold) -> Option<@ast::item> {
 
     let (pth, tts) = match it.node {
         item_mac(ast::spanned { node: mac_invoc_tt(pth, ref tts), _}) => {
@@ -211,11 +208,10 @@ fn expand_item_mac(exts: HashMap<~str, SyntaxExtension>,
     return maybe_it;
 }
 
-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)
-{
+pub 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) {
 
     let (mac, pth, tts, semi) = match s {
         stmt_mac(ref mac, semi) => {
@@ -267,7 +263,7 @@ fn expand_stmt(exts: HashMap<~str, SyntaxExtension>, cx: ext_ctxt,
 }
 
 
-fn new_span(cx: ext_ctxt, sp: span) -> span {
+pub fn new_span(cx: ext_ctxt, sp: span) -> span {
     /* this discards information in the case of macro-defining macros */
     return span {lo: sp.lo, hi: sp.hi, expn_info: cx.backtrace()};
 }
@@ -277,7 +273,7 @@ fn new_span(cx: ext_ctxt, sp: span) -> span {
 // is substantially more mature, these should move from here, into a
 // compiled part of libcore at very least.
 
-fn core_macros() -> ~str {
+pub fn core_macros() -> ~str {
     return
 ~"{
     macro_rules! ignore (($($x:tt)*) => (()))
@@ -327,8 +323,8 @@ fn core_macros() -> ~str {
 }";
 }
 
-fn expand_crate(parse_sess: parse::parse_sess,
-                cfg: ast::crate_cfg, c: @crate) -> @crate {
+pub fn expand_crate(parse_sess: parse::parse_sess,
+                    cfg: ast::crate_cfg, c: @crate) -> @crate {
     let exts = syntax_expander_table();
     let afp = default_ast_fold();
     let cx: ext_ctxt = mk_ctxt(parse_sess, cfg);
diff --git a/src/libsyntax/ext/fmt.rs b/src/libsyntax/ext/fmt.rs
index 65890351e39..845d26f77cb 100644
--- a/src/libsyntax/ext/fmt.rs
+++ b/src/libsyntax/ext/fmt.rs
@@ -25,9 +25,7 @@ use ext::base;
 use ext::build::*;
 use extfmt::ct::*;
 
-export expand_syntax_ext;
-
-fn expand_syntax_ext(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
+pub fn expand_syntax_ext(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     -> base::MacResult {
     let args = get_exprs_from_tts(cx, copy tts);
     if args.len() == 0 {
diff --git a/src/libsyntax/ext/log_syntax.rs b/src/libsyntax/ext/log_syntax.rs
index b92e0b58bd5..f713e5ce7d8 100644
--- a/src/libsyntax/ext/log_syntax.rs
+++ b/src/libsyntax/ext/log_syntax.rs
@@ -17,8 +17,10 @@ use print;
 use core::io::WriterUtil;
 use core::option;
 
-fn expand_syntax_ext(cx: ext_ctxt, sp: codemap::span, tt: ~[ast::token_tree])
-    -> base::MacResult {
+pub fn expand_syntax_ext(cx: ext_ctxt,
+                         sp: codemap::span,
+                         tt: ~[ast::token_tree])
+                      -> base::MacResult {
 
     cx.print_backtrace();
     io::stdout().write_line(
diff --git a/src/libsyntax/ext/pipes/liveness.rs b/src/libsyntax/ext/pipes/liveness.rs
index 2e73002a890..b0a8f49c7a2 100644
--- a/src/libsyntax/ext/pipes/liveness.rs
+++ b/src/libsyntax/ext/pipes/liveness.rs
@@ -40,7 +40,7 @@ updating the states using rule (2) until there are no changes.
 use core::prelude::*;
 
 use ext::base::ext_ctxt;
-use ext::pipes::protocol;
+use ext::pipes::proto::protocol;
 
 use core::str;
 use std::bitv::{Bitv};
diff --git a/src/libsyntax/ext/pipes/mod.rs b/src/libsyntax/ext/pipes/mod.rs
index c84ab54af2b..8f0f00f42c0 100644
--- a/src/libsyntax/ext/pipes/mod.rs
+++ b/src/libsyntax/ext/pipes/mod.rs
@@ -56,17 +56,16 @@ use parse::parser::Parser;
 
 use core::option::None;
 
-mod ast_builder;
-mod parse_proto;
-mod pipec;
-mod proto;
-mod check;
-mod liveness;
+pub mod ast_builder;
+pub mod parse_proto;
+pub mod pipec;
+pub mod proto;
+pub mod check;
+pub mod liveness;
 
 
-fn expand_proto(cx: ext_ctxt, _sp: span, id: ast::ident,
-                tt: ~[ast::token_tree]) -> base::MacResult
-{
+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,
diff --git a/src/libsyntax/ext/source_util.rs b/src/libsyntax/ext/source_util.rs
index 4ecbbdc9760..07dacc7c1b3 100644
--- a/src/libsyntax/ext/source_util.rs
+++ b/src/libsyntax/ext/source_util.rs
@@ -21,17 +21,8 @@ use core::result;
 use core::str;
 use core::vec;
 
-export expand_line;
-export expand_col;
-export expand_file;
-export expand_stringify;
-export expand_mod;
-export expand_include;
-export expand_include_str;
-export expand_include_bin;
-
 /* line!(): expands to the current line number */
-fn expand_line(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
+pub fn expand_line(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     -> base::MacResult {
     base::check_zero_tts(cx, sp, tts, "line!");
     let loc = cx.codemap().lookup_char_pos(sp.lo);
@@ -39,7 +30,7 @@ fn expand_line(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
 }
 
 /* col!(): expands to the current column number */
-fn expand_col(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
+pub fn expand_col(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     -> base::MacResult {
     base::check_zero_tts(cx, sp, tts, "col!");
     let loc = cx.codemap().lookup_char_pos(sp.lo);
@@ -49,7 +40,7 @@ fn expand_col(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
 /* file!(): expands to the current filename */
 /* The filemap (`loc.file`) contains a bunch more information we could spit
  * out if we wanted. */
-fn expand_file(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
+pub fn expand_file(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     -> base::MacResult {
     base::check_zero_tts(cx, sp, tts, "file!");
     let Loc { file: @FileMap { name: filename, _ }, _ } =
@@ -57,13 +48,13 @@ fn expand_file(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     base::MRExpr(mk_base_str(cx, sp, filename))
 }
 
-fn expand_stringify(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
+pub fn expand_stringify(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     -> base::MacResult {
     let s = pprust::tts_to_str(tts, cx.parse_sess().interner);
     base::MRExpr(mk_base_str(cx, sp, s))
 }
 
-fn expand_mod(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
+pub fn expand_mod(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     -> base::MacResult {
     base::check_zero_tts(cx, sp, tts, "module_path!");
     base::MRExpr(mk_base_str(cx, sp,
@@ -71,7 +62,7 @@ fn expand_mod(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
                                   |x| cx.str_of(*x)), ~"::")))
 }
 
-fn expand_include(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
+pub fn expand_include(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     -> base::MacResult {
     let file = get_single_str_from_tts(cx, sp, tts, "include!");
     let p = parse::new_sub_parser_from_file(
@@ -80,7 +71,7 @@ fn expand_include(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     base::MRExpr(p.parse_expr())
 }
 
-fn expand_include_str(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
+pub fn expand_include_str(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     -> base::MacResult {
     let file = get_single_str_from_tts(cx, sp, tts, "include_str!");
     let res = io::read_whole_file_str(&res_rel_file(cx, sp, &Path(file)));
@@ -94,7 +85,7 @@ fn expand_include_str(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     base::MRExpr(mk_base_str(cx, sp, result::unwrap(res)))
 }
 
-fn expand_include_bin(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
+pub fn expand_include_bin(cx: ext_ctxt, sp: span, tts: ~[ast::token_tree])
     -> base::MacResult {
     let file = get_single_str_from_tts(cx, sp, tts, "include_bin!");
     match io::read_whole_file(&res_rel_file(cx, sp, &Path(file))) {
diff --git a/src/libsyntax/ext/trace_macros.rs b/src/libsyntax/ext/trace_macros.rs
index e4ea46416d3..a87882c4f20 100644
--- a/src/libsyntax/ext/trace_macros.rs
+++ b/src/libsyntax/ext/trace_macros.rs
@@ -18,8 +18,8 @@ use parse::parser::Parser;
 
 use core::option::None;
 
-fn expand_trace_macros(cx: ext_ctxt, sp: span,
-                       tt: ~[ast::token_tree]) -> base::MacResult {
+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,
diff --git a/src/libsyntax/ext/tt/macro_parser.rs b/src/libsyntax/ext/tt/macro_parser.rs
index a990e53c1a7..4c0550b3c3a 100644
--- a/src/libsyntax/ext/tt/macro_parser.rs
+++ b/src/libsyntax/ext/tt/macro_parser.rs
@@ -101,18 +101,18 @@ eof: [a $( a )* a b ·]
 /* to avoid costly uniqueness checks, we require that `match_seq` always has a
 nonempty body. */
 
-enum matcher_pos_up { /* to break a circularity */
+pub enum matcher_pos_up { /* to break a circularity */
     matcher_pos_up(Option<matcher_pos>)
 }
 
-fn is_some(&&mpu: matcher_pos_up) -> bool {
+pub fn is_some(&&mpu: matcher_pos_up) -> bool {
     match &mpu {
       &matcher_pos_up(None) => false,
       _ => true
     }
 }
 
-type matcher_pos = ~{
+pub type matcher_pos = ~{
     elts: ~[ast::matcher], // maybe should be /&? Need to understand regions.
     sep: Option<Token>,
     mut idx: uint,
@@ -122,14 +122,14 @@ type matcher_pos = ~{
     sp_lo: BytePos,
 };
 
-fn copy_up(&& mpu: matcher_pos_up) -> matcher_pos {
+pub fn copy_up(&& mpu: matcher_pos_up) -> matcher_pos {
     match &mpu {
       &matcher_pos_up(Some(ref mp)) => copy (*mp),
       _ => fail
     }
 }
 
-fn count_names(ms: &[matcher]) -> uint {
+pub fn count_names(ms: &[matcher]) -> uint {
     vec::foldl(0u, ms, |ct, m| {
         ct + match m.node {
           match_tok(_) => 0u,
@@ -139,8 +139,8 @@ fn count_names(ms: &[matcher]) -> uint {
 }
 
 #[allow(non_implicitly_copyable_typarams)]
-fn initial_matcher_pos(ms: ~[matcher], sep: Option<Token>, lo: BytePos)
-    -> matcher_pos {
+pub fn initial_matcher_pos(ms: ~[matcher], sep: Option<Token>, lo: BytePos)
+                        -> matcher_pos {
     let mut match_idx_hi = 0u;
     for ms.each() |elt| {
         match elt.node {
@@ -177,15 +177,15 @@ fn initial_matcher_pos(ms: ~[matcher], sep: Option<Token>, lo: BytePos)
 // only on the nesting depth of ast::match_seqs in the originating
 // ast::matcher it was derived from.
 
-enum named_match {
+pub enum named_match {
     matched_seq(~[@named_match], codemap::span),
     matched_nonterminal(nonterminal)
 }
 
-type earley_item = matcher_pos;
+pub type earley_item = matcher_pos;
 
-fn nameize(p_s: parse_sess, ms: ~[matcher], res: ~[@named_match])
-    -> HashMap<ident,@named_match> {
+pub fn nameize(p_s: parse_sess, ms: ~[matcher], res: ~[@named_match])
+            -> HashMap<ident,@named_match> {
     fn n_rec(p_s: parse_sess, m: matcher, res: ~[@named_match],
              ret_val: HashMap<ident, @named_match>) {
         match m {
@@ -211,14 +211,14 @@ fn nameize(p_s: parse_sess, ms: ~[matcher], res: ~[@named_match])
     return ret_val;
 }
 
-enum parse_result {
+pub enum parse_result {
     success(HashMap<ident, @named_match>),
     failure(codemap::span, ~str),
     error(codemap::span, ~str)
 }
 
-fn parse_or_else(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader,
-                 ms: ~[matcher]) -> HashMap<ident, @named_match> {
+pub fn parse_or_else(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader,
+                     ms: ~[matcher]) -> HashMap<ident, @named_match> {
     match parse(sess, cfg, rdr, ms) {
       success(m) => m,
       failure(sp, ref str) => sess.span_diagnostic.span_fatal(sp, (*str)),
@@ -226,8 +226,11 @@ fn parse_or_else(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader,
     }
 }
 
-fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
-    -> parse_result {
+pub fn parse(sess: parse_sess,
+             cfg: ast::crate_cfg,
+             rdr: reader,
+             ms: ~[matcher])
+          -> parse_result {
     let mut cur_eis = ~[];
     cur_eis.push(initial_matcher_pos(ms, None, rdr.peek().sp.lo));
 
@@ -398,7 +401,7 @@ fn parse(sess: parse_sess, cfg: ast::crate_cfg, rdr: reader, ms: ~[matcher])
     }
 }
 
-fn parse_nt(p: Parser, name: ~str) -> nonterminal {
+pub fn parse_nt(p: Parser, name: ~str) -> nonterminal {
     match name {
       ~"item" => match p.parse_item(~[]) {
         Some(i) => token::nt_item(i),
diff --git a/src/libsyntax/ext/tt/macro_rules.rs b/src/libsyntax/ext/tt/macro_rules.rs
index bcaa7679a5a..f7ef79db466 100644
--- a/src/libsyntax/ext/tt/macro_rules.rs
+++ b/src/libsyntax/ext/tt/macro_rules.rs
@@ -29,8 +29,8 @@ use print;
 use core::io;
 use std::map::HashMap;
 
-fn add_new_extension(cx: ext_ctxt, sp: span, name: ident,
-                     arg: ~[ast::token_tree]) -> base::MacResult {
+pub fn add_new_extension(cx: ext_ctxt, sp: span, name: ident,
+                         arg: ~[ast::token_tree]) -> base::MacResult {
     // these spans won't matter, anyways
     fn ms(m: matcher_) -> matcher {
         ast::spanned { node: m, span: dummy_sp() }
diff --git a/src/libsyntax/ext/tt/transcribe.rs b/src/libsyntax/ext/tt/transcribe.rs
index 47489034a0f..b3b1e04976a 100644
--- a/src/libsyntax/ext/tt/transcribe.rs
+++ b/src/libsyntax/ext/tt/transcribe.rs
@@ -23,8 +23,6 @@ use core::vec;
 use std;
 use std::map::HashMap;
 
-export tt_reader,  new_tt_reader, dup_tt_reader, tt_next_token;
-
 enum tt_frame_up { /* to break a circularity */
     tt_frame_up(Option<tt_frame>)
 }
@@ -40,7 +38,7 @@ type tt_frame = @{
     up: tt_frame_up,
 };
 
-type tt_reader = @{
+pub type tt_reader = @{
     sp_diag: span_handler,
     interner: @ident_interner,
     mut cur: tt_frame,
@@ -56,10 +54,10 @@ type tt_reader = @{
 /** This can do Macro-By-Example transcription. On the other hand, if
  *  `src` contains no `tt_seq`s and `tt_nonterminal`s, `interp` can (and
  *  should) be none. */
-fn new_tt_reader(sp_diag: span_handler, itr: @ident_interner,
-                 interp: Option<std::map::HashMap<ident,@named_match>>,
-                 src: ~[ast::token_tree])
-    -> tt_reader {
+pub fn new_tt_reader(sp_diag: span_handler, itr: @ident_interner,
+                     interp: Option<std::map::HashMap<ident,@named_match>>,
+                     src: ~[ast::token_tree])
+                  -> tt_reader {
     let r = @{sp_diag: sp_diag, interner: itr,
               mut cur: @{readme: src, mut idx: 0u, dotdotdoted: false,
                          sep: None, up: tt_frame_up(option::None)},
@@ -88,7 +86,7 @@ pure fn dup_tt_frame(&&f: tt_frame) -> tt_frame {
      }
 }
 
-pure fn dup_tt_reader(&&r: tt_reader) -> tt_reader {
+pub pure fn dup_tt_reader(&&r: tt_reader) -> tt_reader {
     @{sp_diag: r.sp_diag, interner: r.interner,
       mut cur: dup_tt_frame(r.cur),
       interpolations: r.interpolations,
@@ -151,7 +149,7 @@ fn lockstep_iter_size(t: token_tree, r: tt_reader) -> lis {
 }
 
 
-fn tt_next_token(&&r: tt_reader) -> {tok: Token, sp: span} {
+pub fn tt_next_token(&&r: tt_reader) -> {tok: Token, sp: span} {
     let ret_val = { tok: r.cur_tok, sp: r.cur_span };
     while r.cur.idx >= r.cur.readme.len() {
         /* done with this set; pop or repeat? */