---

yaml
---
r: 158582
b: refs/heads/try
c: 2a7fb35
h: refs/heads/master
v: v3

Author: Jorge Aparicio

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: a0a7ab461283322215f0343cd2b5e66fc19a7bd5
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 1b2ad7831f1745bf4a4709a1fa1772afb47c933c
-refs/heads/try: 11790a545c77e0f35a00d2b27ff590393d705246
+refs/heads/try: 2a7fb3584c974d6bf09182d454a457515aca228b
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/doc/guide.md

@@ -777,7 +777,7 @@ fn add_one(x: int) -> int {
      x + 1;
 }
 
-help: consider removing this semicolon:
+note: consider removing this semicolon:
      x + 1;
           ^
 ```
@@ -4467,19 +4467,18 @@ see why consumers matter.
 
 ## Iterators
 
-As we've said before, an iterator is something that we can call the
-`.next()` method on repeatedly, and it gives us a sequence of things.
-Because you need to call the method, this means that iterators
-are **lazy** and don't need to generate all of the values upfront.
-This code, for example, does not actually generate the numbers
-`1-100`, and just creates a value that represents the sequence:
+As we've said before, an iterator is something that we can call the `.next()`
+method on repeatedly, and it gives us a sequence of things. Because you need
+to call the method, this means that iterators are **lazy**. This code, for
+example, does not actually generate the numbers `1-100`, and just creates a
+value that represents the sequence:
 
 ```{rust}
 let nums = range(1i, 100i);
 ```
 
 Since we didn't do anything with the range, it didn't generate the sequence.
-Let's add the consumer:
+Once we add the consumer:
 
 ```{rust}
 let nums = range(1i, 100i).collect::<Vec<int>>();
