---

yaml
---
r: 40776
b: refs/heads/dist-snap
c: 0138d87
h: refs/heads/master
v: v3

Author: catamorphism

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
 refs/heads/incoming: e90142e536c150df0d9b4b2f11352152177509b5
-refs/heads/dist-snap: e24ae85025e40aa17915f6c604d89aefbca274bd
+refs/heads/dist-snap: 0138d87f8f1b9f9614e439deb14cbaabad6d104c
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/rust.md

@@ -847,10 +847,25 @@ fn main() {
 
 Like items, `use` declarations are private to the containing module, by default.
 Also like items, a `use` declaration can be public, if qualified by the `pub` keyword.
+Such a `use` declaration serves to _re-export_ a name.
 A public `use` declaration can therefore be used to _redirect_ some public name to a different target definition,
 even a definition with a private canonical path, inside a different module.
 If a sequence of such redirections form a cycle or cannot be unambiguously resolved, they represent a compile-time error.
 
+An example of re-exporting:
+~~~~
+mod quux {
+    mod foo {
+        pub fn bar() { }
+        pub fn baz() { }
+    }
+    
+    pub use foo::*;
+}
+~~~~
+
+In this example, the module `quux` re-exports all of the public names defined in `foo`.
+
 ### Functions
 
 A _function item_ defines a sequence of [statements](#statements) and an optional final [expression](#expressions), along with a name and a set of parameters.

branches/dist-snap/src/librustc/middle/astencode.rs

@@ -1033,8 +1033,6 @@ fn decode_item_ast(par_doc: ebml::Doc) -> @ast::item {
 trait fake_ext_ctxt {
     fn cfg() -> ast::crate_cfg;
     fn parse_sess() -> parse::parse_sess;
-    fn call_site() -> span;
-    fn ident_of(st: ~str) -> ast::ident;
 }
 
 #[cfg(test)]
@@ -1044,16 +1042,6 @@ type fake_session = parse::parse_sess;
 impl fake_session: fake_ext_ctxt {
     fn cfg() -> ast::crate_cfg { ~[] }
     fn parse_sess() -> parse::parse_sess { self }
-    fn call_site() -> span {
-        codemap::span {
-            lo: codemap::BytePos(0),
-            hi: codemap::BytePos(0),
-            expn_info: None
-        }
-    }
-    fn ident_of(st: ~str) -> ast::ident {
-        self.interner.intern(@st)
-    }
 }
 
 #[cfg(test)]
@@ -1062,8 +1050,7 @@ fn mk_ctxt() -> fake_ext_ctxt {
 }
 
 #[cfg(test)]
-fn roundtrip(in_item: Option<@ast::item>) {
-    let in_item = in_item.get();
+fn roundtrip(in_item: @ast::item) {
     let bytes = do io::with_bytes_writer |wr| {
         let ebml_w = writer::Serializer(wr);
         encode_item_ast(ebml_w, in_item);
@@ -1087,45 +1074,45 @@ fn roundtrip(in_item: Option<@ast::item>) {
 #[test]
 fn test_basic() {
     let ext_cx = mk_ctxt();
-    roundtrip(quote_item!(
+    roundtrip(#ast[item]{
         fn foo() {}
-    ));
+    });
 }
 
 #[test]
 fn test_smalltalk() {
     let ext_cx = mk_ctxt();
-    roundtrip(quote_item!(
+    roundtrip(#ast[item]{
         fn foo() -> int { 3 + 4 } // first smalltalk program ever executed.
-    ));
+    });
 }
 
 #[test]
 fn test_more() {
     let ext_cx = mk_ctxt();
-    roundtrip(quote_item!(
+    roundtrip(#ast[item]{
         fn foo(x: uint, y: uint) -> uint {
             let z = x + y;
             return z;
         }
-    ));
+    });
 }
 
 #[test]
 fn test_simplification() {
     let ext_cx = mk_ctxt();
-    let item_in = ast::ii_item(quote_item!(
+    let item_in = ast::ii_item(#ast[item] {
         fn new_int_alist<B: Copy>() -> alist<int, B> {
             fn eq_int(&&a: int, &&b: int) -> bool { a == b }
             return {eq_fn: eq_int, mut data: ~[]};
         }
-    ).get());
+    });
     let item_out = simplify_ast(item_in);
-    let item_exp = ast::ii_item(quote_item!(
+    let item_exp = ast::ii_item(#ast[item] {
         fn new_int_alist<B: Copy>() -> alist<int, B> {
             return {eq_fn: eq_int, mut data: ~[]};
         }
-    ).get());
+    });
     match (item_out, item_exp) {
       (ast::ii_item(item_out), ast::ii_item(item_exp)) => {
         assert pprust::item_to_str(item_out, ext_cx.parse_sess().interner)

branches/dist-snap/src/libsyntax/ast.rs

@@ -842,7 +842,13 @@ type mac_body = Option<mac_body_>;
 #[auto_serialize]
 #[auto_deserialize]
 enum mac_ {
+    mac_invoc(@path, mac_arg, mac_body), // old macro-invocation
     mac_invoc_tt(@path,~[token_tree]),   // new macro-invocation
+    mac_ellipsis,                        // old pattern-match (obsolete)
+
+    // the span is used by the quoter/anti-quoter ...
+    mac_aq(span /* span of quote */, @expr), // anti-quote
+    mac_var(uint)
 }
 
 type lit = spanned<lit_>;

branches/dist-snap/src/libsyntax/ext/auto_serialize.rs

@@ -309,7 +309,7 @@ priv impl ext_ctxt {
     fn lambda(blk: ast::blk) -> @ast::expr {
         let ext_cx = self;
         let blk_e = self.expr(blk.span, ast::expr_block(blk));
-        quote_expr!( || $blk_e )
+        #ast{ || $(blk_e) }
     }
 
     fn blk(span: span, stmts: ~[@ast::stmt]) -> ast::blk {

branches/dist-snap/src/libsyntax/ext/base.rs

@@ -16,16 +16,16 @@ use ast_util::dummy_sp;
 
 // obsolete old-style #macro code:
 //
-//    syntax_expander, normal, builtin
+//    syntax_expander, normal, macro_defining, macro_definer,
+//    builtin
 //
 // new-style macro! tt code:
 //
 //    syntax_expander_tt, syntax_expander_tt_item, mac_result,
 //    normal_tt, item_tt
 //
-// 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.
+// also note that ast::mac has way too many cases and can probably
+// be trimmed down substantially.
 
 // second argument is the span to blame for general argument problems
 type syntax_expander_ =
@@ -35,6 +35,10 @@ type syntax_expander = {expander: syntax_expander_, span: Option<span>};
 
 type macro_def = {name: ~str, ext: syntax_extension};
 
+// macro_definer is obsolete, remove when #old_macros go away.
+type macro_definer =
+    fn@(ext_ctxt, span, ast::mac_arg, ast::mac_body) -> macro_def;
+
 type item_decorator =
     fn@(ext_ctxt, span, ast::meta_item, ~[@ast::item]) -> ~[@ast::item];
 
@@ -59,6 +63,9 @@ enum syntax_extension {
     // normal() is obsolete, remove when #old_macros go away.
     normal(syntax_expander),
 
+    // macro_defining() is obsolete, remove when #old_macros go away.
+    macro_defining(macro_definer),
+
     // #[auto_serialize] and such. will probably survive death of #old_macros
     item_decorator(item_decorator),
 
@@ -82,6 +89,8 @@ fn syntax_expander_table() -> HashMap<~str, syntax_extension> {
         item_tt({expander: f, span: None})
     }
     let syntax_expanders = HashMap();
+    syntax_expanders.insert(~"macro",
+                            macro_defining(ext::simplext::add_new_extension));
     syntax_expanders.insert(~"macro_rules",
                             builtin_item_tt(
                                 ext::tt::macro_rules::add_new_extension));
@@ -100,6 +109,8 @@ fn syntax_expander_table() -> HashMap<~str, syntax_extension> {
     syntax_expanders.insert(~"log_syntax",
                             builtin_normal_tt(
                                 ext::log_syntax::expand_syntax_ext));
+    syntax_expanders.insert(~"ast",
+                            builtin(ext::qquote::expand_ast));
     syntax_expanders.insert(~"deriving_eq",
                             item_decorator(
                                 ext::deriving::expand_deriving_eq));

branches/dist-snap/src/libsyntax/ext/expand.rs

@@ -10,10 +10,11 @@
 
 use std::map::HashMap;
 
-use ast::{crate, expr_, expr_mac, mac_invoc_tt,
+use ast::{crate, expr_, expr_mac, mac_invoc, mac_invoc_tt,
           tt_delim, tt_tok, item_mac, stmt_, stmt_mac, stmt_expr, stmt_semi};
 use fold::*;
 use ext::base::*;
+use ext::qquote::{qq_helper};
 use parse::{parser, parse_expr_from_source_str, new_parser_from_tts};
 
 
@@ -31,6 +32,51 @@ fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
           expr_mac(ref mac) => {
 
             match (*mac).node {
+              // Old-style macros. For compatibility, will erase this whole
+              // block once we've transitioned.
+              mac_invoc(pth, args, body) => {
+                assert (vec::len(pth.idents) > 0u);
+                /* using idents and token::special_idents would make the
+                the macro names be hygienic */
+                let extname = cx.parse_sess().interner.get(pth.idents[0]);
+                match exts.find(*extname) {
+                  None => {
+                    cx.span_fatal(pth.span,
+                                  fmt!("macro undefined: '%s'", *extname))
+                  }
+                  Some(item_decorator(_)) => {
+                    cx.span_fatal(
+                        pth.span,
+                        fmt!("%s can only be used as a decorator", *extname));
+                  }
+                  Some(normal({expander: exp, span: exp_sp})) => {
+
+                    cx.bt_push(ExpandedFrom({call_site: s,
+                                callie: {name: *extname, span: exp_sp}}));
+                    let expanded = exp(cx, (*mac).span, args, body);
+
+                    //keep going, outside-in
+                    let fully_expanded = fld.fold_expr(expanded).node;
+                    cx.bt_pop();
+
+                    (fully_expanded, s)
+                  }
+                  Some(macro_defining(ext)) => {
+                    let named_extension = ext(cx, (*mac).span, args, body);
+                    exts.insert(named_extension.name, named_extension.ext);
+                    (ast::expr_rec(~[], None), s)
+                  }
+                  Some(normal_tt(_)) => {
+                    cx.span_fatal(pth.span,
+                                  fmt!("this tt-style macro should be \
+                                        invoked '%s!(...)'", *extname))
+                  }
+                  Some(item_tt(*)) => {
+                    cx.span_fatal(pth.span,
+                                  ~"cannot use item macros in this context");
+                  }
+                }
+              }
 
               // Token-tree macros, these will be the only case when we're
               // finished transitioning.
@@ -85,6 +131,7 @@ fn expand_expr(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
 
                 }
               }
+              _ => cx.span_bug((*mac).span, ~"naked syntactic bit")
             }
           }
           _ => orig(e, s, fld)
@@ -119,15 +166,10 @@ 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(_))
-                | Some(normal_tt(_)) | Some(item_tt(*)) => items,
+              None | Some(normal(_)) | Some(macro_defining(_))
+              | Some(normal_tt(_)) | Some(item_tt(*)) => items,
               Some(item_decorator(dec_fn)) => {
-                  cx.bt_push(ExpandedFrom({call_site: attr.span,
-                                           callie: {name: copy mname,
-                                                    span: None}}));
-                  let r = dec_fn(cx, attr.span, attr.node.value, items);
-                  cx.bt_pop();
-                  r
+                dec_fn(cx, attr.span, attr.node.value, items)
               }
             }
         }
@@ -163,16 +205,36 @@ fn expand_item(exts: HashMap<~str, syntax_extension>,
     }
 }
 
+// avoid excess indentation when a series of nested `match`es
+// has only one "good" outcome
+macro_rules! biased_match (
+    (   ($e    :expr) ~ ($p    :pat) else $err    :stmt ;
+     $( ($e_cdr:expr) ~ ($p_cdr:pat) else $err_cdr:stmt ; )*
+     => $body:expr
+    ) => (
+        match $e {
+            $p => {
+                biased_match!($( ($e_cdr) ~ ($p_cdr) else $err_cdr ; )*
+                              => $body)
+            }
+            _ => { $err }
+        }
+    );
+    ( => $body:expr ) => ( $body )
+)
+
+
 // 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>,
                    cx: ext_ctxt, &&it: @ast::item,
                    fld: ast_fold) -> Option<@ast::item> {
-
-    let (pth, tts) = match it.node {
-        item_mac({node: mac_invoc_tt(pth, ref tts), _}) => (pth, (*tts)),
-        _ => cx.span_bug(it.span, ~"invalid item macro invocation")
-    };
+    let (pth, tts) = biased_match!(
+        (it.node) ~ (item_mac({node: mac_invoc_tt(pth, ref tts), _})) else {
+            cx.span_bug(it.span, ~"invalid item macro invocation")
+        };
+        => (pth, (*tts))
+    );
 
     let extname = cx.parse_sess().interner.get(pth.idents[0]);
     let expanded = match exts.find(*extname) {
@@ -227,15 +289,12 @@ fn expand_stmt(exts: HashMap<~str, syntax_extension>, cx: ext_ctxt,
                orig: fn@(&&s: stmt_, span, ast_fold) -> (stmt_, span))
     -> (stmt_, span)
 {
-
-    let (mac, pth, tts, semi) = match s {
-        stmt_mac(ref mac, semi) => {
-            match (*mac).node {
-                mac_invoc_tt(pth, ref tts) => ((*mac), pth, (*tts), semi)
-            }
-        }
-        _ => return orig(s, sp, fld)
-    };
+    let (mac, pth, tts, semi) = biased_match! (
+        (s)        ~ (stmt_mac(ref mac, semi))   else return orig(s, sp, fld);
+        ((*mac).node) ~ (mac_invoc_tt(pth, ref tts)) else {
+            cx.span_bug((*mac).span, ~"naked syntactic bit")
+        };
+        => ((*mac), pth, (*tts), semi));
 
     assert(vec::len(pth.idents) == 1u);
     let extname = cx.parse_sess().interner.get(pth.idents[0]);