Part of #68490.
Care has been taken to leave the old consts where appropriate, for testing backcompat regressions, module shadowing, etc. The intrinsics docs were accidentally referring to some methods on f64 as std::f64, which I changed due to being contrary with how we normally disambiguate the shadow module from the primitive. In one other place I changed std::u8 to std::ops since it was just testing path handling in macros.
For places which have legitimate uses of the old consts, deprecated attributes have been optimistically inserted. Although currently unnecessary, they exist to emphasize to any future deprecation effort the necessity of these specific symbols and prevent them from being accidentally removed.
/// Returns the square root of an `f32`
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::sqrt`](../../std/primitive.f32.html#method.sqrt)
+ /// [`f32::sqrt`](../../std/primitive.f32.html#method.sqrt)
pub fn sqrtf32(x: f32) -> f32;
/// Returns the square root of an `f64`
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::sqrt`](../../std/primitive.f64.html#method.sqrt)
+ /// [`f64::sqrt`](../../std/primitive.f64.html#method.sqrt)
pub fn sqrtf64(x: f64) -> f64;
/// Raises an `f32` to an integer power.
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::powi`](../../std/primitive.f32.html#method.powi)
+ /// [`f32::powi`](../../std/primitive.f32.html#method.powi)
pub fn powif32(a: f32, x: i32) -> f32;
/// Raises an `f64` to an integer power.
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::powi`](../../std/primitive.f64.html#method.powi)
+ /// [`f64::powi`](../../std/primitive.f64.html#method.powi)
pub fn powif64(a: f64, x: i32) -> f64;
/// Returns the sine of an `f32`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::sin`](../../std/primitive.f32.html#method.sin)
+ /// [`f32::sin`](../../std/primitive.f32.html#method.sin)
pub fn sinf32(x: f32) -> f32;
/// Returns the sine of an `f64`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::sin`](../../std/primitive.f64.html#method.sin)
+ /// [`f64::sin`](../../std/primitive.f64.html#method.sin)
pub fn sinf64(x: f64) -> f64;
/// Returns the cosine of an `f32`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::cos`](../../std/primitive.f32.html#method.cos)
+ /// [`f32::cos`](../../std/primitive.f32.html#method.cos)
pub fn cosf32(x: f32) -> f32;
/// Returns the cosine of an `f64`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::cos`](../../std/primitive.f64.html#method.cos)
+ /// [`f64::cos`](../../std/primitive.f64.html#method.cos)
pub fn cosf64(x: f64) -> f64;
/// Raises an `f32` to an `f32` power.
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::powf`](../../std/primitive.f32.html#method.powf)
+ /// [`f32::powf`](../../std/primitive.f32.html#method.powf)
pub fn powf32(a: f32, x: f32) -> f32;
/// Raises an `f64` to an `f64` power.
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::powf`](../../std/primitive.f64.html#method.powf)
+ /// [`f64::powf`](../../std/primitive.f64.html#method.powf)
pub fn powf64(a: f64, x: f64) -> f64;
/// Returns the exponential of an `f32`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::exp`](../../std/primitive.f32.html#method.exp)
+ /// [`f32::exp`](../../std/primitive.f32.html#method.exp)
pub fn expf32(x: f32) -> f32;
/// Returns the exponential of an `f64`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::exp`](../../std/primitive.f64.html#method.exp)
+ /// [`f64::exp`](../../std/primitive.f64.html#method.exp)
pub fn expf64(x: f64) -> f64;
/// Returns 2 raised to the power of an `f32`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::exp2`](../../std/primitive.f32.html#method.exp2)
+ /// [`f32::exp2`](../../std/primitive.f32.html#method.exp2)
pub fn exp2f32(x: f32) -> f32;
/// Returns 2 raised to the power of an `f64`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::exp2`](../../std/primitive.f64.html#method.exp2)
+ /// [`f64::exp2`](../../std/primitive.f64.html#method.exp2)
pub fn exp2f64(x: f64) -> f64;
/// Returns the natural logarithm of an `f32`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::ln`](../../std/primitive.f32.html#method.ln)
+ /// [`f32::ln`](../../std/primitive.f32.html#method.ln)
pub fn logf32(x: f32) -> f32;
/// Returns the natural logarithm of an `f64`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::ln`](../../std/primitive.f64.html#method.ln)
+ /// [`f64::ln`](../../std/primitive.f64.html#method.ln)
pub fn logf64(x: f64) -> f64;
/// Returns the base 10 logarithm of an `f32`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::log10`](../../std/primitive.f32.html#method.log10)
+ /// [`f32::log10`](../../std/primitive.f32.html#method.log10)
pub fn log10f32(x: f32) -> f32;
/// Returns the base 10 logarithm of an `f64`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::log10`](../../std/primitive.f64.html#method.log10)
+ /// [`f64::log10`](../../std/primitive.f64.html#method.log10)
pub fn log10f64(x: f64) -> f64;
/// Returns the base 2 logarithm of an `f32`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::log2`](../../std/primitive.f32.html#method.log2)
+ /// [`f32::log2`](../../std/primitive.f32.html#method.log2)
pub fn log2f32(x: f32) -> f32;
/// Returns the base 2 logarithm of an `f64`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::log2`](../../std/primitive.f64.html#method.log2)
+ /// [`f64::log2`](../../std/primitive.f64.html#method.log2)
pub fn log2f64(x: f64) -> f64;
/// Returns `a * b + c` for `f32` values.
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::mul_add`](../../std/primitive.f32.html#method.mul_add)
+ /// [`f32::mul_add`](../../std/primitive.f32.html#method.mul_add)
pub fn fmaf32(a: f32, b: f32, c: f32) -> f32;
/// Returns `a * b + c` for `f64` values.
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::mul_add`](../../std/primitive.f64.html#method.mul_add)
+ /// [`f64::mul_add`](../../std/primitive.f64.html#method.mul_add)
pub fn fmaf64(a: f64, b: f64, c: f64) -> f64;
/// Returns the absolute value of an `f32`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::abs`](../../std/primitive.f32.html#method.abs)
+ /// [`f32::abs`](../../std/primitive.f32.html#method.abs)
pub fn fabsf32(x: f32) -> f32;
/// Returns the absolute value of an `f64`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::abs`](../../std/primitive.f64.html#method.abs)
+ /// [`f64::abs`](../../std/primitive.f64.html#method.abs)
pub fn fabsf64(x: f64) -> f64;
/// Returns the minimum of two `f32` values.
/// Copies the sign from `y` to `x` for `f32` values.
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::copysign`](../../std/primitive.f32.html#method.copysign)
+ /// [`f32::copysign`](../../std/primitive.f32.html#method.copysign)
pub fn copysignf32(x: f32, y: f32) -> f32;
/// Copies the sign from `y` to `x` for `f64` values.
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::copysign`](../../std/primitive.f64.html#method.copysign)
+ /// [`f64::copysign`](../../std/primitive.f64.html#method.copysign)
pub fn copysignf64(x: f64, y: f64) -> f64;
/// Returns the largest integer less than or equal to an `f32`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::floor`](../../std/primitive.f32.html#method.floor)
+ /// [`f32::floor`](../../std/primitive.f32.html#method.floor)
pub fn floorf32(x: f32) -> f32;
/// Returns the largest integer less than or equal to an `f64`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::floor`](../../std/primitive.f64.html#method.floor)
+ /// [`f64::floor`](../../std/primitive.f64.html#method.floor)
pub fn floorf64(x: f64) -> f64;
/// Returns the smallest integer greater than or equal to an `f32`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::ceil`](../../std/primitive.f32.html#method.ceil)
+ /// [`f32::ceil`](../../std/primitive.f32.html#method.ceil)
pub fn ceilf32(x: f32) -> f32;
/// Returns the smallest integer greater than or equal to an `f64`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::ceil`](../../std/primitive.f64.html#method.ceil)
+ /// [`f64::ceil`](../../std/primitive.f64.html#method.ceil)
pub fn ceilf64(x: f64) -> f64;
/// Returns the integer part of an `f32`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::trunc`](../../std/primitive.f32.html#method.trunc)
+ /// [`f32::trunc`](../../std/primitive.f32.html#method.trunc)
pub fn truncf32(x: f32) -> f32;
/// Returns the integer part of an `f64`.
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::trunc`](../../std/primitive.f64.html#method.trunc)
+ /// [`f64::trunc`](../../std/primitive.f64.html#method.trunc)
pub fn truncf64(x: f64) -> f64;
/// Returns the nearest integer to an `f32`. May raise an inexact floating-point exception
/// Returns the nearest integer to an `f32`. Rounds half-way cases away from zero.
///
/// The stabilized version of this intrinsic is
- /// [`std::f32::round`](../../std/primitive.f32.html#method.round)
+ /// [`f32::round`](../../std/primitive.f32.html#method.round)
pub fn roundf32(x: f32) -> f32;
/// Returns the nearest integer to an `f64`. Rounds half-way cases away from zero.
///
/// The stabilized version of this intrinsic is
- /// [`std::f64::round`](../../std/primitive.f64.html#method.round)
+ /// [`f64::round`](../../std/primitive.f64.html#method.round)
pub fn roundf64(x: f64) -> f64;
/// Float addition that allows optimizations based on algebraic rules.
#[test]
fn test_nan() {
- use core::f64;
let x = "NaN".to_string();
assert_eq!(format!("{}", f64::NAN), x);
assert_eq!(format!("{:e}", f64::NAN), x);
#[repr(i64)]
pub enum I64 {
- I64Min = std::i64::MIN,
- I64Max = std::i64::MAX,
+ I64Min = i64::MIN,
+ I64Max = i64::MAX,
}
#[repr(u64)]
pub enum U64 {
- U64Min = std::u64::MIN,
- U64Max = std::u64::MAX,
+ U64Min = u64::MIN,
+ U64Max = u64::MAX,
}
fn main() {
// compile-flags: -C no-prepopulate-passes
#![crate_type="rlib"]
-use std::usize;
#[repr(align(16))]
pub struct S {
// error-pattern: are too big for the current architecture
fn main() {
- println!("Size: {}", std::mem::size_of::<[u8; std::u64::MAX as usize]>());
+ println!("Size: {}", std::mem::size_of::<[u8; u64::MAX as usize]>());
}
// @!has 'foo/index.html' '//code' 'pub use self::i32;'
// @has 'foo/index.html' '//tr[@class="module-item"]' 'i32'
// @has 'foo/i32/index.html'
+#[allow(deprecated, deprecated_in_future)]
pub use std::i32;
// @!has 'foo/index.html' '//code' 'pub use self::string::String;'
// @has 'foo/index.html' '//tr[@class="module-item"]' 'String'
pub use std::f32::consts::PI;
// @has show_const_contents/constant.MAX.html '= i32::MAX; // 2_147_483_647i32'
+#[allow(deprecated, deprecated_in_future)]
pub use std::i32::MAX;
macro_rules! int_module {
// error-pattern:index out of bounds
// ignore-emscripten no processes
-use std::usize;
use std::mem::size_of;
fn main() {
error: this arithmetic operation will overflow
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:29:22
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:27:22
|
LL | const NEG: i32 = -i32::MIN + T::NEG;
| ^^^^^^^^^ attempt to negate `i32::MIN`, which would overflow
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:31:35
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:29:35
|
LL | const NEG_REV: i32 = T::NEG + (-i32::MIN);
| ^^^^^^^^^^^ attempt to negate `i32::MIN`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:34:22
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:32:22
|
LL | const ADD: i32 = (i32::MAX+1) + T::ADD;
| ^^^^^^^^^^^^ attempt to compute `i32::MAX + 1_i32`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:36:36
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:34:36
|
LL | const ADD_REV: i32 = T::ADD + (i32::MAX+1);
| ^^^^^^^^^^^^ attempt to compute `i32::MAX + 1_i32`, which would overflow
error: this operation will panic at runtime
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:39:22
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:37:22
|
LL | const DIV: i32 = (1/0) + T::DIV;
| ^^^^^ attempt to divide `1_i32` by zero
= note: `#[deny(unconditional_panic)]` on by default
error: this operation will panic at runtime
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:41:35
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:39:35
|
LL | const DIV_REV: i32 = T::DIV + (1/0);
| ^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:44:22
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:42:22
|
LL | const OOB: i32 = [1][1] + T::OOB;
| ^^^^^^ index out of bounds: the length is 1 but the index is 1
error: this operation will panic at runtime
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:46:35
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:44:35
|
LL | const OOB_REV: i32 = T::OOB + [1][1];
| ^^^^^^ index out of bounds: the length is 1 but the index is 1
error: this arithmetic operation will overflow
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:29:22
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:27:22
|
LL | const NEG: i32 = -i32::MIN + T::NEG;
| ^^^^^^^^^ attempt to negate `i32::MIN`, which would overflow
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:31:35
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:29:35
|
LL | const NEG_REV: i32 = T::NEG + (-i32::MIN);
| ^^^^^^^^^^^ attempt to negate `i32::MIN`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:34:22
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:32:22
|
LL | const ADD: i32 = (i32::MAX+1) + T::ADD;
| ^^^^^^^^^^^^ attempt to compute `i32::MAX + 1_i32`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:36:36
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:34:36
|
LL | const ADD_REV: i32 = T::ADD + (i32::MAX+1);
| ^^^^^^^^^^^^ attempt to compute `i32::MAX + 1_i32`, which would overflow
error: this operation will panic at runtime
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:39:22
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:37:22
|
LL | const DIV: i32 = (1/0) + T::DIV;
| ^^^^^ attempt to divide `1_i32` by zero
= note: `#[deny(unconditional_panic)]` on by default
error: this operation will panic at runtime
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:41:35
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:39:35
|
LL | const DIV_REV: i32 = T::DIV + (1/0);
| ^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:44:22
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:42:22
|
LL | const OOB: i32 = [1][1] + T::OOB;
| ^^^^^^ index out of bounds: the length is 1 but the index is 1
error: this operation will panic at runtime
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:46:35
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:44:35
|
LL | const OOB_REV: i32 = T::OOB + [1][1];
| ^^^^^^ index out of bounds: the length is 1 but the index is 1
error: this arithmetic operation will overflow
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:29:22
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:27:22
|
LL | const NEG: i32 = -i32::MIN + T::NEG;
| ^^^^^^^^^ attempt to negate `i32::MIN`, which would overflow
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:31:35
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:29:35
|
LL | const NEG_REV: i32 = T::NEG + (-i32::MIN);
| ^^^^^^^^^^^ attempt to negate `i32::MIN`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:34:22
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:32:22
|
LL | const ADD: i32 = (i32::MAX+1) + T::ADD;
| ^^^^^^^^^^^^ attempt to compute `i32::MAX + 1_i32`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:36:36
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:34:36
|
LL | const ADD_REV: i32 = T::ADD + (i32::MAX+1);
| ^^^^^^^^^^^^ attempt to compute `i32::MAX + 1_i32`, which would overflow
error: this operation will panic at runtime
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:39:22
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:37:22
|
LL | const DIV: i32 = (1/0) + T::DIV;
| ^^^^^ attempt to divide `1_i32` by zero
= note: `#[deny(unconditional_panic)]` on by default
error: this operation will panic at runtime
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:41:35
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:39:35
|
LL | const DIV_REV: i32 = T::DIV + (1/0);
| ^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:44:22
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:42:22
|
LL | const OOB: i32 = [1][1] + T::OOB;
| ^^^^^^ index out of bounds: the length is 1 but the index is 1
error: this operation will panic at runtime
- --> $DIR/issue-69020-assoc-const-arith-overflow.rs:46:35
+ --> $DIR/issue-69020-assoc-const-arith-overflow.rs:44:35
|
LL | const OOB_REV: i32 = T::OOB + [1][1];
| ^^^^^^ index out of bounds: the length is 1 but the index is 1
#![crate_type="lib"]
-use std::i32;
-
pub trait Foo {
const NEG: i32;
const NEG_REV: i32;
assert_eq!((-2147483648i32).wrapping_sub(1), 2147483647);
- assert_eq!(-3.40282356e+38_f32, ::std::f32::MIN);
- assert_eq!(3.40282356e+38_f32, ::std::f32::MAX);
- assert_eq!(-1.7976931348623158e+308_f64, ::std::f64::MIN);
- assert_eq!(1.7976931348623158e+308_f64, ::std::f64::MAX);
+ assert_eq!(-3.40282356e+38_f32, f32::MIN);
+ assert_eq!(3.40282356e+38_f32, f32::MAX);
+ assert_eq!(-1.7976931348623158e+308_f64, f64::MIN);
+ assert_eq!(1.7976931348623158e+308_f64, f64::MAX);
}
if a < b {
std::mem::size_of::<T>()
} else {
- std::usize::MAX
+ usize::MAX
}
}
error: constant expression depends on a generic parameter
- --> $DIR/issue-72819-generic-in-const-eval.rs:9:47
+ --> $DIR/issue-72819-generic-in-const-eval.rs:9:39
|
-LL | where Assert::<{N < usize::max_value() / 2}>: IsTrue,
- | ^^^^^^
+LL | where Assert::<{N < usize::MAX / 2}>: IsTrue,
+ | ^^^^^^
|
= note: this may fail depending on what value the parameter takes
error: generic parameters may not be used in const operations
--> $DIR/issue-72819-generic-in-const-eval.rs:9:17
|
-LL | where Assert::<{N < usize::max_value() / 2}>: IsTrue,
+LL | where Assert::<{N < usize::MAX / 2}>: IsTrue,
| ^ cannot perform const operation using `N`
|
= help: const parameters may only be used as standalone arguments, i.e. `N`
#![cfg_attr(min, feature(min_const_generics))]
struct Arr<const N: usize>
-where Assert::<{N < usize::max_value() / 2}>: IsTrue,
+where Assert::<{N < usize::MAX / 2}>: IsTrue,
//[full]~^ ERROR constant expression depends on a generic parameter
//[min]~^^ ERROR generic parameters may not be used in const operations
{
impl IsTrue for Assert<true> {}
fn main() {
- let x: Arr<{usize::max_value()}> = Arr {};
+ let x: Arr<{usize::MAX}> = Arr {};
}
#![feature(const_generics)]
#![allow(incomplete_features)]
struct Arr<const N: usize>
-where Assert::<{N < usize::max_value() / 2}>: IsTrue, //~ ERROR constant expression
+where Assert::<{N < usize::MAX / 2}>: IsTrue, //~ ERROR constant expression
{
}
impl IsTrue for Assert<true> {}
fn main() {
- let x: Arr<{usize::max_value()}> = Arr {};
+ let x: Arr<{usize::MAX}> = Arr {};
//~^ ERROR mismatched types
//~| ERROR mismatched types
}
error: constant expression depends on a generic parameter
- --> $DIR/issue-73260.rs:6:47
+ --> $DIR/issue-73260.rs:6:39
|
-LL | where Assert::<{N < usize::max_value() / 2}>: IsTrue,
- | ^^^^^^
+LL | where Assert::<{N < usize::MAX / 2}>: IsTrue,
+ | ^^^^^^
|
= note: this may fail depending on what value the parameter takes
error[E0308]: mismatched types
--> $DIR/issue-73260.rs:17:12
|
-LL | let x: Arr<{usize::max_value()}> = Arr {};
- | ^^^^^^^^^^^^^^^^^^^^^^^^^ expected `false`, found `true`
+LL | let x: Arr<{usize::MAX}> = Arr {};
+ | ^^^^^^^^^^^^^^^^^ expected `false`, found `true`
|
= note: expected type `false`
found type `true`
error[E0308]: mismatched types
- --> $DIR/issue-73260.rs:17:40
+ --> $DIR/issue-73260.rs:17:32
|
-LL | let x: Arr<{usize::max_value()}> = Arr {};
- | ^^^ expected `false`, found `true`
+LL | let x: Arr<{usize::MAX}> = Arr {};
+ | ^^^ expected `false`, found `true`
|
= note: expected type `false`
found type `true`
#![deny(const_err)]
-pub const A: i8 = -std::i8::MIN; //~ ERROR const_err
+pub const A: i8 = -i8::MIN; //~ ERROR const_err
pub const B: u8 = 200u8 + 200u8; //~ ERROR const_err
pub const C: u8 = 200u8 * 4; //~ ERROR const_err
pub const D: u8 = 42u8 - (42u8 + 1); //~ ERROR const_err
error: any use of this value will cause an error
--> $DIR/const-err-early.rs:3:19
|
-LL | pub const A: i8 = -std::i8::MIN;
- | ------------------^^^^^^^^^^^^^-
+LL | pub const A: i8 = -i8::MIN;
+ | ------------------^^^^^^^^-
| |
| attempt to negate `i8::MIN`, which would overflow
|
#![deny(const_err)]
-pub const A: i8 = -std::i8::MIN;
+pub const A: i8 = -i8::MIN;
//~^ ERROR const_err
pub const B: i8 = A;
//~^ ERROR const_err
error: any use of this value will cause an error
--> $DIR/const-err-multi.rs:3:19
|
-LL | pub const A: i8 = -std::i8::MIN;
- | ------------------^^^^^^^^^^^^^-
+LL | pub const A: i8 = -i8::MIN;
+ | ------------------^^^^^^^^-
| |
| attempt to negate `i8::MIN`, which would overflow
|
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:19:13
|
-LL | let a = -std::i8::MIN;
- | ^^^^^^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
+LL | let a = -i8::MIN;
+ | ^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
|
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:21:18
|
-LL | let a_i128 = -std::i128::MIN;
- | ^^^^^^^^^^^^^^^ attempt to negate `i128::MIN`, which would overflow
+LL | let a_i128 = -i128::MIN;
+ | ^^^^^^^^^^ attempt to negate `i128::MIN`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:23:13
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:25:18
|
-LL | let b_i128 = std::i128::MIN - std::i128::MAX;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to compute `i128::MIN - i128::MAX`, which would overflow
+LL | let b_i128 = i128::MIN - i128::MAX;
+ | ^^^^^^^^^^^^^^^^^^^^^ attempt to compute `i128::MIN - i128::MAX`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:27:13
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:19:13
|
-LL | let a = -std::i8::MIN;
- | ^^^^^^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
+LL | let a = -i8::MIN;
+ | ^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
|
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:21:18
|
-LL | let a_i128 = -std::i128::MIN;
- | ^^^^^^^^^^^^^^^ attempt to negate `i128::MIN`, which would overflow
+LL | let a_i128 = -i128::MIN;
+ | ^^^^^^^^^^ attempt to negate `i128::MIN`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:23:13
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:25:18
|
-LL | let b_i128 = std::i128::MIN - std::i128::MAX;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to compute `i128::MIN - i128::MAX`, which would overflow
+LL | let b_i128 = i128::MIN - i128::MAX;
+ | ^^^^^^^^^^^^^^^^^^^^^ attempt to compute `i128::MIN - i128::MAX`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:27:13
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:19:13
|
-LL | let a = -std::i8::MIN;
- | ^^^^^^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
+LL | let a = -i8::MIN;
+ | ^^^^^^^^ attempt to negate `i8::MIN`, which would overflow
|
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:21:18
|
-LL | let a_i128 = -std::i128::MIN;
- | ^^^^^^^^^^^^^^^ attempt to negate `i128::MIN`, which would overflow
+LL | let a_i128 = -i128::MIN;
+ | ^^^^^^^^^^ attempt to negate `i128::MIN`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:23:13
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:25:18
|
-LL | let b_i128 = std::i128::MIN - std::i128::MAX;
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to compute `i128::MIN - i128::MAX`, which would overflow
+LL | let b_i128 = i128::MIN - i128::MAX;
+ | ^^^^^^^^^^^^^^^^^^^^^ attempt to compute `i128::MIN - i128::MAX`, which would overflow
error: this arithmetic operation will overflow
--> $DIR/const-err2.rs:27:13
}
fn main() {
- let a = -std::i8::MIN;
+ let a = -i8::MIN;
//~^ ERROR arithmetic operation will overflow
- let a_i128 = -std::i128::MIN;
+ let a_i128 = -i128::MIN;
//~^ ERROR arithmetic operation will overflow
let b = 200u8 + 200u8 + 200u8;
//~^ ERROR arithmetic operation will overflow
- let b_i128 = std::i128::MIN - std::i128::MAX;
+ let b_i128 = i128::MIN - i128::MAX;
//~^ ERROR arithmetic operation will overflow
let c = 200u8 * 4;
//~^ ERROR arithmetic operation will overflow
#![allow(unused_imports)]
use std::fmt;
-use std::{i8, i16, i32, i64, isize};
-use std::{u8, u16, u32, u64, usize};
const A_I8_I
: [u32; (i8::MAX as usize) + 1]
error[E0080]: evaluation of constant value failed
- --> $DIR/const-eval-overflow-3.rs:20:11
+ --> $DIR/const-eval-overflow-3.rs:18:11
|
LL | = [0; (i8::MAX + 1) as usize];
| ^^^^^^^^^^^^^ attempt to compute `i8::MAX + 1_i8`, which would overflow
#![allow(unused_imports)]
use std::fmt;
-use std::{i8, i16, i32, i64, isize};
-use std::{u8, u16, u32, u64, usize};
const A_I8_I
: [u32; (i8::MAX as usize) + 1]
error[E0308]: mismatched types
- --> $DIR/const-eval-overflow-3b.rs:18:22
+ --> $DIR/const-eval-overflow-3b.rs:16:22
|
LL | = [0; (i8::MAX + 1u8) as usize];
| ^^^ expected `i8`, found `u8`
error[E0277]: cannot add `u8` to `i8`
- --> $DIR/const-eval-overflow-3b.rs:18:20
+ --> $DIR/const-eval-overflow-3b.rs:16:20
|
LL | = [0; (i8::MAX + 1u8) as usize];
| ^ no implementation for `i8 + u8`
#![allow(unused_imports)]
use std::fmt;
-use std::{i8, i16, i32, i64, isize};
-use std::{u8, u16, u32, u64, usize};
const A_I8_T
: [u32; (i8::MAX as i8 + 1i8) as usize]
error[E0080]: evaluation of constant value failed
- --> $DIR/const-eval-overflow-4.rs:13:13
+ --> $DIR/const-eval-overflow-4.rs:11:13
|
LL | : [u32; (i8::MAX as i8 + 1i8) as usize]
| ^^^^^^^^^^^^^^^^^^^^^ attempt to compute `i8::MAX + 1_i8`, which would overflow
#![allow(unused_imports)]
-use std::{i8, i16, i32, i64, isize};
-use std::{u8, u16, u32, u64, usize};
-
const A_I8_T
: [u32; (i8::MAX as i8 + 1u8) as usize]
//~^ ERROR mismatched types
error[E0308]: mismatched types
- --> $DIR/const-eval-overflow-4b.rs:12:30
+ --> $DIR/const-eval-overflow-4b.rs:9:30
|
LL | : [u32; (i8::MAX as i8 + 1u8) as usize]
| ^^^ expected `i8`, found `u8`
error[E0277]: cannot add `u8` to `i8`
- --> $DIR/const-eval-overflow-4b.rs:12:28
+ --> $DIR/const-eval-overflow-4b.rs:9:28
|
LL | : [u32; (i8::MAX as i8 + 1u8) as usize]
| ^ no implementation for `i8 + u8`
= help: the trait `Add<u8>` is not implemented for `i8`
error[E0604]: only `u8` can be cast as `char`, not `i8`
- --> $DIR/const-eval-overflow-4b.rs:25:13
+ --> $DIR/const-eval-overflow-4b.rs:22:13
|
LL | : [u32; 5i8 as char as usize]
| ^^^^^^^^^^^ invalid cast
#![deny(const_err)]
use std::fmt;
-use std::{i8, i16, i32, i64, isize};
-use std::{u8, u16, u32, u64, usize};
const VALS_I8: (i8,) =
(
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2.rs:16:6
+ --> $DIR/const-eval-overflow2.rs:14:6
|
LL | / const VALS_I8: (i8,) =
LL | | (
| ^^^^^^^^^
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2.rs:22:6
+ --> $DIR/const-eval-overflow2.rs:20:6
|
LL | / const VALS_I16: (i16,) =
LL | | (
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2.rs:28:6
+ --> $DIR/const-eval-overflow2.rs:26:6
|
LL | / const VALS_I32: (i32,) =
LL | | (
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2.rs:34:6
+ --> $DIR/const-eval-overflow2.rs:32:6
|
LL | / const VALS_I64: (i64,) =
LL | | (
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2.rs:40:6
+ --> $DIR/const-eval-overflow2.rs:38:6
|
LL | / const VALS_U8: (u8,) =
LL | | (
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2.rs:45:6
+ --> $DIR/const-eval-overflow2.rs:43:6
|
LL | / const VALS_U16: (u16,) = (
LL | | u16::MIN - 1,
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2.rs:50:6
+ --> $DIR/const-eval-overflow2.rs:48:6
|
LL | / const VALS_U32: (u32,) = (
LL | | u32::MIN - 1,
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2.rs:56:6
+ --> $DIR/const-eval-overflow2.rs:54:6
|
LL | / const VALS_U64: (u64,) =
LL | | (
#![deny(const_err)]
use std::fmt;
-use std::{i8, i16, i32, i64, isize};
-use std::{u8, u16, u32, u64, usize};
const VALS_I8: (i8,) =
(
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2b.rs:16:6
+ --> $DIR/const-eval-overflow2b.rs:14:6
|
LL | / const VALS_I8: (i8,) =
LL | | (
| ^^^^^^^^^
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2b.rs:22:6
+ --> $DIR/const-eval-overflow2b.rs:20:6
|
LL | / const VALS_I16: (i16,) =
LL | | (
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2b.rs:28:6
+ --> $DIR/const-eval-overflow2b.rs:26:6
|
LL | / const VALS_I32: (i32,) =
LL | | (
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2b.rs:34:6
+ --> $DIR/const-eval-overflow2b.rs:32:6
|
LL | / const VALS_I64: (i64,) =
LL | | (
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2b.rs:40:6
+ --> $DIR/const-eval-overflow2b.rs:38:6
|
LL | / const VALS_U8: (u8,) =
LL | | (
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2b.rs:45:6
+ --> $DIR/const-eval-overflow2b.rs:43:6
|
LL | / const VALS_U16: (u16,) = (
LL | | u16::MAX + 1,
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2b.rs:50:6
+ --> $DIR/const-eval-overflow2b.rs:48:6
|
LL | / const VALS_U32: (u32,) = (
LL | | u32::MAX + 1,
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2b.rs:56:6
+ --> $DIR/const-eval-overflow2b.rs:54:6
|
LL | / const VALS_U64: (u64,) =
LL | | (
#![deny(const_err)]
use std::fmt;
-use std::{i8, i16, i32, i64, isize};
-use std::{u8, u16, u32, u64, usize};
const VALS_I8: (i8,) =
(
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2c.rs:16:6
+ --> $DIR/const-eval-overflow2c.rs:14:6
|
LL | / const VALS_I8: (i8,) =
LL | | (
| ^^^^^^^^^
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2c.rs:22:6
+ --> $DIR/const-eval-overflow2c.rs:20:6
|
LL | / const VALS_I16: (i16,) =
LL | | (
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2c.rs:28:6
+ --> $DIR/const-eval-overflow2c.rs:26:6
|
LL | / const VALS_I32: (i32,) =
LL | | (
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2c.rs:34:6
+ --> $DIR/const-eval-overflow2c.rs:32:6
|
LL | / const VALS_I64: (i64,) =
LL | | (
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2c.rs:40:6
+ --> $DIR/const-eval-overflow2c.rs:38:6
|
LL | / const VALS_U8: (u8,) =
LL | | (
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2c.rs:45:6
+ --> $DIR/const-eval-overflow2c.rs:43:6
|
LL | / const VALS_U16: (u16,) = (
LL | | u16::MAX * 2,
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2c.rs:50:6
+ --> $DIR/const-eval-overflow2c.rs:48:6
|
LL | / const VALS_U32: (u32,) = (
LL | | u32::MAX * 2,
| |_______-
error: any use of this value will cause an error
- --> $DIR/const-eval-overflow2c.rs:56:6
+ --> $DIR/const-eval-overflow2c.rs:54:6
|
LL | / const VALS_U64: (u64,) =
LL | | (
#![feature(const_raw_ptr_deref)]
-use std::{mem, usize};
+use std::mem;
// Make sure we error with the right kind of error on a too large slice.
const TEST: () = { unsafe { //~ NOTE
#![feature(const_overflowing_int_methods)]
#![feature(const_wrapping_int_methods)]
-use std::{i8, i128};
-
macro_rules! suite {
($(
$fn:ident -> $ty:ty { $( $label:ident : $expr:expr, $result:expr; )* }
const SHR_B: (u32, bool) = 0x10u32.overflowing_shr(132);
const NEG_A: (u32, bool) = 0u32.overflowing_neg();
-const NEG_B: (u32, bool) = core::u32::MAX.overflowing_neg();
+const NEG_B: (u32, bool) = u32::MAX.overflowing_neg();
const ABS_POS: (i32, bool) = 10i32.overflowing_abs();
const ABS_NEG: (i32, bool) = (-10i32).overflowing_abs();
const I: isize = -2147483648isize;
#[cfg(target_pointer_width = "64")]
const I: isize = -9223372036854775808isize;
- assert_eq!(::std::i32::MIN as u64, 0xffffffff80000000);
+ assert_eq!(i32::MIN as u64, 0xffffffff80000000);
assert_eq!(-2147483648isize as u64, 0xffffffff80000000);
assert_eq!(-2147483648i32 as u64, 0xffffffff80000000);
- assert_eq!(::std::i64::MIN as u64, 0x8000000000000000);
+ assert_eq!(i64::MIN as u64, 0x8000000000000000);
#[cfg(target_pointer_width = "64")]
assert_eq!(-9223372036854775808isize as u64, 0x8000000000000000);
#[cfg(target_pointer_width = "32")]
assert_eq!(-9223372036854775808isize as u64, 0);
assert_eq!(-9223372036854775808i32 as u64, 0);
- const J: usize = ::std::i32::MAX as usize;
+ const J: usize = i32::MAX as usize;
const K: usize = -1i32 as u32 as usize;
- const L: usize = ::std::i32::MIN as usize;
- const M: usize = ::std::i64::MIN as usize;
+ const L: usize = i32::MIN as usize;
+ const M: usize = i64::MIN as usize;
match 5 {
J => {},
K => {},
// Regression test for #63952, shouldn't hang.
-use std::usize;
-
#[repr(C)]
#[derive(Copy, Clone)]
struct SliceRepr {
error[E0080]: it is undefined behavior to use this value
- --> $DIR/issue-63952.rs:18:1
+ --> $DIR/issue-63952.rs:16:1
|
LL | / const SLICE_WAY_TOO_LONG: &[u8] = unsafe {
LL | | SliceTransmute {
+#![allow(deprecated, deprecated_in_future)] // can be removed if different fns are chosen
// build-pass (FIXME(62277): could be check-pass?)
fn main() {
// make sure that these do not cause trouble despite overflowing
baz_u32(&(0-1));
- baz_i32(&-std::i32::MIN);
+ baz_i32(&-i32::MIN);
}
#![allow(dead_code, unused_variables, unused_imports)]
-use std::{i8,u8,i16,u16,i32,u32,i64, u64};
-
fn f_i8() {
#[repr(i8)]
enum A {
error[E0308]: mismatched types
- --> $DIR/discrim-ill-typed.rs:17:16
+ --> $DIR/discrim-ill-typed.rs:15:16
|
LL | OhNo = 0_u8,
| ^^^^ expected `i8`, found `u8`
| ^^^^
error[E0308]: mismatched types
- --> $DIR/discrim-ill-typed.rs:30:16
+ --> $DIR/discrim-ill-typed.rs:28:16
|
LL | OhNo = 0_i8,
| ^^^^ expected `u8`, found `i8`
| ^^^^
error[E0308]: mismatched types
- --> $DIR/discrim-ill-typed.rs:43:16
+ --> $DIR/discrim-ill-typed.rs:41:16
|
LL | OhNo = 0_u16,
| ^^^^^ expected `i16`, found `u16`
| ^^^^^
error[E0308]: mismatched types
- --> $DIR/discrim-ill-typed.rs:56:16
+ --> $DIR/discrim-ill-typed.rs:54:16
|
LL | OhNo = 0_i16,
| ^^^^^ expected `u16`, found `i16`
| ^^^^^
error[E0308]: mismatched types
- --> $DIR/discrim-ill-typed.rs:69:16
+ --> $DIR/discrim-ill-typed.rs:67:16
|
LL | OhNo = 0_u32,
| ^^^^^ expected `i32`, found `u32`
| ^^^^^
error[E0308]: mismatched types
- --> $DIR/discrim-ill-typed.rs:82:16
+ --> $DIR/discrim-ill-typed.rs:80:16
|
LL | OhNo = 0_i32,
| ^^^^^ expected `u32`, found `i32`
| ^^^^^
error[E0308]: mismatched types
- --> $DIR/discrim-ill-typed.rs:95:16
+ --> $DIR/discrim-ill-typed.rs:93:16
|
LL | OhNo = 0_u64,
| ^^^^^ expected `i64`, found `u64`
| ^^^^^
error[E0308]: mismatched types
- --> $DIR/discrim-ill-typed.rs:108:16
+ --> $DIR/discrim-ill-typed.rs:106:16
|
LL | OhNo = 0_i64,
| ^^^^^ expected `u64`, found `i64`
// See also run-pass/discrim-explicit-23030.rs where the suggested
// workaround is tested.
-use std::{i8,u8,i16,u16,i32,u32,i64, u64};
-
fn f_i8() {
#[repr(i8)]
enum A {
error[E0370]: enum discriminant overflowed
- --> $DIR/discrim-overflow-2.rs:15:9
+ --> $DIR/discrim-overflow-2.rs:13:9
|
LL | OhNo,
| ^^^^ overflowed on value after 127
= note: explicitly set `OhNo = -128` if that is desired outcome
error[E0370]: enum discriminant overflowed
- --> $DIR/discrim-overflow-2.rs:24:9
+ --> $DIR/discrim-overflow-2.rs:22:9
|
LL | OhNo,
| ^^^^ overflowed on value after 255
= note: explicitly set `OhNo = 0` if that is desired outcome
error[E0370]: enum discriminant overflowed
- --> $DIR/discrim-overflow-2.rs:33:9
+ --> $DIR/discrim-overflow-2.rs:31:9
|
LL | OhNo,
| ^^^^ overflowed on value after 32767
= note: explicitly set `OhNo = -32768` if that is desired outcome
error[E0370]: enum discriminant overflowed
- --> $DIR/discrim-overflow-2.rs:42:9
+ --> $DIR/discrim-overflow-2.rs:40:9
|
LL | OhNo,
| ^^^^ overflowed on value after 65535
= note: explicitly set `OhNo = 0` if that is desired outcome
error[E0370]: enum discriminant overflowed
- --> $DIR/discrim-overflow-2.rs:51:9
+ --> $DIR/discrim-overflow-2.rs:49:9
|
LL | OhNo,
| ^^^^ overflowed on value after 2147483647
= note: explicitly set `OhNo = -2147483648` if that is desired outcome
error[E0370]: enum discriminant overflowed
- --> $DIR/discrim-overflow-2.rs:60:9
+ --> $DIR/discrim-overflow-2.rs:58:9
|
LL | OhNo,
| ^^^^ overflowed on value after 4294967295
= note: explicitly set `OhNo = 0` if that is desired outcome
error[E0370]: enum discriminant overflowed
- --> $DIR/discrim-overflow-2.rs:69:9
+ --> $DIR/discrim-overflow-2.rs:67:9
|
LL | OhNo,
| ^^^^ overflowed on value after 9223372036854775807
= note: explicitly set `OhNo = -9223372036854775808` if that is desired outcome
error[E0370]: enum discriminant overflowed
- --> $DIR/discrim-overflow-2.rs:78:9
+ --> $DIR/discrim-overflow-2.rs:76:9
|
LL | OhNo,
| ^^^^ overflowed on value after 18446744073709551615
// See also run-pass/discrim-explicit-23030.rs where the suggested
// workaround is tested.
-use std::{i8,u8,i16,u16,i32,u32,i64, u64};
-
fn f_i8() {
#[repr(i8)]
enum A {
error[E0370]: enum discriminant overflowed
- --> $DIR/discrim-overflow.rs:13:9
+ --> $DIR/discrim-overflow.rs:11:9
|
LL | OhNo,
| ^^^^ overflowed on value after 127
= note: explicitly set `OhNo = -128` if that is desired outcome
error[E0370]: enum discriminant overflowed
- --> $DIR/discrim-overflow.rs:24:9
+ --> $DIR/discrim-overflow.rs:22:9
|
LL | OhNo,
| ^^^^ overflowed on value after 255
= note: explicitly set `OhNo = 0` if that is desired outcome
error[E0370]: enum discriminant overflowed
- --> $DIR/discrim-overflow.rs:35:9
+ --> $DIR/discrim-overflow.rs:33:9
|
LL | OhNo,
| ^^^^ overflowed on value after 32767
= note: explicitly set `OhNo = -32768` if that is desired outcome
error[E0370]: enum discriminant overflowed
- --> $DIR/discrim-overflow.rs:46:9
+ --> $DIR/discrim-overflow.rs:44:9
|
LL | OhNo,
| ^^^^ overflowed on value after 65535
= note: explicitly set `OhNo = 0` if that is desired outcome
error[E0370]: enum discriminant overflowed
- --> $DIR/discrim-overflow.rs:58:9
+ --> $DIR/discrim-overflow.rs:56:9
|
LL | OhNo,
| ^^^^ overflowed on value after 2147483647
= note: explicitly set `OhNo = -2147483648` if that is desired outcome
error[E0370]: enum discriminant overflowed
- --> $DIR/discrim-overflow.rs:70:9
+ --> $DIR/discrim-overflow.rs:68:9
|
LL | OhNo,
| ^^^^ overflowed on value after 4294967295
= note: explicitly set `OhNo = 0` if that is desired outcome
error[E0370]: enum discriminant overflowed
- --> $DIR/discrim-overflow.rs:82:9
+ --> $DIR/discrim-overflow.rs:80:9
|
LL | OhNo,
| ^^^^ overflowed on value after 9223372036854775807
= note: explicitly set `OhNo = -9223372036854775808` if that is desired outcome
error[E0370]: enum discriminant overflowed
- --> $DIR/discrim-overflow.rs:94:9
+ --> $DIR/discrim-overflow.rs:92:9
|
LL | OhNo,
| ^^^^ overflowed on value after 18446744073709551615
ptr,
rc::Rc,
task::{Context, Poll, RawWaker, RawWakerVTable, Waker},
- usize,
};
struct InjectedFailure;
use std::ops::Generator;
use std::panic;
use std::pin::Pin;
-use std::usize;
struct InjectedFailure;
-use std::{isize, usize};
-
fn main() {
match 0usize {
//~^ ERROR non-exhaustive patterns: `_` not covered
error[E0004]: non-exhaustive patterns: `_` not covered
- --> $DIR/feature-gate-precise_pointer_size_matching.rs:4:11
+ --> $DIR/feature-gate-precise_pointer_size_matching.rs:2:11
|
LL | match 0usize {
| ^^^^^^ pattern `_` not covered
= help: add `#![feature(precise_pointer_size_matching)]` to the crate attributes to enable precise `usize` matching
error[E0004]: non-exhaustive patterns: `_` not covered
- --> $DIR/feature-gate-precise_pointer_size_matching.rs:12:11
+ --> $DIR/feature-gate-precise_pointer_size_matching.rs:10:11
|
LL | match 0isize {
| ^^^^^^ pattern `_` not covered
}
fn floats() {
- m!(0f32, core::f32::NEG_INFINITY..); //~ ERROR non-exhaustive patterns: `_` not covered
- m!(0f32, ..core::f32::INFINITY); //~ ERROR non-exhaustive patterns: `_` not covered
+ m!(0f32, f32::NEG_INFINITY..); //~ ERROR non-exhaustive patterns: `_` not covered
+ m!(0f32, ..f32::INFINITY); //~ ERROR non-exhaustive patterns: `_` not covered
}
fn khar() {
mod unsigned {
fn u8() {
- const ALMOST_MAX: u8 = core::u8::MAX - 1;
- const ALMOST_MIN: u8 = core::u8::MIN + 1;
+ const ALMOST_MAX: u8 = u8::MAX - 1;
+ const ALMOST_MIN: u8 = u8::MIN + 1;
const VAL: u8 = 42;
const VAL_1: u8 = VAL + 1;
const VAL_2: u8 = VAL + 2;
- m!(0, ..core::u8::MAX); //~ ERROR non-exhaustive patterns
+ m!(0, ..u8::MAX); //~ ERROR non-exhaustive patterns
m!(0, ..ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ALMOST_MIN..); //~ ERROR non-exhaustive patterns
m!(0, ..=ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ..VAL_1 | VAL_2..); //~ ERROR non-exhaustive patterns
}
fn u16() {
- const ALMOST_MAX: u16 = core::u16::MAX - 1;
- const ALMOST_MIN: u16 = core::u16::MIN + 1;
+ const ALMOST_MAX: u16 = u16::MAX - 1;
+ const ALMOST_MIN: u16 = u16::MIN + 1;
const VAL: u16 = 42;
const VAL_1: u16 = VAL + 1;
const VAL_2: u16 = VAL + 2;
- m!(0, ..core::u16::MAX); //~ ERROR non-exhaustive patterns
+ m!(0, ..u16::MAX); //~ ERROR non-exhaustive patterns
m!(0, ..ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ALMOST_MIN..); //~ ERROR non-exhaustive patterns
m!(0, ..=ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ..VAL_1 | VAL_2..); //~ ERROR non-exhaustive patterns
}
fn u32() {
- const ALMOST_MAX: u32 = core::u32::MAX - 1;
- const ALMOST_MIN: u32 = core::u32::MIN + 1;
+ const ALMOST_MAX: u32 = u32::MAX - 1;
+ const ALMOST_MIN: u32 = u32::MIN + 1;
const VAL: u32 = 42;
const VAL_1: u32 = VAL + 1;
const VAL_2: u32 = VAL + 2;
- m!(0, ..core::u32::MAX); //~ ERROR non-exhaustive patterns
+ m!(0, ..u32::MAX); //~ ERROR non-exhaustive patterns
m!(0, ..ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ALMOST_MIN..); //~ ERROR non-exhaustive patterns
m!(0, ..=ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ..VAL_1 | VAL_2..); //~ ERROR non-exhaustive patterns
}
fn u64() {
- const ALMOST_MAX: u64 = core::u64::MAX - 1;
- const ALMOST_MIN: u64 = core::u64::MIN + 1;
+ const ALMOST_MAX: u64 = u64::MAX - 1;
+ const ALMOST_MIN: u64 = u64::MIN + 1;
const VAL: u64 = 42;
const VAL_1: u64 = VAL + 1;
const VAL_2: u64 = VAL + 2;
- m!(0, ..core::u64::MAX); //~ ERROR non-exhaustive patterns
+ m!(0, ..u64::MAX); //~ ERROR non-exhaustive patterns
m!(0, ..ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ALMOST_MIN..); //~ ERROR non-exhaustive patterns
m!(0, ..=ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ..VAL_1 | VAL_2..); //~ ERROR non-exhaustive patterns
}
fn u128() {
- const ALMOST_MAX: u128 = core::u128::MAX - 1;
- const ALMOST_MIN: u128 = core::u128::MIN + 1;
+ const ALMOST_MAX: u128 = u128::MAX - 1;
+ const ALMOST_MIN: u128 = u128::MIN + 1;
const VAL: u128 = 42;
const VAL_1: u128 = VAL + 1;
const VAL_2: u128 = VAL + 2;
- m!(0, ..core::u128::MAX); //~ ERROR non-exhaustive patterns
+ m!(0, ..u128::MAX); //~ ERROR non-exhaustive patterns
m!(0, ..ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ALMOST_MIN..); //~ ERROR non-exhaustive patterns
m!(0, ..=ALMOST_MAX); //~ ERROR non-exhaustive patterns
mod signed {
fn i8() {
- const ALMOST_MAX: i8 = core::i8::MAX - 1;
- const ALMOST_MIN: i8 = core::i8::MIN + 1;
+ const ALMOST_MAX: i8 = i8::MAX - 1;
+ const ALMOST_MIN: i8 = i8::MIN + 1;
const VAL: i8 = 42;
const VAL_1: i8 = VAL + 1;
const VAL_2: i8 = VAL + 2;
- m!(0, ..core::i8::MAX); //~ ERROR non-exhaustive patterns
+ m!(0, ..i8::MAX); //~ ERROR non-exhaustive patterns
m!(0, ..ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ALMOST_MIN..); //~ ERROR non-exhaustive patterns
m!(0, ..=ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ..VAL_1 | VAL_2..); //~ ERROR non-exhaustive patterns
}
fn i16() {
- const ALMOST_MAX: i16 = core::i16::MAX - 1;
- const ALMOST_MIN: i16 = core::i16::MIN + 1;
+ const ALMOST_MAX: i16 = i16::MAX - 1;
+ const ALMOST_MIN: i16 = i16::MIN + 1;
const VAL: i16 = 42;
const VAL_1: i16 = VAL + 1;
const VAL_2: i16 = VAL + 2;
- m!(0, ..core::i16::MAX); //~ ERROR non-exhaustive patterns
+ m!(0, ..i16::MAX); //~ ERROR non-exhaustive patterns
m!(0, ..ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ALMOST_MIN..); //~ ERROR non-exhaustive patterns
m!(0, ..=ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ..VAL_1 | VAL_2..); //~ ERROR non-exhaustive patterns
}
fn i32() {
- const ALMOST_MAX: i32 = core::i32::MAX - 1;
- const ALMOST_MIN: i32 = core::i32::MIN + 1;
+ const ALMOST_MAX: i32 = i32::MAX - 1;
+ const ALMOST_MIN: i32 = i32::MIN + 1;
const VAL: i32 = 42;
const VAL_1: i32 = VAL + 1;
const VAL_2: i32 = VAL + 2;
- m!(0, ..core::i32::MAX); //~ ERROR non-exhaustive patterns
+ m!(0, ..i32::MAX); //~ ERROR non-exhaustive patterns
m!(0, ..ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ALMOST_MIN..); //~ ERROR non-exhaustive patterns
m!(0, ..=ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ..VAL_1 | VAL_2..); //~ ERROR non-exhaustive patterns
}
fn i64() {
- const ALMOST_MAX: i64 = core::i64::MAX - 1;
- const ALMOST_MIN: i64 = core::i64::MIN + 1;
+ const ALMOST_MAX: i64 = i64::MAX - 1;
+ const ALMOST_MIN: i64 = i64::MIN + 1;
const VAL: i64 = 42;
const VAL_1: i64 = VAL + 1;
const VAL_2: i64 = VAL + 2;
- m!(0, ..core::i64::MAX); //~ ERROR non-exhaustive patterns
+ m!(0, ..i64::MAX); //~ ERROR non-exhaustive patterns
m!(0, ..ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ALMOST_MIN..); //~ ERROR non-exhaustive patterns
m!(0, ..=ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ..VAL_1 | VAL_2..); //~ ERROR non-exhaustive patterns
}
fn i128() {
- const ALMOST_MAX: i128 = core::i128::MAX - 1;
- const ALMOST_MIN: i128 = core::i128::MIN + 1;
+ const ALMOST_MAX: i128 = i128::MAX - 1;
+ const ALMOST_MIN: i128 = i128::MIN + 1;
const VAL: i128 = 42;
const VAL_1: i128 = VAL + 1;
const VAL_2: i128 = VAL + 2;
- m!(0, ..core::i128::MAX); //~ ERROR non-exhaustive patterns
+ m!(0, ..i128::MAX); //~ ERROR non-exhaustive patterns
m!(0, ..ALMOST_MAX); //~ ERROR non-exhaustive patterns
m!(0, ALMOST_MIN..); //~ ERROR non-exhaustive patterns
m!(0, ..=ALMOST_MAX); //~ ERROR non-exhaustive patterns
error[E0004]: non-exhaustive patterns: `_` not covered
--> $DIR/half-open-range-pats-exhaustive-fail.rs:16:8
|
-LL | m!(0f32, core::f32::NEG_INFINITY..);
+LL | m!(0f32, f32::NEG_INFINITY..);
| ^^^^ pattern `_` not covered
|
= help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
error[E0004]: non-exhaustive patterns: `_` not covered
--> $DIR/half-open-range-pats-exhaustive-fail.rs:17:8
|
-LL | m!(0f32, ..core::f32::INFINITY);
+LL | m!(0f32, ..f32::INFINITY);
| ^^^^ pattern `_` not covered
|
= help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
error[E0004]: non-exhaustive patterns: `u8::MAX` not covered
--> $DIR/half-open-range-pats-exhaustive-fail.rs:41:12
|
-LL | m!(0, ..core::u8::MAX);
+LL | m!(0, ..u8::MAX);
| ^ pattern `u8::MAX` not covered
|
= help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
error[E0004]: non-exhaustive patterns: `u16::MAX` not covered
--> $DIR/half-open-range-pats-exhaustive-fail.rs:54:12
|
-LL | m!(0, ..core::u16::MAX);
+LL | m!(0, ..u16::MAX);
| ^ pattern `u16::MAX` not covered
|
= help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
error[E0004]: non-exhaustive patterns: `u32::MAX` not covered
--> $DIR/half-open-range-pats-exhaustive-fail.rs:67:12
|
-LL | m!(0, ..core::u32::MAX);
+LL | m!(0, ..u32::MAX);
| ^ pattern `u32::MAX` not covered
|
= help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
error[E0004]: non-exhaustive patterns: `u64::MAX` not covered
--> $DIR/half-open-range-pats-exhaustive-fail.rs:80:12
|
-LL | m!(0, ..core::u64::MAX);
+LL | m!(0, ..u64::MAX);
| ^ pattern `u64::MAX` not covered
|
= help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
error[E0004]: non-exhaustive patterns: `u128::MAX` not covered
--> $DIR/half-open-range-pats-exhaustive-fail.rs:93:12
|
-LL | m!(0, ..core::u128::MAX);
+LL | m!(0, ..u128::MAX);
| ^ pattern `u128::MAX` not covered
|
= help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
error[E0004]: non-exhaustive patterns: `i8::MAX` not covered
--> $DIR/half-open-range-pats-exhaustive-fail.rs:109:12
|
-LL | m!(0, ..core::i8::MAX);
+LL | m!(0, ..i8::MAX);
| ^ pattern `i8::MAX` not covered
|
= help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
error[E0004]: non-exhaustive patterns: `i16::MAX` not covered
--> $DIR/half-open-range-pats-exhaustive-fail.rs:122:12
|
-LL | m!(0, ..core::i16::MAX);
+LL | m!(0, ..i16::MAX);
| ^ pattern `i16::MAX` not covered
|
= help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
error[E0004]: non-exhaustive patterns: `i32::MAX` not covered
--> $DIR/half-open-range-pats-exhaustive-fail.rs:135:12
|
-LL | m!(0, ..core::i32::MAX);
+LL | m!(0, ..i32::MAX);
| ^ pattern `i32::MAX` not covered
|
= help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
error[E0004]: non-exhaustive patterns: `i64::MAX` not covered
--> $DIR/half-open-range-pats-exhaustive-fail.rs:148:12
|
-LL | m!(0, ..core::i64::MAX);
+LL | m!(0, ..i64::MAX);
| ^ pattern `i64::MAX` not covered
|
= help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
error[E0004]: non-exhaustive patterns: `i128::MAX` not covered
--> $DIR/half-open-range-pats-exhaustive-fail.rs:161:12
|
-LL | m!(0, ..core::i128::MAX);
+LL | m!(0, ..i128::MAX);
| ^ pattern `i128::MAX` not covered
|
= help: ensure that all possible cases are being handled, possibly by adding wildcards or more match arms
}
fn unsigned_int() {
- test_int!(0u8, core::u8::MIN, core::u8::MAX);
- test_int!(0u16, core::u16::MIN, core::u16::MAX);
- test_int!(0u32, core::u32::MIN, core::u32::MAX);
- test_int!(0u64, core::u64::MIN, core::u64::MAX);
- test_int!(0u128, core::u128::MIN, core::u128::MAX);
+ test_int!(0u8, u8::MIN, u8::MAX);
+ test_int!(0u16, u16::MIN, u16::MAX);
+ test_int!(0u32, u32::MIN, u32::MAX);
+ test_int!(0u64, u64::MIN, u64::MAX);
+ test_int!(0u128, u128::MIN, u128::MAX);
}
fn signed_int() {
- test_int!(0i8, core::i8::MIN, core::i8::MAX);
- test_int!(0i16, core::i16::MIN, core::i16::MAX);
- test_int!(0i32, core::i32::MIN, core::i32::MAX);
- test_int!(0i64, core::i64::MIN, core::i64::MAX);
- test_int!(0i128, core::i128::MIN, core::i128::MAX);
+ test_int!(0i8, i8::MIN, i8::MAX);
+ test_int!(0i16, i16::MIN, i16::MAX);
+ test_int!(0i32, i32::MIN, i32::MAX);
+ test_int!(0i64, i64::MIN, i64::MAX);
+ test_int!(0i128, i128::MIN, i128::MAX);
}
fn khar() {
//---------------------------------------
// u8; `..=X`
- assert!(yes!(core::u8::MIN, ..=core::u8::MIN));
- assert!(yes!(core::u8::MIN, ..=5));
+ assert!(yes!(u8::MIN, ..=u8::MIN));
+ assert!(yes!(u8::MIN, ..=5));
assert!(yes!(5u8, ..=5));
assert!(!yes!(6u8, ..=5));
// i16; `..=X`
- assert!(yes!(core::i16::MIN, ..=core::i16::MIN));
- assert!(yes!(core::i16::MIN, ..=0));
- assert!(yes!(core::i16::MIN, ..=-5));
+ assert!(yes!(i16::MIN, ..=i16::MIN));
+ assert!(yes!(i16::MIN, ..=0));
+ assert!(yes!(i16::MIN, ..=-5));
assert!(yes!(-5, ..=-5));
assert!(!yes!(-4, ..=-5));
assert!(!yes!('b', ..='a'));
// f32; `..=X`
- assert!(yes!(core::f32::NEG_INFINITY, ..=core::f32::NEG_INFINITY));
- assert!(yes!(core::f32::NEG_INFINITY, ..=1.0f32));
+ assert!(yes!(f32::NEG_INFINITY, ..=f32::NEG_INFINITY));
+ assert!(yes!(f32::NEG_INFINITY, ..=1.0f32));
assert!(yes!(1.5f32, ..=1.5f32));
assert!(!yes!(1.6f32, ..=-1.5f32));
// f64; `..=X`
- assert!(yes!(core::f64::NEG_INFINITY, ..=core::f64::NEG_INFINITY));
- assert!(yes!(core::f64::NEG_INFINITY, ..=1.0f64));
+ assert!(yes!(f64::NEG_INFINITY, ..=f64::NEG_INFINITY));
+ assert!(yes!(f64::NEG_INFINITY, ..=1.0f64));
assert!(yes!(1.5f64, ..=1.5f64));
assert!(!yes!(1.6f64, ..=-1.5f64));
}
assert!(!yes!(6u8, ..5));
// u8; `..X`
- const NU8: u8 = core::u8::MIN + 1;
- assert!(yes!(core::u8::MIN, ..NU8));
+ const NU8: u8 = u8::MIN + 1;
+ assert!(yes!(u8::MIN, ..NU8));
assert!(yes!(0u8, ..5));
assert!(!yes!(5u8, ..5));
assert!(!yes!(6u8, ..5));
// i16; `..X`
- const NI16: i16 = core::i16::MIN + 1;
- assert!(yes!(core::i16::MIN, ..NI16));
- assert!(yes!(core::i16::MIN, ..5));
+ const NI16: i16 = i16::MIN + 1;
+ assert!(yes!(i16::MIN, ..NI16));
+ assert!(yes!(i16::MIN, ..5));
assert!(yes!(-6, ..-5));
assert!(!yes!(-5, ..-5));
assert!(!yes!('b', ..'a'));
// f32; `..X`
- assert!(yes!(core::f32::NEG_INFINITY, ..1.0f32));
+ assert!(yes!(f32::NEG_INFINITY, ..1.0f32));
assert!(!yes!(1.5f32, ..1.5f32));
- const E32: f32 = 1.5f32 + core::f32::EPSILON;
+ const E32: f32 = 1.5f32 + f32::EPSILON;
assert!(yes!(1.5f32, ..E32));
assert!(!yes!(1.6f32, ..1.5f32));
// f64; `..X`
- assert!(yes!(core::f64::NEG_INFINITY, ..1.0f64));
+ assert!(yes!(f64::NEG_INFINITY, ..1.0f64));
assert!(!yes!(1.5f64, ..1.5f64));
- const E64: f64 = 1.5f64 + core::f64::EPSILON;
+ const E64: f64 = 1.5f64 + f64::EPSILON;
assert!(yes!(1.5f64, ..E64));
assert!(!yes!(1.6f64, ..1.5f64));
}
//--------------------------------
// u8; `X..`
- assert!(yes!(core::u8::MIN, core::u8::MIN..));
- assert!(yes!(core::u8::MAX, core::u8::MIN..));
- assert!(!yes!(core::u8::MIN, 1..));
+ assert!(yes!(u8::MIN, u8::MIN..));
+ assert!(yes!(u8::MAX, u8::MIN..));
+ assert!(!yes!(u8::MIN, 1..));
assert!(!yes!(4, 5..));
assert!(yes!(5, 5..));
assert!(yes!(6, 5..));
- assert!(yes!(core::u8::MAX, core::u8::MAX..));
+ assert!(yes!(u8::MAX, u8::MAX..));
// i16; `X..`
- assert!(yes!(core::i16::MIN, core::i16::MIN..));
- assert!(yes!(core::i16::MAX, core::i16::MIN..));
- const NI16: i16 = core::i16::MIN + 1;
- assert!(!yes!(core::i16::MIN, NI16..));
+ assert!(yes!(i16::MIN, i16::MIN..));
+ assert!(yes!(i16::MAX, i16::MIN..));
+ const NI16: i16 = i16::MIN + 1;
+ assert!(!yes!(i16::MIN, NI16..));
assert!(!yes!(-4, 5..));
assert!(yes!(-4, -4..));
assert!(yes!(-3, -4..));
- assert!(yes!(core::i16::MAX, core::i16::MAX..));
+ assert!(yes!(i16::MAX, i16::MAX..));
// char; `X..`
assert!(yes!('\u{0}', '\u{0}'..));
assert!(yes!(core::char::MAX, core::char::MAX..));
// f32; `X..`
- assert!(yes!(core::f32::NEG_INFINITY, core::f32::NEG_INFINITY..));
- assert!(yes!(core::f32::INFINITY, core::f32::NEG_INFINITY..));
- assert!(!yes!(core::f32::NEG_INFINITY, 1.0f32..));
- assert!(yes!(core::f32::INFINITY, 1.0f32..));
- assert!(!yes!(1.0f32 - core::f32::EPSILON, 1.0f32..));
+ assert!(yes!(f32::NEG_INFINITY, f32::NEG_INFINITY..));
+ assert!(yes!(f32::INFINITY, f32::NEG_INFINITY..));
+ assert!(!yes!(f32::NEG_INFINITY, 1.0f32..));
+ assert!(yes!(f32::INFINITY, 1.0f32..));
+ assert!(!yes!(1.0f32 - f32::EPSILON, 1.0f32..));
assert!(yes!(1.0f32, 1.0f32..));
- assert!(yes!(core::f32::INFINITY, 1.0f32..));
- assert!(yes!(core::f32::INFINITY, core::f32::INFINITY..));
+ assert!(yes!(f32::INFINITY, 1.0f32..));
+ assert!(yes!(f32::INFINITY, f32::INFINITY..));
// f64; `X..`
- assert!(yes!(core::f64::NEG_INFINITY, core::f64::NEG_INFINITY..));
- assert!(yes!(core::f64::INFINITY, core::f64::NEG_INFINITY..));
- assert!(!yes!(core::f64::NEG_INFINITY, 1.0f64..));
- assert!(yes!(core::f64::INFINITY, 1.0f64..));
- assert!(!yes!(1.0f64 - core::f64::EPSILON, 1.0f64..));
+ assert!(yes!(f64::NEG_INFINITY, f64::NEG_INFINITY..));
+ assert!(yes!(f64::INFINITY, f64::NEG_INFINITY..));
+ assert!(!yes!(f64::NEG_INFINITY, 1.0f64..));
+ assert!(yes!(f64::INFINITY, 1.0f64..));
+ assert!(!yes!(1.0f64 - f64::EPSILON, 1.0f64..));
assert!(yes!(1.0f64, 1.0f64..));
- assert!(yes!(core::f64::INFINITY, 1.0f64..));
- assert!(yes!(core::f64::INFINITY, core::f64::INFINITY..));
+ assert!(yes!(f64::INFINITY, 1.0f64..));
+ assert!(yes!(f64::INFINITY, f64::INFINITY..));
}
fn main() {
}
fn main() {
- m!(0, ..core::u8::MIN);
+ m!(0, ..u8::MIN);
//~^ ERROR lower range bound must be less than upper
//~| ERROR lower range bound must be less than upper
- m!(0, ..core::u16::MIN);
+ m!(0, ..u16::MIN);
//~^ ERROR lower range bound must be less than upper
//~| ERROR lower range bound must be less than upper
- m!(0, ..core::u32::MIN);
+ m!(0, ..u32::MIN);
//~^ ERROR lower range bound must be less than upper
//~| ERROR lower range bound must be less than upper
- m!(0, ..core::u64::MIN);
+ m!(0, ..u64::MIN);
//~^ ERROR lower range bound must be less than upper
//~| ERROR lower range bound must be less than upper
- m!(0, ..core::u128::MIN);
+ m!(0, ..u128::MIN);
//~^ ERROR lower range bound must be less than upper
//~| ERROR lower range bound must be less than upper
- m!(0, ..core::i8::MIN);
+ m!(0, ..i8::MIN);
//~^ ERROR lower range bound must be less than upper
//~| ERROR lower range bound must be less than upper
- m!(0, ..core::i16::MIN);
+ m!(0, ..i16::MIN);
//~^ ERROR lower range bound must be less than upper
//~| ERROR lower range bound must be less than upper
- m!(0, ..core::i32::MIN);
+ m!(0, ..i32::MIN);
//~^ ERROR lower range bound must be less than upper
//~| ERROR lower range bound must be less than upper
- m!(0, ..core::i64::MIN);
+ m!(0, ..i64::MIN);
//~^ ERROR lower range bound must be less than upper
//~| ERROR lower range bound must be less than upper
- m!(0, ..core::i128::MIN);
+ m!(0, ..i128::MIN);
//~^ ERROR lower range bound must be less than upper
//~| ERROR lower range bound must be less than upper
- m!(0f32, ..core::f32::NEG_INFINITY);
+ m!(0f32, ..f32::NEG_INFINITY);
//~^ ERROR lower range bound must be less than upper
//~| ERROR lower range bound must be less than upper
- m!(0f64, ..core::f64::NEG_INFINITY);
+ m!(0f64, ..f64::NEG_INFINITY);
//~^ ERROR lower range bound must be less than upper
//~| ERROR lower range bound must be less than upper
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:12:11
|
-LL | m!(0, ..core::u8::MIN);
- | ^^^^^^^^^^^^^^^
+LL | m!(0, ..u8::MIN);
+ | ^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:15:11
|
-LL | m!(0, ..core::u16::MIN);
- | ^^^^^^^^^^^^^^^^
+LL | m!(0, ..u16::MIN);
+ | ^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:18:11
|
-LL | m!(0, ..core::u32::MIN);
- | ^^^^^^^^^^^^^^^^
+LL | m!(0, ..u32::MIN);
+ | ^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:21:11
|
-LL | m!(0, ..core::u64::MIN);
- | ^^^^^^^^^^^^^^^^
+LL | m!(0, ..u64::MIN);
+ | ^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:24:11
|
-LL | m!(0, ..core::u128::MIN);
- | ^^^^^^^^^^^^^^^^^
+LL | m!(0, ..u128::MIN);
+ | ^^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:28:11
|
-LL | m!(0, ..core::i8::MIN);
- | ^^^^^^^^^^^^^^^
+LL | m!(0, ..i8::MIN);
+ | ^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:31:11
|
-LL | m!(0, ..core::i16::MIN);
- | ^^^^^^^^^^^^^^^^
+LL | m!(0, ..i16::MIN);
+ | ^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:34:11
|
-LL | m!(0, ..core::i32::MIN);
- | ^^^^^^^^^^^^^^^^
+LL | m!(0, ..i32::MIN);
+ | ^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:37:11
|
-LL | m!(0, ..core::i64::MIN);
- | ^^^^^^^^^^^^^^^^
+LL | m!(0, ..i64::MIN);
+ | ^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:40:11
|
-LL | m!(0, ..core::i128::MIN);
- | ^^^^^^^^^^^^^^^^^
+LL | m!(0, ..i128::MIN);
+ | ^^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:44:14
|
-LL | m!(0f32, ..core::f32::NEG_INFINITY);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | m!(0f32, ..f32::NEG_INFINITY);
+ | ^^^^^^^^^^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:47:14
|
-LL | m!(0f64, ..core::f64::NEG_INFINITY);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | m!(0f64, ..f64::NEG_INFINITY);
+ | ^^^^^^^^^^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:51:13
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:12:11
|
-LL | m!(0, ..core::u8::MIN);
- | ^^^^^^^^^^^^^^^
+LL | m!(0, ..u8::MIN);
+ | ^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:15:11
|
-LL | m!(0, ..core::u16::MIN);
- | ^^^^^^^^^^^^^^^^
+LL | m!(0, ..u16::MIN);
+ | ^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:18:11
|
-LL | m!(0, ..core::u32::MIN);
- | ^^^^^^^^^^^^^^^^
+LL | m!(0, ..u32::MIN);
+ | ^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:21:11
|
-LL | m!(0, ..core::u64::MIN);
- | ^^^^^^^^^^^^^^^^
+LL | m!(0, ..u64::MIN);
+ | ^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:24:11
|
-LL | m!(0, ..core::u128::MIN);
- | ^^^^^^^^^^^^^^^^^
+LL | m!(0, ..u128::MIN);
+ | ^^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:28:11
|
-LL | m!(0, ..core::i8::MIN);
- | ^^^^^^^^^^^^^^^
+LL | m!(0, ..i8::MIN);
+ | ^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:31:11
|
-LL | m!(0, ..core::i16::MIN);
- | ^^^^^^^^^^^^^^^^
+LL | m!(0, ..i16::MIN);
+ | ^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:34:11
|
-LL | m!(0, ..core::i32::MIN);
- | ^^^^^^^^^^^^^^^^
+LL | m!(0, ..i32::MIN);
+ | ^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:37:11
|
-LL | m!(0, ..core::i64::MIN);
- | ^^^^^^^^^^^^^^^^
+LL | m!(0, ..i64::MIN);
+ | ^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:40:11
|
-LL | m!(0, ..core::i128::MIN);
- | ^^^^^^^^^^^^^^^^^
+LL | m!(0, ..i128::MIN);
+ | ^^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:44:14
|
-LL | m!(0f32, ..core::f32::NEG_INFINITY);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | m!(0f32, ..f32::NEG_INFINITY);
+ | ^^^^^^^^^^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:47:14
|
-LL | m!(0f64, ..core::f64::NEG_INFINITY);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | m!(0f64, ..f64::NEG_INFINITY);
+ | ^^^^^^^^^^^^^^^^^^^
error[E0579]: lower range bound must be less than upper
--> $DIR/half-open-range-pats-thir-lower-empty.rs:51:13
// ignore-emscripten no processes
use std::collections::hash_map::HashMap;
-use std::usize;
use std::mem::size_of;
fn main() {
#![allow(unused_imports)]
#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
+#![allow(deprecated, deprecated_in_future)]
// aux-build:i8.rs
// ignore-pretty issue #37201
// run-pass
#![allow(unused_imports)]
use std::fmt;
-use std::{i8, i16, i32, i64, isize};
-use std::{u8, u16, u32, u64, usize};
const A_I8_T
: [u32; (i8::MAX as i8 - 1i8) as usize]
// run-pass
fn main() {
match (0, 0) {
- (std::usize::MIN, std::usize::MAX) => {}
+ (usize::MIN, usize::MAX) => {}
_ => {}
}
}
Some(self.state.clone())
}
#[inline]
- fn size_hint(&self) -> (usize, Option<usize>) { (std::usize::MAX, None) }
+ fn size_hint(&self) -> (usize, Option<usize>) { (usize::MAX, None) }
}
fn main() {
#[cfg(target_pointer_width = "16")]
fn main() {
- assert!(Step::steps_between(&0u32, &::std::u32::MAX).is_none());
+ assert!(Step::steps_between(&0u32, &u32::MAX).is_none());
}
#[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
fn main() {
- assert!(Step::steps_between(&0u32, &::std::u32::MAX).is_some());
+ assert!(Step::steps_between(&0u32, &u32::MAX).is_some());
}
extern crate test;
-use std::f64::{NAN, NEG_INFINITY, INFINITY, MAX};
use std::mem::size_of;
use test::black_box;
macro_rules! compare {
($op:tt) => {
compare!(
- [NEG_INFINITY, -MAX, -1.0, -0.0, 0.0, 1.0, MAX, INFINITY, NAN],
+ [f64::NEG_INFINITY, -f64::MAX, -1.0, -0.0, 0.0, 1.0, f64::MAX, f64::INFINITY, f64::NAN],
$op
);
};
$(compare!(
$lhs,
$op,
- [NEG_INFINITY, -MAX, -1.0, -0.0, 0.0, 1.0, MAX, INFINITY, NAN]
+ [f64::NEG_INFINITY, -f64::MAX, -1.0, -0.0, 0.0, 1.0, f64::MAX, f64::INFINITY, f64::NAN]
);)+
};
($lhs:expr, $op:tt, [$($rhs:expr),+]) => {
fn main() {
assert_eq!(0.0/0.0 < 0.0/0.0, false);
assert_eq!(0.0/0.0 > 0.0/0.0, false);
- assert_eq!(NAN < NAN, false);
- assert_eq!(NAN > NAN, false);
+ assert_eq!(f64::NAN < f64::NAN, false);
+ assert_eq!(f64::NAN > f64::NAN, false);
compare!(==);
compare!(!=);
// build-pass
fn main() {
- println!("{}", [(); std::usize::MAX].len());
+ println!("{}", [(); usize::MAX].len());
}
#![allow(unused)]
#![deny(illegal_floating_point_literal_pattern)]
-use std::f64::NAN;
+const NAN: f64 = f64::NAN;
fn main() {
let x = NAN;
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:14:36
+ --> $DIR/issue-8460-const.rs:13:36
|
LL | assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to compute `isize::MIN / -1_isize`, which would overflow
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:16:36
+ --> $DIR/issue-8460-const.rs:15:36
|
LL | assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to compute `i8::MIN / -1_i8`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:18:36
+ --> $DIR/issue-8460-const.rs:17:36
|
LL | assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i16::MIN / -1_i16`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:20:36
+ --> $DIR/issue-8460-const.rs:19:36
|
LL | assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i32::MIN / -1_i32`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:22:36
+ --> $DIR/issue-8460-const.rs:21:36
|
LL | assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i64::MIN / -1_i64`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:24:36
+ --> $DIR/issue-8460-const.rs:23:36
|
LL | assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to compute `i128::MIN / -1_i128`, which would overflow
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:26:36
+ --> $DIR/issue-8460-const.rs:25:36
|
LL | assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
| ^^^^^^^^^^ attempt to divide `1_isize` by zero
= note: `#[deny(unconditional_panic)]` on by default
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:28:36
+ --> $DIR/issue-8460-const.rs:27:36
|
LL | assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
| ^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:30:36
+ --> $DIR/issue-8460-const.rs:29:36
|
LL | assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:32:36
+ --> $DIR/issue-8460-const.rs:31:36
|
LL | assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:34:36
+ --> $DIR/issue-8460-const.rs:33:36
|
LL | assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:36:36
+ --> $DIR/issue-8460-const.rs:35:36
|
LL | assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
| ^^^^^^^^^ attempt to divide `1_i128` by zero
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:38:36
+ --> $DIR/issue-8460-const.rs:37:36
|
LL | assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to compute the remainder of `isize::MIN % -1_isize`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:40:36
+ --> $DIR/issue-8460-const.rs:39:36
|
LL | assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to compute the remainder of `i8::MIN % -1_i8`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:42:36
+ --> $DIR/issue-8460-const.rs:41:36
|
LL | assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute the remainder of `i16::MIN % -1_i16`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:44:36
+ --> $DIR/issue-8460-const.rs:43:36
|
LL | assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute the remainder of `i32::MIN % -1_i32`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:46:36
+ --> $DIR/issue-8460-const.rs:45:36
|
LL | assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute the remainder of `i64::MIN % -1_i64`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:48:36
+ --> $DIR/issue-8460-const.rs:47:36
|
LL | assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to compute the remainder of `i128::MIN % -1_i128`, which would overflow
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:50:36
+ --> $DIR/issue-8460-const.rs:49:36
|
LL | assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
| ^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:52:36
+ --> $DIR/issue-8460-const.rs:51:36
|
LL | assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
| ^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:54:36
+ --> $DIR/issue-8460-const.rs:53:36
|
LL | assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:56:36
+ --> $DIR/issue-8460-const.rs:55:36
|
LL | assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:58:36
+ --> $DIR/issue-8460-const.rs:57:36
|
LL | assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:60:36
+ --> $DIR/issue-8460-const.rs:59:36
|
LL | assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
| ^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:14:36
+ --> $DIR/issue-8460-const.rs:13:36
|
LL | assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to compute `isize::MIN / -1_isize`, which would overflow
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:16:36
+ --> $DIR/issue-8460-const.rs:15:36
|
LL | assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to compute `i8::MIN / -1_i8`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:18:36
+ --> $DIR/issue-8460-const.rs:17:36
|
LL | assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i16::MIN / -1_i16`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:20:36
+ --> $DIR/issue-8460-const.rs:19:36
|
LL | assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i32::MIN / -1_i32`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:22:36
+ --> $DIR/issue-8460-const.rs:21:36
|
LL | assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i64::MIN / -1_i64`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:24:36
+ --> $DIR/issue-8460-const.rs:23:36
|
LL | assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to compute `i128::MIN / -1_i128`, which would overflow
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:26:36
+ --> $DIR/issue-8460-const.rs:25:36
|
LL | assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
| ^^^^^^^^^^ attempt to divide `1_isize` by zero
= note: `#[deny(unconditional_panic)]` on by default
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:28:36
+ --> $DIR/issue-8460-const.rs:27:36
|
LL | assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
| ^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:30:36
+ --> $DIR/issue-8460-const.rs:29:36
|
LL | assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:32:36
+ --> $DIR/issue-8460-const.rs:31:36
|
LL | assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:34:36
+ --> $DIR/issue-8460-const.rs:33:36
|
LL | assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:36:36
+ --> $DIR/issue-8460-const.rs:35:36
|
LL | assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
| ^^^^^^^^^ attempt to divide `1_i128` by zero
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:38:36
+ --> $DIR/issue-8460-const.rs:37:36
|
LL | assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to compute the remainder of `isize::MIN % -1_isize`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:40:36
+ --> $DIR/issue-8460-const.rs:39:36
|
LL | assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to compute the remainder of `i8::MIN % -1_i8`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:42:36
+ --> $DIR/issue-8460-const.rs:41:36
|
LL | assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute the remainder of `i16::MIN % -1_i16`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:44:36
+ --> $DIR/issue-8460-const.rs:43:36
|
LL | assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute the remainder of `i32::MIN % -1_i32`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:46:36
+ --> $DIR/issue-8460-const.rs:45:36
|
LL | assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute the remainder of `i64::MIN % -1_i64`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:48:36
+ --> $DIR/issue-8460-const.rs:47:36
|
LL | assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to compute the remainder of `i128::MIN % -1_i128`, which would overflow
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:50:36
+ --> $DIR/issue-8460-const.rs:49:36
|
LL | assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
| ^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:52:36
+ --> $DIR/issue-8460-const.rs:51:36
|
LL | assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
| ^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:54:36
+ --> $DIR/issue-8460-const.rs:53:36
|
LL | assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:56:36
+ --> $DIR/issue-8460-const.rs:55:36
|
LL | assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:58:36
+ --> $DIR/issue-8460-const.rs:57:36
|
LL | assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:60:36
+ --> $DIR/issue-8460-const.rs:59:36
|
LL | assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
| ^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:14:36
+ --> $DIR/issue-8460-const.rs:13:36
|
LL | assert!(thread::spawn(move|| { isize::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to compute `isize::MIN / -1_isize`, which would overflow
= note: `#[deny(arithmetic_overflow)]` on by default
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:16:36
+ --> $DIR/issue-8460-const.rs:15:36
|
LL | assert!(thread::spawn(move|| { i8::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to compute `i8::MIN / -1_i8`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:18:36
+ --> $DIR/issue-8460-const.rs:17:36
|
LL | assert!(thread::spawn(move|| { i16::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i16::MIN / -1_i16`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:20:36
+ --> $DIR/issue-8460-const.rs:19:36
|
LL | assert!(thread::spawn(move|| { i32::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i32::MIN / -1_i32`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:22:36
+ --> $DIR/issue-8460-const.rs:21:36
|
LL | assert!(thread::spawn(move|| { i64::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute `i64::MIN / -1_i64`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:24:36
+ --> $DIR/issue-8460-const.rs:23:36
|
LL | assert!(thread::spawn(move|| { i128::MIN / -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to compute `i128::MIN / -1_i128`, which would overflow
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:26:36
+ --> $DIR/issue-8460-const.rs:25:36
|
LL | assert!(thread::spawn(move|| { 1isize / 0; }).join().is_err());
| ^^^^^^^^^^ attempt to divide `1_isize` by zero
= note: `#[deny(unconditional_panic)]` on by default
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:28:36
+ --> $DIR/issue-8460-const.rs:27:36
|
LL | assert!(thread::spawn(move|| { 1i8 / 0; }).join().is_err());
| ^^^^^^^ attempt to divide `1_i8` by zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:30:36
+ --> $DIR/issue-8460-const.rs:29:36
|
LL | assert!(thread::spawn(move|| { 1i16 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i16` by zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:32:36
+ --> $DIR/issue-8460-const.rs:31:36
|
LL | assert!(thread::spawn(move|| { 1i32 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i32` by zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:34:36
+ --> $DIR/issue-8460-const.rs:33:36
|
LL | assert!(thread::spawn(move|| { 1i64 / 0; }).join().is_err());
| ^^^^^^^^ attempt to divide `1_i64` by zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:36:36
+ --> $DIR/issue-8460-const.rs:35:36
|
LL | assert!(thread::spawn(move|| { 1i128 / 0; }).join().is_err());
| ^^^^^^^^^ attempt to divide `1_i128` by zero
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:38:36
+ --> $DIR/issue-8460-const.rs:37:36
|
LL | assert!(thread::spawn(move|| { isize::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^^ attempt to compute the remainder of `isize::MIN % -1_isize`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:40:36
+ --> $DIR/issue-8460-const.rs:39:36
|
LL | assert!(thread::spawn(move|| { i8::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^ attempt to compute the remainder of `i8::MIN % -1_i8`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:42:36
+ --> $DIR/issue-8460-const.rs:41:36
|
LL | assert!(thread::spawn(move|| { i16::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute the remainder of `i16::MIN % -1_i16`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:44:36
+ --> $DIR/issue-8460-const.rs:43:36
|
LL | assert!(thread::spawn(move|| { i32::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute the remainder of `i32::MIN % -1_i32`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:46:36
+ --> $DIR/issue-8460-const.rs:45:36
|
LL | assert!(thread::spawn(move|| { i64::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^ attempt to compute the remainder of `i64::MIN % -1_i64`, which would overflow
error: this arithmetic operation will overflow
- --> $DIR/issue-8460-const.rs:48:36
+ --> $DIR/issue-8460-const.rs:47:36
|
LL | assert!(thread::spawn(move|| { i128::MIN % -1; }).join().is_err());
| ^^^^^^^^^^^^^^ attempt to compute the remainder of `i128::MIN % -1_i128`, which would overflow
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:50:36
+ --> $DIR/issue-8460-const.rs:49:36
|
LL | assert!(thread::spawn(move|| { 1isize % 0; }).join().is_err());
| ^^^^^^^^^^ attempt to calculate the remainder of `1_isize` with a divisor of zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:52:36
+ --> $DIR/issue-8460-const.rs:51:36
|
LL | assert!(thread::spawn(move|| { 1i8 % 0; }).join().is_err());
| ^^^^^^^ attempt to calculate the remainder of `1_i8` with a divisor of zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:54:36
+ --> $DIR/issue-8460-const.rs:53:36
|
LL | assert!(thread::spawn(move|| { 1i16 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i16` with a divisor of zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:56:36
+ --> $DIR/issue-8460-const.rs:55:36
|
LL | assert!(thread::spawn(move|| { 1i32 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i32` with a divisor of zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:58:36
+ --> $DIR/issue-8460-const.rs:57:36
|
LL | assert!(thread::spawn(move|| { 1i64 % 0; }).join().is_err());
| ^^^^^^^^ attempt to calculate the remainder of `1_i64` with a divisor of zero
error: this operation will panic at runtime
- --> $DIR/issue-8460-const.rs:60:36
+ --> $DIR/issue-8460-const.rs:59:36
|
LL | assert!(thread::spawn(move|| { 1i128 % 0; }).join().is_err());
| ^^^^^^^^^ attempt to calculate the remainder of `1_i128` with a divisor of zero
#![deny(const_err)]
-use std::{isize, i8, i16, i32, i64, i128};
use std::thread;
fn main() {
// compile-flags: -C debug_assertions=yes -C opt-level=3
use std::panic;
-use std::usize::MAX;
fn main() {
- assert_eq!((0..MAX).by_ref().count(), MAX);
+ assert_eq!((0..usize::MAX).by_ref().count(), usize::MAX);
let r = panic::catch_unwind(|| {
- (0..=MAX).by_ref().count()
+ (0..=usize::MAX).by_ref().count()
});
assert!(r.is_err());
}
// only-32bit too impatient for 2⁶⁴ items
// compile-flags: -C debug_assertions=no -C opt-level=3
-use std::usize::MAX;
-
fn main() {
- assert_eq!((0..MAX).by_ref().count(), MAX);
- assert_eq!((0..=MAX).by_ref().count(), 0);
+ assert_eq!((0..usize::MAX).by_ref().count(), usize::MAX);
+ assert_eq!((0..=usize::MAX).by_ref().count(), 0);
}
// compile-flags: -C debug_assertions=yes -C opt-level=3
use std::panic;
-use std::usize::MAX;
fn main() {
- let n = MAX as u64;
- assert_eq!((0..).by_ref().position(|i| i >= n), Some(MAX));
+ let n = usize::MAX as u64;
+ assert_eq!((0..).by_ref().position(|i| i >= n), Some(usize::MAX));
let r = panic::catch_unwind(|| {
(0..).by_ref().position(|i| i > n)
// only-32bit too impatient for 2⁶⁴ items
// compile-flags: -C debug_assertions=no -C opt-level=3
-use std::usize::MAX;
-
fn main() {
- let n = MAX as u64;
- assert_eq!((0..).by_ref().position(|i| i >= n), Some(MAX));
+ let n = usize::MAX as u64;
+ assert_eq!((0..).by_ref().position(|i| i >= n), Some(usize::MAX));
assert_eq!((0..).by_ref().position(|i| i > n), Some(0));
assert_eq!((0..=n + 1).by_ref().position(|_| false), None);
}
test_path!();
test_path!(,);
test_path!(::std);
-test_path!(std::u8,);
+test_path!(std::ops,);
test_path!(any, super, super::super::self::path, X<Y>::Z<'a, T=U>);
macro_rules! test_lifetime {
#![feature(box_syntax, unboxed_closures)]
-use std::usize;
-
fn to_fn<A,F:Fn<A>>(f: F) -> F { f }
fn test(_x: Box<usize>) {}
error[E0507]: cannot move out of `i`, a captured variable in an `Fn` closure
- --> $DIR/moves-based-on-type-move-out-of-closure-env-issue-1965.rs:11:28
+ --> $DIR/moves-based-on-type-move-out-of-closure-env-issue-1965.rs:9:28
|
LL | let i = box 3;
| - captured outer variable
#![deny(const_err)]
-use std::{f32, f64};
-
// Forces evaluation of constants, triggering hard error
fn force<T>(_: T) {}
// run-pass
-use std::f64;
pub fn main() {
let nan: f64 = f64::NAN;
($(($name:ident, $size:expr),)*) => ($(
mod $name {
pub const BITS: usize = $size;
- pub use std::$name::*;
+ pub const MAX: $name = $name::MAX;
+ pub const MIN: $name = $name::MIN;
}
)*)
}
#![allow(arithmetic_overflow)]
fn main() {
- let _x = -std::i8::MIN;
+ let _x = -i8::MIN;
}
extern crate test;
use self::test::black_box;
-use std::{f32, f64};
-#[cfg(not(target_os = "emscripten"))]
-use std::{i128, u128};
-use std::{i16, i32, i64, i8, u16, u32, u64, u8};
macro_rules! test {
($val:expr, $src_ty:ident -> $dest_ty:ident, $expected:expr) => (
let x = 1_u8 << id(0);
assert_eq!(x, 1);
let x = 1_i8 << id(7);
- assert_eq!(x, std::i8::MIN);
+ assert_eq!(x, i8::MIN);
let x = 1_u8 << id(7);
assert_eq!(x, 0x80);
// high-order bits on LHS are silently discarded without panic.
let x = 3_i8 << id(7);
- assert_eq!(x, std::i8::MIN);
+ assert_eq!(x, i8::MIN);
let x = 3_u8 << id(7);
assert_eq!(x, 0x80);
// above is (approximately) expanded from:
- tests!(i8, u8, 7, std::i8::MIN, 0x80_u8);
+ tests!(i8, u8, 7, i8::MIN, 0x80_u8);
- tests!(i16, u16, 15, std::i16::MIN, 0x8000_u16);
- tests!(i32, u32, 31, std::i32::MIN, 0x8000_0000_u32);
- tests!(i64, u64, 63, std::i64::MIN, 0x8000_0000_0000_0000_u64);
+ tests!(i16, u16, 15, i16::MIN, 0x8000_u16);
+ tests!(i32, u32, 31, i32::MIN, 0x8000_0000_u32);
+ tests!(i64, u64, 63, i64::MIN, 0x8000_0000_0000_0000_u64);
}
fn test_right_shift() {
} }
}
- tests!(i8, u8, 7, std::i8::MIN, 0x40_i8, 0x80_u8);
- tests!(i16, u16, 15, std::i16::MIN, 0x4000_u16, 0x8000_u16);
- tests!(i32, u32, 31, std::i32::MIN, 0x4000_0000_u32, 0x8000_0000_u32);
- tests!(i64, u64, 63, std::i64::MIN,
+ tests!(i8, u8, 7, i8::MIN, 0x40_i8, 0x80_u8);
+ tests!(i16, u16, 15, i16::MIN, 0x4000_u16, 0x8000_u16);
+ tests!(i32, u32, 31, i32::MIN, 0x4000_0000_u32, 0x8000_0000_u32);
+ tests!(i64, u64, 63, i64::MIN,
0x4000_0000_0000_0000_u64, 0x8000_0000_0000_0000_u64);
}
#![deny(overflowing_literals)]
extern crate test;
-use std::f32;
-use std::u128;
use test::black_box;
macro_rules! test {
error: lifetime may not live long enough
- --> $DIR/regions-addr-of-upvar-self.rs:10:20
+ --> $DIR/regions-addr-of-upvar-self.rs:8:20
|
LL | let _f = || {
| -- lifetime `'1` represents this closure's body
= note: closure implements `FnMut`, so references to captured variables can't escape the closure
error: lifetime may not live long enough
- --> $DIR/regions-addr-of-upvar-self.rs:10:20
+ --> $DIR/regions-addr-of-upvar-self.rs:8:20
|
LL | pub fn chase_cat(&mut self) {
| - let's call the lifetime of this reference `'1`
| ^^^^^^^^^^^^^^^^^^ type annotation requires that `'1` must outlive `'static`
error[E0597]: `self` does not live long enough
- --> $DIR/regions-addr-of-upvar-self.rs:10:46
+ --> $DIR/regions-addr-of-upvar-self.rs:8:46
|
LL | let _f = || {
| -- value captured here
-use std::usize;
-
struct Dog {
food: usize,
}
error[E0495]: cannot infer an appropriate lifetime for borrow expression due to conflicting requirements
- --> $DIR/regions-addr-of-upvar-self.rs:10:41
+ --> $DIR/regions-addr-of-upvar-self.rs:8:41
|
LL | let p: &'static mut usize = &mut self.food;
| ^^^^^^^^^^^^^^
|
-note: first, the lifetime cannot outlive the lifetime `'_` as defined on the body at 9:18...
- --> $DIR/regions-addr-of-upvar-self.rs:9:18
+note: first, the lifetime cannot outlive the lifetime `'_` as defined on the body at 7:18...
+ --> $DIR/regions-addr-of-upvar-self.rs:7:18
|
LL | let _f = || {
| ^^
note: ...so that closure can access `self`
- --> $DIR/regions-addr-of-upvar-self.rs:10:41
+ --> $DIR/regions-addr-of-upvar-self.rs:8:41
|
LL | let p: &'static mut usize = &mut self.food;
| ^^^^^^^^^^^^^^
= note: but, the lifetime must be valid for the static lifetime...
note: ...so that reference does not outlive borrowed content
- --> $DIR/regions-addr-of-upvar-self.rs:10:41
+ --> $DIR/regions-addr-of-upvar-self.rs:8:41
|
LL | let p: &'static mut usize = &mut self.food;
| ^^^^^^^^^^^^^^
-use std::f32;
-
#[derive(PartialEq)]
struct Foo {
x: u32
error: to use a constant of type `Foo` in a pattern, `Foo` must be annotated with `#[derive(PartialEq, Eq)]`
- --> $DIR/match-forbidden-without-eq.rs:13:9
+ --> $DIR/match-forbidden-without-eq.rs:11:9
|
LL | FOO => { }
| ^^^
warning: floating-point types cannot be used in patterns
- --> $DIR/match-forbidden-without-eq.rs:20:9
+ --> $DIR/match-forbidden-without-eq.rs:18:9
|
LL | f32::INFINITY => { }
| ^^^^^^^^^^^^^
= note: for more information, see issue #41620 <https://github.com/rust-lang/rust/issues/41620>
warning: floating-point types cannot be used in patterns
- --> $DIR/match-forbidden-without-eq.rs:20:9
+ --> $DIR/match-forbidden-without-eq.rs:18:9
|
LL | f32::INFINITY => { }
| ^^^^^^^^^^^^^
let y = f32x4(2.0, 1.0, 4.0, 3.0);
#[cfg(not(any(target_arch = "mips", target_arch = "mips64")))]
- let nan = ::std::f32::NAN;
+ let nan = f32::NAN;
// MIPS hardware treats f32::NAN as SNAN. Clear the signaling bit.
// See https://github.com/rust-lang/rust/issues/52746.
#[cfg(any(target_arch = "mips", target_arch = "mips64"))]
- let nan = f32::from_bits(::std::f32::NAN.to_bits() - 1);
+ let nan = f32::from_bits(f32::NAN.to_bits() - 1);
let n = f32x4(nan, nan, nan, nan);
#![feature(repr_simd, platform_intrinsics, concat_idents)]
#![allow(non_camel_case_types)]
-use std::f32::NAN;
-
#[repr(simd)]
#[derive(Copy, Clone)]
struct i32x4(i32, i32, i32, i32);
// NAN comparisons are special:
// -11 (*) 13
// -5 -100 (*)
- let f4 = f32x4(NAN, f1.1, NAN, f2.3);
+ let f4 = f32x4(f32::NAN, f1.1, f32::NAN, f2.3);
unsafe {
tests! {
use std::thread::{self, sleep};
use std::time::Duration;
use std::sync::{Arc, Mutex};
-use std::u64;
fn main() {
let finished = Arc::new(Mutex::new(false));
// See also compile-fail/overflow-discrim.rs, which shows what
// happens if you leave the OhNo explicit cases out here.
-use std::{i8,u8,i16,u16,i32,u32,i64,u64,isize,usize};
-
fn f_i8() {
#[repr(i8)]
enum A {
// `i8`
pub struct I8<const F: i8>;
- impl I8<{std::i8::MIN}> {
+ impl I8<{i8::MIN}> {
pub fn foo() {}
}
- impl I8<{std::i8::MAX}> {
+ impl I8<{i8::MAX}> {
pub fn foo() {}
}
// `i16`
pub struct I16<const F: i16>;
- impl I16<{std::i16::MIN}> {
+ impl I16<{i16::MIN}> {
pub fn foo() {}
}
// `i32`
pub struct I32<const F: i32>;
- impl I32<{std::i32::MIN}> {
+ impl I32<{i32::MIN}> {
pub fn foo() {}
}
// `i64`
pub struct I64<const F: i64>;
- impl I64<{std::i64::MIN}> {
+ impl I64<{i64::MIN}> {
pub fn foo() {}
}
// `i128`
pub struct I128<const F: i128>;
- impl I128<{std::i128::MIN}> {
+ impl I128<{i128::MIN}> {
pub fn foo() {}
}
// run-pass
-extern crate core;
-use core::f32;
-
union U {
a: (u8, u8),
b: u16,
// Make sure the module level constants are still there and accessible even after
// the corresponding associated constants have been added, and later stabilized.
+#![allow(deprecated, deprecated_in_future)]
use std::{u16, f32};
fn main() {
// Don't warn about overflowing ops on 32-bit platforms
#![cfg_attr(target_pointer_width = "32", allow(const_err))]
-use std::{i8, i16, i32, i64, isize};
-use std::{u8, u16, u32, u64, usize};
-
fn main() {
assert_eq!( i8::MAX.wrapping_add(1), i8::MIN);
assert_eq!( i16::MAX.wrapping_add(1), i16::MIN);
v != 1.0;
const ZERO_ARRAY: [f32; 3] = [0.0, 0.0, 0.0];
- const ZERO_INF_ARRAY: [f32; 3] = [0.0, ::std::f32::INFINITY, ::std::f32::NEG_INFINITY];
+ const ZERO_INF_ARRAY: [f32; 3] = [0.0, f32::INFINITY, f32::NEG_INFINITY];
const NON_ZERO_ARRAY: [f32; 3] = [0.0, 0.1, 0.2];
const NON_ZERO_ARRAY2: [f32; 3] = [0.2, 0.1, 0.0];
projects / rust.git / commitdiff