---

yaml
---
r: 113058
b: refs/heads/try
c: 593f6a4
h: refs/heads/master
v: v3

Author: TeXitoi

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: abdacecdf86b4b5a4f432560445a24e1c5f4751b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 922c420fcd4dfbfc7e3bce4dd20d9b17a20b39f3
-refs/heads/try: e0d261e576817817bf3433deee6a1434cec47002
+refs/heads/try: 593f6a42d01070c7217c1241e8783b4e908884bb
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/RELEASES.txt

@@ -63,7 +63,7 @@ Version 0.10 (April 2014)
       documentation index page.
     * std: `std::condition` has been removed. All I/O errors are now propagated
       through the `Result` type. In order to assist with error handling, a
-      `try!` macro for unwrapping errors with an early return and a lint for
+      `try!` macro for unwrapping errors with an early return and an lint for
       unused results has been added. See #12039 for more information.
     * std: The `vec` module has been renamed to `slice`.
     * std: A new vector type, `Vec<T>`, has been added in preparation for DST.

branches/try/src/compiletest/header.rs

@@ -170,7 +170,7 @@ fn parse_compile_flags(line: &str) -> Option<~str> {
 }
 
 fn parse_run_flags(line: &str) -> Option<~str> {
-    parse_name_value_directive(line, "run-flags".to_owned())
+    parse_name_value_directive(line, ~"run-flags")
 }
 
 fn parse_debugger_cmd(line: &str) -> Option<~str> {

branches/try/src/doc/guide-lifetimes.md

@@ -263,7 +263,7 @@ process is called *rooting*.
 The previous example demonstrated *rooting*, the process by which the
 compiler ensures that managed boxes remain live for the duration of a
 borrow. Unfortunately, rooting does not work for borrows of owned
-boxes, because it is not possible to have two references to an owned
+boxes, because it is not possible to have two references to a owned
 box.
 
 For owned boxes, therefore, the compiler will only allow a borrow *if
@@ -462,7 +462,7 @@ of a `f64` as if it were a struct with two fields would be a memory
 safety violation.
 
 So, in fact, for every `ref` binding, the compiler will impose the
-same rules as the ones we saw for borrowing the interior of an owned
+same rules as the ones we saw for borrowing the interior of a owned
 box: it must be able to guarantee that the `enum` will not be
 overwritten for the duration of the borrow.  In fact, the compiler
 would accept the example we gave earlier. The example is safe because

branches/try/src/doc/guide-unsafe.md

@@ -56,7 +56,7 @@ standard library types, e.g. `Cell` and `RefCell`, that provide inner
 mutability by replacing compile time guarantees with dynamic checks at
 runtime.
 
-An `&mut` reference has a stronger requirement: when an object has an
+An `&mut` reference has a stronger requirement: when a object has an
 `&mut T` pointing into it, then that `&mut` reference must be the only
 such usable path to that object in the whole program. That is, an
 `&mut` cannot alias with any other references.

branches/try/src/doc/rust.md

@@ -161,7 +161,7 @@ Comments in Rust code follow the general C++ style of line and block-comment for
 with no nesting of block-comment delimiters.
 
 Line comments beginning with exactly _three_ slashes (`///`), and block
-comments beginning with exactly one repeated asterisk in the block-open
+comments beginning with a exactly one repeated asterisk in the block-open
 sequence (`/**`), are interpreted as a special syntax for `doc`
 [attributes](#attributes).  That is, they are equivalent to writing
 `#[doc="..."]` around the body of the comment (this includes the comment
@@ -365,7 +365,7 @@ of integer literal suffix:
     give the literal the corresponding machine type.
 
 The type of an _unsuffixed_ integer literal is determined by type inference.
-If an integer type can be _uniquely_ determined from the surrounding program
+If a 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, the unsuffixed integer literal's type is `int`; if
 the program context overconstrains the type, it is considered a static type
@@ -2184,7 +2184,7 @@ Supported traits for `deriving` are:
 * `Hash`, to iterate over the bytes in a data type.
 * `Rand`, to create a random instance of a data type.
 * `Default`, to create an empty instance of a data type.
-* `Zero`, to create a zero instance of a numeric data type.
+* `Zero`, to create an zero instance of a numeric data type.
 * `FromPrimitive`, to create an instance from a numeric primitive.
 * `Show`, to format a value using the `{}` formatter.
 

branches/try/src/doc/tutorial.md

@@ -1197,7 +1197,7 @@ fn eq(xs: &List, ys: &List) -> bool {
     match (xs, ys) {
         // If we have reached the end of both lists, they are equal.
         (&Nil, &Nil) => true,
-        // If the current elements of both lists are equal, keep going.
+        // If the current element in both lists is equal, keep going.
         (&Cons(x, ~ref next_xs), &Cons(y, ~ref next_ys))
                 if x == y => eq(next_xs, next_ys),
         // If the current elements are not equal, the lists are not equal.
@@ -1304,7 +1304,7 @@ fn eq<T: Eq>(xs: &List<T>, ys: &List<T>) -> bool {
     match (xs, ys) {
         // If we have reached the end of both lists, they are equal.
         (&Nil, &Nil) => true,
-        // If the current elements of both lists are equal, keep going.
+        // If the current element in both lists is equal, keep going.
         (&Cons(ref x, ~ref next_xs), &Cons(ref y, ~ref next_ys))
                 if x == y => eq(next_xs, next_ys),
         // If the current elements are not equal, the lists are not equal.
@@ -1333,7 +1333,7 @@ impl<T: Eq> Eq for List<T> {
         match (self, ys) {
             // If we have reached the end of both lists, they are equal.
             (&Nil, &Nil) => true,
-            // If the current elements of both lists are equal, keep going.
+            // If the current element in both lists is equal, keep going.
             (&Cons(ref x, ~ref next_xs), &Cons(ref y, ~ref next_ys))
                     if x == y => next_xs == next_ys,
             // If the current elements are not equal, the lists are not equal.
@@ -2965,7 +2965,7 @@ use farm::*;
 ~~~
 
 > *Note:* This feature of the compiler is currently gated behind the
-> `#![feature(globs)]` directive. More about these directives can be found in
+> `#[feature(globs)]` directive. More about these directives can be found in
 > the manual.
 
 However, that's not all. You can also rename an item while you're bringing it into scope:
@@ -2980,7 +2980,7 @@ fn main() {
 }
 ~~~
 
-In general, `use` creates a local alias:
+In general, `use` creates an local alias:
 An alternate path and a possibly different name to access the same item,
 without touching the original, and with both being interchangeable.
 

branches/try/src/etc/zsh/_rust

@@ -68,7 +68,7 @@ _rustc_opts_lint=(
     'unsafe-block[usage of an `unsafe` block]'
     'unstable[detects use of #\[unstable\] items (incl. items with no stability attribute)]'
     'unused-imports[imports that are never used]'
-    'unused-must-use[unused result of a type flagged as #\[must_use\]]'
+    'unused-must-use[unused result of an type flagged as #\[must_use\]]'
     "unused-mut[detect mut variables which don't need to be mutable]"
     'unused-result[unused result of an expression in a statement]'
     'unused-unsafe[unnecessary use of an `unsafe` block]'

branches/try/src/libcollections/hashmap.rs

@@ -278,7 +278,8 @@ mod table {
         /// the appropriate types to pass on to most of the other functions in
         /// this module.
         pub fn peek(&self, index: uint) -> BucketState {
-            debug_assert!(index < self.capacity);
+            // FIXME #12049
+            if cfg!(test) { assert!(index < self.capacity) }
 
             let idx  = index as int;
             let hash = unsafe { *self.hashes.offset(idx) };
@@ -305,7 +306,8 @@ mod table {
             let idx = index.idx;
 
             unsafe {
-                debug_assert!(*self.hashes.offset(idx) != EMPTY_BUCKET);
+                // FIXME #12049
+                if cfg!(test) { assert!(*self.hashes.offset(idx) != EMPTY_BUCKET) }
                 (&'a *self.keys.offset(idx),
                  &'a *self.vals.offset(idx))
             }
@@ -317,7 +319,8 @@ mod table {
             let idx = index.idx;
 
             unsafe {
-                debug_assert!(*self.hashes.offset(idx) != EMPTY_BUCKET);
+                // FIXME #12049
+                if cfg!(test) { assert!(*self.hashes.offset(idx) != EMPTY_BUCKET) }
                 (&'a     *self.keys.offset(idx),
                  &'a mut *self.vals.offset(idx))
             }
@@ -329,7 +332,8 @@ mod table {
             let idx = index.idx;
 
             unsafe {
-                debug_assert!(*self.hashes.offset(idx) != EMPTY_BUCKET);
+                // FIXME #12049
+                if cfg!(test) { assert!(*self.hashes.offset(idx) != EMPTY_BUCKET) }
                 (transmute(self.hashes.offset(idx)),
                  &'a mut *self.keys.offset(idx),
                  &'a mut *self.vals.offset(idx))
@@ -347,7 +351,8 @@ mod table {
             let idx = index.idx;
 
             unsafe {
-                debug_assert_eq!(*self.hashes.offset(idx), EMPTY_BUCKET);
+                // FIXME #12049
+                if cfg!(test) { assert_eq!(*self.hashes.offset(idx), EMPTY_BUCKET) }
                 *self.hashes.offset(idx) = hash.inspect();
                 move_val_init(&mut *self.keys.offset(idx), k);
                 move_val_init(&mut *self.vals.offset(idx), v);
@@ -366,7 +371,8 @@ mod table {
             let idx  = index.idx;
 
             unsafe {
-                debug_assert!(*self.hashes.offset(idx) != EMPTY_BUCKET);
+                // FIXME #12049
+                if cfg!(test) { assert!(*self.hashes.offset(idx) != EMPTY_BUCKET) }
 
                 *self.hashes.offset(idx) = EMPTY_BUCKET;
 
@@ -692,13 +698,13 @@ static INITIAL_LOAD_FACTOR: Fraction = (9, 10);
 /// book_reviews.insert("The Adventures of Sherlock Holmes", "Eye lyked it alot.");
 ///
 /// // check for a specific one.
-/// if !book_reviews.contains_key(&("Les Misérables")) {
+/// if !book_reviews.contains_key(& &"Les Misérables") {
 ///     println!("We've got {} reviews, but Les Misérables ain't one.",
 ///              book_reviews.len());
 /// }
 ///
 /// // oops, this review has a lot of spelling mistakes, let's delete it.
-/// book_reviews.remove(&("The Adventures of Sherlock Holmes"));
+/// book_reviews.remove(& &"The Adventures of Sherlock Holmes");
 ///
 /// // look up the values associated with some keys.
 /// let to_find = ["Pride and Prejudice", "Alice's Adventure in Wonderland"];

branches/try/src/libcollections/treemap.rs

@@ -1651,10 +1651,10 @@ mod test_set {
 
         // FIXME: #5801: this needs a type hint to compile...
         let result: Option<(&uint, & &'static str)> = z.next();
-        assert_eq!(result.unwrap(), (&5u, &("bar")));
+        assert_eq!(result.unwrap(), (&5u, & &"bar"));
 
         let result: Option<(&uint, & &'static str)> = z.next();
-        assert_eq!(result.unwrap(), (&11u, &("foo")));
+        assert_eq!(result.unwrap(), (&11u, & &"foo"));
 
         let result: Option<(&uint, & &'static str)> = z.next();
         assert!(result.is_none());

branches/try/src/libgetopts/lib.rs

@@ -1441,7 +1441,7 @@ mod tests {
             optmulti("l", "", "Desc", "VAL"));
 
         let expected =
-"Usage: fruits
+~"Usage: fruits
 
 Options:
     -b --banana VAL     Desc
@@ -1450,7 +1450,7 @@ Options:
     -k --kiwi           Desc
     -p [VAL]            Desc
     -l VAL              Desc
-".to_owned();
+";
 
         let generated_usage = usage("Usage: fruits", optgroups.as_slice());
 
@@ -1471,13 +1471,13 @@ Options:
                 "This is a long description which _will_ be wrapped..+.."));
 
         let expected =
-"Usage: fruits
+~"Usage: fruits
 
 Options:
     -k --kiwi           This is a long description which won't be wrapped..+..
     -a --apple          This is a long description which _will_ be
                         wrapped..+..
-".to_owned();
+";
 
         let usage = usage("Usage: fruits", optgroups.as_slice());
 
@@ -1496,14 +1496,14 @@ Options:
 confuse the line wrapping; an apple costs 0.51€ in some parts of Europe."));
 
         let expected =
-"Usage: fruits
+~"Usage: fruits
 
 Options:
     -k --k–w–           The word kiwi is normally spelled with two i's
     -a --apple          This “description” has some characters that could
                         confuse the line wrapping; an apple costs 0.51€ in
                         some parts of Europe.
-".to_owned();
+";
 
         let usage = usage("Usage: fruits", optgroups.as_slice());
 

branches/try/src/libnative/io/timer_win32.rs

@@ -137,7 +137,7 @@ impl rtio::RtioTimer for Timer {
 
         // there are 10^6 nanoseconds in a millisecond, and the parameter is in
         // 100ns intervals, so we multiply by 10^4.
-        let due = -(msecs as i64 * 10000) as libc::LARGE_INTEGER;
+        let due = -(msecs * 10000) as libc::LARGE_INTEGER;
         assert_eq!(unsafe {
             imp::SetWaitableTimer(self.obj, &due, 0, ptr::null(),
                                   ptr::mut_null(), 0)
@@ -151,7 +151,7 @@ impl rtio::RtioTimer for Timer {
         let (tx, rx) = channel();
 
         // see above for the calculation
-        let due = -(msecs as i64 * 10000) as libc::LARGE_INTEGER;
+        let due = -(msecs * 10000) as libc::LARGE_INTEGER;
         assert_eq!(unsafe {
             imp::SetWaitableTimer(self.obj, &due, 0, ptr::null(),
                                   ptr::mut_null(), 0)
@@ -167,7 +167,7 @@ impl rtio::RtioTimer for Timer {
         let (tx, rx) = channel();
 
         // see above for the calculation
-        let due = -(msecs as i64 * 10000) as libc::LARGE_INTEGER;
+        let due = -(msecs * 10000) as libc::LARGE_INTEGER;
         assert_eq!(unsafe {
             imp::SetWaitableTimer(self.obj, &due, msecs as libc::LONG,
                                   ptr::null(), ptr::mut_null(), 0)