---

yaml
---
r: 130267
b: refs/heads/auto
c: 3c610af
h: refs/heads/master
i:
  130265: 02b68b7
  130263: 6a74106
v: v3

Author: nrc

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: f7ec95efbb96f8e9bcb8b5e71b5d13803e840dc9
+refs/heads/auto: 3c610af6706a66b185807b8ec721f454e16625de
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/doc/complement-lang-faq.md

@@ -83,7 +83,7 @@ We want to maintain the option to parametrize at runtime. We may eventually chan
 
 ## Why aren't values type-parametric? Why only items?
 
-Doing so would make type inference much more complex, and require the implementation strategy of runtime parameterization.
+Doing so would make type inference much more complex, and require the implementation strategy of runtime parametrization.
 
 ## Why are enumerations nominal and closed?
 

branches/auto/src/doc/guide.md

@@ -1808,7 +1808,7 @@ our code in this file. We'll talk about multiple-file projects later on in the
 guide.
 
 Before we move on, let me show you one more Cargo command: `run`. `cargo run`
-is kind of like `cargo build`, but it also then runs the produced executable.
+is kind of like `cargo build`, but it also then runs the produced exectuable.
 Try it out:
 
 ```{notrust,ignore}

branches/auto/src/doc/rust.md

@@ -1954,7 +1954,7 @@ On `struct`s:
 
 - `repr` - specifies the representation to use for this struct. Takes a list
   of options. The currently accepted ones are `C` and `packed`, which may be
-  combined. `C` will use a C ABI compatible struct layout, and `packed` will
+  combined. `C` will use a C ABI comptible struct layout, and `packed` will
   remove any padding between fields (note that this is very fragile and may
   break platforms which require aligned access).
 
@@ -2367,7 +2367,7 @@ One can indicate the stability of an API using the following attributes:
 These levels are directly inspired by
 [Node.js' "stability index"](http://nodejs.org/api/documentation.html).
 
-Stability levels are inherited, so an item's stability attribute is the
+Stability levels are inherited, so an items's stability attribute is the
 default stability for everything nested underneath it.
 
 There are lints for disallowing items marked with certain levels: `deprecated`,
@@ -2444,7 +2444,7 @@ The currently implemented features of the reference compiler are:
 
 * `concat_idents` - Allows use of the `concat_idents` macro, which is in many
                     ways insufficient for concatenating identifiers, and may
-                    be removed entirely for something more wholesome.
+                    be removed entirely for something more wholsome.
 
 * `default_type_params` - Allows use of default type parameters. The future of
                           this feature is uncertain.
@@ -3604,7 +3604,7 @@ of the type.[^structtype]
 
 New instances of a `struct` can be constructed with a [struct expression](#structure-expressions).
 
-The memory layout of a `struct` is undefined by default to allow for compiler optimizations like
+The memory layout of a `struct` is undefined by default to allow for compiler optimziations like
 field reordering, but it can be fixed with the `#[repr(...)]` attribute.
 In either case, fields may be given in any order in a corresponding struct *expression*;
 the resulting `struct` value will always have the same memory layout.
@@ -3668,17 +3668,32 @@ let a: List<int> = Cons(7, box Cons(13, box Nil));
 
 All pointers in Rust are explicit first-class values.
 They can be copied, stored into data structures, and returned from functions.
-There are two varieties of pointer in Rust:
+There are four varieties of pointer in Rust:
+
+* Owning pointers (`Box`)
+  : These point to owned heap allocations (or "boxes") in the shared, inter-task heap.
+    Each owned box has a single owning pointer; pointer and pointee retain a 1:1 relationship at all times.
+    Owning pointers are written `Box<content>`,
+    for example `Box<int>` means an owning pointer to an owned box containing an integer.
+    Copying an owned box is a "deep" operation:
+    it involves allocating a new owned box and copying the contents of the old box into the new box.
+    Releasing an owning pointer immediately releases its corresponding owned box.
 
 * References (`&`)
   : These point to memory _owned by some other value_.
