---

yaml
---
r: 234814
b: refs/heads/tmp
c: 318cd84
h: refs/heads/master
v: v3

Author: gandro

[refs]

@@ -25,7 +25,7 @@ refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/beta: d2e13e822a73e0ea46ae9e21afdd3155fc997f6d
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 2a6f6f26f4d4a1e22ea5e2b4498d3245d80e8aff
+refs/heads/tmp: 318cd843d1103579291a9f6c9eab8aacce7e9f82
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: ab792abf1fcc28afbd315426213f6428da25c085
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828

branches/tmp/mk/cfg/x86_64-unknown-netbsd.mk

@@ -1,4 +1,5 @@
 # x86_64-unknown-netbsd configuration
+CROSS_PREFIX_x86_64-unknown-netbsd=x86_64-unknown-netbsd-
 CC_x86_64-unknown-netbsd=$(CC)
 CXX_x86_64-unknown-netbsd=$(CXX)
 CPP_x86_64-unknown-netbsd=$(CPP)

branches/tmp/mk/platform.mk

@@ -208,14 +208,6 @@ define CFG_MAKE_TOOLCHAIN
 
   ifeq ($$(findstring $(HOST_$(1)),arm aarch64 mips mipsel powerpc),)
 
-  # On OpenBSD, we need to pass the path of libstdc++.so to the linker
-  # (use path of libstdc++.a which is a known name for the same path)
-  ifeq ($(OSTYPE_$(1)),unknown-openbsd)
-    RUSTC_FLAGS_$(1)=-L "$$(dir $$(shell $$(CC_$(1)) $$(CFG_GCCISH_CFLAGS_$(1)) \
-        -print-file-name=lib$(CFG_STDCPP_NAME).a))" \
-        $(RUSTC_FLAGS_$(1))
-  endif
-
   # On Bitrig, we need the relocation model to be PIC for everything
   ifeq (,$(filter $(OSTYPE_$(1)),bitrig))
     LLVM_MC_RELOCATION_MODEL="pic"

branches/tmp/src/compiletest/runtest.rs

