diff --git a/chalk-derive/src/lib.rs b/chalk-derive/src/lib.rs index faf63909166..3bc1573e265 100644 --- a/chalk-derive/src/lib.rs +++ b/chalk-derive/src/lib.rs @@ -277,49 +277,33 @@ fn derive_fold(mut s: synstructure::Structure) -> TokenStream { let type_name = &input.ident; - let (target_interner, result) = match kind { - DeriveKind::FromHasInternerAttr => (interner.clone(), quote! { #type_name }), - DeriveKind::FromHasInterner => { - let param = get_generic_param_name(input).unwrap(); - - s.add_impl_generic(parse_quote! { _U }) - .add_impl_generic(parse_quote! { _TI }) - .add_where_predicate( - parse_quote! { #param: ::chalk_ir::fold::Fold<#interner, _TI, Result = _U> }, - ) - .add_where_predicate( - parse_quote! { _U: ::chalk_ir::interner::HasInterner }, - ) - .add_where_predicate( - parse_quote! { _TI: ::chalk_ir::interner::TargetInterner<#interner> }, - ); - - (quote! { _TI }, quote! { #type_name<_U> }) - } - DeriveKind::FromInterner => { - s.add_impl_generic(parse_quote! { _TI }) - .add_where_predicate( - parse_quote! { _TI: ::chalk_ir::interner::TargetInterner<#interner> }, - ); - - (quote! { _TI }, quote! { #type_name<_TI> }) - } + let result = if kind == DeriveKind::FromHasInterner { + let param = get_generic_param_name(input).unwrap(); + s.add_impl_generic(parse_quote! { _U }) + .add_where_predicate( + parse_quote! { #param: ::chalk_ir::fold::Fold<#interner, Result = _U> }, + ) + .add_where_predicate( + parse_quote! { _U: ::chalk_ir::interner::HasInterner }, + ); + quote! { #type_name <_U> } + } else { + quote! { #type_name < #interner > } }; s.add_bounds(synstructure::AddBounds::None); s.bound_impl( - quote!(::chalk_ir::fold::Fold<#interner, #target_interner>), + quote!(::chalk_ir::fold::Fold<#interner>), quote! { type Result = #result; fn fold_with<'i>( &self, - folder: &mut dyn ::chalk_ir::fold::Folder < 'i, #interner, #target_interner >, + folder: &mut dyn ::chalk_ir::fold::Folder < 'i, #interner >, outer_binder: ::chalk_ir::DebruijnIndex, ) -> ::chalk_ir::Fallible where #interner: 'i, - #target_interner: 'i, { Ok(match *self { #body }) } diff --git a/chalk-engine/src/lib.rs b/chalk-engine/src/lib.rs index 369de54fe92..f9ef26bebbf 100644 --- a/chalk-engine/src/lib.rs +++ b/chalk-engine/src/lib.rs @@ -57,7 +57,7 @@ use std::cmp::min; use std::usize; use chalk_derive::{Fold, HasInterner, Visit}; -use chalk_ir::interner::{Interner, TargetInterner}; +use chalk_ir::interner::Interner; use chalk_ir::visit::VisitResult; use chalk_ir::{ AnswerSubst, Canonical, ConstrainedSubst, Constraint, DebruijnIndex, Goal, InEnvironment, diff --git a/chalk-engine/src/normalize_deep.rs b/chalk-engine/src/normalize_deep.rs index 53f9112c786..105d7bd9d0d 100644 --- a/chalk-engine/src/normalize_deep.rs +++ b/chalk-engine/src/normalize_deep.rs @@ -97,10 +97,6 @@ where fn interner(&self) -> &'i I { self.interner } - - fn target_interner(&self) -> &'i I { - self.interner() - } } #[cfg(test)] diff --git a/chalk-ir/src/fold.rs b/chalk-ir/src/fold.rs index 454e634573e..1fca1bf2483 100644 --- a/chalk-ir/src/fold.rs +++ b/chalk-ir/src/fold.rs @@ -1,6 +1,5 @@ //! Traits for transforming bits of IR. -use crate::interner::TargetInterner; use crate::*; use std::fmt::Debug; @@ -20,15 +19,6 @@ pub use self::subst::Subst; /// `Folder`, will reconstruct itself, invoking the folder's methods /// to transform each of the types/lifetimes embedded within. /// -/// # Interners -/// -/// The Folder trait has two type parameters, `I` and `TI`: -/// -/// * `I` is the "source interner" that we are folding *from* -/// * `TI` is the "target interner" that we are folding *into* -/// -/// Often, both are the same. -/// /// # Usage patterns /// /// ## Substituting for free variables @@ -63,10 +53,9 @@ pub use self::subst::Subst; /// ```rust,ignore /// let x = x.fold_with(&mut folder, 0); /// ``` -pub trait Folder<'i, I: Interner, TI: TargetInterner = I> +pub trait Folder<'i, I: Interner> where I: 'i, - TI: 'i, { /// Creates a `dyn` value from this folder. Unfortunately, this /// must be added manually to each impl of Folder; it permits the @@ -75,13 +64,13 @@ where /// method). Effectively, this limits impls of `Folder` to types /// for which we are able to create a dyn value (i.e., not `[T]` /// types). - fn as_dyn(&mut self) -> &mut dyn Folder<'i, I, TI>; + fn as_dyn(&mut self) -> &mut dyn Folder<'i, I>; /// Top-level callback: invoked for each `Ty` that is /// encountered when folding. By default, invokes /// `super_fold_with`, which will in turn invoke the more /// specialized folding methods below, like `fold_free_var_ty`. - fn fold_ty(&mut self, ty: &Ty, outer_binder: DebruijnIndex) -> Fallible> { + fn fold_ty(&mut self, ty: &Ty, outer_binder: DebruijnIndex) -> Fallible> { ty.super_fold_with(self.as_dyn(), outer_binder) } @@ -93,7 +82,7 @@ where &mut self, lifetime: &Lifetime, outer_binder: DebruijnIndex, - ) -> Fallible> { + ) -> Fallible> { lifetime.super_fold_with(self.as_dyn(), outer_binder) } @@ -105,7 +94,7 @@ where &mut self, constant: &Const, outer_binder: DebruijnIndex, - ) -> Fallible> { + ) -> Fallible> { constant.super_fold_with(self.as_dyn(), outer_binder) } @@ -114,12 +103,12 @@ where &mut self, clause: &ProgramClause, outer_binder: DebruijnIndex, - ) -> Fallible> { + ) -> Fallible> { clause.super_fold_with(self.as_dyn(), outer_binder) } /// Invoked for every goal. By default, recursively folds the goals contents. - fn fold_goal(&mut self, goal: &Goal, outer_binder: DebruijnIndex) -> Fallible> { + fn fold_goal(&mut self, goal: &Goal, outer_binder: DebruijnIndex) -> Fallible> { goal.super_fold_with(self.as_dyn(), outer_binder) } @@ -143,7 +132,7 @@ where &mut self, bound_var: BoundVar, outer_binder: DebruijnIndex, - ) -> Fallible> { + ) -> Fallible> { if self.forbid_free_vars() { panic!( "unexpected free variable with depth `{:?}` with outer binder {:?}", @@ -151,7 +140,7 @@ where ) } else { let bound_var = bound_var.shifted_in_from(outer_binder); - Ok(TyKind::::BoundVar(bound_var).intern(self.target_interner())) + Ok(TyKind::::BoundVar(bound_var).intern(self.interner())) } } @@ -160,7 +149,7 @@ where &mut self, bound_var: BoundVar, outer_binder: DebruijnIndex, - ) -> Fallible> { + ) -> Fallible> { if self.forbid_free_vars() { panic!( "unexpected free variable with depth `{:?}` with outer binder {:?}", @@ -168,7 +157,7 @@ where ) } else { let bound_var = bound_var.shifted_in_from(outer_binder); - Ok(LifetimeData::::BoundVar(bound_var).intern(self.target_interner())) + Ok(LifetimeData::::BoundVar(bound_var).intern(self.interner())) } } @@ -178,7 +167,7 @@ where ty: &Ty, bound_var: BoundVar, outer_binder: DebruijnIndex, - ) -> Fallible> { + ) -> Fallible> { if self.forbid_free_vars() { panic!( "unexpected free variable with depth `{:?}` with outer binder {:?}", @@ -188,9 +177,9 @@ where let bound_var = bound_var.shifted_in_from(outer_binder); Ok(ConstData { ty: ty.fold_with(self.as_dyn(), outer_binder)?, - value: ConstValue::::BoundVar(bound_var), + value: ConstValue::::BoundVar(bound_var), } - .intern(self.target_interner())) + .intern(self.interner())) } } @@ -212,11 +201,11 @@ where &mut self, universe: PlaceholderIndex, outer_binder: DebruijnIndex, - ) -> Fallible> { + ) -> Fallible> { if self.forbid_free_placeholders() { panic!("unexpected placeholder type `{:?}`", universe) } else { - Ok(universe.to_ty::(self.target_interner())) + Ok(universe.to_ty::(self.interner())) } } @@ -226,11 +215,11 @@ where &mut self, universe: PlaceholderIndex, outer_binder: DebruijnIndex, - ) -> Fallible> { + ) -> Fallible> { if self.forbid_free_placeholders() { panic!("unexpected placeholder lifetime `{:?}`", universe) } else { - Ok(universe.to_lifetime(self.target_interner())) + Ok(universe.to_lifetime(self.interner())) } } @@ -241,14 +230,11 @@ where ty: &Ty, universe: PlaceholderIndex, outer_binder: DebruijnIndex, - ) -> Fallible> { + ) -> Fallible> { if self.forbid_free_placeholders() { panic!("unexpected placeholder const `{:?}`", universe) } else { - Ok(universe.to_const( - self.target_interner(), - ty.fold_with(self.as_dyn(), outer_binder)?, - )) + Ok(universe.to_const(self.interner(), ty.fold_with(self.as_dyn(), outer_binder)?)) } } @@ -272,11 +258,11 @@ where var: InferenceVar, kind: TyVariableKind, outer_binder: DebruijnIndex, - ) -> Fallible> { + ) -> Fallible> { if self.forbid_inference_vars() { panic!("unexpected inference type `{:?}`", var) } else { - Ok(var.to_ty(self.target_interner(), kind)) + Ok(var.to_ty(self.interner(), kind)) } } @@ -286,11 +272,11 @@ where &mut self, var: InferenceVar, outer_binder: DebruijnIndex, - ) -> Fallible> { + ) -> Fallible> { if self.forbid_inference_vars() { panic!("unexpected inference lifetime `'{:?}`", var) } else { - Ok(var.to_lifetime(self.target_interner())) + Ok(var.to_lifetime(self.interner())) } } @@ -301,40 +287,24 @@ where ty: &Ty, var: InferenceVar, outer_binder: DebruijnIndex, - ) -> Fallible> { + ) -> Fallible> { if self.forbid_inference_vars() { panic!("unexpected inference const `{:?}`", var) } else { - Ok(var.to_const( - self.target_interner(), - ty.fold_with(self.as_dyn(), outer_binder)?, - )) + Ok(var.to_const(self.interner(), ty.fold_with(self.as_dyn(), outer_binder)?)) } } /// Gets the interner that is being folded from. fn interner(&self) -> &'i I; - - /// Gets the interner that is being folded to. - fn target_interner(&self) -> &'i TI; } /// Applies the given `Folder` to a value, producing a folded result -/// of type `Self::Result`. The result is in the interner -/// `TI`. The result type is typically the same as the source type -/// (modulo interner), but in some cases we convert from borrowed +/// of type `Self::Result`. The result type is typically the same as +/// the source type, but in some cases we convert from borrowed /// to owned as well (e.g., the folder for `&T` will fold to a fresh /// `T`; well, actually `T::Result`). -/// -/// # Interners -/// -/// The `Fold` trait has two type parameters, `I` and `TI`: -/// -/// * `I` is the "source interner" that we are folding *from* -/// * `TI` is the "target interner" that we are folding *into* -/// -/// Often, both are the same. -pub trait Fold = I>: Debug { +pub trait Fold: Debug { /// The type of value that will be produced once folding is done. /// Typically this is `Self`, unless `Self` contains borrowed /// values, in which case owned values are produced (for example, @@ -349,62 +319,57 @@ pub trait Fold = I>: Debug { /// constructs. fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where - I: 'i, - TI: 'i; + I: 'i; } /// For types where "fold" invokes a callback on the `Folder`, the /// `SuperFold` trait captures the recursive behavior that folds all /// the contents of the type. -pub trait SuperFold = I>: Fold { +pub trait SuperFold: Fold { /// Recursively folds the value. fn super_fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where - I: 'i, - TI: 'i; + I: 'i; } /// "Folding" a type invokes the `fold_ty` method on the folder; this /// usually (in turn) invokes `super_fold_ty` to fold the individual /// parts. -impl> Fold for Ty { - type Result = Ty; +impl Fold for Ty { + type Result = Ty; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { folder.fold_ty(self, outer_binder) } } /// "Super fold" for a type invokes te more detailed callbacks on the type -impl SuperFold for Ty +impl SuperFold for Ty where I: Interner, - TI: TargetInterner, { fn super_fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, - ) -> Fallible> + ) -> Fallible> where I: 'i, - TI: 'i, { let interner = folder.interner(); Ok(match self.kind(interner) { @@ -419,85 +384,90 @@ where // This variable was bound within the binders that // we folded over, so just return a bound // variable. - TyKind::::BoundVar(*bound_var).intern(folder.target_interner()) + TyKind::::BoundVar(*bound_var).intern(folder.interner()) } } - TyKind::Dyn(clauses) => TyKind::Dyn(clauses.fold_with(folder, outer_binder)?) - .intern(folder.target_interner()), + TyKind::Dyn(clauses) => { + TyKind::Dyn(clauses.fold_with(folder, outer_binder)?).intern(folder.interner()) + } TyKind::InferenceVar(var, kind) => { folder.fold_inference_ty(*var, *kind, outer_binder)? } TyKind::Placeholder(ui) => folder.fold_free_placeholder_ty(*ui, outer_binder)?, - TyKind::Alias(proj) => TyKind::Alias(proj.fold_with(folder, outer_binder)?) - .intern(folder.target_interner()), - TyKind::Function(fun) => TyKind::Function(fun.fold_with(folder, outer_binder)?) - .intern(folder.target_interner()), + TyKind::Alias(proj) => { + TyKind::Alias(proj.fold_with(folder, outer_binder)?).intern(folder.interner()) + } + TyKind::Function(fun) => { + TyKind::Function(fun.fold_with(folder, outer_binder)?).intern(folder.interner()) + } TyKind::Adt(id, substitution) => TyKind::Adt( id.fold_with(folder, outer_binder)?, substitution.fold_with(folder, outer_binder)?, ) - .intern(folder.target_interner()), + .intern(folder.interner()), TyKind::AssociatedType(assoc_ty, substitution) => TyKind::AssociatedType( assoc_ty.fold_with(folder, outer_binder)?, substitution.fold_with(folder, outer_binder)?, ) - .intern(folder.target_interner()), - TyKind::Scalar(scalar) => TyKind::Scalar(scalar.fold_with(folder, outer_binder)?) - .intern(folder.target_interner()), - TyKind::Str => TyKind::Str.intern(folder.target_interner()), + .intern(folder.interner()), + TyKind::Scalar(scalar) => { + TyKind::Scalar(scalar.fold_with(folder, outer_binder)?).intern(folder.interner()) + } + TyKind::Str => TyKind::Str.intern(folder.interner()), TyKind::Tuple(arity, substitution) => { TyKind::Tuple(*arity, substitution.fold_with(folder, outer_binder)?) - .intern(folder.target_interner()) + .intern(folder.interner()) } TyKind::OpaqueType(opaque_ty, substitution) => TyKind::OpaqueType( opaque_ty.fold_with(folder, outer_binder)?, substitution.fold_with(folder, outer_binder)?, ) - .intern(folder.target_interner()), + .intern(folder.interner()), TyKind::Slice(substitution) => { TyKind::Slice(substitution.fold_with(folder, outer_binder)?) - .intern(folder.target_interner()) + .intern(folder.interner()) } TyKind::FnDef(fn_def, substitution) => TyKind::FnDef( fn_def.fold_with(folder, outer_binder)?, substitution.fold_with(folder, outer_binder)?, ) - .intern(folder.target_interner()), + .intern(folder.interner()), TyKind::Ref(mutability, lifetime, ty) => TyKind::Ref( mutability.fold_with(folder, outer_binder)?, lifetime.fold_with(folder, outer_binder)?, ty.fold_with(folder, outer_binder)?, ) - .intern(folder.target_interner()), + .intern(folder.interner()), TyKind::Raw(mutability, ty) => TyKind::Raw( mutability.fold_with(folder, outer_binder)?, ty.fold_with(folder, outer_binder)?, ) - .intern(folder.target_interner()), - TyKind::Never => TyKind::Never.intern(folder.target_interner()), + .intern(folder.interner()), + TyKind::Never => TyKind::Never.intern(folder.interner()), TyKind::Array(ty, const_) => TyKind::Array( ty.fold_with(folder, outer_binder)?, const_.fold_with(folder, outer_binder)?, ) - .intern(folder.target_interner()), + .intern(folder.interner()), TyKind::Closure(id, substitution) => TyKind::Closure( id.fold_with(folder, outer_binder)?, substitution.fold_with(folder, outer_binder)?, ) - .intern(folder.target_interner()), + .intern(folder.interner()), TyKind::Generator(id, substitution) => TyKind::Generator( id.fold_with(folder, outer_binder)?, substitution.fold_with(folder, outer_binder)?, ) - .intern(folder.target_interner()), + .intern(folder.interner()), TyKind::GeneratorWitness(id, substitution) => TyKind::GeneratorWitness( 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()), + .intern(folder.interner()), + TyKind::Foreign(id) => { + TyKind::Foreign(id.fold_with(folder, outer_binder)?).intern(folder.interner()) + } + TyKind::Error => TyKind::Error.intern(folder.interner()), }) } } @@ -505,35 +475,32 @@ where /// "Folding" a lifetime invokes the `fold_lifetime` method on the folder; this /// usually (in turn) invokes `super_fold_lifetime` to fold the individual /// parts. -impl> Fold for Lifetime { - type Result = Lifetime; +impl Fold for Lifetime { + type Result = Lifetime; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { folder.fold_lifetime(self, outer_binder) } } -impl SuperFold for Lifetime +impl SuperFold for Lifetime where I: Interner, - TI: TargetInterner, { fn super_fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, - ) -> Fallible> + ) -> Fallible> where I: 'i, - TI: 'i, { let interner = folder.interner(); match self.data(interner) { @@ -548,14 +515,14 @@ where // This variable was bound within the binders that // we folded over, so just return a bound // variable. - Ok(LifetimeData::::BoundVar(*bound_var).intern(folder.target_interner())) + Ok(LifetimeData::::BoundVar(*bound_var).intern(folder.interner())) } } LifetimeData::InferenceVar(var) => folder.fold_inference_lifetime(*var, outer_binder), LifetimeData::Placeholder(universe) => { folder.fold_free_placeholder_lifetime(*universe, outer_binder) } - LifetimeData::Static => Ok(LifetimeData::::Static.intern(folder.target_interner())), + LifetimeData::Static => Ok(LifetimeData::::Static.intern(folder.interner())), LifetimeData::Phantom(..) => unreachable!(), } } @@ -564,38 +531,34 @@ where /// "Folding" a const invokes the `fold_const` method on the folder; this /// usually (in turn) invokes `super_fold_const` to fold the individual /// parts. -impl> Fold for Const { - type Result = Const; +impl Fold for Const { + type Result = Const; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { folder.fold_const(self, outer_binder) } } -impl SuperFold for Const +impl SuperFold for Const where I: Interner, - TI: TargetInterner, { fn super_fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, - ) -> Fallible> + ) -> Fallible> where I: 'i, - TI: 'i, { let interner = folder.interner(); - let target_interner = folder.target_interner(); let ConstData { ref ty, ref value } = self.data(interner); let mut fold_ty = || ty.fold_with(folder, outer_binder); match value { @@ -603,7 +566,7 @@ where if let Some(bound_var1) = bound_var.shifted_out_to(outer_binder) { folder.fold_free_var_const(ty, bound_var1, outer_binder) } else { - Ok(bound_var.to_const(target_interner, fold_ty()?)) + Ok(bound_var.to_const(interner, fold_ty()?)) } } ConstValue::InferenceVar(var) => folder.fold_inference_const(ty, *var, outer_binder), @@ -613,47 +576,44 @@ where ConstValue::Concrete(ev) => Ok(ConstData { ty: fold_ty()?, value: ConstValue::Concrete(ConcreteConst { - interned: folder.target_interner().transfer_const(&ev.interned), + interned: ev.interned.clone(), }), } - .intern(folder.target_interner())), + .intern(folder.interner())), } } } /// Folding a goal invokes the `fold_goal` callback (which will, by /// default, invoke super-fold). -impl> Fold for Goal { - type Result = Goal; +impl Fold for Goal { + type Result = Goal; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { folder.fold_goal(self, outer_binder) } } /// Superfold folds recursively. -impl> SuperFold for Goal { +impl SuperFold for Goal { fn super_fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { let interner = folder.interner(); - let target_interner = folder.target_interner(); Ok(Goal::new( - target_interner, + interner, self.data(interner).fold_with(folder, outer_binder)?, )) } @@ -662,17 +622,16 @@ impl> SuperFold for Goal { /// Folding a program clause invokes the `fold_program_clause` /// callback on the folder (which will, by default, invoke the /// `super_fold_with` method on the program clause). -impl> Fold for ProgramClause { - type Result = ProgramClause; +impl Fold for ProgramClause { + type Result = ProgramClause; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { folder.fold_program_clause(self, outer_binder) } diff --git a/chalk-ir/src/fold/binder_impls.rs b/chalk-ir/src/fold/binder_impls.rs index dc290e9224f..ff041703b5d 100644 --- a/chalk-ir/src/fold/binder_impls.rs +++ b/chalk-ir/src/fold/binder_impls.rs @@ -3,19 +3,17 @@ //! //! The more interesting impls of `Fold` remain in the `fold` module. -use crate::interner::TargetInterner; use crate::*; -impl> Fold for FnPointer { - type Result = FnPointer; +impl Fold for FnPointer { + type Result = FnPointer; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { let FnPointer { num_binders, @@ -26,7 +24,7 @@ impl> Fold for FnPointer { num_binders: *num_binders, substitution: substitution.fold_with(folder, outer_binder.shifted_in())?, sig: FnSig { - abi: TI::transfer_abi(sig.abi), + abi: sig.abi, safety: sig.safety, variadic: sig.variadic, }, @@ -34,21 +32,20 @@ impl> Fold for FnPointer { } } -impl> Fold for Binders +impl Fold for Binders where - T: HasInterner + Fold, - >::Result: HasInterner, + T: HasInterner + Fold, + >::Result: HasInterner, I: Interner, { type Result = Binders; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { let Binders { binders: self_binders, @@ -56,28 +53,26 @@ where } = self; let value = self_value.fold_with(folder, outer_binder.shifted_in())?; let binders = VariableKinds { - interned: TI::transfer_variable_kinds(self_binders.interned().clone()), + interned: self_binders.interned().clone(), }; Ok(Binders::new(binders, value)) } } -impl Fold for Canonical +impl Fold for Canonical where I: Interner, - T: HasInterner + Fold, - >::Result: HasInterner, - TI: TargetInterner, + T: HasInterner + Fold, + >::Result: HasInterner, { type Result = Canonical; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { let Canonical { binders: self_binders, @@ -85,7 +80,7 @@ where } = self; let value = self_value.fold_with(folder, outer_binder.shifted_in())?; let binders = CanonicalVarKinds { - interned: TI::transfer_canonical_var_kinds(self_binders.interned().clone()), + interned: self_binders.interned().clone(), }; Ok(Canonical { binders, value }) } diff --git a/chalk-ir/src/fold/boring_impls.rs b/chalk-ir/src/fold/boring_impls.rs index b300c36974f..850bee05ae7 100644 --- a/chalk-ir/src/fold/boring_impls.rs +++ b/chalk-ir/src/fold/boring_impls.rs @@ -4,36 +4,33 @@ //! //! The more interesting impls of `Fold` remain in the `fold` module. -use crate::interner::TargetInterner; use crate::*; use std::marker::PhantomData; use std::sync::Arc; -impl<'a, T: Fold, I: Interner, TI: TargetInterner> Fold for &'a T { +impl<'a, T: Fold, I: Interner> Fold for &'a T { type Result = T::Result; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { (**self).fold_with(folder, outer_binder) } } -impl, I: Interner, TI: TargetInterner> Fold for Vec { +impl, I: Interner> Fold for Vec { type Result = Vec; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { self.iter() .map(|e| e.fold_with(folder, outer_binder)) @@ -41,31 +38,29 @@ impl, I: Interner, TI: TargetInterner> Fold for Vec } } -impl, I: Interner, TI: TargetInterner> Fold for Box { +impl, I: Interner> Fold for Box { type Result = Box; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { Ok(Box::new((**self).fold_with(folder, outer_binder)?)) } } -impl, I: Interner, TI: TargetInterner> Fold for Arc { +impl, I: Interner> Fold for Arc { type Result = Arc; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { Ok(Arc::new((**self).fold_with(folder, outer_binder)?)) } @@ -73,12 +68,11 @@ impl, I: Interner, TI: TargetInterner> Fold for Arc macro_rules! tuple_fold { ($($n:ident),*) => { - impl<$($n: Fold,)* I: Interner, TI: TargetInterner> Fold for ($($n,)*) { + impl<$($n: Fold,)* I: Interner> Fold for ($($n,)*) { type Result = ($($n::Result,)*); - fn fold_with<'i>(&self, folder: &mut dyn Folder<'i, I, TI>, outer_binder: DebruijnIndex) -> Fallible + fn fold_with<'i>(&self, folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex) -> Fallible where I: 'i, - TI: 'i, { #[allow(non_snake_case)] let &($(ref $n),*) = self; @@ -93,16 +87,15 @@ tuple_fold!(A, B, C); tuple_fold!(A, B, C, D); tuple_fold!(A, B, C, D, E); -impl, I: Interner, TI: TargetInterner> Fold for Option { +impl, I: Interner> Fold for Option { type Result = Option; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { match self { None => Ok(None), @@ -111,125 +104,111 @@ impl, I: Interner, TI: TargetInterner> Fold for Option< } } -impl> Fold for GenericArg { - type Result = GenericArg; +impl Fold for GenericArg { + type Result = GenericArg; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { let interner = folder.interner(); - let target_interner = folder.target_interner(); let data = self.data(interner).fold_with(folder, outer_binder)?; - Ok(GenericArg::new(target_interner, data)) + Ok(GenericArg::new(interner, data)) } } -impl> Fold for Substitution { - type Result = Substitution; +impl Fold for Substitution { + type Result = Substitution; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { let interner = folder.interner(); - let target_interner = folder.target_interner(); + let folded = self .iter(interner) .map(|p| p.fold_with(folder, outer_binder)); - Ok(Substitution::from_fallible(target_interner, folded)?) + Ok(Substitution::from_fallible(interner, folded)?) } } -impl> Fold for Goals { - type Result = Goals; +impl Fold for Goals { + type Result = Goals; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { let interner = folder.interner(); - let target_interner = folder.target_interner(); let folded = self .iter(interner) .map(|p| p.fold_with(folder, outer_binder)); - Ok(Goals::from_fallible(target_interner, folded)?) + Ok(Goals::from_fallible(interner, folded)?) } } -impl> Fold for ProgramClauses { - type Result = ProgramClauses; +impl Fold for ProgramClauses { + type Result = ProgramClauses; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { let interner = folder.interner(); - let target_interner = folder.target_interner(); let folded = self .iter(interner) .map(|p| p.fold_with(folder, outer_binder)); - Ok(ProgramClauses::from_fallible(target_interner, folded)?) + Ok(ProgramClauses::from_fallible(interner, folded)?) } } -impl> Fold for QuantifiedWhereClauses { - type Result = QuantifiedWhereClauses; +impl Fold for QuantifiedWhereClauses { + type Result = QuantifiedWhereClauses; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { let interner = folder.interner(); - let target_interner = folder.target_interner(); let folded = self .iter(interner) .map(|p| p.fold_with(folder, outer_binder)); - Ok(QuantifiedWhereClauses::from_fallible( - target_interner, - folded, - )?) + Ok(QuantifiedWhereClauses::from_fallible(interner, folded)?) } } -impl> Fold for Constraints { - type Result = Constraints; +impl Fold for Constraints { + type Result = Constraints; fn fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> Fallible where I: 'i, - TI: 'i, { let interner = folder.interner(); - let target_interner = folder.target_interner(); let folded = self .iter(interner) .map(|p| p.fold_with(folder, outer_binder)); - Ok(Constraints::from_fallible(target_interner, folded)?) + Ok(Constraints::from_fallible(interner, folded)?) } } @@ -237,16 +216,15 @@ impl> Fold for Constraints { #[macro_export] macro_rules! copy_fold { ($t:ty) => { - impl> $crate::fold::Fold for $t { + impl $crate::fold::Fold for $t { type Result = Self; fn fold_with<'i>( &self, - _folder: &mut dyn ($crate::fold::Folder<'i, I, TI>), + _folder: &mut dyn ($crate::fold::Folder<'i, I>), _outer_binder: DebruijnIndex, ) -> ::chalk_ir::Fallible where I: 'i, - TI: 'i, { Ok(*self) } @@ -273,31 +251,24 @@ copy_fold!(Safety); #[macro_export] macro_rules! id_fold { ($t:ident) => { - $crate::id_fold!($t, transfer_def_id); - }; - - ($t:ident, $transfer_fn:ident) => { - impl> $crate::fold::Fold for $t { - type Result = $t; + impl $crate::fold::Fold for $t { + type Result = $t; fn fold_with<'i>( &self, - _folder: &mut dyn ($crate::fold::Folder<'i, I, TI>), + _folder: &mut dyn ($crate::fold::Folder<'i, I>), _outer_binder: DebruijnIndex, ) -> ::chalk_ir::Fallible where I: 'i, - TI: 'i, { - let $t(def_id_tf) = *self; - let def_id_ttf = TI::$transfer_fn(def_id_tf); - Ok($t(def_id_ttf)) + Ok(*self) } } }; } id_fold!(ImplId); -id_fold!(AdtId, transfer_adt_id); +id_fold!(AdtId); id_fold!(TraitId); id_fold!(AssocTypeId); id_fold!(OpaqueTyId); @@ -306,48 +277,45 @@ id_fold!(ClosureId); id_fold!(GeneratorId); id_fold!(ForeignDefId); -impl> SuperFold for ProgramClauseData { +impl SuperFold for ProgramClauseData { fn super_fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> ::chalk_ir::Fallible where I: 'i, - TI: 'i, { Ok(ProgramClauseData(self.0.fold_with(folder, outer_binder)?)) } } -impl> SuperFold for ProgramClause { +impl SuperFold for ProgramClause { fn super_fold_with<'i>( &self, - folder: &mut dyn Folder<'i, I, TI>, + folder: &mut dyn Folder<'i, I>, outer_binder: DebruijnIndex, ) -> ::chalk_ir::Fallible where I: 'i, - TI: 'i, { let clause = self.data(folder.interner()); Ok(clause .super_fold_with(folder, outer_binder)? - .intern(folder.target_interner())) + .intern(folder.interner())) } } -impl> Fold for PhantomData { - type Result = PhantomData; +impl Fold for PhantomData { + type Result = PhantomData; fn fold_with<'i>( &self, - _folder: &mut dyn Folder<'i, I, TI>, + _folder: &mut dyn Folder<'i, I>, _outer_binder: DebruijnIndex, ) -> ::chalk_ir::Fallible where I: 'i, - TI: 'i, { Ok(PhantomData) } diff --git a/chalk-ir/src/fold/shift.rs b/chalk-ir/src/fold/shift.rs index af4c59137e8..cd6043f75ee 100644 --- a/chalk-ir/src/fold/shift.rs +++ b/chalk-ir/src/fold/shift.rs @@ -5,7 +5,7 @@ use crate::*; /// Methods for converting debruijn indices to move values into or out /// of binders. -pub trait Shift: Fold { +pub trait Shift: Fold { /// Shifts this term in one level of binders. fn shifted_in(&self, interner: &I) -> Self::Result; @@ -23,7 +23,7 @@ pub trait Shift: Fold { fn shifted_out_to(&self, interner: &I, target_binder: DebruijnIndex) -> Fallible; } -impl, I: Interner> Shift for T { +impl, I: Interner> Shift for T { fn shifted_in(&self, interner: &I) -> Self::Result { self.shifted_in_from(interner, DebruijnIndex::ONE) } @@ -110,10 +110,6 @@ impl<'i, I: Interner> Folder<'i, I> for Shifter<'i, I> { fn interner(&self) -> &'i I { self.interner } - - fn target_interner(&self) -> &'i I { - self.interner() - } } //--------------------------------------------------------------------------- @@ -182,8 +178,4 @@ impl<'i, I: Interner> Folder<'i, I> for DownShifter<'i, I> { fn interner(&self) -> &'i I { self.interner } - - fn target_interner(&self) -> &'i I { - self.interner() - } } diff --git a/chalk-ir/src/fold/subst.rs b/chalk-ir/src/fold/subst.rs index 6c6cb2c7a18..94f942669e6 100644 --- a/chalk-ir/src/fold/subst.rs +++ b/chalk-ir/src/fold/subst.rs @@ -12,11 +12,7 @@ pub struct Subst<'s, 'i, I: Interner> { impl Subst<'_, '_, I> { /// Applies the substitution by folding - pub fn apply>( - interner: &I, - parameters: &[GenericArg], - value: &T, - ) -> T::Result { + pub fn apply>(interner: &I, parameters: &[GenericArg], value: &T) -> T::Result { value .fold_with( &mut Subst { @@ -116,8 +112,4 @@ impl<'i, I: Interner> Folder<'i, I> for Subst<'_, 'i, I> { fn interner(&self) -> &'i I { self.interner } - - fn target_interner(&self) -> &'i I { - self.interner() - } } diff --git a/chalk-ir/src/interner.rs b/chalk-ir/src/interner.rs index 66dd85b87ba..25c4efb4003 100644 --- a/chalk-ir/src/interner.rs +++ b/chalk-ir/src/interner.rs @@ -620,73 +620,6 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash { ) -> &'a [InEnvironment>]; } -/// "Target" interner, used to specify the interner of the folded value. -/// In most cases, both interners are the same, but in some cases you want -/// to change a value to a different internal representation, and as such -/// a different target interner. -/// -/// Contains several methods to transfer types from another interner to -/// the `TargetInterner`. -pub trait TargetInterner: Interner { - /// Transfer a `DefId` to the target interner. - fn transfer_def_id(def_id: I::DefId) -> Self::DefId; - - /// Transfer an AdtId to the target interner. - fn transfer_adt_id(adt_id: I::InternedAdtId) -> Self::InternedAdtId; - - /// Transfer variable kinds to the target interner. - fn transfer_variable_kinds( - variable_kinds: I::InternedVariableKinds, - ) -> Self::InternedVariableKinds; - - /// Transfer canonical var kinds to the target interner. - fn transfer_canonical_var_kinds( - variable_kinds: I::InternedCanonicalVarKinds, - ) -> Self::InternedCanonicalVarKinds; - - /// Transfer constant values to the target interner. - fn transfer_const( - &self, - const_evaluated: &I::InternedConcreteConst, - ) -> Self::InternedConcreteConst; - - /// Transfer function ABI to the target interner. - fn transfer_abi(abi: I::FnAbi) -> Self::FnAbi; -} - -impl TargetInterner for I { - fn transfer_def_id(def_id: I::DefId) -> Self::DefId { - def_id - } - - fn transfer_adt_id(adt_id: I::InternedAdtId) -> Self::InternedAdtId { - adt_id - } - - fn transfer_variable_kinds( - variable_kinds: I::InternedVariableKinds, - ) -> Self::InternedVariableKinds { - variable_kinds - } - - fn transfer_canonical_var_kinds( - variable_kinds: I::InternedCanonicalVarKinds, - ) -> Self::InternedCanonicalVarKinds { - variable_kinds - } - - fn transfer_const( - &self, - const_evaluated: &I::InternedConcreteConst, - ) -> Self::InternedConcreteConst { - const_evaluated.clone() - } - - fn transfer_abi(abi: I::FnAbi) -> Self::FnAbi { - abi - } -} - /// Implemented by types that have an associated interner (which /// are virtually all of the types in chalk-ir, for example). /// This lets us map from a type like `Ty` to the parameter `I`. diff --git a/chalk-ir/src/lib.rs b/chalk-ir/src/lib.rs index d6b70e8465c..3dfe315a5e5 100644 --- a/chalk-ir/src/lib.rs +++ b/chalk-ir/src/lib.rs @@ -1890,7 +1890,7 @@ impl Binders { impl Binders> where - T: Fold + HasInterner, + T: Fold + HasInterner, T::Result: HasInterner, I: Interner, { @@ -1926,7 +1926,7 @@ impl From> for (VariableKinds, T) { impl Binders where - T: Fold + HasInterner, + T: Fold + HasInterner, I: Interner, { /// Substitute `parameters` for the variables introduced by these @@ -2403,7 +2403,7 @@ impl Substitution { /// Apply the substitution to a value. pub fn apply(&self, value: &T, interner: &I) -> T::Result where - T: Fold, + T: Fold, { value .fold_with( @@ -2542,10 +2542,6 @@ impl<'i, I: Interner> Folder<'i, I> for &SubstFolder<'i, I> { fn interner(&self) -> &'i I { self.interner } - - fn target_interner(&self) -> &'i I { - self.interner() - } } macro_rules! interned_slice { diff --git a/chalk-ir/src/zip.rs b/chalk-ir/src/zip.rs index 0dd964366ee..d6be4923a40 100644 --- a/chalk-ir/src/zip.rs +++ b/chalk-ir/src/zip.rs @@ -34,7 +34,7 @@ pub trait Zipper<'i, I: Interner> { /// Zips two values appearing beneath binders. fn zip_binders(&mut self, a: &Binders, b: &Binders) -> Fallible<()> where - T: HasInterner + Zip + Fold; + T: HasInterner + Zip + Fold; /// Retreives the interner from the underlying zipper object fn interner(&self) -> &'i I; @@ -59,7 +59,7 @@ where fn zip_binders(&mut self, a: &Binders, b: &Binders) -> Fallible<()> where - T: HasInterner + Zip + Fold, + T: HasInterner + Zip + Fold, { (**self).zip_binders(a, b) } @@ -182,7 +182,7 @@ impl Zip for Const { zipper.zip_consts(a, b) } } -impl + Zip + Fold> Zip +impl + Zip + Fold> Zip for Binders { fn zip_with<'i, Z: Zipper<'i, I>>(zipper: &mut Z, a: &Self, b: &Self) -> Fallible<()> diff --git a/chalk-recursive/src/solve.rs b/chalk-recursive/src/solve.rs index e78d867c634..c7c3304379d 100644 --- a/chalk-recursive/src/solve.rs +++ b/chalk-recursive/src/solve.rs @@ -181,7 +181,7 @@ trait SolveIterationHelpers: SolveDatabase { } } - fn new_inference_table + HasInterner + Clone>( + fn new_inference_table + HasInterner + Clone>( &self, ucanonical_goal: &UCanonical>, ) -> ( diff --git a/chalk-solve/src/clauses/generalize.rs b/chalk-solve/src/clauses/generalize.rs index 0e6719888d3..7f045e2c8fa 100644 --- a/chalk-solve/src/clauses/generalize.rs +++ b/chalk-solve/src/clauses/generalize.rs @@ -23,7 +23,7 @@ pub struct Generalize<'i, I: Interner> { impl Generalize<'_, I> { pub fn apply(interner: &I, value: &T) -> Binders where - T: HasInterner + Fold, + T: HasInterner + Fold, T::Result: HasInterner, { let mut generalize = Generalize { @@ -79,8 +79,4 @@ impl<'i, I: Interner> Folder<'i, I> for Generalize<'i, I> { fn interner(&self) -> &'i I { self.interner } - - fn target_interner(&self) -> &'i I { - self.interner - } } diff --git a/chalk-solve/src/infer/canonicalize.rs b/chalk-solve/src/infer/canonicalize.rs index 4b25d0957eb..19dd042649b 100644 --- a/chalk-solve/src/infer/canonicalize.rs +++ b/chalk-solve/src/infer/canonicalize.rs @@ -240,8 +240,4 @@ where fn interner(&self) -> &'i I { self.interner } - - fn target_interner(&self) -> &'i I { - self.interner() - } } diff --git a/chalk-solve/src/infer/invert.rs b/chalk-solve/src/infer/invert.rs index 77235dac3be..96131c4e8a8 100644 --- a/chalk-solve/src/infer/invert.rs +++ b/chalk-solve/src/infer/invert.rs @@ -178,8 +178,4 @@ where fn interner(&self) -> &'i I { self.interner } - - fn target_interner(&self) -> &'i I { - self.interner() - } } diff --git a/chalk-solve/src/infer/ucanonicalize.rs b/chalk-solve/src/infer/ucanonicalize.rs index 7dedc2842f2..dd06024eb77 100644 --- a/chalk-solve/src/infer/ucanonicalize.rs +++ b/chalk-solve/src/infer/ucanonicalize.rs @@ -295,10 +295,6 @@ where fn interner(&self) -> &'i I { self.interner } - - fn target_interner(&self) -> &'i I { - self.interner() - } } struct UMapFromCanonical<'q, I> { @@ -347,8 +343,4 @@ where fn interner(&self) -> &'i I { self.interner } - - fn target_interner(&self) -> &'i I { - self.interner() - } } diff --git a/chalk-solve/src/infer/unify.rs b/chalk-solve/src/infer/unify.rs index 89da5d8e692..9e9eefb52f0 100644 --- a/chalk-solve/src/infer/unify.rs +++ b/chalk-solve/src/infer/unify.rs @@ -794,8 +794,4 @@ where fn interner(&self) -> &'i I { self.unifier.interner } - - fn target_interner(&self) -> &'i I { - self.interner() - } } diff --git a/chalk-solve/src/rust_ir.rs b/chalk-solve/src/rust_ir.rs index 5f86ad3bd5c..95122eeb0d0 100644 --- a/chalk-solve/src/rust_ir.rs +++ b/chalk-solve/src/rust_ir.rs @@ -5,7 +5,7 @@ use chalk_derive::{Fold, HasInterner, Visit}; use chalk_ir::cast::Cast; use chalk_ir::fold::shift::Shift; -use chalk_ir::interner::{Interner, TargetInterner}; +use chalk_ir::interner::Interner; use chalk_ir::{ visit::{Visit, VisitResult}, AdtId, AliasEq, AliasTy, AssocTypeId, Binders, DebruijnIndex, FnDefId, GenericArg, ImplId,