@@ -4508,8 +4507,8 @@ std::iter::count(1i, 5i);
 ```
 
 This iterator counts up from one, adding five each time. It will give
-you a new integer every time, forever (well, technically, until it reaches the
-maximum number representable by an `int`). But since iterators are lazy,
+you a new integer every time, forever. Well, technically, until the
+maximum number that an `int` can represent. But since iterators are lazy,
 that's okay! You probably don't want to use `collect()` on it, though...
 
 That's enough about iterators. Iterator adapters are the last concept
@@ -5252,8 +5251,8 @@ to do something that it can't currently do? You may be able to write a macro
 to extend Rust's capabilities.
 
 You've already used one macro extensively: `println!`. When we invoke
-a Rust macro, we need to use the exclamation mark (`!`). There are two reasons
-why this is so: the first is that it makes it clear when you're using a
+a Rust macro, we need to use the exclamation mark (`!`). There's two reasons
+that this is true: the first is that it makes it clear when you're using a
 macro. The second is that macros allow for flexible syntax, and so Rust must
 be able to tell where a macro starts and ends. The `!(...)` helps with this.
 
@@ -5268,7 +5267,7 @@ println!("x is: {}", x);
 
 The `println!` macro does a few things:
 
-1. It parses the string to find any `{}`s.
+1. It parses the string to find any `{}`s
 2. It checks that the number of `{}`s matches the number of other arguments.
 3. It generates a bunch of Rust code, taking this in mind.
 
@@ -5277,8 +5276,8 @@ Rust will generate code that takes all of the types into account. If
 `println!` was a function, it could still do this type checking, but it
 would happen at run time rather than compile time.
 
-We can check this out using a special flag to `rustc`. Put this code in a file
-called `print.rs`:
+We can check this out using a special flag to `rustc`. This code, in a file
+`print.rs`:
 
 ```{rust}
 fn main() {
@@ -5287,7 +5286,7 @@ fn main() {
 }
 ```
 
-You can have the macros expanded like this: `rustc print.rs --pretty=expanded` – which will
+Can have its macros expanded like this: `rustc print.rs --pretty=expanded`, will
 give us this huge result:
 
 ```{rust,ignore}
@@ -5326,12 +5325,12 @@ invoke the `println_args` function with the generated arguments.
 This is the code that Rust actually compiles. You can see all of the extra
 information that's here. We get all of the type safety and options that it
 provides, but at compile time, and without needing to type all of this out.
-This is how macros are powerful: without them you would need to type all of
-this by hand to get a type-checked `println`.
+This is how macros are powerful. Without them, you would need to type all of
+this by hand to get a type checked `println`.
 
 For more on macros, please consult [the Macros Guide](guide-macros.html).
-Macros are a very advanced and still slightly experimental feature, but they don't
-require a deep understanding to be called, since they look just like functions. The
+Macros are a very advanced and still slightly experimental feature, but don't
+require a deep understanding to call, since they look just like functions. The
 Guide can help you if you want to write your own.
 
 # Unsafe
@@ -5348,8 +5347,8 @@ keyword, which indicates that the function may not behave properly.
 
 Second, if you'd like to create some sort of shared-memory data structure, Rust
 won't allow it, because memory must be owned by a single owner. However, if
-you're planning on making access to that shared memory safe – such as with a
-mutex – _you_ know that it's safe, but Rust can't know. Writing an `unsafe`
+you're planning on making access to that shared memory safe, such as with a
+mutex, _you_ know that it's safe, but Rust can't know. Writing an `unsafe`
 block allows you to ask the compiler to trust you. In this case, the _internal_
 implementation of the mutex is considered unsafe, but the _external_ interface
 we present is safe. This allows it to be effectively used in normal Rust, while

branches/try/src/doc/reference.md

@@ -831,7 +831,7 @@ mod math {
 }
 ```
 
-Modules and types share the same namespace. Declaring a named type with
+Modules and types share the same namespace. Declaring a named type that has
 the same name as a module in scope is forbidden: that is, a type definition,
 trait, struct, enumeration, or type parameter can't shadow the name of a module
 in scope, or vice versa.
@@ -870,8 +870,8 @@ view_item : extern_crate_decl | use_decl ;
 ```
 
 A view item manages the namespace of a module. View items do not define new
-items, but rather, simply change other items' visibility. There are two
-kinds of view items:
+items, but rather, simply change other items' visibility. There are several
+kinds of view item:
 
 * [`extern crate` declarations](#extern-crate-declarations)
 * [`use` declarations](#use-declarations)
@@ -896,7 +896,7 @@ external crate when it was compiled. If no `crateid` is provided, a default
 `name` attribute is assumed, equal to the `ident` given in the
 `extern_crate_decl`.
 
-Three examples of `extern crate` declarations:
+Four examples of `extern crate` declarations:
 
 ```{.ignore}
 extern crate pcre;

branches/try/src/etc/vim/autoload/rust.vim

@@ -178,14 +178,14 @@ function! s:WithPath(func, ...)
 			call mkdir(tmpdir)
 
 			let save_cwd = getcwd()
-			silent exe 'lcd' fnameescape(tmpdir)
+			silent exe 'lcd' tmpdir
 
 			let path = 'unnamed.rs'
 
 			let save_mod = &mod
 			set nomod
 
-			silent exe 'keepalt write! ' . fnameescape(path)
+			silent exe 'keepalt write! ' . path
 			if pathisempty
 				silent keepalt 0file
 			endif
@@ -195,10 +195,10 @@ function! s:WithPath(func, ...)
 
 		call call(a:func, [path] + a:000)
 	finally
-		if exists("save_mod")   | let &mod = save_mod                    | endif
-		if exists("save_write") | let &write = save_write                | endif
-		if exists("save_cwd")   | silent exe 'lcd' fnameescape(save_cwd) | endif
-		if exists("tmpdir")     | silent call s:RmDir(tmpdir)            | endif
+		if exists("save_mod")   | let &mod = save_mod          | endif
+		if exists("save_write") | let &write = save_write      | endif
+		if exists("save_cwd")   | silent exe 'lcd' save_cwd    | endif
+		if exists("tmpdir")     | silent call s:RmDir(tmpdir)  | endif
 	endtry
 endfunction
 

branches/try/src/librand/distributions/mod.rs

@@ -227,13 +227,6 @@ fn ziggurat<R:Rng>(
         // creating a f64), so we might as well reuse some to save
         // generating a whole extra random number. (Seems to be 15%
         // faster.)
-        //
-        // This unfortunately misses out on the benefits of direct
-        // floating point generation if an RNG like dSMFT is
-        // used. (That is, such RNGs create floats directly, highly
-        // efficiently and overload next_f32/f64, so by not calling it
-        // this may be slower than it would be otherwise.)
-        // FIXME: investigate/optimise for the above.
         let bits: u64 = rng.gen();
         let i = (bits & 0xff) as uint;
         let f = (bits >> 11) as f64 / SCALE;

branches/try/src/librand/lib.rs

@@ -78,46 +78,6 @@ pub trait Rng {
         (self.next_u32() as u64 << 32) | (self.next_u32() as u64)
     }
 
-    /// Return the next random f32 selected from the half-open
-    /// interval `[0, 1)`.
-    ///
-    /// By default this is implemented in terms of `next_u32`, but a
-    /// random number generator which can generate numbers satisfying
-    /// the requirements directly can overload this for performance.
-    /// It is required that the return value lies in `[0, 1)`.
-    ///
-    /// See `Closed01` for the closed interval `[0,1]`, and
-    /// `Open01` for the open interval `(0,1)`.
-    fn next_f32(&mut self) -> f32 {
-        const MANTISSA_BITS: uint = 24;
-        const IGNORED_BITS: uint = 8;
-        const SCALE: f32 = (1u64 << MANTISSA_BITS) as f32;
-
-        // using any more than `MANTISSA_BITS` bits will
-        // cause (e.g.) 0xffff_ffff to correspond to 1
-        // exactly, so we need to drop some (8 for f32, 11
-        // for f64) to guarantee the open end.
-        (self.next_u32() >> IGNORED_BITS) as f32 / SCALE
-    }
-
-    /// Return the next random f64 selected from the half-open
-    /// interval `[0, 1)`.
-    ///
-    /// By default this is implemented in terms of `next_u64`, but a
-    /// random number generator which can generate numbers satisfying
-    /// the requirements directly can overload this for performance.
-    /// It is required that the return value lies in `[0, 1)`.
-    ///
-    /// See `Closed01` for the closed interval `[0,1]`, and
-    /// `Open01` for the open interval `(0,1)`.
-    fn next_f64(&mut self) -> f64 {
-        const MANTISSA_BITS: uint = 53;
-        const IGNORED_BITS: uint = 11;
-        const SCALE: f64 = (1u64 << MANTISSA_BITS) as f64;
-
-        (self.next_u64() >> IGNORED_BITS) as f64 / SCALE
-    }
-
     /// Fill `dest` with random data.
     ///
     /// This has a default implementation in terms of `next_u64` and

branches/try/src/librand/rand_impls.rs

@@ -96,11 +96,11 @@ impl Rand for u64 {
 }
 
 macro_rules! float_impls {
-    ($mod_name:ident, $ty:ty, $mantissa_bits:expr, $method_name:ident) => {
+    ($mod_name:ident, $ty:ty, $mantissa_bits:expr, $method_name:ident, $ignored_bits:expr) => {
         mod $mod_name {
             use {Rand, Rng, Open01, Closed01};
 
-            const SCALE: $ty = (1u64 << $mantissa_bits) as $ty;
+            static SCALE: $ty = (1u64 << $mantissa_bits) as $ty;
 
             impl Rand for $ty {
                 /// Generate a floating point number in the half-open
@@ -110,7 +110,11 @@ macro_rules! float_impls {
                 /// and `Open01` for the open interval `(0,1)`.
                 #[inline]
                 fn rand<R: Rng>(rng: &mut R) -> $ty {
-                    rng.$method_name()
+                    // using any more than `mantissa_bits` bits will
+                    // cause (e.g.) 0xffff_ffff to correspond to 1
+                    // exactly, so we need to drop some (8 for f32, 11
+                    // for f64) to guarantee the open end.
+                    (rng.$method_name() >> $ignored_bits) as $ty / SCALE
                 }
             }
             impl Rand for Open01<$ty> {
@@ -120,22 +124,23 @@ macro_rules! float_impls {
                     // the precision of f64/f32 at 1.0), so that small
                     // numbers are larger than 0, but large numbers
                     // aren't pushed to/above 1.
-                    Open01(rng.$method_name() + 0.25 / SCALE)
+                    Open01(((rng.$method_name() >> $ignored_bits) as $ty + 0.25) / SCALE)
                 }
             }
             impl Rand for Closed01<$ty> {
                 #[inline]
                 fn rand<R: Rng>(rng: &mut R) -> Closed01<$ty> {
-                    // rescale so that 1.0 - epsilon becomes 1.0
-                    // precisely.
-                    Closed01(rng.$method_name() * SCALE / (SCALE - 1.0))
+                    // divide by the maximum value of the numerator to
+                    // get a non-zero probability of getting exactly
+                    // 1.0.
+                    Closed01((rng.$method_name() >> $ignored_bits) as $ty / (SCALE - 1.0))
                 }
             }
         }
     }
 }
-float_impls! { f64_rand_impls, f64, 53, next_f64 }
-float_impls! { f32_rand_impls, f32, 24, next_f32 }
+float_impls! { f64_rand_impls, f64, 53, next_u64, 11 }
+float_impls! { f32_rand_impls, f32, 24, next_u32, 8 }
 
 impl Rand for char {
     #[inline]

branches/try/src/librustc/lint/builtin.rs

@@ -187,12 +187,12 @@ impl LintPass for TypeLimits {
 
                     if let Some(bits) = opt_ty_bits {
                         let exceeding = if let ast::ExprLit(ref lit) = r.node {
-                            if let ast::LitInt(shift, _) = lit.node { shift >= bits }
+                            if let ast::LitInt(shift, _) = lit.node { shift > bits }
                             else { false }
                         } else {
                             match eval_const_expr_partial(cx.tcx, &**r) {
-                                Ok(const_int(shift)) => { shift as u64 >= bits },
-                                Ok(const_uint(shift)) => { shift >= bits },
+                                Ok(const_int(shift)) => { shift as u64 > bits },
+                                Ok(const_uint(shift)) => { shift > bits },
                                 _ => { false }
                             }
                         };

branches/try/src/librustc/lint/context.rs

@@ -532,7 +532,7 @@ impl<'a, 'tcx> Context<'a, 'tcx> {
         }
     }
 
-    fn visit_ids(&mut self, f: |&mut ast_util::IdVisitor<Context>|) {
+    fn visit_ids(&self, f: |&mut ast_util::IdVisitor<Context>|) {
         let mut v = ast_util::IdVisitor {
             operation: self,
             pass_through_items: false,
@@ -749,7 +749,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> {
 
 // Output any lints that were previously added to the session.
 impl<'a, 'tcx> IdVisitingOperation for Context<'a, 'tcx> {
-    fn visit_id(&mut self, id: ast::NodeId) {
+    fn visit_id(&self, id: ast::NodeId) {
         match self.tcx.sess.lints.borrow_mut().pop(&id) {
             None => {}
             Some(lints) => {

branches/try/src/librustc/metadata/common.rs

@@ -148,7 +148,7 @@ impl astencode_tag {
     pub fn from_uint(value : uint) -> Option<astencode_tag> {
         let is_a_tag = first_astencode_tag <= value && value <= last_astencode_tag;
         if !is_a_tag { None } else {
-            Some(unsafe { mem::transmute::<uint, astencode_tag>(value) })
+            Some(unsafe { mem::transmute(value) })
         }
     }
 }
@@ -247,3 +247,4 @@ pub const tag_type_param_def: uint = 0xa5;
 
 pub const tag_item_generics: uint = 0xa6;
 pub const tag_method_ty_generics: uint = 0xa7;
+

branches/try/src/librustc/metadata/decoder.rs

@@ -36,7 +36,7 @@ use std::io::extensions::u64_from_be_bytes;
 use std::io;
 use std::collections::hash_map::HashMap;
 use std::rc::Rc;
-use std::str;
+use std::u64;
 use rbml::reader;
 use rbml;
 use serialize::Decodable;
@@ -215,9 +215,7 @@ fn each_reexport(d: rbml::Doc, f: |rbml::Doc| -> bool) -> bool {
 
 fn variant_disr_val(d: rbml::Doc) -> Option<ty::Disr> {
     reader::maybe_get_doc(d, tag_disr_val).and_then(|val_doc| {
-        reader::with_doc_data(val_doc, |data| {
-            str::from_utf8(data).and_then(from_str)
-        })
+        reader::with_doc_data(val_doc, |data| u64::parse_bytes(data, 10u))
     })
 }