---

yaml
---
r: 83279
b: refs/heads/try
c: 76a5391
h: refs/heads/master
i:
  83277: 8eb0eef
  83275: c51147a
  83271: 6b6e90e
  83263: e98a444
v: v3

Author: huonw

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0e4d1fc8cae42e15e00f71d9f439b01bb25a86ae
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
-refs/heads/try: 176051c6f85d5cd3843d7aa4446998ac620627b4
+refs/heads/try: 76a53911b45aad4bb036bd7af596b6c43dd600a8
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/tutorial-container.md

@@ -4,14 +4,14 @@
 
 The container traits are defined in the `std::container` module.
 
-## Unique vectors
+## Unique and managed vectors
 
-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 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 can also be sorted and used as efficient lookup tables with the
-`bsearch()` method, if all the elements are inserted at one time and
+`std::vec::bsearch` function, if all the elements are inserted at one time and
 deletions are unnecessary.
 
 ## Maps and sets
@@ -42,15 +42,10 @@ implementing the `IterBytes` trait.
 
 ## Double-ended queues
 
-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.
+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.
 
 ## Priority queues
 
@@ -202,11 +197,11 @@ The function `range` (or `range_inclusive`) allows to simply iterate through a g
 
 ~~~
 for i in range(0, 5) {
-  print!("{} ", i) // prints "0 1 2 3 4"
+  printf!("%d ", i) // prints "0 1 2 3 4"
 }
 
 for i in std::iter::range_inclusive(0, 5) { // needs explicit import
-  print!("{} ", i) // prints "0 1 2 3 4 5"
+  printf!("%d ", i) // prints "0 1 2 3 4 5"
 }
 ~~~
 
@@ -238,15 +233,15 @@ let mut it = xs.iter().zip(ys.iter());
 
 // print out the pairs of elements up to (&3, &"baz")
 for (x, y) in it {
-    println!("{} {}", *x, *y);
+    printfln!("%d %s", *x, *y);
 
     if *x == 3 {
         break;
     }
 }
 
 // yield and print the last pair from the iterator
-println!("last: {:?}", it.next());
+printfln!("last: %?", it.next());
 
 // the iterator is now fully consumed
 assert!(it.next().is_none());
@@ -340,13 +335,13 @@ another `DoubleEndedIterator` with `next` and `next_back` exchanged.
 ~~~
 let xs = [1, 2, 3, 4, 5, 6];
 let mut it = xs.iter();
-println!("{:?}", it.next()); // prints `Some(&1)`
-println!("{:?}", it.next()); // prints `Some(&2)`
-println!("{:?}", it.next_back()); // prints `Some(&6)`
+printfln!("%?", it.next()); // prints `Some(&1)`
+printfln!("%?", it.next()); // prints `Some(&2)`
+printfln!("%?", it.next_back()); // prints `Some(&6)`
 
 // prints `5`, `4` and `3`
 for &x in it.invert() {
-    println!("{}", x)
+    printfln!("%?", x)
 }
 ~~~
 
@@ -361,11 +356,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);
 
-println!("{:?}", it.next()); // prints `Some(2)`
+printfln!("%?", it.next()); // prints `Some(2)`
 
 // prints `16`, `14`, `12`, `10`, `8`, `6`, `4`
 for x in it.invert() {
-    println!("{}", x);
+    printfln!("%?", x);
 }
 ~~~
 
@@ -392,17 +387,17 @@ underlying iterators are.
 let xs = [1, 2, 3, 4, 5];
 let ys = ~[7, 9, 11];
 let mut it = xs.iter().chain(ys.iter());
-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`
+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`
 
 // yield two elements from the beginning, and one from the end
 it.next();
 it.next();
 it.next_back();
 
-println!("{:?}", it.idx(0)); // prints `Some(&3)`
-println!("{:?}", it.idx(4)); // prints `Some(&9)`
-println!("{:?}", it.idx(6)); // prints `None`
+printfln!("%?", it.idx(0)); // prints `Some(&3)`
+printfln!("%?", it.idx(4)); // prints `Some(&9)`
+printfln!("%?", it.idx(6)); // prints `None`
 ~~~

branches/try/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]: rustpkg.html
+[rustpkg]: tutorial-rustpkg.html
 
 [wiki]: https://github.com/mozilla/rust/wiki/Docs
 

branches/try/src/libextra/glob.rs

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

branches/try/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;
                             }
-                            _ => unreachable!()
+                            _ => util::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 => unreachable!()
+                        FormatString => util::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 => unreachable!()
+                        FormatString => util::unreachable()
                     }
                     s
                 }

branches/try/src/libextra/url.rs

@@ -1061,16 +1061,12 @@ 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_ref(&~"a"), &~[~"1"]);
-        assert_eq!(form.get_ref(&~"foo bar"), &~[~"abc", ~"12 = 34"]);
-        */
+        assert_eq!(form.get(&~"a"), &~[~"1"]);
+        assert_eq!(form.get(&~"foo bar"), &~[~"abc", ~"12 = 34"]);
     }
 }

branches/try/src/librustc/back/rpath.rs

@@ -14,7 +14,7 @@ use metadata::cstore;
 use metadata::filesearch;
 
 use std::hashmap::HashSet;
-use std::{os, vec};
+use std::{os, util, 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 => unreachable!()
+        session::OsWin32 => util::unreachable()
     };
 
     Path(prefix).push_rel(&os::make_absolute(output).get_relative_to(&os::make_absolute(lib)))

branches/try/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
             };

branches/try/src/librustc/middle/entry.rs

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

branches/try/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))
                 }
             }
-            unreachable!();
+            ::std::util::unreachable();
         }
         ast::DefFn(*) |
         ast::DefStruct(_) => {

branches/try/src/librustdoc/prune_private_pass.rs

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

branches/try/src/librustpkg/api.rs

@@ -16,7 +16,6 @@ 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};
@@ -41,13 +40,11 @@ pub fn new_default_context(c: workcache::Context, p: Path) -> BuildContext {
 }
 
 fn file_is_fresh(path: &str, in_hash: &str) -> bool {
-    let path = Path(path);
-    os::path_exists(&path) && in_hash == digest_file_with_date(&path)
+    in_hash == digest_file_with_date(&Path(path))
 }
 
 fn binary_is_fresh(path: &str, in_hash: &str) -> bool {
-    let path = Path(path);
-    os::path_exists(&path) && in_hash == digest_only_date(&path)
+    in_hash == digest_only_date(&Path(path))
 }
 
 pub fn new_workcache_context(p: &Path) -> workcache::Context {

branches/try/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;

branches/try/src/librustpkg/path_util.rs

@@ -118,6 +118,7 @@ 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());

branches/try/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); }
 
 }