---

yaml
---
r: 136572
b: refs/heads/dist-snap
c: 9fcfcaa
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 189b7332968972f34cdbbbd9b62d97ababf53059
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: b11c5722f84879db3539e84d8d21c4c758165163
+refs/heads/dist-snap: 9fcfcaa347ffcace8503601bdc09bf3612e8585f
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/etc/make-win-dist.py

@@ -58,15 +58,15 @@ def make_win_dist(dist_root, target_triple):
     for src in rustc_dlls:
         shutil.copy(src, dist_bin_dir)
 
-    # Copy platform tools (and another copy of runtime dlls) to platform-spcific bin directory
-    target_bin_dir = os.path.join(dist_root, "bin", "rustlib", target_triple, "bin")
+    # Copy platform tools to platform-specific bin directory
+    target_bin_dir = os.path.join(dist_root, "bin", "rustlib", target_triple, "gcc", "bin")
     if not os.path.exists(target_bin_dir):
         os.makedirs(target_bin_dir)
     for src in target_tools:
         shutil.copy(src, target_bin_dir)
 
     # Copy platform libs to platform-spcific lib directory
-    target_lib_dir = os.path.join(dist_root, "bin", "rustlib", target_triple, "lib")
+    target_lib_dir = os.path.join(dist_root, "bin", "rustlib", target_triple, "gcc", "lib")
     if not os.path.exists(target_lib_dir):
         os.makedirs(target_lib_dir)
     for src in target_libs:

branches/dist-snap/src/librustc/driver/config.rs

@@ -180,7 +180,6 @@ debugging_opts!(
         GC,
         PRINT_LINK_ARGS,
         PRINT_LLVM_PASSES,
-        LTO,
         AST_JSON,
         AST_JSON_NOEXPAND,
         LS,
@@ -219,7 +218,6 @@ pub fn debugging_opts_map() -> Vec<(&'static str, &'static str, u64)> {
      ("print-llvm-passes",
       "Prints the llvm optimization passes being run",
       PRINT_LLVM_PASSES),
-     ("lto", "Perform LLVM link-time optimizations", LTO),
      ("ast-json", "Print the AST as JSON and halt", AST_JSON),
      ("ast-json-noexpand", "Print the pre-expansion AST as JSON and halt", AST_JSON_NOEXPAND),
      ("ls", "List the symbols defined by a library crate", LS),
@@ -353,6 +351,8 @@ cgoptions!(
         "system linker to link outputs with"),
     link_args: Vec<String> = (Vec::new(), parse_list,
         "extra arguments to pass to the linker (space separated)"),
+    lto: bool = (false, parse_bool,
+        "perform LLVM link-time optimizations"),
     target_cpu: String = ("generic".to_string(), parse_string,
         "select target processor (llc -mcpu=help for details)"),
     target_feature: String = ("".to_string(), parse_string,

branches/dist-snap/src/librustc/driver/driver.rs

@@ -560,8 +560,8 @@ pub fn phase_6_link_output(sess: &Session,
                            trans: &CrateTranslation,
                            outputs: &OutputFilenames) {
     let old_path = os::getenv("PATH").unwrap_or_else(||String::new());
-    let mut new_path = os::split_paths(old_path.as_slice());
-    new_path.push_all_move(sess.host_filesearch().get_tools_search_paths());
+    let mut new_path = sess.host_filesearch().get_tools_search_paths();
+    new_path.push_all_move(os::split_paths(old_path.as_slice()));
     os::setenv("PATH", os::join_paths(new_path.as_slice()).unwrap());
 
     time(sess.time_passes(), "linking", (), |_|

branches/dist-snap/src/librustc/driver/session.rs

@@ -168,7 +168,7 @@ impl Session {
         self.debugging_opt(config::PRINT_LLVM_PASSES)
     }
     pub fn lto(&self) -> bool {
-        self.debugging_opt(config::LTO)
+        self.opts.cg.lto
     }
     pub fn no_landing_pads(&self) -> bool {
         self.debugging_opt(config::NO_LANDING_PADS)

branches/dist-snap/src/librustc/metadata/filesearch.rs

@@ -150,8 +150,12 @@ impl<'a> FileSearch<'a> {
         p.push(find_libdir(self.sysroot));
         p.push(rustlibdir());
         p.push(self.triple);
-        p.push("bin");
-        vec![p]
+        let mut p1 = p.clone();
+        p1.push("bin");
+        let mut p2 = p.clone();
+        p2.push("gcc");
+        p2.push("bin");
+        vec![p1, p2]
     }
 }
 

branches/dist-snap/src/librustc/middle/resolve.rs

@@ -2928,7 +2928,7 @@ impl<'a> Resolver<'a> {
                             Some(span) => {
                                 self.session
                                     .span_note(span,
-                                               "note conflicting value here");
+                                               "conflicting value here");
                             }
                         }
                     }
@@ -2951,7 +2951,7 @@ impl<'a> Resolver<'a> {
                             Some(span) => {
                                 self.session
                                     .span_note(span,
-                                               "note conflicting type here")
+                                               "conflicting type here")
                             }
                         }
                     }

branches/dist-snap/src/libsyntax/parse/parser.rs

@@ -3480,22 +3480,32 @@ impl<'a> Parser<'a> {
         })
     }
 
