Rollup merge of #56749 - alexcrichton:adx, r=gnzlbg
x86: Add the `adx` target feature to whitelist
Requested in rust-lang-nursery/stdsimd#322 this is hopefully the first
step!
diff --git a/src/bootstrap/builder.rs b/src/bootstrap/builder.rs
index 7dc64db..32f3e57 100644
--- a/src/bootstrap/builder.rs
+++ b/src/bootstrap/builder.rs
@@ -684,6 +684,11 @@
.env("RUSTDOC_REAL", self.rustdoc(host))
.env("RUSTDOC_CRATE_VERSION", self.rust_version())
.env("RUSTC_BOOTSTRAP", "1");
+
+ // Remove make-related flags that can cause jobserver problems.
+ cmd.env_remove("MAKEFLAGS");
+ cmd.env_remove("MFLAGS");
+
if let Some(linker) = self.linker(host) {
cmd.env("RUSTC_TARGET_LINKER", linker);
}
diff --git a/src/bootstrap/channel.rs b/src/bootstrap/channel.rs
index 88b6925..878b6ed 100644
--- a/src/bootstrap/channel.rs
+++ b/src/bootstrap/channel.rs
@@ -24,7 +24,7 @@
use config::Config;
// The version number
-pub const CFG_RELEASE_NUM: &str = "1.32.0";
+pub const CFG_RELEASE_NUM: &str = "1.33.0";
pub struct GitInfo {
inner: Option<Info>,
diff --git a/src/doc/rustc/src/codegen-options/index.md b/src/doc/rustc/src/codegen-options/index.md
index 4fc5f42..94f2104 100644
--- a/src/doc/rustc/src/codegen-options/index.md
+++ b/src/doc/rustc/src/codegen-options/index.md
@@ -22,6 +22,13 @@
This flag lets you append multiple extra arguments to the linker invocation. The
options should be separated by spaces.
+## linker-flavor
+
+This flag lets you control the linker flavor used by `rustc`. If a linker is given with the
+`-C linker` flag described above then the linker flavor is inferred from the value provided. If no
+linker is given then the linker flavor is used to determine the linker to use. Every `rustc` target
+defaults to some linker flavor.
+
## link-dead-code
Normally, the linker will remove dead code. This flag disables this behavior.
diff --git a/src/doc/unstable-book/src/compiler-flags/linker-flavor.md b/src/doc/unstable-book/src/compiler-flags/linker-flavor.md
deleted file mode 100644
index 3965960..0000000
--- a/src/doc/unstable-book/src/compiler-flags/linker-flavor.md
+++ /dev/null
@@ -1,61 +0,0 @@
-# `linker-flavor`
-
-The tracking issue for this feature is: None
-
-------------------------
-
-Every `rustc` target defaults to some linker. For example, Linux targets default
-to gcc. In some cases, you may want to override the default; you can do that
-with the unstable CLI argument: `-Z linker-flavor`.
-
-Here how you would use this flag to link a Rust binary for the
-`thumbv7m-none-eabi` using LLD instead of GCC.
-
-``` text
-$ xargo rustc --target thumbv7m-none-eabi -- \
- -C linker=ld.lld \
- -Z linker-flavor=ld \
- -Z print-link-args | tr ' ' '\n'
-"ld.lld"
-"-L"
-"$SYSROOT/lib/rustlib/thumbv7m-none-eabi/lib"
-"$PWD/target/thumbv7m-none-eabi/debug/deps/app-512e9dbf385f233c.0.o"
-"-o"
-"$PWD/target/thumbv7m-none-eabi/debug/deps/app-512e9dbf385f233c"
-"--gc-sections"
-"-L"
-"$PWD/target/thumbv7m-none-eabi/debug/deps"
-"-L"
-"$PWD/target/debug/deps"
-"-L"
-"$SYSROOT/lib/rustlib/thumbv7m-none-eabi/lib"
-"-Bstatic"
-"$SYSROOT/lib/rustlib/thumbv7m-none-eabi/lib/libcore-e1ccb7dfb1cb9ebb.rlib"
-"-Bdynamic"
-```
-
-Whereas the default is:
-
-``` text
-$ xargo rustc --target thumbv7m-none-eabi -- \
- -C link-arg=-nostartfiles \
- -Z print-link-args | tr ' ' '\n'
-"arm-none-eabi-gcc"
-"-L"
-"$SYSROOT/lib/rustlib/thumbv7m-none-eabi/lib"
-"$PWD/target/thumbv7m-none-eabi/debug/deps/app-961e39416baa38d9.0.o"
-"-o"
-"$PWD/target/thumbv7m-none-eabi/debug/deps/app-961e39416baa38d9"
-"-Wl,--gc-sections"
-"-nodefaultlibs"
-"-L"
-"$PWD/target/thumbv7m-none-eabi/debug/deps"
-"-L"
-"$PWD/target/debug/deps"
-"-L"
-"$SYSROOT/lib/rustlib/thumbv7m-none-eabi/lib"
-"-Wl,-Bstatic"
-"$SYSROOT/lib/rustlib/thumbv7m-none-eabi/lib/libcore-e1ccb7dfb1cb9ebb.rlib"
-"-nostartfiles"
-"-Wl,-Bdynamic"
-```
diff --git a/src/liballoc/collections/vec_deque.rs b/src/liballoc/collections/vec_deque.rs
index c0adeca..0c5926f 100644
--- a/src/liballoc/collections/vec_deque.rs
+++ b/src/liballoc/collections/vec_deque.rs
@@ -1026,7 +1026,10 @@
iter: Iter {
tail: drain_tail,
head: drain_head,
- ring: unsafe { self.buffer_as_mut_slice() },
+ // Crucially, we only create shared references from `self` here and read from
+ // it. We do not write to `self` nor reborrow to a mutable reference.
+ // Hence the raw pointer we created above, for `deque`, remains valid.
+ ring: unsafe { self.buffer_as_slice() },
},
}
}
diff --git a/src/liballoc/tests/str.rs b/src/liballoc/tests/str.rs
index 683ce2b..9ad8ad1 100644
--- a/src/liballoc/tests/str.rs
+++ b/src/liballoc/tests/str.rs
@@ -1514,9 +1514,9 @@
#[test]
fn trim_ws() {
- assert_eq!(" \t a \t ".trim_left_matches(|c: char| c.is_whitespace()),
+ assert_eq!(" \t a \t ".trim_start_matches(|c: char| c.is_whitespace()),
"a \t ");
- assert_eq!(" \t a \t ".trim_right_matches(|c: char| c.is_whitespace()),
+ assert_eq!(" \t a \t ".trim_end_matches(|c: char| c.is_whitespace()),
" \t a");
assert_eq!(" \t a \t ".trim_start_matches(|c: char| c.is_whitespace()),
"a \t ");
@@ -1524,9 +1524,9 @@
" \t a");
assert_eq!(" \t a \t ".trim_matches(|c: char| c.is_whitespace()),
"a");
- assert_eq!(" \t \t ".trim_left_matches(|c: char| c.is_whitespace()),
+ assert_eq!(" \t \t ".trim_start_matches(|c: char| c.is_whitespace()),
"");
- assert_eq!(" \t \t ".trim_right_matches(|c: char| c.is_whitespace()),
+ assert_eq!(" \t \t ".trim_end_matches(|c: char| c.is_whitespace()),
"");
assert_eq!(" \t \t ".trim_start_matches(|c: char| c.is_whitespace()),
"");
diff --git a/src/libcore/ffi.rs b/src/libcore/ffi.rs
index d7a112e..899fae9 100644
--- a/src/libcore/ffi.rs
+++ b/src/libcore/ffi.rs
@@ -1,7 +1,6 @@
#![stable(feature = "", since = "1.30.0")]
#![allow(non_camel_case_types)]
-#![cfg_attr(stage0, allow(dead_code))]
//! Utilities related to FFI bindings.
@@ -123,7 +122,6 @@
all supported platforms",
issue = "27745")]
#[repr(transparent)]
-#[cfg(not(stage0))]
pub struct VaList<'a>(&'a mut VaListImpl);
// The VaArgSafe trait needs to be used in public interfaces, however, the trait
@@ -173,7 +171,6 @@
issue = "27745")]
impl<T> sealed_trait::VaArgSafe for *const T {}
-#[cfg(not(stage0))]
impl<'a> VaList<'a> {
/// Advance to the next arg.
#[unstable(feature = "c_variadic",
@@ -208,7 +205,6 @@
}
}
-#[cfg(not(stage0))]
extern "rust-intrinsic" {
/// Destroy the arglist `ap` after initialization with `va_start` or
/// `va_copy`.
diff --git a/src/libcore/intrinsics.rs b/src/libcore/intrinsics.rs
index eebb98b..b94d5b4 100644
--- a/src/libcore/intrinsics.rs
+++ b/src/libcore/intrinsics.rs
@@ -718,7 +718,6 @@
pub fn uninit<T>() -> T;
/// Moves a value out of scope without running drop glue.
- #[cfg(not(stage0))]
pub fn forget<T: ?Sized>(_: T);
/// Reinterprets the bits of a value of one type as another type.
@@ -1476,14 +1475,12 @@
/// The stabilized versions of this intrinsic are available on the integer
/// primitives via the `rotate_left` method. For example,
/// [`std::u32::rotate_left`](../../std/primitive.u32.html#method.rotate_left)
- #[cfg(not(stage0))]
pub fn rotate_left<T>(x: T, y: T) -> T;
/// Performs rotate right.
/// The stabilized versions of this intrinsic are available on the integer
/// primitives via the `rotate_right` method. For example,
/// [`std::u32::rotate_right`](../../std/primitive.u32.html#method.rotate_right)
- #[cfg(not(stage0))]
pub fn rotate_right<T>(x: T, y: T) -> T;
/// Returns (a + b) mod 2<sup>N</sup>, where N is the width of T in bits.
diff --git a/src/libcore/marker.rs b/src/libcore/marker.rs
index 0d43f92..d3d1612 100644
--- a/src/libcore/marker.rs
+++ b/src/libcore/marker.rs
@@ -640,15 +640,15 @@
#[unstable(feature = "pin", issue = "49150")]
pub auto trait Unpin {}
-/// A type which does not implement `Unpin`.
+/// A marker type which does not implement `Unpin`.
///
-/// If a type contains a `Pinned`, it will not implement `Unpin` by default.
+/// If a type contains a `PhantomPinned`, it will not implement `Unpin` by default.
#[unstable(feature = "pin", issue = "49150")]
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
-pub struct Pinned;
+pub struct PhantomPinned;
#[unstable(feature = "pin", issue = "49150")]
-impl !Unpin for Pinned {}
+impl !Unpin for PhantomPinned {}
#[unstable(feature = "pin", issue = "49150")]
impl<'a, T: ?Sized + 'a> Unpin for &'a T {}
diff --git a/src/libcore/mem.rs b/src/libcore/mem.rs
index 06754f1..afd9fcb 100644
--- a/src/libcore/mem.rs
+++ b/src/libcore/mem.rs
@@ -149,7 +149,6 @@
///
/// [`forget`]: fn.forget.html
#[inline]
-#[cfg(not(stage0))]
#[unstable(feature = "forget_unsized", issue = "0")]
pub fn forget_unsized<T: ?Sized>(t: T) {
unsafe { intrinsics::forget(t) }
diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs
index 13b4221..4acf3a1 100644
--- a/src/libcore/num/mod.rs
+++ b/src/libcore/num/mod.rs
@@ -2330,12 +2330,7 @@
#[rustc_const_unstable(feature = "const_int_rotate")]
#[inline]
pub const fn rotate_left(self, n: u32) -> Self {
- #[cfg(not(stage0))] {
- unsafe { intrinsics::rotate_left(self, n as $SelfT) }
- }
- #[cfg(stage0)] {
- (self << (n % $BITS)) | (self >> (($BITS - (n % $BITS)) % $BITS))
- }
+ unsafe { intrinsics::rotate_left(self, n as $SelfT) }
}
}
@@ -2360,12 +2355,7 @@
#[rustc_const_unstable(feature = "const_int_rotate")]
#[inline]
pub const fn rotate_right(self, n: u32) -> Self {
- #[cfg(not(stage0))] {
- unsafe { intrinsics::rotate_right(self, n as $SelfT) }
- }
- #[cfg(stage0)] {
- (self >> (n % $BITS)) | (self << (($BITS - (n % $BITS)) % $BITS))
- }
+ unsafe { intrinsics::rotate_right(self, n as $SelfT) }
}
}
diff --git a/src/libcore/ops/unsize.rs b/src/libcore/ops/unsize.rs
index 4d9a40a..e86a392 100644
--- a/src/libcore/ops/unsize.rs
+++ b/src/libcore/ops/unsize.rs
@@ -93,7 +93,7 @@
/// {}
/// ```
#[unstable(feature = "dispatch_from_dyn", issue = "0")]
-#[cfg_attr(not(stage0), lang = "dispatch_from_dyn")]
+#[lang = "dispatch_from_dyn"]
pub trait DispatchFromDyn<T> {
// Empty.
}
diff --git a/src/libcore/pin.rs b/src/libcore/pin.rs
index aa51555..0ad6e8c 100644
--- a/src/libcore/pin.rs
+++ b/src/libcore/pin.rs
@@ -7,23 +7,33 @@
//! since moving an object with pointers to itself will invalidate them,
//! which could cause undefined behavior.
//!
-//! In order to prevent objects from moving, they must be pinned
-//! by wrapping a pointer to the data in the [`Pin`] type. A pointer wrapped
-//! in a `Pin` is otherwise equivalent to its normal version, e.g., `Pin<Box<T>>`
-//! and `Box<T>` work the same way except that the first is pinning the value
-//! of `T` in place.
+//! By default, all types in Rust are movable. Rust allows passing all types by-value,
+//! and common smart-pointer types such as `Box`, `Rc`, and `&mut` allow replacing and
+//! moving the values they contain. In order to prevent objects from moving, they must
+//! be pinned by wrapping a pointer to the data in the [`Pin`] type.
+//! Doing this prohibits moving the value behind the pointer.
+//! For example, `Pin<Box<T>>` functions much like a regular `Box<T>`,
+//! but doesn't allow moving `T`. The pointer value itself (the `Box`) can still be moved,
+//! but the value behind it cannot.
//!
-//! First of all, these are pointer types because pinned data mustn't be passed around by value
-//! (that would change its location in memory).
-//! Secondly, since data can be moved out of `&mut` and `Box` with functions such as [`swap`],
-//! which causes their contents to swap places in memory,
-//! we need dedicated types that prohibit such operations.
+//! Since data can be moved out of `&mut` and `Box` with functions such as [`swap`],
+//! changing the location of the underlying data, [`Pin`] prohibits accessing the
+//! underlying pointer type (the `&mut` or `Box`) directly, and provides its own set of
+//! APIs for accessing and using the value. [`Pin`] also guarantees that no other
+//! functions will move the pointed-to value. This allows for the creation of
+//! self-references and other special behaviors that are only possible for unmovable
+//! values.
//!
-//! However, these restrictions are usually not necessary,
-//! so most types implement the [`Unpin`] auto-trait,
-//! which indicates that the type can be moved out safely.
-//! Doing so removes the limitations of pinning types,
-//! making them the same as their non-pinning counterparts.
+//! However, these restrictions are usually not necessary. Many types are always freely
+//! movable. These types implement the [`Unpin`] auto-trait, which nullifies the affect
+//! of [`Pin`]. For `T: Unpin`, `Pin<Box<T>>` and `Box<T>` function identically, as do
+//! `Pin<&mut T>` and `&mut T`.
+//!
+//! Note that pinning and `Unpin` only affect the pointed-to type. For example, whether
+//! or not `Box<T>` is `Unpin` has no affect on the behavior of `Pin<Box<T>>`. Similarly,
+//! `Pin<Box<T>>` and `Pin<&mut T>` are always `Unpin` themselves, even though the
+//! `T` underneath them isn't, because the pointers in `Pin<Box<_>>` and `Pin<&mut _>`
+//! are always freely movable, even if the data they point to isn't.
//!
//! [`Pin`]: struct.Pin.html
//! [`Unpin`]: trait.Unpin.html
@@ -36,7 +46,7 @@
//! #![feature(pin)]
//!
//! use std::pin::Pin;
-//! use std::marker::Pinned;
+//! use std::marker::PhantomPinned;
//! use std::ptr::NonNull;
//!
//! // This is a self-referential struct since the slice field points to the data field.
@@ -47,7 +57,7 @@
//! struct Unmovable {
//! data: String,
//! slice: NonNull<String>,
-//! _pin: Pinned,
+//! _pin: PhantomPinned,
//! }
//!
//! impl Unmovable {
@@ -60,7 +70,7 @@
//! // we only create the pointer once the data is in place
//! // otherwise it will have already moved before we even started
//! slice: NonNull::dangling(),
-//! _pin: Pinned,
+//! _pin: PhantomPinned,
//! };
//! let mut boxed = Box::pinned(res);
//!
diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs
index b11ae30..f61e582 100644
--- a/src/libcore/ptr.rs
+++ b/src/libcore/ptr.rs
@@ -2848,14 +2848,14 @@
#[unstable(feature = "ptr_internals", issue = "0")]
impl<'a, T: ?Sized> From<&'a mut T> for Unique<T> {
fn from(reference: &'a mut T) -> Self {
- Unique { pointer: unsafe { NonZero(reference as _) }, _marker: PhantomData }
+ Unique { pointer: unsafe { NonZero(reference as *mut T) }, _marker: PhantomData }
}
}
#[unstable(feature = "ptr_internals", issue = "0")]
impl<'a, T: ?Sized> From<&'a T> for Unique<T> {
fn from(reference: &'a T) -> Self {
- Unique { pointer: unsafe { NonZero(reference as _) }, _marker: PhantomData }
+ Unique { pointer: unsafe { NonZero(reference as *const T) }, _marker: PhantomData }
}
}
@@ -3058,7 +3058,7 @@
impl<'a, T: ?Sized> From<&'a mut T> for NonNull<T> {
#[inline]
fn from(reference: &'a mut T) -> Self {
- NonNull { pointer: unsafe { NonZero(reference as _) } }
+ NonNull { pointer: unsafe { NonZero(reference as *mut T) } }
}
}
@@ -3066,6 +3066,6 @@
impl<'a, T: ?Sized> From<&'a T> for NonNull<T> {
#[inline]
fn from(reference: &'a T) -> Self {
- NonNull { pointer: unsafe { NonZero(reference as _) } }
+ NonNull { pointer: unsafe { NonZero(reference as *const T) } }
}
}
diff --git a/src/libcore/sync/atomic.rs b/src/libcore/sync/atomic.rs
index 27eeb04..060983a 100644
--- a/src/libcore/sync/atomic.rs
+++ b/src/libcore/sync/atomic.rs
@@ -1940,7 +1940,7 @@
8,
u64 AtomicU64 ATOMIC_U64_INIT
}
-#[cfg(all(not(stage0), target_has_atomic = "128"))]
+#[cfg(target_has_atomic = "128")]
atomic_int! {
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
@@ -1954,7 +1954,7 @@
16,
i128 AtomicI128 ATOMIC_I128_INIT
}
-#[cfg(all(not(stage0), target_has_atomic = "128"))]
+#[cfg(target_has_atomic = "128")]
atomic_int! {
unstable(feature = "integer_atomics", issue = "32976"),
unstable(feature = "integer_atomics", issue = "32976"),
diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs
index e6a7c20..56da6b7 100644
--- a/src/librustc/ich/impls_ty.rs
+++ b/src/librustc/ich/impls_ty.rs
@@ -338,7 +338,7 @@
);
impl_stable_hash_for!(
- impl<'tcx, M> for enum mir::interpret::AllocType<'tcx, M> [ mir::interpret::AllocType ] {
+ impl<'tcx> for enum mir::interpret::AllocKind<'tcx> [ mir::interpret::AllocKind ] {
Function(instance),
Static(def_id),
Memory(mem),
diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs
index a09d167..b7759a8 100644
--- a/src/librustc/lint/builtin.rs
+++ b/src/librustc/lint/builtin.rs
@@ -463,7 +463,7 @@
Ok(ref s) => {
// FIXME(Manishearth) ideally the emitting code
// can tell us whether or not this is global
- let opt_colon = if s.trim_left().starts_with("::") {
+ let opt_colon = if s.trim_start().starts_with("::") {
""
} else {
"::"
diff --git a/src/librustc/mir/interpret/mod.rs b/src/librustc/mir/interpret/mod.rs
index 9369b6e..d54a1c9 100644
--- a/src/librustc/mir/interpret/mod.rs
+++ b/src/librustc/mir/interpret/mod.rs
@@ -41,7 +41,6 @@
use ty::layout::{self, Size};
use middle::region;
use std::io;
-use std::hash::Hash;
use rustc_serialize::{Encoder, Decodable, Encodable};
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::sync::{Lock as Mutex, HashMapExt};
@@ -90,7 +89,7 @@
impl ::rustc_serialize::UseSpecializedDecodable for AllocId {}
#[derive(RustcDecodable, RustcEncodable)]
-enum AllocKind {
+enum AllocDiscriminant {
Alloc,
Fn,
Static,
@@ -104,23 +103,23 @@
tcx: TyCtxt<'a, 'tcx, 'tcx>,
alloc_id: AllocId,
) -> Result<(), E::Error> {
- let alloc_type: AllocType<'tcx, &'tcx Allocation> =
+ let alloc_kind: AllocKind<'tcx> =
tcx.alloc_map.lock().get(alloc_id).expect("no value for AllocId");
- match alloc_type {
- AllocType::Memory(alloc) => {
+ match alloc_kind {
+ AllocKind::Memory(alloc) => {
trace!("encoding {:?} with {:#?}", alloc_id, alloc);
- AllocKind::Alloc.encode(encoder)?;
+ AllocDiscriminant::Alloc.encode(encoder)?;
alloc.encode(encoder)?;
}
- AllocType::Function(fn_instance) => {
+ AllocKind::Function(fn_instance) => {
trace!("encoding {:?} with {:#?}", alloc_id, fn_instance);
- AllocKind::Fn.encode(encoder)?;
+ AllocDiscriminant::Fn.encode(encoder)?;
fn_instance.encode(encoder)?;
}
- AllocType::Static(did) => {
+ AllocKind::Static(did) => {
// referring to statics doesn't need to know about their allocations,
// just about its DefId
- AllocKind::Static.encode(encoder)?;
+ AllocDiscriminant::Static.encode(encoder)?;
did.encode(encoder)?;
}
}
@@ -189,10 +188,10 @@
let idx = decoder.read_u32()? as usize;
let pos = self.state.data_offsets[idx] as usize;
- // Decode the AllocKind now so that we know if we have to reserve an
+ // Decode the AllocDiscriminant now so that we know if we have to reserve an
// AllocId.
let (alloc_kind, pos) = decoder.with_position(pos, |decoder| {
- let alloc_kind = AllocKind::decode(decoder)?;
+ let alloc_kind = AllocDiscriminant::decode(decoder)?;
Ok((alloc_kind, decoder.position()))
})?;
@@ -208,7 +207,7 @@
ref mut entry @ State::Empty => {
// We are allowed to decode
match alloc_kind {
- AllocKind::Alloc => {
+ AllocDiscriminant::Alloc => {
// If this is an allocation, we need to reserve an
// AllocId so we can decode cyclic graphs.
let alloc_id = decoder.tcx().alloc_map.lock().reserve();
@@ -217,7 +216,7 @@
alloc_id);
Some(alloc_id)
},
- AllocKind::Fn | AllocKind::Static => {
+ AllocDiscriminant::Fn | AllocDiscriminant::Static => {
// Fns and statics cannot be cyclic and their AllocId
// is determined later by interning
*entry = State::InProgressNonAlloc(
@@ -251,15 +250,15 @@
// Now decode the actual data
let alloc_id = decoder.with_position(pos, |decoder| {
match alloc_kind {
- AllocKind::Alloc => {
+ AllocDiscriminant::Alloc => {
let allocation = <&'tcx Allocation as Decodable>::decode(decoder)?;
// We already have a reserved AllocId.
let alloc_id = alloc_id.unwrap();
trace!("decoded alloc {:?} {:#?}", alloc_id, allocation);
- decoder.tcx().alloc_map.lock().set_id_same_memory(alloc_id, allocation);
+ decoder.tcx().alloc_map.lock().set_alloc_id_same_memory(alloc_id, allocation);
Ok(alloc_id)
},
- AllocKind::Fn => {
+ AllocDiscriminant::Fn => {
assert!(alloc_id.is_none());
trace!("creating fn alloc id");
let instance = ty::Instance::decode(decoder)?;
@@ -267,7 +266,7 @@
let alloc_id = decoder.tcx().alloc_map.lock().create_fn_alloc(instance);
Ok(alloc_id)
},
- AllocKind::Static => {
+ AllocDiscriminant::Static => {
assert!(alloc_id.is_none());
trace!("creating extern static alloc id at");
let did = DefId::decode(decoder)?;
@@ -292,39 +291,42 @@
}
#[derive(Debug, Clone, Eq, PartialEq, Hash, RustcDecodable, RustcEncodable)]
-pub enum AllocType<'tcx, M> {
+pub enum AllocKind<'tcx> {
/// The alloc id is used as a function pointer
Function(Instance<'tcx>),
/// The alloc id points to a "lazy" static variable that did not get computed (yet).
/// This is also used to break the cycle in recursive statics.
Static(DefId),
/// The alloc id points to memory
- Memory(M)
+ Memory(&'tcx Allocation),
}
-pub struct AllocMap<'tcx, M> {
+pub struct AllocMap<'tcx> {
/// Lets you know what an AllocId refers to
- id_to_type: FxHashMap<AllocId, AllocType<'tcx, M>>,
+ id_to_kind: FxHashMap<AllocId, AllocKind<'tcx>>,
- /// Used to ensure that functions and statics only get one associated AllocId
- type_interner: FxHashMap<AllocType<'tcx, M>, AllocId>,
+ /// Used to ensure that statics only get one associated AllocId
+ type_interner: FxHashMap<AllocKind<'tcx>, AllocId>,
/// The AllocId to assign to the next requested id.
/// Always incremented, never gets smaller.
next_id: AllocId,
}
-impl<'tcx, M: fmt::Debug + Eq + Hash + Clone> AllocMap<'tcx, M> {
+impl<'tcx> AllocMap<'tcx> {
pub fn new() -> Self {
AllocMap {
- id_to_type: Default::default(),
+ id_to_kind: Default::default(),
type_interner: Default::default(),
next_id: AllocId(0),
}
}
- /// obtains a new allocation ID that can be referenced but does not
+ /// Obtains a new allocation ID that can be referenced but does not
/// yet have an allocation backing it.
+ ///
+ /// Make sure to call `set_alloc_id_memory` or `set_alloc_id_same_memory` before returning such
+ /// an `AllocId` from a query.
pub fn reserve(
&mut self,
) -> AllocId {
@@ -337,53 +339,73 @@
next
}
- fn intern(&mut self, alloc_type: AllocType<'tcx, M>) -> AllocId {
- if let Some(&alloc_id) = self.type_interner.get(&alloc_type) {
+ fn intern(&mut self, alloc_kind: AllocKind<'tcx>) -> AllocId {
+ if let Some(&alloc_id) = self.type_interner.get(&alloc_kind) {
return alloc_id;
}
let id = self.reserve();
- debug!("creating alloc_type {:?} with id {}", alloc_type, id);
- self.id_to_type.insert(id, alloc_type.clone());
- self.type_interner.insert(alloc_type, id);
+ debug!("creating alloc_kind {:?} with id {}", alloc_kind, id);
+ self.id_to_kind.insert(id, alloc_kind.clone());
+ self.type_interner.insert(alloc_kind, id);
id
}
- // FIXME: Check if functions have identity. If not, we should not intern these,
- // but instead create a new id per use.
- // Alternatively we could just make comparing function pointers an error.
+ /// Functions cannot be identified by pointers, as asm-equal functions can get deduplicated
+ /// by the linker and functions can be duplicated across crates.
+ /// We thus generate a new `AllocId` for every mention of a function. This means that
+ /// `main as fn() == main as fn()` is false, while `let x = main as fn(); x == x` is true.
pub fn create_fn_alloc(&mut self, instance: Instance<'tcx>) -> AllocId {
- self.intern(AllocType::Function(instance))
+ let id = self.reserve();
+ self.id_to_kind.insert(id, AllocKind::Function(instance));
+ id
}
- pub fn get(&self, id: AllocId) -> Option<AllocType<'tcx, M>> {
- self.id_to_type.get(&id).cloned()
+ /// Returns `None` in case the `AllocId` is dangling. An `EvalContext` can still have a
+ /// local `Allocation` for that `AllocId`, but having such an `AllocId` in a constant is
+ /// illegal and will likely ICE.
+ /// This function exists to allow const eval to detect the difference between evaluation-
+ /// local dangling pointers and allocations in constants/statics.
+ pub fn get(&self, id: AllocId) -> Option<AllocKind<'tcx>> {
+ self.id_to_kind.get(&id).cloned()
}
- pub fn unwrap_memory(&self, id: AllocId) -> M {
+ /// Panics if the `AllocId` does not refer to an `Allocation`
+ pub fn unwrap_memory(&self, id: AllocId) -> &'tcx Allocation {
match self.get(id) {
- Some(AllocType::Memory(mem)) => mem,
+ Some(AllocKind::Memory(mem)) => mem,
_ => bug!("expected allocation id {} to point to memory", id),
}
}
+ /// Generate an `AllocId` for a static or return a cached one in case this function has been
+ /// called on the same static before.
pub fn intern_static(&mut self, static_id: DefId) -> AllocId {
- self.intern(AllocType::Static(static_id))
+ self.intern(AllocKind::Static(static_id))
}
- pub fn allocate(&mut self, mem: M) -> AllocId {
+ /// Intern the `Allocation` and return a new `AllocId`, even if there's already an identical
+ /// `Allocation` with a different `AllocId`.
+ // FIXME: is this really necessary? Can we ensure `FOO` and `BAR` being different after codegen
+ // in `static FOO: u32 = 42; static BAR: u32 = 42;` even if they reuse the same allocation
+ // inside rustc?
+ pub fn allocate(&mut self, mem: &'tcx Allocation) -> AllocId {
let id = self.reserve();
- self.set_id_memory(id, mem);
+ self.set_alloc_id_memory(id, mem);
id
}
- pub fn set_id_memory(&mut self, id: AllocId, mem: M) {
- if let Some(old) = self.id_to_type.insert(id, AllocType::Memory(mem)) {
+ /// Freeze an `AllocId` created with `reserve` by pointing it at an `Allocation`. Trying to
+ /// call this function twice, even with the same `Allocation` will ICE the compiler.
+ pub fn set_alloc_id_memory(&mut self, id: AllocId, mem: &'tcx Allocation) {
+ if let Some(old) = self.id_to_kind.insert(id, AllocKind::Memory(mem)) {
bug!("tried to set allocation id {}, but it was already existing as {:#?}", id, old);
}
}
- pub fn set_id_same_memory(&mut self, id: AllocId, mem: M) {
- self.id_to_type.insert_same(id, AllocType::Memory(mem));
+ /// Freeze an `AllocId` created with `reserve` by pointing it at an `Allocation`. May be called
+ /// twice for the same `(AllocId, Allocation)` pair.
+ fn set_alloc_id_same_memory(&mut self, id: AllocId, mem: &'tcx Allocation) {
+ self.id_to_kind.insert_same(id, AllocKind::Memory(mem));
}
}
diff --git a/src/librustc/mir/interpret/value.rs b/src/librustc/mir/interpret/value.rs
index 500bd47..b8d4c5a 100644
--- a/src/librustc/mir/interpret/value.rs
+++ b/src/librustc/mir/interpret/value.rs
@@ -18,7 +18,7 @@
/// Represents the result of a raw const operation, pre-validation.
#[derive(Copy, Clone, Debug, Eq, PartialEq, RustcEncodable, RustcDecodable, Hash)]
pub struct RawConst<'tcx> {
- // the value lives here, at offset 0, and that allocation definitely is a `AllocType::Memory`
+ // the value lives here, at offset 0, and that allocation definitely is a `AllocKind::Memory`
// (so you can use `AllocMap::unwrap_memory`).
pub alloc_id: AllocId,
pub ty: Ty<'tcx>,
diff --git a/src/librustc/mir/mod.rs b/src/librustc/mir/mod.rs
index b7a4295..68b5c3e 100644
--- a/src/librustc/mir/mod.rs
+++ b/src/librustc/mir/mod.rs
@@ -2637,7 +2637,7 @@
if let Ref(_, &ty::TyS { sty: Str, .. }, _) = ty.sty {
return ty::tls::with(|tcx| {
let alloc = tcx.alloc_map.lock().get(ptr.alloc_id);
- if let Some(interpret::AllocType::Memory(alloc)) = alloc {
+ if let Some(interpret::AllocKind::Memory(alloc)) = alloc {
assert_eq!(len as usize as u128, len);
let slice =
&alloc.bytes[(ptr.offset.bytes() as usize)..][..(len as usize)];
diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs
index 750b7f1..b58d80e 100644
--- a/src/librustc/session/config.rs
+++ b/src/librustc/session/config.rs
@@ -14,7 +14,7 @@
use std::str::FromStr;
use session::{early_error, early_warn, Session};
-use session::search_paths::SearchPaths;
+use session::search_paths::SearchPath;
use rustc_target::spec::{LinkerFlavor, PanicStrategy, RelroLevel};
use rustc_target::spec::{Target, TargetTriple};
@@ -374,7 +374,7 @@
lint_cap: Option<lint::Level> [TRACKED],
describe_lints: bool [UNTRACKED],
output_types: OutputTypes [TRACKED],
- search_paths: SearchPaths [UNTRACKED],
+ search_paths: Vec<SearchPath> [UNTRACKED],
libs: Vec<(String, Option<String>, Option<cstore::NativeLibraryKind>)> [TRACKED],
maybe_sysroot: Option<PathBuf> [TRACKED],
@@ -593,7 +593,7 @@
lint_cap: None,
describe_lints: false,
output_types: OutputTypes(BTreeMap::new()),
- search_paths: SearchPaths::new(),
+ search_paths: vec![],
maybe_sysroot: None,
target_triple: TargetTriple::from_triple(host_triple()),
test: false,
@@ -1135,6 +1135,8 @@
"enable incremental compilation"),
default_linker_libraries: Option<bool> = (None, parse_opt_bool, [UNTRACKED],
"allow the linker to link its default libraries"),
+ linker_flavor: Option<LinkerFlavor> = (None, parse_linker_flavor, [UNTRACKED],
+ "Linker flavor"),
}
options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
@@ -1297,8 +1299,6 @@
"pass `-install_name @rpath/...` to the macOS linker"),
sanitizer: Option<Sanitizer> = (None, parse_sanitizer, [TRACKED],
"Use a sanitizer"),
- linker_flavor: Option<LinkerFlavor> = (None, parse_linker_flavor, [UNTRACKED],
- "Linker flavor"),
fuel: Option<(String, u64)> = (None, parse_optimization_fuel, [TRACKED],
"set the optimization fuel quota for a crate"),
print_fuel: Option<String> = (None, parse_opt_string, [TRACKED],
@@ -2115,9 +2115,9 @@
}
};
- let mut search_paths = SearchPaths::new();
+ let mut search_paths = vec![];
for s in &matches.opt_strs("L") {
- search_paths.add_path(&s[..], error_format);
+ search_paths.push(SearchPath::from_cli_opt(&s[..], error_format));
}
let libs = matches
@@ -2535,6 +2535,7 @@
use session::config::{build_configuration, build_session_options_and_crate_config};
use session::config::{LtoCli, CrossLangLto};
use session::build_session;
+ use session::search_paths::SearchPath;
use std::collections::{BTreeMap, BTreeSet};
use std::iter::FromIterator;
use std::path::PathBuf;
@@ -2790,48 +2791,48 @@
// Reference
v1.search_paths
- .add_path("native=abc", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("native=abc", super::ErrorOutputType::Json(false)));
v1.search_paths
- .add_path("crate=def", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("crate=def", super::ErrorOutputType::Json(false)));
v1.search_paths
- .add_path("dependency=ghi", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("dependency=ghi", super::ErrorOutputType::Json(false)));
v1.search_paths
- .add_path("framework=jkl", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("framework=jkl", super::ErrorOutputType::Json(false)));
v1.search_paths
- .add_path("all=mno", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("all=mno", super::ErrorOutputType::Json(false)));
v2.search_paths
- .add_path("native=abc", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("native=abc", super::ErrorOutputType::Json(false)));
v2.search_paths
- .add_path("dependency=ghi", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("dependency=ghi", super::ErrorOutputType::Json(false)));
v2.search_paths
- .add_path("crate=def", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("crate=def", super::ErrorOutputType::Json(false)));
v2.search_paths
- .add_path("framework=jkl", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("framework=jkl", super::ErrorOutputType::Json(false)));
v2.search_paths
- .add_path("all=mno", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("all=mno", super::ErrorOutputType::Json(false)));
v3.search_paths
- .add_path("crate=def", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("crate=def", super::ErrorOutputType::Json(false)));
v3.search_paths
- .add_path("framework=jkl", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("framework=jkl", super::ErrorOutputType::Json(false)));
v3.search_paths
- .add_path("native=abc", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("native=abc", super::ErrorOutputType::Json(false)));
v3.search_paths
- .add_path("dependency=ghi", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("dependency=ghi", super::ErrorOutputType::Json(false)));
v3.search_paths
- .add_path("all=mno", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("all=mno", super::ErrorOutputType::Json(false)));
v4.search_paths
- .add_path("all=mno", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("all=mno", super::ErrorOutputType::Json(false)));
v4.search_paths
- .add_path("native=abc", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("native=abc", super::ErrorOutputType::Json(false)));
v4.search_paths
- .add_path("crate=def", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("crate=def", super::ErrorOutputType::Json(false)));
v4.search_paths
- .add_path("dependency=ghi", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("dependency=ghi", super::ErrorOutputType::Json(false)));
v4.search_paths
- .add_path("framework=jkl", super::ErrorOutputType::Json(false));
+ .push(SearchPath::from_cli_opt("framework=jkl", super::ErrorOutputType::Json(false)));
assert!(v1.dep_tracking_hash() == v2.dep_tracking_hash());
assert!(v1.dep_tracking_hash() == v3.dep_tracking_hash());
diff --git a/src/librustc/session/filesearch.rs b/src/librustc/session/filesearch.rs
index 8159c65..c204556 100644
--- a/src/librustc/session/filesearch.rs
+++ b/src/librustc/session/filesearch.rs
@@ -12,13 +12,12 @@
pub use self::FileMatch::*;
-use rustc_data_structures::fx::FxHashSet;
use std::borrow::Cow;
use std::env;
use std::fs;
use std::path::{Path, PathBuf};
-use session::search_paths::{SearchPaths, PathKind};
+use session::search_paths::{SearchPath, PathKind};
use rustc_fs_util::fix_windows_verbatim_for_gcc;
#[derive(Copy, Clone)]
@@ -30,31 +29,19 @@
// A module for searching for libraries
pub struct FileSearch<'a> {
- pub sysroot: &'a Path,
- pub search_paths: &'a SearchPaths,
- pub triple: &'a str,
- pub kind: PathKind,
+ sysroot: &'a Path,
+ triple: &'a str,
+ search_paths: &'a [SearchPath],
+ tlib_path: &'a SearchPath,
+ kind: PathKind,
}
impl<'a> FileSearch<'a> {
- pub fn for_each_lib_search_path<F>(&self, mut f: F) where
- F: FnMut(&Path, PathKind)
- {
- let mut visited_dirs = FxHashSet::default();
- visited_dirs.reserve(self.search_paths.paths.len() + 1);
- for (path, kind) in self.search_paths.iter(self.kind) {
- f(path, kind);
- visited_dirs.insert(path.to_path_buf());
- }
-
- debug!("filesearch: searching lib path");
- let tlib_path = make_target_lib_path(self.sysroot,
- self.triple);
- if !visited_dirs.contains(&tlib_path) {
- f(&tlib_path, PathKind::All);
- }
-
- visited_dirs.insert(tlib_path);
+ pub fn search_paths(&self) -> impl Iterator<Item = &'a SearchPath> {
+ let kind = self.kind;
+ self.search_paths.iter()
+ .filter(move |sp| sp.kind.matches(kind))
+ .chain(std::iter::once(self.tlib_path))
}
pub fn get_lib_path(&self) -> PathBuf {
@@ -64,14 +51,8 @@
pub fn search<F>(&self, mut pick: F)
where F: FnMut(&Path, PathKind) -> FileMatch
{
- self.for_each_lib_search_path(|lib_search_path, kind| {
- debug!("searching {}", lib_search_path.display());
- let files = match fs::read_dir(lib_search_path) {
- Ok(files) => files,
- Err(..) => return,
- };
- let files = files.filter_map(|p| p.ok().map(|s| s.path()))
- .collect::<Vec<_>>();
+ for search_path in self.search_paths() {
+ debug!("searching {}", search_path.dir.display());
fn is_rlib(p: &Path) -> bool {
p.extension() == Some("rlib".as_ref())
}
@@ -79,11 +60,11 @@
// an rlib and a dylib we only read one of the files of
// metadata, so in the name of speed, bring all rlib files to
// the front of the search list.
- let files1 = files.iter().filter(|p| is_rlib(p));
- let files2 = files.iter().filter(|p| !is_rlib(p));
+ let files1 = search_path.files.iter().filter(|p| is_rlib(p));
+ let files2 = search_path.files.iter().filter(|p| !is_rlib(p));
for path in files1.chain(files2) {
debug!("testing {}", path.display());
- let maybe_picked = pick(path, kind);
+ let maybe_picked = pick(path, search_path.kind);
match maybe_picked {
FileMatches => {
debug!("picked {}", path.display());
@@ -93,29 +74,30 @@
}
}
}
- });
+ }
}
pub fn new(sysroot: &'a Path,
triple: &'a str,
- search_paths: &'a SearchPaths,
- kind: PathKind) -> FileSearch<'a> {
+ search_paths: &'a Vec<SearchPath>,
+ tlib_path: &'a SearchPath,
+ kind: PathKind)
+ -> FileSearch<'a> {
debug!("using sysroot = {}, triple = {}", sysroot.display(), triple);
FileSearch {
sysroot,
- search_paths,
triple,
+ search_paths,
+ tlib_path,
kind,
}
}
- // Returns a list of directories where target-specific dylibs might be located.
- pub fn get_dylib_search_paths(&self) -> Vec<PathBuf> {
- let mut paths = Vec::new();
- self.for_each_lib_search_path(|lib_search_path, _| {
- paths.push(lib_search_path.to_path_buf());
- });
- paths
+ // Returns just the directories within the search paths.
+ pub fn search_path_dirs(&self) -> Vec<PathBuf> {
+ self.search_paths()
+ .map(|sp| sp.dir.to_path_buf())
+ .collect()
}
// Returns a list of directories where target-specific tool binaries are located.
@@ -138,8 +120,7 @@
p
}
-fn make_target_lib_path(sysroot: &Path,
- target_triple: &str) -> PathBuf {
+pub fn make_target_lib_path(sysroot: &Path, target_triple: &str) -> PathBuf {
sysroot.join(&relative_target_lib_path(sysroot, target_triple))
}
diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs
index d1dd745..12b5646 100644
--- a/src/librustc/session/mod.rs
+++ b/src/librustc/session/mod.rs
@@ -19,8 +19,8 @@
use lint::builtin::BuiltinLintDiagnostics;
use middle::allocator::AllocatorKind;
use middle::dependency_format;
-use session::search_paths::PathKind;
use session::config::{OutputType, Lto};
+use session::search_paths::{PathKind, SearchPath};
use util::nodemap::{FxHashMap, FxHashSet};
use util::common::{duration_to_secs_str, ErrorReported};
use util::common::ProfileQueriesMsg;
@@ -48,7 +48,7 @@
use std::env;
use std::fmt;
use std::io::Write;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
use std::time::Duration;
use std::sync::mpsc;
use std::sync::atomic::{AtomicUsize, Ordering};
@@ -64,12 +64,15 @@
pub target: config::Config,
pub host: Target,
pub opts: config::Options,
+ pub host_tlib_path: SearchPath,
+ /// This is `None` if the host and target are the same.
+ pub target_tlib_path: Option<SearchPath>,
pub parse_sess: ParseSess,
/// For a library crate, this is always none
pub entry_fn: Once<Option<(NodeId, Span, config::EntryFnType)>>,
pub plugin_registrar_fn: Once<Option<ast::NodeId>>,
pub proc_macro_decls_static: Once<Option<ast::NodeId>>,
- pub default_sysroot: Option<PathBuf>,
+ pub sysroot: PathBuf,
/// The name of the root source file of the crate, in the local file system.
/// `None` means that there is no source file.
pub local_crate_source_file: Option<PathBuf>,
@@ -694,27 +697,22 @@
)
}
- pub fn sysroot<'a>(&'a self) -> &'a Path {
- match self.opts.maybe_sysroot {
- Some(ref sysroot) => sysroot,
- None => self.default_sysroot
- .as_ref()
- .expect("missing sysroot and default_sysroot in Session"),
- }
- }
pub fn target_filesearch(&self, kind: PathKind) -> filesearch::FileSearch<'_> {
filesearch::FileSearch::new(
- self.sysroot(),
+ &self.sysroot,
self.opts.target_triple.triple(),
&self.opts.search_paths,
+ // target_tlib_path==None means it's the same as host_tlib_path.
+ self.target_tlib_path.as_ref().unwrap_or(&self.host_tlib_path),
kind,
)
}
pub fn host_filesearch(&self, kind: PathKind) -> filesearch::FileSearch<'_> {
filesearch::FileSearch::new(
- self.sysroot(),
+ &self.sysroot,
config::host_triple(),
&self.opts.search_paths,
+ &self.host_tlib_path,
kind,
)
}
@@ -1109,9 +1107,18 @@
let target_cfg = config::build_target_config(&sopts, &span_diagnostic);
let p_s = parse::ParseSess::with_span_handler(span_diagnostic, source_map);
- let default_sysroot = match sopts.maybe_sysroot {
- Some(_) => None,
- None => Some(filesearch::get_or_default_sysroot()),
+ let sysroot = match &sopts.maybe_sysroot {
+ Some(sysroot) => sysroot.clone(),
+ None => filesearch::get_or_default_sysroot(),
+ };
+
+ let host_triple = config::host_triple();
+ let target_triple = sopts.target_triple.triple();
+ let host_tlib_path = SearchPath::from_sysroot_and_triple(&sysroot, host_triple);
+ let target_tlib_path = if host_triple == target_triple {
+ None
+ } else {
+ Some(SearchPath::from_sysroot_and_triple(&sysroot, target_triple))
};
let file_path_mapping = sopts.file_path_mapping();
@@ -1142,12 +1149,14 @@
target: target_cfg,
host,
opts: sopts,
+ host_tlib_path,
+ target_tlib_path,
parse_sess: p_s,
// For a library crate, this is always none
entry_fn: Once::new(),
plugin_registrar_fn: Once::new(),
proc_macro_decls_static: Once::new(),
- default_sysroot,
+ sysroot,
local_crate_source_file,
working_dir,
lint_store: RwLock::new(lint::LintStore::new()),
diff --git a/src/librustc/session/search_paths.rs b/src/librustc/session/search_paths.rs
index 6b0a8a0..5c44a07 100644
--- a/src/librustc/session/search_paths.rs
+++ b/src/librustc/session/search_paths.rs
@@ -8,18 +8,15 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::slice;
use std::path::{Path, PathBuf};
use session::{early_error, config};
+use session::filesearch::make_target_lib_path;
#[derive(Clone, Debug)]
-pub struct SearchPaths {
- crate paths: Vec<(PathKind, PathBuf)>,
-}
-
-pub struct Iter<'a> {
- kind: PathKind,
- iter: slice::Iter<'a, (PathKind, PathBuf)>,
+pub struct SearchPath {
+ pub kind: PathKind,
+ pub dir: PathBuf,
+ pub files: Vec<PathBuf>,
}
#[derive(Eq, PartialEq, Clone, Copy, Debug, PartialOrd, Ord, Hash)]
@@ -32,12 +29,17 @@
All,
}
-impl SearchPaths {
- pub fn new() -> SearchPaths {
- SearchPaths { paths: Vec::new() }
+impl PathKind {
+ pub fn matches(&self, kind: PathKind) -> bool {
+ match (self, kind) {
+ (PathKind::All, _) | (_, PathKind::All) => true,
+ _ => *self == kind,
+ }
}
+}
- pub fn add_path(&mut self, path: &str, output: config::ErrorOutputType) {
+impl SearchPath {
+ pub fn from_cli_opt(path: &str, output: config::ErrorOutputType) -> Self {
let (kind, path) = if path.starts_with("native=") {
(PathKind::Native, &path["native=".len()..])
} else if path.starts_with("crate=") {
@@ -54,34 +56,28 @@
if path.is_empty() {
early_error(output, "empty search path given via `-L`");
}
- self.paths.push((kind, PathBuf::from(path)));
+
+ let dir = PathBuf::from(path);
+ Self::new(kind, dir)
}
- pub fn iter(&self, kind: PathKind) -> Iter<'_> {
- Iter { kind: kind, iter: self.paths.iter() }
+ pub fn from_sysroot_and_triple(sysroot: &Path, triple: &str) -> Self {
+ Self::new(PathKind::All, make_target_lib_path(sysroot, triple))
}
-}
-impl<'a> Iterator for Iter<'a> {
- type Item = (&'a Path, PathKind);
-
- fn next(&mut self) -> Option<(&'a Path, PathKind)> {
- loop {
- match *self.iter.next()? {
- (kind, ref p) if self.kind == PathKind::All ||
- kind == PathKind::All ||
- kind == self.kind => {
- return Some((p, kind))
- }
- _ => {}
+ fn new(kind: PathKind, dir: PathBuf) -> Self {
+ // Get the files within the directory.
+ let files = match std::fs::read_dir(&dir) {
+ Ok(files) => {
+ files.filter_map(|p| {
+ p.ok().map(|s| s.path())
+ })
+ .collect::<Vec<_>>()
}
- }
- }
+ Err(..) => vec![],
+ };
- fn size_hint(&self) -> (usize, Option<usize>) {
- // This iterator will never return more elements than the base iterator;
- // but it can ignore all the remaining elements.
- let (_, upper) = self.iter.size_hint();
- (0, upper)
+ SearchPath { kind, dir, files }
}
}
+
diff --git a/src/librustc/traits/specialize/specialization_graph.rs b/src/librustc/traits/specialize/specialization_graph.rs
index 22221e0..b0ca2f6 100644
--- a/src/librustc/traits/specialize/specialization_graph.rs
+++ b/src/librustc/traits/specialize/specialization_graph.rs
@@ -132,10 +132,12 @@
simplified_self,
);
- for possible_sibling in match simplified_self {
- Some(sty) => self.filtered(sty),
- None => self.iter(),
- } {
+ let possible_siblings = match simplified_self {
+ Some(sty) => PotentialSiblings::Filtered(self.filtered(sty)),
+ None => PotentialSiblings::Unfiltered(self.iter()),
+ };
+
+ for possible_sibling in possible_siblings {
debug!(
"insert: impl_def_id={:?}, simplified_self={:?}, possible_sibling={:?}",
impl_def_id,
@@ -222,14 +224,37 @@
Ok(Inserted::BecameNewSibling(last_lint))
}
- fn iter(&mut self) -> Box<dyn Iterator<Item = DefId> + '_> {
+ fn iter(&mut self) -> impl Iterator<Item = DefId> + '_ {
let nonblanket = self.nonblanket_impls.iter_mut().flat_map(|(_, v)| v.iter());
- Box::new(self.blanket_impls.iter().chain(nonblanket).cloned())
+ self.blanket_impls.iter().chain(nonblanket).cloned()
}
- fn filtered(&mut self, sty: SimplifiedType) -> Box<dyn Iterator<Item = DefId> + '_> {
+ fn filtered(&mut self, sty: SimplifiedType) -> impl Iterator<Item = DefId> + '_ {
let nonblanket = self.nonblanket_impls.entry(sty).or_default().iter();
- Box::new(self.blanket_impls.iter().chain(nonblanket).cloned())
+ self.blanket_impls.iter().chain(nonblanket).cloned()
+ }
+}
+
+// A custom iterator used by Children::insert
+enum PotentialSiblings<I, J>
+ where I: Iterator<Item = DefId>,
+ J: Iterator<Item = DefId>
+{
+ Unfiltered(I),
+ Filtered(J)
+}
+
+impl<I, J> Iterator for PotentialSiblings<I, J>
+ where I: Iterator<Item = DefId>,
+ J: Iterator<Item = DefId>
+{
+ type Item = DefId;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ match *self {
+ PotentialSiblings::Unfiltered(ref mut iter) => iter.next(),
+ PotentialSiblings::Filtered(ref mut iter) => iter.next()
+ }
}
}
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
index a3db3a0..e27d734 100644
--- a/src/librustc/ty/context.rs
+++ b/src/librustc/ty/context.rs
@@ -946,7 +946,7 @@
/// Stores the value of constants (and deduplicates the actual memory)
allocation_interner: Lock<FxHashMap<&'tcx Allocation, ()>>,
- pub alloc_map: Lock<interpret::AllocMap<'tcx, &'tcx Allocation>>,
+ pub alloc_map: Lock<interpret::AllocMap<'tcx>>,
layout_interner: Lock<FxHashMap<&'tcx LayoutDetails, ()>>,
diff --git a/src/librustc/util/profiling.rs b/src/librustc/util/profiling.rs
index 1e648c4..c2bfa62 100644
--- a/src/librustc/util/profiling.rs
+++ b/src/librustc/util/profiling.rs
@@ -62,11 +62,15 @@
}
fn print(&self, lock: &mut StderrLock<'_>) {
- writeln!(lock, "| Phase | Time (ms) | Queries | Hits (%) |")
+ writeln!(lock, "| Phase | Time (ms) \
+ | Time (%) | Queries | Hits (%)")
.unwrap();
- writeln!(lock, "| ---------------- | -------------- | -------------- | -------- |")
+ writeln!(lock, "| ---------------- | -------------- \
+ | -------- | -------------- | --------")
.unwrap();
+ let total_time = ($(self.times.$name + )* 0) as f32;
+
$(
let (hits, total) = self.query_counts.$name;
let (hits, total) = if total > 0 {
@@ -78,11 +82,12 @@
writeln!(
lock,
- "| {0: <16} | {1: <14} | {2: <14} | {3: <8} |",
+ "| {0: <16} | {1: <14} | {2: <8.2} | {3: <14} | {4: <8}",
stringify!($name),
self.times.$name / 1_000_000,
+ ((self.times.$name as f32) / total_time) * 100.0,
total,
- hits
+ hits,
).unwrap();
)*
}
diff --git a/src/librustc_codegen_llvm/attributes.rs b/src/librustc_codegen_llvm/attributes.rs
index ffe5e12..48e0a3a 100644
--- a/src/librustc_codegen_llvm/attributes.rs
+++ b/src/librustc_codegen_llvm/attributes.rs
@@ -15,14 +15,16 @@
use rustc::hir::def_id::{DefId, LOCAL_CRATE};
use rustc::session::Session;
use rustc::session::config::Sanitizer;
-use rustc::ty::TyCtxt;
+use rustc::ty::{self, TyCtxt, PolyFnSig};
use rustc::ty::layout::HasTyCtxt;
use rustc::ty::query::Providers;
+use rustc_data_structures::small_c_str::SmallCStr;
use rustc_data_structures::sync::Lrc;
use rustc_data_structures::fx::FxHashMap;
use rustc_target::spec::PanicStrategy;
use rustc_codegen_ssa::traits::*;
+use abi::Abi;
use attributes;
use llvm::{self, Attribute};
use llvm::AttributePlace::Function;
@@ -60,7 +62,7 @@
/// Tell LLVM whether the function can or cannot unwind.
#[inline]
-pub fn unwind(val: &'ll Value, can_unwind: bool) {
+fn unwind(val: &'ll Value, can_unwind: bool) {
Attribute::NoUnwind.toggle_llfn(Function, val, !can_unwind);
}
@@ -129,8 +131,7 @@
}
pub fn apply_target_cpu_attr(cx: &CodegenCx<'ll, '_>, llfn: &'ll Value) {
- let cpu = llvm_util::target_cpu(cx.tcx.sess);
- let target_cpu = CString::new(cpu).unwrap();
+ let target_cpu = SmallCStr::new(llvm_util::target_cpu(cx.tcx.sess));
llvm::AddFunctionAttrStringValue(
llfn,
llvm::AttributePlace::Function,
@@ -150,9 +151,10 @@
/// Composite function which sets LLVM attributes for function depending on its AST (`#[attribute]`)
/// attributes.
pub fn from_fn_attrs(
- cx: &CodegenCx<'ll, '_>,
+ cx: &CodegenCx<'ll, 'tcx>,
llfn: &'ll Value,
id: Option<DefId>,
+ sig: PolyFnSig<'tcx>,
) {
let codegen_fn_attrs = id.map(|id| cx.tcx.codegen_fn_attrs(id))
.unwrap_or_else(|| CodegenFnAttrs::new());
@@ -194,37 +196,42 @@
llvm::AttributePlace::ReturnValue, llfn);
}
- let can_unwind = if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::UNWIND) {
- Some(true)
+ unwind(llfn, if cx.tcx.sess.panic_strategy() != PanicStrategy::Unwind {
+ // In panic=abort mode we assume nothing can unwind anywhere, so
+ // optimize based on this!
+ false
+ } else if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::UNWIND) {
+ // If a specific #[unwind] attribute is present, use that
+ true
} else if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::RUSTC_ALLOCATOR_NOUNWIND) {
- Some(false)
-
- // Perhaps questionable, but we assume that anything defined
- // *in Rust code* may unwind. Foreign items like `extern "C" {
- // fn foo(); }` are assumed not to unwind **unless** they have
- // a `#[unwind]` attribute.
- } else if id.map(|id| !cx.tcx.is_foreign_item(id)).unwrap_or(false) {
- Some(true)
- } else {
- None
- };
-
- match can_unwind {
- Some(false) => attributes::unwind(llfn, false),
- Some(true) if cx.tcx.sess.panic_strategy() == PanicStrategy::Unwind => {
- attributes::unwind(llfn, true);
+ // Special attribute for allocator functions, which can't unwind
+ false
+ } else if let Some(id) = id {
+ let sig = cx.tcx.normalize_erasing_late_bound_regions(ty::ParamEnv::reveal_all(), &sig);
+ if cx.tcx.is_foreign_item(id) {
+ // Foreign items like `extern "C" { fn foo(); }` are assumed not to
+ // unwind
+ false
+ } else if sig.abi != Abi::Rust && sig.abi != Abi::RustCall {
+ // Any items defined in Rust that *don't* have the `extern` ABI are
+ // defined to not unwind. We insert shims to abort if an unwind
+ // happens to enforce this.
+ false
+ } else {
+ // Anything else defined in Rust is assumed that it can possibly
+ // unwind
+ true
}
- Some(true) | None => {}
- }
+ } else {
+ // assume this can possibly unwind, avoiding the application of a
+ // `nounwind` attribute below.
+ true
+ });
// Always annotate functions with the target-cpu they are compiled for.
// Without this, ThinLTO won't inline Rust functions into Clang generated
// functions (because Clang annotates functions this way too).
- // NOTE: For now we just apply this if -Zcross-lang-lto is specified, since
- // it introduce a little overhead and isn't really necessary otherwise.
- if cx.tcx.sess.opts.debugging_opts.cross_lang_lto.enabled() {
- apply_target_cpu_attr(cx, llfn);
- }
+ apply_target_cpu_attr(cx, llfn);
let features = llvm_target_features(cx.tcx.sess)
.map(|s| s.to_string())
diff --git a/src/librustc_codegen_llvm/back/link.rs b/src/librustc_codegen_llvm/back/link.rs
index 9e100a1..f1c0464 100644
--- a/src/librustc_codegen_llvm/back/link.rs
+++ b/src/librustc_codegen_llvm/back/link.rs
@@ -212,12 +212,7 @@
}
fn archive_search_paths(sess: &Session) -> Vec<PathBuf> {
- let mut search = Vec::new();
- sess.target_filesearch(PathKind::Native).for_each_lib_search_path(|path, _| {
- search.push(path.to_path_buf());
- });
-
- search
+ sess.target_filesearch(PathKind::Native).search_path_dirs()
}
fn archive_config<'a>(sess: &'a Session,
@@ -1024,11 +1019,10 @@
// where extern libraries might live, based on the
// addl_lib_search_paths
if sess.opts.cg.rpath {
- let sysroot = sess.sysroot();
let target_triple = sess.opts.target_triple.triple();
let mut get_install_prefix_lib_path = || {
let install_prefix = option_env!("CFG_PREFIX").expect("CFG_PREFIX");
- let tlib = filesearch::relative_target_lib_path(sysroot, target_triple);
+ let tlib = filesearch::relative_target_lib_path(&sess.sysroot, target_triple);
let mut path = PathBuf::from(install_prefix);
path.push(&tlib);
@@ -1068,12 +1062,13 @@
fn add_local_native_libraries(cmd: &mut dyn Linker,
sess: &Session,
codegen_results: &CodegenResults) {
- sess.target_filesearch(PathKind::All).for_each_lib_search_path(|path, k| {
- match k {
- PathKind::Framework => { cmd.framework_path(path); }
- _ => { cmd.include_path(&fix_windows_verbatim_for_gcc(path)); }
+ let filesearch = sess.target_filesearch(PathKind::All);
+ for search_path in filesearch.search_paths() {
+ match search_path.kind {
+ PathKind::Framework => { cmd.framework_path(&search_path.dir); }
+ _ => { cmd.include_path(&fix_windows_verbatim_for_gcc(&search_path.dir)); }
}
- });
+ }
let relevant_libs = codegen_results.crate_info.used_libraries.iter().filter(|l| {
relevant_lib(sess, l)
diff --git a/src/librustc_codegen_llvm/callee.rs b/src/librustc_codegen_llvm/callee.rs
index f13eeb6..87185a2 100644
--- a/src/librustc_codegen_llvm/callee.rs
+++ b/src/librustc_codegen_llvm/callee.rs
@@ -94,7 +94,7 @@
if instance.def.is_inline(tcx) {
attributes::inline(cx, llfn, attributes::InlineAttr::Hint);
}
- attributes::from_fn_attrs(cx, llfn, Some(instance.def.def_id()));
+ attributes::from_fn_attrs(cx, llfn, Some(instance.def.def_id()), sig);
let instance_def_id = instance.def_id();
diff --git a/src/librustc_codegen_llvm/common.rs b/src/librustc_codegen_llvm/common.rs
index 55f286e..ad14ca7 100644
--- a/src/librustc_codegen_llvm/common.rs
+++ b/src/librustc_codegen_llvm/common.rs
@@ -21,7 +21,7 @@
use rustc_codegen_ssa::traits::*;
use rustc::ty::layout::{HasDataLayout, LayoutOf, self, TyLayout, Size};
-use rustc::mir::interpret::{Scalar, AllocType, Allocation};
+use rustc::mir::interpret::{Scalar, AllocKind, Allocation};
use consts::const_alloc_to_llvm;
use rustc_codegen_ssa::mir::place::PlaceRef;
@@ -316,9 +316,9 @@
}
},
Scalar::Ptr(ptr) => {
- let alloc_type = self.tcx.alloc_map.lock().get(ptr.alloc_id);
- let base_addr = match alloc_type {
- Some(AllocType::Memory(alloc)) => {
+ let alloc_kind = self.tcx.alloc_map.lock().get(ptr.alloc_id);
+ let base_addr = match alloc_kind {
+ Some(AllocKind::Memory(alloc)) => {
let init = const_alloc_to_llvm(self, alloc);
if alloc.mutability == Mutability::Mutable {
self.static_addr_of_mut(init, alloc.align, None)
@@ -326,10 +326,10 @@
self.static_addr_of(init, alloc.align, None)
}
}
- Some(AllocType::Function(fn_instance)) => {
+ Some(AllocKind::Function(fn_instance)) => {
self.get_fn(fn_instance)
}
- Some(AllocType::Static(def_id)) => {
+ Some(AllocKind::Static(def_id)) => {
assert!(self.tcx.is_static(def_id).is_some());
self.get_static(def_id)
}
diff --git a/src/librustc_codegen_llvm/context.rs b/src/librustc_codegen_llvm/context.rs
index 6c90937..0bd6146 100644
--- a/src/librustc_codegen_llvm/context.rs
+++ b/src/librustc_codegen_llvm/context.rs
@@ -409,7 +409,6 @@
));
let llfn = self.declare_fn("rust_eh_unwind_resume", sig);
- attributes::unwind(llfn, true);
attributes::apply_target_cpu_attr(self, llfn);
unwresume.set(Some(llfn));
llfn
diff --git a/src/librustc_codegen_llvm/declare.rs b/src/librustc_codegen_llvm/declare.rs
index c23aab4..2964f2e 100644
--- a/src/librustc_codegen_llvm/declare.rs
+++ b/src/librustc_codegen_llvm/declare.rs
@@ -26,8 +26,7 @@
use rustc::ty::layout::LayoutOf;
use rustc::session::config::Sanitizer;
use rustc_data_structures::small_c_str::SmallCStr;
-use rustc_target::spec::PanicStrategy;
-use abi::{Abi, FnType, FnTypeExt};
+use abi::{FnType, FnTypeExt};
use attributes;
use context::CodegenCx;
use type_::Type;
@@ -86,10 +85,6 @@
_ => {},
}
- if cx.tcx.sess.panic_strategy() != PanicStrategy::Unwind {
- attributes::unwind(llfn, false);
- }
-
attributes::non_lazy_bind(cx.sess(), llfn);
llfn
@@ -132,10 +127,6 @@
llvm::Attribute::NoReturn.apply_llfn(Function, llfn);
}
- if sig.abi != Abi::Rust && sig.abi != Abi::RustCall {
- attributes::unwind(llfn, false);
- }
-
fty.apply_attrs_llfn(llfn);
llfn
diff --git a/src/librustc_codegen_llvm/intrinsic.rs b/src/librustc_codegen_llvm/intrinsic.rs
index 59608b1..2b82ebe 100644
--- a/src/librustc_codegen_llvm/intrinsic.rs
+++ b/src/librustc_codegen_llvm/intrinsic.rs
@@ -1081,7 +1081,7 @@
Abi::Rust
));
let llfn = cx.define_internal_fn(name, rust_fn_sig);
- attributes::from_fn_attrs(cx, llfn, None);
+ attributes::from_fn_attrs(cx, llfn, None, rust_fn_sig);
let bx = Builder::new_block(cx, llfn, "entry-block");
codegen(bx);
llfn
diff --git a/src/librustc_codegen_llvm/mono_item.rs b/src/librustc_codegen_llvm/mono_item.rs
index 1d5bcc4..9c69d7d 100644
--- a/src/librustc_codegen_llvm/mono_item.rs
+++ b/src/librustc_codegen_llvm/mono_item.rs
@@ -82,7 +82,12 @@
if instance.def.is_inline(self.tcx) {
attributes::inline(self, lldecl, attributes::InlineAttr::Hint);
}
- attributes::from_fn_attrs(self, lldecl, Some(instance.def.def_id()));
+ attributes::from_fn_attrs(
+ self,
+ lldecl,
+ Some(instance.def.def_id()),
+ mono_sig,
+ );
self.instances.borrow_mut().insert(instance, lldecl);
}
diff --git a/src/librustc_codegen_ssa/back/link.rs b/src/librustc_codegen_ssa/back/link.rs
index 24a70dc..59102e0 100644
--- a/src/librustc_codegen_ssa/back/link.rs
+++ b/src/librustc_codegen_ssa/back/link.rs
@@ -192,11 +192,7 @@
// linker and linker flavor specified via command line have precedence over what the target
// specification specifies
- if let Some(ret) = infer_from(
- sess,
- sess.opts.cg.linker.clone(),
- sess.opts.debugging_opts.linker_flavor,
- ) {
+ if let Some(ret) = infer_from(sess, sess.opts.cg.linker.clone(), sess.opts.cg.linker_flavor) {
return ret;
}
diff --git a/src/librustc_codegen_ssa/back/linker.rs b/src/librustc_codegen_ssa/back/linker.rs
index 2f92c42..4960c89 100644
--- a/src/librustc_codegen_ssa/back/linker.rs
+++ b/src/librustc_codegen_ssa/back/linker.rs
@@ -606,8 +606,7 @@
self.cmd.arg("/DEBUG");
// This will cause the Microsoft linker to embed .natvis info into the PDB file
- let sysroot = self.sess.sysroot();
- let natvis_dir_path = sysroot.join("lib\\rustlib\\etc");
+ let natvis_dir_path = self.sess.sysroot.join("lib\\rustlib\\etc");
if let Ok(natvis_dir) = fs::read_dir(&natvis_dir_path) {
// LLVM 5.0.0's lld-link frontend doesn't yet recognize, and chokes
// on, the /NATVIS:... flags. LLVM 6 (or earlier) should at worst ignore
diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs
index f2edcdc..b26d81b 100644
--- a/src/librustc_driver/driver.rs
+++ b/src/librustc_driver/driver.rs
@@ -975,7 +975,7 @@
let mut old_path = OsString::new();
if cfg!(windows) {
old_path = env::var_os("PATH").unwrap_or(old_path);
- let mut new_path = sess.host_filesearch(PathKind::All).get_dylib_search_paths();
+ let mut new_path = sess.host_filesearch(PathKind::All).search_path_dirs();
for path in env::split_paths(&old_path) {
if !new_path.contains(&path) {
new_path.push(path);
diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs
index 39777e0..41c9b22 100644
--- a/src/librustc_driver/lib.rs
+++ b/src/librustc_driver/lib.rs
@@ -1042,7 +1042,7 @@
targets.sort();
println!("{}", targets.join("\n"));
},
- Sysroot => println!("{}", sess.sysroot().display()),
+ Sysroot => println!("{}", sess.sysroot.display()),
TargetSpec => println!("{}", sess.target.target.to_json().pretty()),
FileNames | CrateName => {
let input = input.unwrap_or_else(||
diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs
index ae9f6a5..7bd0f0f 100644
--- a/src/librustc_errors/emitter.rs
+++ b/src/librustc_errors/emitter.rs
@@ -1262,7 +1262,7 @@
// Do not underline the leading...
let start = part.snippet.len()
- .saturating_sub(part.snippet.trim_left().len());
+ .saturating_sub(part.snippet.trim_start().len());
// ...or trailing spaces. Account for substitutions containing unicode
// characters.
let sub_len = part.snippet.trim().chars().fold(0, |acc, ch| {
diff --git a/src/librustc_lint/nonstandard_style.rs b/src/librustc_lint/nonstandard_style.rs
index 13be50e..e071c34 100644
--- a/src/librustc_lint/nonstandard_style.rs
+++ b/src/librustc_lint/nonstandard_style.rs
@@ -167,7 +167,7 @@
fn to_snake_case(mut str: &str) -> String {
let mut words = vec![];
// Preserve leading underscores
- str = str.trim_left_matches(|c: char| {
+ str = str.trim_start_matches(|c: char| {
if c == '_' {
words.push(String::new());
true
@@ -199,7 +199,7 @@
if ident.is_empty() {
return true;
}
- let ident = ident.trim_left_matches('\'');
+ let ident = ident.trim_start_matches('\'');
let ident = ident.trim_matches('_');
let mut allow_underscore = true;
diff --git a/src/librustc_llvm/build.rs b/src/librustc_llvm/build.rs
index 7d01ed5..ce48208 100644
--- a/src/librustc_llvm/build.rs
+++ b/src/librustc_llvm/build.rs
@@ -192,11 +192,11 @@
// On MSVC llvm-config will print the full name to libraries, but
// we're only interested in the name part
let name = Path::new(lib).file_name().unwrap().to_str().unwrap();
- name.trim_right_matches(".lib")
+ name.trim_end_matches(".lib")
} else if lib.ends_with(".lib") {
// Some MSVC libraries just come up with `.lib` tacked on, so chop
// that off
- lib.trim_right_matches(".lib")
+ lib.trim_end_matches(".lib")
} else {
continue;
};
diff --git a/src/librustc_metadata/locator.rs b/src/librustc_metadata/locator.rs
index 1f298f6..f01ed9e 100644
--- a/src/librustc_metadata/locator.rs
+++ b/src/librustc_metadata/locator.rs
@@ -678,7 +678,7 @@
// candidates are all canonicalized, so we canonicalize the sysroot
// as well.
if let Some((ref prev, _)) = ret {
- let sysroot = self.sess.sysroot();
+ let sysroot = &self.sess.sysroot;
let sysroot = sysroot.canonicalize()
.unwrap_or_else(|_| sysroot.to_path_buf());
if prev.starts_with(&sysroot) {
diff --git a/src/librustc_mir/borrow_check/move_errors.rs b/src/librustc_mir/borrow_check/move_errors.rs
index db60017..fb93c41 100644
--- a/src/librustc_mir/borrow_check/move_errors.rs
+++ b/src/librustc_mir/borrow_check/move_errors.rs
@@ -426,13 +426,13 @@
.span_to_snippet(pat_span)
.unwrap();
if pat_snippet.starts_with('&') {
- let pat_snippet = pat_snippet[1..].trim_left();
+ let pat_snippet = pat_snippet[1..].trim_start();
let suggestion;
let to_remove;
if pat_snippet.starts_with("mut")
&& pat_snippet["mut".len()..].starts_with(Pattern_White_Space)
{
- suggestion = pat_snippet["mut".len()..].trim_left();
+ suggestion = pat_snippet["mut".len()..].trim_start();
to_remove = "&mut";
} else {
suggestion = pat_snippet;
diff --git a/src/librustc_mir/build/matches/simplify.rs b/src/librustc_mir/build/matches/simplify.rs
index cfea357..328b330 100644
--- a/src/librustc_mir/build/matches/simplify.rs
+++ b/src/librustc_mir/build/matches/simplify.rs
@@ -26,6 +26,10 @@
use build::matches::{Ascription, Binding, MatchPair, Candidate};
use hair::*;
use rustc::mir::*;
+use rustc::ty;
+use rustc::ty::layout::{Integer, IntegerExt, Size};
+use syntax::attr::{SignedInt, UnsignedInt};
+use rustc::hir::RangeEnd;
use std::mem;
@@ -62,6 +66,7 @@
match_pair: MatchPair<'pat, 'tcx>,
candidate: &mut Candidate<'pat, 'tcx>)
-> Result<(), MatchPair<'pat, 'tcx>> {
+ let tcx = self.hir.tcx();
match *match_pair.pattern.kind {
PatternKind::AscribeUserType { ref subpattern, ref user_ty, user_ty_span } => {
candidate.ascriptions.push(Ascription {
@@ -104,7 +109,34 @@
Err(match_pair)
}
- PatternKind::Range { .. } => {
+ PatternKind::Range { lo, hi, ty, end } => {
+ let range = match ty.sty {
+ ty::Char => {
+ Some(('\u{0000}' as u128, '\u{10FFFF}' as u128, Size::from_bits(32)))
+ }
+ ty::Int(ity) => {
+ // FIXME(49937): refactor these bit manipulations into interpret.
+ let size = Integer::from_attr(&tcx, SignedInt(ity)).size();
+ let min = 1u128 << (size.bits() - 1);
+ let max = (1u128 << (size.bits() - 1)) - 1;
+ Some((min, max, size))
+ }
+ ty::Uint(uty) => {
+ // FIXME(49937): refactor these bit manipulations into interpret.
+ let size = Integer::from_attr(&tcx, UnsignedInt(uty)).size();
+ let max = !0u128 >> (128 - size.bits());
+ Some((0, max, size))
+ }
+ _ => None,
+ };
+ if let Some((min, max, sz)) = range {
+ if let (Some(lo), Some(hi)) = (lo.val.try_to_bits(sz), hi.val.try_to_bits(sz)) {
+ if lo <= min && (hi > max || hi == max && end == RangeEnd::Included) {
+ // Irrefutable pattern match.
+ return Ok(());
+ }
+ }
+ }
Err(match_pair)
}
diff --git a/src/librustc_mir/build/mod.rs b/src/librustc_mir/build/mod.rs
index b0601b3..ab52d9b 100644
--- a/src/librustc_mir/build/mod.rs
+++ b/src/librustc_mir/build/mod.rs
@@ -628,12 +628,7 @@
// unwind anyway. Don't stop them.
let attrs = &tcx.get_attrs(fn_def_id);
match attr::find_unwind_attr(Some(tcx.sess.diagnostic()), attrs) {
- None => {
- // FIXME(rust-lang/rust#48251) -- Had to disable
- // abort-on-panic for backwards compatibility reasons.
- false
- }
-
+ None => true,
Some(UnwindAttr::Allowed) => false,
Some(UnwindAttr::Aborts) => true,
}
diff --git a/src/librustc_mir/interpret/intrinsics.rs b/src/librustc_mir/interpret/intrinsics.rs
index bbee6e0..cbe2e25 100644
--- a/src/librustc_mir/interpret/intrinsics.rs
+++ b/src/librustc_mir/interpret/intrinsics.rs
@@ -103,7 +103,7 @@
if bits == 0 {
return err!(Intrinsic(format!("{} called on 0", intrinsic_name)));
}
- numeric_intrinsic(intrinsic_name.trim_right_matches("_nonzero"), bits, kind)?
+ numeric_intrinsic(intrinsic_name.trim_end_matches("_nonzero"), bits, kind)?
} else {
numeric_intrinsic(intrinsic_name, bits, kind)?
};
diff --git a/src/librustc_mir/interpret/memory.rs b/src/librustc_mir/interpret/memory.rs
index e32abb9..420fe26 100644
--- a/src/librustc_mir/interpret/memory.rs
+++ b/src/librustc_mir/interpret/memory.rs
@@ -29,7 +29,7 @@
use super::{
Pointer, AllocId, Allocation, GlobalId, AllocationExtra,
- EvalResult, Scalar, EvalErrorKind, AllocType, PointerArithmetic,
+ EvalResult, Scalar, EvalErrorKind, AllocKind, PointerArithmetic,
Machine, AllocMap, MayLeak, ErrorHandled, InboundsCheck,
};
@@ -204,12 +204,12 @@
None => {
// Deallocating static memory -- always an error
return match self.tcx.alloc_map.lock().get(ptr.alloc_id) {
- Some(AllocType::Function(..)) => err!(DeallocatedWrongMemoryKind(
+ Some(AllocKind::Function(..)) => err!(DeallocatedWrongMemoryKind(
"function".to_string(),
format!("{:?}", kind),
)),
- Some(AllocType::Static(..)) |
- Some(AllocType::Memory(..)) => err!(DeallocatedWrongMemoryKind(
+ Some(AllocKind::Static(..)) |
+ Some(AllocKind::Memory(..)) => err!(DeallocatedWrongMemoryKind(
"static".to_string(),
format!("{:?}", kind),
)),
@@ -326,15 +326,15 @@
) -> EvalResult<'tcx, Cow<'tcx, Allocation<M::PointerTag, M::AllocExtra>>> {
let alloc = tcx.alloc_map.lock().get(id);
let def_id = match alloc {
- Some(AllocType::Memory(mem)) => {
+ Some(AllocKind::Memory(mem)) => {
// We got tcx memory. Let the machine figure out whether and how to
// turn that into memory with the right pointer tag.
return Ok(M::adjust_static_allocation(mem, memory_extra))
}
- Some(AllocType::Function(..)) => {
+ Some(AllocKind::Function(..)) => {
return err!(DerefFunctionPointer)
}
- Some(AllocType::Static(did)) => {
+ Some(AllocKind::Static(did)) => {
did
}
None =>
@@ -435,8 +435,8 @@
}
// Could also be a fn ptr or extern static
match self.tcx.alloc_map.lock().get(id) {
- Some(AllocType::Function(..)) => (Size::ZERO, Align::from_bytes(1).unwrap()),
- Some(AllocType::Static(did)) => {
+ Some(AllocKind::Function(..)) => (Size::ZERO, Align::from_bytes(1).unwrap()),
+ Some(AllocKind::Static(did)) => {
// The only way `get` couldn't have worked here is if this is an extern static
assert!(self.tcx.is_foreign_item(did));
// Use size and align of the type
@@ -459,7 +459,7 @@
}
trace!("reading fn ptr: {}", ptr.alloc_id);
match self.tcx.alloc_map.lock().get(ptr.alloc_id) {
- Some(AllocType::Function(instance)) => Ok(instance),
+ Some(AllocKind::Function(instance)) => Ok(instance),
_ => Err(EvalErrorKind::ExecuteMemory.into()),
}
}
@@ -557,16 +557,16 @@
Err(()) => {
// static alloc?
match self.tcx.alloc_map.lock().get(id) {
- Some(AllocType::Memory(alloc)) => {
+ Some(AllocKind::Memory(alloc)) => {
self.dump_alloc_helper(
&mut allocs_seen, &mut allocs_to_print,
msg, alloc, " (immutable)".to_owned()
);
}
- Some(AllocType::Function(func)) => {
+ Some(AllocKind::Function(func)) => {
trace!("{} {}", msg, func);
}
- Some(AllocType::Static(did)) => {
+ Some(AllocKind::Static(did)) => {
trace!("{} {:?}", msg, did);
}
None => {
@@ -638,7 +638,7 @@
// ensure llvm knows not to put this into immutable memory
alloc.mutability = mutability;
let alloc = self.tcx.intern_const_alloc(alloc);
- self.tcx.alloc_map.lock().set_id_memory(alloc_id, alloc);
+ self.tcx.alloc_map.lock().set_alloc_id_memory(alloc_id, alloc);
// recurse into inner allocations
for &(_, alloc) in alloc.relocations.values() {
// FIXME: Reusing the mutability here is likely incorrect. It is originally
diff --git a/src/librustc_mir/interpret/validity.rs b/src/librustc_mir/interpret/validity.rs
index 4f17373..c7bfea8 100644
--- a/src/librustc_mir/interpret/validity.rs
+++ b/src/librustc_mir/interpret/validity.rs
@@ -17,7 +17,7 @@
use rustc::ty;
use rustc_data_structures::fx::FxHashSet;
use rustc::mir::interpret::{
- Scalar, AllocType, EvalResult, EvalErrorKind,
+ Scalar, AllocKind, EvalResult, EvalErrorKind,
};
use super::{
@@ -388,7 +388,7 @@
"integer pointer in non-ZST reference", self.path);
// Skip validation entirely for some external statics
let alloc_kind = self.ecx.tcx.alloc_map.lock().get(ptr.alloc_id);
- if let Some(AllocType::Static(did)) = alloc_kind {
+ if let Some(AllocKind::Static(did)) = alloc_kind {
// `extern static` cannot be validated as they have no body.
// FIXME: Statics from other crates are also skipped.
// They might be checked at a different type, but for now we
diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs
index c962a24..a6239a8 100644
--- a/src/librustc_mir/monomorphize/collector.rs
+++ b/src/librustc_mir/monomorphize/collector.rs
@@ -197,7 +197,7 @@
use rustc::mir::{self, Location, Promoted};
use rustc::mir::visit::Visitor as MirVisitor;
use rustc::mir::mono::MonoItem;
-use rustc::mir::interpret::{Scalar, GlobalId, AllocType, ErrorHandled};
+use rustc::mir::interpret::{Scalar, GlobalId, AllocKind, ErrorHandled};
use monomorphize::{self, Instance};
use rustc::util::nodemap::{FxHashSet, FxHashMap, DefIdMap};
@@ -1161,22 +1161,22 @@
alloc_id: AllocId,
output: &mut Vec<MonoItem<'tcx>>,
) {
- let alloc_type = tcx.alloc_map.lock().get(alloc_id);
- match alloc_type {
- Some(AllocType::Static(did)) => {
+ let alloc_kind = tcx.alloc_map.lock().get(alloc_id);
+ match alloc_kind {
+ Some(AllocKind::Static(did)) => {
let instance = Instance::mono(tcx, did);
if should_monomorphize_locally(tcx, &instance) {
trace!("collecting static {:?}", did);
output.push(MonoItem::Static(did));
}
}
- Some(AllocType::Memory(alloc)) => {
+ Some(AllocKind::Memory(alloc)) => {
trace!("collecting {:?} with {:#?}", alloc_id, alloc);
for &((), inner) in alloc.relocations.values() {
collect_miri(tcx, inner, output);
}
},
- Some(AllocType::Function(fn_instance)) => {
+ Some(AllocKind::Function(fn_instance)) => {
if should_monomorphize_locally(tcx, &fn_instance) {
trace!("collecting {:?} with {:#?}", alloc_id, fn_instance);
output.push(create_fn_mono_item(fn_instance));
diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs
index f4f6b3d..db4b686 100644
--- a/src/librustc_typeck/check/demand.rs
+++ b/src/librustc_typeck/check/demand.rs
@@ -123,7 +123,7 @@
let sole_field_ty = sole_field.ty(self.tcx, substs);
if self.can_coerce(expr_ty, sole_field_ty) {
let variant_path = self.tcx.item_path_str(variant.did);
- Some(variant_path.trim_left_matches("std::prelude::v1::").to_string())
+ Some(variant_path.trim_start_matches("std::prelude::v1::").to_string())
} else {
None
}
@@ -519,7 +519,7 @@
let suffix_suggestion = format!(
"{}{}{}{}",
if needs_paren { "(" } else { "" },
- src.trim_right_matches(&checked_ty.to_string()),
+ src.trim_end_matches(&checked_ty.to_string()),
expected_ty,
if needs_paren { ")" } else { "" },
);
diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs
index f4d05c6..b421f07 100644
--- a/src/librustdoc/config.rs
+++ b/src/librustdoc/config.rs
@@ -20,7 +20,7 @@
use rustc::session::config::{CodegenOptions, DebuggingOptions, ErrorOutputType, Externs};
use rustc::session::config::{nightly_options, build_codegen_options, build_debugging_options,
get_cmd_lint_options};
-use rustc::session::search_paths::SearchPaths;
+use rustc::session::search_paths::SearchPath;
use rustc_driver;
use rustc_target::spec::TargetTriple;
use syntax::edition::Edition;
@@ -46,7 +46,7 @@
/// How to format errors and warnings.
pub error_format: ErrorOutputType,
/// Library search paths to hand to the compiler.
- pub libs: SearchPaths,
+ pub libs: Vec<SearchPath>,
/// The list of external crates to link against.
pub externs: Externs,
/// List of `cfg` flags to hand to the compiler. Always includes `rustdoc`.
@@ -295,10 +295,9 @@
}
let input = PathBuf::from(&matches.free[0]);
- let mut libs = SearchPaths::new();
- for s in &matches.opt_strs("L") {
- libs.add_path(s, error_format);
- }
+ let libs = matches.opt_strs("L").iter()
+ .map(|s| SearchPath::from_cli_opt(s, error_format))
+ .collect();
let externs = match parse_externs(&matches) {
Ok(ex) => ex,
Err(err) => {
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index 047d355..b85342f 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -51,7 +51,7 @@
use passes;
pub use rustc::session::config::{Input, Options, CodegenOptions};
-pub use rustc::session::search_paths::SearchPaths;
+pub use rustc::session::search_paths::SearchPath;
pub type ExternalPaths = FxHashMap<DefId, (Vec<String>, clean::TypeKind)>;
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index 00ca4fe..536ea39 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -806,6 +806,10 @@
}
pub fn plain_summary_line(md: &str) -> String {
+ plain_summary_line_full(md, false)
+}
+
+pub fn plain_summary_line_full(md: &str, limit_length: bool) -> String {
struct ParserWrapper<'a> {
inner: Parser<'a>,
is_in: isize,
@@ -852,7 +856,21 @@
s.push_str(&t);
}
}
- s
+ if limit_length && s.chars().count() > 60 {
+ let mut len = 0;
+ let mut ret = s.split_whitespace()
+ .take_while(|p| {
+ // + 1 for the added character after the word.
+ len += p.chars().count() + 1;
+ len < 60
+ })
+ .collect::<Vec<_>>()
+ .join(" ");
+ ret.push('…');
+ ret
+ } else {
+ s
+ }
}
pub fn markdown_links(md: &str) -> Vec<(String, Option<Range<usize>>)> {
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
index 8d7942a..4b10c23 100644
--- a/src/librustdoc/html/render.rs
+++ b/src/librustdoc/html/render.rs
@@ -698,7 +698,7 @@
ty: item.type_(),
name: item.name.clone().unwrap(),
path: fqp[..fqp.len() - 1].join("::"),
- desc: plain_summary_line(item.doc_value()),
+ desc: plain_summary_line_short(item.doc_value()),
parent: Some(did),
parent_idx: None,
search_type: get_index_search_type(&item),
@@ -736,7 +736,7 @@
}
let crate_doc = krate.module.as_ref().map(|module| {
- plain_summary_line(module.doc_value())
+ plain_summary_line_short(module.doc_value())
}).unwrap_or(String::new());
let mut crate_data = BTreeMap::new();
@@ -1481,7 +1481,7 @@
ty: item.type_(),
name: s.to_string(),
path: path.join("::"),
- desc: plain_summary_line(item.doc_value()),
+ desc: plain_summary_line_short(item.doc_value()),
parent,
parent_idx: None,
search_type: get_index_search_type(&item),
@@ -1512,7 +1512,8 @@
clean::FunctionItem(..) | clean::ModuleItem(..) |
clean::ForeignFunctionItem(..) | clean::ForeignStaticItem(..) |
clean::ConstantItem(..) | clean::StaticItem(..) |
- clean::UnionItem(..) | clean::ForeignTypeItem | clean::MacroItem(..)
+ clean::UnionItem(..) | clean::ForeignTypeItem |
+ clean::MacroItem(..) | clean::ProcMacroItem(..)
if !self.stripped_mod => {
// Re-exported items mean that the same id can show up twice
// in the rustdoc ast that we're looking at. We know,
@@ -1673,7 +1674,7 @@
ty: item.type_(),
name: item_name.to_string(),
path: path.clone(),
- desc: plain_summary_line(item.doc_value()),
+ desc: plain_summary_line_short(item.doc_value()),
parent: None,
parent_idx: None,
search_type: get_index_search_type(&item),
@@ -2388,7 +2389,13 @@
#[inline]
fn plain_summary_line(s: Option<&str>) -> String {
let line = shorter(s).replace("\n", " ");
- markdown::plain_summary_line(&line[..])
+ markdown::plain_summary_line_full(&line[..], false)
+}
+
+#[inline]
+fn plain_summary_line_short(s: Option<&str>) -> String {
+ let line = shorter(s).replace("\n", " ");
+ markdown::plain_summary_line_full(&line[..], true)
}
fn document(w: &mut fmt::Formatter, cx: &Context, item: &clean::Item) -> fmt::Result {
diff --git a/src/librustdoc/markdown.rs b/src/librustdoc/markdown.rs
index e0e0be7..504567e 100644
--- a/src/librustdoc/markdown.rs
+++ b/src/librustdoc/markdown.rs
@@ -35,7 +35,7 @@
for line in s.lines() {
if line.starts_with("# ") || line.starts_with("%") {
// trim the whitespace after the symbol
- metadata.push(line[1..].trim_left());
+ metadata.push(line[1..].trim_start());
count += line.len() + 1;
} else {
return (metadata, &s[count..]);
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs
index 29062ba..2e8bfd8 100644
--- a/src/librustdoc/passes/collect_intra_doc_links.rs
+++ b/src/librustdoc/passes/collect_intra_doc_links.rs
@@ -294,23 +294,23 @@
"trait@", "union@"].iter()
.find(|p| link.starts_with(**p)) {
kind = PathKind::Type;
- link.trim_left_matches(prefix)
+ link.trim_start_matches(prefix)
} else if let Some(prefix) =
["const@", "static@",
"value@", "function@", "mod@",
"fn@", "module@", "method@"]
.iter().find(|p| link.starts_with(**p)) {
kind = PathKind::Value;
- link.trim_left_matches(prefix)
+ link.trim_start_matches(prefix)
} else if link.ends_with("()") {
kind = PathKind::Value;
- link.trim_right_matches("()")
+ link.trim_end_matches("()")
} else if link.starts_with("macro@") {
kind = PathKind::Macro;
- link.trim_left_matches("macro@")
+ link.trim_start_matches("macro@")
} else if link.ends_with('!') {
kind = PathKind::Macro;
- link.trim_right_matches('!')
+ link.trim_end_matches('!')
} else {
&link[..]
}.trim();
diff --git a/src/librustdoc/passes/unindent_comments.rs b/src/librustdoc/passes/unindent_comments.rs
index 6d875c1..5c565bf 100644
--- a/src/librustdoc/passes/unindent_comments.rs
+++ b/src/librustdoc/passes/unindent_comments.rs
@@ -95,7 +95,7 @@
});
if !lines.is_empty() {
- let mut unindented = vec![ lines[0].trim_left().to_string() ];
+ let mut unindented = vec![ lines[0].trim_start().to_string() ];
unindented.extend_from_slice(&lines[1..].iter().map(|&line| {
if line.chars().all(|c| c.is_whitespace()) {
line.to_string()
diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs
index be9327c..50acde6 100644
--- a/src/librustdoc/test.rs
+++ b/src/librustdoc/test.rs
@@ -21,7 +21,7 @@
use rustc::hir::intravisit;
use rustc::session::{self, CompileIncomplete, config};
use rustc::session::config::{OutputType, OutputTypes, Externs, CodegenOptions};
-use rustc::session::search_paths::{SearchPaths, PathKind};
+use rustc::session::search_paths::{SearchPath, PathKind};
use syntax::ast;
use syntax::source_map::SourceMap;
use syntax::edition::Edition;
@@ -187,7 +187,7 @@
}
fn run_test(test: &str, cratename: &str, filename: &FileName, line: usize,
- cfgs: Vec<String>, libs: SearchPaths,
+ cfgs: Vec<String>, libs: Vec<SearchPath>,
cg: CodegenOptions, externs: Externs,
should_panic: bool, no_run: bool, as_test_harness: bool,
compile_fail: bool, mut error_codes: Vec<String>, opts: &TestOptions,
@@ -556,7 +556,7 @@
names: Vec<String>,
cfgs: Vec<String>,
- libs: SearchPaths,
+ libs: Vec<SearchPath>,
cg: CodegenOptions,
externs: Externs,
use_headers: bool,
@@ -571,7 +571,7 @@
}
impl Collector {
- pub fn new(cratename: String, cfgs: Vec<String>, libs: SearchPaths, cg: CodegenOptions,
+ pub fn new(cratename: String, cfgs: Vec<String>, libs: Vec<SearchPath>, cg: CodegenOptions,
externs: Externs, use_headers: bool, opts: TestOptions,
maybe_sysroot: Option<PathBuf>, source_map: Option<Lrc<SourceMap>>,
filename: Option<PathBuf>, linker: Option<PathBuf>, edition: Edition) -> Collector {
diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
index 004be1c..287984c 100644
--- a/src/librustdoc/visit_ast.rs
+++ b/src/librustdoc/visit_ast.rs
@@ -424,10 +424,11 @@
hir::ItemKind::Use(ref path, kind) => {
let is_glob = kind == hir::UseKind::Glob;
- // Struct and variant constructors always show up alongside their definitions, we've
- // already processed them so just discard these.
+ // Struct and variant constructors and proc macro stubs always show up alongside
+ // their definitions, we've already processed them so just discard these.
match path.def {
- Def::StructCtor(..) | Def::VariantCtor(..) | Def::SelfCtor(..) => return,
+ Def::StructCtor(..) | Def::VariantCtor(..) | Def::SelfCtor(..) |
+ Def::Macro(_, MacroKind::ProcMacroStub) => return,
_ => {}
}
diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs
index 9439dc7..b0884e1 100644
--- a/src/libserialize/json.rs
+++ b/src/libserialize/json.rs
@@ -3493,7 +3493,7 @@
// Helper function for counting indents
fn indents(source: &str) -> usize {
- let trimmed = source.trim_left_matches(' ');
+ let trimmed = source.trim_start_matches(' ');
source.len() - trimmed.len()
}
diff --git a/src/libstd/error.rs b/src/libstd/error.rs
index a9b2711..e5c5ab8 100644
--- a/src/libstd/error.rs
+++ b/src/libstd/error.rs
@@ -533,6 +533,7 @@
Error::description(&**self)
}
+ #[allow(deprecated)]
fn cause(&self) -> Option<&dyn Error> {
Error::cause(&**self)
}
diff --git a/src/libstd/ffi/mod.rs b/src/libstd/ffi/mod.rs
index 99da73a..f46c4f2 100644
--- a/src/libstd/ffi/mod.rs
+++ b/src/libstd/ffi/mod.rs
@@ -174,7 +174,6 @@
#[stable(feature = "raw_os", since = "1.1.0")]
pub use core::ffi::c_void;
-#[cfg(not(stage0))]
#[unstable(feature = "c_variadic",
reason = "the `c_variadic` feature has not been properly tested on \
all supported platforms",
diff --git a/src/libstd/ffi/os_str.rs b/src/libstd/ffi/os_str.rs
index 8289721..766142f 100644
--- a/src/libstd/ffi/os_str.rs
+++ b/src/libstd/ffi/os_str.rs
@@ -536,17 +536,42 @@
///
/// # Examples
///
- /// Calling `to_string_lossy` on an `OsStr` with valid unicode:
+ /// Calling `to_string_lossy` on an `OsStr` with invalid unicode:
///
/// ```
- /// use std::ffi::OsStr;
+ /// // Note, due to differences in how Unix and Windows represent strings,
+ /// // we are forced to complicate this example, setting up example `OsStr`s
+ /// // with different source data and via different platform extensions.
+ /// // Understand that in reality you could end up with such example invalid
+ /// // sequences simply through collecting user command line arguments, for
+ /// // example.
///
- /// let os_str = OsStr::new("foo");
- /// assert_eq!(os_str.to_string_lossy(), "foo");
+ /// #[cfg(any(unix, target_os = "redox"))] {
+ /// use std::ffi::OsStr;
+ /// use std::os::unix::ffi::OsStrExt;
+ ///
+ /// // Here, the values 0x66 and 0x6f correspond to 'f' and 'o'
+ /// // respectively. The value 0x80 is a lone continuation byte, invalid
+ /// // in a UTF-8 sequence.
+ /// let source = [0x66, 0x6f, 0x80, 0x6f];
+ /// let os_str = OsStr::from_bytes(&source[..]);
+ ///
+ /// assert_eq!(os_str.to_string_lossy(), "fo�o");
+ /// }
+ /// #[cfg(windows)] {
+ /// use std::ffi::OsString;
+ /// use std::os::windows::prelude::*;
+ ///
+ /// // Here the values 0x0066 and 0x006f correspond to 'f' and 'o'
+ /// // respectively. The value 0xD800 is a lone surrogate half, invalid
+ /// // in a UTF-16 sequence.
+ /// let source = [0x0066, 0x006f, 0xD800, 0x006f];
+ /// let os_string = OsString::from_wide(&source[..]);
+ /// let os_str = os_string.as_os_str();
+ ///
+ /// assert_eq!(os_str.to_string_lossy(), "fo�o");
+ /// }
/// ```
- ///
- /// Had `os_str` contained invalid unicode, the `to_string_lossy` call might
- /// have returned `"fo�"`.
#[stable(feature = "rust1", since = "1.0.0")]
pub fn to_string_lossy(&self) -> Cow<str> {
self.inner.to_string_lossy()
diff --git a/src/libstd/io/error.rs b/src/libstd/io/error.rs
index 32e2996..d3844eb 100644
--- a/src/libstd/io/error.rs
+++ b/src/libstd/io/error.rs
@@ -555,6 +555,7 @@
}
}
+ #[allow(deprecated)]
fn cause(&self) -> Option<&dyn error::Error> {
match self.repr {
Repr::Os(..) => None,
diff --git a/src/libstd/io/lazy.rs b/src/libstd/io/lazy.rs
index c2aaeb9..24965ff 100644
--- a/src/libstd/io/lazy.rs
+++ b/src/libstd/io/lazy.rs
@@ -26,7 +26,6 @@
unsafe impl<T> Sync for Lazy<T> {}
impl<T> Lazy<T> {
- #[unstable(feature = "sys_internals", issue = "0")] // FIXME: min_const_fn
pub const fn new() -> Lazy<T> {
Lazy {
lock: Mutex::new(),
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index 90c8eaf..0febbe5 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -271,6 +271,7 @@
#![feature(libc)]
#![feature(link_args)]
#![feature(linkage)]
+#![cfg_attr(not(stage0), feature(min_const_unsafe_fn))]
#![feature(needs_panic_runtime)]
#![feature(never_type)]
#![feature(nll)]
@@ -317,10 +318,6 @@
#![default_lib_allocator]
-#[cfg(stage0)]
-#[global_allocator]
-static ALLOC: alloc::System = alloc::System;
-
// Explicitly import the prelude. The compiler uses this same unstable attribute
// to import the prelude implicitly when building crates that depend on std.
#[prelude_import]
diff --git a/src/libstd/panic.rs b/src/libstd/panic.rs
index 099b4d6..3eacc7a 100644
--- a/src/libstd/panic.rs
+++ b/src/libstd/panic.rs
@@ -264,7 +264,7 @@
#[cfg(target_has_atomic = "64")]
#[unstable(feature = "integer_atomics", issue = "32976")]
impl RefUnwindSafe for atomic::AtomicI64 {}
-#[cfg(all(not(stage0), target_has_atomic = "128"))]
+#[cfg(target_has_atomic = "128")]
#[unstable(feature = "integer_atomics", issue = "32976")]
impl RefUnwindSafe for atomic::AtomicI128 {}
@@ -283,7 +283,7 @@
#[cfg(target_has_atomic = "64")]
#[unstable(feature = "integer_atomics", issue = "32976")]
impl RefUnwindSafe for atomic::AtomicU64 {}
-#[cfg(all(not(stage0), target_has_atomic = "128"))]
+#[cfg(target_has_atomic = "128")]
#[unstable(feature = "integer_atomics", issue = "32976")]
impl RefUnwindSafe for atomic::AtomicU128 {}
diff --git a/src/libstd/panicking.rs b/src/libstd/panicking.rs
index 6b47ba6..b6180fb 100644
--- a/src/libstd/panicking.rs
+++ b/src/libstd/panicking.rs
@@ -209,7 +209,8 @@
if let Some(format) = log_backtrace {
let _ = backtrace::print(err, format);
} else if FIRST_PANIC.compare_and_swap(true, false, Ordering::SeqCst) {
- let _ = writeln!(err, "note: Run with `RUST_BACKTRACE=1` for a backtrace.");
+ let _ = writeln!(err, "note: Run with `RUST_BACKTRACE=1` \
+ environment variable to display a backtrace.");
}
}
};
diff --git a/src/libstd/sys/cloudabi/condvar.rs b/src/libstd/sys/cloudabi/condvar.rs
index ccf848a..3229d98 100644
--- a/src/libstd/sys/cloudabi/condvar.rs
+++ b/src/libstd/sys/cloudabi/condvar.rs
@@ -13,7 +13,7 @@
use sync::atomic::{AtomicU32, Ordering};
use sys::cloudabi::abi;
use sys::mutex::{self, Mutex};
-use sys::time::dur2intervals;
+use sys::time::checked_dur2intervals;
use time::Duration;
extern "C" {
@@ -114,6 +114,8 @@
// Call into the kernel to wait on the condition variable.
let condvar = self.condvar.get();
+ let timeout = checked_dur2intervals(&dur)
+ .expect("overflow converting duration to nanoseconds");
let subscriptions = [
abi::subscription {
type_: abi::eventtype::CONDVAR,
@@ -132,7 +134,7 @@
union: abi::subscription_union {
clock: abi::subscription_clock {
clock_id: abi::clockid::MONOTONIC,
- timeout: dur2intervals(&dur),
+ timeout,
..mem::zeroed()
},
},
diff --git a/src/libstd/sys/cloudabi/thread.rs b/src/libstd/sys/cloudabi/thread.rs
index a76e1fa..1773214 100644
--- a/src/libstd/sys/cloudabi/thread.rs
+++ b/src/libstd/sys/cloudabi/thread.rs
@@ -16,7 +16,7 @@
use mem;
use ptr;
use sys::cloudabi::abi;
-use sys::time::dur2intervals;
+use sys::time::checked_dur2intervals;
use sys_common::thread::*;
use time::Duration;
@@ -70,13 +70,15 @@
}
pub fn sleep(dur: Duration) {
+ let timeout = checked_dur2intervals(&dur)
+ .expect("overflow converting duration to nanoseconds");
unsafe {
let subscription = abi::subscription {
type_: abi::eventtype::CLOCK,
union: abi::subscription_union {
clock: abi::subscription_clock {
clock_id: abi::clockid::MONOTONIC,
- timeout: dur2intervals(&dur),
+ timeout,
..mem::zeroed()
},
},
diff --git a/src/libstd/sys/cloudabi/time.rs b/src/libstd/sys/cloudabi/time.rs
index a442d1e..c9fea18 100644
--- a/src/libstd/sys/cloudabi/time.rs
+++ b/src/libstd/sys/cloudabi/time.rs
@@ -19,15 +19,10 @@
t: abi::timestamp,
}
-fn checked_dur2intervals(dur: &Duration) -> Option<abi::timestamp> {
+pub fn checked_dur2intervals(dur: &Duration) -> Option<abi::timestamp> {
dur.as_secs()
- .checked_mul(NSEC_PER_SEC)
- .and_then(|nanos| nanos.checked_add(dur.subsec_nanos() as abi::timestamp))
-}
-
-pub fn dur2intervals(dur: &Duration) -> abi::timestamp {
- checked_dur2intervals(dur)
- .expect("overflow converting duration to nanoseconds")
+ .checked_mul(NSEC_PER_SEC)?
+ .checked_add(dur.subsec_nanos() as abi::timestamp)
}
impl Instant {
@@ -47,20 +42,16 @@
Duration::new(diff / NSEC_PER_SEC, (diff % NSEC_PER_SEC) as u32)
}
- pub fn add_duration(&self, other: &Duration) -> Instant {
- Instant {
- t: self.t
- .checked_add(dur2intervals(other))
- .expect("overflow when adding duration to instant"),
- }
+ pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
+ Some(Instant {
+ t: self.t.checked_add(checked_dur2intervals(other)?)?,
+ })
}
- pub fn sub_duration(&self, other: &Duration) -> Instant {
- Instant {
- t: self.t
- .checked_sub(dur2intervals(other))
- .expect("overflow when subtracting duration from instant"),
- }
+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+ Some(Instant {
+ t: self.t.checked_sub(checked_dur2intervals(other)?)?,
+ })
}
}
@@ -95,23 +86,16 @@
}
}
- pub fn add_duration(&self, other: &Duration) -> SystemTime {
- self.checked_add_duration(other)
- .expect("overflow when adding duration to instant")
- }
-
pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
- checked_dur2intervals(other)
- .and_then(|d| self.t.checked_add(d))
- .map(|t| SystemTime {t})
+ Some(SystemTime {
+ t: self.t.checked_add(checked_dur2intervals(other)?)?,
+ })
}
- pub fn sub_duration(&self, other: &Duration) -> SystemTime {
- SystemTime {
- t: self.t
- .checked_sub(dur2intervals(other))
- .expect("overflow when subtracting duration from instant"),
- }
+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+ Some(SystemTime {
+ t: self.t.checked_sub(checked_dur2intervals(other)?)?,
+ })
}
}
diff --git a/src/libstd/sys/redox/time.rs b/src/libstd/sys/redox/time.rs
index beff8d2..cb2eab5 100644
--- a/src/libstd/sys/redox/time.rs
+++ b/src/libstd/sys/redox/time.rs
@@ -41,10 +41,6 @@
}
}
- fn add_duration(&self, other: &Duration) -> Timespec {
- self.checked_add_duration(other).expect("overflow when adding duration to time")
- }
-
fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> {
let mut secs = other
.as_secs()
@@ -67,27 +63,25 @@
})
}
- fn sub_duration(&self, other: &Duration) -> Timespec {
+ fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {
let mut secs = other
.as_secs()
.try_into() // <- target type would be `i64`
.ok()
- .and_then(|secs| self.t.tv_sec.checked_sub(secs))
- .expect("overflow when subtracting duration from time");
+ .and_then(|secs| self.t.tv_sec.checked_sub(secs))?;
// Similar to above, nanos can't overflow.
let mut nsec = self.t.tv_nsec as i32 - other.subsec_nanos() as i32;
if nsec < 0 {
nsec += NSEC_PER_SEC as i32;
- secs = secs.checked_sub(1).expect("overflow when subtracting \
- duration from time");
+ secs = secs.checked_sub(1)?;
}
- Timespec {
+ Some(Timespec {
t: syscall::TimeSpec {
tv_sec: secs,
tv_nsec: nsec as i32,
},
- }
+ })
}
}
@@ -150,12 +144,12 @@
})
}
- pub fn add_duration(&self, other: &Duration) -> Instant {
- Instant { t: self.t.add_duration(other) }
+ pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
+ Some(Instant { t: self.t.checked_add_duration(other)? })
}
- pub fn sub_duration(&self, other: &Duration) -> Instant {
- Instant { t: self.t.sub_duration(other) }
+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+ Some(Instant { t: self.t.checked_sub_duration(other)? })
}
}
@@ -178,16 +172,12 @@
self.t.sub_timespec(&other.t)
}
- pub fn add_duration(&self, other: &Duration) -> SystemTime {
- SystemTime { t: self.t.add_duration(other) }
- }
-
pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
- self.t.checked_add_duration(other).map(|t| SystemTime { t })
+ Some(SystemTime { t: self.t.checked_add_duration(other)? })
}
- pub fn sub_duration(&self, other: &Duration) -> SystemTime {
- SystemTime { t: self.t.sub_duration(other) }
+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+ Some(SystemTime { t: self.t.checked_sub_duration(other)? })
}
}
diff --git a/src/libstd/sys/sgx/abi/mem.rs b/src/libstd/sys/sgx/abi/mem.rs
index 508f2ff..bf32c71 100644
--- a/src/libstd/sys/sgx/abi/mem.rs
+++ b/src/libstd/sys/sgx/abi/mem.rs
@@ -34,13 +34,6 @@
base
}
-pub fn is_enclave_range(p: *const u8, len: usize) -> bool {
- let start=p as u64;
- let end=start + (len as u64);
- start >= image_base() &&
- end <= image_base() + (unsafe { ENCLAVE_SIZE } as u64) // unsafe ok: link-time constant
-}
-
pub fn is_user_range(p: *const u8, len: usize) -> bool {
let start=p as u64;
let end=start + (len as u64);
diff --git a/src/libstd/sys/sgx/abi/usercalls/mod.rs b/src/libstd/sys/sgx/abi/usercalls/mod.rs
index 2bc32c9..d1d180e 100644
--- a/src/libstd/sys/sgx/abi/usercalls/mod.rs
+++ b/src/libstd/sys/sgx/abi/usercalls/mod.rs
@@ -33,14 +33,6 @@
}
}
-pub fn read_alloc(fd: Fd) -> IoResult<Vec<u8>> {
- unsafe {
- let mut userbuf = alloc::User::<ByteBuffer>::uninitialized();
- raw::read_alloc(fd, userbuf.as_raw_mut_ptr()).from_sgx_result()?;
- Ok(copy_user_buffer(&userbuf))
- }
-}
-
pub fn write(fd: Fd, buf: &[u8]) -> IoResult<usize> {
unsafe {
let userbuf = alloc::User::new_from_enclave(buf);
diff --git a/src/libstd/sys/sgx/condvar.rs b/src/libstd/sys/sgx/condvar.rs
index d3e8165..940f50f 100644
--- a/src/libstd/sys/sgx/condvar.rs
+++ b/src/libstd/sys/sgx/condvar.rs
@@ -18,7 +18,6 @@
}
impl Condvar {
- #[unstable(feature = "sgx_internals", issue = "0")] // FIXME: min_const_fn
pub const fn new() -> Condvar {
Condvar { inner: SpinMutex::new(WaitVariable::new(())) }
}
diff --git a/src/libstd/sys/sgx/mutex.rs b/src/libstd/sys/sgx/mutex.rs
index 6633611..994cf91 100644
--- a/src/libstd/sys/sgx/mutex.rs
+++ b/src/libstd/sys/sgx/mutex.rs
@@ -20,7 +20,6 @@
// Implementation according to “Operating Systems: Three Easy Pieces”, chapter 28
impl Mutex {
- #[unstable(feature = "sgx_internals", issue = "0")] // FIXME: min_const_fn
pub const fn new() -> Mutex {
Mutex { inner: SpinMutex::new(WaitVariable::new(false)) }
}
@@ -79,7 +78,6 @@
}
impl ReentrantMutex {
- #[unstable(feature = "sgx_internals", issue = "0")] // FIXME: min_const_fn
pub const fn uninitialized() -> ReentrantMutex {
ReentrantMutex {
inner: SpinMutex::new(WaitVariable::new(ReentrantLock { owner: None, count: 0 }))
diff --git a/src/libstd/sys/sgx/rwlock.rs b/src/libstd/sys/sgx/rwlock.rs
index 7b6970b..a1551db 100644
--- a/src/libstd/sys/sgx/rwlock.rs
+++ b/src/libstd/sys/sgx/rwlock.rs
@@ -21,7 +21,6 @@
//unsafe impl Sync for RWLock {} // FIXME
impl RWLock {
- #[unstable(feature = "sgx_internals", issue = "0")] // FIXME: min_const_fn
pub const fn new() -> RWLock {
RWLock {
readers: SpinMutex::new(WaitVariable::new(None)),
diff --git a/src/libstd/sys/sgx/time.rs b/src/libstd/sys/sgx/time.rs
index b01c992..196e1a9 100644
--- a/src/libstd/sys/sgx/time.rs
+++ b/src/libstd/sys/sgx/time.rs
@@ -28,12 +28,12 @@
self.0 - other.0
}
- pub fn add_duration(&self, other: &Duration) -> Instant {
- Instant(self.0 + *other)
+ pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
+ Some(Instant(self.0.checked_add(*other)?))
}
- pub fn sub_duration(&self, other: &Duration) -> Instant {
- Instant(self.0 - *other)
+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+ Some(Instant(self.0.checked_sub(*other)?))
}
}
@@ -47,15 +47,11 @@
self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)
}
- pub fn add_duration(&self, other: &Duration) -> SystemTime {
- SystemTime(self.0 + *other)
- }
-
pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
- self.0.checked_add(*other).map(|d| SystemTime(d))
+ Some(SystemTime(self.0.checked_add(*other)?))
}
- pub fn sub_duration(&self, other: &Duration) -> SystemTime {
- SystemTime(self.0 - *other)
+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+ Some(SystemTime(self.0.checked_sub(*other)?))
}
}
diff --git a/src/libstd/sys/sgx/waitqueue.rs b/src/libstd/sys/sgx/waitqueue.rs
index ec1135b..ef0def1 100644
--- a/src/libstd/sys/sgx/waitqueue.rs
+++ b/src/libstd/sys/sgx/waitqueue.rs
@@ -50,7 +50,6 @@
}
impl<T> WaitVariable<T> {
- #[unstable(feature = "sgx_internals", issue = "0")] // FIXME: min_const_fn
pub const fn new(var: T) -> Self {
WaitVariable {
queue: WaitQueue::new(),
@@ -137,7 +136,6 @@
}
impl WaitQueue {
- #[unstable(feature = "sgx_internals", issue = "0")] // FIXME: min_const_fn
pub const fn new() -> Self {
WaitQueue {
inner: UnsafeList::new()
@@ -255,7 +253,6 @@
}
impl<T> UnsafeList<T> {
- #[unstable(feature = "sgx_internals", issue = "0")] // FIXME: min_const_fn
pub const fn new() -> Self {
unsafe {
UnsafeList {
diff --git a/src/libstd/sys/unix/time.rs b/src/libstd/sys/unix/time.rs
index 1f9539c..8f8aaa8 100644
--- a/src/libstd/sys/unix/time.rs
+++ b/src/libstd/sys/unix/time.rs
@@ -42,10 +42,6 @@
}
}
- fn add_duration(&self, other: &Duration) -> Timespec {
- self.checked_add_duration(other).expect("overflow when adding duration to time")
- }
-
fn checked_add_duration(&self, other: &Duration) -> Option<Timespec> {
let mut secs = other
.as_secs()
@@ -68,27 +64,25 @@
})
}
- fn sub_duration(&self, other: &Duration) -> Timespec {
+ fn checked_sub_duration(&self, other: &Duration) -> Option<Timespec> {
let mut secs = other
.as_secs()
.try_into() // <- target type would be `libc::time_t`
.ok()
- .and_then(|secs| self.t.tv_sec.checked_sub(secs))
- .expect("overflow when subtracting duration from time");
+ .and_then(|secs| self.t.tv_sec.checked_sub(secs))?;
// Similar to above, nanos can't overflow.
let mut nsec = self.t.tv_nsec as i32 - other.subsec_nanos() as i32;
if nsec < 0 {
nsec += NSEC_PER_SEC as i32;
- secs = secs.checked_sub(1).expect("overflow when subtracting \
- duration from time");
+ secs = secs.checked_sub(1)?;
}
- Timespec {
+ Some(Timespec {
t: libc::timespec {
tv_sec: secs,
tv_nsec: nsec as _,
},
- }
+ })
}
}
@@ -165,18 +159,16 @@
Duration::new(nanos / NSEC_PER_SEC, (nanos % NSEC_PER_SEC) as u32)
}
- pub fn add_duration(&self, other: &Duration) -> Instant {
- Instant {
- t: self.t.checked_add(dur2intervals(other))
- .expect("overflow when adding duration to instant"),
- }
+ pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
+ Some(Instant {
+ t: self.t.checked_add(checked_dur2intervals(other)?)?,
+ })
}
- pub fn sub_duration(&self, other: &Duration) -> Instant {
- Instant {
- t: self.t.checked_sub(dur2intervals(other))
- .expect("overflow when subtracting duration from instant"),
- }
+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+ Some(Instant {
+ t: self.t.checked_sub(checked_dur2intervals(other)?)?,
+ })
}
}
@@ -199,16 +191,12 @@
self.t.sub_timespec(&other.t)
}
- pub fn add_duration(&self, other: &Duration) -> SystemTime {
- SystemTime { t: self.t.add_duration(other) }
- }
-
pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
- self.t.checked_add_duration(other).map(|t| SystemTime { t })
+ Some(SystemTime { t: self.t.checked_add_duration(other)? })
}
- pub fn sub_duration(&self, other: &Duration) -> SystemTime {
- SystemTime { t: self.t.sub_duration(other) }
+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+ Some(SystemTime { t: self.t.checked_sub_duration(other)? })
}
}
@@ -236,12 +224,12 @@
}
}
- fn dur2intervals(dur: &Duration) -> u64 {
+ fn checked_dur2intervals(dur: &Duration) -> Option<u64> {
+ let nanos = dur.as_secs()
+ .checked_mul(NSEC_PER_SEC)?
+ .checked_add(dur.subsec_nanos() as u64)?;
let info = info();
- let nanos = dur.as_secs().checked_mul(NSEC_PER_SEC).and_then(|nanos| {
- nanos.checked_add(dur.subsec_nanos() as u64)
- }).expect("overflow converting duration to nanoseconds");
- mul_div_u64(nanos, info.denom as u64, info.numer as u64)
+ Some(mul_div_u64(nanos, info.denom as u64, info.numer as u64))
}
fn info() -> &'static libc::mach_timebase_info {
@@ -299,12 +287,12 @@
})
}
- pub fn add_duration(&self, other: &Duration) -> Instant {
- Instant { t: self.t.add_duration(other) }
+ pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
+ Some(Instant { t: self.t.checked_add_duration(other)? })
}
- pub fn sub_duration(&self, other: &Duration) -> Instant {
- Instant { t: self.t.sub_duration(other) }
+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+ Some(Instant { t: self.t.checked_sub_duration(other)? })
}
}
@@ -327,16 +315,12 @@
self.t.sub_timespec(&other.t)
}
- pub fn add_duration(&self, other: &Duration) -> SystemTime {
- SystemTime { t: self.t.add_duration(other) }
- }
-
pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
- self.t.checked_add_duration(other).map(|t| SystemTime { t })
+ Some(SystemTime { t: self.t.checked_add_duration(other)? })
}
- pub fn sub_duration(&self, other: &Duration) -> SystemTime {
- SystemTime { t: self.t.sub_duration(other) }
+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+ Some(SystemTime { t: self.t.checked_sub_duration(other)? })
}
}
diff --git a/src/libstd/sys/wasm/time.rs b/src/libstd/sys/wasm/time.rs
index 991e817..cc56773 100644
--- a/src/libstd/sys/wasm/time.rs
+++ b/src/libstd/sys/wasm/time.rs
@@ -28,12 +28,12 @@
self.0 - other.0
}
- pub fn add_duration(&self, other: &Duration) -> Instant {
- Instant(self.0 + *other)
+ pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
+ Some(Instant(self.0.checked_add(*other)?))
}
- pub fn sub_duration(&self, other: &Duration) -> Instant {
- Instant(self.0 - *other)
+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
+ Some(Instant(self.0.checked_sub(*other)?))
}
}
@@ -47,15 +47,11 @@
self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)
}
- pub fn add_duration(&self, other: &Duration) -> SystemTime {
- SystemTime(self.0 + *other)
- }
-
pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
- self.0.checked_add(*other).map(|d| SystemTime(d))
+ Some(SystemTime(self.0.checked_add(*other)?))
}
- pub fn sub_duration(&self, other: &Duration) -> SystemTime {
- SystemTime(self.0 - *other)
+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+ Some(SystemTime(self.0.checked_sub(*other)?))
}
}
diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs
index 2be30e6..84ef62e 100644
--- a/src/libstd/sys/windows/os.rs
+++ b/src/libstd/sys/windows/os.rs
@@ -76,7 +76,7 @@
match String::from_utf16(&buf[..res]) {
Ok(mut msg) => {
// Trim trailing CRLF inserted by FormatMessageW
- let len = msg.trim_right().len();
+ let len = msg.trim_end().len();
msg.truncate(len);
msg
},
diff --git a/src/libstd/sys/windows/time.rs b/src/libstd/sys/windows/time.rs
index c809a0b..bb2c97e 100644
--- a/src/libstd/sys/windows/time.rs
+++ b/src/libstd/sys/windows/time.rs
@@ -68,30 +68,27 @@
Duration::new(nanos / NANOS_PER_SEC, (nanos % NANOS_PER_SEC) as u32)
}
- pub fn add_duration(&self, other: &Duration) -> Instant {
+ pub fn checked_add_duration(&self, other: &Duration) -> Option<Instant> {
let freq = frequency() as u64;
- let t = other.as_secs().checked_mul(freq).and_then(|i| {
- (self.t as u64).checked_add(i)
- }).and_then(|i| {
- i.checked_add(mul_div_u64(other.subsec_nanos() as u64, freq,
- NANOS_PER_SEC))
- }).expect("overflow when adding duration to time");
- Instant {
+ let t = other.as_secs()
+ .checked_mul(freq)?
+ .checked_add(mul_div_u64(other.subsec_nanos() as u64, freq, NANOS_PER_SEC))?
+ .checked_add(self.t as u64)?;
+ Some(Instant {
t: t as c::LARGE_INTEGER,
- }
+ })
}
- pub fn sub_duration(&self, other: &Duration) -> Instant {
+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<Instant> {
let freq = frequency() as u64;
let t = other.as_secs().checked_mul(freq).and_then(|i| {
(self.t as u64).checked_sub(i)
}).and_then(|i| {
- i.checked_sub(mul_div_u64(other.subsec_nanos() as u64, freq,
- NANOS_PER_SEC))
- }).expect("overflow when subtracting duration from time");
- Instant {
+ i.checked_sub(mul_div_u64(other.subsec_nanos() as u64, freq, NANOS_PER_SEC))
+ })?;
+ Some(Instant {
t: t as c::LARGE_INTEGER,
- }
+ })
}
}
@@ -127,20 +124,14 @@
}
}
- pub fn add_duration(&self, other: &Duration) -> SystemTime {
- self.checked_add_duration(other).expect("overflow when adding duration to time")
- }
-
pub fn checked_add_duration(&self, other: &Duration) -> Option<SystemTime> {
- checked_dur2intervals(other)
- .and_then(|d| self.intervals().checked_add(d))
- .map(|i| SystemTime::from_intervals(i))
+ let intervals = self.intervals().checked_add(checked_dur2intervals(other)?)?;
+ Some(SystemTime::from_intervals(intervals))
}
- pub fn sub_duration(&self, other: &Duration) -> SystemTime {
- let intervals = self.intervals().checked_sub(dur2intervals(other))
- .expect("overflow when subtracting from time");
- SystemTime::from_intervals(intervals)
+ pub fn checked_sub_duration(&self, other: &Duration) -> Option<SystemTime> {
+ let intervals = self.intervals().checked_sub(checked_dur2intervals(other)?)?;
+ Some(SystemTime::from_intervals(intervals))
}
}
@@ -184,16 +175,12 @@
}
}
-fn checked_dur2intervals(d: &Duration) -> Option<i64> {
- d.as_secs()
- .checked_mul(INTERVALS_PER_SEC)
- .and_then(|i| i.checked_add(d.subsec_nanos() as u64 / 100))
- .and_then(|i| i.try_into().ok())
-}
-
-fn dur2intervals(d: &Duration) -> i64 {
- checked_dur2intervals(d)
- .expect("overflow when converting duration to intervals")
+fn checked_dur2intervals(dur: &Duration) -> Option<i64> {
+ dur.as_secs()
+ .checked_mul(INTERVALS_PER_SEC)?
+ .checked_add(dur.subsec_nanos() as u64 / 100)?
+ .try_into()
+ .ok()
}
fn intervals2dur(intervals: u64) -> Duration {
diff --git a/src/libstd/sys_common/condvar.rs b/src/libstd/sys_common/condvar.rs
index 16bf080..b6f29dd 100644
--- a/src/libstd/sys_common/condvar.rs
+++ b/src/libstd/sys_common/condvar.rs
@@ -25,7 +25,6 @@
///
/// Behavior is undefined if the condition variable is moved after it is
/// first used with any of the functions below.
- #[unstable(feature = "sys_internals", issue = "0")] // FIXME: min_const_fn
pub const fn new() -> Condvar { Condvar(imp::Condvar::new()) }
/// Prepares the condition variable for use.
diff --git a/src/libstd/sys_common/mutex.rs b/src/libstd/sys_common/mutex.rs
index 8768423..c6d531c 100644
--- a/src/libstd/sys_common/mutex.rs
+++ b/src/libstd/sys_common/mutex.rs
@@ -27,7 +27,6 @@
/// Also, until `init` is called, behavior is undefined if this
/// mutex is ever used reentrantly, i.e., `raw_lock` or `try_lock`
/// are called by the thread currently holding the lock.
- #[unstable(feature = "sys_internals", issue = "0")] // FIXME: min_const_fn
pub const fn new() -> Mutex { Mutex(imp::Mutex::new()) }
/// Prepare the mutex for use.
diff --git a/src/libstd/sys_common/rwlock.rs b/src/libstd/sys_common/rwlock.rs
index a430c25..71a4f01 100644
--- a/src/libstd/sys_common/rwlock.rs
+++ b/src/libstd/sys_common/rwlock.rs
@@ -22,7 +22,6 @@
///
/// Behavior is undefined if the reader-writer lock is moved after it is
/// first used with any of the functions below.
- #[unstable(feature = "sys_internals", issue = "0")] // FIXME: min_const_fn
pub const fn new() -> RWLock { RWLock(imp::RWLock::new()) }
/// Acquires shared access to the underlying lock, blocking the current
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index 6678104..63cede7 100644
--- a/src/libstd/time.rs
+++ b/src/libstd/time.rs
@@ -208,6 +208,22 @@
pub fn elapsed(&self) -> Duration {
Instant::now() - *self
}
+
+ /// Returns `Some(t)` where `t` is the time `self + duration` if `t` can be represented as
+ /// `Instant` (which means it's inside the bounds of the underlying data structure), `None`
+ /// otherwise.
+ #[unstable(feature = "time_checked_add", issue = "55940")]
+ pub fn checked_add(&self, duration: Duration) -> Option<Instant> {
+ self.0.checked_add_duration(&duration).map(|t| Instant(t))
+ }
+
+ /// Returns `Some(t)` where `t` is the time `self - duration` if `t` can be represented as
+ /// `Instant` (which means it's inside the bounds of the underlying data structure), `None`
+ /// otherwise.
+ #[unstable(feature = "time_checked_add", issue = "55940")]
+ pub fn checked_sub(&self, duration: Duration) -> Option<Instant> {
+ self.0.checked_sub_duration(&duration).map(|t| Instant(t))
+ }
}
#[stable(feature = "time2", since = "1.8.0")]
@@ -215,7 +231,8 @@
type Output = Instant;
fn add(self, other: Duration) -> Instant {
- Instant(self.0.add_duration(&other))
+ self.checked_add(other)
+ .expect("overflow when adding duration to instant")
}
}
@@ -231,7 +248,8 @@
type Output = Instant;
fn sub(self, other: Duration) -> Instant {
- Instant(self.0.sub_duration(&other))
+ self.checked_sub(other)
+ .expect("overflow when subtracting duration from instant")
}
}
@@ -365,6 +383,14 @@
pub fn checked_add(&self, duration: Duration) -> Option<SystemTime> {
self.0.checked_add_duration(&duration).map(|t| SystemTime(t))
}
+
+ /// Returns `Some(t)` where `t` is the time `self - duration` if `t` can be represented as
+ /// `SystemTime` (which means it's inside the bounds of the underlying data structure), `None`
+ /// otherwise.
+ #[unstable(feature = "time_checked_add", issue = "55940")]
+ pub fn checked_sub(&self, duration: Duration) -> Option<SystemTime> {
+ self.0.checked_sub_duration(&duration).map(|t| SystemTime(t))
+ }
}
#[stable(feature = "time2", since = "1.8.0")]
@@ -372,7 +398,8 @@
type Output = SystemTime;
fn add(self, dur: Duration) -> SystemTime {
- SystemTime(self.0.add_duration(&dur))
+ self.checked_add(dur)
+ .expect("overflow when adding duration to instant")
}
}
@@ -388,7 +415,8 @@
type Output = SystemTime;
fn sub(self, dur: Duration) -> SystemTime {
- SystemTime(self.0.sub_duration(&dur))
+ self.checked_sub(dur)
+ .expect("overflow when subtracting duration from instant")
}
}
@@ -521,6 +549,20 @@
let second = Duration::new(1, 0);
assert_almost_eq!(a - second + second, a);
+ assert_almost_eq!(a.checked_sub(second).unwrap().checked_add(second).unwrap(), a);
+
+ // checked_add_duration will not panic on overflow
+ let mut maybe_t = Some(Instant::now());
+ let max_duration = Duration::from_secs(u64::max_value());
+ // in case `Instant` can store `>= now + max_duration`.
+ for _ in 0..2 {
+ maybe_t = maybe_t.and_then(|t| t.checked_add(max_duration));
+ }
+ assert_eq!(maybe_t, None);
+
+ // checked_add_duration calculates the right time and will work for another year
+ let year = Duration::from_secs(60 * 60 * 24 * 365);
+ assert_eq!(a + year, a.checked_add(year).unwrap());
}
#[test]
@@ -557,6 +599,7 @@
.duration(), second);
assert_almost_eq!(a - second + second, a);
+ assert_almost_eq!(a.checked_sub(second).unwrap().checked_add(second).unwrap(), a);
// A difference of 80 and 800 years cannot fit inside a 32-bit time_t
if !(cfg!(unix) && ::mem::size_of::<::libc::time_t>() <= 4) {
diff --git a/src/libsyntax/diagnostics/plugin.rs b/src/libsyntax/diagnostics/plugin.rs
index 1229db9..3b88767 100644
--- a/src/libsyntax/diagnostics/plugin.rs
+++ b/src/libsyntax/diagnostics/plugin.rs
@@ -141,6 +141,7 @@
])
}
+#[allow(deprecated)]
pub fn expand_build_diagnostic_array<'cx>(ecx: &'cx mut ExtCtxt,
span: Span,
token_tree: &[TokenTree])
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index eb71003..10c451e 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -15,7 +15,7 @@
use early_buffered_lints::{BufferedEarlyLint, BufferedEarlyLintId};
use source_map::{SourceMap, FilePathMapping};
use syntax_pos::{Span, SourceFile, FileName, MultiSpan};
-use errors::{Handler, ColorConfig, Diagnostic, DiagnosticBuilder};
+use errors::{FatalError, Level, Handler, ColorConfig, Diagnostic, DiagnosticBuilder};
use feature_gate::UnstableFeatures;
use parse::parser::Parser;
use ptr::P;
@@ -192,6 +192,14 @@
source_file_to_parser(sess, file_to_source_file(sess, path, None))
}
+/// Create a new parser, returning buffered diagnostics if the file doesn't
+/// exist or from lexing the initial token stream.
+pub fn maybe_new_parser_from_file<'a>(sess: &'a ParseSess, path: &Path)
+ -> Result<Parser<'a>, Vec<Diagnostic>> {
+ let file = try_file_to_source_file(sess, path, None).map_err(|db| vec![db])?;
+ maybe_source_file_to_parser(sess, file)
+}
+
/// Given a session, a crate config, a path, and a span, add
/// the file at the given path to the source_map, and return a parser.
/// On an error, use the given span as the source of the problem.
@@ -237,17 +245,30 @@
// base abstractions
/// Given a session and a path and an optional span (for error reporting),
+/// add the path to the session's source_map and return the new source_file or
+/// error when a file can't be read.
+fn try_file_to_source_file(sess: &ParseSess, path: &Path, spanopt: Option<Span>)
+ -> Result<Lrc<SourceFile>, Diagnostic> {
+ sess.source_map().load_file(path)
+ .map_err(|e| {
+ let msg = format!("couldn't read {}: {}", path.display(), e);
+ let mut diag = Diagnostic::new(Level::Fatal, &msg);
+ if let Some(sp) = spanopt {
+ diag.set_span(sp);
+ }
+ diag
+ })
+}
+
+/// Given a session and a path and an optional span (for error reporting),
/// add the path to the session's source_map and return the new source_file.
fn file_to_source_file(sess: &ParseSess, path: &Path, spanopt: Option<Span>)
-> Lrc<SourceFile> {
- match sess.source_map().load_file(path) {
+ match try_file_to_source_file(sess, path, spanopt) {
Ok(source_file) => source_file,
- Err(e) => {
- let msg = format!("couldn't read {}: {}", path.display(), e);
- match spanopt {
- Some(sp) => sess.span_diagnostic.span_fatal(sp, &msg).raise(),
- None => sess.span_diagnostic.fatal(&msg).raise()
- }
+ Err(d) => {
+ DiagnosticBuilder::new_diagnostic(&sess.span_diagnostic, d).emit();
+ FatalError.raise();
}
}
}
diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs
index 8e4d3c0..ed74665 100644
--- a/src/libsyntax/parse/token.rs
+++ b/src/libsyntax/parse/token.rs
@@ -207,6 +207,10 @@
Eof,
}
+// `Token` is used a lot. Make sure it doesn't unintentionally get bigger.
+#[cfg(target_arch = "x86_64")]
+static_assert!(MEM_SIZE_OF_STATEMENT: mem::size_of::<Token>() == 16);
+
impl Token {
pub fn interpolated(nt: Nonterminal) -> Token {
Token::Interpolated(Lrc::new((nt, LazyTokenStream::new())))
diff --git a/src/libsyntax/source_map.rs b/src/libsyntax/source_map.rs
index 4500812..9a34312 100644
--- a/src/libsyntax/source_map.rs
+++ b/src/libsyntax/source_map.rs
@@ -579,7 +579,7 @@
match self.span_to_prev_source(sp) {
Err(_) => None,
Ok(source) => source.split('\n').last().map(|last_line| {
- last_line.len() - last_line.trim_left().len()
+ last_line.len() - last_line.trim_start().len()
})
}
}
@@ -593,7 +593,7 @@
/// if no character could be found or if an error occurred while retrieving the code snippet.
pub fn span_extend_to_prev_char(&self, sp: Span, c: char) -> Span {
if let Ok(prev_source) = self.span_to_prev_source(sp) {
- let prev_source = prev_source.rsplit(c).nth(0).unwrap_or("").trim_left();
+ let prev_source = prev_source.rsplit(c).nth(0).unwrap_or("").trim_start();
if !prev_source.is_empty() && !prev_source.contains('\n') {
return sp.with_lo(BytePos(sp.lo().0 - prev_source.len() as u32));
}
@@ -613,7 +613,7 @@
for ws in &[" ", "\t", "\n"] {
let pat = pat.to_owned() + ws;
if let Ok(prev_source) = self.span_to_prev_source(sp) {
- let prev_source = prev_source.rsplit(&pat).nth(0).unwrap_or("").trim_left();
+ let prev_source = prev_source.rsplit(&pat).nth(0).unwrap_or("").trim_start();
if !prev_source.is_empty() && (!prev_source.contains('\n') || accept_newlines) {
return sp.with_lo(BytePos(sp.lo().0 - prev_source.len() as u32));
}
@@ -627,7 +627,7 @@
pub fn span_until_char(&self, sp: Span, c: char) -> Span {
match self.span_to_snippet(sp) {
Ok(snippet) => {
- let snippet = snippet.split(c).nth(0).unwrap_or("").trim_right();
+ let snippet = snippet.split(c).nth(0).unwrap_or("").trim_end();
if !snippet.is_empty() && !snippet.contains('\n') {
sp.with_hi(BytePos(sp.lo().0 + snippet.len() as u32))
} else {
diff --git a/src/libsyntax_pos/lib.rs b/src/libsyntax_pos/lib.rs
index 8b7ffa4..9aafb9f 100644
--- a/src/libsyntax_pos/lib.rs
+++ b/src/libsyntax_pos/lib.rs
@@ -24,10 +24,13 @@
#![feature(nll)]
#![feature(non_exhaustive)]
#![feature(optin_builtin_traits)]
+#![feature(rustc_attrs)]
#![feature(specialization)]
+#![feature(step_trait)]
#![cfg_attr(not(stage0), feature(stdsimd))]
extern crate arena;
+#[macro_use]
extern crate rustc_data_structures;
#[macro_use]
diff --git a/src/libsyntax_pos/symbol.rs b/src/libsyntax_pos/symbol.rs
index 05c5387..b720db8 100644
--- a/src/libsyntax_pos/symbol.rs
+++ b/src/libsyntax_pos/symbol.rs
@@ -14,6 +14,7 @@
use arena::DroplessArena;
use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::indexed_vec::Idx;
use serialize::{Decodable, Decoder, Encodable, Encoder};
use std::fmt;
@@ -57,7 +58,7 @@
}
pub fn without_first_quote(self) -> Ident {
- Ident::new(Symbol::intern(self.as_str().trim_left_matches('\'')), self.span)
+ Ident::new(Symbol::intern(self.as_str().trim_start_matches('\'')), self.span)
}
/// "Normalize" ident for use in comparisons using "item hygiene".
@@ -143,9 +144,18 @@
}
}
-/// A symbol is an interned or gensymed string.
+/// A symbol is an interned or gensymed string. The use of newtype_index! means
+/// that Option<Symbol> only takes up 4 bytes, because newtype_index! reserves
+/// the last 256 values for tagging purposes.
+///
+/// Note that Symbol cannot be a newtype_index! directly because it implements
+/// fmt::Debug, Encodable, and Decodable in special ways.
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Symbol(u32);
+pub struct Symbol(SymbolIndex);
+
+newtype_index! {
+ pub struct SymbolIndex { .. }
+}
// The interner is pointed to by a thread local value which is only set on the main thread
// with parallelization is disabled. So we don't allow `Symbol` to transfer between threads
@@ -156,6 +166,10 @@
impl !Sync for Symbol { }
impl Symbol {
+ const fn new(n: u32) -> Self {
+ Symbol(SymbolIndex::from_u32_const(n))
+ }
+
/// Maps a string to its interned representation.
pub fn intern(string: &str) -> Self {
with_interner(|interner| interner.intern(string))
@@ -189,7 +203,7 @@
}
pub fn as_u32(self) -> u32 {
- self.0
+ self.0.as_u32()
}
}
@@ -197,7 +211,7 @@
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let is_gensymed = with_interner(|interner| interner.is_gensymed(*self));
if is_gensymed {
- write!(f, "{}({})", self, self.0)
+ write!(f, "{}({:?})", self, self.0)
} else {
write!(f, "{}", self)
}
@@ -229,6 +243,9 @@
}
// The `&'static str`s in this type actually point into the arena.
+//
+// Note that normal symbols are indexed upward from 0, and gensyms are indexed
+// downward from SymbolIndex::MAX_AS_U32.
#[derive(Default)]
pub struct Interner {
arena: DroplessArena,
@@ -243,7 +260,7 @@
for &string in init {
if string == "" {
// We can't allocate empty strings in the arena, so handle this here.
- let name = Symbol(this.strings.len() as u32);
+ let name = Symbol::new(this.strings.len() as u32);
this.names.insert("", name);
this.strings.push("");
} else {
@@ -258,7 +275,7 @@
return name;
}
- let name = Symbol(self.strings.len() as u32);
+ let name = Symbol::new(self.strings.len() as u32);
// `from_utf8_unchecked` is safe since we just allocated a `&str` which is known to be
// UTF-8.
@@ -276,10 +293,10 @@
}
pub fn interned(&self, symbol: Symbol) -> Symbol {
- if (symbol.0 as usize) < self.strings.len() {
+ if (symbol.0.as_usize()) < self.strings.len() {
symbol
} else {
- self.interned(self.gensyms[(!0 - symbol.0) as usize])
+ self.interned(self.gensyms[(SymbolIndex::MAX_AS_U32 - symbol.0.as_u32()) as usize])
}
}
@@ -290,17 +307,17 @@
fn gensymed(&mut self, symbol: Symbol) -> Symbol {
self.gensyms.push(symbol);
- Symbol(!0 - self.gensyms.len() as u32 + 1)
+ Symbol::new(SymbolIndex::MAX_AS_U32 - self.gensyms.len() as u32 + 1)
}
fn is_gensymed(&mut self, symbol: Symbol) -> bool {
- symbol.0 as usize >= self.strings.len()
+ symbol.0.as_usize() >= self.strings.len()
}
pub fn get(&self, symbol: Symbol) -> &str {
- match self.strings.get(symbol.0 as usize) {
+ match self.strings.get(symbol.0.as_usize()) {
Some(string) => string,
- None => self.get(self.gensyms[(!0 - symbol.0) as usize]),
+ None => self.get(self.gensyms[(SymbolIndex::MAX_AS_U32 - symbol.0.as_u32()) as usize]),
}
}
}
@@ -324,7 +341,7 @@
$(
#[allow(non_upper_case_globals)]
pub const $konst: Keyword = Keyword {
- ident: Ident::with_empty_ctxt(super::Symbol($index))
+ ident: Ident::with_empty_ctxt(super::Symbol::new($index))
};
)*
@@ -709,19 +726,19 @@
fn interner_tests() {
let mut i: Interner = Interner::default();
// first one is zero:
- assert_eq!(i.intern("dog"), Symbol(0));
+ assert_eq!(i.intern("dog"), Symbol::new(0));
// re-use gets the same entry:
- assert_eq!(i.intern("dog"), Symbol(0));
+ assert_eq!(i.intern("dog"), Symbol::new(0));
// different string gets a different #:
- assert_eq!(i.intern("cat"), Symbol(1));
- assert_eq!(i.intern("cat"), Symbol(1));
+ assert_eq!(i.intern("cat"), Symbol::new(1));
+ assert_eq!(i.intern("cat"), Symbol::new(1));
// dog is still at zero
- assert_eq!(i.intern("dog"), Symbol(0));
- assert_eq!(i.gensym("zebra"), Symbol(4294967295));
- // gensym of same string gets new number :
- assert_eq!(i.gensym("zebra"), Symbol(4294967294));
+ assert_eq!(i.intern("dog"), Symbol::new(0));
+ assert_eq!(i.gensym("zebra"), Symbol::new(SymbolIndex::MAX_AS_U32));
+ // gensym of same string gets new number:
+ assert_eq!(i.gensym("zebra"), Symbol::new(SymbolIndex::MAX_AS_U32 - 1));
// gensym of *existing* string gets new number:
- assert_eq!(i.gensym("dog"), Symbol(4294967293));
+ assert_eq!(i.gensym("dog"), Symbol::new(SymbolIndex::MAX_AS_U32 - 2));
}
#[test]
diff --git a/src/stage0.txt b/src/stage0.txt
index 8369413..843ecae 100644
--- a/src/stage0.txt
+++ b/src/stage0.txt
@@ -12,7 +12,7 @@
# source tarball for a stable release you'll likely see `1.x.0` for rustc and
# `0.x.0` for Cargo where they were released on `date`.
-date: 2018-11-21
+date: 2018-12-09
rustc: beta
cargo: beta
diff --git a/src/test/codegen/nounwind-extern.rs b/src/test/codegen/nounwind-extern.rs
new file mode 100644
index 0000000..ed07cf1
--- /dev/null
+++ b/src/test/codegen/nounwind-extern.rs
@@ -0,0 +1,16 @@
+// Copyright 2018 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: -O
+
+#![crate_type = "lib"]
+
+// CHECK: Function Attrs: norecurse nounwind
+pub extern fn foo() {}
diff --git a/src/test/compile-fail/issue-10755.rs b/src/test/compile-fail/issue-10755.rs
index 57915bc..bb77748 100644
--- a/src/test/compile-fail/issue-10755.rs
+++ b/src/test/compile-fail/issue-10755.rs
@@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// compile-flags: -C linker=llllll -Z linker-flavor=ld
+// compile-flags: -C linker=llllll -C linker-flavor=ld
// error-pattern: linker `llllll` not found
fn main() {
diff --git a/src/test/compile-fail/nolink-with-link-args.rs b/src/test/compile-fail/nolink-with-link-args.rs
index 6dfd74f..95f827e 100644
--- a/src/test/compile-fail/nolink-with-link-args.rs
+++ b/src/test/compile-fail/nolink-with-link-args.rs
@@ -9,7 +9,7 @@
// except according to those terms.
// error-pattern:aFdEfSeVEE
-// compile-flags: -Z linker-flavor=ld
+// compile-flags: -C linker-flavor=ld
/* We're testing that link_args are indeed passed when nolink is specified.
So we try to compile with junk link_args and make sure they are visible in
diff --git a/src/test/run-make-fulldeps/libtest-json/output.json b/src/test/run-make-fulldeps/libtest-json/output.json
index 80e75c8..2b831ea 100644
--- a/src/test/run-make-fulldeps/libtest-json/output.json
+++ b/src/test/run-make-fulldeps/libtest-json/output.json
@@ -2,7 +2,7 @@
{ "type": "test", "event": "started", "name": "a" }
{ "type": "test", "name": "a", "event": "ok" }
{ "type": "test", "event": "started", "name": "b" }
-{ "type": "test", "name": "b", "event": "failed", "stdout": "thread 'main' panicked at 'assertion failed: false', f.rs:18:5\nnote: Run with `RUST_BACKTRACE=1` for a backtrace.\n" }
+{ "type": "test", "name": "b", "event": "failed", "stdout": "thread 'main' panicked at 'assertion failed: false', f.rs:18:5\nnote: Run with `RUST_BACKTRACE=1` environment variable to display a backtrace.\n" }
{ "type": "test", "event": "started", "name": "c" }
{ "type": "test", "name": "c", "event": "ok" }
{ "type": "test", "event": "started", "name": "d" }
diff --git a/src/test/run-pass/abort-on-c-abi.rs b/src/test/run-pass/abort-on-c-abi.rs
index 17b2ee3..12b5b78 100644
--- a/src/test/run-pass/abort-on-c-abi.rs
+++ b/src/test/run-pass/abort-on-c-abi.rs
@@ -15,14 +15,11 @@
// ignore-cloudabi no env and process
// ignore-emscripten no processes
-#![feature(unwind_attributes)]
-
use std::{env, panic};
use std::io::prelude::*;
use std::io;
use std::process::{Command, Stdio};
-#[unwind(aborts)]
extern "C" fn panic_in_ffi() {
panic!("Test");
}
diff --git a/src/test/run-pass/extern/extern-call-deep.rs b/src/test/run-pass/extern/extern-call-deep.rs
index f6eff60..12df0f3 100644
--- a/src/test/run-pass/extern/extern-call-deep.rs
+++ b/src/test/run-pass/extern/extern-call-deep.rs
@@ -10,6 +10,7 @@
// run-pass
// ignore-wasm32-bare no libc to test ffi with
+// ignore-emscripten blows the JS stack
#![feature(rustc_private)]
diff --git a/src/test/run-pass/multi-panic.rs b/src/test/run-pass/multi-panic.rs
index 2e6e109..03e58fc 100644
--- a/src/test/run-pass/multi-panic.rs
+++ b/src/test/run-pass/multi-panic.rs
@@ -17,7 +17,8 @@
let mut it = err.lines();
assert_eq!(it.next().map(|l| l.starts_with("thread '<unnamed>' panicked at")), Some(true));
- assert_eq!(it.next(), Some("note: Run with `RUST_BACKTRACE=1` for a backtrace."));
+ assert_eq!(it.next(), Some("note: Run with `RUST_BACKTRACE=1` \
+ environment variable to display a backtrace."));
assert_eq!(it.next().map(|l| l.starts_with("thread 'main' panicked at")), Some(true));
assert_eq!(it.next(), None);
}
diff --git a/src/test/rustdoc-ui/failed-doctest-output.stdout b/src/test/rustdoc-ui/failed-doctest-output.stdout
index cd19099..bd6fa1f 100644
--- a/src/test/rustdoc-ui/failed-doctest-output.stdout
+++ b/src/test/rustdoc-ui/failed-doctest-output.stdout
@@ -13,13 +13,13 @@
| ^^ not found in this scope
thread '$DIR/failed-doctest-output.rs - OtherStruct (line 27)' panicked at 'couldn't compile the test', src/librustdoc/test.rs:326:13
-note: Run with `RUST_BACKTRACE=1` for a backtrace.
+note: Run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
---- $DIR/failed-doctest-output.rs - SomeStruct (line 21) stdout ----
thread '$DIR/failed-doctest-output.rs - SomeStruct (line 21)' panicked at 'test executable failed:
thread 'main' panicked at 'oh no', $DIR/failed-doctest-output.rs:3:1
-note: Run with `RUST_BACKTRACE=1` for a backtrace.
+note: Run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
', src/librustdoc/test.rs:361:17
diff --git a/src/test/rustdoc/proc-macro.rs b/src/test/rustdoc/proc-macro.rs
index 23d0d00..05d64f8 100644
--- a/src/test/rustdoc/proc-macro.rs
+++ b/src/test/rustdoc/proc-macro.rs
@@ -61,3 +61,16 @@
pub fn some_derive(_item: TokenStream) -> TokenStream {
TokenStream::new()
}
+
+// @has some_macros/foo/index.html
+pub mod foo {
+ // @has - '//code' 'pub use some_proc_macro;'
+ // @has - '//a/@href' '../../some_macros/macro.some_proc_macro.html'
+ pub use some_proc_macro;
+ // @has - '//code' 'pub use some_proc_attr;'
+ // @has - '//a/@href' '../../some_macros/attr.some_proc_attr.html'
+ pub use some_proc_attr;
+ // @has - '//code' 'pub use some_derive;'
+ // @has - '//a/@href' '../../some_macros/derive.SomeDerive.html'
+ pub use some_derive;
+}
diff --git a/src/test/ui/feature-gates/feature-gate-linker-flavor.rs b/src/test/ui/feature-gates/feature-gate-linker-flavor.rs
deleted file mode 100644
index 56ede01..0000000
--- a/src/test/ui/feature-gates/feature-gate-linker-flavor.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright 2018 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.
-
-// This is a fake compile fail test as there's no way to generate a
-// `#![feature(linker_flavor)]` error. The only reason we have a `linker_flavor`
-// feature gate is to be able to document `-Z linker-flavor` in the unstable
-// book
-
-#[used]
-//~^ ERROR attribute must be applied to a `static` variable
-fn foo() {}
-
-fn main() {}
diff --git a/src/test/ui/feature-gates/feature-gate-linker-flavor.stderr b/src/test/ui/feature-gates/feature-gate-linker-flavor.stderr
deleted file mode 100644
index 7019a66..0000000
--- a/src/test/ui/feature-gates/feature-gate-linker-flavor.stderr
+++ /dev/null
@@ -1,8 +0,0 @@
-error: attribute must be applied to a `static` variable
- --> $DIR/feature-gate-linker-flavor.rs:16:1
- |
-LL | #[used]
- | ^^^^^^^
-
-error: aborting due to previous error
-
diff --git a/src/test/ui/pattern/irrefutable-exhaustive-integer-binding.rs b/src/test/ui/pattern/irrefutable-exhaustive-integer-binding.rs
new file mode 100644
index 0000000..ff06588
--- /dev/null
+++ b/src/test/ui/pattern/irrefutable-exhaustive-integer-binding.rs
@@ -0,0 +1,8 @@
+// run-pass
+
+fn main() {
+ let -2147483648..=2147483647 = 1;
+ let 0..=255 = 0u8;
+ let -128..=127 = 0i8;
+ let '\u{0000}'..='\u{10FFFF}' = 'v';
+}
diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs
index 896b380..ea6c711 100644
--- a/src/tools/build-manifest/src/main.rs
+++ b/src/tools/build-manifest/src/main.rs
@@ -621,8 +621,10 @@
let asc = self.output.join(format!("{}.asc", filename));
println!("signing: {:?}", path);
let mut cmd = Command::new("gpg");
- cmd.arg("--no-tty")
+ cmd.arg("--pinentry-mode=loopback")
+ .arg("--no-tty")
.arg("--yes")
+ .arg("--batch")
.arg("--passphrase-fd").arg("0")
.arg("--personal-digest-preferences").arg("SHA512")
.arg("--armor")
diff --git a/src/tools/cargo b/src/tools/cargo
index 28fb200..2cf1f5d 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit 28fb20034a5bb42ea589664de2617dd1840506d3
+Subproject commit 2cf1f5dda2f7ed84e94c4d32f643e0f1f15352f0
diff --git a/src/tools/clippy b/src/tools/clippy
index a3c77f6..b7a431e 160000
--- a/src/tools/clippy
+++ b/src/tools/clippy
@@ -1 +1 @@
-Subproject commit a3c77f6ad1c1c185e561e9cd7fdec7db569169d1
+Subproject commit b7a431ea1ddb96a396921bf9b5f2f6d8690cd474
diff --git a/src/tools/compiletest/src/main.rs b/src/tools/compiletest/src/main.rs
index 65f6bff..9aefd15 100644
--- a/src/tools/compiletest/src/main.rs
+++ b/src/tools/compiletest/src/main.rs
@@ -511,7 +511,11 @@
test::TestOpts {
filter: config.filter.clone(),
filter_exact: config.filter_exact,
- run_ignored: config.run_ignored,
+ run_ignored: if config.run_ignored {
+ test::RunIgnored::Yes
+ } else {
+ test::RunIgnored::No
+ },
format: if config.quiet {
test::OutputFormat::Terse
} else {
