---

yaml
---
r: 229105
b: refs/heads/try
c: 6beaeda
h: refs/heads/master
i:
  229103: c9a0123
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: aca2057ed5fb7af3f8905b2bc01f72fa001c35c8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 6109d0567d5b72c70762e5bac00497ed30adf1b9
+refs/heads/try: 6beaedaa5f9e93e0f6a1eafb485db1fd26a0e210
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/src/doc/tarpl/repr-rust.md

@@ -31,8 +31,8 @@ type's size is a multiple of its alignment. For instance:
 ```rust
 struct A {
     a: u8,
-    c: u32,
-    b: u16,
+    b: u32,
+    c: u16,
 }
 ```
 

branches/try/src/liblibc/lib.rs

@@ -1002,7 +1002,7 @@ pub mod types {
             }
             pub mod posix01 {
                 use types::common::c95::{c_void};
-                use types::common::c99::{uint8_t, uint32_t, int32_t};
+                use types::common::c99::{uint32_t, int32_t};
                 use types::os::arch::c95::{c_long, time_t};
                 use types::os::arch::posix88::{dev_t, gid_t, ino_t};
                 use types::os::arch::posix88::{mode_t, off_t};
@@ -1096,7 +1096,7 @@ pub mod types {
             }
             pub mod posix01 {
                 use types::common::c95::{c_void};
-                use types::common::c99::{uint8_t, uint32_t, int32_t};
+                use types::common::c99::{uint32_t, int32_t};
                 use types::os::arch::c95::{c_long, time_t};
                 use types::os::arch::posix88::{dev_t, gid_t, ino_t};
                 use types::os::arch::posix88::{mode_t, off_t};

branches/try/src/librustc_trans/back/msvc/mod.rs

@@ -206,7 +206,7 @@ pub fn link_exe_cmd(sess: &Session) -> Command {
         return max_key
     }
 
-    fn get_windows_sdk_path() -> Option<(PathBuf, usize)> {
+    fn get_windows_sdk_path() -> Option<(PathBuf, usize, Option<OsString>)> {
         let key = r"SOFTWARE\Microsoft\Microsoft SDKs\Windows";
         let key = LOCAL_MACHINE.open(key.as_ref());
         let (n, k) = match key.ok().as_ref().and_then(max_version) {
@@ -217,28 +217,29 @@ pub fn link_exe_cmd(sess: &Session) -> Command {
         let major = parts.next().unwrap().parse::<usize>().unwrap();
         let _minor = parts.next().unwrap().parse::<usize>().unwrap();
         k.query_str("InstallationFolder").ok().map(|folder| {
-            (PathBuf::from(folder), major)
+            let ver = k.query_str("ProductVersion");
+            (PathBuf::from(folder), major, ver.ok())
         })
     }
 
     fn get_windows_sdk_lib_path(sess: &Session) -> Option<PathBuf> {
-        let (mut path, major) = match get_windows_sdk_path() {
+        let (mut path, major, ver) = match get_windows_sdk_path() {
             Some(p) => p,
             None => return None,
         };
         path.push("Lib");
         if major <= 7 {
             // In Windows SDK 7.x, x86 libraries are directly in the Lib folder,
-            // x64 libraries are inside, and it's not necessary to link agains
+            // x64 libraries are inside, and it's not necessary to link against
             // the SDK 7.x when targeting ARM or other architectures.
             let x86 = match &sess.target.target.arch[..] {
                 "x86" => true,
                 "x86_64" => false,
                 _ => return None,
             };
             Some(if x86 {path} else {path.join("x64")})
-        } else {
-            // Windows SDK 8.x installes libraries in a folder whose names
+        } else if major <= 8 {
+            // Windows SDK 8.x installs libraries in a folder whose names
             // depend on the version of the OS you're targeting. By default
             // choose the newest, which usually corresponds to the version of
             // the OS you've installed the SDK on.
@@ -251,7 +252,25 @@ pub fn link_exe_cmd(sess: &Session) -> Command {
             }).map(|path| {
                 path.join("um").join(extra)
             })
-        }
+        } else if let Some(mut ver) = ver {
+            // Windows SDK 10 splits the libraries into architectures the same
+            // as Windows SDK 8.x, except for the addition of arm64.
+            // Additionally, the SDK 10 is split by Windows 10 build numbers
+            // rather than the OS version like the SDK 8.x does.
+            let extra = match windows_sdk_v10_subdir(sess) {
+                Some(e) => e,
+                None => return None,
+            };
+            // To get the correct directory we need to get the Windows SDK 10
+            // version, and so far it looks like the "ProductVersion" of the SDK
+            // corresponds to the folder name that the libraries are located in
+            // except that the folder contains an extra ".0". For now just
+            // append a ".0" to look for find the directory we're in. This logic
+            // will likely want to be refactored one day.
+            ver.push(".0");
+            let p = path.join(ver).join("um").join(extra);
+            fs::metadata(&p).ok().map(|_| p)
+        } else { None }
     }
 
     fn windows_sdk_v8_subdir(sess: &Session) -> Option<&'static str> {
@@ -263,6 +282,16 @@ pub fn link_exe_cmd(sess: &Session) -> Command {
         }
     }
 
+    fn windows_sdk_v10_subdir(sess: &Session) -> Option<&'static str> {
+        match &sess.target.target.arch[..] {
+            "x86" => Some("x86"),
+            "x86_64" => Some("x64"),
+            "arm" => Some("arm"),
+            "aarch64" => Some("arm64"), // FIXME - Check if aarch64 is correct
+            _ => return None,
+        }
+    }
+
     fn ucrt_install_dir(vs_install_dir: &Path) -> Option<(PathBuf, String)> {
         let is_vs_14 = vs_install_dir.iter().filter_map(|p| p.to_str()).any(|s| {
             s == "Microsoft Visual Studio 14.0"

branches/try/src/libsyntax/parse/parser.rs

@@ -4610,7 +4610,7 @@ impl<'a> Parser<'a> {
             None
         };
 
-        if try!(self.eat(&token::DotDot) ){
+        if opt_trait.is_some() && try!(self.eat(&token::DotDot) ){
             if generics.is_parameterized() {
                 self.span_err(impl_span, "default trait implementations are not \
                                           allowed to have generics");

branches/try/src/test/parse-fail/empty-impl-semicolon.rs

@@ -10,4 +10,4 @@
 
 // compile-flags: -Z parse-only
 
-impl Foo; //~ ERROR expected one of `(`, `+`, `..`, `::`, `<`, `for`, `where`, or `{`, found `;`
+impl Foo; //~ ERROR expected one of `(`, `+`, `::`, `<`, `for`, `where`, or `{`, found `;`

branches/try/src/test/parse-fail/issue-27255.rs

@@ -0,0 +1,15 @@
+// Copyright 2015 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.
+
+// compile-flags: -Z parse-only
+
+impl A .. {} //~ ERROR
+
+fn main() {}

branches/try/src/test/parse-fail/multitrait.rs

@@ -15,7 +15,7 @@ struct S {
 }
 
 impl Cmp, ToString for S {
-//~^ ERROR: expected one of `(`, `+`, `..`, `::`, `<`, `for`, `where`, or `{`, found `,`
+//~^ ERROR: expected one of `(`, `+`, `::`, `<`, `for`, `where`, or `{`, found `,`
   fn eq(&&other: S) { false }
   fn to_string(&self) -> String { "hi".to_string() }
 }

branches/try/src/test/parse-fail/trait-bounds-not-on-impl.rs

@@ -17,7 +17,7 @@ struct Bar;
 
 impl Foo + Owned for Bar {
 //~^ ERROR not a trait
-//~^^ ERROR expected one of `..`, `where`, or `{`, found `Bar`
+//~^^ ERROR expected one of `where` or `{`, found `Bar`
 }
 
 fn main() { }