---

yaml
---
r: 274794
b: refs/heads/stable
c: 98ec51a
h: refs/heads/master

Author: bors

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: c0221c8897db309a79990367476177b1230bb264
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: a17fb64fcecdc42c5e25dd1745e517db881f14e1
+refs/heads/stable: 98ec51a4ddc5519f809d667e7dbbf636d59ab653
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/compiletest/runtest.rs

@@ -1229,11 +1229,13 @@ fn compose_and_run_compiler(config: &Config, props: &TestProps,
             // for the test suite (otherwise including libstd statically in all
             // executables takes up quite a bit of space).
             //
-            // For targets like MUSL, however, there is no support for dynamic
-            // libraries so we just go back to building a normal library. Note,
-            // however, that if the library is built with `force_host` then it's
-            // ok to be a dylib as the host should always support dylibs.
-            if config.target.contains("musl") && !aux_props.force_host {
+            // For targets like MUSL or Emscripten, however, there is no support for
+            // dynamic libraries so we just go back to building a normal library. Note,
+            // however, that for MUSL if the library is built with `force_host` then
+            // it's ok to be a dylib as the host should always support dylibs.
+            if (config.target.contains("musl") && !aux_props.force_host) ||
+                config.target.contains("emscripten")
+            {
                 vec!("--crate-type=lib".to_owned())
             } else {
                 vec!("--crate-type=dylib".to_owned())

branches/stable/src/liballoc/arc.rs

@@ -879,7 +879,7 @@ impl<T: ?Sized + fmt::Debug> fmt::Debug for Arc<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> fmt::Pointer for Arc<T> {
+impl<T: ?Sized> fmt::Pointer for Arc<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Pointer::fmt(&*self._ptr, f)
     }

branches/stable/src/liballoc/boxed.rs

@@ -442,7 +442,7 @@ impl<T: fmt::Debug + ?Sized> fmt::Debug for Box<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> fmt::Pointer for Box<T> {
+impl<T: ?Sized> fmt::Pointer for Box<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // It's not possible to extract the inner Uniq directly from the Box,
         // instead we cast it to a *const which aliases the Unique

branches/stable/src/liballoc/rc.rs

@@ -688,7 +688,7 @@ impl<T: ?Sized + fmt::Debug> fmt::Debug for Rc<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> fmt::Pointer for Rc<T> {
+impl<T: ?Sized> fmt::Pointer for Rc<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Pointer::fmt(&*self._ptr, f)
     }

branches/stable/src/liballoc_jemalloc/lib.rs

@@ -56,8 +56,7 @@ const MIN_ALIGN: usize = 8;
 #[cfg(all(any(target_arch = "x86",
               target_arch = "x86_64",
               target_arch = "aarch64",
-              target_arch = "powerpc64",
-              target_arch = "powerpc64le")))]
+              target_arch = "powerpc64")))]
 const MIN_ALIGN: usize = 16;
 
 // MALLOCX_ALIGN(a) macro

branches/stable/src/libcore/fmt/mod.rs

