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

Fix w/ comments

Browse source
This commit is contained in:
kadmin 2022-02-01 15:28:31 +00:00
parent c654e4d6f4
commit 78fb74a600
40 changed files with 281 additions and 199 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
compiler/rustc_hir/src/hir.rs
View file

@ -2165,6 +2165,12 @@ impl TypeBinding<'_> {
_ => panic!("expected equality type binding for parenthesized generic args"),
}
}
pub fn opt_const(&self) -> Option<&'_ AnonConst> {
match self.kind {
TypeBindingKind::Equality { term: Term::Const(ref c) } => Some(c),
_ => None,
}
}
}
#[derive(Debug)]

12
compiler/rustc_infer/src/infer/at.rs
View file

@ -288,13 +288,21 @@ impl<'tcx> ToTrace<'tcx> for &'tcx Const<'tcx> {
impl<'tcx> ToTrace<'tcx> for ty::Term<'tcx> {
fn to_trace(
_: TyCtxt<'tcx>,
tcx: TyCtxt<'tcx>,
cause: &ObligationCause<'tcx>,
a_is_expected: bool,
a: Self,
b: Self,
) -> TypeTrace<'tcx> {
TypeTrace { cause: cause.clone(), values: Terms(ExpectedFound::new(a_is_expected, a, b)) }
match (a, b) {
(ty::Term::Ty(a), ty::Term::Ty(b)) => {
ToTrace::to_trace(tcx, cause, a_is_expected, a, b)
}
(ty::Term::Const(a), ty::Term::Const(b)) => {
ToTrace::to_trace(tcx, cause, a_is_expected, a, b)
}
(_, _) => todo!(),
}
}
}

1
compiler/rustc_infer/src/infer/error_reporting/mod.rs
View file

