nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-04-13 12:36:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #126620 - oli-obk:taint_errors, r=fee1-dead

Browse Source 
Actually taint InferCtxt when a fulfillment error is emitted

And avoid checking the global error counter

fixes #122044
fixes #123255
fixes #123276
fixes #125799
This commit is contained in:
Matthias Krüger 2024-06-20 07:52:43 +02:00 committed by GitHub
commit e7be3562b7
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
42 changed files with 595 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
compiler/rustc_hir_analysis/src/check/wfcheck.rs
View File

@ -119,16 +119,7 @@ where
let errors = wfcx.select_all_or_error();
if !errors.is_empty() {
let err = infcx.err_ctxt().report_fulfillment_errors(errors);
if tcx.dcx().has_errors().is_some() {
return Err(err);
} else {
// HACK(oli-obk): tests/ui/specialization/min_specialization/specialize_on_type_error.rs
// causes an delayed bug during normalization, without reporting an error, so we need
// to act as if no error happened, in order to let our callers continue and report an
// error later in check_impl_items_against_trait.
return Ok(());
}
return Err(infcx.err_ctxt().report_fulfillment_errors(errors));
}
debug!(?assumed_wf_types);

2
compiler/rustc_hir_typeck/src/writeback.rs
View File

@ -793,7 +793,7 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx> {
}
fn report_error(&self, p: impl Into<ty::GenericArg<'tcx>>) -> ErrorGuaranteed {
if let Some(guar) = self.fcx.dcx().has_errors() {
if let Some(guar) = self.fcx.tainted_by_errors() {
guar
} else {
self.fcx

188
compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
View File

@ -2776,97 +2776,115 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
let mut this = "this bound";
let mut note = None;
let mut help = None;
if let ty::PredicateKind::Clause(clause) = predicate.kind().skip_binder()
&& let ty::ClauseKind::Trait(trait_pred) = clause
{
let def_id = trait_pred.def_id();
let visible_item = if let Some(local) = def_id.as_local() {
// Check for local traits being reachable.
let vis = &tcx.resolutions(()).effective_visibilities;
// Account for non-`pub` traits in the root of the local crate.
let is_locally_reachable = tcx.parent(def_id).is_crate_root();
vis.is_reachable(local) || is_locally_reachable
} else {
// Check for foreign traits being reachable.
tcx.visible_parent_map(()).get(&def_id).is_some()
};
if tcx.is_lang_item(def_id, LangItem::Sized) {
// Check if this is an implicit bound, even in foreign crates.
if tcx
.generics_of(item_def_id)
.own_params
.iter()
.any(|param| tcx.def_span(param.def_id) == span)
{
a = "an implicit `Sized`";
this = "the implicit `Sized` requirement on this type parameter";
}
if let Some(hir::Node::TraitItem(hir::TraitItem {
generics,
kind: hir::TraitItemKind::Type(bounds, None),
..
})) = tcx.hir().get_if_local(item_def_id)
// Do not suggest relaxing if there is an explicit `Sized` obligation.
&& !bounds.iter()
.filter_map(|bound| bound.trait_ref())
.any(|tr| tr.trait_def_id() == tcx.lang_items().sized_trait())
{
let (span, separator) = if let [.., last] = bounds {
(last.span().shrink_to_hi(), " +")
if let ty::PredicateKind::Clause(clause) = predicate.kind().skip_binder() {
match clause {
ty::ClauseKind::Trait(trait_pred) => {
let def_id = trait_pred.def_id();
let visible_item = if let Some(local) = def_id.as_local() {
// Check for local traits being reachable.
let vis = &tcx.resolutions(()).effective_visibilities;
// Account for non-`pub` traits in the root of the local crate.
let is_locally_reachable = tcx.parent(def_id).is_crate_root();
vis.is_reachable(local) || is_locally_reachable
} else {
(generics.span.shrink_to_hi(), ":")
// Check for foreign traits being reachable.
tcx.visible_parent_map(()).get(&def_id).is_some()
};
err.span_suggestion_verbose(
span,
"consider relaxing the implicit `Sized` restriction",
format!("{separator} ?Sized"),
Applicability::MachineApplicable,
);
if tcx.is_lang_item(def_id, LangItem::Sized) {
// Check if this is an implicit bound, even in foreign crates.
if tcx
.generics_of(item_def_id)
.own_params
.iter()
.any(|param| tcx.def_span(param.def_id) == span)
{
a = "an implicit `Sized`";
this =
"the implicit `Sized` requirement on this type parameter";
}
if let Some(hir::Node::TraitItem(hir::TraitItem {
generics,
kind: hir::TraitItemKind::Type(bounds, None),
..
})) = tcx.hir().get_if_local(item_def_id)
// Do not suggest relaxing if there is an explicit `Sized` obligation.
&& !bounds.iter()
.filter_map(|bound| bound.trait_ref())
.any(|tr| tr.trait_def_id() == tcx.lang_items().sized_trait())
{
let (span, separator) = if let [.., last] = bounds {
(last.span().shrink_to_hi(), " +")
} else {
(generics.span.shrink_to_hi(), ":")
};
err.span_suggestion_verbose(
span,
"consider relaxing the implicit `Sized` restriction",
format!("{separator} ?Sized"),
Applicability::MachineApplicable,
);
}
}
if let DefKind::Trait = tcx.def_kind(item_def_id)
&& !visible_item
{
note = Some(format!(
"`{short_item_name}` is a \"sealed trait\", because to implement it \
you also need to implement `{}`, which is not accessible; this is \
usually done to force you to use one of the provided types that \
already implement it",
with_no_trimmed_paths!(tcx.def_path_str(def_id)),
));
let impls_of = tcx.trait_impls_of(def_id);
let impls = impls_of
.non_blanket_impls()
.values()
.flatten()
.chain(impls_of.blanket_impls().iter())
.collect::<Vec<_>>();
if !impls.is_empty() {
let len = impls.len();
let mut types = impls
.iter()
.map(|t| {
with_no_trimmed_paths!(format!(
" {}",
tcx.type_of(*t).instantiate_identity(),
))
})
.collect::<Vec<_>>();
let post = if types.len() > 9 {
types.truncate(8);
format!("\nand {} others", len - 8)
} else {
String::new()
};
help = Some(format!(
"the following type{} implement{} the trait:\n{}{post}",
pluralize!(len),
if len == 1 { "s" } else { "" },
types.join("\n"),
));
}
}
}
}
if let DefKind::Trait = tcx.def_kind(item_def_id)
&& !visible_item
{
note = Some(format!(
"`{short_item_name}` is a \"sealed trait\", because to implement it \
you also need to implement `{}`, which is not accessible; this is \
usually done to force you to use one of the provided types that \
already implement it",
with_no_trimmed_paths!(tcx.def_path_str(def_id)),
));
let impls_of = tcx.trait_impls_of(def_id);
let impls = impls_of
.non_blanket_impls()
.values()
.flatten()
.chain(impls_of.blanket_impls().iter())
.collect::<Vec<_>>();
if !impls.is_empty() {
let len = impls.len();
let mut types = impls
.iter()
.map(|t| {
with_no_trimmed_paths!(format!(
" {}",
tcx.type_of(*t).instantiate_identity(),
))
})
.collect::<Vec<_>>();
let post = if types.len() > 9 {
types.truncate(8);
format!("\nand {} others", len - 8)
ty::ClauseKind::ConstArgHasType(..) => {
let descr =
format!("required by a const generic parameter in `{item_name}`");
if span.is_visible(sm) {
let msg = format!(
"required by this const generic parameter in `{short_item_name}`"
);
multispan.push_span_label(span, msg);
err.span_note(multispan, descr);
} else {
String::new()
};
help = Some(format!(
"the following type{} implement{} the trait:\n{}{post}",
pluralize!(len),
if len == 1 { "s" } else { "" },
types.join("\n"),
));
err.span_note(tcx.def_span(item_def_id), descr);
}
return;
}
_ => (),
}
};
}
let descr = format!("required by {a} bound in `{item_name}`");
if span.is_visible(sm) {
let msg = format!("required by {this} in `{short_item_name}`");

23
compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
View File

@ -179,6 +179,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
for (error, suppressed) in iter::zip(&errors, &is_suppressed) {
if !suppressed && error.obligation.cause.span.from_expansion() == from_expansion {
let guar = self.report_fulfillment_error(error);
self.infcx.set_tainted_by_errors(guar);
reported = Some(guar);
// We want to ignore desugarings here: spans are equivalent even
// if one is the result of a desugaring and the other is not.
@ -2686,22 +2687,14 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
}
}
// Given some `ConstArgHasType(?x, usize)`, we should not emit an error such as
// "type annotations needed: cannot satisfy the constant `_` has type `usize`"
// Instead we should emit a normal error suggesting the user to turbofish the
// const parameter that is currently being inferred. Unfortunately we cannot
// nicely emit such an error so we delay an ICE incase nobody else reports it
// for us.
ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(ct, ty)) => {
return self.tcx.sess.dcx().span_delayed_bug(
ty::PredicateKind::Clause(ty::ClauseKind::ConstArgHasType(ct, ..)) => self
.emit_inference_failure_err(
obligation.cause.body_id,
span,
format!(
"`ambiguous ConstArgHasType({:?}, {:?}) unaccompanied by inference error`",
ct, ty
),
);
}
ct.into(),
ErrorCode::E0284,
true,
),
ty::PredicateKind::NormalizesTo(ty::NormalizesTo { alias, term })
if term.is_infer() =>
{

38
tests/crashes/122044.rs
View File

@ -1,38 +0,0 @@
//@ known-bug: #122044
use std::hint::black_box;
trait Func {
type Ret: Id;
}
trait Id {
type Assoc;
}
impl Id for u32 {}
impl Id for u32 {}
impl<F: FnOnce() -> R, R: Id> Func for F {
type Ret = R;
}
fn bar() -> impl Copy + Id {
0u32
}
struct Foo<T: Func> {
_func: T,
value: Option<<<T as Func>::Ret as Id>::Assoc>,
}
fn main() {
let mut fn_def = black_box(Foo {
_func: bar,
value: None,
});
let fn_ptr = black_box(Foo {
_func: bar as fn() -> _,
value: None,
});
fn_def.value = fn_ptr.value;
}

13
tests/crashes/123255.rs
View File

@ -1,13 +0,0 @@
//@ known-bug: rust-lang/rust#123255
//@ edition:2021
#![crate_type = "lib"]
pub fn a() {}
mod handlers {
pub struct C(&());
pub fn c() -> impl Fn() -> C {
let a1 = ();
|| C((crate::a(), a1).into())
}
}

2
tests/incremental/const-generics/issue-64087.rs
View File

@ -6,4 +6,6 @@ fn combinator<T, const S: usize>() -> [T; S] {}
fn main() {
combinator().into_iter();
//[cfail1]~^ ERROR type annotations needed
//[cfail1]~| ERROR type annotations needed
//[cfail1]~| ERROR type annotations needed
}

1
tests/ui/const-generics/defaults/doesnt_infer.rs
View File

@ -12,4 +12,5 @@ fn main() {
let foo = Foo::<1>::foo();
let foo = Foo::foo();
//~^ ERROR type annotations needed for `Foo<_>`
//~| ERROR type annotations needed
}

31
tests/ui/const-generics/defaults/doesnt_infer.stderr
View File

@ -1,14 +1,37 @@
error[E0282]: type annotations needed for `Foo<_>`
error[E0284]: type annotations needed for `Foo<_>`
--> $DIR/doesnt_infer.rs:13:9
|
LL | let foo = Foo::foo();
| ^^^
| ^^^ ---------- type must be known at this point
|
note: required by a const generic parameter in `Foo::<N>::foo`
--> $DIR/doesnt_infer.rs:5:6
|
LL | impl<const N: u32> Foo<N> {
| ^^^^^^^^^^^^ required by this const generic parameter in `Foo::<N>::foo`
LL | fn foo() -> Self {
| --- required by a bound in this associated function
help: consider giving `foo` an explicit type, where the value of const parameter `N` is specified
|
LL | let foo: Foo<N> = Foo::foo();
| ++++++++
error: aborting due to 1 previous error
error[E0284]: type annotations needed for `Foo<_>`
--> $DIR/doesnt_infer.rs:13:9
|
LL | let foo = Foo::foo();
| ^^^ --- type must be known at this point
|
note: required by a const generic parameter in `Foo`
--> $DIR/doesnt_infer.rs:3:12
|
LL | struct Foo<const N: u32 = 2>;
| ^^^^^^^^^^^^^^^^ required by this const generic parameter in `Foo`
help: consider giving `foo` an explicit type, where the value of const parameter `N` is specified
|
LL | let foo: Foo<N> = Foo::foo();
| ++++++++
For more information about this error, try `rustc --explain E0282`.
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0284`.

9
tests/ui/const-generics/defaults/rp_impl_trait_fail.stderr
View File

@ -31,12 +31,17 @@ LL | 1_u64
|
= help: the trait `Traitor<1, 2>` is implemented for `u64`
error[E0282]: type annotations needed
error[E0284]: type annotations needed
--> $DIR/rp_impl_trait_fail.rs:28:5
|
LL | uwu();
| ^^^ cannot infer the value of the const parameter `N` declared on the function `uwu`
|
note: required by a const generic parameter in `uwu`
--> $DIR/rp_impl_trait_fail.rs:16:8
|
LL | fn uwu<const N: u8>() -> impl Traitor<N> {
| ^^^^^^^^^^^ required by this const generic parameter in `uwu`
help: consider specifying the generic argument
|
LL | uwu::<N>();
@ -44,5 +49,5 @@ LL | uwu::<N>();
error: aborting due to 4 previous errors
Some errors have detailed explanations: E0277, E0282.
Some errors have detailed explanations: E0277, E0284.
For more information about an error, try `rustc --explain E0277`.

1
tests/ui/const-generics/generic_arg_infer/issue-91614.rs
View File

@ -5,4 +5,5 @@ use std::simd::Mask;
fn main() {
let y = Mask::<_, _>::splat(false);
//~^ ERROR: type annotations needed
//~| ERROR type annotations needed
}

30
tests/ui/const-generics/generic_arg_infer/issue-91614.stderr
View File

@ -1,23 +1,29 @@
error[E0283]: type annotations needed for `Mask<_, _>`
error[E0284]: type annotations needed for `Mask<_, _>`
--> $DIR/issue-91614.rs:6:9
|
LL | let y = Mask::<_, _>::splat(false);
| ^ -------------------------- type must be known at this point
|
= note: cannot satisfy `_: MaskElement`
= help: the following types implement trait `MaskElement`:
i16
i32
i64
i8
isize
note: required by a bound in `Mask::<T, N>::splat`
note: required by a const generic parameter in `Mask::<T, N>::splat`
--> $SRC_DIR/core/src/../../portable-simd/crates/core_simd/src/masks.rs:LL:COL
help: consider giving `y` an explicit type, where the type for type parameter `T` is specified
help: consider giving `y` an explicit type, where the value of const parameter `N` is specified
|
LL | let y: Mask<T, N> = Mask::<_, _>::splat(false);
| ++++++++++++
error: aborting due to 1 previous error
error[E0284]: type annotations needed for `Mask<_, _>`
--> $DIR/issue-91614.rs:6:9
|
LL | let y = Mask::<_, _>::splat(false);
| ^ ------------ type must be known at this point
|
note: required by a const generic parameter in `Mask`
--> $SRC_DIR/core/src/../../portable-simd/crates/core_simd/src/masks.rs:LL:COL
help: consider giving `y` an explicit type, where the value of const parameter `N` is specified
|
LL | let y: Mask<T, N> = Mask::<_, _>::splat(false);
| ++++++++++++
For more information about this error, try `rustc --explain E0283`.
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0284`.

33
tests/ui/const-generics/generic_const_exprs/issue-62504.full.stderr
View File

@ -18,18 +18,41 @@ help: try adding a `where` bound
LL | pub const fn new() -> Self where [(); Self::SIZE]: {
| +++++++++++++++++++++++
error[E0282]: type annotations needed for `ArrayHolder<_>`
error[E0284]: type annotations needed for `ArrayHolder<_>`
--> $DIR/issue-62504.rs:26:9
|
LL | let mut array = ArrayHolder::new();
| ^^^^^^^^^
| ^^^^^^^^^ ------------------ type must be known at this point
|
note: required by a const generic parameter in `ArrayHolder::<X>::new`
--> $DIR/issue-62504.rs:16:6
|
LL | impl<const X: usize> ArrayHolder<X> {
| ^^^^^^^^^^^^^^ required by this const generic parameter in `ArrayHolder::<X>::new`
LL | pub const fn new() -> Self {
| --- required by a bound in this associated function
help: consider giving `array` an explicit type, where the value of const parameter `X` is specified
|
LL | let mut array: ArrayHolder<X> = ArrayHolder::new();
| ++++++++++++++++
error: aborting due to 3 previous errors
error[E0284]: type annotations needed for `ArrayHolder<_>`
--> $DIR/issue-62504.rs:26:9
|
LL | let mut array = ArrayHolder::new();
| ^^^^^^^^^ ----------- type must be known at this point
|
note: required by a const generic parameter in `ArrayHolder`
--> $DIR/issue-62504.rs:14:20
|
LL | struct ArrayHolder<const X: usize>([u32; X]);
| ^^^^^^^^^^^^^^ required by this const generic parameter in `ArrayHolder`
help: consider giving `array` an explicit type, where the value of const parameter `X` is specified
|
LL | let mut array: ArrayHolder<X> = ArrayHolder::new();
| ++++++++++++++++
Some errors have detailed explanations: E0282, E0308.
For more information about an error, try `rustc --explain E0282`.
error: aborting due to 4 previous errors
Some errors have detailed explanations: E0284, E0308.
For more information about an error, try `rustc --explain E0284`.

33
tests/ui/const-generics/generic_const_exprs/issue-62504.min.stderr
View File

@ -22,18 +22,41 @@ note: tuple struct defined here
LL | struct ArrayHolder<const X: usize>([u32; X]);
| ^^^^^^^^^^^
error[E0282]: type annotations needed for `ArrayHolder<_>`
error[E0284]: type annotations needed for `ArrayHolder<_>`
--> $DIR/issue-62504.rs:26:9
|
LL | let mut array = ArrayHolder::new();
| ^^^^^^^^^
| ^^^^^^^^^ ------------------ type must be known at this point
|
note: required by a const generic parameter in `ArrayHolder::<X>::new`
--> $DIR/issue-62504.rs:16:6
|
LL | impl<const X: usize> ArrayHolder<X> {
| ^^^^^^^^^^^^^^ required by this const generic parameter in `ArrayHolder::<X>::new`
LL | pub const fn new() -> Self {
| --- required by a bound in this associated function
help: consider giving `array` an explicit type, where the value of const parameter `X` is specified
|
LL | let mut array: ArrayHolder<X> = ArrayHolder::new();
| ++++++++++++++++
error: aborting due to 3 previous errors
error[E0284]: type annotations needed for `ArrayHolder<_>`
--> $DIR/issue-62504.rs:26:9
|
LL | let mut array = ArrayHolder::new();
| ^^^^^^^^^ ----------- type must be known at this point
|
note: required by a const generic parameter in `ArrayHolder`
--> $DIR/issue-62504.rs:14:20
|
LL | struct ArrayHolder<const X: usize>([u32; X]);
| ^^^^^^^^^^^^^^ required by this const generic parameter in `ArrayHolder`
help: consider giving `array` an explicit type, where the value of const parameter `X` is specified
|
LL | let mut array: ArrayHolder<X> = ArrayHolder::new();
| ++++++++++++++++
Some errors have detailed explanations: E0282, E0308.
For more information about an error, try `rustc --explain E0282`.
error: aborting due to 4 previous errors
Some errors have detailed explanations: E0284, E0308.
For more information about an error, try `rustc --explain E0284`.

1
tests/ui/const-generics/generic_const_exprs/issue-62504.rs
View File

@ -25,4 +25,5 @@ impl<const X: usize> ArrayHolder<X> {
fn main() {
let mut array = ArrayHolder::new();
//~^ ERROR: type annotations needed
//~| ERROR type annotations needed
}

1
tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.rs
View File

@ -18,4 +18,5 @@ fn use_dyn<const N: usize>(v: &dyn Foo<N>) where [u8; N + 1]: Sized {
fn main() {
use_dyn(&());
//~^ ERROR type annotations needed
//~| ERROR type annotations needed
}

29
tests/ui/const-generics/generic_const_exprs/object-safety-ok-infer-err.stderr
View File

@ -4,16 +4,37 @@ error[E0284]: type annotations needed
LL | use_dyn(&());
| ^^^^^^^ cannot infer the value of the const parameter `N` declared on the function `use_dyn`
|
note: required by a bound in `use_dyn`
--> $DIR/object-safety-ok-infer-err.rs:14:55
note: required by a const generic parameter in `use_dyn`
--> $DIR/object-safety-ok-infer-err.rs:14:12
|
LL | fn use_dyn<const N: usize>(v: &dyn Foo<N>) where [u8; N + 1]: Sized {
| ^^^^^ required by this bound in `use_dyn`
| ^^^^^^^^^^^^^^ required by this const generic parameter in `use_dyn`
help: consider specifying the generic argument
|
LL | use_dyn::<N>(&());
| +++++
error: aborting due to 1 previous error
error[E0284]: type annotations needed
--> $DIR/object-safety-ok-infer-err.rs:19:5
|
LL | use_dyn(&());
| ^^^^^^^ --- type must be known at this point
| |
| cannot infer the value of the const parameter `N` declared on the function `use_dyn`
|
note: required for `()` to implement `Foo<_>`
--> $DIR/object-safety-ok-infer-err.rs:8:22
|
LL | impl<const N: usize> Foo<N> for () {
| -------------- ^^^^^^ ^^
| |
| unsatisfied trait bound introduced here
= note: required for the cast from `&()` to `&dyn Foo<_>`
help: consider specifying the generic argument
|
LL | use_dyn::<N>(&());
| +++++
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0284`.

9
tests/ui/const-generics/infer/cannot-infer-const-args.stderr
View File

@ -1,9 +1,14 @@
error[E0282]: type annotations needed
error[E0284]: type annotations needed
--> $DIR/cannot-infer-const-args.rs:6:5
|
LL | foo();
| ^^^ cannot infer the value of the const parameter `X` declared on the function `foo`
|
note: required by a const generic parameter in `foo`
--> $DIR/cannot-infer-const-args.rs:1:8
|
LL | fn foo<const X: usize>() -> usize {
| ^^^^^^^^^^^^^^ required by this const generic parameter in `foo`
help: consider specifying the generic argument
|
LL | foo::<X>();
@ -11,4 +16,4 @@ LL | foo::<X>();
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0282`.
For more information about this error, try `rustc --explain E0284`.

5
tests/ui/const-generics/infer/issue-77092.rs
View File

@ -1,14 +1,15 @@
use std::convert::TryInto;
fn take_array_from_mut<T, const N: usize>(data: &mut [T], start: usize) -> &mut [T; N] {
(&mut data[start .. start + N]).try_into().unwrap()
(&mut data[start..start + N]).try_into().unwrap()
}
fn main() {
let mut arr = [0, 1, 2, 3, 4, 5, 6, 7, 8];
for i in 1 .. 4 {
for i in 1..4 {
println!("{:?}", take_array_from_mut(&mut arr, i));
//~^ ERROR type annotations needed
//~| ERROR type annotations needed
}
}

29
tests/ui/const-generics/infer/issue-77092.stderr
View File

@ -1,14 +1,37 @@
error[E0282]: type annotations needed
error[E0284]: type annotations needed
--> $DIR/issue-77092.rs:11:26
|
LL | println!("{:?}", take_array_from_mut(&mut arr, i));
| ^^^^^^^^^^^^^^^^^^^ cannot infer the value of the const parameter `N` declared on the function `take_array_from_mut`
|
note: required by a const generic parameter in `take_array_from_mut`
--> $DIR/issue-77092.rs:3:27
|
LL | fn take_array_from_mut<T, const N: usize>(data: &mut [T], start: usize) -> &mut [T; N] {
| ^^^^^^^^^^^^^^ required by this const generic parameter in `take_array_from_mut`
help: consider specifying the generic arguments
|
LL | println!("{:?}", take_array_from_mut::<i32, N>(&mut arr, i));
| ++++++++++
error: aborting due to 1 previous error
error[E0284]: type annotations needed
--> $DIR/issue-77092.rs:11:26
|
LL | println!("{:?}", take_array_from_mut(&mut arr, i));
| ---- ^^^^^^^^^^^^^^^^^^^ cannot infer the value of the const parameter `N` declared on the function `take_array_from_mut`
| |
| type must be known at this point
|
= note: required for `[i32; _]` to implement `Debug`
= note: 1 redundant requirement hidden
= note: required for `&mut [i32; _]` to implement `Debug`
note: required by a bound in `core::fmt::rt::Argument::<'a>::new_debug`
--> $SRC_DIR/core/src/fmt/rt.rs:LL:COL
help: consider specifying the generic arguments
|
LL | println!("{:?}", take_array_from_mut::<i32, N>(&mut arr, i));
| ++++++++++
For more information about this error, try `rustc --explain E0282`.
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0284`.

9
tests/ui/const-generics/infer/method-chain.stderr
View File

@ -1,9 +1,14 @@
error[E0282]: type annotations needed
error[E0284]: type annotations needed
--> $DIR/method-chain.rs:15:33
|
LL | Foo.bar().bar().bar().bar().baz();
| ^^^ cannot infer the value of the const parameter `N` declared on the method `baz`
|
note: required by a const generic parameter in `Foo::baz`
--> $DIR/method-chain.rs:8:12
|
LL | fn baz<const N: usize>(self) -> Foo {
| ^^^^^^^^^^^^^^ required by this const generic parameter in `Foo::baz`
help: consider specifying the generic argument
|
LL | Foo.bar().bar().bar().bar().baz::<N>();
@ -11,4 +16,4 @@ LL | Foo.bar().bar().bar().bar().baz::<N>();
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0282`.
For more information about this error, try `rustc --explain E0284`.

9
tests/ui/const-generics/infer/one-param-uninferred.stderr
View File

@ -1,9 +1,14 @@
error[E0282]: type annotations needed
error[E0284]: type annotations needed
--> $DIR/one-param-uninferred.rs:9:23
|
LL | let _: [u8; 17] = foo();
| ^^^ cannot infer the value of the const parameter `M` declared on the function `foo`
|
note: required by a const generic parameter in `foo`
--> $DIR/one-param-uninferred.rs:2:24
|
LL | fn foo<const N: usize, const M: usize>() -> [u8; N] {
| ^^^^^^^^^^^^^^ required by this const generic parameter in `foo`
help: consider specifying the generic arguments
|
LL | let _: [u8; 17] = foo::<17, M>();
@ -11,4 +16,4 @@ LL | let _: [u8; 17] = foo::<17, M>();
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0282`.
For more information about this error, try `rustc --explain E0284`.

1
tests/ui/const-generics/infer/uninferred-consts.rs
View File

@ -8,4 +8,5 @@ impl Foo {
fn main() {
Foo.foo();
//~^ ERROR type annotations needed
//~| ERROR type annotations needed
}

27
tests/ui/const-generics/infer/uninferred-consts.stderr
View File

@ -1,14 +1,35 @@
error[E0282]: type annotations needed
error[E0284]: type annotations needed
--> $DIR/uninferred-consts.rs:9:9
|
LL | Foo.foo();
| ^^^ cannot infer the value of the const parameter `A` declared on the method `foo`
|
note: required by a const generic parameter in `Foo::foo`
--> $DIR/uninferred-consts.rs:6:12
|
LL | fn foo<const A: usize, const B: usize>(self) {}
| ^^^^^^^^^^^^^^ required by this const generic parameter in `Foo::foo`
help: consider specifying the generic arguments
|
LL | Foo.foo::<A, B>();
| ++++++++
error: aborting due to 1 previous error
error[E0284]: type annotations needed
--> $DIR/uninferred-consts.rs:9:9
|
LL | Foo.foo();
| ^^^ cannot infer the value of the const parameter `B` declared on the method `foo`
|
note: required by a const generic parameter in `Foo::foo`
--> $DIR/uninferred-consts.rs:6:28
|
LL | fn foo<const A: usize, const B: usize>(self) {}
| ^^^^^^^^^^^^^^ required by this const generic parameter in `Foo::foo`
help: consider specifying the generic arguments
|
LL | Foo.foo::<A, B>();
| ++++++++
For more information about this error, try `rustc --explain E0282`.
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0284`.

4
tests/crashes/125799.rs → tests/ui/const-generics/mistyped_const_in_pat.rs
View File

@ -1,4 +1,5 @@
//@ known-bug: rust-lang/rust#125799
//! Used to ICE rust-lang/rust#125799 due to `isize` != `()`
//! not being detected early due to the conflicting impls.
//@ only-x86_64
trait Trait<T> {
@ -10,6 +11,7 @@ impl<T> Trait<T> for Vec<T> {
}
impl Trait<u8> for Vec<u8> {}
//~^ ERROR: conflicting implementations
const BAR: <Vec<u8> as Trait<u8>>::Assoc = 3;

12
tests/ui/const-generics/mistyped_const_in_pat.stderr Normal file
View File

@ -0,0 +1,12 @@
error[E0119]: conflicting implementations of trait `Trait<u8>` for type `Vec<u8>`
--> $DIR/mistyped_const_in_pat.rs:13:1
|
LL | impl<T> Trait<T> for Vec<T> {
| --------------------------- first implementation here
...
LL | impl Trait<u8> for Vec<u8> {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `Vec<u8>`
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0119`.

6
tests/ui/const-generics/parent_generics_of_encoding_impl_trait.stderr
View File

@ -4,11 +4,11 @@ error[E0284]: type annotations needed
LL | generics_of_parent_impl_trait::foo([()]);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot infer the value of const parameter `N` declared on the function `foo`
|
note: required by a bound in `foo`
--> $DIR/auxiliary/generics_of_parent_impl_trait.rs:5:48
note: required by a const generic parameter in `foo`
--> $DIR/auxiliary/generics_of_parent_impl_trait.rs:5:12
|
LL | pub fn foo<const N: usize>(foo: impl Into<[(); N + 1]>) {
| ^^^^^ required by this bound in `foo`
| ^^^^^^^^^^^^^^ required by this const generic parameter in `foo`
error: aborting due to 1 previous error

4
tests/ui/const-generics/type_mismatch.stderr
View File

@ -4,11 +4,11 @@ error: the constant `N` is not of type `u8`
LL | bar::<N>()
| ^ expected `u8`, found `usize`
|
note: required by a bound in `bar`
note: required by a const generic parameter in `bar`
--> $DIR/type_mismatch.rs:6:8
|
LL | fn bar<const N: u8>() -> [u8; N] {}
| ^^^^^^^^^^^ required by this bound in `bar`
| ^^^^^^^^^^^ required by this const generic parameter in `bar`
error[E0308]: mismatched types
--> $DIR/type_mismatch.rs:6:26

9
tests/ui/const-generics/unify_with_nested_expr.stderr
View File

@ -4,14 +4,11 @@ error[E0284]: type annotations needed
LL | bar();
| ^^^ cannot infer the value of the const parameter `N` declared on the function `bar`
|
note: required by a bound in `bar`
--> $DIR/unify_with_nested_expr.rs:14:10
note: required by a const generic parameter in `bar`
--> $DIR/unify_with_nested_expr.rs:12:8
|
LL | fn bar<const N: usize>()
| --- required by a bound in this function
LL | where
LL | [(); N + 1]:,
| ^^^^^ required by this bound in `bar`
| ^^^^^^^^^^^^^^ required by this const generic parameter in `bar`
help: consider specifying the generic argument
|
LL | bar::<N>();

16
tests/ui/impl-trait/upvar_captures.rs Normal file
View File

@ -0,0 +1,16 @@
//! This test used to ICE: rust-lang/rust#123255
//! Because the errors on `C` were ignored when trying
//! to compute the MIR of the closure, which thus ended
//! up with broken upvars.
//@ edition:2021
#![crate_type = "lib"]
pub fn a() {}
mod handlers {
pub struct C(&()); //~ ERROR missing lifetime specifier
pub fn c() -> impl Fn() -> C {
let a1 = ();
|| C((crate::a(), a1).into())
}
}

14
tests/ui/impl-trait/upvar_captures.stderr Normal file
View File

@ -0,0 +1,14 @@
error[E0106]: missing lifetime specifier
--> $DIR/upvar_captures.rs:11:18
|
LL | pub struct C(&());
| ^ expected named lifetime parameter
|
help: consider introducing a named lifetime parameter
|
LL | pub struct C<'a>(&'a ());
| ++++ ++
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0106`.

11
tests/ui/inference/issue-83606.stderr
View File

@ -1,9 +1,14 @@
error[E0282]: type annotations needed for `[usize; _]`
error[E0284]: type annotations needed for `[usize; _]`
--> $DIR/issue-83606.rs:8:9
|
LL | let _ = foo("foo");
| ^
| ^ ---------- type must be known at this point
|
note: required by a const generic parameter in `foo`
--> $DIR/issue-83606.rs:3:8
|
LL | fn foo<const N: usize>(_: impl std::fmt::Display) -> [usize; N] {
| ^^^^^^^^^^^^^^ required by this const generic parameter in `foo`
help: consider giving this pattern a type, where the value of const parameter `N` is specified
|
LL | let _: [usize; N] = foo("foo");
@ -11,4 +16,4 @@ LL | let _: [usize; N] = foo("foo");
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0282`.
For more information about this error, try `rustc --explain E0284`.

2
tests/ui/issues/issue-98299.rs
View File

@ -3,6 +3,8 @@ use std::convert::TryFrom;
pub fn test_usage(p: ()) {
SmallCString::try_from(p).map(|cstr| cstr);
//~^ ERROR: type annotations needed
//~| ERROR: type annotations needed
//~| ERROR: type annotations needed
}
pub struct SmallCString<const N: usize> {}

55
tests/ui/issues/issue-98299.stderr
View File

@ -1,14 +1,61 @@
error[E0282]: type annotations needed for `SmallCString<_>`
error[E0284]: type annotations needed for `SmallCString<_>`
--> $DIR/issue-98299.rs:4:36
|
LL | SmallCString::try_from(p).map(|cstr| cstr);
| ^^^^
| ------------ ^^^^
| |
| type must be known at this point
|
note: required by a const generic parameter in `SmallCString`
--> $DIR/issue-98299.rs:10:25
|
LL | pub struct SmallCString<const N: usize> {}
| ^^^^^^^^^^^^^^ required by this const generic parameter in `SmallCString`
help: consider giving this closure parameter an explicit type, where the value of const parameter `N` is specified
|
LL | SmallCString::try_from(p).map(|cstr: SmallCString<N>| cstr);
| +++++++++++++++++
error: aborting due to 1 previous error
error[E0284]: type annotations needed for `SmallCString<_>`
--> $DIR/issue-98299.rs:4:36
|
LL | SmallCString::try_from(p).map(|cstr| cstr);
| ------------ ^^^^
| |
| type must be known at this point
|
note: required for `SmallCString<_>` to implement `TryFrom<()>`
--> $DIR/issue-98299.rs:12:22
|
LL | impl<const N: usize> TryFrom<()> for SmallCString<N> {
| -------------- ^^^^^^^^^^^ ^^^^^^^^^^^^^^^
| |
| unsatisfied trait bound introduced here
help: consider giving this closure parameter an explicit type, where the value of const parameter `N` is specified
|
LL | SmallCString::try_from(p).map(|cstr: SmallCString<N>| cstr);
| +++++++++++++++++
For more information about this error, try `rustc --explain E0282`.
error[E0284]: type annotations needed for `SmallCString<_>`
--> $DIR/issue-98299.rs:4:36
|
LL | SmallCString::try_from(p).map(|cstr| cstr);
| ------------------------- ^^^^
| |
| type must be known at this point
|
note: required for `SmallCString<_>` to implement `TryFrom<()>`
--> $DIR/issue-98299.rs:12:22
|
LL | impl<const N: usize> TryFrom<()> for SmallCString<N> {
| -------------- ^^^^^^^^^^^ ^^^^^^^^^^^^^^^
| |
| unsatisfied trait bound introduced here
help: consider giving this closure parameter an explicit type, where the value of const parameter `N` is specified
|
LL | SmallCString::try_from(p).map(|cstr: SmallCString<N>| cstr);
| +++++++++++++++++
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0284`.

34
tests/ui/rfcs/rfc-2632-const-trait-impl/const_derives/derive-const-use.stderr
View File

@ -37,6 +37,19 @@ error[E0207]: the const parameter `host` is not constrained by the impl trait, s
= 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[E0284]: type annotations needed
--> $DIR/derive-const-use.rs:18:35
|
LL | const _: () = assert!(S((), A) == S::default());
| ^^^^^^^^^^^^ cannot infer the value of the constant `_`
|
note: required for `S` to implement `Default`
--> $DIR/derive-const-use.rs:15:16
|
LL | #[derive_const(Default, PartialEq)]
| ^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
= note: this error originates in the derive macro `Default` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0308]: mismatched types
--> $DIR/derive-const-use.rs:16:14
|
@ -49,7 +62,24 @@ LL | pub struct S((), A);
found constant `true`
= 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
error[E0284]: type annotations needed
--> $DIR/derive-const-use.rs:16:18
|
LL | #[derive_const(Default, PartialEq)]
| ------- in this derive macro expansion
LL | pub struct S((), A);
| ^ cannot infer the value of the constant `_`
|
note: required for `A` to implement `Default`
--> $DIR/derive-const-use.rs:7:12
|
LL | impl const Default for A {
| ----- ^^^^^^^ ^
| |
| unsatisfied trait bound introduced here
= note: this error originates in the derive macro `Default` (in Nightly builds, run with -Z macro-backtrace for more info)
Some errors have detailed explanations: E0207, E0308, E0635.
error: aborting due to 8 previous errors
Some errors have detailed explanations: E0207, E0284, E0308, E0635.
For more information about an error, try `rustc --explain E0207`.

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

@ -34,6 +34,94 @@ LL | impl const FromResidual for T {
= 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
error[E0284]: type annotations needed
--> $DIR/trait-default-body-stability.rs:33:6
|
LL | impl const FromResidual for T {
| ^^^^^ cannot infer the value of the constant `_`
|
note: required for `T` to implement `Try`
--> $DIR/trait-default-body-stability.rs:18:12
|
LL | impl const Try for T {
| ----- ^^^ ^
| |
| unsatisfied trait bound introduced here
For more information about this error, try `rustc --explain E0207`.
error[E0284]: type annotations needed
--> $DIR/trait-default-body-stability.rs:44:9
|
LL | T?
| ^^ cannot infer the value of the constant `_`
|
note: required for `T` to implement `Try`
--> $DIR/trait-default-body-stability.rs:18:12
|
LL | impl const Try for T {
| ----- ^^^ ^
| |
| unsatisfied trait bound introduced here
error[E0284]: type annotations needed
--> $DIR/trait-default-body-stability.rs:44:9
|
LL | T?
| ^^ cannot infer the value of the constant `_`
|
note: required for `T` to implement `FromResidual<T>`
--> $DIR/trait-default-body-stability.rs:33:12
|
LL | impl const FromResidual for T {
| ----- ^^^^^^^^^^^^ ^
| |
| unsatisfied trait bound introduced here
error[E0284]: type annotations needed
--> $DIR/trait-default-body-stability.rs:44:9
|
LL | T?
| ^^ cannot infer the value of the constant `_`
|
note: required for `T` to implement `Try`
--> $DIR/trait-default-body-stability.rs:18:12
|
LL | impl const Try for T {
| ----- ^^^ ^
| |
| unsatisfied trait bound introduced here
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error[E0284]: type annotations needed
--> $DIR/trait-default-body-stability.rs:44:9
|
LL | T?
| ^^ cannot infer the value of the constant `_`
|
note: required for `T` to implement `FromResidual<T>`
--> $DIR/trait-default-body-stability.rs:33:12
|
LL | impl const FromResidual for T {
| ----- ^^^^^^^^^^^^ ^
| |
| unsatisfied trait bound introduced here
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error[E0284]: type annotations needed
--> $DIR/trait-default-body-stability.rs:44:9
|
LL | T?
| ^^ cannot infer the value of the constant `_`
|
note: required for `T` to implement `Try`
--> $DIR/trait-default-body-stability.rs:18:12
|
LL | impl const Try for T {
| ----- ^^^ ^
| |
| unsatisfied trait bound introduced here
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
error: aborting due to 10 previous errors
Some errors have detailed explanations: E0207, E0284.
For more information about an error, try `rustc --explain E0207`.

1
tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs
View File

@ -4,4 +4,5 @@ fn main() {
//~| ERROR cannot find type `T` in this scope
//~| ERROR const and type arguments are not allowed on builtin type `str`
//~| ERROR expected unit struct, unit variant or constant, found associated function `str<
//~| ERROR type annotations needed
}

15
tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.stderr
View File

@ -32,7 +32,18 @@ error[E0533]: expected unit struct, unit variant or constant, found associated f
LL | let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not a unit struct, unit variant or constant
error: aborting due to 4 previous errors
error[E0282]: type annotations needed
--> $DIR/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs:2:31
|
LL | let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes;
| ^^^^^^^^^^^^^^^^^^
|
help: consider giving this pattern a type
|
LL | let str::<{fn str() { let str::T>>::as_bytes: /* Type */; }}, T>::as_bytes;
| ++++++++++++
Some errors have detailed explanations: E0109, E0412, E0533.
error: aborting due to 5 previous errors
Some errors have detailed explanations: E0109, E0282, E0412, E0533.
For more information about an error, try `rustc --explain E0109`.

4
tests/ui/specialization/default-proj-ty-as-type-of-const-issue-125757.stderr
View File

@ -14,11 +14,11 @@ LL | impl<const C: usize> Wrapper<C> {}
|
= help: consider constraining the associated type `<i32 as Trait>::Type` to `usize`
= note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
note: required by a bound in `Wrapper`
note: required by a const generic parameter in `Wrapper`
--> $DIR/default-proj-ty-as-type-of-const-issue-125757.rs:12:16
|
LL | struct Wrapper<const C: <i32 as Trait>::Type> {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `Wrapper`
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this const generic parameter in `Wrapper`
error[E0308]: mismatched types
--> $DIR/default-proj-ty-as-type-of-const-issue-125757.rs:15:30

2
tests/ui/transmutability/issue-101739-1.stderr
View File

@ -10,7 +10,7 @@ error: the constant `ASSUME_ALIGNMENT` is not of type `Assume`
LL | Dst: BikeshedIntrinsicFrom<Src, ASSUME_ALIGNMENT>,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Assume`, found `bool`
|
note: required by a bound in `BikeshedIntrinsicFrom`
note: required by a const generic parameter in `BikeshedIntrinsicFrom`
--> $SRC_DIR/core/src/mem/transmutability.rs:LL:COL
error[E0308]: mismatched types

8
tests/crashes/123276.rs → tests/ui/where-clauses/normalization-of-unknown-type.rs
View File

@ -1,4 +1,6 @@
//@ known-bug: rust-lang/rust#123276
//! This test used to ICE: rust-lang/rust#123276 because we did
//! not taint when failing to find the `Foo` type and then tried
//! to normalize it.
//@ edition:2021
async fn create_task() {
@ -19,7 +21,9 @@ struct AndThen;
impl Filter for AndThen
where
Foo: Filter,
Foo: Filter, //~ ERROR: cannot find type `Foo`
{
type Future = ();
}
fn main() {}

9
tests/ui/where-clauses/normalization-of-unknown-type.stderr Normal file
View File

@ -0,0 +1,9 @@
error[E0412]: cannot find type `Foo` in this scope
--> $DIR/normalization-of-unknown-type.rs:24:5
|
LL | Foo: Filter,
| ^^^ not found in this scope
error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0412`.