Rollup of 15 pull requests

Cargo.lock

@@ -2751,20 +2751,6 @@ dependencies = [
  "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
-[[package]]
-name = "rustc_allocator"
-version = "0.0.0"
-dependencies = [
- "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc 0.0.0",
- "rustc_data_structures 0.0.0",
- "rustc_errors 0.0.0",
- "rustc_target 0.0.0",
- "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "syntax 0.0.0",
- "syntax_pos 0.0.0",
-]
-
 [[package]]
 name = "rustc_apfloat"
 version = "0.0.0"
@@ -2822,7 +2808,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_allocator 0.0.0",
  "rustc_apfloat 0.0.0",
  "rustc_codegen_utils 0.0.0",
  "rustc_data_structures 0.0.0",
@@ -2883,7 +2868,6 @@ dependencies = [
  "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc 0.0.0",
  "rustc-rayon 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc_allocator 0.0.0",
  "rustc_ast_borrowck 0.0.0",
  "rustc_codegen_utils 0.0.0",
  "rustc_data_structures 0.0.0",
@@ -2904,7 +2888,6 @@ dependencies = [
  "serialize 0.0.0",
  "smallvec 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
  "syntax 0.0.0",
- "syntax_ext 0.0.0",
  "syntax_pos 0.0.0",
 ]
 
@@ -2948,7 +2931,6 @@ dependencies = [
  "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "rustc 0.0.0",
  "rustc-rayon 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc_allocator 0.0.0",
  "rustc_ast_borrowck 0.0.0",
  "rustc_codegen_ssa 0.0.0",
  "rustc_codegen_utils 0.0.0",

src/bootstrap/sanity.rs

@@ -78,8 +78,11 @@ pub fn check(build: &mut Build) {
 
  // We need cmake, but only if we're actually building LLVM or sanitizers.
  let building_llvm = build.hosts.iter()
- .filter_map(|host| build.config.target_config.get(host))
- .any(|config| config.llvm_config.is_none());
+ .map(|host| build.config.target_config
+ .get(host)
+ .map(|config| config.llvm_config.is_none())
+ .unwrap_or(true))
+ .any(|build_llvm_ourselves| build_llvm_ourselves);
  if building_llvm || build.config.sanitizers {
  cmd_finder.must_have("cmake");
  }
@@ -106,6 +109,14 @@ pub fn check(build: &mut Build) {
  build.config.ninja = true;
  }
  }
+
+ if build.config.lldb_enabled {
+ cmd_finder.must_have("swig");
+ let out = output(Command::new("swig").arg("-version"));
+ if !out.contains("SWIG Version 3") && !out.contains("SWIG Version 4") {
+ panic!("Ensure that Swig 3.x.x or 4.x.x is installed.");
+ }
+ }
  }
 
  build.config.python = build.config.python.take().map(|p| cmd_finder.must_have(p))

src/doc/rustdoc/src/unstable-features.md

@@ -183,9 +183,8 @@ Book][unstable-masked] and [its tracking issue][issue-masked].
 
 As designed in [RFC 1990], Rustdoc can read an external file to use as a type's documentation. This
 is useful if certain documentation is so long that it would break the flow of reading the source.
-Instead of writing it all inline, writing `#[doc(include = "sometype.md")]` (where `sometype.md` is
-a file adjacent to the `lib.rs` for the crate) will ask Rustdoc to instead read that file and use it
-as if it were written inline.
+Instead of writing it all inline, writing `#[doc(include = "sometype.md")]` will ask Rustdoc to
+instead read that file and use it as if it were written inline.
 
 [RFC 1990]: https://github.com/rust-lang/rfcs/pull/1990
 

src/liballoc/slice.rs

@@ -494,10 +494,10 @@ impl<T> [T] {
  /// 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>
+ pub fn concat<Item: ?Sized>(&self) -> <Self as Concat<Item>>::Output
+ where Self: Concat<Item>
  {
- SliceConcat::concat(self)
+ Concat::concat(self)
  }
 
  /// Flattens a slice of `T` into a single value `Self::Output`, placing a
@@ -508,12 +508,13 @@ impl<T> [T] {
  /// ```
  /// assert_eq!(["hello", "world"].join(" "), "hello world");
  /// assert_eq!([[1, 2], [3, 4]].join(&0), [1, 2, 0, 3, 4]);
+ /// assert_eq!([[1, 2], [3, 4]].join(&[0, 0][..]), [1, 2, 0, 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>
+ pub fn join<Separator>(&self, sep: Separator) -> <Self as Join<Separator>>::Output
+ where Self: Join<Separator>
  {
- SliceConcat::join(self, sep)
+ Join::join(self, sep)
  }
 
  /// Flattens a slice of `T` into a single value `Self::Output`, placing a
@@ -528,10 +529,10 @@ impl<T> [T] {
  /// ```
  #[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>
+ pub fn connect<Separator>(&self, sep: Separator) -> <Self as Join<Separator>>::Output
+ where Self: Join<Separator>
  {
- SliceConcat::join(self, sep)
+ Join::join(self, sep)
  }
 
 }
@@ -578,45 +579,83 @@ impl [u8] {
 // Extension traits for slices over specific kinds of data
 ////////////////////////////////////////////////////////////////////////////////
 
-/// Helper trait for [`[T]::concat`](../../std/primitive.slice.html#method.concat)
-/// and [`[T]::join`](../../std/primitive.slice.html#method.join)
+/// Helper trait for [`[T]::concat`](../../std/primitive.slice.html#method.concat).
+///
+/// Note: the `Item` type parameter is not used in this trait,
+/// but it allows impls to be more generic.
+/// Without it, we get this error:
+///
+/// ```error
+/// error[E0207]: the type parameter `T` is not constrained by the impl trait, self type, or predica
+/// --> src/liballoc/slice.rs:608:6
+/// |
+/// 608 | impl<T: Clone, V: Borrow<[T]>> Concat for [V] {
+/// | ^ unconstrained type parameter
+/// ```
+///
+/// This is because there could exist `V` types with multiple `Borrow<[_]>` impls,
+/// such that multiple `T` types would apply:
+///
+/// ```
+/// # #[allow(dead_code)]
+/// pub struct Foo(Vec<u32>, Vec<String>);
+///
+/// impl std::borrow::Borrow<[u32]> for Foo {
+/// fn borrow(&self) -> &[u32] { &self.0 }
+/// }
+///
+/// impl std::borrow::Borrow<[String]> for Foo {
+/// fn borrow(&self) -> &[String] { &self.1 }
+/// }
+/// ```
 #[unstable(feature = "slice_concat_trait", issue = "27747")]
-pub trait SliceConcat<Separator: ?Sized>: Sized {
+pub trait Concat<Item: ?Sized> {
  #[unstable(feature = "slice_concat_trait", issue = "27747")]
  /// The resulting type after concatenation
  type Output;
 
  /// Implementation of [`[T]::concat`](../../std/primitive.slice.html#method.concat)
  #[unstable(feature = "slice_concat_trait", issue = "27747")]
- fn concat(slice: &[Self]) -> Self::Output;
+ fn concat(slice: &Self) -> Self::Output;
+}
+
+/// Helper trait for [`[T]::join`](../../std/primitive.slice.html#method.join)
+#[unstable(feature = "slice_concat_trait", issue = "27747")]
+pub trait Join<Separator> {
+ #[unstable(feature = "slice_concat_trait", issue = "27747")]
+ /// The resulting type after concatenation
+ type Output;
 
  /// 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;
+ 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]>> SliceConcat<T> for V {
+#[unstable(feature = "slice_concat_ext", issue = "27747")]
+impl<T: Clone, V: Borrow<[T]>> Concat<T> for [V] {
  type Output = Vec<T>;
 
- fn concat(slice: &[Self]) -> Vec<T> {
+ 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 slice {
  result.extend_from_slice(v.borrow())
  }
  result
  }
+}
+
+#[unstable(feature = "slice_concat_ext", issue = "27747")]
+impl<T: Clone, V: Borrow<[T]>> Join<&T> for [V] {
+ type Output = Vec<T>;
 
- fn join(slice: &[Self], sep: &T) -> Vec<T> {
+ 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 = slice.iter().map(|slice| slice.borrow().len()).sum::<usize>() + slice.len() - 1;
+ let size = slice.iter().map(|v| v.borrow().len()).sum::<usize>() + slice.len() - 1;
  let mut result = Vec::with_capacity(size);
  result.extend_from_slice(first.borrow());
 
@@ -628,6 +667,29 @@ impl<T: Clone, V: Borrow<[T]>> SliceConcat<T> for V {
  }
 }
 
+#[unstable(feature = "slice_concat_ext", issue = "27747")]
+impl<T: Clone, V: Borrow<[T]>> Join<&[T]> for [V] {
+ type Output = Vec<T>;
+
+ 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 = slice.iter().map(|v| v.borrow().len()).sum::<usize>() +
+ sep.len() * (slice.len() - 1);
+ let mut result = Vec::with_capacity(size);
+ result.extend_from_slice(first.borrow());
+
+ for v in iter {
+ result.extend_from_slice(sep);
+ result.extend_from_slice(v.borrow())
+ }
+ result
+ }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Standard trait implementations for slices
 ////////////////////////////////////////////////////////////////////////////////

src/liballoc/str.rs

@@ -37,7 +37,7 @@ use core::unicode::conversions;
 
 use crate::borrow::ToOwned;
 use crate::boxed::Box;
-use crate::slice::{SliceConcat, SliceIndex};
+use crate::slice::{Concat, Join, SliceIndex};
 use crate::string::String;
 use crate::vec::Vec;
 
@@ -71,17 +71,22 @@ pub use core::str::SplitAsciiWhitespace;
 #[stable(feature = "str_escape", since = "1.34.0")]
 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>> SliceConcat<str> for S {
+/// Note: `str` in `Concat<str>` is not meaningful here.
+/// This type parameter of the trait only exists to enable another impl.
+#[unstable(feature = "slice_concat_ext", issue = "27747")]
+impl<S: Borrow<str>> Concat<str> for [S] {
  type Output = String;
 
- fn concat(slice: &[Self]) -> String {
- Self::join(slice, "")
+ fn concat(slice: &Self) -> String {
+ Join::join(slice, "")
  }
+}
+
+#[unstable(feature = "slice_concat_ext", issue = "27747")]
+impl<S: Borrow<str>> Join<&str> for [S] {
+ type Output = String;
 
- fn join(slice: &[Self], sep: &str) -> String {
+ fn join(slice: &Self, sep: &str) -> String {
  unsafe {
  String::from_utf8_unchecked( join_generic_copy(slice, sep.as_bytes()) )
  }

src/libcore/any.rs

@@ -450,3 +450,29 @@ impl TypeId {
  }
  }
 }
+
+/// Returns the name of a type as a string slice.
+///
+/// # Note
+///
+/// This is intended for diagnostic use. The exact contents and format of the
+/// string are not specified, other than being a best-effort description of the
+/// type. For example, `type_name::<Option<String>>()` could return the
+/// `"Option<String>"` or `"std::option::Option<std::string::String>"`, but not
+/// `"foobar"`. In addition, the output may change between versions of the
+/// compiler.
+///
+/// The type name should not be considered a unique identifier of a type;
+/// multiple types may share the same type name.
+///
+/// The current implementation uses the same infrastructure as compiler
+/// diagnostics and debuginfo, but this is not guaranteed.
+#[stable(feature = "type_name", since = "1.38.0")]
+pub fn type_name<T: ?Sized>() -> &'static str {
+ #[cfg(bootstrap)]
+ unsafe {
+ intrinsics::type_name::<T>()
+ }
+ #[cfg(not(bootstrap))]
+ intrinsics::type_name::<T>()
+}