+    /// Get an expected item after attributes error message.
+    fn expected_item_err(attrs: &[Attribute]) -> &'static str {
+        match attrs.last() {
+            Some(&Attribute { node: ast::Attribute_ { is_sugared_doc: true, .. }, .. }) => {
+                "expected item after doc comment"
+            }
+            _ => "expected item after attributes",
+        }
+    }
+
     /// Parse a statement. may include decl.
     /// Precondition: any attributes are parsed already
     pub fn parse_stmt(&mut self, item_attrs: Vec<Attribute>) -> P<Stmt> {
         maybe_whole!(self, NtStmt);
 
-        fn check_expected_item(p: &mut Parser, found_attrs: bool) {
+        fn check_expected_item(p: &mut Parser, attrs: &[Attribute]) {
             // If we have attributes then we should have an item
-            if found_attrs {
+            if !attrs.is_empty() {
                 let last_span = p.last_span;
-                p.span_err(last_span, "expected item after attributes");
+                p.span_err(last_span, Parser::expected_item_err(attrs));
             }
         }
 
         let lo = self.span.lo;
         if self.is_keyword(keywords::Let) {
-            check_expected_item(self, !item_attrs.is_empty());
+            check_expected_item(self, item_attrs.as_slice());
             self.expect_keyword(keywords::Let);
             let decl = self.parse_let();
             P(spanned(lo, decl.span.hi, StmtDecl(decl, ast::DUMMY_NODE_ID)))
@@ -3504,7 +3514,7 @@ impl<'a> Parser<'a> {
             && self.look_ahead(1, |t| *t == token::NOT) {
             // it's a macro invocation:
 
-            check_expected_item(self, !item_attrs.is_empty());
+            check_expected_item(self, item_attrs.as_slice());
 
             // Potential trouble: if we allow macros with paths instead of
             // idents, we'd need to look ahead past the whole path here...
@@ -3561,6 +3571,7 @@ impl<'a> Parser<'a> {
 
         } else {
             let found_attrs = !item_attrs.is_empty();
+            let item_err = Parser::expected_item_err(item_attrs.as_slice());
             match self.parse_item_or_view_item(item_attrs, false) {
                 IoviItem(i) => {
                     let hi = i.span.hi;
@@ -3575,7 +3586,10 @@ impl<'a> Parser<'a> {
                     self.fatal("foreign items are not allowed here");
                 }
                 IoviNone(_) => {
-                    check_expected_item(self, found_attrs);
+                    if found_attrs {
+                        let last_span = self.last_span;
+                        self.span_err(last_span, item_err);
+                    }
 
                     // Remainder are line-expr stmts.
                     let e = self.parse_expr_res(RestrictionStmtExpr);
@@ -3653,7 +3667,8 @@ impl<'a> Parser<'a> {
                 token::SEMI => {
                     if !attributes_box.is_empty() {
                         let last_span = self.last_span;
-                        self.span_err(last_span, "expected item after attributes");
+                        self.span_err(last_span,
+                                      Parser::expected_item_err(attributes_box.as_slice()));
                         attributes_box = Vec::new();
                     }
                     self.bump(); // empty
@@ -3739,7 +3754,8 @@ impl<'a> Parser<'a> {
 
         if !attributes_box.is_empty() {
             let last_span = self.last_span;
-            self.span_err(last_span, "expected item after attributes");
+            self.span_err(last_span,
+                          Parser::expected_item_err(attributes_box.as_slice()));
         }
 
         let hi = self.span.hi;
@@ -4685,7 +4701,8 @@ impl<'a> Parser<'a> {
         if first && attrs_remaining_len > 0u {
             // We parsed attributes for the first item but didn't find it
             let last_span = self.last_span;
-            self.span_err(last_span, "expected item after attributes");
+            self.span_err(last_span,
+                          Parser::expected_item_err(attrs_remaining.as_slice()));
         }
 
         ast::Mod {
@@ -4919,10 +4936,10 @@ impl<'a> Parser<'a> {
             items: _,
             foreign_items: foreign_items
         } = self.parse_foreign_items(first_item_attrs, true);
-        if ! attrs_remaining.is_empty() {
+        if !attrs_remaining.is_empty() {
             let last_span = self.last_span;
             self.span_err(last_span,
-                          "expected item after attributes");
+                          Parser::expected_item_err(attrs_remaining.as_slice()));
         }
         assert!(self.token == token::RBRACE);
         ast::ForeignMod {
@@ -5052,7 +5069,7 @@ impl<'a> Parser<'a> {
     fn parse_enum_def(&mut self, _generics: &ast::Generics) -> EnumDef {
         let mut variants = Vec::new();
         let mut all_nullary = true;
-        let mut have_disr = false;
+        let mut any_disr = None;
         while self.token != token::RBRACE {
             let variant_attrs = self.parse_outer_attributes();
             let vlo = self.span.lo;
@@ -5084,8 +5101,8 @@ impl<'a> Parser<'a> {
                 }
                 kind = TupleVariantKind(args);
             } else if self.eat(&token::EQ) {
-                have_disr = true;
                 disr_expr = Some(self.parse_expr());
+                any_disr = disr_expr.as_ref().map(|expr| expr.span);
                 kind = TupleVariantKind(args);
             } else {
                 kind = TupleVariantKind(Vec::new());
@@ -5104,9 +5121,11 @@ impl<'a> Parser<'a> {
             if !self.eat(&token::COMMA) { break; }
         }
         self.expect(&token::RBRACE);
-        if have_disr && !all_nullary {
-            self.fatal("discriminator values can only be used with a c-like \
-                        enum");
+        match any_disr {
+            Some(disr_span) if !all_nullary =>
+                self.span_err(disr_span,
+                    "discriminator values can only be used with a c-like enum"),
+            _ => ()
         }
 
         ast::EnumDef { variants: variants }

branches/dist-snap/src/test/compile-fail/attr-before-eof.rs

@@ -0,0 +1,11 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[deriving(Show)] //~ERROR expected item after attributes

branches/dist-snap/src/test/compile-fail/doc-before-attr.rs

@@ -0,0 +1,12 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/// hi
+#[deriving(Show)] //~ERROR expected item after attributes

branches/dist-snap/src/test/compile-fail/doc-before-eof.rs

@@ -0,0 +1,11 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+/// hi //~ERROR expected item after doc comment

branches/dist-snap/src/test/compile-fail/doc-before-extern-rbrace.rs

@@ -0,0 +1,14 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+extern {
+    /// hi
+}
+//~^^ ERROR expected item after doc comment

branches/dist-snap/src/test/compile-fail/doc-before-macro.rs

@@ -0,0 +1,15 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    /// hi
+    println!("hi");
+    //~^^ ERROR expected item after doc comment
+}

branches/dist-snap/src/test/compile-fail/doc-before-rbrace.rs

@@ -0,0 +1,14 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    println!("Hi"); /// hi
+    //~^ ERROR expected item after doc comment
+}

branches/dist-snap/src/test/compile-fail/doc-before-semi.rs

@@ -0,0 +1,15 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    /// hi
+    ;
+    //~^^ ERROR expected item after doc comment
+}

branches/dist-snap/src/test/compile-fail/issue-11154.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// compile-flags: -Z lto -C prefer-dynamic
+// compile-flags: -C lto -C prefer-dynamic
 
 // error-pattern: cannot prefer dynamic linking
 

branches/dist-snap/src/test/compile-fail/issue-17383.rs

@@ -0,0 +1,18 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+enum X {
+    A =
+        b'a' //~ ERROR discriminator values can only be used with a c-like enum
+    ,
+    B(int)
+}
+
+fn main() {}

branches/dist-snap/src/test/debuginfo/cross-crate-type-uniquing.rs

@@ -14,7 +14,7 @@
 extern crate cross_crate_debuginfo_type_uniquing;
 
 // no-prefer-dynamic
-// compile-flags:-g -Zlto
+// compile-flags:-g -C lto
 
 pub struct C;
 pub fn p() -> C {

branches/dist-snap/src/test/debuginfo/gdb-pretty-struct-and-enums-pre-gdb-7-7.rs

@@ -12,6 +12,7 @@
 // older versions of GDB too. A more extensive test can be found in
 // gdb-pretty-struct-and-enums.rs
 
+// ignore-windows failing on win32 bot
 // ignore-tidy-linelength
 // ignore-lldb
 // ignore-android: FIXME(#10381)