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>,
#[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 ");
" \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()),
"");
#![stable(feature = "", since = "1.30.0")]
#![allow(non_camel_case_types)]
-#![cfg_attr(stage0, allow(dead_code))]
//! Utilities related to FFI bindings.
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
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",
}
}
-#[cfg(not(stage0))]
extern "rust-intrinsic" {
/// Destroy the arglist `ap` after initialization with `va_start` or
/// `va_copy`.
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.
/// 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.
///
/// [`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) }
#[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) }
}
}
#[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) }
}
}
/// {}
/// ```
#[unstable(feature = "dispatch_from_dyn", issue = "0")]
-#[cfg_attr(not(stage0), lang = "dispatch_from_dyn")]
+#[lang = "dispatch_from_dyn"]
pub trait DispatchFromDyn<T> {
// Empty.
}
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"),
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"),
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 {
"::"
// 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| {
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
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;
// 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;
};
.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;
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)?
};
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
}
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 { "" },
);
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..]);
"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();
});
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()
// 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()
}
Error::description(&**self)
}
+ #[allow(deprecated)]
fn cause(&self) -> Option<&dyn Error> {
Error::cause(&**self)
}
#[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",
}
}
+ #[allow(deprecated)]
fn cause(&self) -> Option<&dyn error::Error> {
match self.repr {
Repr::Os(..) => None,
#![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]
#[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 {}
#[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 {}
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
},
])
}
+#[allow(deprecated)]
pub fn expand_build_diagnostic_array<'cx>(ecx: &'cx mut ExtCtxt,
span: Span,
token_tree: &[TokenTree])
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()
})
}
}
/// 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));
}
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));
}
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 {
}
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".
# 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
-Subproject commit 28fb20034a5bb42ea589664de2617dd1840506d3
+Subproject commit 2cf1f5dda2f7ed84e94c4d32f643e0f1f15352f0
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 {