@ -2127,7 +2127,6 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
infer::Types(exp_found) => self.expected_found_str_ty(exp_found),
infer::Regions(exp_found) => self.expected_found_str(exp_found),
infer::Consts(exp_found) => self.expected_found_str(exp_found),
infer::Terms(exp_found) => self.expected_found_str(exp_found),
infer::TraitRefs(exp_found) => {
let pretty_exp_found = ty::error::ExpectedFound {
expected: exp_found.expected.print_only_trait_path(),

1
compiler/rustc_infer/src/infer/mod.rs
View file

@ -371,7 +371,6 @@ pub enum ValuePairs<'tcx> {
Types(ExpectedFound<Ty<'tcx>>),
Regions(ExpectedFound<ty::Region<'tcx>>),
Consts(ExpectedFound<&'tcx ty::Const<'tcx>>),
Terms(ExpectedFound<ty::Term<'tcx>>),
TraitRefs(ExpectedFound<ty::TraitRef<'tcx>>),
PolyTraitRefs(ExpectedFound<ty::PolyTraitRef<'tcx>>),
}

25
compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
View file

@ -1356,11 +1356,26 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
normalized_ty,
data.term,
) {
values = Some(infer::ValuePairs::Terms(ExpectedFound::new(
is_normalized_ty_expected,
normalized_ty,
data.term,
)));
values = Some(match (normalized_ty, data.term) {
(ty::Term::Ty(normalized_ty), ty::Term::Ty(ty)) => {
infer::ValuePairs::Types(ExpectedFound::new(
is_normalized_ty_expected,
normalized_ty,
ty,
))
}
(ty::Term::Const(normalized_ct), ty::Term::Const(ct)) => {
infer::ValuePairs::Consts(ExpectedFound::new(
is_normalized_ty_expected,
normalized_ct,
ct,
))
}
(_, _) => span_bug!(
obligation.cause.span,
"found const or type where other expected"
),
});
err_buf = error;
err = &err_buf;
}

81
compiler/rustc_trait_selection/src/traits/project.rs
View file

@ -199,61 +199,30 @@ fn project_and_unify_type<'cx, 'tcx>(
let mut obligations = vec![];
let infcx = selcx.infcx();
match obligation.predicate.term {
ty::Term::Ty(obligation_pred_ty) => {
let normalized_ty = match opt_normalize_projection_type(
selcx,
obligation.param_env,
obligation.predicate.projection_ty,
obligation.cause.clone(),
obligation.recursion_depth,
&mut obligations,
) {
Ok(Some(n)) => n.ty().unwrap(),
Ok(None) => return Ok(Ok(None)),
Err(InProgress) => return Ok(Err(InProgress)),
};
debug!(?normalized_ty, ?obligations, "project_and_unify_type result");
match infcx
.at(&obligation.cause, obligation.param_env)
.eq(normalized_ty, obligation_pred_ty)
{
Ok(InferOk { obligations: inferred_obligations, value: () }) => {
obligations.extend(inferred_obligations);
Ok(Ok(Some(obligations)))
}
Err(err) => {
debug!("project_and_unify_type: equating types encountered error {:?}", err);
Err(MismatchedProjectionTypes { err })
}
}
let normalized = match opt_normalize_projection_type(
selcx,
obligation.param_env,
obligation.predicate.projection_ty,
obligation.cause.clone(),
obligation.recursion_depth,
&mut obligations,
) {
Ok(Some(n)) => n,
Ok(None) => return Ok(Ok(None)),
Err(InProgress) => return Ok(Err(InProgress)),
};
debug!(?normalized, ?obligations, "project_and_unify_type result");
match infcx
.at(&obligation.cause, obligation.param_env)
.eq(normalized, obligation.predicate.term)
{
Ok(InferOk { obligations: inferred_obligations, value: () }) => {
obligations.extend(inferred_obligations);
Ok(Ok(Some(obligations)))
}
ty::Term::Const(obligation_pred_const) => {
let normalized_const = match opt_normalize_projection_type(
selcx,
obligation.param_env,
obligation.predicate.projection_ty,
obligation.cause.clone(),
obligation.recursion_depth,
&mut obligations,
) {
Ok(Some(n)) => n.ct().unwrap(),
Ok(None) => return Ok(Ok(None)),
Err(InProgress) => return Ok(Err(InProgress)),
};
match infcx
.at(&obligation.cause, obligation.param_env)
.eq(normalized_const, obligation_pred_const)
{
Ok(InferOk { obligations: inferred_obligations, value: () }) => {
obligations.extend(inferred_obligations);
Ok(Ok(Some(obligations)))
}
Err(err) => {
debug!("project_and_unify_type: equating consts encountered error {:?}", err);
Err(MismatchedProjectionTypes { err })
}
}
Err(err) => {
debug!("project_and_unify_type: equating types encountered error {:?}", err);
Err(MismatchedProjectionTypes { err })
}
}
}
@ -934,6 +903,8 @@ fn opt_normalize_projection_type<'a, 'b, 'tcx>(
// created (and hence the new ones will quickly be
// discarded as duplicated). But when doing trait
// evaluation this is not the case, and dropping the trait
// evaluations can causes ICEs (e.g., #43132).
debug!(?ty, "found normalized ty");
obligations.extend(ty.obligations);
return Ok(Some(ty.value));
}
@ -1127,6 +1098,8 @@ fn project<'cx, 'tcx>(
Ok(Projected::Progress(confirm_candidate(selcx, obligation, candidate)))
}
ProjectionCandidateSet::None => Ok(Projected::NoProgress(
// FIXME(associated_const_generics): this may need to change in the future?
// need to investigate whether or not this is fine.
selcx
.tcx()
.mk_projection(obligation.predicate.item_def_id, obligation.predicate.substs)

12
compiler/rustc_typeck/src/astconv/mod.rs
View file

@ -1244,17 +1244,23 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
// the "projection predicate" for:
//
// `<T as Iterator>::Item = u32`
let def_kind = tcx.def_kind(projection_ty.skip_binder().item_def_id);
let assoc_item_def_id = projection_ty.skip_binder().item_def_id;
let def_kind = tcx.def_kind(assoc_item_def_id);
match (def_kind, term) {
(hir::def::DefKind::AssocTy, ty::Term::Ty(_))
| (hir::def::DefKind::AssocConst, ty::Term::Const(_)) => (),
(_, _) => {
let got = if let ty::Term::Ty(_) = term { "type" } else { "const" };
let expected = def_kind.descr(assoc_item_def_id);
tcx.sess
.struct_span_err(
binding.span,
"type/const mismatch in equality bind of associated field",
&format!("mismatch in bind of {expected}, got {got}"),
)
.span_note(
tcx.def_span(assoc_item_def_id),
&format!("{expected} defined here does not match {got}"),
)
.span_label(binding.span, "type/const Mismatch")
.emit();
}
}

64
compiler/rustc_typeck/src/collect/type_of.rs
View file

@ -161,40 +161,26 @@ pub(super) fn opt_const_param_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<
// We've encountered an `AnonConst` in some path, so we need to
// figure out which generic parameter it corresponds to and return
// the relevant type.
let filtered = path
.segments
.iter()
.filter_map(|seg| seg.args.map(|args| (args.args, seg)))
.find_map(|(args, seg)| {
args.iter()
.filter(|arg| arg.is_ty_or_const())
.position(|arg| arg.id() == hir_id)
.map(|index| (index, seg))
});
// FIXME(associated_const_equality): recursively search through the bindings instead
// of just top level.
let filtered = path.segments.iter().find_map(|seg| {
seg.args?
.args
.iter()
.filter(|arg| arg.is_ty_or_const())
.position(|arg| arg.id() == hir_id)
.map(|index| (index, seg))
});
// FIXME(associated_const_generics): can we blend this with iteration above?
let (arg_index, segment) = match filtered {
None => {
let binding_filtered = path
.segments
.iter()
.filter_map(|seg| seg.args.map(|args| (args.bindings, seg)))
.find_map(|(bindings, seg)| {
bindings
.iter()
.filter_map(|binding| {
if let hir::TypeBindingKind::Equality { term: Term::Const(c) } =
binding.kind
{
Some(c)
} else {
None
}
})
.position(|ct| ct.hir_id == hir_id)
.map(|idx| (idx, seg))
});
let binding_filtered = path.segments.iter().find_map(|seg| {
seg.args?
.bindings
.iter()
.filter_map(TypeBinding::opt_const)
.position(|ct| ct.hir_id == hir_id)
.map(|idx| (idx, seg))
});
match binding_filtered {
Some(inner) => inner,
None => {
@ -518,20 +504,10 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> {
path
.segments
.iter()
.filter_map(|seg| seg.args.map(|args| (args.bindings, seg)))
.find_map(|(bindings, seg)| {
bindings
.find_map(|seg| {
seg.args?.bindings
.iter()
.filter_map(|binding| {
if let hir::TypeBindingKind::Equality { term: Term::Const(c) } =
binding.kind
{
Some((binding, c))
} else {
None
}
})
.find_map(|(binding, ct)| if ct.hir_id == hir_id {
.find_map(|binding| if binding.opt_const()?.hir_id == hir_id {
Some((binding, seg))
} else {
None

26
src/test/ui/associated-consts/assoc-const-eq-missing.rs Normal file
View file

@ -0,0 +1,26 @@
#![feature(associated_const_equality)]
#![allow(unused)]
pub trait Foo {
const N: usize;
}
pub struct Bar;
impl Foo for Bar {
const N: usize = 3;
}
fn foo1<F: Foo<Z=3>>() {}
//~^ ERROR associated type
fn foo2<F: Foo<Z=usize>>() {}
//~^ ERROR associated type
fn foo3<F: Foo<Z=5>>() {}
//~^ ERROR associated type
fn main() {
foo1::<Bar>();
foo2::<Bar>();
foo3::<Bar>();
}

21
src/test/ui/associated-consts/assoc-const-eq-missing.stderr Normal file
View file

@ -0,0 +1,21 @@
error[E0220]: associated type `Z` not found for `Foo`
--> $DIR/assoc-const-eq-missing.rs:15:16
|
LL | fn foo1<F: Foo<Z=3>>() {}
| ^ associated type `Z` not found
error[E0220]: associated type `Z` not found for `Foo`
--> $DIR/assoc-const-eq-missing.rs:17:16
|
LL | fn foo2<F: Foo<Z=usize>>() {}
| ^ associated type `Z` not found
error[E0220]: associated type `Z` not found for `Foo`
--> $DIR/assoc-const-eq-missing.rs:19:16
|
LL | fn foo3<F: Foo<Z=5>>() {}
| ^ associated type `Z` not found
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0220`.

4
src/test/ui/associated-consts/assoc-const-ty-mismatch.rs
View file

@ -21,9 +21,9 @@ impl FooTy for Bar {
fn foo<F: Foo<N=usize>>() {}
//~^ ERROR type/const mismatch
//~^ ERROR mismatch in
fn foo2<F: FooTy<T=3usize>>() {}
//~^ ERROR type/const mismatch
//~^ ERROR mismatch in
fn main() {
foo::<Bar>();

20
src/test/ui/associated-consts/assoc-const-ty-mismatch.stderr
View file

@ -1,14 +1,26 @@
error: type/const mismatch in equality bind of associated field
error: mismatch in bind of associated constant, got type
--> $DIR/assoc-const-ty-mismatch.rs:23:15
|
LL | fn foo<F: Foo<N=usize>>() {}
| ^^^^^^^ type/const Mismatch
| ^^^^^^^
|
note: associated constant defined here does not match type
--> $DIR/assoc-const-ty-mismatch.rs:5:3
|
LL | const N: usize;
| ^^^^^^^^^^^^^^^
error: type/const mismatch in equality bind of associated field
error: mismatch in bind of associated type, got const
--> $DIR/assoc-const-ty-mismatch.rs:25:18
|
LL | fn foo2<F: FooTy<T=3usize>>() {}
| ^^^^^^^^ type/const Mismatch
| ^^^^^^^^
|
note: associated type defined here does not match const
--> $DIR/assoc-const-ty-mismatch.rs:9:3
|
LL | type T;
| ^^^^^^^
error: aborting due to 2 previous errors

4
src/test/ui/associated-types/associated-types-binding-to-type-defined-in-supertrait.stderr
View file

@ -4,7 +4,7 @@ error[E0271]: type mismatch resolving `<ModelT as Vehicle>::Color == Blue`
LL | fn b() { blue_car(ModelT); }
| ^^^^^^^^ type mismatch resolving `<ModelT as Vehicle>::Color == Blue`
|
note: expected struct `Blue`, found struct `Black`
note: expected this to be `Blue`
--> $DIR/associated-types-binding-to-type-defined-in-supertrait.rs:16:40
|
LL | impl Vehicle for ModelT { type Color = Black; }
@ -21,7 +21,7 @@ error[E0271]: type mismatch resolving `<ModelU as Vehicle>::Color == Black`
LL | fn c() { black_car(ModelU); }
| ^^^^^^^^^ type mismatch resolving `<ModelU as Vehicle>::Color == Black`
|
note: expected struct `Black`, found struct `Blue`
note: expected this to be `Black`
--> $DIR/associated-types-binding-to-type-defined-in-supertrait.rs:21:40
|
LL | impl Vehicle for ModelU { type Color = Blue; }

4
src/test/ui/associated-types/associated-types-eq-3.stderr
View file

@ -19,7 +19,7 @@ error[E0271]: type mismatch resolving `<isize as Foo>::A == Bar`
LL | foo1(a);
| ^^^^ type mismatch resolving `<isize as Foo>::A == Bar`
|
note: expected struct `Bar`, found `usize`
note: expected this to be `Bar`
--> $DIR/associated-types-eq-3.rs:12:14
|
LL | type A = usize;
@ -36,7 +36,7 @@ error[E0271]: type mismatch resolving `<isize as Foo>::A == Bar`
LL | baz(&a);
| ^^ type mismatch resolving `<isize as Foo>::A == Bar`
|
note: expected struct `Bar`, found `usize`
note: expected this to be `Bar`
--> $DIR/associated-types-eq-3.rs:12:14
|
LL | type A = usize;

8
src/test/ui/associated-types/associated-types-eq-hr.stderr
View file

@ -4,11 +4,13 @@ error[E0271]: type mismatch resolving `for<'x> <UintStruct as TheTrait<&'x isize
LL | foo::<UintStruct>();
| ^^^^^^^^^^^^^^^^^ type mismatch resolving `for<'x> <UintStruct as TheTrait<&'x isize>>::A == &'x isize`
|
note: expected `isize`, found `usize`
note: expected this to be `&isize`
--> $DIR/associated-types-eq-hr.rs:26:14
|
LL | type A = &'a usize;
| ^^^^^^^^^
= note: expected reference `&isize`
found reference `&usize`
note: required by a bound in `foo`
--> $DIR/associated-types-eq-hr.rs:45:36
|
@ -24,11 +26,13 @@ error[E0271]: type mismatch resolving `for<'x> <IntStruct as TheTrait<&'x isize>
LL | bar::<IntStruct>();
| ^^^^^^^^^^^^^^^^ type mismatch resolving `for<'x> <IntStruct as TheTrait<&'x isize>>::A == &'x usize`
|
note: expected `usize`, found `isize`
note: expected this to be `&usize`
--> $DIR/associated-types-eq-hr.rs:14:14
|
LL | type A = &'a isize;
| ^^^^^^^^^
= note: expected reference `&usize`
found reference `&isize`
note: required by a bound in `bar`
--> $DIR/associated-types-eq-hr.rs:52:36
|

4
src/test/ui/associated-types/associated-types-issue-20346.stderr
View file

@ -7,12 +7,12 @@ LL | fn test_adapter<T, I: Iterator<Item=Option<T>>>(it: I) {
LL | is_iterator_of::<Option<T>, _>(&adapter);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type mismatch resolving `<Adapter<I> as Iterator>::Item == Option<T>`
|
note: expected enum `Option`, found type parameter `T`
note: expected this to be `Option<T>`
--> $DIR/associated-types-issue-20346.rs:23:17
|
LL | type Item = T;
| ^
= note: expected type `Option<T>`
= note: expected enum `Option<T>`
found type `T`
note: required by a bound in `is_iterator_of`
--> $DIR/associated-types-issue-20346.rs:15:34

8
src/test/ui/associated-types/associated-types-multiple-types-one-trait.stderr
View file

@ -4,8 +4,8 @@ error[E0271]: type mismatch resolving `<T as Foo>::Y == i32`
LL | want_y(t);
| ^^^^^^ expected `i32`, found associated type
|
= note: expected type `i32`
found type `<T as Foo>::Y`
= note: expected type `i32`
found associated type `<T as Foo>::Y`
note: required by a bound in `want_y`
--> $DIR/associated-types-multiple-types-one-trait.rs:44:17
|
@ -22,8 +22,8 @@ error[E0271]: type mismatch resolving `<T as Foo>::X == u32`
LL | want_x(t);
| ^^^^^^ expected `u32`, found associated type
|
= note: expected type `u32`
found type `<T as Foo>::X`
= note: expected type `u32`
found associated type `<T as Foo>::X`
note: required by a bound in `want_x`
--> $DIR/associated-types-multiple-types-one-trait.rs:42:17
|

4
src/test/ui/associated-types/hr-associated-type-projection-1.stderr
View file

@ -4,8 +4,8 @@ error[E0271]: type mismatch resolving `<T as Deref>::Target == T`
LL | impl<T: Copy + std::ops::Deref> UnsafeCopy<'_, T> for T {
| - this type parameter ^^^^^^^^^^^^^^^^^ expected associated type, found type parameter `T`
|
= note: expected type `<T as Deref>::Target`
found type `T`
= note: expected associated type `<T as Deref>::Target`
found type parameter `T`
help: consider further restricting this bound
|
LL | impl<T: Copy + std::ops::Deref + Deref<Target = T>> UnsafeCopy<'_, T> for T {

7
src/test/ui/associated-types/impl-trait-return-missing-constraint.stderr
View file

@ -1,11 +1,14 @@
error[E0271]: type mismatch resolving `<impl Bar as Foo>::Item == i32`
--> $DIR/impl-trait-return-missing-constraint.rs:25:13
|
LL | fn bar() -> impl Bar {
| -------- the found opaque type
...
LL | fn baz() -> impl Bar<Item = i32> {
| ^^^^^^^^^^^^^^^^^^^^ expected `i32`, found associated type
|
= note: expected type `i32`
found type `<impl Bar as Foo>::Item`
= note: expected type `i32`
found associated type `<impl Bar as Foo>::Item`
help: consider constraining the associated type `<impl Bar as Foo>::Item` to `i32`
|
LL | fn bar() -> impl Bar<Item = i32> {

2
src/test/ui/associated-types/issue-44153.stderr
View file

@ -4,7 +4,7 @@ error[E0271]: type mismatch resolving `<() as Array>::Element == &()`
LL | <() as Visit>::visit();
| ^^^^^^^^^^^^^^^^^^^^ type mismatch resolving `<() as Array>::Element == &()`
|
note: expected `&()`, found `()`
note: expected this to be `&()`
--> $DIR/issue-44153.rs:10:20
|
LL | type Element = ();

2
src/test/ui/associated-types/issue-72806.stderr
View file

@ -4,7 +4,7 @@ error[E0271]: type mismatch resolving `<Foo2 as Bar2>::Ok == char`
LL | type Sibling = Foo2;
| ^^^^ type mismatch resolving `<Foo2 as Bar2>::Ok == char`
|
note: expected `char`, found `u32`
note: expected this to be `char`
--> $DIR/issue-72806.rs:18:15
|
LL | type Ok = u32;

77
src/test/ui/associated-types/issue-87261.stderr
View file

@ -4,8 +4,8 @@ error[E0271]: type mismatch resolving `<A as Trait>::Associated == ()`
LL | accepts_trait(a);
| ^^^^^^^^^^^^^ expected `()`, found associated type
|
= note: expected type `()`
found type `<A as Trait>::Associated`
= note: expected unit type `()`
found associated type `<A as Trait>::Associated`
note: required by a bound in `accepts_trait`
--> $DIR/issue-87261.rs:43:27
|
@ -22,8 +22,8 @@ error[E0271]: type mismatch resolving `<B as Trait>::Associated == ()`
LL | accepts_trait(b);
| ^^^^^^^^^^^^^ expected `()`, found associated type
|
= note: expected type `()`
found type `<B as Trait>::Associated`
= note: expected unit type `()`
found associated type `<B as Trait>::Associated`
= help: consider constraining the associated type `<B as Trait>::Associated` to `()`
= note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
note: required by a bound in `accepts_trait`
@ -38,8 +38,8 @@ error[E0271]: type mismatch resolving `<C as Trait>::Associated == ()`
LL | accepts_trait(c);
| ^^^^^^^^^^^^^ expected `()`, found associated type
|
= note: expected type `()`
found type `<C as Trait>::Associated`
= note: expected unit type `()`
found associated type `<C as Trait>::Associated`
note: required by a bound in `accepts_trait`
--> $DIR/issue-87261.rs:43:27
|
@ -56,8 +56,8 @@ error[E0271]: type mismatch resolving `<D as Trait>::Associated == ()`
LL | accepts_trait(d);
| ^^^^^^^^^^^^^ expected `()`, found associated type
|
= note: expected type `()`
found type `<D as Trait>::Associated`
= note: expected unit type `()`
found associated type `<D as Trait>::Associated`
= help: consider constraining the associated type `<D as Trait>::Associated` to `()`
= note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
note: required by a bound in `accepts_trait`
@ -72,8 +72,8 @@ error[E0271]: type mismatch resolving `<E as GenericTrait<()>>::Associated == ()
LL | accepts_generic_trait(e);
| ^^^^^^^^^^^^^^^^^^^^^ expected `()`, found associated type
|
= note: expected type `()`
found type `<E as GenericTrait<()>>::Associated`
= note: expected unit type `()`
found associated type `<E as GenericTrait<()>>::Associated`
note: required by a bound in `accepts_generic_trait`
--> $DIR/issue-87261.rs:44:46
|
@ -90,8 +90,8 @@ error[E0271]: type mismatch resolving `<F as GenericTrait<()>>::Associated == ()
LL | accepts_generic_trait(f);
| ^^^^^^^^^^^^^^^^^^^^^ expected `()`, found associated type
|
= note: expected type `()`
found type `<F as GenericTrait<()>>::Associated`
= note: expected unit type `()`
found associated type `<F as GenericTrait<()>>::Associated`
note: required by a bound in `accepts_generic_trait`
--> $DIR/issue-87261.rs:44:46
|
@ -108,8 +108,8 @@ error[E0271]: type mismatch resolving `<G as GenericTrait<()>>::Associated == ()
LL | accepts_generic_trait(g);
| ^^^^^^^^^^^^^^^^^^^^^ expected `()`, found associated type
|
= note: expected type `()`
found type `<G as GenericTrait<()>>::Associated`
= note: expected unit type `()`
found associated type `<G as GenericTrait<()>>::Associated`
= help: consider constraining the associated type `<G as GenericTrait<()>>::Associated` to `()`
= note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
note: required by a bound in `accepts_generic_trait`
@ -121,11 +121,14 @@ LL | fn accepts_generic_trait<T: GenericTrait<(), Associated = ()>>(_: T) {}
error[E0271]: type mismatch resolving `<impl Trait as Trait>::Associated == ()`
--> $DIR/issue-87261.rs:79:5
|
LL | fn returns_opaque() -> impl Trait + 'static {
| -------------------- the found opaque type
...
LL | accepts_trait(returns_opaque());
| ^^^^^^^^^^^^^ expected `()`, found associated type
|
= note: expected type `()`
found type `<impl Trait as Trait>::Associated`
= note: expected unit type `()`
found associated type `<impl Trait as Trait>::Associated`
note: required by a bound in `accepts_trait`
--> $DIR/issue-87261.rs:43:27
|
@ -139,11 +142,14 @@ LL | fn returns_opaque() -> impl Trait<Associated = ()> + 'static {
error[E0271]: type mismatch resolving `<impl DerivedTrait as Trait>::Associated == ()`
--> $DIR/issue-87261.rs:82:5
|
LL | fn returns_opaque_derived() -> impl DerivedTrait + 'static {
| --------------------------- the found opaque type
...
LL | accepts_trait(returns_opaque_derived());
| ^^^^^^^^^^^^^ expected `()`, found associated type
|
= note: expected type `()`
found type `<impl DerivedTrait as Trait>::Associated`
= note: expected unit type `()`
found associated type `<impl DerivedTrait as Trait>::Associated`
note: required by a bound in `accepts_trait`
--> $DIR/issue-87261.rs:43:27
|
@ -157,11 +163,14 @@ LL | fn returns_opaque_derived() -> impl DerivedTrait<Associated = ()> + 'static
error[E0271]: type mismatch resolving `<impl Foo + Trait as Trait>::Associated == ()`
--> $DIR/issue-87261.rs:85:5
|
LL | fn returns_opaque_foo() -> impl Trait + Foo {
| ---------------- the found opaque type
...
LL | accepts_trait(returns_opaque_foo());
| ^^^^^^^^^^^^^ expected `()`, found associated type
|
= note: expected type `()`
found type `<impl Foo + Trait as Trait>::Associated`
= note: expected unit type `()`
found associated type `<impl Foo + Trait as Trait>::Associated`
note: required by a bound in `accepts_trait`
--> $DIR/issue-87261.rs:43:27
|
@ -175,11 +184,14 @@ LL | fn returns_opaque_foo() -> impl Trait<Associated = ()> + Foo {
error[E0271]: type mismatch resolving `<impl Foo + DerivedTrait as Trait>::Associated == ()`
--> $DIR/issue-87261.rs:88:5
|
LL | fn returns_opaque_derived_foo() -> impl DerivedTrait + Foo {
| ----------------------- the found opaque type
...
LL | accepts_trait(returns_opaque_derived_foo());
| ^^^^^^^^^^^^^ expected `()`, found associated type
|
= note: expected type `()`
found type `<impl Foo + DerivedTrait as Trait>::Associated`
= note: expected unit type `()`
found associated type `<impl Foo + DerivedTrait as Trait>::Associated`
= help: consider constraining the associated type `<impl Foo + DerivedTrait as Trait>::Associated` to `()`
= note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
note: required by a bound in `accepts_trait`
@ -191,11 +203,14 @@ LL | fn accepts_trait<T: Trait<Associated = ()>>(_: T) {}
error[E0271]: type mismatch resolving `<impl GenericTrait<()> as GenericTrait<()>>::Associated == ()`
--> $DIR/issue-87261.rs:91:5
|
LL | fn returns_opaque_generic() -> impl GenericTrait<()> + 'static {
| ------------------------------- the found opaque type
...
LL | accepts_generic_trait(returns_opaque_generic());
| ^^^^^^^^^^^^^^^^^^^^^ expected `()`, found associated type
|
= note: expected type `()`
found type `<impl GenericTrait<()> as GenericTrait<()>>::Associated`
= note: expected unit type `()`
found associated type `<impl GenericTrait<()> as GenericTrait<()>>::Associated`
note: required by a bound in `accepts_generic_trait`
--> $DIR/issue-87261.rs:44:46
|
@ -209,11 +224,14 @@ LL | fn returns_opaque_generic() -> impl GenericTrait<(), Associated = ()> + 'st
error[E0271]: type mismatch resolving `<impl Foo + GenericTrait<()> as GenericTrait<()>>::Associated == ()`
--> $DIR/issue-87261.rs:94:5
|
LL | fn returns_opaque_generic_foo() -> impl GenericTrait<()> + Foo {
| --------------------------- the found opaque type
...
LL | accepts_generic_trait(returns_opaque_generic_foo());
| ^^^^^^^^^^^^^^^^^^^^^ expected `()`, found associated type
|
= note: expected type `()`
found type `<impl Foo + GenericTrait<()> as GenericTrait<()>>::Associated`
= note: expected unit type `()`
found associated type `<impl Foo + GenericTrait<()> as GenericTrait<()>>::Associated`
note: required by a bound in `accepts_generic_trait`
--> $DIR/issue-87261.rs:44:46
|
@ -227,11 +245,14 @@ LL | fn returns_opaque_generic_foo() -> impl GenericTrait<(), Associated = ()> +
error[E0271]: type mismatch resolving `<impl GenericTrait<u8> + GenericTrait<()> as GenericTrait<()>>::Associated == ()`
--> $DIR/issue-87261.rs:97:5
|
LL | fn returns_opaque_generic_duplicate() -> impl GenericTrait<()> + GenericTrait<u8> {
| ---------------------------------------- the found opaque type
...
LL | accepts_generic_trait(returns_opaque_generic_duplicate());
| ^^^^^^^^^^^^^^^^^^^^^ expected `()`, found associated type
|
= note: expected type `()`
found type `<impl GenericTrait<u8> + GenericTrait<()> as GenericTrait<()>>::Associated`
= note: expected unit type `()`
found associated type `<impl GenericTrait<u8> + GenericTrait<()> as GenericTrait<()>>::Associated`
= help: consider constraining the associated type `<impl GenericTrait<u8> + GenericTrait<()> as GenericTrait<()>>::Associated` to `()`
= note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
note: required by a bound in `accepts_generic_trait`

2
src/test/ui/associated-types/point-at-type-on-obligation-failure.stderr
View file

@ -4,7 +4,7 @@ error[E0271]: type mismatch resolving `<Foo2 as Bar2>::Ok == ()`
LL | type Sibling = Foo2;
| ^^^^ type mismatch resolving `<Foo2 as Bar2>::Ok == ()`
|
note: expected `()`, found `u32`
note: expected this to be `()`
--> $DIR/point-at-type-on-obligation-failure.rs:18:15
|
LL | type Ok = u32;

2
src/test/ui/error-codes/E0271.stderr
View file

@ -4,7 +4,7 @@ error[E0271]: type mismatch resolving `<i8 as Trait>::AssociatedType == u32`
LL | foo(3_i8);
| ^^^ type mismatch resolving `<i8 as Trait>::AssociatedType == u32`
|
note: expected `u32`, found `&str`
note: expected this to be `u32`
--> $DIR/E0271.rs:7:43
|
LL | impl Trait for i8 { type AssociatedType = &'static str; }

2
src/test/ui/generator/type-mismatch-signature-deduction.stderr
View file

@ -19,7 +19,7 @@ LL | fn foo() -> impl Generator<Return = i32> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `i32`, found enum `Result`
|
= note: expected type `i32`
found type `Result<{integer}, _>`
found enum `Result<{integer}, _>`
error: aborting due to 2 previous errors

4
src/test/ui/generic-associated-types/issue-68656-unsized-values.stderr
View file

@ -6,8 +6,8 @@ LL | impl<T: Copy + std::ops::Deref> UnsafeCopy<T> for T {
LL | type Item<'a> = T;
| ^ expected type parameter `T`, found associated type
|
= note: expected type `T`
found type `<T as Deref>::Target`
= note: expected type parameter `T`
found associated type `<T as Deref>::Target`
note: required by a bound in `UnsafeCopy::Item`
--> $DIR/issue-68656-unsized-values.rs:6:36
|

2
src/test/ui/generic-associated-types/issue-74684-2.stderr
View file

@ -4,7 +4,7 @@ error[E0271]: type mismatch resolving `<{integer} as Fun>::F<'_> == [u8]`
LL | bug(Box::new(x));
| ^^^ type mismatch resolving `<{integer} as Fun>::F<'_> == [u8]`
|
note: expected slice `[u8]`, found `i32`
note: expected this to be `[u8]`
--> $DIR/issue-74684-2.rs:10:18
|
LL | type F<'a> = i32;

6
src/test/ui/hrtb/issue-62203-hrtb-ice.stderr
View file

@ -4,13 +4,13 @@ error[E0271]: type mismatch resolving `for<'r> <L<[closure@$DIR/issue-62203-hrtb
LL | let v = Unit2.m(
| ^ type mismatch resolving `for<'r> <L<[closure@$DIR/issue-62203-hrtb-ice.rs:42:17: 42:39]> as T0<'r, (&'r u8,)>>::O == <_ as Ty<'r>>::V`
|
note: expected associated type, found struct `Unit4`
note: expected this to be `<_ as Ty<'_>>::V`
--> $DIR/issue-62203-hrtb-ice.rs:21:14
|
LL | type O = T::Output;
| ^^^^^^^^^
= note: expected type `<_ as Ty<'_>>::V`
found type `Unit4`
= note: expected associated type `<_ as Ty<'_>>::V`
found struct `Unit4`
= help: consider constraining the associated type `<_ as Ty<'_>>::V` to `Unit4` or calling a method that returns `<_ as Ty<'_>>::V`
= note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
note: required by a bound in `T1::m`

12
src/test/ui/impl-trait/bound-normalization-fail.stderr
View file

@ -4,13 +4,13 @@ error[E0271]: type mismatch resolving `<Foo<()> as FooLike>::Output == <T as imp
LL | fn foo_fail<T: Trait>() -> impl FooLike<Output = T::Assoc> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type mismatch resolving `<Foo<()> as FooLike>::Output == <T as impl_trait::Trait>::Assoc`
|
note: expected associated type, found `()`
note: expected this to be `<T as impl_trait::Trait>::Assoc`
--> $DIR/bound-normalization-fail.rs:14:19
|
LL | type Output = T;
| ^
= note: expected type `<T as impl_trait::Trait>::Assoc`
found type `()`
= note: expected associated type `<T as impl_trait::Trait>::Assoc`
found unit type `()`
help: consider constraining the associated type `<T as impl_trait::Trait>::Assoc` to `()`
|
LL | fn foo_fail<T: Trait<Assoc = ()>>() -> impl FooLike<Output = T::Assoc> {
@ -28,13 +28,13 @@ error[E0271]: type mismatch resolving `<Foo<()> as FooLike>::Output == <T as lif
LL | fn foo2_fail<'a, T: Trait<'a>>() -> impl FooLike<Output = T::Assoc> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type mismatch resolving `<Foo<()> as FooLike>::Output == <T as lifetimes::Trait<'static>>::Assoc`
|
note: expected associated type, found `()`
note: expected this to be `<T as lifetimes::Trait<'static>>::Assoc`
--> $DIR/bound-normalization-fail.rs:14:19
|
LL | type Output = T;
| ^
= note: expected type `<T as lifetimes::Trait<'static>>::Assoc`
found type `()`
= note: expected associated type `<T as lifetimes::Trait<'static>>::Assoc`
found unit type `()`
help: consider constraining the associated type `<T as lifetimes::Trait<'static>>::Assoc` to `()`
|
LL | fn foo2_fail<'a, T: Trait<'a, Assoc = ()>>() -> impl FooLike<Output = T::Assoc> {

9
src/test/ui/impl-trait/issues/issue-70877.stderr
View file

@ -1,16 +1,19 @@
error[E0271]: type mismatch resolving `<Bar as Iterator>::Item == Box<(dyn for<'r> Fn(&'r (dyn ToString + 'r)) -> Option<String> + 'static)>`
--> $DIR/issue-70877.rs:7:12
|
LL | type FooRet = impl std::fmt::Debug;
| -------------------- the found opaque type
...
LL | type Foo = impl Iterator<Item = FooItem>;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type mismatch resolving `<Bar as Iterator>::Item == Box<(dyn for<'r> Fn(&'r (dyn ToString + 'r)) -> Option<String> + 'static)>`
|
note: expected enum `Option`, found opaque type
note: expected this to be `Box<(dyn for<'r> Fn(&'r (dyn ToString + 'r)) -> Option<String> + 'static)>`
--> $DIR/issue-70877.rs:13:17
|
LL | type Item = FooItem;
| ^^^^^^^
= note: expected type `Box<(dyn for<'r> Fn(&'r (dyn ToString + 'r)) -> Option<String> + 'static)>`
found type `Box<(dyn for<'r> Fn(&'r (dyn ToString + 'r)) -> impl Debug + 'static)>`
= note: expected struct `Box<(dyn for<'r> Fn(&'r (dyn ToString + 'r)) -> Option<String> + 'static)>`
found struct `Box<(dyn for<'r> Fn(&'r (dyn ToString + 'r)) -> impl Debug + 'static)>`
error: aborting due to previous error

2
src/test/ui/impl-trait/projection-mismatch-in-impl-where-clause.stderr
View file

@ -4,7 +4,7 @@ error[E0271]: type mismatch resolving `<() as Super>::Assoc == ()`
LL | fn test() -> impl Test {
| ^^^^^^^^^ type mismatch resolving `<() as Super>::Assoc == ()`
|
note: expected `()`, found `u8`
note: expected this to be `()`
--> $DIR/projection-mismatch-in-impl-where-clause.rs:6:18
|
LL | type Assoc = u8;

4
src/test/ui/issues/issue-31173.stderr
View file

@ -4,8 +4,8 @@ error[E0271]: type mismatch resolving `<TakeWhile<&mut std::vec::IntoIter<u8>, [
LL | .cloned()
| ^^^^^^ expected reference, found `u8`
|
= note: expected type `&_`
found type `u8`
= note: expected reference `&_`
found type `u8`
note: required by a bound in `cloned`
--> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
|

8
src/test/ui/issues/issue-33941.stderr
View file

@ -4,8 +4,8 @@ error[E0271]: type mismatch resolving `<std::collections::hash_map::Iter<'_, _,
LL | for _ in HashMap::new().iter().cloned() {}
| ^^^^^^ expected reference, found tuple
|
= note: expected type `&_`
found type `(&_, &_)`
= note: expected reference `&_`
found tuple `(&_, &_)`
note: required by a bound in `cloned`
--> $SRC_DIR/core/src/iter/traits/iterator.rs:LL:COL
|
@ -18,8 +18,8 @@ error[E0271]: type mismatch resolving `<std::collections::hash_map::Iter<'_, _,
LL | for _ in HashMap::new().iter().cloned() {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected tuple, found reference
|
= note: expected type `(&_, &_)`
found type `&_`
= note: expected tuple `(&_, &_)`
found reference `&_`
= note: required because of the requirements on the impl of `Iterator` for `Cloned<std::collections::hash_map::Iter<'_, _, _>>`
= note: required because of the requirements on the impl of `IntoIterator` for `Cloned<std::collections::hash_map::Iter<'_, _, _>>`

2
src/test/ui/issues/issue-39970.stderr
View file

@ -4,7 +4,7 @@ error[E0271]: type mismatch resolving `for<'a> <() as Array<'a>>::Element == ()`
LL | <() as Visit>::visit();
| ^^^^^^^^^^^^^^^^^^^^ type mismatch resolving `for<'a> <() as Array<'a>>::Element == ()`
|
note: expected `()`, found `&()`
note: expected this to be `()`
--> $DIR/issue-39970.rs:10:20
|
LL | type Element = &'a ();

4
src/test/ui/issues/issue-67039-unsound-pin-partialeq.stderr
View file

@ -4,8 +4,8 @@ error[E0271]: type mismatch resolving `<Rc<Apple> as Deref>::Target == Rc<Apple>
LL | let _ = Pin::new(Apple) == Rc::pin(Apple);
| ^^ expected struct `Apple`, found struct `Rc`
|
= note: expected type `Apple`
found type `Rc<Apple>`
= note: expected struct `Apple`
found struct `Rc<Apple>`
= note: required because of the requirements on the impl of `PartialEq<Pin<Rc<Apple>>>` for `Pin<Apple>`
error: aborting due to previous error

4
src/test/ui/never_type/fallback-closure-wrap.fallback.stderr
View file

@ -8,8 +8,8 @@ LL | | panic!("Can't connect to server.");
LL | | }) as Box<dyn FnMut()>);
| |______^ expected `()`, found `!`
|
= note: expected type `()`
found type `!`
= note: expected unit type `()`
found type `!`
= note: required for the cast to the object type `dyn FnMut()`
error: aborting due to previous error

2
src/test/ui/traits/associated_type_bound/check-trait-object-bounds-5.stderr
View file

@ -4,7 +4,7 @@ error[E0271]: type mismatch resolving `<i32 as Is>::T == i64`
LL | is_obj(x)
| ^^^^^^ type mismatch resolving `<i32 as Is>::T == i64`
|
note: expected `i64`, found `i32`
note: expected this to be `i64`
--> $DIR/check-trait-object-bounds-5.rs:9:14
|
LL | type T = U;

2
src/test/ui/traits/associated_type_bound/check-trait-object-bounds-6.stderr
View file

@ -4,7 +4,7 @@ error[E0271]: type mismatch resolving `<i32 as Is>::T == i64`
LL | is_obj(x)
| ^^^^^^ type mismatch resolving `<i32 as Is>::T == i64`
|
note: expected `i64`, found `i32`
note: expected this to be `i64`
--> $DIR/check-trait-object-bounds-6.rs:9:14
|
LL | type T = U;

8
src/test/ui/type-alias-impl-trait/issue-63355.stderr
View file

@ -1,16 +1,18 @@
error[E0271]: type mismatch resolving `<() as Bar>::Foo == ()`
--> $DIR/issue-63355.rs:34:20
|
LL | pub type FooImpl = impl Foo;
| -------- the found opaque type
LL | pub type BarImpl = impl Bar<Foo = FooImpl>;
| ^^^^^^^^^^^^^^^^^^^^^^^ type mismatch resolving `<() as Bar>::Foo == ()`
|
note: expected `()`, found opaque type
note: expected this to be `()`
--> $DIR/issue-63355.rs:24:16
|
LL | type Foo = FooImpl;
| ^^^^^^^
= note: expected type `()`
found type `impl Foo`
= note: expected unit type `()`
found opaque type `impl Foo`
error: aborting due to previous error

12
src/test/ui/type-alias-impl-trait/issue-89686.stderr
View file

@ -3,9 +3,17 @@ error[E0271]: type mismatch resolving `<impl Future<Output = [async output]> as
|
LL | type G<'a, T> = impl Future<Output = ()>;
| ^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found associated type
...
LL | async move { self.f().await }
| ------------------ the found `async` block
|
= note: expected type `()`
found type `<impl Future<Output = [async output]> as Future>::Output`
::: $SRC_DIR/core/src/future/mod.rs:LL:COL
|
LL | pub const fn from_generator<T>(gen: T) -> impl Future<Output = T::Return>
| ------------------------------- the found opaque type
|
= note: expected unit type `()`
found associated type `<impl Future<Output = [async output]> as Future>::Output`
= help: consider constraining the associated type `<impl Future<Output = [async output]> as Future>::Output` to `()`
= note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html