---

yaml
---
r: 178584
b: refs/heads/try
c: 00a933f
h: refs/heads/master
v: v3

Author: Alfie John

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 336c8d2e9c6b276b162bdb3edd43706372e6eddd
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 474b324eda10440d6568ef872a7307d38e7de95b
-refs/heads/try: ca4b9674c26c1de07a2042cb68e6a062d7184cef
+refs/heads/try: 00a933f9ece4ef22f8651320e5f4fcfcbd37e0bf
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/doc/intro.md

@@ -424,7 +424,7 @@ Let's see an example. This Rust code will not compile:
 use std::thread::Thread;
 
 fn main() {
-    let mut numbers = vec![1, 2, 3];
+    let mut numbers = vec![1is, 2, 3];
 
     for i in 0..3 {
         Thread::spawn(move || {
@@ -478,7 +478,7 @@ use std::thread::Thread;
 use std::sync::{Arc,Mutex};
 
 fn main() {
-    let numbers = Arc::new(Mutex::new(vec![1, 2, 3]));
+    let numbers = Arc::new(Mutex::new(vec![1is, 2, 3]));
 
     for i in 0us..3 {
         let number = numbers.clone();
@@ -539,7 +539,7 @@ safety check that makes this an error about moved values:
 use std::thread::Thread;
 
 fn main() {
-    let vec = vec![1, 2, 3];
+    let vec = vec![1is, 2, 3];
 
     for i in 0us..3 {
         Thread::spawn(move || {

branches/try/src/doc/reference.md

@@ -268,7 +268,7 @@ cases mentioned in [Number literals](#number-literals) below.
 ##### Suffixes
 | Integer | Floating-point |
 |---------|----------------|
-| `u8`, `i8`, `u16`, `i16`, `u32`, `i32`, `u64`, `i64`, `is` (`isize`), `us` (`usize`) | `f32`, `f64` |
+| `is` (`isize`), `us` (`usize`), `u8`, `i8`, `u16`, `i16`, `u32`, `i32`, `u64`, `i64` | `f32`, `f64` |
 
 #### Character and string literals
 
@@ -468,29 +468,27 @@ Like any literal, an integer literal may be followed (immediately,
 without any spaces) by an _integer suffix_, which forcibly sets the
 type of the literal. There are 10 valid values for an integer suffix:
 
+* The `is` and `us` suffixes give the literal type `isize` or `usize`,
+  respectively.
 * Each of the signed and unsigned machine types `u8`, `i8`,
   `u16`, `i16`, `u32`, `i32`, `u64` and `i64`
   give the literal the corresponding machine type.
-* The `is` and `us` suffixes give the literal type `isize` or `usize`,
-  respectively.
 
 The type of an _unsuffixed_ integer literal is determined by type inference.
 If an integer type can be _uniquely_ determined from the surrounding program
 context, the unsuffixed integer literal has that type. If the program context
-underconstrains the type, it defaults to the signed 32-bit integer `i32`; if
-the program context overconstrains the type, it is considered a static type
-error.
+underconstrains the type, it is considered a static type error; if the program
+context overconstrains the type, it is also considered a static type error.
 
 Examples of integer literals of various forms:
 
 ```
-123i32;                            // type i32
-123u32;                            // type u32
-123_u32;                           // type u32
+123is;                             // type isize
+123us;                             // type usize
+123_us;                            // type usize
 0xff_u8;                           // type u8
 0o70_i16;                          // type i16
 0b1111_1111_1001_0000_i32;         // type i32
-0us;                               // type usize
 ```
 
 ##### Floating-point literals
@@ -1137,8 +1135,8 @@ used as a type name.
 
 When a generic function is referenced, its type is instantiated based on the
 context of the reference. For example, calling the `iter` function defined
-above on `[1, 2]` will instantiate type parameter `T` with `i32`, and require
-the closure parameter to have type `fn(i32)`.
+above on `[1, 2]` will instantiate type parameter `T` with `isize`, and require
+the closure parameter to have type `fn(isize)`.
 
 The type parameters can also be explicitly supplied in a trailing
 [path](#paths) component after the function name. This might be necessary if
@@ -2748,9 +2746,9 @@ constant expression that can be evaluated at compile time, such as a
 [literal](#literals) or a [static item](#static-items).
 
 ```
-[1, 2, 3, 4];
+[1is, 2, 3, 4];
 ["a", "b", "c", "d"];
-[0; 128];              // array with 128 zeros
+[0is; 128];            // array with 128 zeros
 [0u8, 0u8, 0u8, 0u8];
 ```
 
@@ -2923,7 +2921,7 @@ moves](#moved-and-copied-types) its right-hand operand to its left-hand
 operand.
 
 ```
-# let mut x = 0;
+# let mut x = 0is;
 # let y = 0;
 
 x = y;
@@ -3309,11 +3307,11 @@ fn main() {
 ```
 
 Patterns can also dereference pointers by using the `&`, `&mut` and `box`
-symbols, as appropriate. For example, these two matches on `x: &i32` are
+symbols, as appropriate. For example, these two matches on `x: &isize` are
 equivalent:
 
 ```
-# let x = &3;
+# let x = &3is;
 let y = match *x { 0 => "zero", _ => "some" };
 let z = match x { &0 => "zero", _ => "some" };
 
@@ -3334,7 +3332,7 @@ Multiple match patterns may be joined with the `|` operator. A range of values
 may be specified with `...`. For example:
 
 ```
-# let x = 2;
+# let x = 2is;
 
 let message = match x {
   0 | 1  => "not many",
@@ -3675,16 +3673,16 @@ The type of a closure mapping an input of type `A` to an output of type `B` is
 An example of creating and calling a closure:
 
 ```rust
-let captured_var = 10;
+let captured_var = 10is;
 
 let closure_no_args = |&:| println!("captured_var={}", captured_var);
 
-let closure_args = |&: arg: i32| -> i32 {
+let closure_args = |&: arg: isize| -> isize {
   println!("captured_var={}, arg={}", captured_var, arg);
   arg // Note lack of semicolon after 'arg'
 };
 
-fn call_closure<F: Fn(), G: Fn(i32) -> i32>(c1: F, c2: G) {
+fn call_closure<F: Fn(), G: Fn(isize) -> isize>(c1: F, c2: G) {
   c1();
   c2(2);
 }
@@ -3716,7 +3714,7 @@ trait Printable {
   fn stringify(&self) -> String;
 }
 
-impl Printable for i32 {
+impl Printable for isize {
   fn stringify(&self) -> String { self.to_string() }
 }
 
@@ -3725,7 +3723,7 @@ fn print(a: Box<Printable>) {
 }
 
 fn main() {
-   print(Box::new(10) as Box<Printable>);
+   print(Box::new(10is) as Box<Printable>);
 }
 ```
 

branches/try/src/liballoc/arc.rs

@@ -39,7 +39,7 @@
 //!
 //! let five = Arc::new(5);
 //!
-//! for _ in 0u..10 {
+//! for _ in 0..10 {
 //!     let five = five.clone();
 //!
 //!     Thread::spawn(move || {
@@ -56,7 +56,7 @@
 //!
 //! let five = Arc::new(Mutex::new(5));
 //!
-//! for _ in 0u..10 {
+//! for _ in 0..10 {
 //!     let five = five.clone();
 //!
 //!     Thread::spawn(move || {
@@ -101,7 +101,7 @@ use heap::deallocate;
 ///     let numbers: Vec<_> = (0..100u32).map(|i| i as f32).collect();
 ///     let shared_numbers = Arc::new(numbers);
 ///
-///     for _ in 0u..10 {
+///     for _ in 0..10 {
 ///         let child_numbers = shared_numbers.clone();
 ///
 ///         Thread::spawn(move || {
@@ -661,7 +661,7 @@ mod tests {
 
     #[test]
     fn test_cowarc_clone_make_unique() {
-        let mut cow0 = Arc::new(75u);
+        let mut cow0 = Arc::new(75);
         let mut cow1 = cow0.clone();
         let mut cow2 = cow1.clone();
 
@@ -685,7 +685,7 @@ mod tests {
 
     #[test]
     fn test_cowarc_clone_unique2() {
-        let mut cow0 = Arc::new(75u);
+        let mut cow0 = Arc::new(75);
         let cow1 = cow0.clone();
         let cow2 = cow1.clone();
 
@@ -708,7 +708,7 @@ mod tests {
 
     #[test]
     fn test_cowarc_clone_weak() {
-        let mut cow0 = Arc::new(75u);
+        let mut cow0 = Arc::new(75);
         let cow1_weak = cow0.downgrade();
 
         assert!(75 == *cow0);

branches/try/src/liballoc/boxed.rs

@@ -102,52 +102,6 @@ impl<T> Box<T> {
     }
 }
 
-impl<T : ?Sized> Box<T> {
-    /// Constructs a box from the raw pointer.
-    ///
-    /// After this function call, pointer is owned by resulting box.
-    /// In particular, it means that `Box` destructor calls destructor
-    /// of `T` and releases memory. Since the way `Box` allocates and
-    /// releases memory is unspecified, so the only valid pointer to
-    /// pass to this function is the one taken from another `Box` with
-    /// `box::into_raw` function.
-    ///
-    /// Function is unsafe, because improper use of this function may
-    /// lead to memory problems like double-free, for example if the
-    /// function is called twice on the same raw pointer.
-    #[unstable(feature = "alloc",
-               reason = "may be renamed or moved out of Box scope")]
-    pub unsafe fn from_raw(raw: *mut T) -> Self {
-        mem::transmute(raw)
-    }
-}
-
-/// Consumes the `Box`, returning the wrapped raw pointer.
-///
-/// After call to this function, caller is responsible for the memory
-/// previously managed by `Box`, in particular caller should properly
-/// destroy `T` and release memory. The proper way to do it is to
-/// convert pointer back to `Box` with `Box::from_raw` function, because
-/// `Box` does not specify, how memory is allocated.
-///
-/// Function is unsafe, because result of this function is no longer
-/// automatically managed that may lead to memory or other resource
-/// leak.
-///
-/// # Example
-/// ```
-/// use std::boxed;
-///
-/// let seventeen = Box::new(17u32);
-/// let raw = unsafe { boxed::into_raw(seventeen) };
-/// let boxed_again = unsafe { Box::from_raw(raw) };
-/// ```
-#[unstable(feature = "alloc",
-           reason = "may be renamed")]
-pub unsafe fn into_raw<T : ?Sized>(b: Box<T>) -> *mut T {
-    mem::transmute(b)
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Default> Default for Box<T> {
     #[stable(feature = "rust1", since = "1.0.0")]

branches/try/src/liballoc/boxed_test.rs

@@ -15,7 +15,6 @@ use core::ops::Deref;
 use core::result::Result::{Ok, Err};
 use core::clone::Clone;
 
-use std::boxed;
 use std::boxed::Box;
 use std::boxed::BoxAny;
 
@@ -31,19 +30,19 @@ struct Test;
 
 #[test]
 fn any_move() {
-    let a = Box::new(8u) as Box<Any>;
+    let a = Box::new(8us) as Box<Any>;
     let b = Box::new(Test) as Box<Any>;
 
     match a.downcast::<uint>() {
-        Ok(a) => { assert!(a == Box::new(8u)); }
+        Ok(a) => { assert!(a == Box::new(8us)); }
         Err(..) => panic!()
     }
     match b.downcast::<Test>() {
         Ok(a) => { assert!(a == Box::new(Test)); }
         Err(..) => panic!()
     }
 
-    let a = Box::new(8u) as Box<Any>;
+    let a = Box::new(8) as Box<Any>;
     let b = Box::new(Test) as Box<Any>;
 
     assert!(a.downcast::<Box<Test>>().is_err());
@@ -52,14 +51,14 @@ fn any_move() {
 
 #[test]
 fn test_show() {
-    let a = Box::new(8u) as Box<Any>;
+    let a = Box::new(8) as Box<Any>;
     let b = Box::new(Test) as Box<Any>;
     let a_str = format!("{:?}", a);
     let b_str = format!("{:?}", b);
     assert_eq!(a_str, "Box<Any>");
     assert_eq!(b_str, "Box<Any>");
 
-    static EIGHT: usize = 8us;
+    static EIGHT: usize = 8;
     static TEST: Test = Test;
     let a = &EIGHT as &Any;
     let b = &TEST as &Any;
@@ -74,44 +73,3 @@ fn deref() {
     fn homura<T: Deref<Target=i32>>(_: T) { }
     homura(Box::new(765i32));
 }
-
-#[test]
-fn raw_sized() {
-    unsafe {
-        let x = Box::new(17i32);
-        let p = boxed::into_raw(x);
-        assert_eq!(17, *p);
-        *p = 19;
-        let y = Box::from_raw(p);
-        assert_eq!(19, *y);
-    }
-}
-
-#[test]
-fn raw_trait() {
-    trait Foo {
-        fn get(&self) -> u32;
-        fn set(&mut self, value: u32);
-    }
-
-    struct Bar(u32);
-
-    impl Foo for Bar {
-        fn get(&self) -> u32 {
-            self.0
-        }
-
-        fn set(&mut self, value: u32) {
-            self.0 = value;
-        }
-    }
-
-    unsafe {
-        let x: Box<Foo> = Box::new(Bar(17));
-        let p = boxed::into_raw(x);
-        assert_eq!(17, (*p).get());
-        (*p).set(19);
-        let y: Box<Foo> = Box::from_raw(p);
-        assert_eq!(19, y.get());
-    }
-}