Factor out foldable better to reduce code duplication. There is now a "double

dispatch" pattern that lets you easily write new folders and then apply them to
various structures, reusing the "folding" effort.

Author: nikomatsakis

src/librustc/middle/subst.rs

@@ -12,56 +12,48 @@
 
 use middle::ty;
 use middle::ty_fold;
-use middle::ty_fold::TypeFolder;
+use middle::ty_fold::{TypeFoldable, TypeFolder};
 use util::ppaux::Repr;
 
-use std::rc::Rc;
 use syntax::codemap::Span;
-use syntax::owned_slice::OwnedSlice;
 
 ///////////////////////////////////////////////////////////////////////////
 // Public trait `Subst`
 //
 // Just call `foo.subst(tcx, substs)` to perform a substitution across
-// `foo`.
-// Or use `foo.subst_spanned(tcx, substs, Some(span))` when there is more
-// information available (for better errors).
+// `foo`. Or use `foo.subst_spanned(tcx, substs, Some(span))` when
+// there is more information available (for better errors).
 
 pub trait Subst {
     fn subst(&self, tcx: &ty::ctxt, substs: &ty::substs) -> Self {
         self.subst_spanned(tcx, substs, None)
     }
+
     fn subst_spanned(&self, tcx: &ty::ctxt,
                      substs: &ty::substs,
-                     span: Option<Span>) -> Self;
+                     span: Option<Span>)
+                     -> Self;
 }
 