@@ -1384,7 +1384,7 @@ impl Display for char {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Pointer for *const T {
+impl<T: ?Sized> Pointer for *const T {
     fn fmt(&self, f: &mut Formatter) -> Result {
         let old_width = f.width;
         let old_flags = f.flags;
@@ -1402,7 +1402,7 @@ impl<T> Pointer for *const T {
         }
         f.flags |= 1 << (FlagV1::Alternate as u32);
 
-        let ret = LowerHex::fmt(&(*self as usize), f);
+        let ret = LowerHex::fmt(&(*self as *const () as usize), f);
 
         f.width = old_width;
         f.flags = old_flags;
@@ -1412,21 +1412,21 @@ impl<T> Pointer for *const T {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Pointer for *mut T {
+impl<T: ?Sized> Pointer for *mut T {
     fn fmt(&self, f: &mut Formatter) -> Result {
         Pointer::fmt(&(*self as *const T), f)
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Pointer for &'a T {
+impl<'a, T: ?Sized> Pointer for &'a T {
     fn fmt(&self, f: &mut Formatter) -> Result {
         Pointer::fmt(&(*self as *const T), f)
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Pointer for &'a mut T {
+impl<'a, T: ?Sized> Pointer for &'a mut T {
     fn fmt(&self, f: &mut Formatter) -> Result {
         Pointer::fmt(&(&**self as *const T), f)
     }

branches/stable/src/libcoretest/fmt/mod.rs

@@ -20,3 +20,11 @@ fn test_format_flags() {
 
     assert_eq!(format!("{: >3}", 'a'), "  a");
 }
+
+#[test]
+fn test_pointer_formats_data_pointer() {
+    let b: &[u8] = b"";
+    let s: &str = "";
+    assert_eq!(format!("{:p}", s), format!("{:p}", s.as_ptr()));
+    assert_eq!(format!("{:p}", b), format!("{:p}", b.as_ptr()));
+}

branches/stable/src/librustc/front/check_attr.rs

@@ -26,9 +26,9 @@ enum Target {
 impl Target {
     fn from_item(item: &ast::Item) -> Target {
         match item.node {
-            ast::ItemFn(..) => Target::Fn,
-            ast::ItemStruct(..) => Target::Struct,
-            ast::ItemEnum(..) => Target::Enum,
+            ast::ItemKind::Fn(..) => Target::Fn,
+            ast::ItemKind::Struct(..) => Target::Struct,
+            ast::ItemKind::Enum(..) => Target::Enum,
             _ => Target::Other,
         }
     }

branches/stable/src/librustc/front/map/mod.rs

@@ -20,7 +20,7 @@ use middle::cstore::InlinedItem;
 use middle::cstore::InlinedItem as II;
 use middle::def_id::DefId;
 
-use syntax::abi;
+use syntax::abi::Abi;
 use syntax::ast::{self, Name, NodeId, DUMMY_NODE_ID};
 use syntax::codemap::{Span, Spanned};
 use syntax::parse::token;
@@ -512,7 +512,7 @@ impl<'ast> Map<'ast> {
         }
     }
 
-    pub fn get_foreign_abi(&self, id: NodeId) -> abi::Abi {
+    pub fn get_foreign_abi(&self, id: NodeId) -> Abi {
         let parent = self.get_parent(id);
         let abi = match self.find_entry(parent) {
             Some(EntryItem(_, i)) => {
@@ -522,7 +522,7 @@ impl<'ast> Map<'ast> {
                 }
             }
             /// Wrong but OK, because the only inlined foreign items are intrinsics.
-            Some(RootInlinedParent(_)) => Some(abi::RustIntrinsic),
+            Some(RootInlinedParent(_)) => Some(Abi::RustIntrinsic),
             _ => None
         };
         match abi {

branches/stable/src/librustc/lint/context.rs

@@ -374,7 +374,7 @@ pub fn gather_attr(attr: &ast::Attribute)
 
     let meta = &attr.node.value;
     let metas = match meta.node {
-        ast::MetaList(_, ref metas) => metas,
+        ast::MetaItemKind::List(_, ref metas) => metas,
         _ => {
             out.push(Err(meta.span));
             return out;
@@ -383,7 +383,7 @@ pub fn gather_attr(attr: &ast::Attribute)
 
     for meta in metas {
         out.push(match meta.node {
-            ast::MetaWord(ref lint_name) => Ok((lint_name.clone(), level, meta.span)),
+            ast::MetaItemKind::Word(ref lint_name) => Ok((lint_name.clone(), level, meta.span)),
             _ => Err(meta.span),
         });
     }

branches/stable/src/librustc/middle/check_match.rs

@@ -421,7 +421,7 @@ fn check_exhaustive(cx: &MatchCheckCtxt, sp: Span, matrix: &Matrix, source: hir:
 
 fn const_val_to_expr(value: &ConstVal) -> P<hir::Expr> {
     let node = match value {
-        &ConstVal::Bool(b) => ast::LitBool(b),
+        &ConstVal::Bool(b) => ast::LitKind::Bool(b),
         _ => unreachable!()
     };
     P(hir::Expr {

branches/stable/src/librustc/middle/const_eval.rs

@@ -545,34 +545,34 @@ pub enum UintTy { U8, U16, U32, U64 }
 
 impl IntTy {
     pub fn from(tcx: &ty::ctxt, t: ast::IntTy) -> IntTy {
-        let t = if let ast::TyIs = t {
+        let t = if let ast::IntTy::Is = t {
             tcx.sess.target.int_type
         } else {
             t
         };
         match t {
-            ast::TyIs => unreachable!(),
-            ast::TyI8  => IntTy::I8,
-            ast::TyI16 => IntTy::I16,
-            ast::TyI32 => IntTy::I32,
-            ast::TyI64 => IntTy::I64,
+            ast::IntTy::Is => unreachable!(),
+            ast::IntTy::I8  => IntTy::I8,
+            ast::IntTy::I16 => IntTy::I16,
+            ast::IntTy::I32 => IntTy::I32,
+            ast::IntTy::I64 => IntTy::I64,
         }
     }
 }
 
 impl UintTy {
     pub fn from(tcx: &ty::ctxt, t: ast::UintTy) -> UintTy {
-        let t = if let ast::TyUs = t {
+        let t = if let ast::UintTy::Us = t {
             tcx.sess.target.uint_type
         } else {
             t
         };
         match t {
-            ast::TyUs => unreachable!(),
-            ast::TyU8  => UintTy::U8,
-            ast::TyU16 => UintTy::U16,
-            ast::TyU32 => UintTy::U32,
-            ast::TyU64 => UintTy::U64,
+            ast::UintTy::Us => unreachable!(),
+            ast::UintTy::U8  => UintTy::U8,
+            ast::UintTy::U16 => UintTy::U16,
+            ast::UintTy::U32 => UintTy::U32,
+            ast::UintTy::U64 => UintTy::U64,
         }
     }
 }
@@ -1289,65 +1289,63 @@ fn cast_const<'tcx>(tcx: &ty::ctxt<'tcx>, val: ConstVal, ty: Ty) -> CastResult {
 
     // Issue #23890: If isize/usize, then dispatch to appropriate target representation type
     match (&ty.sty, tcx.sess.target.int_type, tcx.sess.target.uint_type) {
-        (&ty::TyInt(ast::TyIs), ast::TyI32, _) => return convert_val!(i32, Int, i64),
-        (&ty::TyInt(ast::TyIs), ast::TyI64, _) => return convert_val!(i64, Int, i64),
-        (&ty::TyInt(ast::TyIs), _, _) => panic!("unexpected target.int_type"),
+        (&ty::TyInt(ast::IntTy::Is), ast::IntTy::I32, _) => return convert_val!(i32, Int, i64),
+        (&ty::TyInt(ast::IntTy::Is), ast::IntTy::I64, _) => return convert_val!(i64, Int, i64),
+        (&ty::TyInt(ast::IntTy::Is), _, _) => panic!("unexpected target.int_type"),
 
-        (&ty::TyUint(ast::TyUs), _, ast::TyU32) => return convert_val!(u32, Uint, u64),
-        (&ty::TyUint(ast::TyUs), _, ast::TyU64) => return convert_val!(u64, Uint, u64),
-        (&ty::TyUint(ast::TyUs), _, _) => panic!("unexpected target.uint_type"),
+        (&ty::TyUint(ast::UintTy::Us), _, ast::UintTy::U32) => return convert_val!(u32, Uint, u64),
+        (&ty::TyUint(ast::UintTy::Us), _, ast::UintTy::U64) => return convert_val!(u64, Uint, u64),
+        (&ty::TyUint(ast::UintTy::Us), _, _) => panic!("unexpected target.uint_type"),
 
         _ => {}
     }
 
     match ty.sty {
-        ty::TyInt(ast::TyIs) => unreachable!(),
-        ty::TyUint(ast::TyUs) => unreachable!(),
+        ty::TyInt(ast::IntTy::Is) => unreachable!(),
+        ty::TyUint(ast::UintTy::Us) => unreachable!(),
 
-        ty::TyInt(ast::TyI8) => convert_val!(i8, Int, i64),
-        ty::TyInt(ast::TyI16) => convert_val!(i16, Int, i64),
-        ty::TyInt(ast::TyI32) => convert_val!(i32, Int, i64),
-        ty::TyInt(ast::TyI64) => convert_val!(i64, Int, i64),
+        ty::TyInt(ast::IntTy::I8) => convert_val!(i8, Int, i64),
+        ty::TyInt(ast::IntTy::I16) => convert_val!(i16, Int, i64),
+        ty::TyInt(ast::IntTy::I32) => convert_val!(i32, Int, i64),
+        ty::TyInt(ast::IntTy::I64) => convert_val!(i64, Int, i64),
 
-        ty::TyUint(ast::TyU8) => convert_val!(u8, Uint, u64),
-        ty::TyUint(ast::TyU16) => convert_val!(u16, Uint, u64),
-        ty::TyUint(ast::TyU32) => convert_val!(u32, Uint, u64),
-        ty::TyUint(ast::TyU64) => convert_val!(u64, Uint, u64),
+        ty::TyUint(ast::UintTy::U8) => convert_val!(u8, Uint, u64),
+        ty::TyUint(ast::UintTy::U16) => convert_val!(u16, Uint, u64),
+        ty::TyUint(ast::UintTy::U32) => convert_val!(u32, Uint, u64),
+        ty::TyUint(ast::UintTy::U64) => convert_val!(u64, Uint, u64),
 
-        ty::TyFloat(ast::TyF32) => convert_val!(f32, Float, f64),
-        ty::TyFloat(ast::TyF64) => convert_val!(f64, Float, f64),
+        ty::TyFloat(ast::FloatTy::F32) => convert_val!(f32, Float, f64),
+        ty::TyFloat(ast::FloatTy::F64) => convert_val!(f64, Float, f64),
         _ => Err(ErrKind::CannotCast),
     }
 }
 
 fn lit_to_const(sess: &Session, span: Span, lit: &ast::Lit, ty_hint: Option<Ty>) -> ConstVal {
     match lit.node {
-        ast::LitStr(ref s, _) => Str((*s).clone()),
-        ast::LitByteStr(ref data) => {
+        ast::LitKind::Str(ref s, _) => Str((*s).clone()),
+        ast::LitKind::ByteStr(ref data) => {
             ByteStr(data.clone())
         }
-        ast::LitByte(n) => Uint(n as u64),
-        ast::LitChar(n) => Uint(n as u64),
-        ast::LitInt(n, ast::SignedIntLit(_, ast::Plus)) => Int(n as i64),
-        ast::LitInt(n, ast::UnsuffixedIntLit(ast::Plus)) => {
+        ast::LitKind::Byte(n) => Uint(n as u64),
+        ast::LitKind::Char(n) => Uint(n as u64),
+        ast::LitKind::Int(n, ast::LitIntType::Signed(_)) => Int(n as i64),
+        ast::LitKind::Int(n, ast::LitIntType::Unsuffixed) => {
             match ty_hint.map(|ty| &ty.sty) {
                 Some(&ty::TyUint(_)) => Uint(n),
                 _ => Int(n as i64)
             }
         }
-        ast::LitInt(n, ast::SignedIntLit(_, ast::Minus)) |
-        ast::LitInt(n, ast::UnsuffixedIntLit(ast::Minus)) => Int(-(n as i64)),
-        ast::LitInt(n, ast::UnsignedIntLit(_)) => Uint(n),
-        ast::LitFloat(ref n, _) |
-        ast::LitFloatUnsuffixed(ref n) => {
+        ast::LitKind::Int(n, ast::LitIntType::Unsigned(_)) => Uint(n),
+        ast::LitKind::Float(ref n, _) |
+        ast::LitKind::FloatUnsuffixed(ref n) => {
             if let Ok(x) = n.parse::<f64>() {
                 Float(x)
             } else {
                 // FIXME(#31407) this is only necessary because float parsing is buggy
                 sess.span_bug(span, "could not evaluate float literal (see issue #31407)");
             }
         }
-        ast::LitBool(b) => Bool(b)
+        ast::LitKind::Bool(b) => Bool(b)
     }
 }
 

branches/stable/src/librustc/middle/intrinsicck.rs

@@ -17,7 +17,7 @@ use middle::ty::{self, Ty, TypeFoldable};
 
 use std::fmt;
 
-use syntax::abi::RustIntrinsic;
+use syntax::abi::Abi::RustIntrinsic;
 use syntax::ast;
 use syntax::codemap::Span;
 use rustc_front::intravisit::{self, Visitor, FnKind};

branches/stable/src/librustc/middle/reachable.rs

@@ -25,7 +25,7 @@ use session::config;
 use util::nodemap::NodeSet;
 
 use std::collections::HashSet;
-use syntax::abi;
+use syntax::abi::Abi;
 use syntax::ast;
 use syntax::attr;
 use rustc_front::hir;
@@ -236,7 +236,7 @@ impl<'a, 'tcx> ReachableContext<'a, 'tcx> {
             // participate in linkage after this product is produced)
             if let ast_map::NodeItem(item) = *node {
                 if let hir::ItemFn(_, _, _, abi, _, _) = item.node {
-                    if abi != abi::Rust {
+                    if abi != Abi::Rust {
                         self.reachable_symbols.insert(search_item);
                     }
                 }

branches/stable/src/librustc/middle/traits/select.rs

@@ -46,7 +46,7 @@ use middle::ty::relate::TypeRelation;
 use std::cell::RefCell;
 use std::fmt;
 use std::rc::Rc;
-use syntax::abi;
+use syntax::abi::Abi;
 use rustc_front::hir;
 use util::common::ErrorReported;
 use util::nodemap::FnvHashMap;
@@ -1288,7 +1288,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             // provide an impl, but only for suitable `fn` pointers
             ty::TyBareFn(_, &ty::BareFnTy {
                 unsafety: hir::Unsafety::Normal,
-                abi: abi::Rust,
+                abi: Abi::Rust,
                 sig: ty::Binder(ty::FnSig {
                     inputs: _,
                     output: ty::FnConverging(_),

branches/stable/src/librustc/middle/ty/contents.rs

@@ -180,7 +180,7 @@ impl<'tcx> ty::TyS<'tcx> {
 
             let result = match ty.sty {
                 // usize and isize are ffi-unsafe
-                ty::TyUint(ast::TyUs) | ty::TyInt(ast::TyIs) => {
+                ty::TyUint(ast::UintTy::Us) | ty::TyInt(ast::IntTy::Is) => {
                     TC::None
                 }