nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 23:04:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Auto merge of #119072 - fee1-dead-contrib:effects-fixes, r=compiler-errors

Browse Source 
Clean up `check_consts` and misc fixes

1. Remove most of the logic around erroring with trait methods. I have kept the part resolving it to a concrete impl, as that is used for const stability checks.
2. Turning on `effects` causes ICE with generic args, due to `~const Tr` when `Tr` is not `#[const_trait]` tripping up expectation in code that handles generic args, more specifically here:
8681e077b8/compiler/rustc_hir_analysis/src/astconv/generics.rs (L377)

We set `arg_count.correct` to `Err` to correctly signal that an error has already been reported.

3. UI test blesses.

Edit(fmease): Fixes #117244 (UI test is in #119099 for now).

r? compiler-errors
This commit is contained in:
bors 2023-12-23 12:26:22 +00:00
commit edcbcc768a
37 changed files with 179 additions and 302 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

187
compiler/rustc_const_eval/src/transform/check_consts/check.rs
View File

@ -5,17 +5,15 @@ use rustc_hir as hir;
use rustc_hir::def_id::DefId;
use rustc_index::bit_set::BitSet;
use rustc_infer::infer::TyCtxtInferExt;
use rustc_infer::traits::{ImplSource, Obligation, ObligationCause};
use rustc_infer::traits::ObligationCause;
use rustc_middle::mir::visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor};
use rustc_middle::mir::*;
use rustc_middle::traits::BuiltinImplSource;
use rustc_middle::ty::GenericArgs;
use rustc_middle::ty::{self, adjustment::PointerCoercion, Instance, InstanceDef, Ty, TyCtxt};
use rustc_middle::ty::{TraitRef, TypeVisitableExt};
use rustc_middle::ty::{self, adjustment::PointerCoercion, Ty, TyCtxt};
use rustc_middle::ty::{Instance, InstanceDef, TypeVisitableExt};
use rustc_mir_dataflow::Analysis;
use rustc_span::{sym, Span, Symbol};
use rustc_trait_selection::traits::error_reporting::TypeErrCtxtExt as _;
use rustc_trait_selection::traits::{self, ObligationCauseCode, ObligationCtxt, SelectionContext};
use rustc_trait_selection::traits::{self, ObligationCauseCode, ObligationCtxt};
use rustc_type_ir::visit::{TypeSuperVisitable, TypeVisitor};
use std::mem;
@ -756,143 +754,43 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
infcx.err_ctxt().report_fulfillment_errors(errors);
}
let mut is_trait = false;
// Attempting to call a trait method?
// FIXME(effects) do we need this?
if let Some(trait_id) = tcx.trait_of_item(callee) {
if tcx.trait_of_item(callee).is_some() {
trace!("attempting to call a trait method");
if !self.tcx.features().const_trait_impl {
// trait method calls are only permitted when `effects` is enabled.
// we don't error, since that is handled by typeck. We try to resolve
// the trait into the concrete method, and uses that for const stability
// checks.
// FIXME(effects) we might consider moving const stability checks to typeck as well.
if tcx.features().effects {
is_trait = true;
if let Ok(Some(instance)) =
Instance::resolve(tcx, param_env, callee, fn_args)
&& let InstanceDef::Item(def) = instance.def
{
// Resolve a trait method call to its concrete implementation, which may be in a
// `const` trait impl. This is only used for the const stability check below, since
// we want to look at the concrete impl's stability.
fn_args = instance.args;
callee = def;
}
} else {
self.check_op(ops::FnCallNonConst {
caller,
callee,
args: fn_args,
span: *fn_span,
call_source: *call_source,
feature: Some(sym::const_trait_impl),
feature: Some(if tcx.features().const_trait_impl {
sym::effects
} else {
sym::const_trait_impl
}),
});
return;
}
let trait_ref = TraitRef::from_method(tcx, trait_id, fn_args);
let obligation =
Obligation::new(tcx, ObligationCause::dummy(), param_env, trait_ref);
let implsrc = {
let infcx = tcx.infer_ctxt().build();
let mut selcx = SelectionContext::new(&infcx);
selcx.select(&obligation)
};
match implsrc {
Ok(Some(ImplSource::Param(_))) if tcx.features().effects => {
debug!(
"const_trait_impl: provided {:?} via where-clause in {:?}",
trait_ref, param_env
);
return;
}
// Closure: Fn{Once|Mut}
Ok(Some(ImplSource::Builtin(BuiltinImplSource::Misc, _)))
if trait_ref.self_ty().is_closure()
&& tcx.fn_trait_kind_from_def_id(trait_id).is_some() =>
{
let ty::Closure(closure_def_id, fn_args) = *trait_ref.self_ty().kind()
else {
unreachable!()
};
if !tcx.is_const_fn_raw(closure_def_id) {
self.check_op(ops::FnCallNonConst {
caller,
callee,
args: fn_args,
span: *fn_span,
call_source: *call_source,
feature: None,
});
return;
}
}
Ok(Some(ImplSource::UserDefined(data))) => {
let callee_name = tcx.item_name(callee);
if let hir::Constness::NotConst = tcx.constness(data.impl_def_id) {
self.check_op(ops::FnCallNonConst {
caller,
callee,
args: fn_args,
span: *fn_span,
call_source: *call_source,
feature: None,
});
return;
}
if let Some(&did) = tcx
.associated_item_def_ids(data.impl_def_id)
.iter()
.find(|did| tcx.item_name(**did) == callee_name)
{
// using internal args is ok here, since this is only
// used for the `resolve` call below
fn_args = GenericArgs::identity_for_item(tcx, did);
callee = did;
}
}
_ if !tcx.is_const_fn_raw(callee) => {
// At this point, it is only legal when the caller is in a trait
// marked with #[const_trait], and the callee is in the same trait.
let mut nonconst_call_permission = false;
if let Some(callee_trait) = tcx.trait_of_item(callee)
&& tcx.has_attr(callee_trait, sym::const_trait)
&& Some(callee_trait) == tcx.trait_of_item(caller.to_def_id())
// Can only call methods when it's `<Self as TheTrait>::f`.
&& tcx.types.self_param == fn_args.type_at(0)
{
nonconst_call_permission = true;
}
if !nonconst_call_permission {
let obligation = Obligation::new(
tcx,
ObligationCause::dummy_with_span(*fn_span),
param_env,
trait_ref,
);
// improve diagnostics by showing what failed. Our requirements are stricter this time
// as we are going to error again anyways.
let infcx = tcx.infer_ctxt().build();
if let Err(e) = implsrc {
infcx.err_ctxt().report_selection_error(
obligation.clone(),
&obligation,
&e,
);
}
self.check_op(ops::FnCallNonConst {
caller,
callee,
args: fn_args,
span: *fn_span,
call_source: *call_source,
feature: None,
});
return;
}
}
_ => {}
}
// Resolve a trait method call to its concrete implementation, which may be in a
// `const` trait impl.
let instance = Instance::resolve(tcx, param_env, callee, fn_args);
debug!("Resolving ({:?}) -> {:?}", callee, instance);
if let Ok(Some(func)) = instance {
if let InstanceDef::Item(def) = func.def {
callee = def;
}
}
}
// At this point, we are calling a function, `callee`, whose `DefId` is known...
@ -925,21 +823,16 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
return;
}
if !tcx.is_const_fn_raw(callee) {
if !tcx.is_const_default_method(callee) {
// To get to here we must have already found a const impl for the
// trait, but for it to still be non-const can be that the impl is
// using default method bodies.
self.check_op(ops::FnCallNonConst {
caller,
callee,
args: fn_args,
span: *fn_span,
call_source: *call_source,
feature: None,
});
return;
}
if !tcx.is_const_fn_raw(callee) && !is_trait {
self.check_op(ops::FnCallNonConst {
caller,
callee,
args: fn_args,
span: *fn_span,
call_source: *call_source,
feature: None,
});
return;
}
// If the `const fn` we are trying to call is not const-stable, ensure that we have

17
compiler/rustc_hir_analysis/src/astconv/mod.rs
View File

@ -378,7 +378,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
assert!(self_ty.is_none());
}
let arg_count = check_generic_arg_count(
let mut arg_count = check_generic_arg_count(
tcx,
span,
def_id,
@ -560,6 +560,14 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
inferred_params: vec![],
infer_args,
};
if let ty::BoundConstness::ConstIfConst = constness
&& generics.has_self
&& !tcx.has_attr(def_id, sym::const_trait)
{
let e = tcx.sess.emit_err(crate::errors::ConstBoundForNonConstTrait { span });
arg_count.correct =
Err(GenericArgCountMismatch { reported: Some(e), invalid_args: vec![] });
}
let args = create_args_for_parent_generic_args(
tcx,
def_id,
@ -570,13 +578,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
&mut args_ctx,
);
if let ty::BoundConstness::ConstIfConst = constness
&& generics.has_self
&& !tcx.has_attr(def_id, sym::const_trait)
{
tcx.sess.emit_err(crate::errors::ConstBoundForNonConstTrait { span });
}
(args, arg_count)
}

2
tests/ui/consts/auxiliary/closure-in-foreign-crate.rs
View File

@ -1,5 +1,5 @@
#![crate_type = "lib"]
#![feature(const_closures, const_trait_impl)]
#![feature(const_closures, const_trait_impl, effects)]
#![allow(incomplete_features)]
pub const fn test() {

29
tests/ui/consts/const-float-classify.rs
View File

@ -1,41 +1,24 @@
// compile-flags: -Zmir-opt-level=0
// known-bug: #110395
// FIXME run-pass
// run-pass
#![feature(const_float_bits_conv)]
#![feature(const_float_classify)]
#![feature(const_trait_impl)]
#![feature(const_trait_impl, effects)]
// 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 {
impl const PartialEq<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!(eq($a, $b));
assert!(eq(nop($a), nop($b)));
const _: () = assert!($a == $b);
assert!(nop($a) == nop($b));
}
};
}

