---

yaml
---
r: 142717
b: refs/heads/try2
c: 663a959
h: refs/heads/master
i:
  142715: 0d94cc1
v: v3

Author: kevinmehall

[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: 9b5d52312622fb301d9e102b3eeca5a7afcdeb9b
+refs/heads/try2: 663a9597b24f841f44e560e2478225353dbcec30
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/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/try2/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/try2/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/try2/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/try2/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/try2/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/try2/src/libstd/libc.rs

@@ -186,6 +186,13 @@ pub mod types {
     // Standard types that are opaque or common, so are not per-target.
     pub mod common {
         pub mod c95 {
+            /**
+            Type used to construct void pointers for use with C.
+
+            This type is only useful as a pointer target. Do not use it as a
+            return type for FFI functions which have the `void` return type in
+            C. Use the unit type `()` or omit the return type instead.
+            */
             pub enum c_void {}
             pub enum FILE {}
             pub enum fpos_t {}

branches/try2/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/try2/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]), "~[{}, {}, {}]");
 }