---

yaml
---
r: 81718
b: refs/heads/master
c: 44997a1
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 76a53911b45aad4bb036bd7af596b6c43dd600a8
+refs/heads/master: 44997a127bb9acc1957d809a0e6cad190b75e491
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729

trunk/README.md

@@ -61,7 +61,7 @@ documentation.
 
 [repo]: https://github.com/mozilla/rust
 [tarball]: http://static.rust-lang.org/dist/rust-0.7.tar.gz
-[tutorial]: http://static.rust-lang.org/doc/tutorial.html
+[tutorial]: http://static.rust-lang.org/doc/0.7/tutorial.html
 
 ## Notes
 

trunk/doc/tutorial-container.md

@@ -4,14 +4,14 @@
 
 The container traits are defined in the `std::container` module.
 
-## Unique and managed vectors
+## Unique vectors
 
-Vectors have `O(1)` indexing and removal from the end, along with `O(1)`
-amortized insertion. Vectors are the most common container in Rust, and are
-flexible enough to fit many use cases.
+Vectors have `O(1)` indexing, push (to the end) and pop (from the end). Vectors
+are the most common container in Rust, and are flexible enough to fit many use
+cases.
 
 Vectors can also be sorted and used as efficient lookup tables with the
-`std::vec::bsearch` function, if all the elements are inserted at one time and
+`bsearch()` method, if all the elements are inserted at one time and
 deletions are unnecessary.
 
 ## Maps and sets
@@ -42,10 +42,15 @@ implementing the `IterBytes` trait.
 
 ## Double-ended queues
 
-The `extra::deque` module implements a double-ended queue with `O(1)` amortized
-inserts and removals from both ends of the container. It also has `O(1)`
-indexing like a vector. The contained elements are not required to be copyable,
-and the queue will be sendable if the contained type is sendable.
+The `extra::ringbuf` module implements a double-ended queue with `O(1)`
+amortized inserts and removals from both ends of the container. It also has
+`O(1)` indexing like a vector. The contained elements are not required to be
+copyable, and the queue will be sendable if the contained type is sendable.
+Its interface `Deque` is defined in `extra::collections`.
+
+The `extra::dlist` module implements a double-ended linked list, also
+implementing the `Deque` trait, with `O(1)` removals and inserts at either end,
+and `O(1)` concatenation.
 
 ## Priority queues
 
@@ -197,11 +202,11 @@ The function `range` (or `range_inclusive`) allows to simply iterate through a g
 
 ~~~
 for i in range(0, 5) {
-  printf!("%d ", i) // prints "0 1 2 3 4"
+  print!("{} ", i) // prints "0 1 2 3 4"
 }
 
 for i in std::iter::range_inclusive(0, 5) { // needs explicit import
-  printf!("%d ", i) // prints "0 1 2 3 4 5"
+  print!("{} ", i) // prints "0 1 2 3 4 5"
 }
 ~~~
 
@@ -233,15 +238,15 @@ let mut it = xs.iter().zip(ys.iter());
 
 // print out the pairs of elements up to (&3, &"baz")
 for (x, y) in it {
-    printfln!("%d %s", *x, *y);
+    println!("{} {}", *x, *y);
 
     if *x == 3 {
         break;
     }
 }
 
 // yield and print the last pair from the iterator
-printfln!("last: %?", it.next());
+println!("last: {:?}", it.next());
 
 // the iterator is now fully consumed
 assert!(it.next().is_none());
@@ -335,13 +340,13 @@ another `DoubleEndedIterator` with `next` and `next_back` exchanged.
 ~~~
 let xs = [1, 2, 3, 4, 5, 6];
 let mut it = xs.iter();
-printfln!("%?", it.next()); // prints `Some(&1)`
-printfln!("%?", it.next()); // prints `Some(&2)`
-printfln!("%?", it.next_back()); // prints `Some(&6)`
+println!("{:?}", it.next()); // prints `Some(&1)`
+println!("{:?}", it.next()); // prints `Some(&2)`
+println!("{:?}", it.next_back()); // prints `Some(&6)`
 
 // prints `5`, `4` and `3`
 for &x in it.invert() {
-    printfln!("%?", x)
+    println!("{}", x)
 }
 ~~~
 
@@ -356,11 +361,11 @@ let xs = [1, 2, 3, 4];
 let ys = [5, 6, 7, 8];
 let mut it = xs.iter().chain(ys.iter()).map(|&x| x * 2);
 
-printfln!("%?", it.next()); // prints `Some(2)`
+println!("{:?}", it.next()); // prints `Some(2)`
 
 // prints `16`, `14`, `12`, `10`, `8`, `6`, `4`
 for x in it.invert() {
-    printfln!("%?", x);
+    println!("{}", x);
 }
 ~~~
 
@@ -387,17 +392,17 @@ underlying iterators are.
 let xs = [1, 2, 3, 4, 5];
 let ys = ~[7, 9, 11];
 let mut it = xs.iter().chain(ys.iter());