11
tests/ui/consts/const-float-classify.stderr
View File

@ -1,11 +0,0 @@
error[E0015]: cannot call non-const fn `<A as MyEq<B>>::eq` in constant functions
--> $DIR/const-float-classify.rs:31:7
|
LL | x.eq(y)
| ^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0015`.

2
tests/ui/consts/const-try.stderr
View File

@ -10,6 +10,7 @@ note: impl defined here, but it is not `const`
LL | impl const Try for TryMe {
| ^^^^^^^^^^^^^^^^^^^^^^^^
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(effects)]` to the crate attributes to enable
error[E0015]: `?` cannot convert from residual of `TryMe` in constant functions
--> $DIR/const-try.rs:33:5
@ -23,6 +24,7 @@ note: impl defined here, but it is not `const`
LL | impl const FromResidual<Error> for TryMe {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(effects)]` to the crate attributes to enable
error: aborting due to 2 previous errors

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

@ -1,6 +1,6 @@
// known-bug: #110395
#![feature(const_type_id)]
#![feature(const_trait_impl)]
#![feature(const_trait_impl, effects)]
use std::any::TypeId;

38
tests/ui/consts/const_cmp_type_id.stderr
View File

@ -1,34 +1,28 @@
error[E0015]: cannot call non-const operator in constant functions
error[E0131]: `main` function is not allowed to have generic parameters
--> $DIR/const_cmp_type_id.rs:7:14
|
LL | const fn main() {
| ^ `main` cannot have generic parameters
error[E0308]: mismatched types
--> $DIR/const_cmp_type_id.rs:8:13
|
LL | assert!(TypeId::of::<u8>() == TypeId::of::<u8>());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `host`, found `true`
|
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: expected constant `host`
found constant `true`
error[E0015]: cannot call non-const operator in constant functions
error[E0308]: mismatched types
--> $DIR/const_cmp_type_id.rs:9:13
|
LL | assert!(TypeId::of::<()>() != TypeId::of::<u8>());
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `host`, found `true`
|
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
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)
= note: expected constant `host`
found constant `true`
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0015`.
Some errors have detailed explanations: E0131, E0308.
For more information about an error, try `rustc --explain E0131`.

