| // Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT |
| // file at the top-level directory of this distribution and at |
| // http://rust-lang.org/COPYRIGHT. |
| // |
| // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or |
| // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your |
| // option. This file may not be copied, modified, or distributed |
| // except according to those terms. |
| |
| use rustc_data_structures::accumulate_vec::AccumulateVec; |
| use traits; |
| use traits::project::Normalized; |
| use ty::{self, Lift, TyCtxt}; |
| use ty::fold::{TypeFoldable, TypeFolder, TypeVisitor}; |
| |
| use std::fmt; |
| use std::rc::Rc; |
| |
| // structural impls for the structs in traits |
| |
| impl<'tcx, T: fmt::Debug> fmt::Debug for Normalized<'tcx, T> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| write!(f, "Normalized({:?},{:?})", |
| self.value, |
| self.obligations) |
| } |
| } |
| |
| impl<'tcx, O: fmt::Debug> fmt::Debug for traits::Obligation<'tcx, O> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| if ty::tls::with(|tcx| tcx.sess.verbose()) { |
| write!(f, "Obligation(predicate={:?},cause={:?},depth={})", |
| self.predicate, |
| self.cause, |
| self.recursion_depth) |
| } else { |
| write!(f, "Obligation(predicate={:?},depth={})", |
| self.predicate, |
| self.recursion_depth) |
| } |
| } |
| } |
| |
| impl<'tcx, N: fmt::Debug> fmt::Debug for traits::Vtable<'tcx, N> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| match *self { |
| super::VtableImpl(ref v) => |
| write!(f, "{:?}", v), |
| |
| super::VtableAutoImpl(ref t) => |
| write!(f, "{:?}", t), |
| |
| super::VtableClosure(ref d) => |
| write!(f, "{:?}", d), |
| |
| super::VtableGenerator(ref d) => |
| write!(f, "{:?}", d), |
| |
| super::VtableFnPointer(ref d) => |
| write!(f, "VtableFnPointer({:?})", d), |
| |
| super::VtableObject(ref d) => |
| write!(f, "{:?}", d), |
| |
| super::VtableParam(ref n) => |
| write!(f, "VtableParam({:?})", n), |
| |
| super::VtableBuiltin(ref d) => |
| write!(f, "{:?}", d) |
| } |
| } |
| } |
| |
| impl<'tcx, N: fmt::Debug> fmt::Debug for traits::VtableImplData<'tcx, N> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| write!(f, "VtableImpl(impl_def_id={:?}, substs={:?}, nested={:?})", |
| self.impl_def_id, |
| self.substs, |
| self.nested) |
| } |
| } |
| |
| impl<'tcx, N: fmt::Debug> fmt::Debug for traits::VtableGeneratorData<'tcx, N> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| write!(f, "VtableGenerator(generator_def_id={:?}, substs={:?}, nested={:?})", |
| self.generator_def_id, |
| self.substs, |
| self.nested) |
| } |
| } |
| |
| impl<'tcx, N: fmt::Debug> fmt::Debug for traits::VtableClosureData<'tcx, N> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| write!(f, "VtableClosure(closure_def_id={:?}, substs={:?}, nested={:?})", |
| self.closure_def_id, |
| self.substs, |
| self.nested) |
| } |
| } |
| |
| impl<'tcx, N: fmt::Debug> fmt::Debug for traits::VtableBuiltinData<N> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| write!(f, "VtableBuiltin(nested={:?})", self.nested) |
| } |
| } |
| |
| impl<'tcx, N: fmt::Debug> fmt::Debug for traits::VtableAutoImplData<N> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| write!(f, "VtableAutoImplData(trait_def_id={:?}, nested={:?})", |
| self.trait_def_id, |
| self.nested) |
| } |
| } |
| |
| impl<'tcx, N: fmt::Debug> fmt::Debug for traits::VtableObjectData<'tcx, N> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| write!(f, "VtableObject(upcast={:?}, vtable_base={}, nested={:?})", |
| self.upcast_trait_ref, |
| self.vtable_base, |
| self.nested) |
| } |
| } |
| |
| impl<'tcx, N: fmt::Debug> fmt::Debug for traits::VtableFnPointerData<'tcx, N> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| write!(f, "VtableFnPointer(fn_ty={:?}, nested={:?})", |
| self.fn_ty, |
| self.nested) |
| } |
| } |
| |
| impl<'tcx> fmt::Debug for traits::FulfillmentError<'tcx> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| write!(f, "FulfillmentError({:?},{:?})", |
| self.obligation, |
| self.code) |
| } |
| } |
| |
| impl<'tcx> fmt::Debug for traits::FulfillmentErrorCode<'tcx> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| match *self { |
| super::CodeSelectionError(ref e) => write!(f, "{:?}", e), |
| super::CodeProjectionError(ref e) => write!(f, "{:?}", e), |
| super::CodeSubtypeError(ref a, ref b) => |
| write!(f, "CodeSubtypeError({:?}, {:?})", a, b), |
| super::CodeAmbiguity => write!(f, "Ambiguity") |
| } |
| } |
| } |
| |
| impl<'tcx> fmt::Debug for traits::MismatchedProjectionTypes<'tcx> { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| write!(f, "MismatchedProjectionTypes({:?})", self.err) |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Lift implementations |
| |
| impl<'a, 'tcx> Lift<'tcx> for traits::SelectionError<'a> { |
| type Lifted = traits::SelectionError<'tcx>; |
| fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> { |
| match *self { |
| super::Unimplemented => Some(super::Unimplemented), |
| super::OutputTypeParameterMismatch(a, b, ref err) => { |
| tcx.lift(&(a, b)).and_then(|(a, b)| { |
| tcx.lift(err).map(|err| { |
| super::OutputTypeParameterMismatch(a, b, err) |
| }) |
| }) |
| } |
| super::TraitNotObjectSafe(def_id) => { |
| Some(super::TraitNotObjectSafe(def_id)) |
| } |
| super::ConstEvalFailure(ref err) => { |
| tcx.lift(err).map(super::ConstEvalFailure) |
| } |
| super::Overflow => bug!() // FIXME: ape ConstEvalFailure? |
| } |
| } |
| } |
| |
| impl<'a, 'tcx> Lift<'tcx> for traits::ObligationCauseCode<'a> { |
| type Lifted = traits::ObligationCauseCode<'tcx>; |
| fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> { |
| match *self { |
| super::ReturnNoExpression => Some(super::ReturnNoExpression), |
| super::MiscObligation => Some(super::MiscObligation), |
| super::SliceOrArrayElem => Some(super::SliceOrArrayElem), |
| super::TupleElem => Some(super::TupleElem), |
| super::ProjectionWf(proj) => tcx.lift(&proj).map(super::ProjectionWf), |
| super::ItemObligation(def_id) => Some(super::ItemObligation(def_id)), |
| super::ReferenceOutlivesReferent(ty) => { |
| tcx.lift(&ty).map(super::ReferenceOutlivesReferent) |
| } |
| super::ObjectTypeBound(ty, r) => { |
| tcx.lift(&ty).and_then(|ty| { |
| tcx.lift(&r).and_then(|r| { |
| Some(super::ObjectTypeBound(ty, r)) |
| }) |
| }) |
| } |
| super::ObjectCastObligation(ty) => { |
| tcx.lift(&ty).map(super::ObjectCastObligation) |
| } |
| super::AssignmentLhsSized => Some(super::AssignmentLhsSized), |
| super::TupleInitializerSized => Some(super::TupleInitializerSized), |
| super::StructInitializerSized => Some(super::StructInitializerSized), |
| super::VariableType(id) => Some(super::VariableType(id)), |
| super::ReturnType(id) => Some(super::ReturnType(id)), |
| super::SizedReturnType => Some(super::SizedReturnType), |
| super::SizedYieldType => Some(super::SizedYieldType), |
| super::RepeatVec => Some(super::RepeatVec), |
| super::FieldSized(item) => Some(super::FieldSized(item)), |
| super::ConstSized => Some(super::ConstSized), |
| super::SharedStatic => Some(super::SharedStatic), |
| super::BuiltinDerivedObligation(ref cause) => { |
| tcx.lift(cause).map(super::BuiltinDerivedObligation) |
| } |
| super::ImplDerivedObligation(ref cause) => { |
| tcx.lift(cause).map(super::ImplDerivedObligation) |
| } |
| super::CompareImplMethodObligation { item_name, |
| impl_item_def_id, |
| trait_item_def_id } => { |
| Some(super::CompareImplMethodObligation { |
| item_name, |
| impl_item_def_id, |
| trait_item_def_id, |
| }) |
| } |
| super::ExprAssignable => Some(super::ExprAssignable), |
| super::MatchExpressionArm { arm_span, source } => { |
| Some(super::MatchExpressionArm { arm_span, |
| source: source }) |
| } |
| super::IfExpression => Some(super::IfExpression), |
| super::IfExpressionWithNoElse => Some(super::IfExpressionWithNoElse), |
| super::MainFunctionType => Some(super::MainFunctionType), |
| super::StartFunctionType => Some(super::StartFunctionType), |
| super::IntrinsicType => Some(super::IntrinsicType), |
| super::MethodReceiver => Some(super::MethodReceiver), |
| super::BlockTailExpression(id) => Some(super::BlockTailExpression(id)), |
| super::TrivialBound => Some(super::TrivialBound), |
| } |
| } |
| } |
| |
| impl<'a, 'tcx> Lift<'tcx> for traits::DerivedObligationCause<'a> { |
| type Lifted = traits::DerivedObligationCause<'tcx>; |
| fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> { |
| tcx.lift(&self.parent_trait_ref).and_then(|trait_ref| { |
| tcx.lift(&*self.parent_code).map(|code| { |
| traits::DerivedObligationCause { |
| parent_trait_ref: trait_ref, |
| parent_code: Rc::new(code) |
| } |
| }) |
| }) |
| } |
| } |
| |
| impl<'a, 'tcx> Lift<'tcx> for traits::ObligationCause<'a> { |
| type Lifted = traits::ObligationCause<'tcx>; |
| fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> { |
| tcx.lift(&self.code).map(|code| { |
| traits::ObligationCause { |
| span: self.span, |
| body_id: self.body_id, |
| code, |
| } |
| }) |
| } |
| } |
| |
| // For codegen only. |
| impl<'a, 'tcx> Lift<'tcx> for traits::Vtable<'a, ()> { |
| type Lifted = traits::Vtable<'tcx, ()>; |
| fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> { |
| match self.clone() { |
| traits::VtableImpl(traits::VtableImplData { |
| impl_def_id, |
| substs, |
| nested |
| }) => { |
| tcx.lift(&substs).map(|substs| { |
| traits::VtableImpl(traits::VtableImplData { |
| impl_def_id, |
| substs, |
| nested, |
| }) |
| }) |
| } |
| traits::VtableAutoImpl(t) => Some(traits::VtableAutoImpl(t)), |
| traits::VtableGenerator(traits::VtableGeneratorData { |
| generator_def_id, |
| substs, |
| nested |
| }) => { |
| tcx.lift(&substs).map(|substs| { |
| traits::VtableGenerator(traits::VtableGeneratorData { |
| generator_def_id: generator_def_id, |
| substs: substs, |
| nested: nested |
| }) |
| }) |
| } |
| traits::VtableClosure(traits::VtableClosureData { |
| closure_def_id, |
| substs, |
| nested |
| }) => { |
| tcx.lift(&substs).map(|substs| { |
| traits::VtableClosure(traits::VtableClosureData { |
| closure_def_id, |
| substs, |
| nested, |
| }) |
| }) |
| } |
| traits::VtableFnPointer(traits::VtableFnPointerData { fn_ty, nested }) => { |
| tcx.lift(&fn_ty).map(|fn_ty| { |
| traits::VtableFnPointer(traits::VtableFnPointerData { |
| fn_ty, |
| nested, |
| }) |
| }) |
| } |
| traits::VtableParam(n) => Some(traits::VtableParam(n)), |
| traits::VtableBuiltin(n) => Some(traits::VtableBuiltin(n)), |
| traits::VtableObject(traits::VtableObjectData { |
| upcast_trait_ref, |
| vtable_base, |
| nested |
| }) => { |
| tcx.lift(&upcast_trait_ref).map(|trait_ref| { |
| traits::VtableObject(traits::VtableObjectData { |
| upcast_trait_ref: trait_ref, |
| vtable_base, |
| nested, |
| }) |
| }) |
| } |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // TypeFoldable implementations. |
| |
| impl<'tcx, O: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::Obligation<'tcx, O> |
| { |
| fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self { |
| traits::Obligation { |
| cause: self.cause.clone(), |
| recursion_depth: self.recursion_depth, |
| predicate: self.predicate.fold_with(folder), |
| param_env: self.param_env.fold_with(folder), |
| } |
| } |
| |
| fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool { |
| self.predicate.visit_with(visitor) |
| } |
| } |
| |
| BraceStructTypeFoldableImpl! { |
| impl<'tcx, N> TypeFoldable<'tcx> for traits::VtableImplData<'tcx, N> { |
| impl_def_id, substs, nested |
| } where N: TypeFoldable<'tcx> |
| } |
| |
| BraceStructTypeFoldableImpl! { |
| impl<'tcx, N> TypeFoldable<'tcx> for traits::VtableGeneratorData<'tcx, N> { |
| generator_def_id, substs, nested |
| } where N: TypeFoldable<'tcx> |
| } |
| |
| BraceStructTypeFoldableImpl! { |
| impl<'tcx, N> TypeFoldable<'tcx> for traits::VtableClosureData<'tcx, N> { |
| closure_def_id, substs, nested |
| } where N: TypeFoldable<'tcx> |
| } |
| |
| BraceStructTypeFoldableImpl! { |
| impl<'tcx, N> TypeFoldable<'tcx> for traits::VtableAutoImplData<N> { |
| trait_def_id, nested |
| } where N: TypeFoldable<'tcx> |
| } |
| |
| BraceStructTypeFoldableImpl! { |
| impl<'tcx, N> TypeFoldable<'tcx> for traits::VtableBuiltinData<N> { |
| nested |
| } where N: TypeFoldable<'tcx> |
| } |
| |
| BraceStructTypeFoldableImpl! { |
| impl<'tcx, N> TypeFoldable<'tcx> for traits::VtableObjectData<'tcx, N> { |
| upcast_trait_ref, vtable_base, nested |
| } where N: TypeFoldable<'tcx> |
| } |
| |
| BraceStructTypeFoldableImpl! { |
| impl<'tcx, N> TypeFoldable<'tcx> for traits::VtableFnPointerData<'tcx, N> { |
| fn_ty, |
| nested |
| } where N: TypeFoldable<'tcx> |
| } |
| |
| EnumTypeFoldableImpl! { |
| impl<'tcx, N> TypeFoldable<'tcx> for traits::Vtable<'tcx, N> { |
| (traits::VtableImpl)(a), |
| (traits::VtableAutoImpl)(a), |
| (traits::VtableGenerator)(a), |
| (traits::VtableClosure)(a), |
| (traits::VtableFnPointer)(a), |
| (traits::VtableParam)(a), |
| (traits::VtableBuiltin)(a), |
| (traits::VtableObject)(a), |
| } where N: TypeFoldable<'tcx> |
| } |
| |
| BraceStructTypeFoldableImpl! { |
| impl<'tcx, T> TypeFoldable<'tcx> for Normalized<'tcx, T> { |
| value, |
| obligations |
| } where T: TypeFoldable<'tcx> |
| } |
| |
| impl<'tcx> fmt::Display for traits::WhereClauseAtom<'tcx> { |
| fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { |
| use traits::WhereClauseAtom::*; |
| |
| match self { |
| Implemented(trait_ref) => write!(fmt, "Implemented({})", trait_ref), |
| ProjectionEq(projection) => write!(fmt, "ProjectionEq({})", projection), |
| } |
| } |
| } |
| |
| impl<'tcx> fmt::Display for traits::DomainGoal<'tcx> { |
| fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { |
| use traits::DomainGoal::*; |
| use traits::WhereClauseAtom::*; |
| |
| match self { |
| Holds(wc) => write!(fmt, "{}", wc), |
| WellFormed(Implemented(trait_ref)) => write!(fmt, "WellFormed({})", trait_ref), |
| WellFormed(ProjectionEq(projection)) => write!(fmt, "WellFormed({})", projection), |
| FromEnv(Implemented(trait_ref)) => write!(fmt, "FromEnv({})", trait_ref), |
| FromEnv(ProjectionEq(projection)) => write!(fmt, "FromEnv({})", projection), |
| WellFormedTy(ty) => write!(fmt, "WellFormed({})", ty), |
| Normalize(projection) => write!(fmt, "Normalize({})", projection), |
| FromEnvTy(ty) => write!(fmt, "FromEnv({})", ty), |
| RegionOutlives(predicate) => write!(fmt, "RegionOutlives({})", predicate), |
| TypeOutlives(predicate) => write!(fmt, "TypeOutlives({})", predicate), |
| } |
| } |
| } |
| |
| impl fmt::Display for traits::QuantifierKind { |
| fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { |
| use traits::QuantifierKind::*; |
| |
| match self { |
| Universal => write!(fmt, "forall"), |
| Existential => write!(fmt, "exists"), |
| } |
| } |
| } |
| |
| impl<'tcx> fmt::Display for traits::Goal<'tcx> { |
| fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { |
| use traits::Goal::*; |
| |
| match self { |
| Implies(hypotheses, goal) => { |
| write!(fmt, "if (")?; |
| for (index, hyp) in hypotheses.iter().enumerate() { |
| if index > 0 { |
| write!(fmt, ", ")?; |
| } |
| write!(fmt, "{}", hyp)?; |
| } |
| write!(fmt, ") {{ {} }}", goal) |
| } |
| And(goal1, goal2) => write!(fmt, "({} && {})", goal1, goal2), |
| Not(goal) => write!(fmt, "not {{ {} }}", goal), |
| DomainGoal(goal) => write!(fmt, "{}", goal), |
| Quantified(qkind, goal) => { |
| // FIXME: appropriate binder names |
| write!(fmt, "{}<> {{ {} }}", qkind, goal.skip_binder()) |
| } |
| CannotProve => write!(fmt, "CannotProve"), |
| } |
| } |
| } |
| |
| impl<'tcx> fmt::Display for traits::ProgramClause<'tcx> { |
| fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { |
| let traits::ProgramClause { goal, hypotheses } = self; |
| write!(fmt, "{}", goal)?; |
| if !hypotheses.is_empty() { |
| write!(fmt, " :- ")?; |
| for (index, condition) in hypotheses.iter().enumerate() { |
| if index > 0 { |
| write!(fmt, ", ")?; |
| } |
| write!(fmt, "{}", condition)?; |
| } |
| } |
| write!(fmt, ".") |
| } |
| } |
| |
| impl<'tcx> fmt::Display for traits::Clause<'tcx> { |
| fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { |
| use traits::Clause::*; |
| |
| match self { |
| Implies(clause) => write!(fmt, "{}", clause), |
| ForAll(clause) => { |
| // FIXME: appropriate binder names |
| write!(fmt, "forall<> {{ {} }}", clause.skip_binder()) |
| } |
| } |
| } |
| } |
| |
| EnumTypeFoldableImpl! { |
| impl<'tcx> TypeFoldable<'tcx> for traits::WhereClauseAtom<'tcx> { |
| (traits::WhereClauseAtom::Implemented)(trait_ref), |
| (traits::WhereClauseAtom::ProjectionEq)(projection), |
| } |
| } |
| |
| EnumTypeFoldableImpl! { |
| impl<'tcx> TypeFoldable<'tcx> for traits::DomainGoal<'tcx> { |
| (traits::DomainGoal::Holds)(wc), |
| (traits::DomainGoal::WellFormed)(wc), |
| (traits::DomainGoal::FromEnv)(wc), |
| (traits::DomainGoal::WellFormedTy)(ty), |
| (traits::DomainGoal::Normalize)(projection), |
| (traits::DomainGoal::FromEnvTy)(ty), |
| (traits::DomainGoal::RegionOutlives)(predicate), |
| (traits::DomainGoal::TypeOutlives)(predicate), |
| } |
| } |
| |
| CloneTypeFoldableImpls! { |
| traits::QuantifierKind, |
| } |
| |
| EnumTypeFoldableImpl! { |
| impl<'tcx> TypeFoldable<'tcx> for traits::Goal<'tcx> { |
| (traits::Goal::Implies)(hypotheses, goal), |
| (traits::Goal::And)(goal1, goal2), |
| (traits::Goal::Not)(goal), |
| (traits::Goal::DomainGoal)(domain_goal), |
| (traits::Goal::Quantified)(qkind, goal), |
| (traits::Goal::CannotProve), |
| } |
| } |
| |
| impl<'tcx> TypeFoldable<'tcx> for &'tcx ty::Slice<traits::Goal<'tcx>> { |
| fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self { |
| let v = self.iter().map(|t| t.fold_with(folder)).collect::<AccumulateVec<[_; 8]>>(); |
| folder.tcx().intern_goals(&v) |
| } |
| |
| fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool { |
| self.iter().any(|t| t.visit_with(visitor)) |
| } |
| } |
| |
| impl<'tcx> TypeFoldable<'tcx> for &'tcx traits::Goal<'tcx> { |
| fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self { |
| let v = (**self).fold_with(folder); |
| folder.tcx().mk_goal(v) |
| } |
| |
| fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool { |
| (**self).visit_with(visitor) |
| } |
| } |
| |
| BraceStructTypeFoldableImpl! { |
| impl<'tcx> TypeFoldable<'tcx> for traits::ProgramClause<'tcx> { |
| goal, |
| hypotheses |
| } |
| } |
| |
| EnumTypeFoldableImpl! { |
| impl<'tcx> TypeFoldable<'tcx> for traits::Clause<'tcx> { |
| (traits::Clause::Implies)(clause), |
| (traits::Clause::ForAll)(clause), |
| } |
| } |
| |
| impl<'tcx> TypeFoldable<'tcx> for &'tcx ty::Slice<traits::Clause<'tcx>> { |
| fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self { |
| let v = self.iter().map(|t| t.fold_with(folder)).collect::<AccumulateVec<[_; 8]>>(); |
| folder.tcx().intern_clauses(&v) |
| } |
| |
| fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool { |
| self.iter().any(|t| t.visit_with(visitor)) |
| } |
| } |
