---

yaml
---
r: 95267
b: refs/heads/dist-snap
c: 0cca359
h: refs/heads/master
i:
  95265: 86de4bb
  95263: cadaf31
v: v3

Author: alexcrichton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: e42e32291ea779a30818521e8aea9693899b8188
+refs/heads/dist-snap: 0cca359da690d357ae3447c0e18cf5fab4ee8732
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libstd/num/num.rs

@@ -404,7 +404,9 @@ pub trait ToPrimitive {
 
     /// Converts the value of `self` to an `u64`.
     #[inline]
-    fn to_u64(&self) -> Option<u64>;
+    fn to_u64(&self) -> Option<u64> {
+        self.to_u64().and_then(|x| x.to_u64())
+    }
 
     /// Converts the value of `self` to an `f32`.
     #[inline]
@@ -1479,51 +1481,4 @@ mod tests {
         assert_eq!(third.checked_mul(&3), Some(third * 3));
         assert_eq!(third.checked_mul(&4), None);
     }
-
-
-    #[deriving(Eq)]
-    struct Value { x: int }
-
-    impl ToPrimitive for Value {
-        fn to_i64(&self) -> Option<i64> { self.x.to_i64() }
-        fn to_u64(&self) -> Option<u64> { self.x.to_u64() }
-    }
-
-    impl FromPrimitive for Value {
-        fn from_i64(n: i64) -> Option<Value> { Some(Value { x: n as int }) }
-        fn from_u64(n: u64) -> Option<Value> { Some(Value { x: n as int }) }
-    }
-
-    #[test]
-    fn test_to_primitive() {
-        let value = Value { x: 5 };
-        assert_eq!(value.to_int(),  Some(5));
-        assert_eq!(value.to_i8(),   Some(5));
-        assert_eq!(value.to_i16(),  Some(5));
-        assert_eq!(value.to_i32(),  Some(5));
-        assert_eq!(value.to_i64(),  Some(5));
-        assert_eq!(value.to_uint(), Some(5));
-        assert_eq!(value.to_u8(),   Some(5));
-        assert_eq!(value.to_u16(),  Some(5));
-        assert_eq!(value.to_u32(),  Some(5));
-        assert_eq!(value.to_u64(),  Some(5));
-        assert_eq!(value.to_f32(),  Some(5f32));
-        assert_eq!(value.to_f64(),  Some(5f64));
-    }
-
-    #[test]
-    fn test_from_primitive() {
-        assert_eq!(from_int(5),    Some(Value { x: 5 }));
-        assert_eq!(from_i8(5),     Some(Value { x: 5 }));
-        assert_eq!(from_i16(5),    Some(Value { x: 5 }));
-        assert_eq!(from_i32(5),    Some(Value { x: 5 }));
-        assert_eq!(from_i64(5),    Some(Value { x: 5 }));
-        assert_eq!(from_uint(5),   Some(Value { x: 5 }));
-        assert_eq!(from_u8(5),     Some(Value { x: 5 }));
-        assert_eq!(from_u16(5),    Some(Value { x: 5 }));
-        assert_eq!(from_u32(5),    Some(Value { x: 5 }));
-        assert_eq!(from_u64(5),    Some(Value { x: 5 }));
-        assert_eq!(from_f32(5f32), Some(Value { x: 5 }));
-        assert_eq!(from_f64(5f64), Some(Value { x: 5 }));
-    }
 }

branches/dist-snap/src/libsyntax/parse/parser.rs

@@ -309,7 +309,6 @@ pub fn Parser(sess: @mut ParseSess,
         quote_depth: @mut 0,
         obsolete_set: @mut HashSet::new(),
         mod_path_stack: @mut ~[],
-        open_braces: @mut ~[]
     }
 }
 
@@ -338,8 +337,6 @@ pub struct Parser {
     obsolete_set: @mut HashSet<ObsoleteSyntax>,
     /// Used to determine the path to externally loaded source files
     mod_path_stack: @mut ~[@str],
-    /// Stack of spans of open delimiters. Used for error message.
-    open_braces: @mut ~[Span]
 }
 
 #[unsafe_destructor]
