---

yaml
---
r: 47855
b: refs/heads/incoming
c: 3792eb2
h: refs/heads/master
i:
  47853: 36a24d7
  47851: 2240623
  47847: 14f17fb
  47839: 34464e9
v: v3

Author: Kimundi

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 2a8fb58d79e685d5ca07b039badcf2ae3ef077ea
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/incoming: b02f5c2090340a9007989b3eb384facb0f0286f2
+refs/heads/incoming: 3792eb2a3847f7891a7d3a1941aa7833626baa5c
 refs/heads/dist-snap: 8b98e5a296d95c5e832db0756828e5bec31c6f50
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libcore/core.rc

@@ -225,6 +225,8 @@ pub const debug : u32 = 4_u32;
 // The runtime interface used by the compiler
 #[cfg(notest)] pub mod rt;
 // The runtime and compiler interface to fmt!
+#[cfg(stage0)]
+#[path = "private/extfmt.rs"]
 pub mod extfmt;
 // Private APIs
 pub mod private;

branches/incoming/src/libcore/prelude.rs

@@ -52,7 +52,6 @@ pub use char;
 pub use cmp;
 pub use dvec;
 pub use either;
-pub use extfmt;
 pub use f32;
 pub use f64;
 pub use float;

branches/incoming/src/libcore/private.rs

@@ -34,6 +34,8 @@ pub mod weak_task;
 pub mod exchange_alloc;
 #[path = "private/intrinsics.rs"]
 pub mod intrinsics;
