---

yaml
---
r: 136571
b: refs/heads/dist-snap
c: b11c572
h: refs/heads/master
i:
  136569: 9ee3d80
  136567: 622ab3c
v: v3

Author: vadimcn

[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: 8d3728fae0fa1979349836be112562aa6d455e76
+refs/heads/dist-snap: b11c5722f84879db3539e84d8d21c4c758165163
 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 to platform-specific bin directory
-    target_bin_dir = os.path.join(dist_root, "bin", "rustlib", target_triple, "gcc", "bin")
+    # 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")
     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, "gcc", "lib")
+    target_lib_dir = os.path.join(dist_root, "bin", "rustlib", target_triple, "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,6 +180,7 @@ debugging_opts!(
         GC,
         PRINT_LINK_ARGS,
         PRINT_LLVM_PASSES,
+        LTO,
         AST_JSON,
         AST_JSON_NOEXPAND,
         LS,
@@ -218,6 +219,7 @@ 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),
@@ -351,8 +353,6 @@ 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 = sess.host_filesearch().get_tools_search_paths();
-    new_path.push_all_move(os::split_paths(old_path.as_slice()));
+    let mut new_path = os::split_paths(old_path.as_slice());
+    new_path.push_all_move(sess.host_filesearch().get_tools_search_paths());
     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.opts.cg.lto