2
tests/ui/consts/constifconst-call-in-const-position.stderr
View File

@ -14,6 +14,7 @@ LL | [0; T::a()]
| ^^^^^^
|
= note: calls in constants are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(effects)]` to the crate attributes to enable
error[E0015]: cannot call non-const fn `<T as Tr>::a` in constants
--> $DIR/constifconst-call-in-const-position.rs:16:38
@ -22,6 +23,7 @@ LL | const fn foo<T: ~const Tr>() -> [u8; T::a()] {
| ^^^^^^
|
= note: calls in constants are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(effects)]` to the crate attributes to enable
error: aborting due to 2 previous errors; 1 warning emitted

1
tests/ui/consts/issue-73976-monomorphic.stderr
View File

@ -7,6 +7,7 @@ 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
= help: add `#![feature(effects)]` to the crate attributes to enable
error: aborting due to 1 previous error

1
tests/ui/consts/issue-94675.stderr
View File

@ -15,6 +15,7 @@ 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
= help: add `#![feature(effects)]` to the crate attributes to enable
error: aborting due to 2 previous errors

1
tests/ui/generic-const-items/const-trait-impl.stderr
View File

@ -5,6 +5,7 @@ LL | const CREATE<T: Create>: T = T::create();
| ^^^^^^^^^^^
|
= note: calls in constants are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(effects)]` to the crate attributes to enable
error: aborting due to 1 previous error

2
tests/ui/rfcs/rfc-2632-const-trait-impl/call-const-trait-method-pass.stderr
View File

@ -5,6 +5,7 @@ LL | a.plus(b)
| ^^^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(effects)]` to the crate attributes to enable
error[E0015]: cannot call non-const operator in constants
--> $DIR/call-const-trait-method-pass.rs:39:22
@ -18,6 +19,7 @@ note: impl defined here, but it is not `const`
LL | impl const std::ops::Add for Int {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: calls in constants are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(effects)]` to the crate attributes to enable
error: aborting due to 2 previous errors

2
tests/ui/rfcs/rfc-2632-const-trait-impl/call.rs
View File

@ -1,6 +1,6 @@
// check-pass
#![feature(const_closures, const_trait_impl)]
#![feature(const_closures, const_trait_impl, effects)]
#![allow(incomplete_features)]
pub const _: () = {

2
tests/ui/rfcs/rfc-2632-const-trait-impl/cross-crate-default-method-body-is-const.rs
View File

@ -3,7 +3,7 @@
//
// check-pass
#![feature(const_trait_impl)]
#![feature(const_trait_impl, effects)]
// aux-build: cross-crate.rs
extern crate cross_crate;

4
tests/ui/rfcs/rfc-2632-const-trait-impl/effects/const_closure-const_trait_impl-ice-113381.rs
View File

@ -1,3 +1,5 @@
// check-pass
// FIXME(effects) this shouldn't pass
#![feature(const_closures, const_trait_impl, effects)]
#![allow(incomplete_features)]
@ -11,5 +13,5 @@ impl Foo for () {
fn main() {
(const || { (()).foo() })();
//~^ ERROR: cannot call non-const fn
// FIXME(effects) ~^ ERROR: cannot call non-const fn
}

11
tests/ui/rfcs/rfc-2632-const-trait-impl/effects/const_closure-const_trait_impl-ice-113381.stderr
View File

@ -1,11 +0,0 @@
error[E0015]: cannot call non-const fn `<() as Foo>::foo` in constant functions
--> $DIR/const_closure-const_trait_impl-ice-113381.rs:13:22
|
LL | (const || { (()).foo() })();
| ^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0015`.

