---

yaml
---
r: 211615
b: refs/heads/master
c: 3d74fbd
h: refs/heads/master
i:
  211613: fc1d417
  211611: b6c9aab
  211607: d771791
  211599: 6f508e7
  211583: a71c3a2
v: v3

Author: alexcrichton

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: da0d45243bbb04ea7efec686162d0b9ce2ec4734
+refs/heads/master: 3d74fbd4961dc66781bc5531e5d937eaee45d99c
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
 refs/heads/try: 1864973ae17213c5a58c4dd3f9af6d1b6c7d2e05

trunk/AUTHORS.txt

@@ -338,7 +338,7 @@ Hajime Morrita <[email protected]>
 Hanno Braun <[email protected]>
 Harry Marr <[email protected]>
 Heather <[email protected]>
-Heejong Ahn <[email protected]>
+Heejong Ahn <[email protected]
 Henrik Schopmans <[email protected]>
 Herman J. Radtke III <[email protected]>
 HeroesGrave <[email protected]>

trunk/configure

@@ -1307,6 +1307,12 @@ CFG_LLVM_SRC_DIR=${CFG_SRC_DIR}src/llvm/
 for t in $CFG_HOST
 do
     do_reconfigure=1
+    is_msvc=0
+    case "$t" in
+        (*-msvc)
+        is_msvc=1
+        ;;
+    esac
 
     if [ -z $CFG_LLVM_ROOT ]
     then
@@ -1326,7 +1332,13 @@ do
             LLVM_ASSERTION_OPTS="--disable-assertions"
         else
             LLVM_ASSERTION_OPTS="--enable-assertions"
-            LLVM_INST_DIR=${LLVM_INST_DIR}+Asserts
+
+            # Apparently even if we request assertions be enabled for MSVC,
+            # LLVM's CMake build system ignore this and outputs in `Release`
+            # anyway.
+            if [ ${is_msvc} -eq 0 ]; then
+                LLVM_INST_DIR=${LLVM_INST_DIR}+Asserts
+            fi
         fi
     else
         msg "not reconfiguring LLVM, external LLVM root"
@@ -1356,14 +1368,7 @@ do
         done
     fi
 
-    use_cmake=0
-    case "$t" in
-        (*-msvc)
-        use_cmake=1
-        ;;
-    esac
-
-    if [ ${do_reconfigure} -ne 0 ] && [ ${use_cmake} -ne 0 ]
+    if [ ${do_reconfigure} -ne 0 ] && [ ${is_msvc} -ne 0 ]
     then
         msg "configuring LLVM for $t with cmake"
 
@@ -1388,7 +1393,7 @@ do
         need_ok "LLVM cmake configure failed"
     fi
 
-    if [ ${do_reconfigure} -ne 0 ] && [ ${use_cmake} -eq 0 ]
+    if [ ${do_reconfigure} -ne 0 ] && [ ${is_msvc} -eq 0 ]
     then
         # LLVM's configure doesn't recognize the new Windows triples yet
         gnu_t=$(to_gnu_triple $t)

trunk/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,

trunk/src/doc/reference.md

@@ -3599,147 +3599,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:
-
-```rust
-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.

trunk/src/libcollections/linked_list.rs

@@ -106,14 +106,16 @@ impl<T> Rawlink<T> {
     /// Convert the `Rawlink` into an Option value
     fn resolve_immut<'a>(&self) -> Option<&'a T> {
         unsafe {
-            self.p.as_ref()
+            mem::transmute(self.p.as_ref())
         }
     }
 
     /// Convert the `Rawlink` into an Option value
     fn resolve<'a>(&mut self) -> Option<&'a mut T> {
-        unsafe {
-            self.p.as_mut()
+        if self.p.is_null() {
+            None
+        } else {
+            Some(unsafe { mem::transmute(self.p) })
         }
     }
 
@@ -609,13 +611,7 @@ impl<T> LinkedList<T> {
             length: len - at
         };
 
-        // Swap split_node.next with list_head (which is None), nulling out split_node.next,
-        // as it is the new tail.
         mem::swap(&mut split_node.resolve().unwrap().next, &mut splitted_list.list_head);
-        // Null out list_head.prev. Note this `unwrap` won't fail because if at == len
-        // we already branched out at the top of the fn to return the empty list.
-        splitted_list.list_head.as_mut().unwrap().prev = Rawlink::none();
-        // Fix the tail ptr
         self.list_tail = split_node;
         self.length = at;
 
@@ -1081,26 +1077,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_26021() {
-        use std::iter::ExactSizeIterator;
-        // There was a bug in split_off that failed to null out the RHS's head's prev ptr.
-        // This caused the RHS's dtor to walk up into the LHS at drop and delete all of
-        // its nodes.
-        //
-        // https://github.com/rust-lang/rust/issues/26021
-        let mut v1 = LinkedList::new();
-        v1.push_front(1u8);
-        v1.push_front(1u8);
-        v1.push_front(1u8);
-        v1.push_front(1u8);
-        let _ = v1.split_off(3); // Dropping this now should not cause laundry consumption
-        assert_eq!(v1.len(), 3);
-
-        assert_eq!(v1.iter().len(), 3);
-        assert_eq!(v1.iter().collect::<Vec<_>>().len(), 3);
-    }
-
     #[cfg(test)]
     fn fuzz_test(sz: i32) {
         let mut m: LinkedList<_> = LinkedList::new();

trunk/src/libcore/result.rs

@@ -223,9 +223,7 @@
 //! }
 //! ```
 //!
-//! `try!` is imported by the prelude and is available everywhere, but it can only
-//! be used in functions that return `Result` because of the early return of
-//! `Err` that it provides.
+//! `try!` is imported by the prelude, and is available everywhere.
 
 #![stable(feature = "rust1", since = "1.0.0")]
 

trunk/src/liblibc/lib.rs

@@ -6308,8 +6308,8 @@ pub mod funcs {
                                 lpOverlapped: LPOVERLAPPED) -> BOOL;
                 pub fn WriteFile(hFile: HANDLE,
                                  lpBuffer: LPVOID,
-                                 nNumberOfBytesToWrite: DWORD,
-                                 lpNumberOfBytesWritten: LPDWORD,
+                                 nNumberOfBytesToRead: DWORD,
+                                 lpNumberOfBytesRead: LPDWORD,
                                  lpOverlapped: LPOVERLAPPED) -> BOOL;
                 pub fn SetFilePointerEx(hFile: HANDLE,
                                         liDistanceToMove: LARGE_INTEGER,

trunk/src/librustc/metadata/csearch.rs

@@ -13,6 +13,7 @@
 use metadata::common::*;
 use metadata::cstore;
 use metadata::decoder;
+use middle::def;
 use middle::lang_items;
 use middle::ty;
 
@@ -113,6 +114,12 @@ pub fn maybe_get_item_ast<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId,
     decoder::maybe_get_item_ast(&*cdata, tcx, def.node, decode_inlined_item)
 }
 
+pub fn get_enum_variant_defs(cstore: &cstore::CStore, enum_id: ast::DefId)
+                             -> Vec<(def::Def, ast::Name, ast::Visibility)> {
+    let cdata = cstore.get_crate_data(enum_id.krate);
+    decoder::get_enum_variant_defs(&*cstore.intr, &*cdata, enum_id.node)
+}
+
 pub fn get_enum_variants<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId)
                                -> Vec<Rc<ty::VariantInfo<'tcx>>> {
     let cstore = &tcx.sess.cstore;