---

yaml
---
r: 211886
b: refs/heads/auto
c: 24808fa
h: refs/heads/master
v: v3

Author: webmobster

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 8a39dffa7f3afc974073d8f62b9dfcb419e03f4e
+refs/heads/auto: 24808fa076a2cf86c32e138d95c68e3ee4c7a0fc
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/configure

@@ -582,7 +582,6 @@ valopt sysconfdir "/etc" "install system configuration files"
 valopt datadir "${CFG_PREFIX}/share" "install data"
 valopt infodir "${CFG_PREFIX}/share/info" "install additional info"
 valopt llvm-root "" "set LLVM root"
-valopt python "" "set path to python"
 valopt jemalloc-root "" "set directory where libjemalloc_pic.a is located"
 valopt build "${DEFAULT_BUILD}" "GNUs ./configure syntax LLVM build triple"
 valopt android-cross-path "/opt/ndk_standalone" "Android NDK standalone path"
@@ -696,9 +695,7 @@ putvar CFG_BOOTSTRAP_KEY
 step_msg "looking for build programs"
 
 probe_need CFG_CURLORWGET  curl wget
-if [ -z "$CFG_PYTHON_PROVIDED" ]; then
-    probe_need CFG_PYTHON      python2.7 python2.6 python2 python
-fi
+probe_need CFG_PYTHON      python2.7 python2.6 python2 python
 
 python_version=$($CFG_PYTHON -V 2>&1)
 if [ $(echo $python_version | grep -c '^Python 2\.[4567]') -ne 1 ]; then
@@ -852,6 +849,13 @@ then
     putvar CFG_LOCAL_RUST_ROOT
 fi
 
+# Force freebsd to build with clang; gcc doesn't like us there
+if [ $CFG_OSTYPE = unknown-freebsd ]
+then
+    step_msg "on FreeBSD, forcing use of clang"
+    CFG_ENABLE_CLANG=1
+fi
+
 # Force bitrig to build with clang; gcc doesn't like us there
 if [ $CFG_OSTYPE = unknown-bitrig ]
 then

branches/auto/mk/docs.mk

@@ -265,7 +265,7 @@ endef
 $(foreach crate,$(CRATES),$(eval $(call DEF_LIB_DOC,$(crate))))
 
 COMPILER_DOC_TARGETS := $(CRATES:%=doc/%/index.html)
-ifdef CFG_ENABLE_COMPILER_DOCS
+ifdef CFG_COMPILER_DOCS
   DOC_TARGETS += $(COMPILER_DOC_TARGETS)
 else
   DOC_TARGETS += $(DOC_CRATES:%=doc/%/index.html)

branches/auto/src/compiletest/runtest.rs

@@ -24,6 +24,7 @@ use std::fmt;
 use std::fs::{self, File};
 use std::io::BufReader;
 use std::io::prelude::*;
+use std::iter::repeat;
 use std::net::TcpStream;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output, ExitStatus};
@@ -927,12 +928,12 @@ fn check_forbid_output(props: &TestProps,
     }
 }
 
-fn check_expected_errors(expected_errors: Vec<errors::ExpectedError>,
+fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
                          testfile: &Path,
                          proc_res: &ProcRes) {
 
     // true if we found the error in question
-    let mut found_flags = vec![false; expected_errors.len()];
+    let mut found_flags: Vec<_> = repeat(false).take(expected_errors.len()).collect();
 
     if proc_res.status.success() {
         fatal("process did not return an error status");
@@ -953,10 +954,14 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError>,
         }
     }
 
-    // A multi-line error will have followup lines which start with a space
-    // or open paren.
+    // A multi-line error will have followup lines which will always
+    // start with one of these strings.
     fn continuation( line: &str) -> bool {
-        line.starts_with(" ") || line.starts_with("(")
+        line.starts_with(" expected") ||
+        line.starts_with("    found") ||
+        //                1234
+        // Should have 4 spaces: see issue 18946
+        line.starts_with("(")
     }
 
     // Scan and extract our error/warning messages,

branches/auto/src/doc/reference.md

@@ -1943,6 +1943,9 @@ macro scope.
 - `simd` - on certain tuple structs, derive the arithmetic operators, which
   lower to the target's SIMD instructions, if any; the `simd` feature gate
   is necessary to use this attribute.
+- `static_assert` - on statics whose type is `bool`, terminates compilation
+  with an error if it is not initialized to `true`. To use this, the `static_assert`
+  feature gate must be enabled.
 - `unsafe_no_drop_flag` - on structs, remove the flag that prevents
   destructors from being run twice. Destructors might be run multiple times on
   the same object with this attribute. To use this, the `unsafe_no_drop_flag` feature
@@ -2298,6 +2301,12 @@ The currently implemented features of the reference compiler are:
                  crate. Stability markers are also attributes: `#[stable]`,
                  `#[unstable]`, and `#[deprecated]` are the three levels.
 
+* `static_assert` - The `#[static_assert]` functionality is experimental and
+                    unstable. The attribute can be attached to a `static` of
+                    type `bool` and the compiler will error if the `bool` is
+                    `false` at compile time. This version of this functionality
+                    is unintuitive and suboptimal.
+
 * `start` - Allows use of the `#[start]` attribute, which changes the entry point
             into a Rust program. This capability, especially the signature for the
             annotated function, is subject to change.
@@ -3599,146 +3608,6 @@ The notation `&self` is a shorthand for `self: &Self`. In this case,
 in the impl, `Self` refers to the value of type `String` that is the
 receiver for a call to the method `make_string`.
 