1
tests/ui/rfcs/rfc-2632-const-trait-impl/generic-bound.stderr
View File

@ -10,6 +10,7 @@ note: impl defined here, but it is not `const`
LL | impl<T> const std::ops::Add for S<T> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(effects)]` to the crate attributes to enable
error: aborting due to 1 previous error

2
tests/ui/rfcs/rfc-2632-const-trait-impl/issue-102985.stderr
View File

@ -4,7 +4,9 @@ error[E0015]: cannot call non-const closure in constants
LL | n => n(),
| ^^^
|
= note: closures need an RFC before allowed to be called in constants
= note: calls in constants are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(effects)]` to the crate attributes to enable
error: aborting due to 1 previous error

2
tests/ui/rfcs/rfc-2632-const-trait-impl/issue-79450.rs
View File

@ -1,5 +1,5 @@
#![feature(const_fmt_arguments_new)]
#![feature(const_trait_impl)]
#![feature(const_trait_impl, effects)]
#[const_trait]
trait Tr {

1
tests/ui/rfcs/rfc-2632-const-trait-impl/issue-88155.stderr
View File

@ -5,6 +5,7 @@ LL | T::assoc()
| ^^^^^^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(effects)]` to the crate attributes to enable
error: aborting due to 1 previous error

1
tests/ui/rfcs/rfc-2632-const-trait-impl/match-non-const-eq.gated.stderr
View File

@ -6,6 +6,7 @@ LL | "a" => (), //FIXME [gated]~ ERROR can't compare `str` with `str` in
|
= note: `str` cannot be compared in compile-time, and therefore cannot be used in `match`es
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(effects)]` to the crate attributes to enable
error: aborting due to 1 previous error