-///////////////////////////////////////////////////////////////////////////
-// Substitution over types
-//
-// Because this is so common, we make a special optimization to avoid
-// doing anything if `substs` is a no-op.  I tried to generalize these
-// to all subst methods but ran into trouble due to the limitations of
-// our current method/trait matching algorithm. - Niko
-
-impl Subst for ty::t {
-    fn subst_spanned(&self, tcx: &ty::ctxt,
+impl<T:TypeFoldable> Subst for T {
+    fn subst_spanned(&self,
+                     tcx: &ty::ctxt,
                      substs: &ty::substs,
-                     span: Option<Span>) -> ty::t {
-        if ty::substs_is_noop(substs) && !ty::type_has_params(*self) {
-            *self
-        } else {
-            let mut folder = SubstFolder {
-                tcx: tcx,
-                substs: substs,
-                span: span,
-                root_ty: Some(*self)
-            };
-            folder.fold_ty(*self)
-        }
+                     span: Option<Span>)
+                     -> T
+    {
+        let mut folder = SubstFolder { tcx: tcx,
+                                       substs: substs,
+                                       span: span,
+                                       root_ty: None,
+                                       ty_stack_depth: 0 };
+        (*self).fold_with(&mut folder)
     }
 }
 
+///////////////////////////////////////////////////////////////////////////
+// The actual substitution engine itself is a type folder.
+
 struct SubstFolder<'a> {
     tcx: &'a ty::ctxt,
     substs: &'a ty::substs,
@@ -70,23 +62,50 @@ struct SubstFolder<'a> {
     span: Option<Span>,
 
     // The root type that is being substituted, if available.
-    root_ty: Option<ty::t>
+    root_ty: Option<ty::t>,
+
+    // Depth of type stack
+    ty_stack_depth: uint,
 }
 
 impl<'a> TypeFolder for SubstFolder<'a> {
     fn tcx<'a>(&'a self) -> &'a ty::ctxt { self.tcx }
 
     fn fold_region(&mut self, r: ty::Region) -> ty::Region {
-        r.subst(self.tcx, self.substs)
+        // Note: This routine only handles regions that are bound on
+        // type declarations and other outer declarations, not those
+        // bound in *fn types*. Region substitution of the bound
+        // regions that appear in a function signature is done using
+        // the specialized routine
+        // `middle::typeck::check::regionmanip::replace_late_regions_in_fn_sig()`.
+        match r {
+            ty::ReEarlyBound(_, i, _) => {
+                match self.substs.regions {
+                    ty::ErasedRegions => ty::ReStatic,
+                    ty::NonerasedRegions(ref regions) => *regions.get(i),
+                }
+            }
+            _ => r
+        }
     }
 
     fn fold_ty(&mut self, t: ty::t) -> ty::t {
         if !ty::type_needs_subst(t) {
             return t;
         }
 
-        match ty::get(t).sty {
+        // track the root type we were asked to substitute
+        let depth = self.ty_stack_depth;
+        if depth == 0 {
+            self.root_ty = Some(t);
+        }
+        self.ty_stack_depth += 1;
+
+        let t1 = match ty::get(t).sty {
             ty::ty_param(p) => {
+                // FIXME -- This...really shouldn't happen. We should
+                // never be substituting without knowing what's in
+                // scope and knowing that the indices will line up!
                 if p.idx < self.substs.tps.len() {
                     *self.substs.tps.get(p.idx)
                 } else {
@@ -124,189 +143,14 @@ impl<'a> TypeFolder for SubstFolder<'a> {
                 }
             }
             _ => ty_fold::super_fold_ty(self, t)
-        }
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////
-// Other types
-
-impl<T:Subst> Subst for Vec<T> {
-    fn subst_spanned(&self, tcx: &ty::ctxt,
-                     substs: &ty::substs,
-                     span: Option<Span>) -> Vec<T> {
-        self.iter().map(|t| t.subst_spanned(tcx, substs, span)).collect()
-    }
-}
-impl<T:Subst> Subst for Rc<T> {
-    fn subst_spanned(&self, tcx: &ty::ctxt,
-                     substs: &ty::substs,
-                     span: Option<Span>) -> Rc<T> {
-        Rc::new((**self).subst_spanned(tcx, substs, span))
-    }
-}
-
-impl<T:Subst> Subst for OwnedSlice<T> {
-    fn subst_spanned(&self, tcx: &ty::ctxt,
-                     substs: &ty::substs,
-                     span: Option<Span>) -> OwnedSlice<T> {
-        self.map(|t| t.subst_spanned(tcx, substs, span))
-    }
-}
-
-impl<T:Subst + 'static> Subst for @T {
-    fn subst_spanned(&self, tcx: &ty::ctxt,
-                     substs: &ty::substs,
-                     span: Option<Span>) -> @T {
-        match self {
-            t => @(**t).subst_spanned(tcx, substs, span)
-        }
-    }
-}
-
-impl<T:Subst> Subst for Option<T> {
-    fn subst_spanned(&self, tcx: &ty::ctxt,
-                     substs: &ty::substs,
-                     span: Option<Span>) -> Option<T> {
-        self.as_ref().map(|t| t.subst_spanned(tcx, substs, span))
-    }
-}
-
-impl Subst for ty::TraitRef {
-    fn subst_spanned(&self, tcx: &ty::ctxt,
-                     substs: &ty::substs,
-                     span: Option<Span>) -> ty::TraitRef {
-        ty::TraitRef {
-            def_id: self.def_id,
-            substs: self.substs.subst_spanned(tcx, substs, span)
-        }
-    }
-}
-
-impl Subst for ty::substs {
-    fn subst_spanned(&self, tcx: &ty::ctxt,
-                     substs: &ty::substs,
-                     span: Option<Span>) -> ty::substs {
-        ty::substs {
-            regions: self.regions.subst_spanned(tcx, substs, span),
-            self_ty: self.self_ty.map(|typ| typ.subst_spanned(tcx, substs, span)),
-            tps: self.tps.iter().map(|typ| typ.subst_spanned(tcx, substs, span)).collect()
-        }
-    }
-}
-
-impl Subst for ty::ItemSubsts {
-    fn subst_spanned(&self, tcx: &ty::ctxt,
-                     substs: &ty::substs,
-                     span: Option<Span>)
-                     -> ty::ItemSubsts {
-        ty::ItemSubsts {
-            substs: self.substs.subst_spanned(tcx, substs, span)
-        }
-    }
-}
-
-impl Subst for ty::RegionSubsts {
-    fn subst_spanned(&self, tcx: &ty::ctxt,
-                     substs: &ty::substs,
-                     span: Option<Span>) -> ty::RegionSubsts {
-        match *self {
-            ty::ErasedRegions => {
-                ty::ErasedRegions
-            }
-            ty::NonerasedRegions(ref regions) => {
-                ty::NonerasedRegions(regions.subst_spanned(tcx, substs, span))
-            }
-        }
-    }
-}
-
-impl Subst for ty::BareFnTy {
-    fn subst_spanned(&self, tcx: &ty::ctxt,
-                     substs: &ty::substs,
-                     span: Option<Span>) -> ty::BareFnTy {
-        let mut folder = SubstFolder {
-            tcx: tcx,
-            substs: substs,
-            span: span,
-            root_ty: None
         };
-        folder.fold_bare_fn_ty(self)
-    }
-}
 
-impl Subst for ty::ParamBounds {
-    fn subst_spanned(&self, tcx: &ty::ctxt,
-                     substs: &ty::substs,
-                     span: Option<Span>) -> ty::ParamBounds {
-        ty::ParamBounds {
-            builtin_bounds: self.builtin_bounds,
-            trait_bounds: self.trait_bounds.subst_spanned(tcx, substs, span)
+        assert_eq!(depth + 1, self.ty_stack_depth);
+        self.ty_stack_depth -= 1;
+        if depth == 0 {
+            self.root_ty = None;
         }
-    }
-}
 
-impl Subst for ty::TypeParameterDef {
-    fn subst_spanned(&self, tcx: &ty::ctxt,
-                     substs: &ty::substs,
-                     span: Option<Span>) -> ty::TypeParameterDef {
-        ty::TypeParameterDef {
-            ident: self.ident,
-            def_id: self.def_id,
-            bounds: self.bounds.subst_spanned(tcx, substs, span),
-            default: self.default.map(|x| x.subst_spanned(tcx, substs, span))
-        }
-    }
-}
-
-impl Subst for ty::Generics {
-    fn subst_spanned(&self, tcx: &ty::ctxt,
-                     substs: &ty::substs,
-                     span: Option<Span>) -> ty::Generics {
-        ty::Generics {
-            type_param_defs: self.type_param_defs.subst_spanned(tcx, substs, span),
-            region_param_defs: self.region_param_defs.subst_spanned(tcx, substs, span),
-        }
-    }
-}
-
-impl Subst for ty::RegionParameterDef {
-    fn subst_spanned(&self, _: &ty::ctxt,
-                     _: &ty::substs,
-                     _: Option<Span>) -> ty::RegionParameterDef {
-        *self
-    }
-}
-
-impl Subst for ty::Region {
-    fn subst_spanned(&self, _tcx: &ty::ctxt,
-                     substs: &ty::substs,
-                     _: Option<Span>) -> ty::Region {
-        // Note: This routine only handles regions that are bound on
-        // type declarations and other outer declarations, not those
-        // bound in *fn types*. Region substitution of the bound
-        // regions that appear in a function signature is done using
-        // the specialized routine
-        // `middle::typeck::check::regionmanip::replace_late_regions_in_fn_sig()`.
-        match self {
-            &ty::ReEarlyBound(_, i, _) => {
-                match substs.regions {
-                    ty::ErasedRegions => ty::ReStatic,
-                    ty::NonerasedRegions(ref regions) => *regions.get(i),
-                }
-            }
-            _ => *self
-        }
-    }
-}
-
-impl Subst for ty::ty_param_bounds_and_ty {
-    fn subst_spanned(&self, tcx: &ty::ctxt,
-                     substs: &ty::substs,
-                     span: Option<Span>) -> ty::ty_param_bounds_and_ty {
-        ty::ty_param_bounds_and_ty {
-            generics: self.generics.subst_spanned(tcx, substs, span),
-            ty: self.ty.subst_spanned(tcx, substs, span)
-        }
+        t1
     }
 }

src/librustc/middle/ty.rs

@@ -26,7 +26,7 @@ use middle::subst::Subst;
 use middle::typeck;
 use middle::typeck::MethodCall;
 use middle::ty_fold;
-use middle::ty_fold::TypeFolder;
+use middle::ty_fold::{TypeFoldable,TypeFolder};
 use middle;
 use util::ppaux::{note_and_explain_region, bound_region_ptr_to_str};
 use util::ppaux::{trait_store_to_str, ty_to_str};
@@ -1034,7 +1034,7 @@ pub struct ParameterEnvironment {
     pub self_param_bound: Option<Rc<TraitRef>>,
 
     /// Bounds on each numbered type parameter
-    pub type_param_bounds: Vec<ParamBounds> ,
+    pub type_param_bounds: Vec<ParamBounds>,
 }
 
 /// A polytype.
@@ -1519,7 +1519,9 @@ pub fn walk_regions_and_ty(cx: &ctxt, ty: t, fldr: |r: Region|, fldt: |t: t|)
 
 impl ItemSubsts {
     pub fn empty() -> ItemSubsts {
-        ItemSubsts { substs: substs::empty() }
+        ItemSubsts {
+            substs: substs::empty(),
+        }
     }
 
     pub fn is_noop(&self) -> bool {
@@ -4102,8 +4104,8 @@ pub fn normalize_ty(cx: &ctxt, t: t) -> t {
                        substs: &substs)
                        -> substs {
             substs { regions: ErasedRegions,
-                     self_ty: ty_fold::fold_opt_ty(self, substs.self_ty),
-                     tps: ty_fold::fold_ty_vec(self, substs.tps.as_slice()) }
+                     self_ty: substs.self_ty.fold_with(self),
+                     tps: substs.tps.fold_with(self) }
         }
 
         fn fold_sig(&mut self,
@@ -4113,8 +4115,8 @@ pub fn normalize_ty(cx: &ctxt, t: t) -> t {
             // are erased at trans time.
             ty::FnSig {
                 binder_id: ast::DUMMY_NODE_ID,
-                inputs: ty_fold::fold_ty_vec(self, sig.inputs.as_slice()),
-                output: self.fold_ty(sig.output),
+                inputs: sig.inputs.fold_with(self),
+                output: sig.output.fold_with(self),
                 variadic: sig.variadic,
             }
         }