-printfln!("%?", it.idx(0)); // prints `Some(&1)`
-printfln!("%?", it.idx(5)); // prints `Some(&7)`
-printfln!("%?", it.idx(7)); // prints `Some(&11)`
-printfln!("%?", it.idx(8)); // prints `None`
+println!("{:?}", it.idx(0)); // prints `Some(&1)`
+println!("{:?}", it.idx(5)); // prints `Some(&7)`
+println!("{:?}", it.idx(7)); // prints `Some(&11)`
+println!("{:?}", it.idx(8)); // prints `None`
 
 // yield two elements from the beginning, and one from the end
 it.next();
 it.next();
 it.next_back();
 
-printfln!("%?", it.idx(0)); // prints `Some(&3)`
-printfln!("%?", it.idx(4)); // prints `Some(&9)`
-printfln!("%?", it.idx(6)); // prints `None`
+println!("{:?}", it.idx(0)); // prints `Some(&3)`
+println!("{:?}", it.idx(4)); // prints `Some(&9)`
+println!("{:?}", it.idx(6)); // prints `None`
 ~~~

trunk/doc/tutorial.md

@@ -2979,15 +2979,15 @@ tutorials on individual topics.
 * [The foreign function interface][ffi]
 * [Containers and iterators](tutorial-container.html)
 * [Error-handling and Conditions](tutorial-conditions.html)
-* [Packaging up Rust code](rustpkg)
+* [Packaging up Rust code][rustpkg]
 
 There is further documentation on the [wiki], however those tend to be even more out of date as this document.
 
 [borrow]: tutorial-borrowed-ptr.html
 [tasks]: tutorial-tasks.html
 [macros]: tutorial-macros.html
 [ffi]: tutorial-ffi.html
-[rustpkg]: tutorial-rustpkg.html
+[rustpkg]: rustpkg.html
 
 [wiki]: https://github.com/mozilla/rust/wiki/Docs
 

trunk/src/libextra/glob.rs

@@ -23,7 +23,7 @@
  * `glob`/`fnmatch` functions.
  */
 
-use std::{os, path, util};
+use std::{os, path};
 
 use sort;
 
@@ -356,7 +356,7 @@ impl Pattern {
                             chars_eq(c, c2, options.case_sensitive)
                         }
                         AnySequence => {
-                            util::unreachable()
+                            unreachable!()
                         }
                     };
                     if !matches {

trunk/src/libextra/terminfo/parm.rs

@@ -261,7 +261,7 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables)
                                 flags.width = (cur as uint - '0' as uint);
                                 fstate = FormatStateWidth;
                             }
-                            _ => util::unreachable()
+                            _ => unreachable!()
                         }
                         state = FormatPattern(flags, fstate);
                     }
@@ -487,7 +487,7 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
                         FormatDigit => 10,
                         FormatOctal => 8,
                         FormatHex|FormatHEX => 16,
-                        FormatString => util::unreachable()
+                        FormatString => unreachable!()
                     };
                     let mut s = ~[];
                     match op {
@@ -535,7 +535,7 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<~[u8],~str> {
                                 s.push_all_move(s_);
                             }
                         }
-                        FormatString => util::unreachable()
+                        FormatString => unreachable!()
                     }
                     s
                 }

trunk/src/libextra/url.rs

@@ -1061,12 +1061,16 @@ mod tests {
 
     #[test]
     fn test_decode_form_urlencoded() {
+        // FIXME #4449: Commented out because this causes an ICE, but only
+        // on FreeBSD
+        /*
         assert_eq!(decode_form_urlencoded([]).len(), 0);
 
         let s = "a=1&foo+bar=abc&foo+bar=12+%3D+34".as_bytes();
         let form = decode_form_urlencoded(s);
         assert_eq!(form.len(), 2);
-        assert_eq!(form.get(&~"a"), &~[~"1"]);
-        assert_eq!(form.get(&~"foo bar"), &~[~"abc", ~"12 = 34"]);
+        assert_eq!(form.get_ref(&~"a"), &~[~"1"]);
+        assert_eq!(form.get_ref(&~"foo bar"), &~[~"abc", ~"12 = 34"]);
+        */
     }
 }

trunk/src/librustc/back/rpath.rs

@@ -14,7 +14,7 @@ use metadata::cstore;
 use metadata::filesearch;
 
 use std::hashmap::HashSet;
