Rollup of 4 pull requests

Cargo.lock

@@ -2985,7 +2985,6 @@ dependencies = [
  "num_cpus 1.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc 0.0.0",
- "rustc-demangle 0.1.15 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc_allocator 0.0.0",
  "rustc_apfloat 0.0.0",
  "rustc_codegen_utils 0.0.0",
@@ -3064,7 +3063,6 @@ dependencies = [
  "rustc_target 0.0.0",
  "rustc_traits 0.0.0",
  "rustc_typeck 0.0.0",
- "scoped-tls 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "serialize 0.0.0",
  "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
  "syntax 0.0.0",
@@ -3128,7 +3126,6 @@ dependencies = [
  "rustc_resolve 0.0.0",
  "rustc_traits 0.0.0",
  "rustc_typeck 0.0.0",
- "scoped-tls 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "serialize 0.0.0",
  "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
  "syntax 0.0.0",

src/liballoc/prelude/v1.rs

@@ -6,6 +6,5 @@
 
 #[unstable(feature = "alloc_prelude", issue = "58935")] pub use crate::borrow::ToOwned;
 #[unstable(feature = "alloc_prelude", issue = "58935")] pub use crate::boxed::Box;
-#[unstable(feature = "alloc_prelude", issue = "58935")] pub use crate::slice::SliceConcatExt;
 #[unstable(feature = "alloc_prelude", issue = "58935")] pub use crate::string::{String, ToString};
 #[unstable(feature = "alloc_prelude", issue = "58935")] pub use crate::vec::Vec;

src/liballoc/slice.rs

@@ -484,6 +484,56 @@ impl<T> [T] {
  }
  buf
  }
+
+ /// Flattens a slice of `T` into a single value `Self::Output`.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// assert_eq!(["hello", "world"].concat(), "helloworld");
+ /// assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]);
+ /// ```
+ #[stable(feature = "rust1", since = "1.0.0")]
+ pub fn concat<Separator: ?Sized>(&self) -> T::Output
+ where T: SliceConcat<Separator>
+ {
+ SliceConcat::concat(self)
+ }
+
+ /// Flattens a slice of `T` into a single value `Self::Output`, placing a
+ /// given separator between each.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// assert_eq!(["hello", "world"].join(" "), "hello world");
+ /// assert_eq!([[1, 2], [3, 4]].join(&0), [1, 2, 0, 3, 4]);
+ /// ```
+ #[stable(feature = "rename_connect_to_join", since = "1.3.0")]
+ pub fn join<Separator: ?Sized>(&self, sep: &Separator) -> T::Output
+ where T: SliceConcat<Separator>
+ {
+ SliceConcat::join(self, sep)
+ }
+
+ /// Flattens a slice of `T` into a single value `Self::Output`, placing a
+ /// given separator between each.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #![allow(deprecated)]
+ /// assert_eq!(["hello", "world"].connect(" "), "hello world");
+ /// assert_eq!([[1, 2], [3, 4]].connect(&0), [1, 2, 0, 3, 4]);
+ /// ```
+ #[stable(feature = "rust1", since = "1.0.0")]
+ #[rustc_deprecated(since = "1.3.0", reason = "renamed to join")]
+ pub fn connect<Separator: ?Sized>(&self, sep: &Separator) -> T::Output
+ where T: SliceConcat<Separator>
+ {
+ SliceConcat::join(self, sep)
+ }
+
 }
 
 #[lang = "slice_u8_alloc"]
@@ -527,87 +577,46 @@ impl [u8] {
 ////////////////////////////////////////////////////////////////////////////////
 // Extension traits for slices over specific kinds of data
 ////////////////////////////////////////////////////////////////////////////////
-#[unstable(feature = "slice_concat_ext",
- reason = "trait should not have to exist",
- issue = "27747")]
-/// An extension trait for concatenating slices
-///
-/// While this trait is unstable, the methods are stable. `SliceConcatExt` is
-/// included in the [standard library prelude], so you can use [`join()`] and
-/// [`concat()`] as if they existed on `[T]` itself.
-///
-/// [standard library prelude]: ../../std/prelude/index.html
-/// [`join()`]: #tymethod.join
-/// [`concat()`]: #tymethod.concat
-pub trait SliceConcatExt<T: ?Sized> {
- #[unstable(feature = "slice_concat_ext",
- reason = "trait should not have to exist",
- issue = "27747")]
+
+/// Helper trait for [`[T]::concat`](../../std/primitive.slice.html#method.concat)
+/// and [`[T]::join`](../../std/primitive.slice.html#method.join)
+#[unstable(feature = "slice_concat_trait", issue = "27747")]
+pub trait SliceConcat<Separator: ?Sized>: Sized {
+ #[unstable(feature = "slice_concat_trait", issue = "27747")]
  /// The resulting type after concatenation
  type Output;
 
- /// Flattens a slice of `T` into a single value `Self::Output`.
- ///
- /// # Examples
- ///
- /// ```
- /// assert_eq!(["hello", "world"].concat(), "helloworld");
- /// assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- fn concat(&self) -> Self::Output;
-
- /// Flattens a slice of `T` into a single value `Self::Output`, placing a
- /// given separator between each.
- ///
- /// # Examples
- ///
- /// ```
- /// assert_eq!(["hello", "world"].join(" "), "hello world");
- /// assert_eq!([[1, 2], [3, 4]].join(&0), [1, 2, 0, 3, 4]);
- /// ```
- #[stable(feature = "rename_connect_to_join", since = "1.3.0")]
- fn join(&self, sep: &T) -> Self::Output;
+ /// Implementation of [`[T]::concat`](../../std/primitive.slice.html#method.concat)
+ #[unstable(feature = "slice_concat_trait", issue = "27747")]
+ fn concat(slice: &[Self]) -> Self::Output;
 
- /// Flattens a slice of `T` into a single value `Self::Output`, placing a
- /// given separator between each.
- ///
- /// # Examples
- ///
- /// ```
- /// # #![allow(deprecated)]
- /// assert_eq!(["hello", "world"].connect(" "), "hello world");
- /// assert_eq!([[1, 2], [3, 4]].connect(&0), [1, 2, 0, 3, 4]);
- /// ```
- #[stable(feature = "rust1", since = "1.0.0")]
- #[rustc_deprecated(since = "1.3.0", reason = "renamed to join")]
- fn connect(&self, sep: &T) -> Self::Output {
- self.join(sep)
- }
+ /// Implementation of [`[T]::join`](../../std/primitive.slice.html#method.join)
+ #[unstable(feature = "slice_concat_trait", issue = "27747")]
+ fn join(slice: &[Self], sep: &Separator) -> Self::Output;
 }
 
 #[unstable(feature = "slice_concat_ext",
  reason = "trait should not have to exist",
  issue = "27747")]