+#[path = "private/extfmt.rs"]
+pub mod extfmt;
 
 extern mod rustrt {
     pub unsafe fn rust_create_little_lock() -> rust_little_lock;

branches/incoming/src/libcore/extfmt.rs renamed to branches/incoming/src/libcore/private/extfmt.rs

@@ -466,7 +466,7 @@ pub fn parse_and_print(code: @~str) -> ~str {
                    sess.cm,
                    // Assuming there are no token_trees
                    syntax::parse::token::mk_fake_ident_interner(),
-                   copy sess.span_diagnostic,
+                   sess.span_diagnostic,
                    crate,
                    filename.to_str(),
                    rdr, a,
@@ -622,7 +622,7 @@ pub fn check_variants(files: &[Path], cx: Context) {
                        sess.cm,
                        // Assuming no token_trees
                        syntax::parse::token::mk_fake_ident_interner(),
-                       copy sess.span_diagnostic,
+                       sess.span_diagnostic,
                        crate,
                        file_str,
                        rdr, a,

branches/incoming/src/libfuzzer/fuzzer.rc

@@ -25,7 +25,7 @@ use syntax::ast::node_id;
 use syntax::ast::{int_ty, uint_ty, float_ty};
 use syntax::codemap::span;
 use syntax::diagnostic;
-use syntax::parse::ParseSess;
+use syntax::parse::parse_sess;
 use syntax::{ast, codemap};
 use syntax;
 
@@ -151,7 +151,7 @@ pub struct Session_ {
     targ_cfg: @config,
     opts: @options,
     cstore: @mut metadata::cstore::CStore,
-    parse_sess: @mut ParseSess,
+    parse_sess: parse_sess,
     codemap: @codemap::CodeMap,
     // For a library crate, this is always none
     main_fn: @mut Option<(node_id, codemap::span)>,

branches/incoming/src/librustc/driver/session.rs

@@ -10,6 +10,10 @@
 
 // Code that generates a test runner to run all the tests in a crate
 
+// XXX - Need to finish off libsyntax first
+#[legacy_records];
+#[allow(structural_records)];
+
 use core::prelude::*;
 
 use driver::session;
@@ -21,7 +25,7 @@ use core::option;
 use core::vec;
 use syntax::ast_util::*;
 use syntax::attr;
-use syntax::codemap::{dummy_sp, span, ExpandedFrom, CallInfo, NameAndSpan};
+use syntax::codemap::{dummy_sp, span, ExpandedFrom};
 use syntax::codemap;
 use syntax::fold;
 use syntax::print::pprust;
@@ -77,13 +81,11 @@ fn generate_test_harness(sess: session::Session,
         testfns: ~[]
     };
 
-    cx.ext_cx.bt_push(ExpandedFrom(CallInfo {
-        call_site: dummy_sp(),
-        callee: NameAndSpan {
-            name: ~"test",
-            span: None
-        }
-    }));
+    cx.ext_cx.bt_push(ExpandedFrom({
+                        call_site: dummy_sp(),
+                        callie: {
+                            name: ~"test",
+                            span: None}}));
 
     let precursor = @fold::AstFoldFns {
         fold_crate: fold::wrap(|a,b| fold_crate(cx, a, b) ),

branches/incoming/src/librustc/front/test.rs

@@ -1193,18 +1193,18 @@ fn decode_item_ast(par_doc: ebml::Doc) -> @ast::item {
 #[cfg(test)]
 trait fake_ext_ctxt {
     fn cfg() -> ast::crate_cfg;
-    fn parse_sess() -> @mut parse::ParseSess;
+    fn parse_sess() -> parse::parse_sess;
     fn call_site() -> span;
     fn ident_of(+st: ~str) -> ast::ident;
 }
 
 #[cfg(test)]
-type fake_session = @mut parse::ParseSess;
+type fake_session = parse::parse_sess;
 
 #[cfg(test)]
 impl fake_ext_ctxt for fake_session {
     fn cfg() -> ast::crate_cfg { ~[] }
-    fn parse_sess() -> @mut parse::ParseSess { self }
+    fn parse_sess() -> parse::parse_sess { self }
     fn call_site() -> span {
         codemap::span {
             lo: codemap::BytePos(0),

branches/incoming/src/librustc/middle/astencode.rs

@@ -196,16 +196,11 @@ pub struct LocWithOpt {
 // used to be structural records. Better names, anyone?
 pub struct FileMapAndLine {fm: @FileMap, line: uint}
 pub struct FileMapAndBytePos {fm: @FileMap, pos: BytePos}
-pub struct NameAndSpan {name: ~str, span: Option<span>}
-
-pub struct CallInfo {
-    call_site: span,
-    callee: NameAndSpan
-}
 
 /// Extra information for tracking macro expansion of spans
 pub enum ExpnInfo {
-    ExpandedFrom(CallInfo)
+    ExpandedFrom({call_site: span,
+                  callie: {name: ~str, span: Option<span>}})
 }
 
 pub type FileName = ~str;

branches/incoming/src/libsyntax/codemap.rs

@@ -290,10 +290,10 @@ fn highlight_lines(cm: @codemap::CodeMap,
 
 fn print_macro_backtrace(cm: @codemap::CodeMap, sp: span) {
     do option::iter(&sp.expn_info) |ei| {
-        let ss = option::map_default(&ei.callee.span, @~"",
+        let ss = option::map_default(&ei.callie.span, @~"",
                                      |span| @cm.span_to_str(*span));
         print_diagnostic(*ss, note,
-                         fmt!("in expansion of %s!", ei.callee.name));
+                         fmt!("in expansion of %s!", ei.callie.name));
         let ss = cm.span_to_str(ei.call_site);
         print_diagnostic(ss, note, ~"expansion site");
         print_macro_backtrace(cm, ei.call_site);

branches/incoming/src/libsyntax/diagnostic.rs

@@ -13,7 +13,6 @@ 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;
@@ -167,7 +166,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) -> @mut parse::ParseSess;
+    fn parse_sess(@mut self) -> parse::parse_sess;
     fn cfg(@mut self) -> ast::crate_cfg;
     fn call_site(@mut self) -> span;
     fn print_backtrace(@mut self);
@@ -191,22 +190,22 @@ pub trait ext_ctxt {
     fn ident_of(@mut self, st: ~str) -> ast::ident;
 }
 
-pub fn mk_ctxt(parse_sess: @mut parse::ParseSess,
+pub fn mk_ctxt(parse_sess: parse::parse_sess,
                cfg: ast::crate_cfg) -> ext_ctxt {
     struct CtxtRepr {
-        parse_sess: @mut parse::ParseSess,
+        parse_sess: parse::parse_sess,
         cfg: ast::crate_cfg,
         backtrace: Option<@ExpnInfo>,
         mod_path: ~[ast::ident],
         trace_mac: bool
     }
     impl ext_ctxt for CtxtRepr {
         fn codemap(@mut self) -> @CodeMap { self.parse_sess.cm }
-        fn parse_sess(@mut self) -> @mut parse::ParseSess { self.parse_sess }
+        fn parse_sess(@mut self) -> parse::parse_sess { self.parse_sess }
         fn cfg(@mut self) -> ast::crate_cfg { self.cfg }
         fn call_site(@mut self) -> span {
             match self.backtrace {
-                Some(@ExpandedFrom(CallInfo {call_site: cs, _})) => cs,
+                Some(@ExpandedFrom({call_site: cs, _})) => cs,
                 None => self.bug(~"missing top span")
             }
         }
@@ -217,18 +216,18 @@ pub fn mk_ctxt(parse_sess: @mut parse::ParseSess,
         fn mod_path(@mut self) -> ~[ast::ident] { return self.mod_path; }
         fn bt_push(@mut self, ei: codemap::ExpnInfo) {
             match ei {
-              ExpandedFrom(CallInfo {call_site: cs, callee: ref callee}) => {
+              ExpandedFrom({call_site: cs, callie: ref callie}) => {
                 self.backtrace =
-                    Some(@ExpandedFrom(CallInfo {
+                    Some(@ExpandedFrom({
                         call_site: span {lo: cs.lo, hi: cs.hi,
                                          expn_info: self.backtrace},
-                        callee: (*callee)}));
+                        callie: (*callie)}));
               }
             }
         }
         fn bt_pop(@mut self) {
             match self.backtrace {
-              Some(@ExpandedFrom(CallInfo {
+              Some(@ExpandedFrom({
                   call_site: span {expn_info: prev, _}, _
               })) => {
                 self.backtrace = prev

branches/incoming/src/libsyntax/ext/base.rs

@@ -19,11 +19,6 @@ 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_)
@@ -152,37 +147,47 @@ 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: &Field) -> ast::field {
+pub fn mk_field(sp: span, f: &{ident: ast::ident, ex: @ast::expr})
+             -> 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: ~[Field]) -> ~[ast::field] {
+pub fn mk_fields(sp: span, fields: ~[{ident: ast::ident, ex: @ast::expr}])
+              -> ~[ast::field] {
     fields.map(|f| mk_field(sp, f))
 }
-pub fn mk_rec_e(cx: ext_ctxt, sp: span, fields: ~[Field]) -> @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>))
 }
-pub fn mk_struct_e(cx: ext_ctxt, sp: span, ctor_path: ~[ast::ident],
-                   fields: ~[Field]) -> @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>))
 }
-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: ~[Field])
+                          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>))
 }
-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,

branches/incoming/src/libsyntax/ext/build.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, CallInfo, ExpandedFrom, NameAndSpan};
+use codemap::{span, ExpandedFrom};
 use ext::base::*;
 use fold::*;
 use parse::{parser, parse_expr_from_source_str, new_parser_from_tts};
@@ -48,12 +48,8 @@ pub fn expand_expr(exts: SyntaxExtensions, cx: ext_ctxt,
                   }
                   Some(NormalTT(SyntaxExpanderTT{expander: exp,
                                                  span: exp_sp})) => {
-                    cx.bt_push(ExpandedFrom(CallInfo{
-                        call_site: s,
-                        callee: NameAndSpan {
-                            name: *extname, span: exp_sp
-                        }
-                    }));
+                    cx.bt_push(ExpandedFrom({call_site: s,
+                                callie: {name: *extname, span: exp_sp}}));
 
                     let expanded = match exp(cx, (*mac).span, (*tts)) {
                       MRExpr(e) => e,
@@ -109,13 +105,9 @@ 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(CallInfo {
-                      call_site: attr.span,
-                      callee: NameAndSpan {
-                          name: /*bad*/ copy *mname,
-                          span: None
-                      }
-                  }));
+                  cx.bt_push(ExpandedFrom({call_site: attr.span,
+                                           callie: {name: /*bad*/ copy *mname,
+                                                    span: None}}));
                   let r = dec_fn(cx, attr.span, attr.node.value, items);
                   cx.bt_pop();
                   r
@@ -178,13 +170,9 @@ pub fn expand_item_mac(exts: SyntaxExtensions,
                                     given '%s'", *extname,
                                    *cx.parse_sess().interner.get(it.ident)));
             }
-            cx.bt_push(ExpandedFrom(CallInfo {
-                call_site: it.span,
-                callee: NameAndSpan {
-                    name: *extname,
-                    span: (*expand).span
-                }
-            }));
+            cx.bt_push(ExpandedFrom({call_site: it.span,
+                                     callie: {name: *extname,
+                                              span: (*expand).span}}));
             ((*expand).expander)(cx, it.span, tts)
         }
         Some(ItemTT(ref expand)) => {
@@ -193,13 +181,9 @@ pub fn expand_item_mac(exts: SyntaxExtensions,
                               fmt!("macro %s! expects an ident argument",
                                    *extname));
             }
-            cx.bt_push(ExpandedFrom(CallInfo {
-                call_site: it.span,
-                callee: NameAndSpan {
-                    name: *extname,
-                    span: (*expand).span
-                }
-            }));
+            cx.bt_push(ExpandedFrom({call_site: it.span,
+                                     callie: {name: *extname,
+                                              span: (*expand).span}}));
             ((*expand).expander)(cx, it.span, it.ident, tts)
         }
         _ => cx.span_fatal(
@@ -244,10 +228,8 @@ pub fn expand_stmt(exts: SyntaxExtensions, cx: ext_ctxt,
 
         Some(NormalTT(
             SyntaxExpanderTT{expander: exp, span: exp_sp})) => {
-            cx.bt_push(ExpandedFrom(CallInfo {
-                call_site: sp,
-                callee: NameAndSpan { name: *extname, span: exp_sp }
-            }));
+            cx.bt_push(ExpandedFrom(
+                {call_site: sp, callie: {name: *extname, span: exp_sp}}));
             let expanded = match exp(cx, mac.span, tts) {
                 MRExpr(e) =>
                     @codemap::spanned { node: stmt_expr(e, cx.next_id()),
@@ -339,7 +321,7 @@ pub fn core_macros() -> ~str {
 }";
 }
 
-pub fn expand_crate(parse_sess: @mut parse::ParseSess,
+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();