mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

fix library and rustdoc tests

Browse source
This commit is contained in:
Deadbeef 2023-04-16 11:12:37 +00:00
parent 147e850691
commit 4c6ddc036b
108 changed files with 841 additions and 444 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
library/alloc/tests/const_fns.rs
View file

@ -1,13 +1,16 @@
// Test const functions in the library
pub const MY_VEC: Vec<usize> = Vec::new();
pub const MY_VEC2: Vec<usize> = Default::default();
// FIXME(#110395)
// pub const MY_VEC2: Vec<usize> = Default::default();
pub const MY_STRING: String = String::new();
pub const MY_STRING2: String = Default::default();
pub const MY_BOXED_SLICE: Box<[usize]> = Default::default();
pub const MY_BOXED_STR: Box<str> = Default::default();
// pub const MY_STRING2: String = Default::default();
// pub const MY_BOXED_SLICE: Box<[usize]> = Default::default();
// pub const MY_BOXED_STR: Box<str> = Default::default();
use std::collections::{BTreeMap, BTreeSet};
@ -23,11 +26,11 @@ pub const SET_IS_EMPTY: bool = SET.is_empty();
#[test]
fn test_const() {
assert_eq!(MY_VEC, MY_VEC2);
assert_eq!(MY_STRING, MY_STRING2);
assert_eq!(MY_VEC, /* MY_VEC */ vec![]);
assert_eq!(MY_STRING, /* MY_STRING2 */ String::default());
assert_eq!(MY_VEC, *MY_BOXED_SLICE);
assert_eq!(MY_STRING, *MY_BOXED_STR);
// assert_eq!(MY_VEC, *MY_BOXED_SLICE);
// assert_eq!(MY_STRING, *MY_BOXED_STR);
assert_eq!(MAP_LEN, 0);
assert_eq!(SET_LEN, 0);

2
library/alloc/tests/lib.rs
View file

@ -3,7 +3,6 @@
#![feature(assert_matches)]
#![feature(btree_drain_filter)]
#![feature(cow_is_borrowed)]
#![feature(const_convert)]
#![feature(const_cow_is_borrowed)]
#![feature(const_heap)]
#![feature(const_mut_refs)]
@ -33,7 +32,6 @@
#![feature(slice_partition_dedup)]
#![feature(string_remove_matches)]
#![feature(const_btree_len)]
#![feature(const_default_impls)]
#![feature(const_trait_impl)]
#![feature(const_str_from_utf8)]
#![feature(panic_update_hook)]

2
library/core/tests/atomic.rs
View file

@ -306,9 +306,11 @@ fn atomic_compare_exchange() {
ATOMIC.compare_exchange_weak(0, 1, SeqCst, SeqCst).ok();
}
/* FIXME(#110395)
#[test]
fn atomic_const_from() {
const _ATOMIC_U8: AtomicU8 = AtomicU8::from(1);
const _ATOMIC_BOOL: AtomicBool = AtomicBool::from(true);
const _ATOMIC_PTR: AtomicPtr<u32> = AtomicPtr::from(core::ptr::null_mut());
}
*/

2
library/core/tests/bool.rs
View file

@ -89,6 +89,7 @@ fn test_bool_to_option() {
assert_eq!(false.then(|| 0), None);
assert_eq!(true.then(|| 0), Some(0));
/* FIXME(#110395)
const fn zero() -> i32 {
0
}
@ -102,4 +103,5 @@ fn test_bool_to_option() {
assert_eq!(B, Some(0));
assert_eq!(C, None);
assert_eq!(D, Some(0));
*/
}

2
library/core/tests/cell.rs
View file

@ -468,6 +468,7 @@ fn const_cells() {
const CELL: Cell<i32> = Cell::new(3);
const _: i32 = CELL.into_inner();
/* FIXME(#110395)
const UNSAFE_CELL_FROM: UnsafeCell<i32> = UnsafeCell::from(3);
const _: i32 = UNSAFE_CELL.into_inner();
@ -476,4 +477,5 @@ fn const_cells() {
const CELL_FROM: Cell<i32> = Cell::from(3);
const _: i32 = CELL.into_inner();
*/
}

2
library/core/tests/char.rs
View file

@ -21,6 +21,7 @@ fn test_convert() {
assert!(char::try_from(0xFFFF_FFFF_u32).is_err());
}
/* FIXME(#110395)
#[test]
const fn test_convert_const() {
assert!(u32::from('a') == 0x61);
@ -30,6 +31,7 @@ const fn test_convert_const() {
assert!(char::from(b'a') == 'a');
assert!(char::from(b'\xFF') == '\u{FF}');
}
*/
#[test]
fn test_from_str() {

2
library/core/tests/cmp.rs
View file

@ -217,6 +217,7 @@ fn cmp_default() {
assert_eq!(Fool(false), Fool(true));
}
/* FIXME(#110395)
mod const_cmp {
use super::*;
@ -248,3 +249,4 @@ mod const_cmp {
const _: () = assert!(S(0) < S(1));
const _: () = assert!(S(1) > S(0));
}
*/

2
library/core/tests/convert.rs
View file

@ -1,3 +1,4 @@
/* FIXME(#110395)
#[test]
fn convert() {
const fn from(x: i32) -> i32 {
@ -14,3 +15,4 @@ fn convert() {
const BAR: Vec<String> = into(Vec::new());
assert_eq!(BAR, Vec::<String>::new());
}
*/

12
library/core/tests/hash/mod.rs
View file

@ -35,13 +35,14 @@ impl Hasher for MyHasher {
#[test]
fn test_writer_hasher() {
const fn hash<T: Hash>(t: &T) -> u64 {
// FIXME(#110395)
/* const */ fn hash<T: Hash>(t: &T) -> u64 {
let mut s = MyHasher { hash: 0 };
t.hash(&mut s);
s.finish()
}
const {
/* const {
// FIXME(fee1-dead): assert_eq
assert!(hash(&()) == 0);
assert!(hash(&5_u8) == 5);
@ -52,7 +53,7 @@ fn test_writer_hasher() {
let s: &str = "a";
assert!(hash(&s) == 97 + 0xFF);
};
}; */
assert_eq!(hash(&()), 0);
@ -139,7 +140,8 @@ impl Hash for Custom {
#[test]
fn test_custom_state() {
const fn hash<T: Hash>(t: &T) -> u64 {
// FIXME(#110395)
/* const */ fn hash<T: Hash>(t: &T) -> u64 {
let mut c = CustomHasher { output: 0 };
t.hash(&mut c);
c.finish()
@ -147,7 +149,7 @@ fn test_custom_state() {
assert_eq!(hash(&Custom { hash: 5 }), 5);
const { assert!(hash(&Custom { hash: 6 }) == 6) };
// const { assert!(hash(&Custom { hash: 6 }) == 6) };
}
// FIXME: Instantiated functions with i128 in the signature is not supported in Emscripten.

2
library/core/tests/hash/sip.rs
View file

@ -23,6 +23,7 @@ fn hash<T: Hash>(x: &T) -> u64 {
hash_with(SipHasher::new(), x)
}
/* FIXME(#110395)
#[test]
const fn test_const_sip() {
let val1 = 0x45;
@ -36,6 +37,7 @@ const fn test_const_sip() {
assert!(const_hash(&(val1)) != const_hash(&(val2)));
}
*/
#[test]
#[allow(unused_must_use)]

2
library/core/tests/lazy.rs
View file

@ -46,11 +46,13 @@ fn unsync_once_cell_drop_empty() {
drop(x);
}
/* FIXME(#110395)
#[test]
const fn once_cell_const() {
let _once_cell: OnceCell<u32> = OnceCell::new();
let _once_cell: OnceCell<u32> = OnceCell::from(32);
}
*/
#[test]
fn clone() {

3
library/core/tests/lib.rs
View file

@ -8,16 +8,13 @@
#![feature(const_assume)]
#![feature(const_align_of_val_raw)]
#![feature(const_black_box)]
#![feature(const_bool_to_option)]
#![feature(const_caller_location)]
#![feature(const_cell_into_inner)]
#![feature(const_convert)]
#![feature(const_hash)]
#![feature(const_heap)]
#![feature(const_maybe_uninit_as_mut_ptr)]
#![feature(const_maybe_uninit_assume_init_read)]
#![feature(const_nonnull_new)]
#![feature(const_num_from_num)]
#![feature(const_pointer_byte_offsets)]
#![feature(const_pointer_is_aligned)]
#![feature(const_ptr_as_ref)]

2
library/core/tests/nonzero.rs
View file

@ -215,11 +215,13 @@ fn nonzero_const() {
const ONE: Option<NonZeroU8> = NonZeroU8::new(1);
assert!(ONE.is_some());
/* FIXME(#110395)
const FROM_NONZERO_U8: u8 = u8::from(NONZERO_U8);
assert_eq!(FROM_NONZERO_U8, 5);
const NONZERO_CONVERT: NonZeroU32 = NonZeroU32::from(NONZERO_U8);
assert_eq!(NONZERO_CONVERT.get(), 5);
*/
}
#[test]

2
library/core/tests/num/const_from.rs
View file

@ -1,3 +1,4 @@
/* FIXME(#110395)
#[test]
fn from() {
use core::convert::TryFrom;
@ -23,3 +24,4 @@ fn from() {
const I16_FROM_U16: Result<i16, TryFromIntError> = i16::try_from(1u16);
assert_eq!(I16_FROM_U16, Ok(1i16));
}
*/

24
library/core/tests/option.rs
View file

@ -88,6 +88,7 @@ fn test_and() {
assert_eq!(x.and(Some(2)), None);
assert_eq!(x.and(None::<isize>), None);
/* FIXME(#110395)
const FOO: Option<isize> = Some(1);
const A: Option<isize> = FOO.and(Some(2));
const B: Option<isize> = FOO.and(None);
@ -99,6 +100,7 @@ fn test_and() {
const D: Option<isize> = BAR.and(None);
assert_eq!(C, None);
assert_eq!(D, None);
*/
}
#[test]
@ -119,6 +121,7 @@ fn test_and_then() {
assert_eq!(x.and_then(plus_one), None);
assert_eq!(x.and_then(none), None);
/* FIXME(#110395)
const FOO: Option<isize> = Some(1);
const A: Option<isize> = FOO.and_then(plus_one);
const B: Option<isize> = FOO.and_then(none);
@ -130,6 +133,7 @@ fn test_and_then() {
const D: Option<isize> = BAR.and_then(none);
assert_eq!(C, None);
assert_eq!(D, None);
*/
}
#[test]
@ -142,6 +146,7 @@ fn test_or() {
assert_eq!(x.or(Some(2)), Some(2));
assert_eq!(x.or(None), None);
/* FIXME(#110395)
const FOO: Option<isize> = Some(1);
const A: Option<isize> = FOO.or(Some(2));
const B: Option<isize> = FOO.or(None);
@ -153,6 +158,7 @@ fn test_or() {
const D: Option<isize> = BAR.or(None);
assert_eq!(C, Some(2));
assert_eq!(D, None);
*/
}
#[test]
@ -173,6 +179,7 @@ fn test_or_else() {
assert_eq!(x.or_else(two), Some(2));
assert_eq!(x.or_else(none), None);
/* FIXME(#110395)
const FOO: Option<isize> = Some(1);
const A: Option<isize> = FOO.or_else(two);
const B: Option<isize> = FOO.or_else(none);
@ -184,6 +191,7 @@ fn test_or_else() {
const D: Option<isize> = BAR.or_else(none);
assert_eq!(C, Some(2));
assert_eq!(D, None);
*/
}
#[test]
@ -215,10 +223,12 @@ fn test_unwrap_or() {
let x: Option<isize> = None;
assert_eq!(x.unwrap_or(2), 2);
/* FIXME(#110395)
const A: isize = Some(1).unwrap_or(2);
const B: isize = None.unwrap_or(2);
assert_eq!(A, 1);
assert_eq!(B, 2);
*/
}
#[test]
@ -233,10 +243,12 @@ fn test_unwrap_or_else() {
let x: Option<isize> = None;
assert_eq!(x.unwrap_or_else(two), 2);
/* FIXME(#110395)
const A: isize = Some(1).unwrap_or_else(two);
const B: isize = None.unwrap_or_else(two);
assert_eq!(A, 1);
assert_eq!(B, 2);
*/
}
#[test]
@ -439,14 +451,15 @@ fn option_const() {
const OPTION: Option<usize> = Some(32);
assert_eq!(OPTION, Some(32));
const OPTION_FROM: Option<usize> = Option::from(32);
assert_eq!(OPTION_FROM, Some(32));
// FIXME(#110395)
// const OPTION_FROM: Option<usize> = Option::from(32);
// assert_eq!(OPTION_FROM, Some(32));
const REF: Option<&usize> = OPTION.as_ref();
assert_eq!(REF, Some(&32));
const REF_FROM: Option<&usize> = Option::from(&OPTION);
assert_eq!(REF_FROM, Some(&32));
// const REF_FROM: Option<&usize> = Option::from(&OPTION);
// assert_eq!(REF_FROM, Some(&32));
const IS_SOME: bool = OPTION.is_some();
assert!(IS_SOME);
@ -474,7 +487,7 @@ const fn option_const_mut() {
None => unreachable!(),
}
}
/* FIXME(const-hack)
{
let as_mut: Option<&mut usize> = Option::from(&mut option);
match as_mut {
@ -482,6 +495,7 @@ const fn option_const_mut() {
None => unreachable!(),
}
}
*/
}
#[test]

12
library/core/tests/time.rs
View file

@ -425,14 +425,16 @@ fn duration_const() {
const SECONDS_F32: f32 = Duration::SECOND.as_secs_f32();
assert_eq!(SECONDS_F32, 1.0);
const FROM_SECONDS_F32: Duration = Duration::from_secs_f32(1.0);
assert_eq!(FROM_SECONDS_F32, Duration::SECOND);
// FIXME(#110395)
// const FROM_SECONDS_F32: Duration = Duration::from_secs_f32(1.0);
// assert_eq!(FROM_SECONDS_F32, Duration::SECOND);
const SECONDS_F64: f64 = Duration::SECOND.as_secs_f64();
assert_eq!(SECONDS_F64, 1.0);
const FROM_SECONDS_F64: Duration = Duration::from_secs_f64(1.0);
assert_eq!(FROM_SECONDS_F64, Duration::SECOND);
// FIXME(#110395)
// const FROM_SECONDS_F64: Duration = Duration::from_secs_f64(1.0);
// assert_eq!(FROM_SECONDS_F64, Duration::SECOND);
const MILLIS: u128 = Duration::SECOND.as_millis();
assert_eq!(MILLIS, 1_000);
@ -463,6 +465,7 @@ fn duration_const() {
const CHECKED_MUL: Option<Duration> = Duration::SECOND.checked_mul(1);
assert_eq!(CHECKED_MUL, Some(Duration::SECOND));
/* FIXME(#110395)
const MUL_F32: Duration = Duration::SECOND.mul_f32(1.0);
assert_eq!(MUL_F32, Duration::SECOND);
@ -477,6 +480,7 @@ fn duration_const() {
const DIV_F64: Duration = Duration::SECOND.div_f64(1.0);
assert_eq!(DIV_F64, Duration::SECOND);
*/
const DIV_DURATION_F32: f32 = Duration::SECOND.div_duration_f32(Duration::SECOND);
assert_eq!(DIV_DURATION_F32, 1.0);

8
tests/rustdoc/hide-complex-unevaluated-const-arguments.rs
View file

@ -29,7 +29,7 @@ pub trait Stage {
//
// @has - '//*[@id="associatedconstant.ARRAY1"]' \
// 'const ARRAY1: [u8; { _ }]'
const ARRAY1: [u8; Struct::new(/* ... */) + Self::ABSTRACT * 1_000];
const ARRAY1: [u8; Struct::new(/* ... */).do_something(Self::ABSTRACT * 1_000)];
// @has - '//*[@id="associatedconstant.VERBOSE"]' \
// 'const VERBOSE: [u16; { _ }]'
@ -73,10 +73,14 @@ pub struct Struct { private: () }
impl Struct {
const fn new() -> Self { Self { private: () } }
const fn do_something(self, x: usize) -> usize {
x
}
}
/* FIXME(const-trait): readd this
impl const std::ops::Add<usize> for Struct {
type Output = usize;
fn add(self, _: usize) -> usize { 0 }
}
*/

40
tests/rustdoc/rfc-2632-const-trait-impl.rs
View file

@ -13,57 +13,57 @@ use std::marker::Destruct;
pub struct S<T>(T);
// @!has foo/trait.Tr.html '//pre[@class="rust item-decl"]/code/a[@class="trait"]' '~const'
// @has - '//pre[@class="rust item-decl"]/code/a[@class="trait"]' 'Clone'
// @has - '//pre[@class="rust item-decl"]/code/a[@class="trait"]' 'Fn'
// @!has - '//pre[@class="rust item-decl"]/code/span[@class="where"]' '~const'
// @has - '//pre[@class="rust item-decl"]/code/span[@class="where"]' ': Clone'
// @has - '//pre[@class="rust item-decl"]/code/span[@class="where"]' ': Fn'
#[const_trait]
pub trait Tr<T> {
// @!has - '//section[@id="method.a"]/h4[@class="code-header"]' '~const'
// @has - '//section[@id="method.a"]/h4[@class="code-header"]/a[@class="trait"]' 'Clone'
// @has - '//section[@id="method.a"]/h4[@class="code-header"]/a[@class="trait"]' 'Fn'
// @!has - '//section[@id="method.a"]/h4[@class="code-header"]/span[@class="where"]' '~const'
// @has - '//section[@id="method.a"]/h4[@class="code-header"]/span[@class="where fmt-newline"]' ': Clone'
fn a<A: ~const Clone + ~const Destruct>()
// @has - '//section[@id="method.a"]/h4[@class="code-header"]/span[@class="where fmt-newline"]' ': Fn'
fn a<A: ~const Fn() + ~const Destruct>()
where
Option<A>: ~const Clone + ~const Destruct,
Option<A>: ~const Fn() + ~const Destruct,
{
}
}
// @has - '//section[@id="impl-Tr%3CT%3E-for-T"]' ''
// @!has - '//section[@id="impl-Tr%3CT%3E-for-T"]/h3[@class="code-header"]' '~const'
// @has - '//section[@id="impl-Tr%3CT%3E-for-T"]/h3[@class="code-header"]/a[@class="trait"]' 'Clone'
// @has - '//section[@id="impl-Tr%3CT%3E-for-T"]/h3[@class="code-header"]/a[@class="trait"]' 'Fn'
// @!has - '//section[@id="impl-Tr%3CT%3E-for-T"]/h3[@class="code-header"]/span[@class="where"]' '~const'
// @has - '//section[@id="impl-Tr%3CT%3E-for-T"]/h3[@class="code-header"]/span[@class="where fmt-newline"]' ': Clone'
impl<T: ~const Clone + ~const Destruct> const Tr<T> for T
// @has - '//section[@id="impl-Tr%3CT%3E-for-T"]/h3[@class="code-header"]/span[@class="where fmt-newline"]' ': Fn'
impl<T: ~const Fn() + ~const Destruct> const Tr<T> for T
where
Option<T>: ~const Clone + ~const Destruct,
Option<T>: ~const Fn() + ~const Destruct,
{
fn a<A: ~const Clone + ~const Destruct>()
fn a<A: ~const Fn() + ~const Destruct>()
where
Option<A>: ~const Clone + ~const Destruct,
Option<A>: ~const Fn() + ~const Destruct,
{
}
}
// @!has foo/fn.foo.html '//pre[@class="rust item-decl"]/code/a[@class="trait"]' '~const'
// @has - '//pre[@class="rust item-decl"]/code/a[@class="trait"]' 'Clone'
// @has - '//pre[@class="rust item-decl"]/code/a[@class="trait"]' 'Fn'
// @!has - '//pre[@class="rust item-decl"]/code/span[@class="where fmt-newline"]' '~const'
// @has - '//pre[@class="rust item-decl"]/code/span[@class="where fmt-newline"]' ': Clone'
pub const fn foo<F: ~const Clone + ~const Destruct>()
// @has - '//pre[@class="rust item-decl"]/code/span[@class="where fmt-newline"]' ': Fn'
pub const fn foo<F: ~const Fn() + ~const Destruct>()
where
Option<F>: ~const Clone + ~const Destruct,
Option<F>: ~const Fn() + ~const Destruct,
{
F::a()
}
impl<T> S<T> {
// @!has foo/struct.S.html '//section[@id="method.foo"]/h4[@class="code-header"]' '~const'
// @has - '//section[@id="method.foo"]/h4[@class="code-header"]/a[@class="trait"]' 'Clone'
// @has - '//section[@id="method.foo"]/h4[@class="code-header"]/a[@class="trait"]' 'Fn'
// @!has - '//section[@id="method.foo"]/h4[@class="code-header"]/span[@class="where"]' '~const'
// @has - '//section[@id="method.foo"]/h4[@class="code-header"]/span[@class="where fmt-newline"]' ': Clone'
pub const fn foo<B, C: ~const Clone + ~const Destruct>()
// @has - '//section[@id="method.foo"]/h4[@class="code-header"]/span[@class="where fmt-newline"]' ': Fn'
pub const fn foo<B, C: ~const Fn() + ~const Destruct>()
where
B: ~const Clone + ~const Destruct,
B: ~const Fn() + ~const Destruct,
{
B::a()
}

3
tests/ui/const-generics/generic_const_exprs/unify-op-with-fn-call.rs
View file

@ -1,3 +1,5 @@
// known-bug: #110395
#![feature(generic_const_exprs, adt_const_params, const_trait_impl)]
#![allow(incomplete_features)]
@ -26,7 +28,6 @@ struct Evaluatable2<const N: usize>;
fn foo2<const N: usize>(a: Evaluatable2<{ N + N }>) {
bar2::<{ std::ops::Add::add(N, N) }>();
//~^ error: unconstrained generic constant
// FIXME(generic_const_exprs) make this not an error
}

11
tests/ui/const-generics/generic_const_exprs/unify-op-with-fn-call.stderr
View file

@ -1,10 +1,11 @@
error: unconstrained generic constant
--> $DIR/unify-op-with-fn-call.rs:28:12
error: const `impl` for trait `Add` which is not marked with `#[const_trait]`
--> $DIR/unify-op-with-fn-call.rs:10:12
|
LL | bar2::<{ std::ops::Add::add(N, N) }>();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | impl const std::ops::Add for Foo {
| ^^^^^^^^^^^^^
|
= help: try adding a `where` bound using this expression: `where [(); { std::ops::Add::add(N, N) }]:`
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error: aborting due to previous error

4
tests/ui/consts/const-eval/const-eval-overflow-3b.stderr
View file

@ -4,13 +4,13 @@ error[E0308]: mismatched types
LL | = [0; (i8::MAX + 1u8) as usize];
| ^^^ expected `i8`, found `u8`
error[E0277]: cannot add `u8` to `i8` in const contexts
error[E0277]: cannot add `u8` to `i8`
--> $DIR/const-eval-overflow-3b.rs:16:20
|
LL | = [0; (i8::MAX + 1u8) as usize];
| ^ no implementation for `i8 + u8`
|
= help: the trait `~const Add<u8>` is not implemented for `i8`
= help: the trait `Add<u8>` is not implemented for `i8`
= help: the following other types implement trait `Add<Rhs>`:
<&'a i8 as Add<i8>>
<&i8 as Add<&i8>>

4
tests/ui/consts/const-eval/const-eval-overflow-4b.stderr
View file

@ -4,13 +4,13 @@ error[E0308]: mismatched types
LL | : [u32; (i8::MAX as i8 + 1u8) as usize]
| ^^^ expected `i8`, found `u8`
error[E0277]: cannot add `u8` to `i8` in const contexts
error[E0277]: cannot add `u8` to `i8`
--> $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 `~const Add<u8>` is not implemented for `i8`
= help: the trait `Add<u8>` is not implemented for `i8`
= help: the following other types implement trait `Add<Rhs>`:
<&'a i8 as Add<i8>>
<&i8 as Add<&i8>>

4
tests/ui/consts/const-eval/const_raw_ptr_ops.rs
View file

@ -1,6 +1,6 @@
fn main() {}
// unconst and bad, will thus error in miri
const X: bool = unsafe { &1 as *const i32 == &2 as *const i32 }; //~ ERROR can't compare
const X: bool = unsafe { &1 as *const i32 == &2 as *const i32 }; //~ ERROR pointers cannot
// unconst and bad, will thus error in miri
const X2: bool = unsafe { 42 as *const i32 == 43 as *const i32 }; //~ ERROR can't compare
const X2: bool = unsafe { 42 as *const i32 == 43 as *const i32 }; //~ ERROR pointers cannot

27
tests/ui/consts/const-eval/const_raw_ptr_ops.stderr
View file

@ -1,29 +1,18 @@
error[E0277]: can't compare `*const i32` with `_` in const contexts
--> $DIR/const_raw_ptr_ops.rs:4:43
error: pointers cannot be reliably compared during const eval
--> $DIR/const_raw_ptr_ops.rs:4:26
|
LL | const X: bool = unsafe { &1 as *const i32 == &2 as *const i32 };
| ^^ no implementation for `*const i32 == _`
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: the trait `~const PartialEq<_>` is not implemented for `*const i32`
note: the trait `PartialEq<_>` is implemented for `*const i32`, but that implementation is not `const`
--> $DIR/const_raw_ptr_ops.rs:4:43
|
LL | const X: bool = unsafe { &1 as *const i32 == &2 as *const i32 };
| ^^
= note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
error[E0277]: can't compare `*const i32` with `_` in const contexts
--> $DIR/const_raw_ptr_ops.rs:6:44
error: pointers cannot be reliably compared during const eval
--> $DIR/const_raw_ptr_ops.rs:6:27
|
LL | const X2: bool = unsafe { 42 as *const i32 == 43 as *const i32 };
| ^^ no implementation for `*const i32 == _`
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: the trait `~const PartialEq<_>` is not implemented for `*const i32`
note: the trait `PartialEq<_>` is implemented for `*const i32`, but that implementation is not `const`
--> $DIR/const_raw_ptr_ops.rs:6:44
|
LL | const X2: bool = unsafe { 42 as *const i32 == 43 as *const i32 };
| ^^
= note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0277`.

2
tests/ui/consts/const-eval/ub-slice-get-unchecked.rs
View file

@ -1,3 +1,5 @@
// known-bug: #110395
#![feature(const_slice_index)]
const A: [(); 5] = [(), (), (), (), ()];

19
tests/ui/consts/const-eval/ub-slice-get-unchecked.stderr
View file

@ -1,18 +1,11 @@
error[E0080]: evaluation of constant value failed
--> $SRC_DIR/core/src/slice/index.rs:LL:COL
|
= note: overflow executing `unchecked_sub`
|
note: inside `<std::ops::Range<usize> as SliceIndex<[()]>>::get_unchecked`
--> $SRC_DIR/core/src/slice/index.rs:LL:COL
note: inside `core::slice::<impl [()]>::get_unchecked::<std::ops::Range<usize>>`
--> $SRC_DIR/core/src/slice/mod.rs:LL:COL
note: inside `B`
--> $DIR/ub-slice-get-unchecked.rs:7:27
error[E0015]: cannot call non-const fn `core::slice::<impl [()]>::get_unchecked::<std::ops::Range<usize>>` in constants
--> $DIR/ub-slice-get-unchecked.rs:9:29
|
LL | const B: &[()] = unsafe { A.get_unchecked(3..1) };
| ^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^
|
= note: calls in constants are limited to constant functions, tuple structs and tuple variants
error: aborting due to previous error
For more information about this error, try `rustc --explain E0080`.
For more information about this error, try `rustc --explain E0015`.

35
tests/ui/consts/const-float-classify.rs
View file

@ -8,11 +8,33 @@
// Don't promote
const fn nop<T>(x: T) -> T { x }
// FIXME(const-hack): replace with PartialEq
#[const_trait]
trait MyEq<T> {
fn eq(self, b: T) -> bool;
}
impl const MyEq<bool> for bool {
fn eq(self, b: bool) -> bool {
self == b
}
}
impl const MyEq<NonDet> for bool {
fn eq(self, _: NonDet) -> bool {
true
}
}
const fn eq<A: ~const MyEq<B>, B>(x: A, y: B) -> bool {
x.eq(y)
}
macro_rules! const_assert {
($a:expr, $b:expr) => {
{
const _: () = assert!($a == $b);
assert_eq!(nop($a), nop($b));
const _: () = assert!(eq($a, $b));
assert!(eq(nop($a), nop($b)));
}
};
}
@ -47,15 +69,6 @@ macro_rules! suite_inner {
#[derive(Debug)]
struct NonDet;
impl const PartialEq<NonDet> for bool {
fn eq(&self, _: &NonDet) -> bool {
true
}
fn ne(&self, _: &NonDet) -> bool {
false
}
}
// The result of the `is_sign` methods are not checked for correctness, since LLVM does not
// guarantee anything about the signedness of NaNs. See
// https://github.com/rust-lang/rust/issues/55131.

1
tests/ui/consts/const-fn-error.rs
View file

@ -7,7 +7,6 @@ const fn f(x: usize) -> usize {
//~| ERROR `for` is not allowed in a `const fn`
//~| ERROR mutable references are not allowed in constant functions
//~| ERROR cannot call non-const fn
//~| ERROR the trait bound
sum += i;
}
sum

19
tests/ui/consts/const-fn-error.stderr
View file

@ -5,7 +5,7 @@ LL | / for i in 0..x {
LL | |
LL | |
LL | |
... |
LL | |
LL | | sum += i;
LL | | }
| |_____^
@ -33,19 +33,6 @@ LL | for i in 0..x {
= note: see issue #57349 <https://github.com/rust-lang/rust/issues/57349> for more information
= help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
error[E0277]: the trait bound `std::ops::Range<usize>: Iterator` is not satisfied
--> $DIR/const-fn-error.rs:5:14
|
LL | for i in 0..x {
| ^^^^ `std::ops::Range<usize>` is not an iterator
|
= help: the trait `~const Iterator` is not implemented for `std::ops::Range<usize>`
note: the trait `Iterator` is implemented for `std::ops::Range<usize>`, but that implementation is not `const`
--> $DIR/const-fn-error.rs:5:14
|
LL | for i in 0..x {
| ^^^^
error[E0015]: cannot call non-const fn `<std::ops::Range<usize> as Iterator>::next` in constant functions
--> $DIR/const-fn-error.rs:5:14
|
@ -55,7 +42,7 @@ LL | for i in 0..x {
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
error: aborting due to 5 previous errors
error: aborting due to 4 previous errors
Some errors have detailed explanations: E0015, E0277, E0658.
Some errors have detailed explanations: E0015, E0658.
For more information about an error, try `rustc --explain E0015`.

1
tests/ui/consts/const-for.rs
View file

@ -5,7 +5,6 @@ const _: () = {
for _ in 0..5 {}
//~^ error: cannot call
//~| error: cannot convert
//~| error: the trait bound
};
fn main() {}

18
tests/ui/consts/const-for.stderr
View file

@ -9,19 +9,6 @@ note: impl defined here, but it is not `const`
= note: calls in constants are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
error[E0277]: the trait bound `std::ops::Range<i32>: Iterator` is not satisfied
--> $DIR/const-for.rs:5:14
|
LL | for _ in 0..5 {}
| ^^^^ `std::ops::Range<i32>` is not an iterator
|
= help: the trait `~const Iterator` is not implemented for `std::ops::Range<i32>`
note: the trait `Iterator` is implemented for `std::ops::Range<i32>`, but that implementation is not `const`
--> $DIR/const-for.rs:5:14
|
LL | for _ in 0..5 {}
| ^^^^
error[E0015]: cannot call non-const fn `<std::ops::Range<i32> as Iterator>::next` in constants
--> $DIR/const-for.rs:5:14
|
@ -31,7 +18,6 @@ LL | for _ in 0..5 {}
= note: calls in constants are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
error: aborting due to 3 previous errors
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0015, E0277.
For more information about an error, try `rustc --explain E0015`.
For more information about this error, try `rustc --explain E0015`.

2
tests/ui/consts/const-try.rs
View file

@ -1,4 +1,4 @@
// check-pass
// known-bug: #110395
// Demonstrates what's needed to make use of `?` in const contexts.

20
tests/ui/consts/const-try.stderr Normal file
View file

@ -0,0 +1,20 @@
error: const `impl` for trait `FromResidual` which is not marked with `#[const_trait]`
--> $DIR/const-try.rs:15:12
|
LL | impl const FromResidual<Error> for TryMe {
| ^^^^^^^^^^^^^^^^^^^
|
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error: const `impl` for trait `Try` which is not marked with `#[const_trait]`
--> $DIR/const-try.rs:21:12
|
LL | impl const Try for TryMe {
| ^^^
|
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error: aborting due to 2 previous errors

2
tests/ui/consts/const_cmp_type_id.rs
View file

@ -1,4 +1,4 @@
// run-pass
// known-bug: #110395
#![feature(const_type_id)]
#![feature(const_trait_impl)]

76
tests/ui/consts/const_cmp_type_id.stderr Normal file
View file

@ -0,0 +1,76 @@
error[E0277]: can't compare `TypeId` with `TypeId` in const contexts
--> $DIR/const_cmp_type_id.rs:8:13
|
LL | assert!(TypeId::of::<u8>() == TypeId::of::<u8>());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no implementation for `TypeId == TypeId`
|
= help: the trait `~const PartialEq` is not implemented for `TypeId`
note: the trait `PartialEq` is implemented for `TypeId`, but that implementation is not `const`
--> $DIR/const_cmp_type_id.rs:8:13
|
LL | assert!(TypeId::of::<u8>() == TypeId::of::<u8>());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0015]: cannot call non-const operator in constant functions
--> $DIR/const_cmp_type_id.rs:8:13
|
LL | assert!(TypeId::of::<u8>() == TypeId::of::<u8>());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: impl defined here, but it is not `const`
--> $SRC_DIR/core/src/any.rs:LL:COL
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
= note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0277]: can't compare `TypeId` with `TypeId` in const contexts
--> $DIR/const_cmp_type_id.rs:9:13
|
LL | assert!(TypeId::of::<()>() != TypeId::of::<u8>());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no implementation for `TypeId == TypeId`
|
= help: the trait `~const PartialEq` is not implemented for `TypeId`
note: the trait `PartialEq` is implemented for `TypeId`, but that implementation is not `const`
--> $DIR/const_cmp_type_id.rs:9:13
|
LL | assert!(TypeId::of::<()>() != TypeId::of::<u8>());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0015]: cannot call non-const operator in constant functions
--> $DIR/const_cmp_type_id.rs:9:13
|
LL | assert!(TypeId::of::<()>() != TypeId::of::<u8>());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: impl defined here, but it is not `const`
--> $SRC_DIR/core/src/any.rs:LL:COL
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
= note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0277]: can't compare `TypeId` with `TypeId` in const contexts
--> $DIR/const_cmp_type_id.rs:10:22
|
LL | const _A: bool = TypeId::of::<u8>() < TypeId::of::<u16>();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no implementation for `TypeId < TypeId` and `TypeId > TypeId`
|
= help: the trait `~const PartialOrd` is not implemented for `TypeId`
note: the trait `PartialOrd` is implemented for `TypeId`, but that implementation is not `const`
--> $DIR/const_cmp_type_id.rs:10:22
|
LL | const _A: bool = TypeId::of::<u8>() < TypeId::of::<u16>();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0015]: cannot call non-const operator in constants
--> $DIR/const_cmp_type_id.rs:10:22
|
LL | const _A: bool = TypeId::of::<u8>() < TypeId::of::<u16>();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: impl defined here, but it is not `const`
--> $SRC_DIR/core/src/any.rs:LL:COL
= note: calls in constants are limited to constant functions, tuple structs and tuple variants
= note: this error originates in the derive macro `PartialOrd` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 6 previous errors
Some errors have detailed explanations: E0015, E0277.
For more information about an error, try `rustc --explain E0015`.

2
tests/ui/consts/fn_trait_refs.rs
View file

@ -1,4 +1,4 @@
// check-pass
// known-bug: #110395
#![feature(const_fn_trait_ref_impls)]
#![feature(fn_traits)]

15
tests/ui/consts/fn_trait_refs.stderr Normal file
View file

@ -0,0 +1,15 @@
error[E0635]: unknown feature `const_fn_trait_ref_impls`
--> $DIR/fn_trait_refs.rs:3:12
|
LL | #![feature(const_fn_trait_ref_impls)]
| ^^^^^^^^^^^^^^^^^^^^^^^^
error[E0635]: unknown feature `const_cmp`
--> $DIR/fn_trait_refs.rs:8:12
|
LL | #![feature(const_cmp)]
| ^^^^^^^^^
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0635`.

2
tests/ui/consts/issue-25826.rs
View file

@ -1,6 +1,6 @@
fn id<T>(t: T) -> T { t }
fn main() {
const A: bool = unsafe { id::<u8> as *const () < id::<u16> as *const () };
//~^ ERROR can't compare
//~^ ERROR pointers cannot
println!("{}", A);
}

14
tests/ui/consts/issue-25826.stderr
View file

@ -1,16 +1,10 @@
error[E0277]: can't compare `*const ()` with `*const ()` in const contexts
--> $DIR/issue-25826.rs:3:52
error: pointers cannot be reliably compared during const eval
--> $DIR/issue-25826.rs:3:30
|
LL | const A: bool = unsafe { id::<u8> as *const () < id::<u16> as *const () };
| ^ no implementation for `*const () < *const ()` and `*const () > *const ()`
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: the trait `~const PartialOrd` is not implemented for `*const ()`
note: the trait `PartialOrd` is implemented for `*const ()`, but that implementation is not `const`
--> $DIR/issue-25826.rs:3:52
|
LL | const A: bool = unsafe { id::<u8> as *const () < id::<u16> as *const () };
| ^
= note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
error: aborting due to previous error
For more information about this error, try `rustc --explain E0277`.

2
tests/ui/consts/issue-73976-monomorphic.rs
View file

@ -1,4 +1,4 @@
// check-pass
// known-bug: #110395
//
// This test is complement to the test in issue-73976-polymorphic.rs.
// In that test we ensure that polymorphic use of type_id and type_name in patterns

28
tests/ui/consts/issue-73976-monomorphic.stderr Normal file
View file

@ -0,0 +1,28 @@
error[E0277]: can't compare `TypeId` with `TypeId` in const contexts
--> $DIR/issue-73976-monomorphic.rs:21:5
|
LL | GetTypeId::<T>::VALUE == GetTypeId::<usize>::VALUE
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ no implementation for `TypeId == TypeId`
|
= help: the trait `~const PartialEq` is not implemented for `TypeId`
note: the trait `PartialEq` is implemented for `TypeId`, but that implementation is not `const`
--> $DIR/issue-73976-monomorphic.rs:21:5
|
LL | GetTypeId::<T>::VALUE == GetTypeId::<usize>::VALUE
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error[E0015]: cannot call non-const operator in constant functions
--> $DIR/issue-73976-monomorphic.rs:21:5
|
LL | GetTypeId::<T>::VALUE == GetTypeId::<usize>::VALUE
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
note: impl defined here, but it is not `const`
--> $SRC_DIR/core/src/any.rs:LL:COL
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
= note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0015, E0277.
For more information about an error, try `rustc --explain E0015`.

5
tests/ui/consts/issue-94675.rs
View file

@ -7,8 +7,9 @@ struct Foo<'a> {
impl<'a> Foo<'a> {
const fn spam(&mut self, baz: &mut Vec<u32>) {
self.bar[0] = baz.len();
//~^ the trait bound `Vec<usize>: ~const Index<_>` is not satisfied
//~| the trait bound `Vec<usize>: ~const IndexMut<usize>` is not satisfied
//~^ ERROR: cannot call
//~| ERROR: cannot call
//~| ERROR: the trait bound
}
}

28
tests/ui/consts/issue-94675.stderr
View file

@ -1,15 +1,10 @@
error[E0277]: the trait bound `Vec<usize>: ~const Index<_>` is not satisfied
--> $DIR/issue-94675.rs:9:9
error[E0015]: cannot call non-const fn `Vec::<u32>::len` in constant functions
--> $DIR/issue-94675.rs:9:27
|
LL | self.bar[0] = baz.len();
| ^^^^^^^^^^^ vector indices are of type `usize` or ranges of `usize`
| ^^^^^
|
= help: the trait `~const Index<_>` is not implemented for `Vec<usize>`
note: the trait `Index<_>` is implemented for `Vec<usize>`, but that implementation is not `const`
--> $DIR/issue-94675.rs:9:9
|
LL | self.bar[0] = baz.len();
| ^^^^^^^^^^^
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
error[E0277]: the trait bound `Vec<usize>: ~const IndexMut<usize>` is not satisfied
--> $DIR/issue-94675.rs:9:9
@ -24,6 +19,17 @@ note: the trait `IndexMut<usize>` is implemented for `Vec<usize>`, but that impl
LL | self.bar[0] = baz.len();
| ^^^^^^^^^^^
error: aborting due to 2 previous errors
error[E0015]: cannot call non-const operator in constant functions
--> $DIR/issue-94675.rs:9:9
|
LL | self.bar[0] = baz.len();
| ^^^^^^^^^^^
|
note: impl defined here, but it is not `const`
--> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
For more information about this error, try `rustc --explain E0277`.
error: aborting due to 3 previous errors
Some errors have detailed explanations: E0015, E0277.
For more information about an error, try `rustc --explain E0015`.

2
tests/ui/consts/min_const_fn/cmp_fn_pointers.rs
View file

@ -1,6 +1,6 @@
const fn cmp(x: fn(), y: fn()) -> bool {
unsafe { x == y }
//~^ ERROR can't compare
//~^ ERROR pointers cannot
}
fn main() {}

14
tests/ui/consts/min_const_fn/cmp_fn_pointers.stderr
View file

@ -1,16 +1,10 @@
error[E0277]: can't compare `fn()` with `_` in const contexts
--> $DIR/cmp_fn_pointers.rs:2:16
error: pointers cannot be reliably compared during const eval
--> $DIR/cmp_fn_pointers.rs:2:14
|
LL | unsafe { x == y }
| ^^ no implementation for `fn() == _`
| ^^^^^^
|
= help: the trait `~const PartialEq<_>` is not implemented for `fn()`
note: the trait `PartialEq<_>` is implemented for `fn()`, but that implementation is not `const`
--> $DIR/cmp_fn_pointers.rs:2:16
|
LL | unsafe { x == y }
| ^^
= note: see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
error: aborting due to previous error
For more information about this error, try `rustc --explain E0277`.

2
tests/ui/consts/promoted_const_call.rs
View file

@ -1,7 +1,9 @@
#![feature(const_mut_refs)]
#![feature(const_trait_impl)]
struct Panic;
impl const Drop for Panic { fn drop(&mut self) { panic!(); } }
pub const fn id<T>(x: T) -> T { x }
pub const C: () = {
let _: &'static _ = &id(&Panic);

12
tests/ui/consts/promoted_const_call.stderr
View file

@ -1,5 +1,5 @@
error[E0716]: temporary value dropped while borrowed
--> $DIR/promoted_const_call.rs:7:26
--> $DIR/promoted_const_call.rs:9:26
|
LL | let _: &'static _ = &id(&Panic);
| ---------- ^^^^^^^^^^ creates a temporary value which is freed while still in use
@ -10,7 +10,7 @@ LL | };
| - temporary value is freed at the end of this statement
error[E0716]: temporary value dropped while borrowed
--> $DIR/promoted_const_call.rs:7:30
--> $DIR/promoted_const_call.rs:9:30
|
LL | let _: &'static _ = &id(&Panic);
| ---------- ^^^^^ - temporary value is freed at the end of this statement
@ -19,7 +19,7 @@ LL | let _: &'static _ = &id(&Panic);
| type annotation requires that borrow lasts for `'static`
error[E0716]: temporary value dropped while borrowed
--> $DIR/promoted_const_call.rs:13:26
--> $DIR/promoted_const_call.rs:15:26
|
LL | let _: &'static _ = &id(&Panic);
| ---------- ^^^^^^^^^^ creates a temporary value which is freed while still in use
@ -30,7 +30,7 @@ LL | }
| - temporary value is freed at the end of this statement
error[E0716]: temporary value dropped while borrowed
--> $DIR/promoted_const_call.rs:13:30
--> $DIR/promoted_const_call.rs:15:30
|
LL | let _: &'static _ = &id(&Panic);
| ---------- ^^^^^ - temporary value is freed at the end of this statement
@ -39,7 +39,7 @@ LL | let _: &'static _ = &id(&Panic);
| type annotation requires that borrow lasts for `'static`
error[E0716]: temporary value dropped while borrowed
--> $DIR/promoted_const_call.rs:16:26
--> $DIR/promoted_const_call.rs:18:26
|
LL | let _: &'static _ = &&(Panic, 0).1;
| ---------- ^^^^^^^^^^^^^ creates a temporary value which is freed while still in use
@ -50,7 +50,7 @@ LL | }
| - temporary value is freed at the end of this statement
error[E0716]: temporary value dropped while borrowed
--> $DIR/promoted_const_call.rs:16:27
--> $DIR/promoted_const_call.rs:18:27
|
LL | let _: &'static _ = &&(Panic, 0).1;
| ---------- ^^^^^^^^^^ creates a temporary value which is freed while still in use

2
tests/ui/consts/rustc-impl-const-stability.rs
View file

@ -1,4 +1,4 @@
// check-pass
// known-bug: #110395
#![crate_type = "lib"]
#![feature(staged_api)]

11
tests/ui/consts/rustc-impl-const-stability.stderr Normal file
View file

@ -0,0 +1,11 @@
error: const `impl` for trait `Default` which is not marked with `#[const_trait]`
--> $DIR/rustc-impl-const-stability.rs:15:12
|
LL | impl const Default for Data {
| ^^^^^^^
|
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error: aborting due to previous error

2
tests/ui/consts/try-operator.rs
View file

@ -1,4 +1,4 @@
// run-pass
// known-bug: #110395
#![feature(try_trait_v2)]
#![feature(const_trait_impl)]

9
tests/ui/consts/try-operator.stderr Normal file
View file

@ -0,0 +1,9 @@
error[E0635]: unknown feature `const_convert`
--> $DIR/try-operator.rs:6:12
|
LL | #![feature(const_convert)]
| ^^^^^^^^^^^^^
error: aborting due to previous error
For more information about this error, try `rustc --explain E0635`.

4
tests/ui/did_you_mean/issue-49746-unicode-confusable-in-float-literal-expt.stderr
View file

@ -15,13 +15,13 @@ help: Unicode character '−' (Minus Sign) looks like '-' (Minus/Hyphen), but it
LL | const UNIVERSAL_GRAVITATIONAL_CONSTANT: f64 = 6.674e-11; // m³⋅kg⁻¹⋅s⁻²
| ~
error[E0277]: cannot subtract `{integer}` from `{float}` in const contexts
error[E0277]: cannot subtract `{integer}` from `{float}`
--> $DIR/issue-49746-unicode-confusable-in-float-literal-expt.rs:1:53
|
LL | const UNIVERSAL_GRAVITATIONAL_CONSTANT: f64 = 6.674e−11; // m³⋅kg⁻¹⋅s⁻²
| ^ no implementation for `{float} - {integer}`
|
= help: the trait `~const Sub<{integer}>` is not implemented for `{float}`
= help: the trait `Sub<{integer}>` is not implemented for `{float}`
= help: the following other types implement trait `Sub<Rhs>`:
<&'a f32 as Sub<f32>>
<&'a f64 as Sub<f64>>

2
tests/ui/issues/issue-25901.rs
View file

@ -2,7 +2,7 @@ struct A;
struct B;
static S: &'static B = &A;
//~^ ERROR the trait bound
//~^ ERROR cannot perform deref coercion
use std::ops::Deref;

25
tests/ui/issues/issue-25901.stderr
View file

@ -1,15 +1,24 @@
error[E0277]: the trait bound `A: Deref` is not satisfied
--> $DIR/issue-25901.rs:4:24
|
LL | static S: &'static B = &A;
| ^^ the trait `~const Deref` is not implemented for `A`
|
note: the trait `Deref` is implemented for `A`, but that implementation is not `const`
error[E0015]: cannot perform deref coercion on `A` in statics
--> $DIR/issue-25901.rs:4:24
|
LL | static S: &'static B = &A;
| ^^
|
= note: attempting to deref into `B`
note: deref defined here
--> $DIR/issue-25901.rs:10:5
|
LL | type Target = B;
| ^^^^^^^^^^^
note: impl defined here, but it is not `const`
--> $DIR/issue-25901.rs:9:1
|
LL | impl Deref for A {
| ^^^^^^^^^^^^^^^^
= note: calls in statics are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
= note: consider wrapping this expression in `Lazy::new(|| ...)` from the `once_cell` crate: https://crates.io/crates/once_cell
error: aborting due to previous error
For more information about this error, try `rustc --explain E0277`.
For more information about this error, try `rustc --explain E0015`.

4
tests/ui/issues/issue-50582.stderr
View file

@ -7,13 +7,13 @@ LL | Vec::<[(); 1 + for x in 0..1 {}]>::new();
= note: see issue #87575 <https://github.com/rust-lang/rust/issues/87575> for more information
= help: add `#![feature(const_for)]` to the crate attributes to enable
error[E0277]: cannot add `()` to `{integer}` in const contexts
error[E0277]: cannot add `()` to `{integer}`
--> $DIR/issue-50582.rs:2:18
|
LL | Vec::<[(); 1 + for x in 0..1 {}]>::new();
| ^ no implementation for `{integer} + ()`
|
= help: the trait `~const Add<()>` is not implemented for `{integer}`
= help: the trait `Add<()>` is not implemented for `{integer}`
= help: the following other types implement trait `Add<Rhs>`:
<&'a f32 as Add<f32>>
<&'a f64 as Add<f64>>

1
tests/ui/never_type/issue-52443.rs
View file

@ -11,5 +11,4 @@ fn main() {
//~| ERROR cannot convert
//~| ERROR mutable references
//~| ERROR cannot call
//~| ERROR the trait bound
}

17
tests/ui/never_type/issue-52443.stderr
View file

@ -58,19 +58,6 @@ LL | [(); { for _ in 0usize.. {}; 0}];
= note: see issue #57349 <https://github.com/rust-lang/rust/issues/57349> for more information
= help: add `#![feature(const_mut_refs)]` to the crate attributes to enable
error[E0277]: the trait bound `RangeFrom<usize>: Iterator` is not satisfied
--> $DIR/issue-52443.rs:9:21
|
LL | [(); { for _ in 0usize.. {}; 0}];
| ^^^^^^^^ `RangeFrom<usize>` is not an iterator
|
= help: the trait `~const Iterator` is not implemented for `RangeFrom<usize>`
note: the trait `Iterator` is implemented for `RangeFrom<usize>`, but that implementation is not `const`
--> $DIR/issue-52443.rs:9:21
|
LL | [(); { for _ in 0usize.. {}; 0}];
| ^^^^^^^^
error[E0015]: cannot call non-const fn `<RangeFrom<usize> as Iterator>::next` in constants
--> $DIR/issue-52443.rs:9:21
|
@ -80,7 +67,7 @@ LL | [(); { for _ in 0usize.. {}; 0}];
= note: calls in constants are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
error: aborting due to 7 previous errors; 1 warning emitted
error: aborting due to 6 previous errors; 1 warning emitted
Some errors have detailed explanations: E0015, E0277, E0308, E0658.
Some errors have detailed explanations: E0015, E0308, E0658.
For more information about an error, try `rustc --explain E0015`.

3
tests/ui/rfc-2632-const-trait-impl/assoc-type.rs
View file

@ -1,3 +1,5 @@
// known-bug: #110395
#![feature(const_trait_impl)]
struct NonConstAdd(i32);
@ -17,7 +19,6 @@ trait Foo {
impl const Foo for NonConstAdd {
type Bar = NonConstAdd;
//~^ ERROR: cannot add `NonConstAdd` to `NonConstAdd` in const contexts
}
#[const_trait]

19
tests/ui/rfc-2632-const-trait-impl/assoc-type.stderr
View file

@ -1,21 +1,8 @@
error[E0277]: cannot add `NonConstAdd` to `NonConstAdd` in const contexts
--> $DIR/assoc-type.rs:19:16
|
LL | type Bar = NonConstAdd;
| ^^^^^^^^^^^ no implementation for `NonConstAdd + NonConstAdd`
|
= help: the trait `~const Add` is not implemented for `NonConstAdd`
note: the trait `Add` is implemented for `NonConstAdd`, but that implementation is not `const`
--> $DIR/assoc-type.rs:19:16
|
LL | type Bar = NonConstAdd;
| ^^^^^^^^^^^
note: required by a bound in `Foo::Bar`
--> $DIR/assoc-type.rs:15:15
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/assoc-type.rs:17:22
|
LL | type Bar: ~const std::ops::Add;
| ^^^^^^^^^^^^^^^^^^^^ required by this bound in `Foo::Bar`
| ^^^^^^^^^^^^^
error: aborting due to previous error
For more information about this error, try `rustc --explain E0277`.

2
tests/ui/rfc-2632-const-trait-impl/call-const-trait-method-pass.rs
View file

@ -1,4 +1,4 @@
// run-pass
// known-bug: #110395
#![feature(const_trait_impl)]

20
tests/ui/rfc-2632-const-trait-impl/call-const-trait-method-pass.stderr Normal file
View file

@ -0,0 +1,20 @@
error: const `impl` for trait `Add` which is not marked with `#[const_trait]`
--> $DIR/call-const-trait-method-pass.rs:7:12
|
LL | impl const std::ops::Add for Int {
| ^^^^^^^^^^^^^
|
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error: const `impl` for trait `PartialEq` which is not marked with `#[const_trait]`
--> $DIR/call-const-trait-method-pass.rs:15:12
|
LL | impl const PartialEq for Int {
| ^^^^^^^^^
|
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error: aborting due to 2 previous errors

2
tests/ui/rfc-2632-const-trait-impl/call-generic-in-impl.rs
View file

@ -1,4 +1,4 @@
// check-pass
// known-bug: #110395
#![feature(const_trait_impl)]
#[const_trait]

8
tests/ui/rfc-2632-const-trait-impl/call-generic-in-impl.stderr Normal file
View file

@ -0,0 +1,8 @@
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/call-generic-in-impl.rs:9:16
|
LL | impl<T: ~const PartialEq> const MyPartialEq for T {
| ^^^^^^^^^
error: aborting due to previous error

2
tests/ui/rfc-2632-const-trait-impl/call-generic-method-chain.rs
View file

@ -1,6 +1,6 @@
//! Basic test for calling methods on generic type parameters in `const fn`.
// check-pass
// known-bug: #110395
#![feature(const_trait_impl)]

23
tests/ui/rfc-2632-const-trait-impl/call-generic-method-chain.stderr Normal file
View file

@ -0,0 +1,23 @@
error: const `impl` for trait `PartialEq` which is not marked with `#[const_trait]`
--> $DIR/call-generic-method-chain.rs:9:12
|
LL | impl const PartialEq for S {
| ^^^^^^^^^
|
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/call-generic-method-chain.rs:18:32
|
LL | const fn equals_self<T: ~const PartialEq>(t: &T) -> bool {
| ^^^^^^^^^
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/call-generic-method-chain.rs:22:40
|
LL | const fn equals_self_wrapper<T: ~const PartialEq>(t: &T) -> bool {
| ^^^^^^^^^
error: aborting due to 3 previous errors

2
tests/ui/rfc-2632-const-trait-impl/call-generic-method-dup-bound.rs
View file

@ -1,4 +1,4 @@
// check-pass
// known-bug: #110395
#![feature(const_trait_impl)]

23
tests/ui/rfc-2632-const-trait-impl/call-generic-method-dup-bound.stderr Normal file
View file

@ -0,0 +1,23 @@
error: const `impl` for trait `PartialEq` which is not marked with `#[const_trait]`
--> $DIR/call-generic-method-dup-bound.rs:7:12
|
LL | impl const PartialEq for S {
| ^^^^^^^^^
|
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/call-generic-method-dup-bound.rs:18:44
|
LL | const fn equals_self<T: PartialEq + ~const PartialEq>(t: &T) -> bool {
| ^^^^^^^^^
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/call-generic-method-dup-bound.rs:25:37
|
LL | const fn equals_self2<T: A + ~const PartialEq>(t: &T) -> bool {
| ^^^^^^^^^
error: aborting due to 3 previous errors

3
tests/ui/rfc-2632-const-trait-impl/call-generic-method-fail.rs
View file

@ -1,8 +1,9 @@
// known-bug: #110395
#![feature(const_trait_impl)]
pub const fn equals_self<T: PartialEq>(t: &T) -> bool {
*t == *t
//~^ ERROR can't compare
// (remove this) ~^ ERROR can't compare
}
fn main() {}

29
tests/ui/rfc-2632-const-trait-impl/call-generic-method-fail.stderr
View file

@ -1,15 +1,28 @@
error[E0277]: can't compare `T` with `_` in const contexts
--> $DIR/call-generic-method-fail.rs:4:8
error[E0277]: can't compare `T` with `T` in const contexts
--> $DIR/call-generic-method-fail.rs:5:5
|
LL | *t == *t
| ^^ no implementation for `T == _`
| ^^^^^^^^ no implementation for `T == T`
|
note: the trait `PartialEq<_>` is implemented for `T`, but that implementation is not `const`
--> $DIR/call-generic-method-fail.rs:4:8
note: the trait `PartialEq` is implemented for `T`, but that implementation is not `const`
--> $DIR/call-generic-method-fail.rs:5:5
|
LL | *t == *t
| ^^
| ^^^^^^^^
error: aborting due to previous error
error[E0015]: cannot call non-const operator in constant functions
--> $DIR/call-generic-method-fail.rs:5:5
|
LL | *t == *t
| ^^^^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
help: consider further restricting this bound
|
LL | pub const fn equals_self<T: PartialEq + ~const std::cmp::PartialEq>(t: &T) -> bool {
| ++++++++++++++++++++++++++++
For more information about this error, try `rustc --explain E0277`.
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0015, E0277.
For more information about an error, try `rustc --explain E0015`.

2
tests/ui/rfc-2632-const-trait-impl/call-generic-method-pass.rs
View file

@ -1,6 +1,6 @@
//! Basic test for calling methods on generic type parameters in `const fn`.
// check-pass
// known-bug: #110395
#![feature(const_trait_impl)]

17
tests/ui/rfc-2632-const-trait-impl/call-generic-method-pass.stderr Normal file
View file

@ -0,0 +1,17 @@
error: const `impl` for trait `PartialEq` which is not marked with `#[const_trait]`
--> $DIR/call-generic-method-pass.rs:9:12
|
LL | impl const PartialEq for S {
| ^^^^^^^^^
|
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/call-generic-method-pass.rs:18:32
|
LL | const fn equals_self<T: ~const PartialEq>(t: &T) -> bool {
| ^^^^^^^^^
error: aborting due to 2 previous errors

4
tests/ui/rfc-2632-const-trait-impl/const-and-non-const-impl.rs
View file

@ -1,9 +1,10 @@
// known-bug: #110395
#![feature(const_trait_impl)]
pub struct Int(i32);
impl const std::ops::Add for i32 {
//~^ ERROR only traits defined in the current crate can be implemented for primitive types
type Output = Self;
fn add(self, rhs: Self) -> Self {
@ -20,7 +21,6 @@ impl std::ops::Add for Int {
}
impl const std::ops::Add for Int {
//~^ ERROR conflicting implementations of trait
type Output = Self;
fn add(self, rhs: Self) -> Self {

27
tests/ui/rfc-2632-const-trait-impl/const-and-non-const-impl.stderr
View file

@ -1,25 +1,20 @@
error[E0117]: only traits defined in the current crate can be implemented for primitive types
--> $DIR/const-and-non-const-impl.rs:5:1
error: const `impl` for trait `Add` which is not marked with `#[const_trait]`
--> $DIR/const-and-non-const-impl.rs:7:12
|
LL | impl const std::ops::Add for i32 {
| ^^^^^^^^^^^-------------^^^^^---
| | | |
| | | `i32` is not defined in the current crate
| | `i32` is not defined in the current crate
| impl doesn't use only types from inside the current crate
| ^^^^^^^^^^^^^
|
= note: define and implement a trait or new type instead
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error[E0119]: conflicting implementations of trait `Add` for type `Int`
--> $DIR/const-and-non-const-impl.rs:22:1
error: const `impl` for trait `Add` which is not marked with `#[const_trait]`
--> $DIR/const-and-non-const-impl.rs:23:12
|
LL | impl std::ops::Add for Int {
| -------------------------- first implementation here
...
LL | impl const std::ops::Add for Int {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Int`
| ^^^^^^^^^^^^^
|
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error: aborting due to 2 previous errors
Some errors have detailed explanations: E0117, E0119.
For more information about an error, try `rustc --explain E0117`.

3
tests/ui/rfc-2632-const-trait-impl/const-closure-trait-method-fail.rs
View file

@ -1,3 +1,5 @@
// known-bug: #110395
#![feature(const_trait_impl)]
#[const_trait]
@ -14,6 +16,5 @@ const fn need_const_closure<T: ~const FnOnce(()) -> i32>(x: T) -> i32 {
}
const _: () = assert!(need_const_closure(Tr::a) == 42);
//~^ ERROR: the trait bound
fn main() {}

4
tests/ui/rfc-2632-const-trait-impl/const-closure-trait-method-fail.stderr
View file

@ -1,11 +1,11 @@
error[E0277]: the trait bound `(): ~const Tr` is not satisfied in `fn(()) -> i32 {<() as Tr>::a}`
--> $DIR/const-closure-trait-method-fail.rs:16:23
--> $DIR/const-closure-trait-method-fail.rs:18:23
|
LL | const _: () = assert!(need_const_closure(Tr::a) == 42);
| ^^^^^^^^^^^^^^^^^^^^^^^^^ within `fn(()) -> i32 {<() as Tr>::a}`, the trait `~const Tr` is not implemented for `()`
|
note: the trait `Tr` is implemented for `()`, but that implementation is not `const`
--> $DIR/const-closure-trait-method-fail.rs:16:23
--> $DIR/const-closure-trait-method-fail.rs:18:23
|
LL | const _: () = assert!(need_const_closure(Tr::a) == 42);
| ^^^^^^^^^^^^^^^^^^^^^^^^^

2
tests/ui/rfc-2632-const-trait-impl/const-closures.rs
View file

@ -1,4 +1,4 @@
// run-pass
// check-pass
#![feature(const_trait_impl)]

54
tests/ui/rfc-2632-const-trait-impl/const-drop-fail-2.precise.stderr
View file

@ -1,50 +1,26 @@
error[E0277]: the trait bound `NonTrivialDrop: ~const A` is not satisfied
--> $DIR/const-drop-fail-2.rs:31:23
error: const `impl` for trait `Drop` which is not marked with `#[const_trait]`
--> $DIR/const-drop-fail-2.rs:23:25
|
LL | const _: () = check::<ConstDropImplWithBounds<NonTrivialDrop>>(
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `~const A` is not implemented for `NonTrivialDrop`
LL | impl<T: ~const A> const Drop for ConstDropImplWithBounds<T> {
| ^^^^
|
note: the trait `A` is implemented for `NonTrivialDrop`, but that implementation is not `const`
--> $DIR/const-drop-fail-2.rs:31:23
|
LL | const _: () = check::<ConstDropImplWithBounds<NonTrivialDrop>>(
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required by a bound in `ConstDropImplWithBounds`
--> $DIR/const-drop-fail-2.rs:21:35
|
LL | struct ConstDropImplWithBounds<T: ~const A>(PhantomData<T>);
| ^^^^^^^^ required by this bound in `ConstDropImplWithBounds`
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error[E0277]: the trait bound `NonTrivialDrop: ~const A` is not satisfied
--> $DIR/const-drop-fail-2.rs:33:5
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/const-drop-fail-2.rs:29:26
|
LL | ConstDropImplWithBounds(PhantomData)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `~const A` is not implemented for `NonTrivialDrop`
|
note: the trait `A` is implemented for `NonTrivialDrop`, but that implementation is not `const`
--> $DIR/const-drop-fail-2.rs:33:5
|
LL | ConstDropImplWithBounds(PhantomData)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required by a bound in `ConstDropImplWithBounds`
--> $DIR/const-drop-fail-2.rs:21:35
|
LL | struct ConstDropImplWithBounds<T: ~const A>(PhantomData<T>);
| ^^^^^^^^ required by this bound in `ConstDropImplWithBounds`
LL | const fn check<T: ~const Destruct>(_: T) {}
| ^^^^^^^^
error[E0367]: `Drop` impl requires `T: ~const A` but the struct it is implemented for does not
--> $DIR/const-drop-fail-2.rs:39:9
error: const `impl` for trait `Drop` which is not marked with `#[const_trait]`
--> $DIR/const-drop-fail-2.rs:39:25
|
LL | impl<T: ~const A> const Drop for ConstDropImplWithNonConstBounds<T> {
| ^^^^^^^^
| ^^^^
|
note: the implementor must specify the same requirement
--> $DIR/const-drop-fail-2.rs:37:1
|
LL | struct ConstDropImplWithNonConstBounds<T: A>(PhantomData<T>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error: aborting due to 3 previous errors
Some errors have detailed explanations: E0277, E0367.
For more information about an error, try `rustc --explain E0277`.

5
tests/ui/rfc-2632-const-trait-impl/const-drop-fail-2.rs
View file

@ -1,4 +1,4 @@
// revisions: stock precise
// known-bug: #110395
#![feature(const_trait_impl)]
#![feature(const_mut_refs)]
#![cfg_attr(precise, feature(const_precise_live_drops))]
@ -29,15 +29,12 @@ impl<T: ~const A> const Drop for ConstDropImplWithBounds<T> {
const fn check<T: ~const Destruct>(_: T) {}
const _: () = check::<ConstDropImplWithBounds<NonTrivialDrop>>(
//~^ ERROR the trait bound
ConstDropImplWithBounds(PhantomData)
//~^ ERROR the trait bound
);
struct ConstDropImplWithNonConstBounds<T: A>(PhantomData<T>);
impl<T: ~const A> const Drop for ConstDropImplWithNonConstBounds<T> {
//~^ ERROR `Drop` impl requires `T: ~const A` but the struct it is implemented for does not
fn drop(&mut self) {
T::a();
}

50
tests/ui/rfc-2632-const-trait-impl/const-drop-fail-2.stderr Normal file
View file

@ -0,0 +1,50 @@
error[E0277]: the trait bound `NonTrivialDrop: ~const A` is not satisfied
--> $DIR/const-drop-fail-2.rs:31:23
|
LL | const _: () = check::<ConstDropImplWithBounds<NonTrivialDrop>>(
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `~const A` is not implemented for `NonTrivialDrop`
|
note: the trait `A` is implemented for `NonTrivialDrop`, but that implementation is not `const`
--> $DIR/const-drop-fail-2.rs:31:23
|
LL | const _: () = check::<ConstDropImplWithBounds<NonTrivialDrop>>(
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required by a bound in `ConstDropImplWithBounds`
--> $DIR/const-drop-fail-2.rs:21:35
|
LL | struct ConstDropImplWithBounds<T: ~const A>(PhantomData<T>);
| ^^^^^^^^ required by this bound in `ConstDropImplWithBounds`
error[E0277]: the trait bound `NonTrivialDrop: ~const A` is not satisfied
--> $DIR/const-drop-fail-2.rs:32:5
|
LL | ConstDropImplWithBounds(PhantomData)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `~const A` is not implemented for `NonTrivialDrop`
|
note: the trait `A` is implemented for `NonTrivialDrop`, but that implementation is not `const`
--> $DIR/const-drop-fail-2.rs:32:5
|
LL | ConstDropImplWithBounds(PhantomData)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required by a bound in `ConstDropImplWithBounds`
--> $DIR/const-drop-fail-2.rs:21:35
|
LL | struct ConstDropImplWithBounds<T: ~const A>(PhantomData<T>);
| ^^^^^^^^ required by this bound in `ConstDropImplWithBounds`
error[E0367]: `Drop` impl requires `T: ~const A` but the struct it is implemented for does not
--> $DIR/const-drop-fail-2.rs:37:9
|
LL | impl<T: ~const A> const Drop for ConstDropImplWithNonConstBounds<T> {
| ^^^^^^^^
|
note: the implementor must specify the same requirement
--> $DIR/const-drop-fail-2.rs:35:1
|
LL | struct ConstDropImplWithNonConstBounds<T: A>(PhantomData<T>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 3 previous errors
Some errors have detailed explanations: E0277, E0367.
For more information about an error, try `rustc --explain E0277`.

54
tests/ui/rfc-2632-const-trait-impl/const-drop-fail-2.stock.stderr
View file

@ -1,50 +1,26 @@
error[E0277]: the trait bound `NonTrivialDrop: ~const A` is not satisfied
--> $DIR/const-drop-fail-2.rs:31:23
error: const `impl` for trait `Drop` which is not marked with `#[const_trait]`
--> $DIR/const-drop-fail-2.rs:23:25
|
LL | const _: () = check::<ConstDropImplWithBounds<NonTrivialDrop>>(
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `~const A` is not implemented for `NonTrivialDrop`
LL | impl<T: ~const A> const Drop for ConstDropImplWithBounds<T> {
| ^^^^
|
note: the trait `A` is implemented for `NonTrivialDrop`, but that implementation is not `const`
--> $DIR/const-drop-fail-2.rs:31:23
|
LL | const _: () = check::<ConstDropImplWithBounds<NonTrivialDrop>>(
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required by a bound in `ConstDropImplWithBounds`
--> $DIR/const-drop-fail-2.rs:21:35
|
LL | struct ConstDropImplWithBounds<T: ~const A>(PhantomData<T>);
| ^^^^^^^^ required by this bound in `ConstDropImplWithBounds`
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error[E0277]: the trait bound `NonTrivialDrop: ~const A` is not satisfied
--> $DIR/const-drop-fail-2.rs:33:5
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/const-drop-fail-2.rs:29:26
|
LL | ConstDropImplWithBounds(PhantomData)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `~const A` is not implemented for `NonTrivialDrop`
|
note: the trait `A` is implemented for `NonTrivialDrop`, but that implementation is not `const`
--> $DIR/const-drop-fail-2.rs:33:5
|
LL | ConstDropImplWithBounds(PhantomData)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required by a bound in `ConstDropImplWithBounds`
--> $DIR/const-drop-fail-2.rs:21:35
|
LL | struct ConstDropImplWithBounds<T: ~const A>(PhantomData<T>);
| ^^^^^^^^ required by this bound in `ConstDropImplWithBounds`
LL | const fn check<T: ~const Destruct>(_: T) {}
| ^^^^^^^^
error[E0367]: `Drop` impl requires `T: ~const A` but the struct it is implemented for does not
--> $DIR/const-drop-fail-2.rs:39:9
error: const `impl` for trait `Drop` which is not marked with `#[const_trait]`
--> $DIR/const-drop-fail-2.rs:39:25
|
LL | impl<T: ~const A> const Drop for ConstDropImplWithNonConstBounds<T> {
| ^^^^^^^^
| ^^^^
|
note: the implementor must specify the same requirement
--> $DIR/const-drop-fail-2.rs:37:1
|
LL | struct ConstDropImplWithNonConstBounds<T: A>(PhantomData<T>);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error: aborting due to 3 previous errors
Some errors have detailed explanations: E0277, E0367.
For more information about an error, try `rustc --explain E0277`.

10
tests/ui/rfc-2632-const-trait-impl/const-drop-fail.precise.stderr
View file

@ -1,5 +1,5 @@
error[E0277]: can't drop `NonTrivialDrop` in const contexts
--> $DIR/const-drop-fail.rs:26:23
--> $DIR/const-drop-fail.rs:28:23
|
LL | const _: () = check($exp);
| ^^^^^^^^^^^ the trait `~const Destruct` is not implemented for `NonTrivialDrop`
@ -11,7 +11,7 @@ LL | | }
| |_- in this macro invocation
|
note: the trait `Destruct` is implemented for `NonTrivialDrop`, but that implementation is not `const`
--> $DIR/const-drop-fail.rs:26:23
--> $DIR/const-drop-fail.rs:28:23
|
LL | const _: () = check($exp);
| ^^^^^^^^^^^
@ -24,7 +24,7 @@ LL | | }
= note: this error originates in the macro `check_all` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0277]: can't drop `NonTrivialDrop` in const contexts
--> $DIR/const-drop-fail.rs:26:23
--> $DIR/const-drop-fail.rs:28:23
|
LL | const _: () = check($exp);
| ^^^^^^^^^^^ within `ConstImplWithDropGlue`, the trait `~const Destruct` is not implemented for `NonTrivialDrop`
@ -36,7 +36,7 @@ LL | | }
| |_- in this macro invocation
|
note: the trait `Destruct` is implemented for `NonTrivialDrop`, but that implementation is not `const`
--> $DIR/const-drop-fail.rs:26:23
--> $DIR/const-drop-fail.rs:28:23
|
LL | const _: () = check($exp);
| ^^^^^^^^^^^
@ -47,7 +47,7 @@ LL | | ConstImplWithDropGlue(NonTrivialDrop),
LL | | }
| |_- in this macro invocation
note: required because it appears within the type `ConstImplWithDropGlue`
--> $DIR/const-drop-fail.rs:16:8
--> $DIR/const-drop-fail.rs:18:8
|
LL | struct ConstImplWithDropGlue(NonTrivialDrop);
| ^^^^^^^^^^^^^^^^^^^^^

4
tests/ui/rfc-2632-const-trait-impl/const-drop-fail.rs
View file

@ -1,3 +1,5 @@
// known-bug: #110395
// revisions: stock precise
#![feature(const_trait_impl)]
#![feature(const_mut_refs)]
@ -24,8 +26,6 @@ const fn check<T: ~const Destruct>(_: T) {}
macro_rules! check_all {
($($exp:expr),*$(,)?) => {$(
const _: () = check($exp);
//~^ ERROR can't drop
//~| ERROR can't drop
)*};
}

10
tests/ui/rfc-2632-const-trait-impl/const-drop-fail.stock.stderr
View file

@ -1,5 +1,5 @@
error[E0277]: can't drop `NonTrivialDrop` in const contexts
--> $DIR/const-drop-fail.rs:26:23
--> $DIR/const-drop-fail.rs:28:23
|
LL | const _: () = check($exp);
| ^^^^^^^^^^^ the trait `~const Destruct` is not implemented for `NonTrivialDrop`
@ -11,7 +11,7 @@ LL | | }
| |_- in this macro invocation
|
note: the trait `Destruct` is implemented for `NonTrivialDrop`, but that implementation is not `const`
--> $DIR/const-drop-fail.rs:26:23
--> $DIR/const-drop-fail.rs:28:23
|
LL | const _: () = check($exp);
| ^^^^^^^^^^^
@ -24,7 +24,7 @@ LL | | }
= note: this error originates in the macro `check_all` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0277]: can't drop `NonTrivialDrop` in const contexts
--> $DIR/const-drop-fail.rs:26:23
--> $DIR/const-drop-fail.rs:28:23
|
LL | const _: () = check($exp);
| ^^^^^^^^^^^ within `ConstImplWithDropGlue`, the trait `~const Destruct` is not implemented for `NonTrivialDrop`
@ -36,7 +36,7 @@ LL | | }
| |_- in this macro invocation
|
note: the trait `Destruct` is implemented for `NonTrivialDrop`, but that implementation is not `const`
--> $DIR/const-drop-fail.rs:26:23
--> $DIR/const-drop-fail.rs:28:23
|
LL | const _: () = check($exp);
| ^^^^^^^^^^^
@ -47,7 +47,7 @@ LL | | ConstImplWithDropGlue(NonTrivialDrop),
LL | | }
| |_- in this macro invocation
note: required because it appears within the type `ConstImplWithDropGlue`
--> $DIR/const-drop-fail.rs:16:8
--> $DIR/const-drop-fail.rs:18:8
|
LL | struct ConstImplWithDropGlue(NonTrivialDrop);
| ^^^^^^^^^^^^^^^^^^^^^

2
tests/ui/rfc-2632-const-trait-impl/const-impl-trait.rs
View file

@ -1,4 +1,4 @@
// check-pass
// known-bug: #110395
#![allow(incomplete_features)]
#![feature(
associated_type_bounds,

39
tests/ui/rfc-2632-const-trait-impl/const-impl-trait.stderr Normal file
View file

@ -0,0 +1,39 @@
error[E0635]: unknown feature `const_cmp`
--> $DIR/const-impl-trait.rs:6:5
|
LL | const_cmp,
| ^^^^^^^^^
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/const-impl-trait.rs:12:30
|
LL | const fn cmp(a: &impl ~const PartialEq) -> bool {
| ^^^^^^^^^
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/const-impl-trait.rs:16:30
|
LL | const fn wrap(x: impl ~const PartialEq + ~const Destruct)
| ^^^^^^^^^
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/const-impl-trait.rs:17:20
|
LL | -> impl ~const PartialEq + ~const Destruct
| ^^^^^^^^^
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/const-impl-trait.rs:24:29
|
LL | fn huh() -> impl ~const PartialEq + ~const Destruct + Copy;
| ^^^^^^^^^
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/const-impl-trait.rs:28:29
|
LL | fn huh() -> impl ~const PartialEq + ~const Destruct + Copy {
| ^^^^^^^^^
error: aborting due to 6 previous errors
For more information about this error, try `rustc --explain E0635`.

1
tests/ui/rfc-2632-const-trait-impl/const_derives/derive-const-gate.rs
View file

@ -1,4 +1,5 @@
#[derive_const(Default)] //~ ERROR use of unstable library feature
//~^ ERROR not marked with `#[const_trait]`
pub struct S;
fn main() {}

12
tests/ui/rfc-2632-const-trait-impl/const_derives/derive-const-gate.stderr
View file

@ -6,6 +6,16 @@ LL | #[derive_const(Default)]
|
= help: add `#![feature(derive_const)]` to the crate attributes to enable
error: aborting due to previous error
error: const `impl` for trait `Default` which is not marked with `#[const_trait]`
--> $DIR/derive-const-gate.rs:1:16
|
LL | #[derive_const(Default)]
| ^^^^^^^
|
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
= note: this error originates in the derive macro `Default` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0658`.

3
tests/ui/rfc-2632-const-trait-impl/const_derives/derive-const-non-const-type.rs
View file

@ -1,3 +1,4 @@
// known-bug: #110395
#![feature(derive_const)]
pub struct A;
@ -8,7 +9,5 @@ impl Default for A {
#[derive_const(Default)]
pub struct S(A);
//~^ cannot call non-const fn
//~| the trait bound
fn main() {}

38
tests/ui/rfc-2632-const-trait-impl/const_derives/derive-const-non-const-type.stderr
View file

@ -1,38 +1,12 @@
error[E0277]: the trait bound `A: Default` is not satisfied
--> $DIR/derive-const-non-const-type.rs:10:14
error: const `impl` for trait `Default` which is not marked with `#[const_trait]`
--> $DIR/derive-const-non-const-type.rs:10:16
|
LL | #[derive_const(Default)]
| ------- in this derive macro expansion
LL | pub struct S(A);
| ^ the trait `~const Default` is not implemented for `A`
| ^^^^^^^
|
note: the trait `Default` is implemented for `A`, but that implementation is not `const`
--> $DIR/derive-const-non-const-type.rs:10:14
|
LL | #[derive_const(Default)]
| ------- in this derive macro expansion
LL | pub struct S(A);
| ^
= note: this error originates in the derive macro `Default` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider annotating `A` with `#[derive(Default)]`
|
LL + #[derive(Default)]
LL | pub struct A;
|
error[E0015]: cannot call non-const fn `<A as Default>::default` in constant functions
--> $DIR/derive-const-non-const-type.rs:10:14
|
LL | #[derive_const(Default)]
| ------- in this derive macro expansion
LL | pub struct S(A);
| ^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(const_trait_impl)]` to the crate attributes to enable
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
= note: this error originates in the derive macro `Default` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 2 previous errors
error: aborting due to previous error
Some errors have detailed explanations: E0015, E0277.
For more information about an error, try `rustc --explain E0015`.

2
tests/ui/rfc-2632-const-trait-impl/const_derives/derive-const-use.rs
View file

@ -1,4 +1,4 @@
// check-pass
// known-bug: #110395
#![feature(const_trait_impl, const_cmp, const_default_impls, derive_const)]
pub struct A;

53
tests/ui/rfc-2632-const-trait-impl/const_derives/derive-const-use.stderr Normal file
View file

@ -0,0 +1,53 @@
error[E0635]: unknown feature `const_cmp`
--> $DIR/derive-const-use.rs:2:30
|
LL | #![feature(const_trait_impl, const_cmp, const_default_impls, derive_const)]
| ^^^^^^^^^
error[E0635]: unknown feature `const_default_impls`
--> $DIR/derive-const-use.rs:2:41
|
LL | #![feature(const_trait_impl, const_cmp, const_default_impls, derive_const)]
| ^^^^^^^^^^^^^^^^^^^
error: const `impl` for trait `Default` which is not marked with `#[const_trait]`
--> $DIR/derive-const-use.rs:6:12
|
LL | impl const Default for A {
| ^^^^^^^
|
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error: const `impl` for trait `PartialEq` which is not marked with `#[const_trait]`
--> $DIR/derive-const-use.rs:10:12
|
LL | impl const PartialEq for A {
| ^^^^^^^^^
|
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error: const `impl` for trait `Default` which is not marked with `#[const_trait]`
--> $DIR/derive-const-use.rs:14:16
|
LL | #[derive_const(Default, PartialEq)]
| ^^^^^^^
|
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
= note: this error originates in the derive macro `Default` (in Nightly builds, run with -Z macro-backtrace for more info)
error: const `impl` for trait `PartialEq` which is not marked with `#[const_trait]`
--> $DIR/derive-const-use.rs:14:25
|
LL | #[derive_const(Default, PartialEq)]
| ^^^^^^^^^
|
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
= note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 6 previous errors
For more information about this error, try `rustc --explain E0635`.

2
tests/ui/rfc-2632-const-trait-impl/const_derives/derive-const-with-params.rs
View file

@ -1,4 +1,4 @@
// check-pass
// known-bug: #110395
#![feature(derive_const)]
#![feature(const_trait_impl)]

20
tests/ui/rfc-2632-const-trait-impl/const_derives/derive-const-with-params.stderr Normal file
View file

@ -0,0 +1,20 @@
error: const `impl` for trait `PartialEq` which is not marked with `#[const_trait]`
--> $DIR/derive-const-with-params.rs:6:16
|
LL | #[derive_const(PartialEq)]
| ^^^^^^^^^
|
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
= note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/derive-const-with-params.rs:6:16
|
LL | #[derive_const(PartialEq)]
| ^^^^^^^^^
|
= note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
error: aborting due to 2 previous errors

2
tests/ui/rfc-2632-const-trait-impl/generic-bound.rs
View file

@ -1,4 +1,4 @@
// run-pass
// known-bug: #110395
#![feature(const_trait_impl)]

11
tests/ui/rfc-2632-const-trait-impl/generic-bound.stderr Normal file
View file

@ -0,0 +1,11 @@
error: const `impl` for trait `Add` which is not marked with `#[const_trait]`
--> $DIR/generic-bound.rs:16:15
|
LL | impl<T> const std::ops::Add for S<T> {
| ^^^^^^^^^^^^^
|
= note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
= note: adding a non-const method body in the future would be a breaking change
error: aborting due to previous error

2
tests/ui/rfc-2632-const-trait-impl/non-const-op-in-closure-in-const.rs
View file

@ -1,4 +1,4 @@
// check-pass
// known-bug: #110395
#![feature(const_trait_impl)]

8
tests/ui/rfc-2632-const-trait-impl/non-const-op-in-closure-in-const.stderr Normal file
View file

@ -0,0 +1,8 @@
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/non-const-op-in-closure-in-const.rs:10:51
|
LL | impl<A, B> const Convert<B> for A where B: ~const From<A> {
| ^^^^^^^
error: aborting due to previous error

7
tests/ui/rfc-2632-const-trait-impl/specializing-constness.rs
View file

@ -11,13 +11,16 @@ pub trait A {
fn a() -> u32;
}
impl<T: ~const Default> const A for T {
#[const_trait]
pub trait Spec {}
impl<T: ~const Spec> const A for T {
default fn a() -> u32 {
2
}
}
impl<T: Default + Sup> A for T {
impl<T: Spec + Sup> A for T {
//~^ ERROR: cannot specialize
//~| ERROR: missing `~const` qualifier
fn a() -> u32 {

12
tests/ui/rfc-2632-const-trait-impl/specializing-constness.stderr
View file

@ -1,14 +1,14 @@
error: cannot specialize on const impl with non-const impl
--> $DIR/specializing-constness.rs:20:1
--> $DIR/specializing-constness.rs:23:1
|
LL | impl<T: Default + Sup> A for T {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
LL | impl<T: Spec + Sup> A for T {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: missing `~const` qualifier for specialization
--> $DIR/specializing-constness.rs:20:9
--> $DIR/specializing-constness.rs:23:9
|
LL | impl<T: Default + Sup> A for T {
| ^^^^^^^
LL | impl<T: Spec + Sup> A for T {
| ^^^^
error: aborting due to 2 previous errors

9
tests/ui/rfc-2632-const-trait-impl/std-impl-gate.gated.stderr Normal file
View file

@ -0,0 +1,9 @@
error[E0635]: unknown feature `const_default_impls`
--> $DIR/std-impl-gate.rs:6:46
|
LL | #![cfg_attr(gated, feature(const_trait_impl, const_default_impls))]
| ^^^^^^^^^^^^^^^^^^^
error: aborting due to previous error
For more information about this error, try `rustc --explain E0635`.

Some files were not shown because too many files have changed in this diff Show more