---

yaml
---
r: 114346
b: refs/heads/master
c: a239663
h: refs/heads/master
v: v3

Author: huonw

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 1edb0e536433056738b7f715dd02ff1de582f2ba
+refs/heads/master: a239663413f62f9ff2ced554f35576557ff32a5c
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ec0258a381b88b5574e3f8ce72ae553ac3a574b7
 refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17

trunk/src/doc/tutorial.md

@@ -944,7 +944,7 @@ struct Foo { x: int, y: Box<int> }
     // `a` is the owner of the struct, and thus the owner of the struct's fields
     let a = Foo { x: 5, y: box 10 };
 }
-// when `a` goes out of scope, the destructor for the `Box<int>` in the struct's
+// when `a` goes out of scope, the destructor for the `~int` in the struct's
 // field is called
 
 // `b` is mutable, and the mutability is inherited by the objects it owns

trunk/src/libcore/iter.rs

@@ -2016,7 +2016,7 @@ pub struct RangeInclusive<A> {
 
 /// Return an iterator over the range [start, stop]
 #[inline]
-pub fn range_inclusive<A: Add<A, A> + Ord + Clone + One>(start: A, stop: A)
+pub fn range_inclusive<A: Add<A, A> + Ord + Clone + One + ToPrimitive>(start: A, stop: A)
     -> RangeInclusive<A> {
     RangeInclusive{range: range(start, stop), done: false}
 }

trunk/src/libflate/lib.rs

@@ -125,7 +125,7 @@ mod tests {
         for _ in range(0, 20) {
             let mut input = vec![];
             for _ in range(0, 2000) {
-                input.push_all(r.choose(words.as_slice()).unwrap().as_slice());
+                input.push_all(r.choose(words.as_slice()).as_slice());
             }
             debug!("de/inflate of {} bytes of random word-sequences",
                    input.len());

trunk/src/librand/lib.rs

@@ -266,39 +266,37 @@ pub trait Rng {
                                                              0123456789");
         let mut s = StrBuf::with_capacity(len);
         for _ in range(0, len) {
-            s.push_char(*self.choose(GEN_ASCII_STR_CHARSET).unwrap() as char)
+            s.push_char(self.choose(GEN_ASCII_STR_CHARSET) as char)
         }
         s
     }
 
-    /// Return a random element from `values`.
-    ///
-    /// Return `None` if `values` is empty.
+    /// Choose an item randomly, failing if `values` is empty.
+    fn choose<T: Clone>(&mut self, values: &[T]) -> T {
+        self.choose_option(values).expect("Rng.choose: `values` is empty").clone()
+    }
+
+    /// Choose `Some(&item)` randomly, returning `None` if values is
+    /// empty.
     ///
     /// # Example
     ///
-    /// ```
+    /// ```rust
     /// use rand::{task_rng, Rng};
     ///
     /// let choices = [1, 2, 4, 8, 16, 32];
     /// let mut rng = task_rng();
-    /// println!("{}", rng.choose(choices));
-    /// assert_eq!(rng.choose(choices.slice_to(0)), None);
+    /// println!("{:?}", rng.choose_option(choices));
+    /// println!("{:?}", rng.choose_option(choices.slice_to(0)));
     /// ```
-    fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
+    fn choose_option<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
         if values.is_empty() {
             None
         } else {
             Some(&values[self.gen_range(0u, values.len())])
         }
     }
 
-    /// Deprecated name for `choose()`.
-    #[deprecated = "replaced by .choose()"]
-    fn choose_option<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
-        self.choose(values)
-    }
-
     /// Shuffle a mutable slice in place.
     ///
     /// # Example
@@ -795,10 +793,18 @@ mod test {
     #[test]
     fn test_choose() {
         let mut r = task_rng();
-        assert_eq!(r.choose([1, 1, 1]).map(|&x|x), Some(1));
+        assert_eq!(r.choose([1, 1, 1]), 1);
+    }
 
+    #[test]
+    fn test_choose_option() {
+        let mut r = task_rng();
         let v: &[int] = &[];
-        assert_eq!(r.choose(v), None);
+        assert!(r.choose_option(v).is_none());
+
+        let i = 1;
+        let v = [1,1,1];
+        assert_eq!(r.choose_option(v), Some(&i));
     }
 
     #[test]

trunk/src/librustc/driver/config.rs

@@ -70,7 +70,7 @@ pub struct Options {
     pub gc: bool,
     pub optimize: OptLevel,
     pub debuginfo: DebugInfoLevel,
-    pub lint_opts: Vec<(lint::Lint, lint::level)> ,
+    pub lint_opts: Vec<(lint::Lint, lint::Level)> ,
     pub output_types: Vec<back::link::OutputType> ,
     // This was mutable for rustpkg, which updates search paths based on the
     // parsed code. It remains mutable in case its replacements wants to use
@@ -580,8 +580,8 @@ pub fn build_session_options(matches: &getopts::Matches) -> Options {
     let no_trans = matches.opt_present("no-trans");
     let no_analysis = matches.opt_present("no-analysis");
 
-    let lint_levels = [lint::allow, lint::warn,
-                       lint::deny, lint::forbid];
+    let lint_levels = [lint::Allow, lint::Warn,
+                       lint::Deny, lint::Forbid];
     let mut lint_opts = Vec::new();
     let lint_dict = lint::get_lint_dict();
     for level in lint_levels.iter() {

trunk/src/librustc/middle/dead.rs

@@ -12,7 +12,7 @@
 // closely. The idea is that all reachable symbols are live, codes called
 // from live codes are live, and everything else is dead.
 
-use middle::lint::{allow, contains_lint, DeadCode};
+use middle::lint::{Allow, contains_lint, DeadCode};
 use middle::privacy;
 use middle::ty;
 use middle::typeck;
@@ -195,7 +195,7 @@ impl<'a> Visitor<()> for MarkSymbolVisitor<'a> {
 }
 
 fn has_allow_dead_code_or_lang_attr(attrs: &[ast::Attribute]) -> bool {
-    contains_lint(attrs, allow, DEAD_CODE_LINT_STR)
+    contains_lint(attrs, Allow, DEAD_CODE_LINT_STR)
     || attr::contains_name(attrs.as_slice(), "lang")
 }