@@ -1669,7 +1669,8 @@ fn compile_test_and_save_ir(config: &Config, props: &TestProps,
     // FIXME (#9639): This needs to handle non-utf8 paths
     let mut link_args = vec!("-L".to_owned(),
                              aux_dir.to_str().unwrap().to_owned());
-    let llvm_args = vec!("--emit=llvm-ir".to_owned(),);
+    let llvm_args = vec!("--emit=llvm-ir".to_owned(),
+                         "--crate-type=lib".to_owned());
     link_args.extend(llvm_args);
     let args = make_compile_args(config,
                                  props,

branches/tmp/src/doc/complement-project-faq.md

@@ -22,7 +22,7 @@ Existing languages at this level of abstraction and efficiency are unsatisfactor
 
 # Is any part of this thing production-ready?
 
-Yes!
+No. Feel free to play around, but don't expect completeness or stability yet. Expect incompleteness and breakage.
 
 # Is this a completely Mozilla-planned and orchestrated thing?
 

branches/tmp/src/doc/style/errors/ergonomics.md

@@ -57,7 +57,7 @@ fn write_info(info: &Info) -> Result<(), IoError> {
 ```
 
 See
-[the `result` module documentation](https://doc.rust-lang.org/stable/std/result/index.html#the-try-macro)
+[the `result` module documentation](https://doc.rust-lang.org/stable/std/result/index.html#the-try!-macro)
 for more details.
 
 ### The `Result`-`impl` pattern [FIXME]

branches/tmp/src/doc/style/features/traits/generics.md

@@ -27,7 +27,7 @@ explicitly implement to be used by this generic function.
 * _Inference_. Since the type parameters to generic functions can usually be
   inferred, generic functions can help cut down on verbosity in code where
   explicit conversions or other method calls would usually be necessary. See the
-  [overloading/implicits use case](#use-case-limited-overloading-andor-implicit-conversions)
+  [overloading/implicits use case](#use-case:-limited-overloading-and/or-implicit-conversions)
   below.
 * _Precise types_. Because generics give a _name_ to the specific type
   implementing a trait, it is possible to be precise about places where that
@@ -51,7 +51,7 @@ explicitly implement to be used by this generic function.
   a `Vec<T>` contains elements of a single concrete type (and, indeed, the
   vector representation is specialized to lay these out in line). Sometimes
   heterogeneous collections are useful; see
-  [trait objects](#use-case-trait-objects) below.
+  [trait objects](#use-case:-trait-objects) below.
 * _Signature verbosity_. Heavy use of generics can bloat function signatures.
   **[Ed. note]** This problem may be mitigated by some language improvements; stay tuned.
 

branches/tmp/src/doc/trpl/error-handling.md

@@ -24,28 +24,28 @@ systems may want to jump around.
 * [The Basics](#the-basics)
     * [Unwrapping explained](#unwrapping-explained)
     * [The `Option` type](#the-option-type)
-        * [Composing `Option<T>` values](#composing-optiont-values)
+        * [Composing `Option<T>` values](#composing-option<t>-values)
     * [The `Result` type](#the-result-type)
         * [Parsing integers](#parsing-integers)
         * [The `Result` type alias idiom](#the-result-type-alias-idiom)
-    * [A brief interlude: unwrapping isn't evil](#a-brief-interlude-unwrapping-isn't-evil)
+    * [A brief interlude: unwrapping isn't evil](#a-brief-interlude:-unwrapping-isn't-evil)
 * [Working with multiple error types](#working-with-multiple-error-types)
     * [Composing `Option` and `Result`](#composing-option-and-result)
     * [The limits of combinators](#the-limits-of-combinators)
     * [Early returns](#early-returns)
-    * [The `try!` macro](#the-try-macro)
+    * [The `try!` macro](#the-try!-macro)
     * [Defining your own error type](#defining-your-own-error-type)
 * [Standard library traits used for error handling](#standard-library-traits-used-for-error-handling)
     * [The `Error` trait](#the-error-trait)
     * [The `From` trait](#the-from-trait)
-    * [The real `try!` macro](#the-real-try-macro)
+    * [The real `try!` macro](#the-real-try!-macro)
     * [Composing custom error types](#composing-custom-error-types)
     * [Advice for library writers](#advice-for-library-writers)
-* [Case study: A program to read population data](#case-study-a-program-to-read-population-data)
+* [Case study: A program to read population data](#case-study:-a-program-to-read-population-data)
     * [Initial setup](#initial-setup)
     * [Argument parsing](#argument-parsing)
     * [Writing the logic](#writing-the-logic)
-    * [Error handling with `Box<Error>`](#error-handling-with-boxerror)
+    * [Error handling with `Box<Error>`](#error-handling-with-box%3Cerror%3E)
     * [Reading from stdin](#reading-from-stdin)
     * [Error handling with a custom type](#error-handling-with-a-custom-type)
     * [Adding functionality](#adding-functionality)
@@ -87,7 +87,7 @@ thread '<main>' panicked at 'Invalid number: 11', src/bin/panic-simple.rs:5
 Here's another example that is slightly less contrived. A program that accepts
 an integer as an argument, doubles it and prints it.
 
-<span id="code-unwrap-double"></span>
+<a name="code-unwrap-double"></a>
 
 ```rust,should_panic
 use std::env;
@@ -139,7 +139,7 @@ system is an important concept because it will cause the compiler to force the
 programmer to handle that absence. Let's take a look at an example that tries
 to find a character in a string:
 
-<span id="code-option-ex-string-find"></span>
+<a name="code-option-ex-string-find"></a>
 
 ```rust
 // Searches `haystack` for the Unicode character `needle`. If one is found, the
@@ -154,7 +154,7 @@ fn find(haystack: &str, needle: char) -> Option<usize> {
 }
 ```
 
-Notice that when this function finds a matching character, it doesn't just
+Notice that when this function finds a matching character, it doen't just
 return the `offset`. Instead, it returns `Some(offset)`. `Some` is a variant or
 a *value constructor* for the `Option` type. You can think of it as a function
 with the type `fn<T>(value: T) -> Option<T>`. Correspondingly, `None` is also a
@@ -186,7 +186,7 @@ But wait, what about `unwrap` used in [`unwrap-double`](#code-unwrap-double)?
 There was no case analysis there! Instead, the case analysis was put inside the
 `unwrap` method for you. You could define it yourself if you want:
 
-<span id="code-option-def-unwrap"></span>
+<a name="code-option-def-unwrap"></a>
 
 ```rust
 enum Option<T> {
@@ -253,7 +253,7 @@ option is `None`, in which case, just return `None`.
 Rust has parametric polymorphism, so it is very easy to define a combinator
 that abstracts this pattern:
 
-<span id="code-option-map"></span>
+<a name="code-option-map"></a>
 
 ```rust
 fn map<F, T, A>(option: Option<T>, f: F) -> Option<A> where F: FnOnce(T) -> A {
@@ -394,7 +394,7 @@ remove choices because they will panic if `Option<T>` is `None`.
 The `Result` type is also
 [defined in the standard library][6]:
 
-<span id="code-result-def"></span>
+<a name="code-result-def-1"></a>
 
 ```rust
 enum Result<T, E> {
@@ -562,7 +562,7 @@ combinators that affect only the error type, such as
 ### The `Result` type alias idiom
 
 In the standard library, you may frequently see types like
-`Result<i32>`. But wait, [we defined `Result`](#code-result-def) to
+`Result<i32>`. But wait, [we defined `Result`](#code-result-def-1) to
 have two type parameters. How can we get away with only specifying
 one? The key is to define a `Result` type alias that *fixes* one of
 the type parameters to a particular type. Usually the fixed type is
@@ -672,7 +672,7 @@ with both an `Option` and a `Result`, the solution is *usually* to convert the
 (from `env::args()`) means the user didn't invoke the program correctly. We
 could just use a `String` to describe the error. Let's try:
 
-<span id="code-error-double-string"></span>
+<a name="code-error-double-string"></a>
 
 ```rust
 use std::env;
@@ -840,7 +840,7 @@ example, the very last call to `map` multiplies the `Ok(...)` value (which is
 an `i32`) by `2`. If an error had occurred before that point, this operation
 would have been skipped because of how `map` is defined.
 
-`map_err` is the trick that makes all of this work. `map_err` is just like
+`map_err` is the trick the makes all of this work. `map_err` is just like
 `map`, except it applies a function to the `Err(...)` value of a `Result`. In
 this case, we want to convert all of our errors to one type: `String`. Since
 both `io::Error` and `num::ParseIntError` implement `ToString`, we can call the
@@ -906,7 +906,7 @@ seen above.
 
 Here is a simplified definition of a `try!` macro:
 
-<span id="code-try-def-simple"></span>
+<a nama name="code-try-def-simple"></a>
 
 ```rust
 macro_rules! try {
@@ -1168,7 +1168,7 @@ The `std::convert::From` trait is
 [defined in the standard
 library](../std/convert/trait.From.html):
 
-<span id="code-from-def"></span>
+<a name="code-from-def"></a>
 
 ```rust
 trait From<T> {
@@ -1223,7 +1223,7 @@ let err2: Box<Error> = From::from(parse_err);
 
 There is a really important pattern to recognize here. Both `err1` and `err2`
 have the *same type*. This is because they are existentially quantified types,
-or trait objects. In particular, their underlying type is *erased* from the
+or trait objects. In particularly, their underlying type is *erased* from the
 compiler's knowledge, so it truly sees `err1` and `err2` as exactly the same.
 Additionally, we constructed `err1` and `err2` using precisely the same
 function call: `From::from`. This is because `From::from` is overloaded on both
@@ -1250,7 +1250,7 @@ macro_rules! try {
 This is not its real definition. Its real definition is
 [in the standard library](../std/macro.try!.html):
 
-<span id="code-try-def"></span>
+<a name="code-try-def"></a>
 
 ```rust
 macro_rules! try {
@@ -1515,7 +1515,7 @@ and [`rustc-serialize`](https://crates.io/crates/rustc-serialize) crates.
 
 We're not going to spend a lot of time on setting up a project with
 Cargo because it is already covered well in [the Cargo
-chapter](../book/hello-cargo.html) and [Cargo's documentation][14].
+chapter](../book/hello-cargo) and [Cargo's documentation][14].
 
 To get started from scratch, run `cargo new --bin city-pop` and make sure your
 `Cargo.toml` looks something like this:
@@ -1573,7 +1573,7 @@ fn main() {
 
     let mut opts = Options::new();
     opts.optflag("h", "help", "Show this usage message.");
-
+    
     let matches = match opts.parse(&args[1..]) {
         Ok(m)  => { m }
 	Err(e) => { panic!(e.to_string()) }
@@ -1584,7 +1584,7 @@ fn main() {
     }
     let data_path = args[1].clone();
     let city = args[2].clone();
-
+	
 	// Do stuff with information
 }
 ```
@@ -1647,27 +1647,27 @@ fn main() {
 
     let mut opts = Options::new();
     opts.optflag("h", "help", "Show this usage message.");
-
+    
     let matches = match opts.parse(&args[1..]) {
         Ok(m)  => { m }
 		Err(e) => { panic!(e.to_string()) }
     };
-
+	
     if matches.opt_present("h") {
         print_usage(&program, opts);
 		return;
 	}
-
+		
 	let data_file = args[1].clone();
 	let data_path = Path::new(&data_file);
 	let city = args[2].clone();
-
+	
 	let file = fs::File::open(data_path).unwrap();
 	let mut rdr = csv::Reader::from_reader(file);
-
+	
 	for row in rdr.decode::<Row>() {
 		let row = row.unwrap();
-
+	
 		if row.city == city {
 			println!("{}, {}: {:?}",
 				row.city, row.country,
@@ -1773,7 +1773,7 @@ fn main() {
 		print_usage(&program, opts);
 		return;
 	}
-
+		
 	let data_file = args[1].clone();
 	let data_path = Path::new(&data_file);
 	let city = args[2].clone();
@@ -1882,7 +1882,7 @@ opts.optflag("h", "help", "Show this usage message.");
 ...
 let file = matches.opt_str("f");
 let data_file = file.as_ref().map(Path::new);
-
+	
 let city = if !matches.free.is_empty() {
 	matches.free[0].clone()
 } else {
@@ -2064,7 +2064,7 @@ string and add a flag to the Option variable. Once were done that, Getopts does
 let mut opts = Options::new();
 opts.optopt("f", "file", "Choose an input file, instead of using STDIN.", "NAME");
 opts.optflag("h", "help", "Show this usage message.");
-opts.optflag("q", "quiet", "Silences errors and warnings.");
+opts.optflag("q", "quit", "Silences errors and warnings.");
 ...
 ```
 

branches/tmp/src/liballoc/lib.rs

@@ -100,7 +100,7 @@
 #![cfg_attr(stage0, feature(alloc_system))]
 #![cfg_attr(not(stage0), feature(needs_allocator))]
 
-#![cfg_attr(test, feature(test, rustc_private, box_heap))]
+#![cfg_attr(test, feature(test, rustc_private))]
 
 #[cfg(stage0)]
 extern crate alloc_system;

branches/tmp/src/libcollections/lib.rs

@@ -38,8 +38,6 @@
 #![feature(core_intrinsics)]
 #![feature(core_slice_ext)]
 #![feature(core_str_ext)]
-#![feature(fmt_internals)]
-#![feature(fmt_radix)]
 #![feature(heap_api)]
 #![feature(iter_order)]
 #![feature(iter_arith)]
@@ -49,8 +47,6 @@
 #![feature(oom)]
 #![feature(pattern)]
 #![feature(ptr_as_ref)]
-#![feature(ref_slice)]
-#![feature(slice_bytes)]
 #![feature(slice_patterns)]
 #![feature(staged_api)]
 #![feature(step_by)]

branches/tmp/src/libcollections/str.rs

@@ -38,7 +38,6 @@ use slice::SliceConcatExt;
 use boxed::Box;
 
 pub use core::str::{FromStr, Utf8Error};
-#[allow(deprecated)]
 pub use core::str::{Lines, LinesAny, CharRange};
 pub use core::str::{Split, RSplit};
 pub use core::str::{SplitN, RSplitN};

branches/tmp/src/libcollections/vec.rs

@@ -65,7 +65,7 @@ use alloc::heap::EMPTY;
 use core::cmp::Ordering;
 use core::fmt;
 use core::hash::{self, Hash};
-use core::intrinsics::{arith_offset, assume, drop_in_place, needs_drop};
+use core::intrinsics::{arith_offset, assume, drop_in_place};
 use core::iter::FromIterator;
 use core::mem;
 use core::ops::{Index, IndexMut, Deref};
@@ -1322,14 +1322,8 @@ impl<T> Drop for Vec<T> {
         // OK because exactly when this stops being a valid assumption, we
         // don't need unsafe_no_drop_flag shenanigans anymore.
         if self.buf.unsafe_no_drop_flag_needs_drop() {
-            unsafe {
-                // The branch on needs_drop() is an -O1 performance optimization.
-                // Without the branch, dropping Vec<u8> takes linear time.
-                if needs_drop::<T>() {
-                    for x in self.iter_mut() {
-                        drop_in_place(x);
-                    }
-                }
+            for x in self.iter_mut() {
+                unsafe { drop_in_place(x); }
             }
         }
         // RawVec handles deallocation

branches/tmp/src/libcollectionstest/btree/set.rs

@@ -148,9 +148,15 @@ fn test_zip() {
     let y = y;
     let mut z = x.iter().zip(&y);
 
-    assert_eq!(z.next().unwrap(), (&5, &("bar")));
-    assert_eq!(z.next().unwrap(), (&11, &("foo")));
-    assert!(z.next().is_none());
+    // FIXME: #5801: this needs a type hint to compile...
+    let result: Option<(&usize, & &'static str)> = z.next();
+    assert_eq!(result.unwrap(), (&5, &("bar")));
+
+    let result: Option<(&usize, & &'static str)> = z.next();
+    assert_eq!(result.unwrap(), (&11, &("foo")));
+
+    let result: Option<(&usize, & &'static str)> = z.next();
+    assert!(result.is_none());
 }
 
 #[test]