---

yaml
---
r: 178039
b: refs/heads/tmp
c: cd977ee
h: refs/heads/master
i:
  178037: ea89c7d
  178035: b17357f
  178031: 4e22351
v: v3

Author: edwardw

[refs]

@@ -34,4 +34,4 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 44a287e6eb22ec3c2a687fc156813577464017f7
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: a09782919413bf23bb862934fe1bc191d24896a9
+refs/heads/tmp: cd977ee21787c38510b2a674673e022a7fd0a393

branches/tmp/src/compiletest/compiletest.rs

@@ -22,7 +22,6 @@
 #![feature(std_misc)]
 #![feature(test)]
 #![feature(unicode)]
-#![feature(env)]
 
 #![deny(warnings)]
 
@@ -32,7 +31,7 @@ extern crate getopts;
 #[macro_use]
 extern crate log;
 
-use std::env;
+use std::os;
 use std::old_io;
 use std::old_io::fs;
 use std::thunk::Thunk;
@@ -49,7 +48,7 @@ pub mod common;
 pub mod errors;
 
 pub fn main() {
-    let args = env::args().map(|s| s.into_string().unwrap()).collect();;
+    let args = os::args();
     let config = parse_config(args);
 
     if config.valgrind_path.is_none() && config.force_valgrind {
@@ -225,15 +224,15 @@ pub fn run_tests(config: &Config) {
         //arm-linux-androideabi debug-info test uses remote debugger
         //so, we test 1 task at once.
         // also trying to isolate problems with adb_run_wrapper.sh ilooping
-        env::set_var("RUST_TEST_TASKS","1");
+        os::setenv("RUST_TEST_TASKS","1");
     }
 
     match config.mode {
         DebugInfoLldb => {
             // Some older versions of LLDB seem to have problems with multiple
             // instances running in parallel, so only run one test task at a
             // time.
-            env::set_var("RUST_TEST_TASKS", "1");
+            os::setenv("RUST_TEST_TASKS", "1");
         }
         _ => { /* proceed */ }
     }
@@ -246,7 +245,7 @@ pub fn run_tests(config: &Config) {
     old_io::test::raise_fd_limit();
     // Prevent issue #21352 UAC blocking .exe containing 'patch' etc. on Windows
     // If #11207 is resolved (adding manifest to .exe) this becomes unnecessary
-    env::set_var("__COMPAT_LAYER", "RunAsInvoker");
+    os::setenv("__COMPAT_LAYER", "RunAsInvoker");
     let res = test::run_tests_console(&opts, tests.into_iter().collect());
     match res {
         Ok(true) => {}

branches/tmp/src/compiletest/runtest.rs

@@ -31,7 +31,7 @@ use std::old_io::process::ProcessExit;
 use std::old_io::process;
 use std::old_io::timer;
 use std::old_io;
-use std::env;
+use std::os;
 use std::iter::repeat;
 use std::str;
 use std::string::String;
@@ -1298,9 +1298,9 @@ fn make_lib_name(config: &Config, auxfile: &Path, testfile: &Path) -> Path {
 
 fn make_exe_name(config: &Config, testfile: &Path) -> Path {
     let mut f = output_base_name(config, testfile);
-    if !env::consts::EXE_SUFFIX.is_empty() {
+    if !os::consts::EXE_SUFFIX.is_empty() {
         let mut fname = f.filename().unwrap().to_vec();
-        fname.extend(env::consts::EXE_SUFFIX.bytes());
+        fname.extend(os::consts::EXE_SUFFIX.bytes());
         f.set_filename(fname);
     }
     f

branches/tmp/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/tmp/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/tmp/src/etc/make-win-dist.py

@@ -87,7 +87,6 @@ def make_win_dist(rust_root, gcc_root, target_triple):
                     "libsetupapi.a",
                     "libshell32.a",
                     "libuser32.a",
-                    "libuserenv.a",
                     "libuuid.a",
                     "libwinhttp.a",
                     "libwinmm.a",

branches/tmp/src/libcollections/dlist.rs

@@ -333,7 +333,7 @@ impl<T> DList<T> {
     ///
     /// let mut dl = DList::new();
     ///
-    /// dl.push_front(2);
+    /// dl.push_front(2is);
     /// assert_eq!(dl.len(), 1);
     ///
     /// dl.push_front(1);
@@ -360,10 +360,10 @@ impl<T> DList<T> {
     ///
     /// let mut dl = DList::new();
     ///
-    /// dl.push_front(2);
+    /// dl.push_front(2is);
     /// dl.push_front(1);
     /// assert_eq!(dl.len(), 2);
-    /// assert_eq!(dl.front(), Some(&1));
+    /// assert_eq!(dl.front(), Some(&1is));
     ///
     /// dl.clear();
     /// assert_eq!(dl.len(), 0);
@@ -388,7 +388,7 @@ impl<T> DList<T> {
     /// assert_eq!(dl.front(), None);
     ///
     /// dl.push_front(1);
-    /// assert_eq!(dl.front(), Some(&1));
+    /// assert_eq!(dl.front(), Some(&1is));
     ///
     /// ```
     #[inline]
@@ -409,13 +409,13 @@ impl<T> DList<T> {
     /// assert_eq!(dl.front(), None);
     ///
     /// dl.push_front(1);
-    /// assert_eq!(dl.front(), Some(&1));
+    /// assert_eq!(dl.front(), Some(&1is));
     ///
     /// match dl.front_mut() {
     ///     None => {},
-    ///     Some(x) => *x = 5,
+    ///     Some(x) => *x = 5is,
     /// }
-    /// assert_eq!(dl.front(), Some(&5));
+    /// assert_eq!(dl.front(), Some(&5is));
     ///
     /// ```
     #[inline]
@@ -436,7 +436,7 @@ impl<T> DList<T> {
     /// assert_eq!(dl.back(), None);
     ///
     /// dl.push_back(1);
-    /// assert_eq!(dl.back(), Some(&1));
+    /// assert_eq!(dl.back(), Some(&1is));
     ///
     /// ```
     #[inline]
@@ -457,13 +457,13 @@ impl<T> DList<T> {
     /// assert_eq!(dl.back(), None);
     ///
     /// dl.push_back(1);
-    /// assert_eq!(dl.back(), Some(&1));
+    /// assert_eq!(dl.back(), Some(&1is));
     ///
     /// match dl.back_mut() {
     ///     None => {},
-    ///     Some(x) => *x = 5,
+    ///     Some(x) => *x = 5is,
     /// }
-    /// assert_eq!(dl.back(), Some(&5));
+    /// assert_eq!(dl.back(), Some(&5is));
     ///
     /// ```
     #[inline]
@@ -483,8 +483,8 @@ impl<T> DList<T> {
     ///
     /// let mut dl = DList::new();
     ///
-    /// dl.push_front(2);
-    /// assert_eq!(dl.front().unwrap(), &2);
+    /// dl.push_front(2is);
+    /// assert_eq!(dl.front().unwrap(), &2is);
     ///
     /// dl.push_front(1);
     /// assert_eq!(dl.front().unwrap(), &1);
@@ -508,7 +508,7 @@ impl<T> DList<T> {
     /// let mut d = DList::new();
     /// assert_eq!(d.pop_front(), None);
     ///
-    /// d.push_front(1);
+    /// d.push_front(1is);
     /// d.push_front(3);
     /// assert_eq!(d.pop_front(), Some(3));
     /// assert_eq!(d.pop_front(), Some(1));
@@ -568,7 +568,7 @@ impl<T> DList<T> {
     ///
     /// let mut d = DList::new();
     ///
-    /// d.push_front(1);
+    /// d.push_front(1is);
     /// d.push_front(2);
     /// d.push_front(3);
     ///