---

yaml
---
r: 144013
b: refs/heads/try2
c: 3ad2355
h: refs/heads/master
i:
  144011: d869725
v: v3

Author: huonw

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 680eb71564ebba5e76ce1e1a8287b30042332cc5
+refs/heads/try2: 3ad23552fbd463d97a3e26c900655b9d134516e4
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/tutorial-container.md

@@ -112,10 +112,10 @@ iterator object. For example, vector slices several iterators available:
 
 * `iter()` and `rev_iter()`, for immutable references to the elements
 * `mut_iter()` and `mut_rev_iter()`, for mutable references to the elements
-* `move_iter()` and `move_rev_iter`, to move the elements out by-value
+* `consume_iter()` and `consume_rev_iter`, to move the elements out by-value
 
 A typical mutable container will implement at least `iter()`, `mut_iter()` and
-`move_iter()` along with the reverse variants if it maintains an order.
+`consume_iter()` along with the reverse variants if it maintains an order.
 
 ### Freezing
 
@@ -139,9 +139,9 @@ and `&mut`.
 
 ## Iterator adaptors
 
-The `Iterator` trait provides many common algorithms as default methods. For
-example, the `fold` method will accumulate the items yielded by an `Iterator`
-into a single value:
+The `IteratorUtil` trait implements common algorithms as methods extending
+every `Iterator` implementation. For example, the `fold` method will accumulate
+the items yielded by an `Iterator` into a single value:
 
 ~~~
 let xs = [1, 9, 2, 3, 14, 12];
@@ -154,10 +154,14 @@ Some adaptors return an adaptor object implementing the `Iterator` trait itself:
 ~~~
 let xs = [1, 9, 2, 3, 14, 12];
 let ys = [5, 2, 1, 8];
-let sum = xs.iter().chain(ys.iter()).fold(0, |a, b| a + *b);
+let sum = xs.iter().chain_(ys.iter()).fold(0, |a, b| a + *b);
 assert_eq!(sum, 57);
 ~~~
 
+Note that some adaptors like the `chain_` method above use a trailing
+underscore to work around an issue with method resolve. The underscores will be
+dropped when they become unnecessary.
+
 ## For loops
 
 The `for` keyword can be used as sugar for iterating through any iterator:
@@ -208,7 +212,7 @@ Iterators offer generic conversion to containers with the `collect` adaptor:
 
 ~~~
 let xs = [0, 1, 1, 2, 3, 5, 8];
-let ys = xs.rev_iter().skip(1).map(|&x| x * 2).collect::<~[int]>();
+let ys = xs.rev_iter().skip(1).transform(|&x| x * 2).collect::<~[int]>();
 assert_eq!(ys, ~[10, 6, 4, 2, 2, 0]);
 ~~~
 