-## Subtyping
-
-Subtyping is implicit and can occur at any stage in type checking or
-inference. Subtyping in Rust is very restricted and occurs only due to
-variance with respect to lifetimes and between types with higher ranked
-lifetimes. If we were to erase lifetimes from types, then the only subtyping
-would be due to type equality.
-
-Consider the following example: string literals always have `'static`
-lifetime. Nevertheless, we can assign `s` to `t`:
-
-```
-fn bar<'a>() {
-    let s: &'static str = "hi";
-    let t: &'a str = s;
-}
-```
-Since `'static` "lives longer" than `'a`, `&'static str` is a subtype of
-`&'a str`.
-
-## Type coercions
-
-Coercions are defined in [RFC401]. A coercion is implicit and has no syntax.
-
-[RFC401]: https://github.com/rust-lang/rfcs/blob/master/text/0401-coercions.md
-
-### Coercion sites
-
-A coercion can only occur at certain coercion sites in a program; these are
-typically places where the desired type is explicit or can be dervied by
-propagation from explicit types (without type inference). Possible coercion
-sites are:
-
-* `let` statements where an explicit type is given.
-
-    In `let _: U = e;`, `e` is coerced to have type `U`.
-
-* `static` and `const` statements (similar to `let` statements).
-
-* arguments for function calls.
-
-    The value being coerced is the
-    actual parameter and it is coerced to the type of the formal parameter. For
-    example, let `foo` be defined as `fn foo(x: U) { ... }` and call it as
-    `foo(e);`. Then `e` is coerced to have type `U`;
-
-* instantiations of struct or variant fields.
-
-    Assume we have a `struct
-    Foo { x: U }` and instantiate it as `Foo { x: e }`. Then `e` is coerced to
-    have type `U`.
-
-* function results (either the final line of a block if it is not semicolon
-terminated or any expression in a `return` statement).
-
-    In `fn foo() -> U { e }`, `e` is coerced to to have type `U`.
-
-If the expression in one of these coercion sites is a coercion-propagating
-expression, then the relevant sub-expressions in that expression are also
-coercion sites. Propagation recurses from these new coercion sites.
-Propagating expressions and their relevant sub-expressions are:
-
-* array literals, where the array has type `[U; n]`. Each sub-expression in
-the array literal is a coercion site for coercion to type `U`.
-
-* array literals with repeating syntax, where the array has type `[U; n]`. The
-repeated sub-expression is a coercion site for coercion to type `U`.
-
-* tuples, where a tuple is a coercion site to type `(U_0, U_1, ..., U_n)`.
-Each sub-expression is a coercion site to the respective type, e.g. the
-zeroth sub-expression is a coercion site to type `U_0`.
-
-* parenthesised sub-expressions (`(e)`). If the expression has type `U`, then
-the sub-expression is a coercion site to `U`.
-
-* blocks. If a block has type `U`, then the last expression in the block (if
-it is not semicolon-terminated) is a coercion site to `U`. This includes
-blocks which are part of control flow statements, such as `if`/`else`, if
-the block has a known type.
-
-### Coercion types
-
-Coercion is allowed between the following types:
-
-* `T` to `U` if `T` is a subtype of `U` (*reflexive case*).
-
-* `T_1` to `T_3` where `T_1` coerces to `T_2` and `T_2` coerces to `T_3`
-(*transitive case*).
-
-    Note that this is not fully supported yet
-
-* `&mut T` to `&T`.
-
-* `*mut T` to `*const T`.
-
-* `&T` to `*const T`.
-
-* `&mut T` to `*mut T`.
-
-* `&T` to `&U` if `T` implements `Deref<Target = U>`. For example:
-    ```
-    use std::ops::Deref;
-
-    struct CharContainer {
-        value: char
-    }
-
-    impl Deref for CharContainer {
-        type Target = char;
-
-        fn deref<'a>(&'a self) -> &'a char {
-            &self.value
-        }
-    }
-
-    fn foo(arg: &char) {}
-
-    fn main() {
-        let x = &mut CharContainer { value: 'y' };
-        foo(x); //&mut CharContainer is coerced to &char.
-    }
-    ```
-* `&mut T` to `&mut U` if `T` implements `DerefMut<Target = U>`.
-
-* TyCtor(`T`) to TyCtor(coerce_inner(`T`)), where TyCtor(`T`) is one of
-    - `&T`
-    - `&mut T`
-    - `*const T`
-    - `*mut T`
-    - `Box<T>`
-
-    and where
-    - coerce_inner(`[T, ..n]`) = `[T]`
-    - coerce_inner(`T`) = `U` where `T` is a concrete type which implements the
-    trait `U`.
-
-    In the future, coerce_inner will be recursively extended to tuples and
-    structs. In addition, coercions from sub-traits to super-traits will be
-    added. See [RFC401] for more details.
-
 # Special traits
 
 Several traits define special evaluation behavior.

branches/auto/src/doc/trpl/mutability.md

@@ -159,7 +159,7 @@ b.x = 10; // error: cannot assign to immutable field `b.x`
 
 [struct]: structs.html
 
-However, by using [`Cell<T>`][cell], you can emulate field-level mutability:
+However, by using `Cell<T>`, you can emulate field-level mutability:
 
 ```rust
 use std::cell::Cell;
@@ -176,6 +176,4 @@ point.y.set(7);
 println!("y: {:?}", point.y);
 ```
 
-[cell]: ../std/cell/struct.Cell.html
-
 This will print `y: Cell { value: 7 }`. We’ve successfully updated `y`.

branches/auto/src/librustc_back/target/freebsd_base.rs

@@ -18,6 +18,11 @@ pub fn opts() -> TargetOptions {
         executables: true,
         morestack: true,
         has_rpath: true,
+        pre_link_args: vec!(
+            "-L/usr/local/lib".to_string(),
+            "-L/usr/local/lib/gcc46".to_string(),
+            "-L/usr/local/lib/gcc44".to_string(),
+        ),
 
         .. Default::default()
     }