-use std::{os, util, vec};
+use std::{os, vec};
 
 fn not_win32(os: session::Os) -> bool {
   os != session::OsWin32
@@ -116,7 +116,7 @@ pub fn get_rpath_relative_to_output(os: session::Os,
         session::OsAndroid | session::OsLinux | session::OsFreebsd
                           => "$ORIGIN",
         session::OsMacos => "@executable_path",
-        session::OsWin32 => util::unreachable()
+        session::OsWin32 => unreachable!()
     };
 
     Path(prefix).push_rel(&os::make_absolute(output).get_relative_to(&os::make_absolute(lib)))

trunk/src/librustc/middle/check_match.rs

@@ -126,7 +126,7 @@ pub fn check_arms(cx: &MatchCheckCtxt, arms: &[Arm]) {
                     Some(&DefStatic(did, false)) => {
                         let const_expr = lookup_const_by_id(cx.tcx, did).unwrap();
                         match eval_const_expr(cx.tcx, const_expr) {
-                            const_float(f) if f.is_NaN() => true,
+                            const_float(f) if f.is_nan() => true,
                             _ => false
                         }
                     }
@@ -136,7 +136,7 @@ pub fn check_arms(cx: &MatchCheckCtxt, arms: &[Arm]) {
             do walk_pat(*pat) |p| {
                 if pat_matches_nan(p) {
                     cx.tcx.sess.span_warn(p.span, "unmatchable NaN in pattern, \
-                                                   use the is_NaN method in a guard instead");
+                                                   use the is_nan method in a guard instead");
                 }
                 true
             };

trunk/src/librustc/middle/entry.rs

@@ -18,7 +18,6 @@ use syntax::codemap::Span;
 use syntax::parse::token::special_idents;
 use syntax::visit;
 use syntax::visit::Visitor;
-use std::util;
 
 struct EntryContext {
     session: Session,
@@ -94,7 +93,7 @@ fn find_item(item: @item, ctxt: &mut EntryContext) {
                             ctxt.non_main_fns.push((item.id, item.span));
                         }
                     }
-                    _ => util::unreachable()
+                    _ => unreachable!()
                 }
             }
 

trunk/src/librustc/middle/trans/_match.rs

@@ -356,7 +356,7 @@ fn variant_opt(bcx: @mut Block, pat_id: ast::NodeId)
                                adt::represent_node(bcx, pat_id))
                 }
             }
-            ::std::util::unreachable();
+            unreachable!();
         }
         ast::DefFn(*) |
         ast::DefStruct(_) => {

trunk/src/librustdoc/prune_private_pass.rs

@@ -20,8 +20,6 @@ use fold::Fold;
 use fold;
 use pass::Pass;
 
-use std::util;
-
 pub fn mk_pass() -> Pass {
     Pass {
         name: ~"prune_private",
@@ -148,7 +146,7 @@ fn is_visible(srv: astsrv::Srv, doc: doc::ItemDoc) -> bool {
                     }
                 }
             }
-            _ => util::unreachable()
+            _ => unreachable!()
         }
     }
 }

trunk/src/librustpkg/api.rs

@@ -16,6 +16,7 @@ use target::*;
 use version::Version;
 use workcache_support::*;
 
+use std::os;
 use extra::arc::{Arc,RWArc};
 use extra::workcache;
 use extra::workcache::{Database, Logger, FreshnessMap};
@@ -40,11 +41,13 @@ pub fn new_default_context(c: workcache::Context, p: Path) -> BuildContext {
 }
 
 fn file_is_fresh(path: &str, in_hash: &str) -> bool {
-    in_hash == digest_file_with_date(&Path(path))
+    let path = Path(path);
+    os::path_exists(&path) && in_hash == digest_file_with_date(&path)
 }
 
 fn binary_is_fresh(path: &str, in_hash: &str) -> bool {
-    in_hash == digest_only_date(&Path(path))
+    let path = Path(path);
+    os::path_exists(&path) && in_hash == digest_only_date(&path)
 }
 
 pub fn new_workcache_context(p: &Path) -> workcache::Context {

trunk/src/librustpkg/exit_codes.rs

@@ -8,4 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub static copy_failed_code: int = 65;
+pub static COPY_FAILED_CODE: int = 65;

trunk/src/librustpkg/path_util.rs

@@ -118,7 +118,6 @@ fn target_bin_dir(workspace: &Path) -> Path {
 /// directory is, and if the file exists, return it.
 pub fn built_executable_in_workspace(pkgid: &PkgId, workspace: &Path) -> Option<Path> {
     let mut result = target_build_dir(workspace);
-    // should use a target-specific subdirectory
     result = mk_output_path(Main, Build, pkgid, result);
     debug!("built_executable_in_workspace: checking whether %s exists",
            result.to_str());

trunk/src/librustpkg/rustpkg.rs

@@ -47,7 +47,7 @@ use package_source::PkgSrc;
 use target::{WhatToBuild, Everything, is_lib, is_main, is_test, is_bench};
 // use workcache_support::{discover_outputs, digest_only_date};
 use workcache_support::digest_only_date;
-use exit_codes::copy_failed_code;
+use exit_codes::COPY_FAILED_CODE;
 
 pub mod api;
 mod conditions;
@@ -789,10 +789,10 @@ pub fn main_args(args: &[~str]) {
         }.run(sub_cmd, rm_args.clone())
     };
     // FIXME #9262: This is using the same error code for all errors,
-    // and at least one test case succeeds if rustpkg returns copy_failed_code,
+    // and at least one test case succeeds if rustpkg returns COPY_FAILED_CODE,
     // when actually, it might set the exit code for that even if a different
     // unhandled condition got raised.
-    if result.is_err() { os::set_exit_status(copy_failed_code); }
+    if result.is_err() { os::set_exit_status(COPY_FAILED_CODE); }
 
 }