+        self.debugging_opt(config::LTO)
     }
     pub fn no_landing_pads(&self) -> bool {
         self.debugging_opt(config::NO_LANDING_PADS)

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

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

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

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

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

@@ -3480,32 +3480,22 @@ 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, attrs: &[Attribute]) {
+        fn check_expected_item(p: &mut Parser, found_attrs: bool) {
             // If we have attributes then we should have an item
-            if !attrs.is_empty() {
+            if found_attrs {
                 let last_span = p.last_span;
-                p.span_err(last_span, Parser::expected_item_err(attrs));
+                p.span_err(last_span, "expected item after attributes");
             }
         }
 
         let lo = self.span.lo;
         if self.is_keyword(keywords::Let) {
-            check_expected_item(self, item_attrs.as_slice());
+            check_expected_item(self, !item_attrs.is_empty());
             self.expect_keyword(keywords::Let);
             let decl = self.parse_let();
             P(spanned(lo, decl.span.hi, StmtDecl(decl, ast::DUMMY_NODE_ID)))
@@ -3514,7 +3504,7 @@ impl<'a> Parser<'a> {
             && self.look_ahead(1, |t| *t == token::NOT) {
             // it's a macro invocation:
 
-            check_expected_item(self, item_attrs.as_slice());
+            check_expected_item(self, !item_attrs.is_empty());
 
             // Potential trouble: if we allow macros with paths instead of
             // idents, we'd need to look ahead past the whole path here...
@@ -3571,7 +3561,6 @@ 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;
@@ -3586,10 +3575,7 @@ impl<'a> Parser<'a> {
                     self.fatal("foreign items are not allowed here");
                 }
                 IoviNone(_) => {
-                    if found_attrs {
-                        let last_span = self.last_span;
-                        self.span_err(last_span, item_err);
-                    }
+                    check_expected_item(self, found_attrs);
 
                     // Remainder are line-expr stmts.
                     let e = self.parse_expr_res(RestrictionStmtExpr);
@@ -3667,8 +3653,7 @@ impl<'a> Parser<'a> {
                 token::SEMI => {
                     if !attributes_box.is_empty() {
                         let last_span = self.last_span;
-                        self.span_err(last_span,
-                                      Parser::expected_item_err(attributes_box.as_slice()));
+                        self.span_err(last_span, "expected item after attributes");
                         attributes_box = Vec::new();
                     }
                     self.bump(); // empty
@@ -3754,8 +3739,7 @@ impl<'a> Parser<'a> {
 
         if !attributes_box.is_empty() {
             let last_span = self.last_span;
-            self.span_err(last_span,
-                          Parser::expected_item_err(attributes_box.as_slice()));
+            self.span_err(last_span, "expected item after attributes");
         }
 
         let hi = self.span.hi;
@@ -4701,8 +4685,7 @@ 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,
-                          Parser::expected_item_err(attrs_remaining.as_slice()));
+            self.span_err(last_span, "expected item after attributes");
         }
 
         ast::Mod {
@@ -4936,10 +4919,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,
-                          Parser::expected_item_err(attrs_remaining.as_slice()));
+                          "expected item after attributes");
         }
         assert!(self.token == token::RBRACE);
         ast::ForeignMod {
@@ -5069,7 +5052,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 any_disr = None;
+        let mut have_disr = false;
         while self.token != token::RBRACE {
             let variant_attrs = self.parse_outer_attributes();
             let vlo = self.span.lo;
@@ -5101,8 +5084,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());
@@ -5121,11 +5104,9 @@ impl<'a> Parser<'a> {
             if !self.eat(&token::COMMA) { break; }
         }
         self.expect(&token::RBRACE);
-        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"),
-            _ => ()
+        if have_disr && !all_nullary {
+            self.fatal("discriminator values can only be used with a c-like \
+                        enum");
         }
 
         ast::EnumDef { variants: variants }

branches/dist-snap/src/libterm/win.rs

@@ -23,15 +23,29 @@ use Terminal;
 /// A Terminal implementation which uses the Win32 Console API.
 pub struct WinConsole<T> {
     buf: T,
+    def_foreground: color::Color,
+    def_background: color::Color,
     foreground: color::Color,
     background: color::Color,
 }
 
+#[allow(non_snake_case)]
+#[repr(C)]
+struct CONSOLE_SCREEN_BUFFER_INFO {
+    dwSize: [libc::c_short, ..2],
+    dwCursorPosition: [libc::c_short, ..2],
+    wAttributes: libc::WORD,
+    srWindow: [libc::c_short, ..4],
+    dwMaximumWindowSize: [libc::c_short, ..2],
+}
+
 #[allow(non_snake_case)]
 #[link(name = "kernel32")]
 extern "system" {
     fn SetConsoleTextAttribute(handle: libc::HANDLE, attr: libc::WORD) -> libc::BOOL;
     fn GetStdHandle(which: libc::DWORD) -> libc::HANDLE;
+    fn GetConsoleScreenBufferInfo(handle: libc::HANDLE,
+                                  info: *mut CONSOLE_SCREEN_BUFFER_INFO) -> libc::BOOL;
 }
 
 fn color_to_bits(color: color::Color) -> u16 {
@@ -56,6 +70,26 @@ fn color_to_bits(color: color::Color) -> u16 {
     }
 }
 
+fn bits_to_color(bits: u16) -> color::Color {
+    let color = match bits & 0x7 {
+        0 => color::BLACK,
+        0x1 => color::BLUE,
+        0x2 => color::GREEN,
+        0x4 => color::RED,
+        0x6 => color::YELLOW,
+        0x5 => color::MAGENTA,
+        0x3 => color::CYAN,
+        0x7 => color::WHITE,
+        _ => unreachable!()
+    };
+
+    if bits >= 8 {
+        color | 0x8
+    } else {
+        color
+    }
+}
+
 impl<T: Writer> WinConsole<T> {
     fn apply(&mut self) {
         let _unused = self.buf.flush();
@@ -91,7 +125,21 @@ impl<T: Writer> Writer for WinConsole<T> {
 
 impl<T: Writer> Terminal<T> for WinConsole<T> {
     fn new(out: T) -> Option<WinConsole<T>> {
-        Some(WinConsole { buf: out, foreground: color::WHITE, background: color::BLACK })
+        let fg;
+        let bg;
+        unsafe {
+            let mut buffer_info = ::std::mem::uninitialized();
+            if GetConsoleScreenBufferInfo(GetStdHandle(-11), &mut buffer_info) != 0 {
+                fg = bits_to_color(buffer_info.wAttributes);
+                bg = bits_to_color(buffer_info.wAttributes >> 4);
+            } else {
+                fg = color::WHITE;
+                bg = color::BLACK;
+            }
+        }
+        Some(WinConsole { buf: out,
+                          def_foreground: fg, def_background: bg,
+                          foreground: fg, background: bg } )
     }
 
     fn fg(&mut self, color: color::Color) -> IoResult<bool> {
@@ -134,8 +182,8 @@ impl<T: Writer> Terminal<T> for WinConsole<T> {
     }
 
     fn reset(&mut self) -> IoResult<()> {
-        self.foreground = color::WHITE;
-        self.background = color::BLACK;
+        self.foreground = self.def_foreground;
+        self.background = self.def_background;
         self.apply();
 
         Ok(())