1
tests/ui/rfcs/rfc-2632-const-trait-impl/non-const-op-const-closure-non-const-outer.stderr
View File

@ -5,6 +5,7 @@ LL | (const || { (()).foo() })();
| ^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
= help: add `#![feature(effects)]` to the crate attributes to enable
error: aborting due to 1 previous error

2
tests/ui/rfcs/rfc-2632-const-trait-impl/specializing-constness-2.rs
View File

@ -1,4 +1,4 @@
#![feature(const_trait_impl, min_specialization, rustc_attrs)]
#![feature(const_trait_impl, effects, min_specialization, rustc_attrs)]
// known-bug: #110395
#[rustc_specialization_trait]
#[const_trait]

15
tests/ui/rfcs/rfc-2632-const-trait-impl/specializing-constness-2.stderr
View File

@ -1,11 +1,12 @@
error[E0015]: cannot call non-const fn `<T as A>::a` in constant functions
--> $DIR/specializing-constness-2.rs:27:5
error[E0119]: conflicting implementations of trait `A`
--> $DIR/specializing-constness-2.rs:20:1
|
LL | <T as A>::a();
| ^^^^^^^^^^^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
LL | impl<T: Default> A for T {
| ------------------------ first implementation here
...
LL | impl<T: Default + ~const Sup> const A for T {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0015`.
For more information about this error, try `rustc --explain E0119`.

8
tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.nn.stderr
View File

@ -1,23 +1,23 @@
error: `~const` is not allowed here
--> $DIR/super-traits-fail-2.rs:11:12
--> $DIR/super-traits-fail-2.rs:10:12
|
LL | trait Bar: ~const Foo {}
| ^^^^^^
|
note: this trait is not a `#[const_trait]`, so it cannot have `~const` trait bounds
--> $DIR/super-traits-fail-2.rs:11:1
--> $DIR/super-traits-fail-2.rs:10:1
|
LL | trait Bar: ~const Foo {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/super-traits-fail-2.rs:11:19
--> $DIR/super-traits-fail-2.rs:10:19
|
LL | trait Bar: ~const Foo {}
| ^^^
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/super-traits-fail-2.rs:11:19
--> $DIR/super-traits-fail-2.rs:10:19
|
LL | trait Bar: ~const Foo {}
| ^^^

4
tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.ny.stderr
View File

@ -1,11 +1,11 @@
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/super-traits-fail-2.rs:11:19
--> $DIR/super-traits-fail-2.rs:10:19
|
LL | trait Bar: ~const Foo {}
| ^^^
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/super-traits-fail-2.rs:11:19
--> $DIR/super-traits-fail-2.rs:10:19
|
LL | trait Bar: ~const Foo {}
| ^^^

11
tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.rs
View File

@ -1,5 +1,4 @@
#![feature(const_trait_impl)]
// known-bug: #110395
#![feature(const_trait_impl, effects)]
// revisions: yy yn ny nn
#[cfg_attr(any(yy, yn), const_trait)]
@ -9,12 +8,14 @@ trait Foo {
#[cfg_attr(any(yy, ny), const_trait)]
trait Bar: ~const Foo {}
// FIXME [ny,nn]~^ ERROR: ~const can only be applied to `#[const_trait]`
// FIXME [ny,nn]~| ERROR: ~const can only be applied to `#[const_trait]`
//[ny,nn]~^ ERROR: ~const can only be applied to `#[const_trait]`
//[ny,nn]~| ERROR: ~const can only be applied to `#[const_trait]`
//[yn,nn]~^^^ ERROR: `~const` is not allowed here
const fn foo<T: Bar>(x: &T) {
x.a();
// FIXME [yn,yy]~^ ERROR the trait bound
//[yy,yn]~^ ERROR mismatched types
// FIXME(effects) diagnostic
}
fn main() {}

16
tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.yn.stderr
View File

@ -1,14 +1,24 @@
error: `~const` is not allowed here
--> $DIR/super-traits-fail-2.rs:11:12
--> $DIR/super-traits-fail-2.rs:10:12
|
LL | trait Bar: ~const Foo {}
| ^^^^^^
|
note: this trait is not a `#[const_trait]`, so it cannot have `~const` trait bounds
--> $DIR/super-traits-fail-2.rs:11:1
--> $DIR/super-traits-fail-2.rs:10:1
|
LL | trait Bar: ~const Foo {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 1 previous error
error[E0308]: mismatched types
--> $DIR/super-traits-fail-2.rs:16:5
|
LL | x.a();
| ^^^^^ expected `host`, found `true`
|
= note: expected constant `host`
found constant `true`
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0308`.

11
tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-2.yy.stderr
View File

@ -1,11 +1,12 @@
error[E0015]: cannot call non-const fn `<T as Foo>::a` in constant functions
--> $DIR/super-traits-fail-2.rs:16:7
error[E0308]: mismatched types
--> $DIR/super-traits-fail-2.rs:16:5
|
LL | x.a();
| ^^^
| ^^^^^ expected `host`, found `true`
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
= note: expected constant `host`
found constant `true`
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0015`.
For more information about this error, try `rustc --explain E0308`.

10
tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.nn.stderr
View File

@ -1,23 +1,23 @@
error: `~const` is not allowed here
--> $DIR/super-traits-fail-3.rs:13:12
--> $DIR/super-traits-fail-3.rs:12:12
|
LL | trait Bar: ~const Foo {}
| ^^^^^^
|
note: this trait is not a `#[const_trait]`, so it cannot have `~const` trait bounds
--> $DIR/super-traits-fail-3.rs:13:1
--> $DIR/super-traits-fail-3.rs:12:1
|
LL | trait Bar: ~const Foo {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/super-traits-fail-3.rs:13:19
--> $DIR/super-traits-fail-3.rs:12:19
|
LL | trait Bar: ~const Foo {}
| ^^^
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/super-traits-fail-3.rs:13:19
--> $DIR/super-traits-fail-3.rs:12:19
|
LL | trait Bar: ~const Foo {}
| ^^^
@ -25,7 +25,7 @@ LL | trait Bar: ~const Foo {}
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/super-traits-fail-3.rs:18:24
--> $DIR/super-traits-fail-3.rs:17:24
|
LL | const fn foo<T: ~const Bar>(x: &T) {
| ^^^

4
tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.ny.stderr
View File

@ -1,11 +1,11 @@
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/super-traits-fail-3.rs:13:19
--> $DIR/super-traits-fail-3.rs:12:19
|
LL | trait Bar: ~const Foo {}
| ^^^
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/super-traits-fail-3.rs:13:19
--> $DIR/super-traits-fail-3.rs:12:19
|
LL | trait Bar: ~const Foo {}
| ^^^

5
tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.rs
View File

@ -1,8 +1,7 @@
#![feature(const_trait_impl)]
#![feature(const_trait_impl, effects)]
// revisions: yy yn ny nn
//[yy] known-bug: #110395
//FIXME [yy] check-pass
//[yy] check-pass
#[cfg_attr(any(yy, yn), const_trait)]
trait Foo {

6
tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.yn.stderr
View File

@ -1,17 +1,17 @@
error: `~const` is not allowed here
--> $DIR/super-traits-fail-3.rs:13:12
--> $DIR/super-traits-fail-3.rs:12:12
|
LL | trait Bar: ~const Foo {}
| ^^^^^^
|
note: this trait is not a `#[const_trait]`, so it cannot have `~const` trait bounds
--> $DIR/super-traits-fail-3.rs:13:1
--> $DIR/super-traits-fail-3.rs:12:1
|
LL | trait Bar: ~const Foo {}
| ^^^^^^^^^^^^^^^^^^^^^^^^
error: ~const can only be applied to `#[const_trait]` traits
--> $DIR/super-traits-fail-3.rs:18:24
--> $DIR/super-traits-fail-3.rs:17:24
|
LL | const fn foo<T: ~const Bar>(x: &T) {
| ^^^

11
tests/ui/rfcs/rfc-2632-const-trait-impl/super-traits-fail-3.yy.stderr
View File

@ -1,11 +0,0 @@
error[E0015]: cannot call non-const fn `<T as Foo>::a` in constant functions
--> $DIR/super-traits-fail-3.rs:20:7
|
LL | x.a();
| ^^^
|
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0015`.

2
tests/ui/rfcs/rfc-2632-const-trait-impl/trait-default-body-stability.rs
View File

@ -1,7 +1,7 @@
// known-bug: #110395
#![feature(staged_api)]
#![feature(const_trait_impl)]
#![feature(const_trait_impl, effects)]
#![feature(const_t_try)]
#![feature(const_try)]
#![feature(try_trait_v2)]

54
tests/ui/rfcs/rfc-2632-const-trait-impl/trait-default-body-stability.stderr
View File

@ -1,29 +1,39 @@
error[E0015]: `?` cannot determine the branch of `T` in constant functions
--> $DIR/trait-default-body-stability.rs:44:9
|
LL | T?
| ^^
|
note: impl defined here, but it is not `const`
--> $DIR/trait-default-body-stability.rs:18:1
error: const `impl` for trait `Try` which is not marked with `#[const_trait]`
--> $DIR/trait-default-body-stability.rs:18:12
|
LL | impl const Try for T {
| ^^^^^^^^^^^^^^^^^^^^
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
| ^^^
|
= 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[E0015]: `?` cannot convert from residual of `T` in constant functions
--> $DIR/trait-default-body-stability.rs:44:9
|
LL | T?
| ^^
|
note: impl defined here, but it is not `const`
--> $DIR/trait-default-body-stability.rs:33:1
error: const `impl` for trait `FromResidual` which is not marked with `#[const_trait]`
--> $DIR/trait-default-body-stability.rs:33:12
|
LL | impl const FromResidual for T {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
| ^^^^^^^^^^^^
|
= 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
error[E0207]: the const parameter `host` is not constrained by the impl trait, self type, or predicates
--> $DIR/trait-default-body-stability.rs:18:6
|
LL | impl const Try for T {
| ^^^^^ unconstrained const parameter
|
= note: expressions using a const parameter must map each value to a distinct output value
= note: proving the result of expressions other than the parameter are unique is not supported
For more information about this error, try `rustc --explain E0015`.
error[E0207]: the const parameter `host` is not constrained by the impl trait, self type, or predicates
--> $DIR/trait-default-body-stability.rs:33:6
|
LL | impl const FromResidual for T {
| ^^^^^ unconstrained const parameter
|
= note: expressions using a const parameter must map each value to a distinct output value
= note: proving the result of expressions other than the parameter are unique is not supported
error: aborting due to 4 previous errors
For more information about this error, try `rustc --explain E0207`.