mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rollup merge of #114594 - compiler-errors:new-solver-resolve-aliases, r=lcnr

Browse Source 
Structurally normalize weak and inherent in new solver

It seems pretty obvious to me that we should be normalizing weak and inherent aliases too, since they can always be normalized. This PR still leaves open the question of what to do with opaques, though 💀

**Also**, we need to structurally resolve the target of a coercion, for the UI test to work.

r? `@lcnr`
This commit is contained in:
Matthias Krüger 2023-08-08 03:30:56 +02:00 committed by GitHub
commit 418b91a3d7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 58 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_hir_analysis/src/autoderef.rs
View File

@ -74,7 +74,7 @@ impl<'a, 'tcx> Iterator for Autoderef<'a, 'tcx> {
// we have some type like `&<Ty as Trait>::Assoc`, since users of
// autoderef expect this type to have been structurally normalized.
if self.infcx.next_trait_solver()
&& let ty::Alias(ty::Projection, _) = ty.kind()
&& let ty::Alias(ty::Projection | ty::Inherent | ty::Weak, _) = ty.kind()
{
let (normalized_ty, obligations) = self.structurally_normalize(ty)?;
self.state.obligations.extend(obligations);

8
compiler/rustc_hir_typeck/src/coercion.rs
View File

@ -1012,6 +1012,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
cause: Option<ObligationCause<'tcx>>,
) -> RelateResult<'tcx, Ty<'tcx>> {
let source = self.try_structurally_resolve_type(expr.span, expr_ty);
let target = self.try_structurally_resolve_type(
cause.as_ref().map_or(expr.span, |cause| cause.span),
target,
);
debug!("coercion::try({:?}: {:?} -> {:?})", expr, source, target);
let cause =
@ -1097,8 +1101,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
where
E: AsCoercionSite,
{
let prev_ty = self.resolve_vars_with_obligations(prev_ty);
let new_ty = self.resolve_vars_with_obligations(new_ty);
let prev_ty = self.try_structurally_resolve_type(cause.span, prev_ty);
let new_ty = self.try_structurally_resolve_type(new.span, new_ty);
debug!(
"coercion::try_find_coercion_lub({:?}, {:?}, exprs={:?} exprs)",
prev_ty,

2
compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
View File

@ -1474,7 +1474,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let ty = self.resolve_vars_with_obligations(ty);
if self.next_trait_solver()
&& let ty::Alias(ty::Projection, _) = ty.kind()
&& let ty::Alias(ty::Projection | ty::Inherent | ty::Weak, _) = ty.kind()
{
match self
.at(&self.misc(sp), self.param_env)

4
compiler/rustc_trait_selection/src/traits/structural_normalize.rs
View File

@ -22,7 +22,9 @@ impl<'tcx> StructurallyNormalizeExt<'tcx> for At<'_, 'tcx> {
assert!(!ty.is_ty_var(), "should have resolved vars before calling");
if self.infcx.next_trait_solver() {
while let ty::Alias(ty::Projection, projection_ty) = *ty.kind() {
while let ty::Alias(ty::Projection | ty::Inherent | ty::Weak, projection_ty) =
*ty.kind()
{
let new_infer_ty = self.infcx.next_ty_var(TypeVariableOrigin {
kind: TypeVariableOriginKind::NormalizeProjectionType,
span: self.cause.span,

12
tests/ui/for/issue-20605.next.stderr
View File

@ -34,12 +34,6 @@ error: the type `&mut <dyn Iterator<Item = &'a mut u8> as IntoIterator>::IntoIte
LL | for item in *things { *item = 0 }
| ^^^^^^^
error[E0614]: type `<<dyn Iterator<Item = &'a mut u8> as IntoIterator>::IntoIter as Iterator>::Item` cannot be dereferenced
--> $DIR/issue-20605.rs:5:27
|
LL | for item in *things { *item = 0 }
| ^^^^^
error[E0277]: the size for values of type `<<dyn Iterator<Item = &'a mut u8> as IntoIterator>::IntoIter as Iterator>::Item` cannot be known at compilation time
--> $DIR/issue-20605.rs:5:9
|
@ -66,6 +60,12 @@ LL | for item in *things { *item = 0 }
note: required by a bound in `None`
--> $SRC_DIR/core/src/option.rs:LL:COL
error[E0614]: type `<<dyn Iterator<Item = &'a mut u8> as IntoIterator>::IntoIter as Iterator>::Item` cannot be dereferenced
--> $DIR/issue-20605.rs:5:27
|
LL | for item in *things { *item = 0 }
| ^^^^^
error: aborting due to 9 previous errors
Some errors have detailed explanations: E0277, E0614.

11
tests/ui/lazy-type-alias/coerce-behind-lazy.current.stderr Normal file
View File

@ -0,0 +1,11 @@
warning: the feature `lazy_type_alias` is incomplete and may not be safe to use and/or cause compiler crashes
--> $DIR/coerce-behind-lazy.rs:5:12
|
LL | #![feature(lazy_type_alias)]
| ^^^^^^^^^^^^^^^
|
= note: see issue #112792 <https://github.com/rust-lang/rust/issues/112792> for more information
= note: `#[warn(incomplete_features)]` on by default
warning: 1 warning emitted

11
tests/ui/lazy-type-alias/coerce-behind-lazy.next.stderr Normal file
View File

@ -0,0 +1,11 @@
warning: the feature `lazy_type_alias` is incomplete and may not be safe to use and/or cause compiler crashes
--> $DIR/coerce-behind-lazy.rs:5:12
|
LL | #![feature(lazy_type_alias)]
| ^^^^^^^^^^^^^^^
|
= note: see issue #112792 <https://github.com/rust-lang/rust/issues/112792> for more information
= note: `#[warn(incomplete_features)]` on by default
warning: 1 warning emitted

16
tests/ui/lazy-type-alias/coerce-behind-lazy.rs Normal file
View File

@ -0,0 +1,16 @@
// check-pass
// revisions: current next
//[next] compile-flags: -Ztrait-solver=next
#![feature(lazy_type_alias)]
//~^ WARN the feature `lazy_type_alias` is incomplete
use std::any::Any;
type Coerce = Box<dyn Any>;
fn test() -> Coerce {
Box::new(1)
}
fn main() {}

2
tests/ui/traits/new-solver/lazy-nested-obligations-2.rs
View File

@ -1,5 +1,5 @@
// compile-flags: -Ztrait-solver=next
// known-bug: #95863
// check-pass
pub trait With {
type F;

39
tests/ui/traits/new-solver/lazy-nested-obligations-2.stderr
View File

@ -1,39 +0,0 @@
error[E0308]: mismatched types
--> $DIR/lazy-nested-obligations-2.rs:15:23
|
LL | let _: V<i32> = V(f);
| - ^ types differ
| |
| arguments to this struct are incorrect
|
= note: expected associated type `<i32 as With>::F`
found fn item `for<'a> fn(&'a str) {f}`
= help: consider constraining the associated type `<i32 as With>::F` to `for<'a> fn(&'a str) {f}` or calling a method that returns `<i32 as With>::F`
= note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
note: tuple struct defined here
--> $DIR/lazy-nested-obligations-2.rs:16:16
|
LL | pub struct V<T: With>(<T as With>::F);
| ^
error[E0308]: mismatched types
--> $DIR/lazy-nested-obligations-2.rs:21:30
|
LL | let _: E3<i32> = E3::Var(f);
| ------- ^ types differ
| |
| arguments to this enum variant are incorrect
|
= note: expected associated type `<i32 as With>::F`
found fn item `for<'a> fn(&'a str) {f}`
= help: consider constraining the associated type `<i32 as With>::F` to `for<'a> fn(&'a str) {f}` or calling a method that returns `<i32 as With>::F`
= note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
note: tuple variant defined here
--> $DIR/lazy-nested-obligations-2.rs:19:9
|
LL | Var(<T as With>::F),
| ^^^
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0308`.

4
tests/ui/traits/new-solver/more-object-bound.stderr
View File

@ -1,8 +1,8 @@
error[E0277]: the trait bound `dyn Trait<A = A, B = B>: Trait` is not satisfied
--> $DIR/more-object-bound.rs:12:17
--> $DIR/more-object-bound.rs:12:5
|
LL | foo::<A, B, dyn Trait<A = A, B = B>>(x)
| ^^^^^^^^^^^^^^^^^^^^^^^ the trait `Trait` is not implemented for `dyn Trait<A = A, B = B>`
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Trait` is not implemented for `dyn Trait<A = A, B = B>`
|
note: required by a bound in `foo`
--> $DIR/more-object-bound.rs:18:8