@@ -303,13 +307,13 @@ for &x in it.invert() {
 The `rev_iter` and `mut_rev_iter` methods on vectors just return an inverted
 version of the standard immutable and mutable vector iterators.
 
-The `chain`, `map`, `filter`, `filter_map` and `inspect` adaptors are
+The `chain_`, `transform`, `filter`, `filter_map` and `peek` adaptors are
 `DoubleEndedIterator` implementations if the underlying iterators are.
 
 ~~~
 let xs = [1, 2, 3, 4];
 let ys = [5, 6, 7, 8];
-let mut it = xs.iter().chain(ys.iter()).map(|&x| x * 2);
+let mut it = xs.iter().chain_(ys.iter()).transform(|&x| x * 2);
 
 printfln!("%?", it.next()); // prints `Some(2)`
 
@@ -325,13 +329,13 @@ The `RandomAccessIterator` trait represents an iterator offering random access
 to the whole range. The `indexable` method retrieves the number of elements
 accessible with the `idx` method.
 
-The `chain` adaptor is an implementation of `RandomAccessIterator` if the
+The `chain_` adaptor is an implementation of `RandomAccessIterator` if the
 underlying iterators are.
 
 ~~~
 let xs = [1, 2, 3, 4, 5];
 let ys = ~[7, 9, 11];
-let mut it = xs.iter().chain(ys.iter());
+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)`

branches/try2/src/compiletest/procsrv.rs

@@ -49,7 +49,7 @@ pub fn run(lib_path: &str,
 
     let env = env + target_env(lib_path, prog);
     let mut proc = run::Process::new(prog, args, run::ProcessOptions {
-        env: Some(env),
+        env: Some(env.slice(0, env.len())),
         dir: None,
         in_fd: None,
         out_fd: None,

branches/try2/src/libextra/rl.rs

@@ -32,7 +32,7 @@ pub mod rustrt {
 
 /// Add a line to history
 pub unsafe fn add_history(line: &str) -> bool {
-    do line.with_c_str |buf| {
+    do line.to_c_str().with_ref |buf| {
         rustrt::linenoiseHistoryAdd(buf) == 1 as c_int
     }
 }
@@ -44,21 +44,21 @@ pub unsafe fn set_history_max_len(len: int) -> bool {
 
 /// Save line history to a file
 pub unsafe fn save_history(file: &str) -> bool {
-    do file.with_c_str |buf| {
+    do file.to_c_str().with_ref |buf| {
         rustrt::linenoiseHistorySave(buf) == 1 as c_int
     }
 }
 
 /// Load line history from a file
 pub unsafe fn load_history(file: &str) -> bool {
-    do file.with_c_str |buf| {
+    do file.to_c_str().with_ref |buf| {
         rustrt::linenoiseHistoryLoad(buf) == 1 as c_int
     }
 }
 
 /// Print out a prompt and then wait for input and return it
 pub unsafe fn read(prompt: &str) -> Option<~str> {
-    do prompt.with_c_str |buf| {
+    do prompt.to_c_str().with_ref |buf| {
         let line = rustrt::linenoise(buf);
 
         if line.is_null() { None }
@@ -80,7 +80,7 @@ pub unsafe fn complete(cb: CompletionCb) {
 
             unsafe {
                 do cb(str::raw::from_c_str(line)) |suggestion| {
-                    do suggestion.with_c_str |buf| {
+                    do suggestion.to_c_str().with_ref |buf| {
                         rustrt::linenoiseAddCompletion(completions, buf);
                     }
                 }

branches/try2/src/libextra/sort.rs

@@ -782,8 +782,11 @@ mod test_qsort3 {
 
 #[cfg(test)]
 mod test_qsort {
+
     use sort::*;
 
+    use std::vec;
+
     fn check_sort(v1: &mut [int], v2: &mut [int]) {
         let len = v1.len();
         fn leual(a: &int, b: &int) -> bool { *a <= *b }
@@ -832,7 +835,9 @@ mod test_qsort {
 
         let immut_names = names;
 
-        for (&a, &b) in expected.iter().zip(immut_names.iter()) {
+        let pairs = vec::zip_slice(expected, immut_names);
+        for p in pairs.iter() {
+            let (a, b) = *p;
             debug!("%d %d", a, b);
             assert_eq!(a, b);
         }

branches/try2/src/libextra/test.rs

@@ -1121,6 +1121,7 @@ mod tests {
 
     use std::either;
     use std::comm::{stream, SharedChan};
+    use std::vec;
     use tempfile;
     use std::os;
 
@@ -1308,8 +1309,14 @@ mod tests {
               ~"test::parse_ignored_flag",
               ~"test::sort_tests"];
 
-        for (a, b) in expected.iter().zip(filtered.iter()) {
-            assert!(*a == b.desc.name.to_str());
+        let pairs = vec::zip(expected, filtered);
+
+        for p in pairs.iter() {
+            match *p {
+                (ref a, ref b) => {
+                    assert!(*a == b.desc.name.to_str());
+                }
+            }
         }
     }
 

branches/try2/src/librustc/back/link.rs

@@ -78,10 +78,10 @@ pub fn WriteOutputFile(sess: Session,
         OptLevel: c_int,
         EnableSegmentedStacks: bool) {
     unsafe {
-        do Triple.with_c_str |Triple| {
-            do Cpu.with_c_str |Cpu| {
-                do Feature.with_c_str |Feature| {
-                    do Output.with_c_str |Output| {
+        do Triple.to_c_str().with_ref |Triple| {
+            do Cpu.to_c_str().with_ref |Cpu| {
+                do Feature.to_c_str().with_ref |Feature| {
+                    do Output.to_c_str().with_ref |Output| {
                         let result = llvm::LLVMRustWriteOutputFile(
                                 PM,
                                 M,
@@ -152,7 +152,7 @@ pub mod jit {
 
                 debug!("linking: %s", path);
 
-                do path.with_c_str |buf_t| {
+                do path.to_c_str().with_ref |buf_t| {
                     if !llvm::LLVMRustLoadCrate(manager, buf_t) {
                         llvm_err(sess, ~"Could not link");
                     }
@@ -171,7 +171,7 @@ pub mod jit {
             // Next, we need to get a handle on the _rust_main function by
             // looking up it's corresponding ValueRef and then requesting that
             // the execution engine compiles the function.
-            let fun = do "_rust_main".with_c_str |entry| {
+            let fun = do "_rust_main".to_c_str().with_ref |entry| {
                 llvm::LLVMGetNamedFunction(m, entry)
             };
             if fun.is_null() {
@@ -270,14 +270,14 @@ pub mod write {
                   output_type_bitcode => {
                     if opts.optimize != session::No {
                         let filename = output.with_filetype("no-opt.bc");
-                        do filename.with_c_str |buf| {
+                        do filename.to_c_str().with_ref |buf| {
                             llvm::LLVMWriteBitcodeToFile(llmod, buf);
                         }
                     }
                   }
                   _ => {
                     let filename = output.with_filetype("bc");
-                    do filename.with_c_str |buf| {
+                    do filename.to_c_str().with_ref |buf| {
                         llvm::LLVMWriteBitcodeToFile(llmod, buf);
                     }
                   }
@@ -340,7 +340,7 @@ pub mod write {
                     // Always output the bitcode file with --save-temps
 
                     let filename = output.with_filetype("opt.bc");
-                    do filename.with_c_str |buf| {
+                    do filename.to_c_str().with_ref |buf| {
                         llvm::LLVMWriteBitcodeToFile(llmod, buf)
                     };
                     // Save the assembly file if -S is used
@@ -401,13 +401,13 @@ pub mod write {
 
             if output_type == output_type_llvm_assembly {
                 // Given options "-S --emit-llvm": output LLVM assembly
-                do output.with_c_str |buf_o| {
+                do output.to_c_str().with_ref |buf_o| {
                     llvm::LLVMRustAddPrintModulePass(pm.llpm, llmod, buf_o);
                 }
             } else {
                 // If only a bitcode file is asked for by using the
                 // '--emit-llvm' flag, then output it here
-                do output.with_c_str |buf| {
+                do output.to_c_str().with_ref |buf| {
                     llvm::LLVMWriteBitcodeToFile(llmod, buf);
                 }
             }

branches/try2/src/librustc/back/passes.rs

@@ -173,7 +173,7 @@ pub fn populate_pass_manager(sess: Session, pm: &mut PassManager, pass_list:&[~s
 }
 
 pub fn create_pass(name:&str) -> Option<PassRef> {
-    do name.with_c_str |s| {
+    do name.to_c_str().with_ref |s| {
         unsafe {
             let p = llvm::LLVMCreatePass(s);
             if p.is_null() {

branches/try2/src/librustc/driver/driver.rs

@@ -65,14 +65,14 @@ pub fn source_name(input: &input) -> @str {
     }
 }
 
-pub fn default_configuration(sess: Session) ->
+pub fn default_configuration(sess: Session, argv0: @str, input: &input) ->
    ast::CrateConfig {
-    let tos = match sess.targ_cfg.os {
-        session::os_win32 =>   @"win32",
-        session::os_macos =>   @"macos",
-        session::os_linux =>   @"linux",
-        session::os_android => @"android",
-        session::os_freebsd => @"freebsd"
+    let (libc, tos) = match sess.targ_cfg.os {
+        session::os_win32 =>   (@"msvcrt.dll", @"win32"),
+        session::os_macos =>   (@"libc.dylib", @"macos"),
+        session::os_linux =>   (@"libc.so.6",  @"linux"),
+        session::os_android => (@"libc.so",    @"android"),
+        session::os_freebsd => (@"libc.so.7",  @"freebsd")
     };
 
     // ARM is bi-endian, however using NDK seems to default
@@ -92,7 +92,10 @@ pub fn default_configuration(sess: Session) ->
          mk(@"target_arch", arch),
          mk(@"target_endian", end),
          mk(@"target_word_size", wordsz),
-    ];
+         mk(@"target_libc", libc),
+         // Build bindings.
+         mk(@"build_compiler", argv0),
+         mk(@"build_input", source_name(input))];
 }
 
 pub fn append_configuration(cfg: &mut ast::CrateConfig, name: @str) {
@@ -101,11 +104,11 @@ pub fn append_configuration(cfg: &mut ast::CrateConfig, name: @str) {
     }
 }
 
-pub fn build_configuration(sess: Session) ->
+pub fn build_configuration(sess: Session, argv0: @str, input: &input) ->
    ast::CrateConfig {
     // Combine the configuration requested by the session (command line) with
     // some default and generated configuration items
-    let default_cfg = default_configuration(sess);
+    let default_cfg = default_configuration(sess, argv0, input);
     let mut user_cfg = sess.opts.cfg.clone();
     // If the user wants a test runner, then add the test cfg
     if sess.opts.test { append_configuration(&mut user_cfg, @"test") }
@@ -977,7 +980,7 @@ pub fn list_metadata(sess: Session, path: &Path, out: @io::Writer) {
 mod test {
 
     use driver::driver::{build_configuration, build_session};
-    use driver::driver::{build_session_options, optgroups};
+    use driver::driver::{build_session_options, optgroups, str_input};
 
     use extra::getopts::groups::getopts;
     use extra::getopts;
@@ -995,7 +998,7 @@ mod test {
         let sessopts = build_session_options(
             @"rustc", matches, diagnostic::emit);
         let sess = build_session(sessopts, diagnostic::emit);
-        let cfg = build_configuration(sess);
+        let cfg = build_configuration(sess, @"whatever", &str_input(@""));
         assert!((attr::contains_name(cfg, "test")));
     }
 
@@ -1013,7 +1016,7 @@ mod test {
         let sessopts = build_session_options(
             @"rustc", matches, diagnostic::emit);
         let sess = build_session(sessopts, diagnostic::emit);
-        let cfg = build_configuration(sess);
+        let cfg = build_configuration(sess, @"whatever", &str_input(@""));
         let mut test_items = cfg.iter().filter(|m| "test" == m.name());
         assert!(test_items.next().is_some());
         assert!(test_items.next().is_none());

branches/try2/src/librustc/lib/llvm.rs

@@ -2271,7 +2271,7 @@ pub struct TargetData {
 }
 
 pub fn mk_target_data(string_rep: &str) -> TargetData {
-    let lltd = do string_rep.with_c_str |buf| {
+    let lltd = do string_rep.to_c_str().with_ref |buf| {
         unsafe { llvm::LLVMCreateTargetData(buf) }
     };
 

branches/try2/src/librustc/metadata/creader.rs

@@ -57,7 +57,6 @@ pub fn read_crates(diag: @mut span_handler,
     warn_if_multiple_versions(e, diag, *e.crate_cache);
 }
 
-#[deriving(Clone)]
 struct cache_entry {
     cnum: int,
     span: span,
@@ -77,13 +76,22 @@ fn dump_crates(crate_cache: &[cache_entry]) {
 fn warn_if_multiple_versions(e: @mut Env,
                              diag: @mut span_handler,
                              crate_cache: &[cache_entry]) {
+    use std::either::*;
+
     if crate_cache.len() != 0u {
         let name = loader::crate_name_from_metas(
             *crate_cache[crate_cache.len() - 1].metas
         );
 
-        let (matches, non_matches) = crate_cache.partitioned(|entry|
-            name == loader::crate_name_from_metas(*entry.metas));
+        let vec: ~[Either<cache_entry, cache_entry>] = crate_cache.iter().map(|&entry| {
+            let othername = loader::crate_name_from_metas(*entry.metas);
+            if name == othername {
+                Left(entry)
+            } else {
+                Right(entry)
+            }
+        }).collect();
+        let (matches, non_matches) = partition(vec);
 
         assert!(!matches.is_empty());