From 1ade3184d4d4147aa00e75ebf904cf633aed92f6 Mon Sep 17 00:00:00 2001 From: Jack Date: Wed, 21 Oct 2020 22:44:08 -0400 Subject: [PATCH] Remove remaining unneeded substitutions --- chalk-engine/src/slg.rs | 14 ++--- chalk-engine/src/slg/aggregate.rs | 38 +++++++---- chalk-engine/src/slg/resolvent.rs | 19 +++--- chalk-integration/src/lowering.rs | 24 ++----- chalk-integration/src/lowering/env.rs | 9 +-- chalk-integration/src/program.rs | 4 +- chalk-ir/src/could_match.rs | 24 +++---- chalk-ir/src/debug.rs | 63 ++++++------------- chalk-ir/src/fold.rs | 16 +++-- chalk-ir/src/lib.rs | 6 +- chalk-ir/src/visit.rs | 48 ++++++++------ chalk-solve/src/clauses.rs | 12 ++-- .../src/clauses/builtin_traits/copy.rs | 9 ++- .../src/clauses/builtin_traits/sized.rs | 4 +- chalk-solve/src/display/ty.rs | 38 +++-------- chalk-solve/src/infer/unify.rs | 19 +++--- chalk-solve/src/wf.rs | 40 ++++++------ 17 files changed, 169 insertions(+), 218 deletions(-) diff --git a/chalk-engine/src/slg.rs b/chalk-engine/src/slg.rs index cbeb6e57684..1ae8ee6f1db 100644 --- a/chalk-engine/src/slg.rs +++ b/chalk-engine/src/slg.rs @@ -439,11 +439,13 @@ impl MayInvalidate<'_, I> { (TyKind::FnDef(id_a, substitution_a), TyKind::FnDef(id_b, substitution_b)) => { self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b) } - (TyKind::Ref(id_a, substitution_a), TyKind::Ref(id_b, substitution_b)) => { - self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b) + (TyKind::Ref(id_a, lifetime_a, ty_a), TyKind::Ref(id_b, lifetime_b, ty_b)) => { + id_a != id_b + || self.aggregate_lifetimes(lifetime_a, lifetime_b) + || self.aggregate_tys(ty_a, ty_b) } - (TyKind::Raw(id_a, substitution_a), TyKind::Raw(id_b, substitution_b)) => { - self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b) + (TyKind::Raw(id_a, ty_a), TyKind::Raw(id_b, ty_b)) => { + id_a != id_b || self.aggregate_tys(ty_a, ty_b) } (TyKind::Never, TyKind::Never) => false, (TyKind::Array(ty_a, const_a), TyKind::Array(ty_b, const_b)) => { @@ -459,9 +461,7 @@ impl MayInvalidate<'_, I> { TyKind::GeneratorWitness(id_a, substitution_a), TyKind::GeneratorWitness(id_b, substitution_b), ) => self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b), - (TyKind::Foreign(id_a, substitution_a), TyKind::Foreign(id_b, substitution_b)) => { - self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b) - } + (TyKind::Foreign(id_a), TyKind::Foreign(id_b)) => id_a != id_b, (TyKind::Error, TyKind::Error) => false, (_, _) => true, diff --git a/chalk-engine/src/slg/aggregate.rs b/chalk-engine/src/slg/aggregate.rs index f8dc1280d95..711fc81ba4e 100644 --- a/chalk-engine/src/slg/aggregate.rs +++ b/chalk-engine/src/slg/aggregate.rs @@ -303,14 +303,25 @@ impl AntiUnifier<'_, '_, I> { .aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b) .map(|(&name, substitution)| TyKind::FnDef(name, substitution).intern(interner)) .unwrap_or_else(|| self.new_ty_variable()), - (TyKind::Ref(id_a, substitution_a), TyKind::Ref(id_b, substitution_b)) => self - .aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b) - .map(|(&name, substitution)| TyKind::Ref(name, substitution).intern(interner)) - .unwrap_or_else(|| self.new_ty_variable()), - (TyKind::Raw(id_a, substitution_a), TyKind::Raw(id_b, substitution_b)) => self - .aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b) - .map(|(&name, substitution)| TyKind::Raw(name, substitution).intern(interner)) - .unwrap_or_else(|| self.new_ty_variable()), + (TyKind::Ref(id_a, lifetime_a, ty_a), TyKind::Ref(id_b, lifetime_b, ty_b)) => { + if id_a == id_b { + TyKind::Ref( + *id_a, + self.aggregate_lifetimes(lifetime_a, lifetime_b), + self.aggregate_tys(ty_a, ty_b), + ) + .intern(interner) + } else { + self.new_ty_variable() + } + } + (TyKind::Raw(id_a, ty_a), TyKind::Raw(id_b, ty_b)) => { + if id_a == id_b { + TyKind::Raw(*id_a, self.aggregate_tys(ty_a, ty_b)).intern(interner) + } else { + self.new_ty_variable() + } + } (TyKind::Never, TyKind::Never) => TyKind::Never.intern(interner), (TyKind::Array(ty_a, const_a), TyKind::Array(ty_b, const_b)) => TyKind::Array( self.aggregate_tys(ty_a, ty_b), @@ -337,10 +348,13 @@ impl AntiUnifier<'_, '_, I> { TyKind::GeneratorWitness(name, substitution).intern(interner) }) .unwrap_or_else(|| self.new_ty_variable()), - (TyKind::Foreign(id_a, substitution_a), TyKind::Foreign(id_b, substitution_b)) => self - .aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b) - .map(|(&name, substitution)| TyKind::Foreign(name, substitution).intern(interner)) - .unwrap_or_else(|| self.new_ty_variable()), + (TyKind::Foreign(id_a), TyKind::Foreign(id_b)) => { + if id_a == id_b { + TyKind::Foreign(*id_a).intern(interner) + } else { + self.new_ty_variable() + } + } (TyKind::Error, TyKind::Error) => TyKind::Error.intern(interner), (_, _) => self.new_ty_variable(), diff --git a/chalk-engine/src/slg/resolvent.rs b/chalk-engine/src/slg/resolvent.rs index 3c16cb5f060..86725e287ee 100644 --- a/chalk-engine/src/slg/resolvent.rs +++ b/chalk-engine/src/slg/resolvent.rs @@ -443,18 +443,16 @@ impl<'i, I: Interner> Zipper<'i, I> for AnswerSubstitutor<'i, I> { Zip::zip_with(self, substitution_a, substitution_b) } ( - TyKind::Ref(mutability_a, substitution_a), - TyKind::Ref(mutability_b, substitution_b), + TyKind::Ref(mutability_a, lifetime_a, ty_a), + TyKind::Ref(mutability_b, lifetime_b, ty_b), ) => { Zip::zip_with(self, mutability_a, mutability_b)?; - Zip::zip_with(self, substitution_a, substitution_b) + Zip::zip_with(self, lifetime_a, lifetime_b)?; + Zip::zip_with(self, ty_a, ty_b) } - ( - TyKind::Raw(mutability_a, substitution_a), - TyKind::Raw(mutability_b, substitution_b), - ) => { + (TyKind::Raw(mutability_a, ty_a), TyKind::Raw(mutability_b, ty_b)) => { Zip::zip_with(self, mutability_a, mutability_b)?; - Zip::zip_with(self, substitution_a, substitution_b) + Zip::zip_with(self, ty_a, ty_b) } (TyKind::Never, TyKind::Never) => Ok(()), (TyKind::Array(ty_a, const_a), TyKind::Array(ty_b, const_b)) => { @@ -476,10 +474,7 @@ impl<'i, I: Interner> Zipper<'i, I> for AnswerSubstitutor<'i, I> { Zip::zip_with(self, id_a, id_b)?; Zip::zip_with(self, substitution_a, substitution_b) } - (TyKind::Foreign(id_a, substitution_a), TyKind::Foreign(id_b, substitution_b)) => { - Zip::zip_with(self, id_a, id_b)?; - Zip::zip_with(self, substitution_a, substitution_b) - } + (TyKind::Foreign(id_a), TyKind::Foreign(id_b)) => Zip::zip_with(self, id_a, id_b), (TyKind::Error, TyKind::Error) => Ok(()), (_, _) => panic!( diff --git a/chalk-integration/src/lowering.rs b/chalk-integration/src/lowering.rs index 1d5c047f822..e09e3c238ef 100644 --- a/chalk-integration/src/lowering.rs +++ b/chalk-integration/src/lowering.rs @@ -788,30 +788,16 @@ impl LowerWithEnv for Ty { Ty::Slice { ty } => chalk_ir::TyKind::Slice(ty.lower(env)?).intern(interner), - Ty::Raw { mutability, ty } => chalk_ir::TyKind::Raw( - mutability.lower(), - chalk_ir::Substitution::from_fallible( - interner, - std::iter::once(Ok(ty.lower(env)?)), - )?, - ) - .intern(interner), + Ty::Raw { mutability, ty } => { + chalk_ir::TyKind::Raw(mutability.lower(), ty.lower(env)?).intern(interner) + } Ty::Ref { mutability, lifetime, ty, - } => chalk_ir::TyKind::Ref( - mutability.lower(), - chalk_ir::Substitution::from_iter( - interner, - &[ - lifetime.lower(env)?.cast(interner), - ty.lower(env)?.cast(interner), - ], - ), - ) - .intern(interner), + } => chalk_ir::TyKind::Ref(mutability.lower(), lifetime.lower(env)?, ty.lower(env)?) + .intern(interner), Ty::Str => chalk_ir::TyKind::Str.intern(interner), diff --git a/chalk-integration/src/lowering/env.rs b/chalk-integration/src/lowering/env.rs index a0de70c0c26..6f1006e9d88 100644 --- a/chalk-integration/src/lowering/env.rs +++ b/chalk-integration/src/lowering/env.rs @@ -162,12 +162,9 @@ impl Env<'_> { )) .intern(interner) .cast(interner)), - Ok(TypeLookup::Foreign(id)) => Ok(chalk_ir::TyKind::Foreign( - id, - chalk_ir::Substitution::empty(interner), - ) - .intern(interner) - .cast(interner)), + Ok(TypeLookup::Foreign(id)) => Ok(chalk_ir::TyKind::Foreign(id) + .intern(interner) + .cast(interner)), Ok(TypeLookup::Trait(_)) => Err(RustIrError::NotStruct(name.clone())), Err(_) => Err(RustIrError::InvalidParameterName(name.clone())), } diff --git a/chalk-integration/src/program.rs b/chalk-integration/src/program.rs index 4bfbb143547..a117413837a 100644 --- a/chalk-integration/src/program.rs +++ b/chalk-integration/src/program.rs @@ -464,7 +464,7 @@ impl RustIrDatabase for Program { (TyKind::OpaqueType(id_a, _), TyKind::OpaqueType(id_b, _)) => id_a == id_b, (TyKind::Slice(_), TyKind::Slice(_)) => true, (TyKind::FnDef(id_a, _), TyKind::FnDef(id_b, _)) => id_a == id_b, - (TyKind::Ref(id_a, _), TyKind::Ref(id_b, _)) => id_a == id_b, + (TyKind::Ref(id_a, _, _), TyKind::Ref(id_b, _, _)) => id_a == id_b, (TyKind::Raw(id_a, _), TyKind::Raw(id_b, _)) => id_a == id_b, (TyKind::Never, TyKind::Never) => true, (TyKind::Array(_, _), TyKind::Array(_, _)) => true, @@ -473,7 +473,7 @@ impl RustIrDatabase for Program { (TyKind::GeneratorWitness(id_a, _), TyKind::GeneratorWitness(id_b, _)) => { id_a == id_b } - (TyKind::Foreign(id_a, _), TyKind::Foreign(id_b, _)) => id_a == id_b, + (TyKind::Foreign(id_a), TyKind::Foreign(id_b)) => id_a == id_b, (TyKind::Error, TyKind::Error) => true, (_, _) => false, } diff --git a/chalk-ir/src/could_match.rs b/chalk-ir/src/could_match.rs index 47bf236c299..4bb79569e01 100644 --- a/chalk-ir/src/could_match.rs +++ b/chalk-ir/src/could_match.rs @@ -55,13 +55,16 @@ where TyKind::FnDef(fn_def_b, substitution_b), ) => fn_def_a == fn_def_b && matches(substitution_a, substitution_b), ( - TyKind::Ref(mutability_a, substitution_a), - TyKind::Ref(mutability_b, substitution_b), - ) => mutability_a == mutability_b && matches(substitution_a, substitution_b), - ( - TyKind::Raw(mutability_a, substitution_a), - TyKind::Raw(mutability_b, substitution_b), - ) => mutability_a == mutability_b && matches(substitution_a, substitution_b), + TyKind::Ref(mutability_a, lifetime_a, ty_a), + TyKind::Ref(mutability_b, lifetime_b, ty_b), + ) => { + mutability_a == mutability_b + && lifetime_a.could_match(interner, &lifetime_b) + && ty_a.could_match(interner, &ty_b) + } + (TyKind::Raw(mutability_a, ty_a), TyKind::Raw(mutability_b, ty_b)) => { + mutability_a == mutability_b && ty_a.could_match(interner, &ty_b) + } (TyKind::Never, TyKind::Never) => true, (TyKind::Array(ty_a, const_a), TyKind::Array(ty_b, const_b)) => { ty_a.could_match(interner, ty_b) && const_a.could_match(interner, const_b) @@ -78,10 +81,9 @@ where TyKind::GeneratorWitness(generator_a, substitution_a), TyKind::GeneratorWitness(generator_b, substitution_b), ) => generator_a == generator_b && matches(substitution_a, substitution_b), - ( - TyKind::Foreign(foreign_ty_a, substitution_a), - TyKind::Foreign(foreign_ty_b, substitution_b), - ) => foreign_ty_a == foreign_ty_b && matches(substitution_a, substitution_b), + (TyKind::Foreign(foreign_ty_a), TyKind::Foreign(foreign_ty_b)) => { + foreign_ty_a == foreign_ty_b + } (TyKind::Error, TyKind::Error) => true, _ => true, diff --git a/chalk-ir/src/debug.rs b/chalk-ir/src/debug.rs index 65362b85dae..7d79cc3149e 100644 --- a/chalk-ir/src/debug.rs +++ b/chalk-ir/src/debug.rs @@ -205,24 +205,14 @@ impl Debug for TyKind { } TyKind::Slice(substitution) => write!(fmt, "{{slice}}<{:?}>", substitution), TyKind::FnDef(fn_def, substitution) => write!(fmt, "{:?}<{:?}>", fn_def, substitution), - TyKind::Ref(mutability, substitution) => write!( - fmt, - "{}<{:?}>", - match mutability { - Mutability::Mut => "{{&mut}}", - Mutability::Not => "{{&}}", - }, - substitution, - ), - TyKind::Raw(mutability, substitution) => write!( - fmt, - "{}<{:?}>", - match mutability { - Mutability::Mut => "{{*mut}}", - Mutability::Not => "{{*const}}", - }, - substitution, - ), + TyKind::Ref(mutability, lifetime, ty) => match mutability { + Mutability::Mut => write!(fmt, "(&{:?} mut {:?})", lifetime, ty), + Mutability::Not => write!(fmt, "(&{:?} {:?})", lifetime, ty), + }, + TyKind::Raw(mutability, ty) => match mutability { + Mutability::Mut => write!(fmt, "(*mut {:?})", ty), + Mutability::Not => write!(fmt, "(*const {:?})", ty), + }, TyKind::Never => write!(fmt, "Never"), TyKind::Array(ty, const_) => write!(fmt, "[{:?}; {:?}]", ty, const_), TyKind::Closure(id, substitution) => { @@ -234,9 +224,7 @@ impl Debug for TyKind { TyKind::GeneratorWitness(witness, substitution) => { write!(fmt, "{:?}<{:?}>", witness, substitution) } - TyKind::Foreign(foreign_ty, substitution) => { - write!(fmt, "{:?}<{:?}>", foreign_ty, substitution) - } + TyKind::Foreign(foreign_ty) => write!(fmt, "{:?}", foreign_ty), TyKind::Error => write!(fmt, "{{error}}"), } } @@ -505,24 +493,14 @@ impl<'a, I: Interner> Debug for TyKindDebug<'a, I> { TyKind::FnDef(fn_def, substitution) => { write!(fmt, "{:?}{:?}", fn_def, substitution.with_angle(interner)) } - TyKind::Ref(mutability, substitution) => write!( - fmt, - "{}{:?}", - match mutability { - Mutability::Mut => "{{&mut}}", - Mutability::Not => "{{&}}", - }, - substitution.with_angle(interner), - ), - TyKind::Raw(mutability, substitution) => write!( - fmt, - "{}{:?}", - match mutability { - Mutability::Mut => "{{*mut}}", - Mutability::Not => "{{*const}}", - }, - substitution.with_angle(interner), - ), + TyKind::Ref(mutability, lifetime, ty) => match mutability { + Mutability::Mut => write!(fmt, "(&{:?} mut {:?})", lifetime, ty), + Mutability::Not => write!(fmt, "(&{:?} {:?})", lifetime, ty), + }, + TyKind::Raw(mutability, ty) => match mutability { + Mutability::Mut => write!(fmt, "(*mut {:?})", ty), + Mutability::Not => write!(fmt, "(*const {:?})", ty), + }, TyKind::Never => write!(fmt, "Never"), TyKind::Array(ty, const_) => write!(fmt, "[{:?}; {:?}]", ty, const_), TyKind::Closure(id, substitution) => write!( @@ -540,12 +518,7 @@ impl<'a, I: Interner> Debug for TyKindDebug<'a, I> { TyKind::GeneratorWitness(witness, substitution) => { write!(fmt, "{:?}{:?}", witness, substitution.with_angle(interner)) } - TyKind::Foreign(foreign_ty, substitution) => write!( - fmt, - "{:?}{:?}", - foreign_ty, - substitution.with_angle(interner) - ), + TyKind::Foreign(foreign_ty) => write!(fmt, "{:?}", foreign_ty,), TyKind::Error => write!(fmt, "{{error}}"), } } diff --git a/chalk-ir/src/fold.rs b/chalk-ir/src/fold.rs index 484d4b74ee6..454e634573e 100644 --- a/chalk-ir/src/fold.rs +++ b/chalk-ir/src/fold.rs @@ -463,14 +463,15 @@ where substitution.fold_with(folder, outer_binder)?, ) .intern(folder.target_interner()), - TyKind::Ref(mutability, substitution) => TyKind::Ref( + TyKind::Ref(mutability, lifetime, ty) => TyKind::Ref( mutability.fold_with(folder, outer_binder)?, - substitution.fold_with(folder, outer_binder)?, + lifetime.fold_with(folder, outer_binder)?, + ty.fold_with(folder, outer_binder)?, ) .intern(folder.target_interner()), - TyKind::Raw(mutability, substitution) => TyKind::Raw( + TyKind::Raw(mutability, ty) => TyKind::Raw( mutability.fold_with(folder, outer_binder)?, - substitution.fold_with(folder, outer_binder)?, + ty.fold_with(folder, outer_binder)?, ) .intern(folder.target_interner()), TyKind::Never => TyKind::Never.intern(folder.target_interner()), @@ -494,11 +495,8 @@ where substitution.fold_with(folder, outer_binder)?, ) .intern(folder.target_interner()), - TyKind::Foreign(id, substitution) => TyKind::Foreign( - id.fold_with(folder, outer_binder)?, - substitution.fold_with(folder, outer_binder)?, - ) - .intern(folder.target_interner()), + TyKind::Foreign(id) => TyKind::Foreign(id.fold_with(folder, outer_binder)?) + .intern(folder.target_interner()), TyKind::Error => TyKind::Error.intern(folder.target_interner()), }) } diff --git a/chalk-ir/src/lib.rs b/chalk-ir/src/lib.rs index 5b613a422ba..d6b70e8465c 100644 --- a/chalk-ir/src/lib.rs +++ b/chalk-ir/src/lib.rs @@ -471,10 +471,10 @@ pub enum TyKind { Slice(Ty), /// a raw pointer type like `*const T` or `*mut T` - Raw(Mutability, Substitution), + Raw(Mutability, Ty), /// a reference type like `&T` or `&mut T` - Ref(Mutability, Substitution), + Ref(Mutability, Lifetime, Ty), /// a placeholder for opaque types like `impl Trait` OpaqueType(OpaqueTyId, Substitution), @@ -498,7 +498,7 @@ pub enum TyKind { GeneratorWitness(GeneratorId, Substitution), /// foreign types - Foreign(ForeignDefId, Substitution), + Foreign(ForeignDefId), /// This can be used to represent an error, e.g. during name resolution of a type. /// Chalk itself will not produce this, just pass it through when given. diff --git a/chalk-ir/src/visit.rs b/chalk-ir/src/visit.rs index 9e53da4d842..5a1ce0f18ba 100644 --- a/chalk-ir/src/visit.rs +++ b/chalk-ir/src/visit.rs @@ -291,32 +291,40 @@ where } TyKind::Scalar(scalar) => scalar.visit_with(visitor, outer_binder), TyKind::Str => R::new(), - TyKind::Tuple(_arity, substitution) => substitution.visit_with(visitor, outer_binder), - TyKind::OpaqueType(_opaque_ty, substitution) => { - substitution.visit_with(visitor, outer_binder) - } + TyKind::Tuple(arity, substitution) => arity + .visit_with(visitor, outer_binder) + .combine(substitution.visit_with(visitor, outer_binder)), + TyKind::OpaqueType(opaque_ty, substitution) => opaque_ty + .visit_with(visitor, outer_binder) + .combine(substitution.visit_with(visitor, outer_binder)), TyKind::Slice(substitution) => substitution.visit_with(visitor, outer_binder), - TyKind::FnDef(_fn_def, substitution) => substitution.visit_with(visitor, outer_binder), - TyKind::Ref(_mutability, substitution) => { - substitution.visit_with(visitor, outer_binder) - } - TyKind::Raw(_mutability, substitution) => { - substitution.visit_with(visitor, outer_binder) + TyKind::FnDef(fn_def, substitution) => fn_def + .visit_with(visitor, outer_binder) + .combine(substitution.visit_with(visitor, outer_binder)), + TyKind::Ref(mutability, lifetime, ty) => { + mutability.visit_with(visitor, outer_binder).combine( + lifetime + .visit_with(visitor, outer_binder) + .combine(ty.visit_with(visitor, outer_binder)), + ) } + TyKind::Raw(mutability, ty) => mutability + .visit_with(visitor, outer_binder) + .combine(ty.visit_with(visitor, outer_binder)), TyKind::Never => R::new(), TyKind::Array(ty, const_) => ty .visit_with(visitor, outer_binder) .combine(const_.visit_with(visitor, outer_binder)), - TyKind::Closure(_id, substitution) => substitution.visit_with(visitor, outer_binder), - TyKind::Generator(_generator, substitution) => { - substitution.visit_with(visitor, outer_binder) - } - TyKind::GeneratorWitness(_witness, substitution) => { - substitution.visit_with(visitor, outer_binder) - } - TyKind::Foreign(_foreign_ty, substitution) => { - substitution.visit_with(visitor, outer_binder) - } + TyKind::Closure(id, substitution) => id + .visit_with(visitor, outer_binder) + .combine(substitution.visit_with(visitor, outer_binder)), + TyKind::Generator(generator, substitution) => generator + .visit_with(visitor, outer_binder) + .combine(substitution.visit_with(visitor, outer_binder)), + TyKind::GeneratorWitness(witness, substitution) => witness + .visit_with(visitor, outer_binder) + .combine(substitution.visit_with(visitor, outer_binder)), + TyKind::Foreign(foreign_ty) => foreign_ty.visit_with(visitor, outer_binder), TyKind::Error => R::new(), } } diff --git a/chalk-solve/src/clauses.rs b/chalk-solve/src/clauses.rs index 3425170ac72..6e8aa1c5ffd 100644 --- a/chalk-solve/src/clauses.rs +++ b/chalk-solve/src/clauses.rs @@ -37,15 +37,13 @@ fn constituent_types(db: &dyn RustIrDatabase, ty: &TyKind) -> // And for `PhantomData`, we pass `T`. TyKind::Adt(_, substitution) | TyKind::Tuple(_, substitution) - | TyKind::Raw(_, substitution) - | TyKind::Ref(_, substitution) | TyKind::FnDef(_, substitution) => substitution .iter(interner) .filter_map(|x| x.ty(interner)) .cloned() .collect(), - TyKind::Slice(ty) => vec![ty.clone()], + TyKind::Raw(_, ty) | TyKind::Ref(_, _, ty) | TyKind::Slice(ty) => vec![ty.clone()], TyKind::Array(_, _) | TyKind::Str | TyKind::Never | TyKind::Scalar(_) => Vec::new(), @@ -73,7 +71,7 @@ fn constituent_types(db: &dyn RustIrDatabase, ty: &TyKind) -> TyKind::Placeholder(_) => panic!("this function should not be called for placeholders"), TyKind::Dyn(_) => panic!("this function should not be called for dyn types"), TyKind::Alias(_) => panic!("this function should not be called for alias"), - TyKind::Foreign(_, _) => panic!("constituent_types of foreign types are unknown!"), + TyKind::Foreign(_) => panic!("constituent_types of foreign types are unknown!"), TyKind::Error => Vec::new(), TyKind::OpaqueType(_, _) => unimplemented!(), TyKind::AssociatedType(_, _) => unimplemented!(), @@ -157,7 +155,7 @@ pub fn push_auto_trait_impls( TyKind::InferenceVar(_, _) | TyKind::BoundVar(_) => Err(Floundered), // auto traits are not implemented for foreign types - TyKind::Foreign(_, _) => Ok(()), + TyKind::Foreign(_) => Ok(()), // closures require binders, while the other types do not TyKind::Closure(closure_id, _) => { @@ -742,11 +740,11 @@ fn match_ty( | TyKind::Str | TyKind::Slice(_) | TyKind::Raw(_, _) - | TyKind::Ref(_, _) + | TyKind::Ref(_, _, _) | TyKind::Array(_, _) | TyKind::Never | TyKind::Closure(_, _) - | TyKind::Foreign(_, _) + | TyKind::Foreign(_) | TyKind::Generator(_, _) | TyKind::GeneratorWitness(_, _) => builder.push_fact(WellFormed::Ty(ty.clone())), TyKind::Placeholder(_) => { diff --git a/chalk-solve/src/clauses/builtin_traits/copy.rs b/chalk-solve/src/clauses/builtin_traits/copy.rs index bb999787143..16be9b662ea 100644 --- a/chalk-solve/src/clauses/builtin_traits/copy.rs +++ b/chalk-solve/src/clauses/builtin_traits/copy.rs @@ -56,14 +56,17 @@ pub fn add_copy_program_clauses( } // these impls are in libcore - TyKind::Ref(_, _) | TyKind::Raw(_, _) | TyKind::Scalar(_) | TyKind::Never | TyKind::Str => { - } + TyKind::Ref(_, _, _) + | TyKind::Raw(_, _) + | TyKind::Scalar(_) + | TyKind::Never + | TyKind::Str => {} TyKind::Adt(_, _) | TyKind::AssociatedType(_, _) | TyKind::Slice(_) | TyKind::OpaqueType(_, _) - | TyKind::Foreign(_, _) + | TyKind::Foreign(_) | TyKind::Generator(_, _) | TyKind::GeneratorWitness(_, _) | TyKind::Error => {} diff --git a/chalk-solve/src/clauses/builtin_traits/sized.rs b/chalk-solve/src/clauses/builtin_traits/sized.rs index eef3166fde9..2cb35925acf 100644 --- a/chalk-solve/src/clauses/builtin_traits/sized.rs +++ b/chalk-solve/src/clauses/builtin_traits/sized.rs @@ -86,13 +86,13 @@ pub fn add_sized_program_clauses( | TyKind::Raw(_, _) | TyKind::Generator(_, _) | TyKind::GeneratorWitness(_, _) - | TyKind::Ref(_, _) => builder.push_fact(trait_ref.clone()), + | TyKind::Ref(_, _, _) => builder.push_fact(trait_ref.clone()), TyKind::AssociatedType(_, _) | TyKind::Slice(_) | TyKind::OpaqueType(_, _) | TyKind::Str - | TyKind::Foreign(_, _) + | TyKind::Foreign(_) | TyKind::Error => {} TyKind::Function(_) diff --git a/chalk-solve/src/display/ty.rs b/chalk-solve/src/display/ty.rs index 97c915fc832..749f163bb95 100644 --- a/chalk-solve/src/display/ty.rs +++ b/chalk-solve/src/display/ty.rs @@ -77,36 +77,14 @@ impl RenderAsRust for TyKind { "{}", display_type_with_generics(s, *opaque_ty_id, substitution.as_slice(interner)) ), - TyKind::Raw(raw, substitution) => { - let mutability = match raw { - Mutability::Mut => "*mut ", - Mutability::Not => "*const ", - }; - write!( - f, - "{}{}", - mutability, - substitution - .iter(interner) - .filter_map(move |p| p.ty(interner)) - .next() - .unwrap() - .display(s) - ) - } - TyKind::Ref(mutability, substitution) => { - let mutability = match mutability { - Mutability::Mut => "mut ", - Mutability::Not => "", - }; - write!( - f, - "&{} {}{}", - substitution.at(interner, 0).display(s), - mutability, - substitution.at(interner, 1).display(s) - ) - } + TyKind::Raw(mutability, ty) => match mutability { + Mutability::Mut => write!(f, "*mut {}", ty.display(s)), + Mutability::Not => write!(f, "*const {}", ty.display(s)), + }, + TyKind::Ref(mutability, lifetime, ty) => match mutability { + Mutability::Mut => write!(f, "&{} mut {}", lifetime.display(s), ty.display(s)), + Mutability::Not => write!(f, "&{} {}", lifetime.display(s), ty.display(s)), + }, TyKind::Str => write!(f, "str"), TyKind::Slice(ty) => write!(f, "[{}]", ty.display(s)), TyKind::Error => write!(f, "{{error}}"), diff --git a/chalk-solve/src/infer/unify.rs b/chalk-solve/src/infer/unify.rs index 286af81a5d2..89da5d8e692 100644 --- a/chalk-solve/src/infer/unify.rs +++ b/chalk-solve/src/infer/unify.rs @@ -184,18 +184,16 @@ impl<'t, I: Interner> Unifier<'t, I> { Zip::zip_with(self, substitution_a, substitution_b) } ( - TyKind::Ref(mutability_a, substitution_a), - TyKind::Ref(mutability_b, substitution_b), + TyKind::Ref(mutability_a, lifetime_a, ty_a), + TyKind::Ref(mutability_b, lifetime_b, ty_b), ) => { Zip::zip_with(self, mutability_a, mutability_b)?; - Zip::zip_with(self, substitution_a, substitution_b) + Zip::zip_with(self, lifetime_a, lifetime_b)?; + Zip::zip_with(self, ty_a, ty_b) } - ( - TyKind::Raw(mutability_a, substitution_a), - TyKind::Raw(mutability_b, substitution_b), - ) => { + (TyKind::Raw(mutability_a, ty_a), TyKind::Raw(mutability_b, ty_b)) => { Zip::zip_with(self, mutability_a, mutability_b)?; - Zip::zip_with(self, substitution_a, substitution_b) + Zip::zip_with(self, ty_a, ty_b) } (TyKind::Never, TyKind::Never) => Ok(()), (TyKind::Array(ty_a, const_a), TyKind::Array(ty_b, const_b)) => { @@ -217,10 +215,7 @@ impl<'t, I: Interner> Unifier<'t, I> { Zip::zip_with(self, id_a, id_b)?; Zip::zip_with(self, substitution_a, substitution_b) } - (TyKind::Foreign(id_a, substitution_a), TyKind::Foreign(id_b, substitution_b)) => { - Zip::zip_with(self, id_a, id_b)?; - Zip::zip_with(self, substitution_a, substitution_b) - } + (TyKind::Foreign(id_a), TyKind::Foreign(id_b)) => Zip::zip_with(self, id_a, id_b), (TyKind::Error, TyKind::Error) => Ok(()), (_, _) => Err(NoSolution), diff --git a/chalk-solve/src/wf.rs b/chalk-solve/src/wf.rs index b1a54053239..57410e8ff7e 100644 --- a/chalk-solve/src/wf.rs +++ b/chalk-solve/src/wf.rs @@ -102,12 +102,14 @@ impl<'i, I: Interner> Visitor<'i, I> for InputTypeCollector<'i, I> { .push(ty.shifted_out_to(interner, outer_binder).unwrap()) }; match ty.kind(interner) { - TyKind::Adt(_id, substitution) => { + TyKind::Adt(id, substitution) => { push_ty(); + id.visit_with(self, outer_binder); substitution.visit_with(self, outer_binder); } - TyKind::AssociatedType(_assoc_ty, substitution) => { + TyKind::AssociatedType(assoc_ty, substitution) => { push_ty(); + assoc_ty.visit_with(self, outer_binder); substitution.visit_with(self, outer_binder); } TyKind::Scalar(scalar) => { @@ -117,28 +119,34 @@ impl<'i, I: Interner> Visitor<'i, I> for InputTypeCollector<'i, I> { TyKind::Str => { push_ty(); } - TyKind::Tuple(_arity, substitution) => { + TyKind::Tuple(arity, substitution) => { push_ty(); + arity.visit_with(self, outer_binder); substitution.visit_with(self, outer_binder); } - TyKind::OpaqueType(_opaque_ty, substitution) => { + TyKind::OpaqueType(opaque_ty, substitution) => { push_ty(); + opaque_ty.visit_with(self, outer_binder); substitution.visit_with(self, outer_binder); } TyKind::Slice(substitution) => { push_ty(); substitution.visit_with(self, outer_binder); } - TyKind::FnDef(_fn_def, substitution) => { + TyKind::FnDef(fn_def, substitution) => { push_ty(); + fn_def.visit_with(self, outer_binder); substitution.visit_with(self, outer_binder); } - TyKind::Ref(_mutability, substitution) => { + TyKind::Ref(mutability, lifetime, ty) => { push_ty(); - substitution.visit_with(self, outer_binder); + mutability.visit_with(self, outer_binder); + lifetime.visit_with(self, outer_binder); + ty.visit_with(self, outer_binder); } - TyKind::Raw(_mutability, substitution) => { + TyKind::Raw(mutability, substitution) => { push_ty(); + mutability.visit_with(self, outer_binder); substitution.visit_with(self, outer_binder); } TyKind::Never => { @@ -161,9 +169,8 @@ impl<'i, I: Interner> Visitor<'i, I> for InputTypeCollector<'i, I> { push_ty(); substitution.visit_with(self, outer_binder); } - TyKind::Foreign(_foreign_ty, substitution) => { + TyKind::Foreign(_foreign_ty) => { push_ty(); - substitution.visit_with(self, outer_binder); } TyKind::Error => { push_ty(); @@ -696,7 +703,7 @@ impl WfWellKnownConstraints { { TyKind::Scalar(_) | TyKind::Raw(_, _) - | TyKind::Ref(Mutability::Not, _) + | TyKind::Ref(Mutability::Not, _, _) | TyKind::Never => return true, TyKind::Adt(_, _) => (), @@ -941,16 +948,13 @@ impl WfWellKnownConstraints { }; match (source.kind(interner), target.kind(interner)) { - (TyKind::Ref(s_m, subst_a), TyKind::Ref(t_m, subst_b)) - | (TyKind::Ref(s_m, subst_a), TyKind::Raw(t_m, subst_b)) - | (TyKind::Raw(s_m, subst_a), TyKind::Raw(t_m, subst_b)) => { + (TyKind::Ref(s_m, _, source), TyKind::Ref(t_m, _, target)) + | (TyKind::Ref(s_m, _, source), TyKind::Raw(t_m, target)) + | (TyKind::Raw(s_m, source), TyKind::Raw(t_m, target)) => { if (*s_m, *t_m) == (Mutability::Not, Mutability::Mut) { return false; } - let source = subst_a.type_parameters(interner).next().unwrap(); - let target = subst_b.type_parameters(interner).next().unwrap(); - let unsize_trait_id = if let Some(id) = db.well_known_trait_id(WellKnownTrait::Unsize) { id @@ -963,7 +967,7 @@ impl WfWellKnownConstraints { trait_id: unsize_trait_id, substitution: Substitution::from_iter( interner, - [source, target].iter().cloned(), + [source.clone(), target.clone()].iter().cloned(), ), } .cast(interner);