-    A reference type is written `&type` for some lifetime-variable `f`,
-    or just `&'a type` when you need an explicit lifetime.
+    References arise by (automatic) conversion from owning pointers, managed pointers,
+    or by applying the borrowing operator `&` to some other value,
+    including [lvalues, rvalues or temporaries](#lvalues,-rvalues-and-temporaries).
+    A borrow expression is written `&content`.
+
+    A reference type is written `&'f type` for some lifetime-variable `f`,
+    or just `&type` when the lifetime can be elided;
+    for example `&int` means a reference to an integer.
     Copying a reference is a "shallow" operation:
     it involves only copying the pointer itself.
     Releasing a reference typically has no effect on the value it points to,
-    with the exception of temporary values, which are released when the last
-    reference to them is released.
+    with the exception of temporary values,
+    which are released when the last reference to them is released.
 
 * Raw pointers (`*`)
   : Raw pointers are pointers without safety or liveness guarantees.
@@ -3691,9 +3706,6 @@ There are two varieties of pointer in Rust:
     they exist to support interoperability with foreign code,
     and writing performance-critical or low-level functions.
 
-The standard library contains addtional 'smart pointer' types beyond references
-and raw pointers.
-
 ### Function types
 
 The function type constructor `fn` forms new function types.
@@ -4202,7 +4214,7 @@ be ignored in favor of only building the artifacts specified by command line.
   purpose of this output type is to create a static library containing all of
   the local crate's code along with all upstream dependencies. The static
   library is actually a `*.a` archive on linux and osx and a `*.lib` file on
-  windows. This format is recommended for use in situations such as linking
+  windows. This format is recommended for use in situtations such as linking
   Rust code into an existing non-Rust application because it will not have
   dynamic dependencies on other Rust code.
 

branches/auto/src/libnum/complex.rs

@@ -12,13 +12,13 @@
 //! Complex numbers.
 
 use std::fmt;
-use std::num::{Zero, One, ToStrRadix};
+use std::num::{Zero,One,ToStrRadix};
 
 // FIXME #1284: handle complex NaN & infinity etc. This
 // probably doesn't map to C's _Complex correctly.
 
 /// A complex number in Cartesian form.
-#[deriving(PartialEq, Clone, Hash)]
+#[deriving(PartialEq,Clone)]
 pub struct Complex<T> {
     /// Real portion of the complex number
     pub re: T,
@@ -36,8 +36,10 @@ impl<T: Clone + Num> Complex<T> {
         Complex { re: re, im: im }
     }
 
-    /// Returns the square of the norm (since `T` doesn't necessarily
-    /// have a sqrt function), i.e. `re^2 + im^2`.
+    /**
+    Returns the square of the norm (since `T` doesn't necessarily
+    have a sqrt function), i.e. `re^2 + im^2`.
+    */
     #[inline]
     pub fn norm_sqr(&self) -> T {
         self.re * self.re + self.im * self.im
@@ -191,8 +193,7 @@ mod test {
     #![allow(non_uppercase_statics)]
 
     use super::{Complex64, Complex};
-    use std::num::{Zero, One, Float};
-    use std::hash::hash;
+    use std::num::{Zero,One,Float};
 
     pub static _0_0i : Complex64 = Complex { re: 0.0, im: 0.0 };
     pub static _1_0i : Complex64 = Complex { re: 1.0, im: 0.0 };
@@ -366,14 +367,4 @@ mod test {
         test(-_neg1_1i, "1-1i".to_string());
         test(_05_05i, "0.5+0.5i".to_string());
     }
-
-    #[test]
-    fn test_hash() {
-        let a = Complex::new(0i32, 0i32);
-        let b = Complex::new(1i32, 0i32);
-        let c = Complex::new(0i32, 1i32);
-        assert!(hash(&a) != hash(&b));
-        assert!(hash(&b) != hash(&c));
-        assert!(hash(&c) != hash(&a));
-    }
 }

branches/auto/src/libnum/rational.rs

@@ -21,7 +21,7 @@ use std::num::{Zero, One, ToStrRadix, FromStrRadix};
 use bigint::{BigInt, BigUint, Sign, Plus, Minus};
 
 /// Represents the ratio between 2 numbers.
-#[deriving(Clone, Hash)]
+#[deriving(Clone)]
 #[allow(missing_doc)]
 pub struct Ratio<T> {
     numer: T,
@@ -380,7 +380,6 @@ mod test {
     use super::{Ratio, Rational, BigRational};
     use std::num::{Zero, One, FromStrRadix, FromPrimitive, ToStrRadix};
     use std::from_str::FromStr;
-    use std::hash::hash;
     use std::num;
 
     pub static _0 : Rational = Ratio { numer: 0, denom: 1};
@@ -752,10 +751,4 @@ mod test {
         assert!(! _neg1_2.is_positive());
         assert!(! _1_2.is_negative());
     }
-
-    #[test]
-    fn test_hash() {
-        assert!(hash(&_0) != hash(&_1));
-        assert!(hash(&_0) != hash(&_3_2));
-    }
 }

branches/auto/src/librustc/diagnostics.rs

@@ -170,6 +170,5 @@ register_diagnostics!(
     E0156,
     E0157,
     E0158,
-    E0159,
-    E0160
+    E0159
 )

branches/auto/src/librustc/front/test.rs

@@ -50,12 +50,10 @@ struct TestCtxt<'a> {
     path: Vec<ast::Ident>,
     ext_cx: ExtCtxt<'a>,
     testfns: Vec<Test>,
+    reexport_mod_ident: ast::Ident,
     reexport_test_harness_main: Option<InternedString>,
     is_test_crate: bool,
     config: ast::CrateConfig,
-
-    // top-level re-export submodule, filled out after folding is finished
-    toplevel_reexport: Option<ast::Ident>,
 }
 
 // Traverse the crate, collecting all the test functions, eliding any
@@ -85,9 +83,7 @@ pub fn modify_for_testing(sess: &Session,
 struct TestHarnessGenerator<'a> {
     cx: TestCtxt<'a>,
     tests: Vec<ast::Ident>,
-
-    // submodule name, gensym'd identifier for re-exports
-    tested_submods: Vec<(ast::Ident, ast::Ident)>,
+    tested_submods: Vec<ast::Ident>,
 }
 
 impl<'a> fold::Folder for TestHarnessGenerator<'a> {
@@ -172,14 +168,10 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
             *i = nomain(*i);
         }
         if !tests.is_empty() || !tested_submods.is_empty() {
-            let (it, sym) = mk_reexport_mod(&mut self.cx, tests, tested_submods);
-            mod_folded.items.push(it);
-
+            mod_folded.items.push(mk_reexport_mod(&mut self.cx, tests,
+                                                  tested_submods));
             if !self.cx.path.is_empty() {
-                self.tested_submods.push((self.cx.path[self.cx.path.len()-1], sym));
-            } else {
-                debug!("pushing nothing, sym: {}", sym);
-                self.cx.toplevel_reexport = Some(sym);
+                self.tested_submods.push(self.cx.path[self.cx.path.len()-1]);
             }
         }
 
@@ -188,16 +180,16 @@ impl<'a> fold::Folder for TestHarnessGenerator<'a> {
 }
 
 fn mk_reexport_mod(cx: &mut TestCtxt, tests: Vec<ast::Ident>,
-                   tested_submods: Vec<(ast::Ident, ast::Ident)>) -> (Gc<ast::Item>, ast::Ident) {
+                   tested_submods: Vec<ast::Ident>) -> Gc<ast::Item> {
     let mut view_items = Vec::new();
     let super_ = token::str_to_ident("super");
 
     view_items.extend(tests.move_iter().map(|r| {
         cx.ext_cx.view_use_simple(DUMMY_SP, ast::Public,
                                   cx.ext_cx.path(DUMMY_SP, vec![super_, r]))
     }));
-    view_items.extend(tested_submods.move_iter().map(|(r, sym)| {
-        let path = cx.ext_cx.path(DUMMY_SP, vec![super_, r, sym]);
+    view_items.extend(tested_submods.move_iter().map(|r| {
+        let path = cx.ext_cx.path(DUMMY_SP, vec![super_, r, cx.reexport_mod_ident]);
         cx.ext_cx.view_use_simple_(DUMMY_SP, ast::Public, r, path)
     }));
 
@@ -206,18 +198,14 @@ fn mk_reexport_mod(cx: &mut TestCtxt, tests: Vec<ast::Ident>,
         view_items: view_items,
         items: Vec::new(),
     };
-
-    let sym = token::gensym_ident("__test_reexports");
-    let it = box(GC) ast::Item {
-        ident: sym.clone(),
+    box(GC) ast::Item {
+        ident: cx.reexport_mod_ident.clone(),
         attrs: Vec::new(),
         id: ast::DUMMY_NODE_ID,
         node: ast::ItemMod(reexport_mod),
         vis: ast::Public,
         span: DUMMY_SP,
-    };
-
-    (it, sym)
+    }
 }
 
 fn generate_test_harness(sess: &Session,
@@ -232,10 +220,10 @@ fn generate_test_harness(sess: &Session,
                              }),
         path: Vec::new(),
         testfns: Vec::new(),
+        reexport_mod_ident: token::gensym_ident("__test_reexports"),
         reexport_test_harness_main: reexport_test_harness_main,
         is_test_crate: is_test_crate(&krate),
         config: krate.config.clone(),
-        toplevel_reexport: None,
     };
 
     cx.ext_cx.bt_push(ExpnInfo {
@@ -542,14 +530,7 @@ fn mk_test_desc_and_fn_rec(cx: &TestCtxt, test: &Test) -> Gc<ast::Expr> {
              field("should_fail", fail_expr)]);
 
 
-    let mut visible_path = match cx.toplevel_reexport {
-        Some(id) => vec![id],
-        None => {
-            cx.sess.bug(
-                "expected to find top-level re-export name, but found None"
-            );
-        }
-    };
+    let mut visible_path = vec![cx.reexport_mod_ident.clone()];
     visible_path.extend(path.move_iter());
 
     let fn_expr = ecx.expr_path(ecx.path_global(span, visible_path));

branches/auto/src/librustc/middle/astencode.rs

@@ -1073,18 +1073,9 @@ impl<'a> rbml_writer_helpers for Encoder<'a> {
                         this.emit_enum_variant_arg(0, |this| Ok(this.emit_unsize_kind(ecx, uk)))
                     })
                 }
-                &ty::AutoUnsafe(m, None) => {
-                    this.emit_enum_variant("AutoUnsafe", 3, 2, |this| {
-                        this.emit_enum_variant_arg(0, |this| m.encode(this));
-                        this.emit_enum_variant_arg(1,
-                            |this| this.emit_option(|this| this.emit_option_none()))
-                    })
-                }
-                &ty::AutoUnsafe(m, Some(box ref a)) => {
-                    this.emit_enum_variant("AutoUnsafe", 3, 2, |this| {
-                        this.emit_enum_variant_arg(0, |this| m.encode(this));
-                        this.emit_enum_variant_arg(1, |this| this.emit_option(
-                            |this| this.emit_option_some(|this| Ok(this.emit_autoref(ecx, a)))))
+                &ty::AutoUnsafe(m) => {
+                    this.emit_enum_variant("AutoUnsafe", 3, 1, |this| {
+                        this.emit_enum_variant_arg(0, |this| m.encode(this))
                     })
                 }
             }
@@ -1644,16 +1635,8 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> {
                     3 => {
                         let m: ast::Mutability =
                             this.read_enum_variant_arg(0, |this| Decodable::decode(this)).unwrap();
-                        let a: Option<Box<ty::AutoRef>> =
-                            this.read_enum_variant_arg(1, |this| this.read_option(|this, b| {
-                                if b {
-                                    Ok(Some(box this.read_autoref(xcx)))
-                                } else {
-                                    Ok(None)
-                                }
-                            })).unwrap();
 
-                        ty::AutoUnsafe(m, a)
+                        ty::AutoUnsafe(m)
                     }
                     _ => fail!("bad enum variant for ty::AutoRef")
                 })

branches/auto/src/librustc/middle/expr_use_visitor.rs

@@ -762,7 +762,7 @@ impl<'d,'t,TYPER:mc::Typer> ExprUseVisitor<'d,'t,TYPER> {
                                      ty::BorrowKind::from_mutbl(m),
                                      AutoRef);
             }
-            ty::AutoUnsizeUniq(_) | ty::AutoUnsize(_) | ty::AutoUnsafe(..) => {}
+            ty::AutoUnsizeUniq(_) | ty::AutoUnsize(_) | ty::AutoUnsafe(_) => {}
         }
     }
 

branches/auto/src/librustc/middle/trans/adt.rs

@@ -296,9 +296,8 @@ impl Case {
 
         for (i, &ty) in self.tys.iter().enumerate() {
             match ty::get(ty).sty {
-                // &T/&mut T/*T could either be a thin or fat pointer depending on T
-                ty::ty_rptr(_, ty::mt { ty, .. })
-                | ty::ty_ptr(ty::mt { ty, .. }) => match ty::get(ty).sty {
+                // &T/&mut T could either be a thin or fat pointer depending on T
+                ty::ty_rptr(_, ty::mt { ty, .. }) => match ty::get(ty).sty {
                     // &[T] and &str are a pointer and length pair
                     ty::ty_vec(_, None) | ty::ty_str => return Some(FatPointer(i, slice_elt_base)),
 

branches/auto/src/librustc/middle/trans/base.rs

@@ -566,8 +566,8 @@ pub fn compare_scalar_types<'a>(
 
     match ty::get(t).sty {
         ty::ty_nil => f(nil_type),
-        ty::ty_bool | ty::ty_uint(_) | ty::ty_char => f(unsigned_int),
-        ty::ty_ptr(mt) if ty::type_is_sized(cx.tcx(), mt.ty) => f(unsigned_int),
+        ty::ty_bool | ty::ty_ptr(_) |
+        ty::ty_uint(_) | ty::ty_char => f(unsigned_int),
         ty::ty_int(_) => f(signed_int),
         ty::ty_float(_) => f(floating_point),
             // Should never get here, because t is scalar.