-impl<T: Clone, V: Borrow<[T]>> SliceConcatExt<T> for [V] {
+impl<T: Clone, V: Borrow<[T]>> SliceConcat<T> for V {
  type Output = Vec<T>;
 
- fn concat(&self) -> Vec<T> {
- let size = self.iter().map(|slice| slice.borrow().len()).sum();
+ fn concat(slice: &[Self]) -> Vec<T> {
+ let size = slice.iter().map(|slice| slice.borrow().len()).sum();
  let mut result = Vec::with_capacity(size);
- for v in self {
+ for v in slice {
  result.extend_from_slice(v.borrow())
  }
  result
  }
 
- fn join(&self, sep: &T) -> Vec<T> {
- let mut iter = self.iter();
+ fn join(slice: &[Self], sep: &T) -> Vec<T> {
+ let mut iter = slice.iter();
  let first = match iter.next() {
  Some(first) => first,
  None => return vec![],
  };
- let size = self.iter().map(|slice| slice.borrow().len()).sum::<usize>() + self.len() - 1;
+ let size = slice.iter().map(|slice| slice.borrow().len()).sum::<usize>() + slice.len() - 1;
  let mut result = Vec::with_capacity(size);
  result.extend_from_slice(first.borrow());
 

src/liballoc/str.rs

@@ -37,7 +37,7 @@ use core::unicode::conversions;
 
 use crate::borrow::ToOwned;
 use crate::boxed::Box;
-use crate::slice::{SliceConcatExt, SliceIndex};
+use crate::slice::{SliceConcat, SliceIndex};
 use crate::string::String;
 use crate::vec::Vec;
 
@@ -74,16 +74,16 @@ pub use core::str::{EscapeDebug, EscapeDefault, EscapeUnicode};
 #[unstable(feature = "slice_concat_ext",
  reason = "trait should not have to exist",
  issue = "27747")]
-impl<S: Borrow<str>> SliceConcatExt<str> for [S] {
+impl<S: Borrow<str>> SliceConcat<str> for S {
  type Output = String;
 
- fn concat(&self) -> String {
- self.join("")
+ fn concat(slice: &[Self]) -> String {
+ Self::join(slice, "")
  }
 
- fn join(&self, sep: &str) -> String {
+ fn join(slice: &[Self], sep: &str) -> String {
  unsafe {
- String::from_utf8_unchecked( join_generic_copy(self, sep.as_bytes()) )
+ String::from_utf8_unchecked( join_generic_copy(slice, sep.as_bytes()) )
  }
  }
 }
@@ -126,7 +126,7 @@ macro_rules! copy_slice_and_advance {
 
 // Optimized join implementation that works for both Vec<T> (T: Copy) and String's inner vec
 // Currently (2018-05-13) there is a bug with type inference and specialization (see issue #36262)
-// For this reason SliceConcatExt<T> is not specialized for T: Copy and SliceConcatExt<str> is the
+// For this reason SliceConcat<T> is not specialized for T: Copy and SliceConcat<str> is the
 // only user of this function. It is left in place for the time when that is fixed.
 //
 // the bounds for String-join are S: Borrow<str> and for Vec-join Borrow<[T]>

src/librustc/infer/opaque_types/mod.rs

@@ -4,6 +4,7 @@ use crate::hir::Node;
 use crate::infer::outlives::free_region_map::FreeRegionRelations;
 use crate::infer::{self, InferCtxt, InferOk, TypeVariableOrigin, TypeVariableOriginKind};
 use crate::middle::region;
+use crate::mir::interpret::ConstValue;
 use crate::traits::{self, PredicateObligation};
 use crate::ty::fold::{BottomUpFolder, TypeFoldable, TypeFolder, TypeVisitor};
 use crate::ty::subst::{InternalSubsts, Kind, SubstsRef, UnpackedKind};
@@ -553,6 +554,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  def_id: DefId,
  opaque_defn: &OpaqueTypeDecl<'tcx>,
  instantiated_ty: Ty<'tcx>,
+ span: Span,
  ) -> Ty<'tcx> {
  debug!(
  "infer_opaque_definition_from_instantiation(def_id={:?}, instantiated_ty={:?})",
@@ -584,6 +586,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  def_id,
  map,
  instantiated_ty,
+ span,
  ));
  debug!("infer_opaque_definition_from_instantiation: definition_ty={:?}", definition_ty);
 
@@ -761,6 +764,9 @@ struct ReverseMapper<'tcx> {
 
  /// initially `Some`, set to `None` once error has been reported
  hidden_ty: Option<Ty<'tcx>>,
+
+ /// Span of function being checked.
+ span: Span,
 }
 
 impl ReverseMapper<'tcx> {
@@ -770,6 +776,7 @@ impl ReverseMapper<'tcx> {
  opaque_type_def_id: DefId,
  map: FxHashMap<Kind<'tcx>, Kind<'tcx>>,
  hidden_ty: Ty<'tcx>,
+ span: Span,
  ) -> Self {
  Self {
  tcx,
@@ -778,6 +785,7 @@ impl ReverseMapper<'tcx> {
  map,
  map_missing_regions_to_empty: false,
  hidden_ty: Some(hidden_ty),
+ span,
  }
  }
 
@@ -812,10 +820,11 @@ impl TypeFolder<'tcx> for ReverseMapper<'tcx> {
  _ => { }
  }
 
+ let generics = self.tcx().generics_of(self.opaque_type_def_id);
  match self.map.get(&r.into()).map(|k| k.unpack()) {
  Some(UnpackedKind::Lifetime(r1)) => r1,
  Some(u) => panic!("region mapped to unexpected kind: {:?}", u),
- None => {
+ None if generics.parent.is_some() => {
  if !self.map_missing_regions_to_empty && !self.tainted_by_errors {
  if let Some(hidden_ty) = self.hidden_ty.take() {
  unexpected_hidden_region_diagnostic(
@@ -829,6 +838,21 @@ impl TypeFolder<'tcx> for ReverseMapper<'tcx> {
  }
  self.tcx.lifetimes.re_empty
  }
+ None => {
+ self.tcx.sess
+ .struct_span_err(
+ self.span,
+ "non-defining existential type use in defining scope"
+ )
+ .span_label(
+ self.span,
+ format!("lifetime `{}` is part of concrete type but not used in \
+ parameter list of existential type", r),
+ )
+ .emit();
+
+ self.tcx().global_tcx().mk_region(ty::ReStatic)
+ },
  }
  }
 
@@ -890,9 +914,59 @@ impl TypeFolder<'tcx> for ReverseMapper<'tcx> {
  self.tcx.mk_generator(def_id, ty::GeneratorSubsts { substs }, movability)
  }
 
+ ty::Param(..) => {
+ // Look it up in the substitution list.
+ match self.map.get(&ty.into()).map(|k| k.unpack()) {
+ // Found it in the substitution list; replace with the parameter from the
+ // existential type.
+ Some(UnpackedKind::Type(t1)) => t1,
+ Some(u) => panic!("type mapped to unexpected kind: {:?}", u),
+ None => {
+ self.tcx.sess
+ .struct_span_err(
+ self.span,
+ &format!("type parameter `{}` is part of concrete type but not \
+ used in parameter list for existential type", ty),
+ )
+ .emit();
+
+ self.tcx().types.err
+ }
+ }
+ }
+
  _ => ty.super_fold_with(self),
  }
  }
+
+ fn fold_const(&mut self, ct: &'tcx ty::Const<'tcx>) -> &'tcx ty::Const<'tcx> {
+ trace!("checking const {:?}", ct);
+ // Find a const parameter
+ match ct.val {
+ ConstValue::Param(..) => {
+ // Look it up in the substitution list.
+ match self.map.get(&ct.into()).map(|k| k.unpack()) {
+ // Found it in the substitution list, replace with the parameter from the
+ // existential type.
+ Some(UnpackedKind::Const(c1)) => c1,
+ Some(u) => panic!("const mapped to unexpected kind: {:?}", u),
+ None => {
+ self.tcx.sess
+ .struct_span_err(
+ self.span,
+ &format!("const parameter `{}` is part of concrete type but not \
+ used in parameter list for existential type", ct)
+ )
+ .emit();
+
+ self.tcx().consts.err
+ }
+ }
+ }
+
+ _ => ct,
+ }
+ }
 }
 
 struct Instantiator<'a, 'tcx> {

src/librustc_codegen_ssa/Cargo.toml

@@ -13,7 +13,6 @@ test = false
 bitflags = "1.0.4"
 cc = "1.0.1"
 num_cpus = "1.0"
-rustc-demangle = "0.1.15"
 memmap = "0.6"
 log = "0.4.5"
 libc = "0.2.44"

src/librustc_driver/Cargo.toml

@@ -15,7 +15,6 @@ graphviz = { path = "../libgraphviz" }
 log = "0.4"
 env_logger = { version = "0.5", default-features = false }
 rayon = { version = "0.2.0", package = "rustc-rayon" }
-scoped-tls = "1.0"
 rustc = { path = "../librustc" }
 rustc_allocator = { path = "../librustc_allocator" }
 rustc_target = { path = "../librustc_target" }