---

yaml
---
r: 155033
b: refs/heads/try2
c: 9f8ec42
h: refs/heads/master
i:
  155031: 07c77db
v: v3

Author: elinorbgr

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 9c68679f2ebd5b165694e9346e4ad96a3e32aceb
+refs/heads/try2: 9f8ec427e57a7da4d935fb19148586fae0d7f3c5
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/etc/get-snapshot.py

@@ -52,7 +52,9 @@ def unpack_snapshot(triple, dl_path):
 if len(sys.argv) == 3:
   dl_path = sys.argv[2]
 else:
-  snap = determine_curr_snapshot(triple)
+  # There are no 64-bit Windows snapshots yet, so we'll use 32-bit ones instead, for now
+  snap_triple = triple if triple != "x86_64-w64-mingw32" else "i686-w64-mingw32"
+  snap = determine_curr_snapshot(snap_triple)
   dl = os.path.join(download_dir_base, snap)
   url = download_url_base + "/" + snap
   print("determined most recent snapshot: " + snap)

branches/try2/src/libcore/fmt/mod.rs

@@ -113,6 +113,7 @@ impl<'a> Arguments<'a> {
     /// Arguments structure. The compiler inserts an `unsafe` block to call this,
     /// which is valid because the compiler performs all necessary validation to
     /// ensure that the resulting call to format/write would be safe.
+    #[cfg(not(stage0))]
     #[doc(hidden)] #[inline]
     pub unsafe fn new<'a>(pieces: &'static [&'static str],
                           args: &'a [Argument<'a>]) -> Arguments<'a> {
@@ -126,6 +127,7 @@ impl<'a> Arguments<'a> {
     /// This function is used to specify nonstandard formatting parameters.
     /// The `pieces` array must be at least as long as `fmt` to construct
     /// a valid Arguments structure.
+    #[cfg(not(stage0))]
     #[doc(hidden)] #[inline]
     pub unsafe fn with_placeholders<'a>(pieces: &'static [&'static str],
                                         fmt: &'static [rt::Argument<'static>],
@@ -136,6 +138,13 @@ impl<'a> Arguments<'a> {
             args: args
         }
     }
+
+    #[cfg(stage0)]
+    #[doc(hidden)] #[inline]
+    pub unsafe fn new<'a>(fmt: &'static [rt::Piece<'static>],
+                          args: &'a [Argument<'a>]) -> Arguments<'a> {
+        Arguments{ fmt: mem::transmute(fmt), args: args }
+    }
 }
 
 /// This structure represents a safely precompiled version of a format string
@@ -147,6 +156,7 @@ impl<'a> Arguments<'a> {
 /// and pass it to a function or closure, passed as the first argument. The
 /// macro validates the format string at compile-time so usage of the `write`
 /// and `format` functions can be safely performed.
+#[cfg(not(stage0))]
 pub struct Arguments<'a> {
     // Format string pieces to print.
     pieces: &'a [&'a str],
@@ -159,6 +169,12 @@ pub struct Arguments<'a> {
     args: &'a [Argument<'a>],
 }
 
