---

yaml
---
r: 234462
b: refs/heads/tmp
c: a1758ae
h: refs/heads/master
v: v3

Author: rutsky

[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: 3a4fb823e26c512d14d97bd86e2ac7b1e7d3d0fa
+refs/heads/tmp: a1758aea18e9008e5b47a99706cab21ca12f1b0a
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: ab792abf1fcc28afbd315426213f6428da25c085
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828

branches/tmp/COPYRIGHT

@@ -22,6 +22,104 @@ The Rust Project includes packages written by third parties.
 The following third party packages are included, and carry
 their own copyright notices and license terms:
 
+* Two header files that are part of the Valgrind
+  package. These files are found at src/rt/valgrind/valgrind.h and
+  src/rt/valgrind/memcheck.h, within this distribution. These files
+  are redistributed under the following terms, as noted in
+  them:
+
+  for src/rt/valgrind/valgrind.h:
+
+    This file is part of Valgrind, a dynamic binary
+    instrumentation framework.
+
+    Copyright (C) 2000-2010 Julian Seward.  All rights
+    reserved.
+
+    Redistribution and use in source and binary forms, with
+    or without modification, are permitted provided that the
+    following conditions are met:
+
+    1. Redistributions of source code must retain the above
+       copyright notice, this list of conditions and the
+       following disclaimer.
+
+    2. The origin of this software must not be
+       misrepresented; you must not claim that you wrote the
+       original software.  If you use this software in a
+       product, an acknowledgment in the product
+       documentation would be appreciated but is not
+       required.
+
+    3. Altered source versions must be plainly marked as
+       such, and must not be misrepresented as being the
+       original software.
+
+    4. The name of the author may not be used to endorse or
+       promote products derived from this software without
+       specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
+    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+    NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+    USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+    USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+    OF SUCH DAMAGE.
+
+  for src/rt/valgrind/memcheck.h:
+
+    This file is part of MemCheck, a heavyweight Valgrind
+    tool for detecting memory errors.
+
+    Copyright (C) 2000-2010 Julian Seward.  All rights
+    reserved.
+
+    Redistribution and use in source and binary forms, with
+    or without modification, are permitted provided that the
+    following conditions are met:
+
+    1. Redistributions of source code must retain the above
+       copyright notice, this list of conditions and the
+       following disclaimer.
+
+    2. The origin of this software must not be
+       misrepresented; you must not claim that you wrote the
+       original software.  If you use this software in a
+       product, an acknowledgment in the product
+       documentation would be appreciated but is not
+       required.
+
+    3. Altered source versions must be plainly marked as
+       such, and must not be misrepresented as being the
+       original software.
+
+    4. The name of the author may not be used to endorse or
+       promote products derived from this software without
+       specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
+    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
+    NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+    USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+    USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+    OF SUCH DAMAGE.
+
 * The src/rt/miniz.c file, carrying an implementation of
   RFC1950/RFC1951 DEFLATE, by Rich Geldreich
   <[email protected]>. All uses of this file are

branches/tmp/src/doc/trpl/macros.md

@@ -313,7 +313,7 @@ fn main() {
 }
 ```
 
-This works because Rust has a [hygienic macro system]. Each macro expansion
+This works because Rust has a [hygienic macro system][https://en.wikipedia.org/wiki/Hygienic_macro]. Each macro expansion
 happens in a distinct ‘syntax context’, and each variable is tagged with the
 syntax context where it was introduced. It’s as though the variable `state`
 inside `main` is painted a different "color" from the variable `state` inside

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

@@ -62,7 +62,7 @@ fn foo(mut x: i32) {
 # Interior vs. Exterior Mutability
 
 However, when we say something is ‘immutable’ in Rust, that doesn’t mean that
-it’s not able to be changed: we mean something has ‘exterior mutability’. Consider,
+it’s not able to be changed: We mean something has ‘exterior mutability’. Consider,
 for example, [`Arc<T>`][arc]:
 
 ```rust
@@ -85,8 +85,8 @@ philosophy, memory safety, and the mechanism by which Rust guarantees it, the
 > You may have one or the other of these two kinds of borrows, but not both at
 > the same time:
 > 
-> * one or more references (`&T`) to a resource,
-> * exactly one mutable reference (`&mut T`).
+> * one or more references (`&T`) to a resource.
+> * exactly one mutable reference (`&mut T`)
 
 [ownership]: ownership.html
 [borrowing]: references-and-borrowing.html#borrowing

branches/tmp/src/doc/trpl/patterns.md

@@ -251,7 +251,7 @@ match x {
 }
 ```
 
-This prints `Some("Steve")`: We’ve bound the inner `name` to `a`.
+This prints `Some("Steve")`: we’ve bound the inner `name` to `a`.
 
 If you use `@` with `|`, you need to make sure the name is bound in each part
 of the pattern:

branches/tmp/src/doc/trpl/references-and-borrowing.md

@@ -159,8 +159,8 @@ First, any borrow must last for a scope no greater than that of the owner.
 Second, you may have one or the other of these two kinds of borrows, but not
 both at the same time:
 
-* one or more references (`&T`) to a resource,
-* exactly one mutable reference (`&mut T`).
+* one or more references (`&T`) to a resource.
+* exactly one mutable reference (`&mut T`)
 
 
 You may notice that this is very similar, though not exactly the same as,
@@ -298,8 +298,8 @@ We can’t modify `v` because it’s borrowed by the loop.
 
 ### use after free
 
-References must not live longer than the resource they refer to. Rust will
-check the scopes of your references to ensure that this is true.
+References must live as long as the resource they refer to. Rust will check the
+scopes of your references to ensure that this is true.
 
 If Rust didn’t check this property, we could accidentally use a reference
 which was invalid. For example:

branches/tmp/src/librustc/middle/infer/error_reporting.rs

@@ -78,7 +78,6 @@ use rustc_front::hir;
 use rustc_front::print::pprust;
 
 use middle::def;
-use middle::def_id::DefId;
 use middle::infer;
 use middle::region;
 use middle::subst;
@@ -227,8 +226,6 @@ pub trait ErrorReporting<'tcx> {
 
     fn report_type_error(&self, trace: TypeTrace<'tcx>, terr: &ty::TypeError<'tcx>);
 
-    fn check_and_note_conflicting_crates(&self, terr: &ty::TypeError<'tcx>, sp: Span);
-
     fn report_and_explain_type_error(&self,
                                      trace: TypeTrace<'tcx>,
                                      terr: &ty::TypeError<'tcx>);
@@ -487,60 +484,13 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
                  expected_found_str,
                  terr);
 
-        self.check_and_note_conflicting_crates(terr, trace.origin.span());
-
         match trace.origin {
             infer::MatchExpressionArm(_, arm_span) =>
                 self.tcx.sess.span_note(arm_span, "match arm with an incompatible type"),
             _ => ()
         }
     }
 
-    /// Adds a note if the types come from similarly named crates
-    fn check_and_note_conflicting_crates(&self, terr: &ty::TypeError<'tcx>, sp: Span) {
-        let report_path_match = |did1: DefId, did2: DefId| {
-            // Only external crates, if either is from a local
-            // module we could have false positives
-            if !(did1.is_local() || did2.is_local()) && did1.krate != did2.krate {
-                let exp_path = self.tcx.with_path(did1,
-                                                  |p| p.map(|x| x.to_string())
-                                                       .collect::<Vec<_>>());
-                let found_path = self.tcx.with_path(did2,
-                                                    |p| p.map(|x| x.to_string())
-                                                         .collect::<Vec<_>>());
-                // We compare strings because PathMod and PathName can be different
-                // for imported and non-imported crates
-                if exp_path == found_path {
-                    let crate_name = self.tcx.sess.cstore
-                                         .get_crate_data(did1.krate).name();
-                    self.tcx.sess.span_note(sp, &format!("Perhaps two different versions \
-                                                          of crate `{}` are being used?",
-                                                          crate_name));
-                }
-            }
-        };
-        match *terr {
-            ty::TypeError::Sorts(ref exp_found) => {
-                // if they are both "path types", there's a chance of ambiguity
-                // due to different versions of the same crate
-                match (&exp_found.expected.sty, &exp_found.found.sty) {
-                    (&ty::TyEnum(ref exp_adt, _), &ty::TyEnum(ref found_adt, _)) |
-                    (&ty::TyStruct(ref exp_adt, _), &ty::TyStruct(ref found_adt, _)) |
-                    (&ty::TyEnum(ref exp_adt, _), &ty::TyStruct(ref found_adt, _)) |
-                    (&ty::TyStruct(ref exp_adt, _), &ty::TyEnum(ref found_adt, _)) => {
-                        report_path_match(exp_adt.did, found_adt.did);
-                    },
-                    _ => ()
-                }
-            },
-            ty::TypeError::Traits(ref exp_found) => {
-                self.tcx.sess.note("errrr0");
-                report_path_match(exp_found.expected, exp_found.found);
-            },
-            _ => () // FIXME(#22750) handle traits and stuff
-        }
-    }
-
     fn report_and_explain_type_error(&self,
                                      trace: TypeTrace<'tcx>,
                                      terr: &ty::TypeError<'tcx>) {

branches/tmp/src/librustc/middle/ty.rs

@@ -5311,16 +5311,6 @@ impl<'tcx> TyS<'tcx> {
 impl<'tcx> fmt::Display for TypeError<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use self::TypeError::*;
-        fn report_maybe_different(f: &mut fmt::Formatter,
-                                  expected: String, found: String) -> fmt::Result {
-            // A naive approach to making sure that we're not reporting silly errors such as:
-            // (expected closure, found closure).
-            if expected == found {
-                write!(f, "expected {}, found a different {}", expected, found)
-            } else {
-                write!(f, "expected {}, found {}", expected, found)
-            }
-        }
 
         match *self {
             CyclicTy => write!(f, "cyclic type of infinite size"),
@@ -5381,15 +5371,20 @@ impl<'tcx> fmt::Display for TypeError<'tcx> {
                            found bound lifetime parameter {}", br)
             }
             Sorts(values) => tls::with(|tcx| {
-                report_maybe_different(f, values.expected.sort_string(tcx),
-                                       values.found.sort_string(tcx))
+                // A naive approach to making sure that we're not reporting silly errors such as:
+                // (expected closure, found closure).
+                let expected_str = values.expected.sort_string(tcx);
+                let found_str = values.found.sort_string(tcx);
+                if expected_str == found_str {
+                    write!(f, "expected {}, found a different {}", expected_str, found_str)
+                } else {
+                    write!(f, "expected {}, found {}", expected_str, found_str)
+                }
             }),
             Traits(values) => tls::with(|tcx| {
-                report_maybe_different(f,
-                                       format!("trait `{}`",
-                                               tcx.item_path_str(values.expected)),
-                                       format!("trait `{}`",
-                                               tcx.item_path_str(values.found)))
+                write!(f, "expected trait `{}`, found trait `{}`",
+                       tcx.item_path_str(values.expected),
+                       tcx.item_path_str(values.found))
             }),
             BuiltinBoundsMismatch(values) => {
                 if values.expected.is_empty() {

branches/tmp/src/librustdoc/html/layout.rs

@@ -62,10 +62,10 @@ r##"<!DOCTYPE html>
 
     {before_content}
 
-    <nav class="sidebar">
+    <section class="sidebar">
         {logo}
         {sidebar}
-    </nav>
+    </section>
 
     <nav class="sub">
         <form class="search-form js-only">
@@ -83,12 +83,10 @@ r##"<!DOCTYPE html>
 
     <section class="footer"></section>
 
-    <aside id="help" class="hidden">
+    <div id="help" class="hidden">
         <div>
-            <h1 class="hidden">Help</h1>
-
             <div class="shortcuts">
-                <h2>Keyboard Shortcuts</h2>
+                <h1>Keyboard Shortcuts</h1>
 
                 <dl>
                     <dt>?</dt>
@@ -105,7 +103,7 @@ r##"<!DOCTYPE html>
             </div>
 
             <div class="infos">
-                <h2>Search Tricks</h2>
+                <h1>Search Tricks</h1>
 
                 <p>
                     Prefix searches with a type followed by a colon (e.g.
@@ -125,7 +123,7 @@ r##"<!DOCTYPE html>
                 </p>
             </div>
         </div>
-    </aside>
+    </div>
 
     {after_content}
 

branches/tmp/src/librustdoc/html/static/main.css

@@ -104,7 +104,7 @@ h3.impl, h3.method, h4.method, h3.type, h4.type {
 h3.impl, h3.method, h3.type {
     margin-top: 15px;
 }
-h1, h2, h3, h4, .sidebar, a.source, .search-input, .content table :not(code)>a, .collapse-toggle {
+h1, h2, h3, h4, section.sidebar, a.source, .search-input, .content table :not(code)>a, .collapse-toggle {
     font-family: "Fira Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
 }
 
@@ -189,16 +189,11 @@ nav.sub {
     padding: 0 10px;
     margin-bottom: 14px;
 }
-.block h2, .block h3 {
+.block h2 {
     margin-top: 0;
     margin-bottom: 8px;
     text-align: center;
 }
-.block ul, .block li {
-    margin: 0;
-    padding: 0;
-    list-style: none;
-}
 
 .block a {
     display: block;
@@ -386,7 +381,7 @@ nav.main .separator {
 nav.sum { text-align: right; }
 nav.sub form { display: inline; }
 
-nav.sub, .content {
+nav, .content {
     margin-left: 230px;
 }
 
@@ -412,7 +407,6 @@ a {
 .content span.method, .content a.method, .block a.current.method { color: #8c6067; }
 .content span.tymethod, .content a.tymethod, .block a.current.tymethod { color: #8c6067; }
 .content .fnname { color: #8c6067; }
-.block a.current.crate { font-weight: 500; }
 
 .search-input {
     width: 100%;
@@ -495,7 +489,7 @@ body.blur > :not(#help) {
 }
 #help dd { margin: 5px 33px; }
 #help .infos { padding-left: 0; }
-#help h1, #help h2 { margin-top: 0; }
+#help h1 { margin-top: 0; }
 #help > div div {
     width: 50%;
     float: left;