---

yaml
---
r: 64193
b: refs/heads/snap-stage3
c: f091a1e
h: refs/heads/master
i:
  64191: 91e4ac4
v: v3

Author: glinscott

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 9b5d52312622fb301d9e102b3eeca5a7afcdeb9b
+refs/heads/snap-stage3: f091a1e075b46b22f9df92acd2cf177e84ca1834
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libextra/json.rs

@@ -16,11 +16,10 @@
 
 //! json serialization
 
-
-use std::char;
+use std::iterator;
 use std::float;
 use std::hashmap::HashMap;
-use std::io::{WriterUtil, ReaderUtil};
+use std::io::WriterUtil;
 use std::io;
 use std::str;
 use std::to_str;
@@ -481,24 +480,17 @@ pub fn to_pretty_str(json: &Json) -> ~str {
     io::with_str_writer(|wr| to_pretty_writer(wr, json))
 }
 
-static BUF_SIZE : uint = 64000;
-
-#[allow(missing_doc)]
-pub struct Parser {
-    priv rdr: @io::Reader,
-    priv buf: ~[char],
-    priv buf_idx: uint,
+pub struct Parser<T> {
+    priv rdr: ~T,
     priv ch: char,
     priv line: uint,
     priv col: uint,
 }
 
-/// Decode a json value from an io::reader
-pub fn Parser(rdr: @io::Reader) -> Parser {
+/// Decode a json value from an Iterator<char>
+pub fn Parser<T : iterator::Iterator<char>>(rdr: ~T) -> Parser<T> {
     let mut p = Parser {
         rdr: rdr,
-        buf: rdr.read_chars(BUF_SIZE),
-        buf_idx: 0,
         ch: 0 as char,
         line: 1,
         col: 0,
@@ -507,7 +499,7 @@ pub fn Parser(rdr: @io::Reader) -> Parser {
     p
 }
 
-impl Parser {
+impl<T: iterator::Iterator<char>> Parser<T> {
     pub fn parse(&mut self) -> Result<Json, Error> {
         match self.parse_value() {
           Ok(value) => {
@@ -525,30 +517,20 @@ impl Parser {
     }
 }
 
-impl Parser {
+impl<T : iterator::Iterator<char>> Parser<T> {
     fn eof(&self) -> bool { self.ch == -1 as char }
 
     fn bump(&mut self) {
-        if self.eof() {
-            return;
-        }
-
-        self.col += 1u;
-
-        if self.buf_idx >= self.buf.len() {
-            self.buf = self.rdr.read_chars(BUF_SIZE);
-            if self.buf.len() == 0 {
-                self.ch = -1 as char;
-                return;
-            }
-            self.buf_idx = 0;
+        match self.rdr.next() {
+            Some(ch) => self.ch = ch,
+            None() => self.ch = -1 as char,
         }
-        self.ch = self.buf[self.buf_idx];
-        self.buf_idx += 1;
 
         if self.ch == '\n' {
             self.line += 1u;
             self.col = 1u;
+        } else {
+            self.col += 1u;
         }
     }
 
@@ -583,7 +565,10 @@ impl Parser {
     }
 
     fn parse_whitespace(&mut self) {
-        while char::is_whitespace(self.ch) { self.bump(); }
+        while self.ch == ' ' ||
+              self.ch == '\n' ||
+              self.ch == '\t' ||
+              self.ch == '\r' { self.bump(); }
     }
 
     fn parse_ident(&mut self, ident: &str, value: Json) -> Result<Json, Error> {
@@ -727,8 +712,11 @@ impl Parser {
         let mut escape = false;
         let mut res = ~"";
 
-        while !self.eof() {
+        loop {
             self.bump();
+            if self.eof() {
+                return self.error(~"EOF while parsing string");
+            }
 
             if (escape) {
                 match self.ch {
@@ -783,8 +771,6 @@ impl Parser {
                 res.push_char(self.ch);
             }
         }
-
-        self.error(~"EOF while parsing string")
     }
 
     fn parse_list(&mut self) -> Result<Json, Error> {
@@ -870,15 +856,15 @@ impl Parser {
 
 /// Decodes a json value from an @io::Reader
 pub fn from_reader(rdr: @io::Reader) -> Result<Json, Error> {
-    let mut parser = Parser(rdr);
+    let s = str::from_bytes(rdr.read_whole_stream());
+    let mut parser = Parser(~s.iter());
     parser.parse()
 }
 
 /// Decodes a json value from a string
 pub fn from_str(s: &str) -> Result<Json, Error> {
-    do io::with_str_reader(s) |rdr| {
-        from_reader(rdr)
-    }
+    let mut parser = Parser(~s.iter());
+    parser.parse()
 }
 
 /// A structure to decode JSON to values in rust.
@@ -1744,7 +1730,7 @@ mod tests {
         assert_eq!(v, 0.4e-01f);
     }
 
-    // FIXME: #7611: xfailed for now
+    #[test]
     fn test_read_str() {
         assert_eq!(from_str("\""),
             Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing string"

branches/snap-stage3/src/librustc/metadata/tydecode.rs

@@ -543,8 +543,7 @@ pub fn parse_type_param_def_data(data: &[u8], start: uint,
 }
 
 fn parse_type_param_def(st: &mut PState, conv: conv_did) -> ty::TypeParameterDef {
-    ty::TypeParameterDef {ident: parse_ident(st, ':'),
-                          def_id: parse_def(st, NominalType, |x,y| conv(x,y)),
+    ty::TypeParameterDef {def_id: parse_def(st, NominalType, |x,y| conv(x,y)),
                           bounds: @parse_bounds(st, |x,y| conv(x,y))}
 }
 

branches/snap-stage3/src/librustc/metadata/tyencode.rs

@@ -416,8 +416,6 @@ fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: &ty::ParamBounds) {
 }
 
 pub fn enc_type_param_def(w: @io::Writer, cx: @ctxt, v: &ty::TypeParameterDef) {
-    w.write_str(cx.tcx.sess.str_of(v.ident));
-    w.write_char(':');
     w.write_str((cx.ds)(v.def_id));
     w.write_char('|');
     enc_bounds(w, cx, v.bounds);

branches/snap-stage3/src/librustc/middle/subst.rs

@@ -130,7 +130,6 @@ impl Subst for ty::ParamBounds {
 impl Subst for ty::TypeParameterDef {
     fn subst(&self, tcx: ty::ctxt, substs: &ty::substs) -> ty::TypeParameterDef {
         ty::TypeParameterDef {
-            ident: self.ident,
             def_id: self.def_id,
             bounds: self.bounds.subst(tcx, substs)
         }

branches/snap-stage3/src/librustc/middle/ty.rs

@@ -794,7 +794,6 @@ impl ToStr for IntVarValue {
 }
 
 pub struct TypeParameterDef {
-    ident: ast::ident,
     def_id: ast::def_id,
     bounds: @ParamBounds
 }

branches/snap-stage3/src/librustc/middle/typeck/collect.rs

@@ -59,7 +59,6 @@ use syntax::print::pprust::{path_to_str, explicit_self_to_str};
 use syntax::visit;
 use syntax::opt_vec::OptVec;
 use syntax::opt_vec;
-use syntax::parse::token::special_idents;
 
 pub fn collect_item_types(ccx: @mut CrateCtxt, crate: &ast::crate) {
     fn collect_intrinsic_type(ccx: &CrateCtxt,
@@ -319,7 +318,6 @@ pub fn ensure_trait_methods(ccx: &CrateCtxt,
         let self_trait_def = get_trait_def(ccx, local_def(trait_id));
         let self_trait_ref = self_trait_def.trait_ref.subst(tcx, &substs);
         new_type_param_defs.push(ty::TypeParameterDef {
-            ident: special_idents::self_,
             def_id: dummy_defid,
             bounds: @ty::ParamBounds {
                 builtin_bounds: ty::EmptyBuiltinBounds(),
@@ -1153,7 +1151,6 @@ pub fn ty_generics(ccx: &CrateCtxt,
                     let bounds = @compute_bounds(ccx, rp, generics,
                                                  param_ty, &param.bounds);
                     let def = ty::TypeParameterDef {
-                        ident: param.ident,
                         def_id: local_def(param.id),
                         bounds: bounds
                     };

branches/snap-stage3/src/librustc/util/ppaux.rs

@@ -435,17 +435,16 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
       ty_infer(infer_ty) => infer_ty.to_str(),
       ty_err => ~"[type error]",
       ty_param(param_ty {idx: id, def_id: did}) => {
-          let param_def = cx.ty_param_defs.find(&did.node);
-          let ident = match param_def {
-              Some(def) => {
-                  cx.sess.str_of(def.ident).to_owned()
-              }
-              None => {
-                  // This should not happen...
-                  fmt!("BUG[%?]", id)
-              }
-          };
-          if !cx.sess.verbose() { ident } else { fmt!("%s:%?", ident, did) }
+          let mut parm = (('T' as uint) + id) as char;
+          if (parm as uint) > ('Z' as uint) {
+              parm = (parm as uint - 26) as char;
+          }
+
+          if cx.sess.verbose() {
+              fmt!("%c:%?", parm, did)
+          } else {
+              fmt!("%c", parm)
+          }
       }
       ty_self(*) => ~"Self",
       ty_enum(did, ref substs) | ty_struct(did, ref substs) => {

branches/snap-stage3/src/libstd/ptr.rs

@@ -15,8 +15,6 @@ use option::{Option, Some, None};
 use sys;
 use unstable::intrinsics;
 use util::swap;
-use ops::{Add,Sub};
-use num::Int;
 
 #[cfg(not(test))] use cmp::{Eq, Ord};
 use uint;
@@ -386,46 +384,6 @@ impl<T> Ord for *const T {
     }
 }
 
-#[cfg(not(test))]
-impl<T, I: Int> Add<I, *T> for *T {
-    /// Add an integer value to a pointer to get an offset pointer.
-    /// Is calculated according to the size of the type pointed to.
-    #[inline]
-    pub fn add(&self, rhs: &I) -> *T {
-        self.offset(rhs.to_int() as uint)
-    }
-}
-
-#[cfg(not(test))]
-impl<T, I: Int> Sub<I, *T> for *T {
-    /// Subtract an integer value from a pointer to get an offset pointer.
-    /// Is calculated according to the size of the type pointed to.
-    #[inline]
-    pub fn sub(&self, rhs: &I) -> *T {
-        self.offset(-rhs.to_int() as uint)
-    }
-}
-
-#[cfg(not(test))]
-impl<T, I: Int> Add<I, *mut T> for *mut T {
-    /// Add an integer value to a pointer to get an offset pointer.
-    /// Is calculated according to the size of the type pointed to.
-    #[inline]
-    pub fn add(&self, rhs: &I) -> *mut T {
-        self.offset(rhs.to_int() as uint)
-    }
-}
-
-#[cfg(not(test))]
-impl<T, I: Int> Sub<I, *mut T> for *mut T {
-    /// Subtract an integer value from a pointer to get an offset pointer.
-    /// Is calculated according to the size of the type pointed to.
-    #[inline]
-    pub fn sub(&self, rhs: &I) -> *mut T {
-        self.offset(-rhs.to_int() as uint)
-    }
-}
-
 #[cfg(test)]
 pub mod ptr_tests {
     use super::*;
@@ -543,60 +501,6 @@ pub mod ptr_tests {
         }
     }
 
-    #[test]
-    fn test_ptr_addition() {
-        use vec::raw::*;
-
-        unsafe {
-            let xs = ~[5, ..16];
-            let mut ptr = to_ptr(xs);
-            let end = ptr + 16;
-
-            while ptr < end {
-                assert_eq!(*ptr, 5);
-                ptr = ptr + 1u;
-            }
-
-            let mut xs_mut = xs.clone();
-            let mut m_ptr = to_mut_ptr(xs_mut);
-            let m_end = m_ptr + 16i16;
-
-            while m_ptr < m_end {
-                *m_ptr += 5;
-                m_ptr = m_ptr + 1u8;
-            }
-
-            assert_eq!(xs_mut, ~[10, ..16]);
-        }
-    }
-
-    #[test]
-    fn test_ptr_subtraction() {
-        use vec::raw::*;
-
-        unsafe {
-            let xs = ~[0,1,2,3,4,5,6,7,8,9];
-            let mut idx = 9i8;
-            let ptr = to_ptr(xs);
-
-            while idx >= 0i8 {
-                assert_eq!(*(ptr + idx), idx as int);
-                idx = idx - 1i8;
-            }
-
-            let mut xs_mut = xs.clone();
-            let mut m_start = to_mut_ptr(xs_mut);
-            let mut m_ptr = m_start + 9u32;
-
-            while m_ptr >= m_start {
-                *m_ptr += *m_ptr;
-                m_ptr = m_ptr - 1i8;
-            }
-
-            assert_eq!(xs_mut, ~[0,2,4,6,8,10,12,14,16,18]);
-        }
-    }
-
     #[test]
     fn test_ptr_array_each_with_len() {
         unsafe {

branches/snap-stage3/src/libstd/repr.rs

@@ -206,13 +206,11 @@ impl ReprVisitor {
                            inner: *TyDesc)
                            -> bool {
         let mut p = ptr;
+        let end = ptr::offset(p, len);
         let (sz, al) = unsafe { ((*inner).size, (*inner).align) };
         self.writer.write_char('[');
         let mut first = true;
-        let mut left = len;
-        // unit structs have 0 size, and don't loop forever.
-        let dec = if sz == 0 {1} else {sz};
-        while left > 0 {
+        while (p as uint) < (end as uint) {
             if first {
                 first = false;
             } else {
@@ -221,7 +219,6 @@ impl ReprVisitor {
             self.write_mut_qualifier(mtbl);
             self.visit_ptr_inner(p as *c_void, inner);
             p = align(ptr::offset(p, sz) as uint, al) as *u8;
-            left -= dec;
         }
         self.writer.write_char(']');
         true
@@ -638,7 +635,4 @@ fn test_repr() {
                "(10, ~\"hello\")");
     exact_test(&(10_u64, ~"hello"),
                "(10, ~\"hello\")");
-
-    struct Foo;
-    exact_test(&(~[Foo, Foo, Foo]), "~[{}, {}, {}]");
 }