Rollup of 7 pull requests

src/liballoc/lib.rs

@@ -124,6 +124,7 @@
 #![feature(allocator_internals)]
 #![feature(on_unimplemented)]
 #![feature(exact_chunks)]
+#![feature(pointer_methods)]
 
 #![cfg_attr(not(test), feature(fused, fn_traits, placement_new_protocol, swap_with_slice, i128))]
 #![cfg_attr(test, feature(test, box_heap))]

src/liballoc/str.rs

@@ -43,6 +43,7 @@ use core::str as core_str;
 use core::str::pattern::Pattern;
 use core::str::pattern::{Searcher, ReverseSearcher, DoubleEndedSearcher};
 use core::mem;
+use core::ptr;
 use core::iter::FusedIterator;
 use std_unicode::str::{UnicodeStr, Utf16Encoder};
 
@@ -2066,9 +2067,59 @@ impl str {
  /// ```
  #[stable(feature = "repeat_str", since = "1.16.0")]
  pub fn repeat(&self, n: usize) -> String {
- let mut s = String::with_capacity(self.len() * n);
- s.extend((0..n).map(|_| self));
- s
+ if n == 0 {
+ return String::new();
+ }
+
+ // If `n` is larger than zero, it can be split as
+ // `n = 2^expn + rem (2^expn > rem, expn >= 0, rem >= 0)`.
+ // `2^expn` is the number represented by the leftmost '1' bit of `n`,
+ // and `rem` is the remaining part of `n`.
+
+ // Using `Vec` to access `set_len()`.
+ let mut buf = Vec::with_capacity(self.len() * n);
+
+ // `2^expn` repetition is done by doubling `buf` `expn`-times.
+ buf.extend(self.as_bytes());
+ {
+ let mut m = n >> 1;
+ // If `m > 0`, there are remaining bits up to the leftmost '1'.
+ while m > 0 {
+ // `buf.extend(buf)`:
+ unsafe {
+ ptr::copy_nonoverlapping(
+ buf.as_ptr(),
+ (buf.as_mut_ptr() as *mut u8).add(buf.len()),
+ buf.len(),
+ );
+ // `buf` has capacity of `self.len() * n`.
+ let buf_len = buf.len();
+ buf.set_len(buf_len * 2);
+ }
+
+ m >>= 1;
+ }
+ }
+
+ // `rem` (`= n - 2^expn`) repetition is done by copying
+ // first `rem` repetitions from `buf` itself.
+ let rem_len = self.len() * n - buf.len(); // `self.len() * rem`
+ if rem_len > 0 {
+ // `buf.extend(buf[0 .. rem_len])`:
+ unsafe {
+ // This is non-overlapping since `2^expn > rem`.
+ ptr::copy_nonoverlapping(
+ buf.as_ptr(),
+ (buf.as_mut_ptr() as *mut u8).add(buf.len()),
+ rem_len,
+ );
+ // `buf.len() + rem_len` equals to `buf.capacity()` (`= self.len() * n`).
+ let buf_cap = buf.capacity();
+ buf.set_len(buf_cap);
+ }
+ }
+
+ unsafe { String::from_utf8_unchecked(buf) }
  }
 
  /// Checks if all characters in this string are within the ASCII range.

src/librustc/ty/layout.rs

@@ -1203,7 +1203,7 @@ impl<'a, 'tcx> LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> {
  }
 
  let pointee = tcx.normalize_associated_type_in_env(&pointee, param_env);
- if pointee.is_sized(tcx, param_env, DUMMY_SP) {
+ if pointee.is_sized(tcx.at(DUMMY_SP), param_env) {
  return Ok(tcx.intern_layout(LayoutDetails::scalar(self, data_ptr)));
  }
 
@@ -1428,7 +1428,7 @@ impl<'a, 'tcx> LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> {
  let param_env = tcx.param_env(def.did);
  let last_field = def.variants[v].fields.last().unwrap();
  let always_sized = tcx.type_of(last_field.did)
- .is_sized(tcx, param_env, DUMMY_SP);
+ .is_sized(tcx.at(DUMMY_SP), param_env);
  if !always_sized { StructKind::MaybeUnsized }
  else { StructKind::AlwaysSized }
  };

src/librustc/ty/util.rs

@@ -20,6 +20,7 @@ use traits::{self, Reveal};
 use ty::{self, Ty, TyCtxt, TypeFoldable};
 use ty::fold::TypeVisitor;
 use ty::subst::{Subst, UnpackedKind};
+use ty::maps::TyCtxtAt;
 use ty::TypeVariants::*;
 use util::common::ErrorReported;
 use middle::lang_items;
@@ -864,11 +865,10 @@ impl<'a, 'tcx> ty::TyS<'tcx> {
  }
 
  pub fn is_sized(&'tcx self,
- tcx: TyCtxt<'a, 'tcx, 'tcx>,
- param_env: ty::ParamEnv<'tcx>,
- span: Span)-> bool
+ tcx_at: TyCtxtAt<'a, 'tcx, 'tcx>,
+ param_env: ty::ParamEnv<'tcx>)-> bool
  {
- tcx.at(span).is_sized_raw(param_env.and(self))
+ tcx_at.is_sized_raw(param_env.and(self))
  }
 
  pub fn is_freeze(&'tcx self,

src/librustc_errors/Cargo.toml

@@ -13,3 +13,5 @@ serialize = { path = "../libserialize" }
 syntax_pos = { path = "../libsyntax_pos" }
 rustc_data_structures = { path = "../librustc_data_structures" }
 unicode-width = "0.1.4"
+atty = "0.2"
+termcolor = "0.3"