+#[cfg(stage0)] #[doc(hidden)]
+pub struct Arguments<'a> {
+    fmt: &'a [rt::Piece<'a>],
+    args: &'a [Argument<'a>],
+}
+
 impl<'a> Show for Arguments<'a> {
     fn fmt(&self, fmt: &mut Formatter) -> Result {
         write(fmt.buf, self)
@@ -280,6 +296,7 @@ uniform_fn_call_workaround! {
     secret_upper_exp, UpperExp;
 }
 
+#[cfg(not(stage0))]
 static DEFAULT_ARGUMENT: rt::Argument<'static> = rt::Argument {
     position: rt::ArgumentNext,
     format: rt::FormatSpec {
@@ -299,6 +316,7 @@ static DEFAULT_ARGUMENT: rt::Argument<'static> = rt::Argument {
 ///
 ///   * output - the buffer to write output to
 ///   * args - the precompiled arguments generated by `format_args!`
+#[cfg(not(stage0))]
 pub fn write(output: &mut FormatWriter, args: &Arguments) -> Result {
     let mut formatter = Formatter {
         flags: 0,
@@ -342,11 +360,30 @@ pub fn write(output: &mut FormatWriter, args: &Arguments) -> Result {
     Ok(())
 }
 
+#[cfg(stage0)] #[doc(hidden)]
+pub fn write(output: &mut FormatWriter, args: &Arguments) -> Result {
+    let mut formatter = Formatter {
+        flags: 0,
+        width: None,
+        precision: None,
+        buf: output,
+        align: rt::AlignUnknown,
+        fill: ' ',
+        args: args.args,
+        curarg: args.args.iter(),
+    };
+    for piece in args.fmt.iter() {
+        try!(formatter.run(piece));
+    }
+    Ok(())
+}
+
 impl<'a> Formatter<'a> {
 
     // First up is the collection of functions used to execute a format string
     // at runtime. This consumes all of the compile-time statics generated by
     // the format! syntax extension.
+    #[cfg(not(stage0))]
     fn run(&mut self, arg: &rt::Argument) -> Result {
         // Fill in the format parameters into the formatter
         self.fill = arg.format.fill;
@@ -365,6 +402,30 @@ impl<'a> Formatter<'a> {
         (value.formatter)(value.value, self)
     }
 
+    #[cfg(stage0)] #[doc(hidden)]
+    fn run(&mut self, piece: &rt::Piece) -> Result {
+        match *piece {
+            rt::String(s) => self.buf.write(s.as_bytes()),
+            rt::Argument(ref arg) => {
+                // Fill in the format parameters into the formatter
+                self.fill = arg.format.fill;
+                self.align = arg.format.align;
+                self.flags = arg.format.flags;
+                self.width = self.getcount(&arg.format.width);
+                self.precision = self.getcount(&arg.format.precision);
+
+                // Extract the correct argument
+                let value = match arg.position {
+                    rt::ArgumentNext => { *self.curarg.next().unwrap() }
+                    rt::ArgumentIs(i) => self.args[i],
+                };
+
+                // Then actually do some printing
+                (value.formatter)(value.value, self)
+            }
+        }
+    }
+
     fn getcount(&mut self, cnt: &rt::Count) -> Option<uint> {
         match *cnt {
             rt::CountIs(n) => { Some(n) }
@@ -415,7 +476,7 @@ impl<'a> Formatter<'a> {
 
         let mut prefixed = false;
         if self.flags & (1 << (FlagAlternate as uint)) != 0 {
-            prefixed = true; width += prefix.char_len();
+            prefixed = true; width += prefix.len();
         }
 
         // Writes the sign if it exists, and then the prefix if it was requested
@@ -501,7 +562,7 @@ impl<'a> Formatter<'a> {
             // If we're under both the maximum and the minimum width, then fill
             // up the minimum width with the specified string + some alignment.
             Some(width) => {
-                self.with_padding(width - s.char_len(), rt::AlignLeft, |me| {
+                self.with_padding(width - s.len(), rt::AlignLeft, |me| {
                     me.buf.write(s.as_bytes())
                 })
             }

branches/try2/src/librustc/front/feature_gate.rs

@@ -143,15 +143,15 @@ impl<'a> Context<'a> {
     }
 }
 
-impl<'a, 'v> Visitor<'v> for Context<'a> {
-    fn visit_ident(&mut self, sp: Span, id: ast::Ident) {
+impl<'a> Visitor<()> for Context<'a> {
+    fn visit_ident(&mut self, sp: Span, id: ast::Ident, _: ()) {
         if !token::get_ident(id).get().is_ascii() {
             self.gate_feature("non_ascii_idents", sp,
                               "non-ascii idents are not fully supported.");
         }
     }
 
-    fn visit_view_item(&mut self, i: &ast::ViewItem) {
+    fn visit_view_item(&mut self, i: &ast::ViewItem, _: ()) {
         match i.node {
             ast::ViewItemUse(ref path) => {
                 match path.node {
@@ -173,10 +173,10 @@ impl<'a, 'v> Visitor<'v> for Context<'a> {
                 }
             }
         }
-        visit::walk_view_item(self, i)
+        visit::walk_view_item(self, i, ())
     }
 
-    fn visit_item(&mut self, i: &ast::Item) {
+    fn visit_item(&mut self, i: &ast::Item, _:()) {
         for attr in i.attrs.iter() {
             if attr.name().equiv(&("thread_local")) {
                 self.gate_feature("thread_local", i.span,
@@ -252,10 +252,10 @@ impl<'a, 'v> Visitor<'v> for Context<'a> {
             _ => {}
         }
 
-        visit::walk_item(self, i);
+        visit::walk_item(self, i, ());
     }
 
-    fn visit_mac(&mut self, macro: &ast::Mac) {
+    fn visit_mac(&mut self, macro: &ast::Mac, _: ()) {
         let ast::MacInvocTT(ref path, _, _) = macro.node;
         let id = path.segments.last().unwrap().identifier;
         let quotes = ["quote_tokens", "quote_expr", "quote_ty",
@@ -299,16 +299,16 @@ impl<'a, 'v> Visitor<'v> for Context<'a> {
         }
     }
 
-    fn visit_foreign_item(&mut self, i: &ast::ForeignItem) {
+    fn visit_foreign_item(&mut self, i: &ast::ForeignItem, _: ()) {
         if attr::contains_name(i.attrs.as_slice(), "linkage") {
             self.gate_feature("linkage", i.span,
                               "the `linkage` attribute is experimental \
                                and not portable across platforms")
         }
-        visit::walk_foreign_item(self, i)
+        visit::walk_foreign_item(self, i, ())
     }
 
-    fn visit_ty(&mut self, t: &ast::Ty) {
+    fn visit_ty(&mut self, t: &ast::Ty, _: ()) {
         match t.node {
             ast::TyClosure(closure) if closure.onceness == ast::Once => {
                 self.gate_feature("once_fns", t.span,
@@ -325,10 +325,10 @@ impl<'a, 'v> Visitor<'v> for Context<'a> {
             _ => {}
         }
 
-        visit::walk_ty(self, t);
+        visit::walk_ty(self, t, ());
     }
 
-    fn visit_expr(&mut self, e: &ast::Expr) {
+    fn visit_expr(&mut self, e: &ast::Expr, _: ()) {
         match e.node {
             ast::ExprUnary(ast::UnBox, _) => {
                 self.gate_box(e.span);
@@ -346,10 +346,10 @@ impl<'a, 'v> Visitor<'v> for Context<'a> {
             }
             _ => {}
         }
-        visit::walk_expr(self, e);
+        visit::walk_expr(self, e, ());
     }
 
-    fn visit_generics(&mut self, generics: &ast::Generics) {
+    fn visit_generics(&mut self, generics: &ast::Generics, _: ()) {
         for type_parameter in generics.ty_params.iter() {
             match type_parameter.default {
                 Some(ty) => {
@@ -360,18 +360,18 @@ impl<'a, 'v> Visitor<'v> for Context<'a> {
                 None => {}
             }
         }
-        visit::walk_generics(self, generics);
+        visit::walk_generics(self, generics, ());
     }
 
-    fn visit_attribute(&mut self, attr: &ast::Attribute) {
+    fn visit_attribute(&mut self, attr: &ast::Attribute, _: ()) {
         if attr::contains_name([*attr], "lang") {
             self.gate_feature("lang_items",
                               attr.span,
                               "language items are subject to change");
         }
     }
 
-    fn visit_pat(&mut self, pattern: &ast::Pat) {
+    fn visit_pat(&mut self, pattern: &ast::Pat, (): ()) {
         match pattern.node {
             ast::PatVec(_, Some(_), ref last) if !last.is_empty() => {
                 self.gate_feature("advanced_slice_patterns",
@@ -382,24 +382,25 @@ impl<'a, 'v> Visitor<'v> for Context<'a> {
             }
             _ => {}
         }
-        visit::walk_pat(self, pattern)
+        visit::walk_pat(self, pattern, ())
     }
 
     fn visit_fn(&mut self,
-                fn_kind: visit::FnKind<'v>,
-                fn_decl: &'v ast::FnDecl,
-                block: &'v ast::Block,
+                fn_kind: &visit::FnKind,
+                fn_decl: &ast::FnDecl,
+                block: &ast::Block,
                 span: Span,
-                _: NodeId) {
-        match fn_kind {
-            visit::FkItemFn(_, _, _, abi) if abi == RustIntrinsic => {
+                _: NodeId,
+                (): ()) {
+        match *fn_kind {
+            visit::FkItemFn(_, _, _, ref abi) if *abi == RustIntrinsic => {
                 self.gate_feature("intrinsics",
                                   span,
                                   "intrinsics are subject to change")
             }
             _ => {}
         }
-        visit::walk_fn(self, fn_kind, fn_decl, block, span);
+        visit::walk_fn(self, fn_kind, fn_decl, block, span, ());
     }
 }
 
@@ -452,7 +453,7 @@ pub fn check_crate(sess: &Session, krate: &ast::Crate) {
         }
     }
 
-    visit::walk_crate(&mut cx, krate);
+    visit::walk_crate(&mut cx, krate, ());
 
     sess.abort_if_errors();
 

branches/try2/src/librustc/front/show_span.rs

@@ -23,18 +23,18 @@ struct ShowSpanVisitor<'a> {
     sess: &'a Session
 }
 
-impl<'a, 'v> Visitor<'v> for ShowSpanVisitor<'a> {
-    fn visit_expr(&mut self, e: &ast::Expr) {
+impl<'a> Visitor<()> for ShowSpanVisitor<'a> {
+    fn visit_expr(&mut self, e: &ast::Expr, _: ()) {
         self.sess.span_note(e.span, "expression");
-        visit::walk_expr(self, e);
+        visit::walk_expr(self, e, ());
     }
 
-    fn visit_mac(&mut self, macro: &ast::Mac) {
-        visit::walk_mac(self, macro);
+    fn visit_mac(&mut self, macro: &ast::Mac, e: ()) {
+        visit::walk_mac(self, macro, e);
     }
 }
 
 pub fn run(sess: &Session, krate: &ast::Crate) {
     let mut v = ShowSpanVisitor { sess: sess };
-    visit::walk_crate(&mut v, krate);
+    visit::walk_crate(&mut v, krate, ());
 }