@@ -2027,18 +2024,12 @@ impl Parser {
 
         match *self.token {
             token::EOF => {
-                for sp in self.open_braces.iter() {
-                    self.span_note(*sp, "Did you mean to close this delimiter?");
-                }
-                // There shouldn't really be a span, but it's easier for the test runner
-                // if we give it one
-                self.fatal("This file contains an un-closed delimiter ");
+                self.fatal("file ended with unbalanced delimiters");
             }
             token::LPAREN | token::LBRACE | token::LBRACKET => {
                 let close_delim = token::flip_delimiter(&*self.token);
 
                 // Parse the open delimiter.
-                (*self.open_braces).push(*self.span);
                 let mut result = ~[parse_any_tt_tok(self)];
 
                 let trees =
@@ -2049,7 +2040,6 @@ impl Parser {
 
                 // Parse the close delimiter.
                 result.push(parse_any_tt_tok(self));
-                self.open_braces.pop();
 
                 tt_delim(@mut result)
             }

branches/dist-snap/src/libsyntax/parse/token.rs

@@ -499,30 +499,11 @@ fn mk_fresh_ident_interner() -> @ident_interner {
     @interner::StrInterner::prefill(init_vec)
 }
 
-// NOTE remove stage0 pub'ed special cases after next snapshot.
-#[cfg(stage0)]
-pub static SELF_KEYWORD_NAME: uint = 8;
-#[cfg(not(stage0))]
 static SELF_KEYWORD_NAME: uint = 8;
-#[cfg(stage0)]
-pub static STATIC_KEYWORD_NAME: uint = 27;
-#[cfg(not(stage0))]
 static STATIC_KEYWORD_NAME: uint = 27;
-#[cfg(stage0)]
-pub static STRICT_KEYWORD_START: uint = 32;
-#[cfg(not(stage0))]
 static STRICT_KEYWORD_START: uint = 32;
-#[cfg(stage0)]
-pub static STRICT_KEYWORD_FINAL: uint = 64;
-#[cfg(not(stage0))]
 static STRICT_KEYWORD_FINAL: uint = 64;
-#[cfg(stage0)]
-pub static RESERVED_KEYWORD_START: uint = 65;
-#[cfg(not(stage0))]
 static RESERVED_KEYWORD_START: uint = 65;
-#[cfg(stage0)]
-pub static RESERVED_KEYWORD_FINAL: uint = 71;
-#[cfg(not(stage0))]
 static RESERVED_KEYWORD_FINAL: uint = 71;
 
 // if an interner exists in TLS, return it. Otherwise, prepare a

branches/dist-snap/src/snapshots.txt

@@ -1,3 +1,11 @@
+S 2013-10-07 c919629
+  freebsd-x86_64 c9af0c52bdcc1ffe2db4c9a3a1aaae66ff7fcc2c
+  linux-i386 0245cb9e57c9b39f3441e9768256783ba76be6e7
+  linux-x86_64 483d9bd109316e647a11d387653568d95e3581e6
+  macos-i386 c12154816a8f5cd7b2c758250859cf6abf3eddbf
+  macos-x86_64 9d46c31618a3bbd6ddffa598f1350e16c620621b
+  winnt-i386 b111d291a15ff7f02aba9c59bb81ae7a3cd86628
+
 S 2013-10-04 8bb55db
   freebsd-x86_64 8b68b99033e68f5d98e3e3d077de9d2e085be1ba
   linux-i386 10bc0069efdca378155640963d70d3a08a7248dc

branches/dist-snap/src/test/compile-fail/issue-2354-1.rs

@@ -8,7 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo() { //~ NOTE Did you mean to close this delimiter?
+// xfail-test
+/*
+  Ideally, the error about the missing close brace in foo would be reported
+  near the corresponding open brace. But currently it's reported at the end.
+  xfailed for now (see Issue #2354)
+ */
+fn foo() { //~ ERROR this open brace is not closed
   match Some(x) {
       Some(y) { fail!(); }
       None    { fail!(); }
@@ -19,4 +25,4 @@ fn bar() {
     while (i < 1000) {}
 }
 
-fn main() {} //~ ERROR This file contains an un-closed delimiter
+fn main() {}