Remove some unused boxed closure code

src/librustc/metadata/tydecode.rs

@@ -243,19 +243,6 @@ fn parse_size(st: &mut PState) -> Option<uint> {
     }
 }
 
-fn parse_trait_store_<F>(st: &mut PState, conv: &mut F) -> ty::TraitStore where
-    F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
-{
-    match next(st) {
-        '~' => ty::UniqTraitStore,
-        '&' => ty::RegionTraitStore(parse_region_(st, conv), parse_mutability(st)),
-        c => {
-            st.tcx.sess.bug(&format!("parse_trait_store(): bad input '{}'",
-                                    c)[])
-        }
-    }
-}
-
 fn parse_vec_per_param_space<'a, 'tcx, T, F>(st: &mut PState<'a, 'tcx>,
                                              mut f: F)
                                              -> VecPerParamSpace<T> where
@@ -641,14 +628,6 @@ fn parse_abi_set(st: &mut PState) -> abi::Abi {
     })
 }
 
-fn parse_onceness(c: char) -> ast::Onceness {
-    match c {
-        'o' => ast::Once,
-        'm' => ast::Many,
-        _ => panic!("parse_onceness: bad onceness")
-    }
-}
-
 fn parse_closure_ty<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>,
                                  mut conv: F) -> ty::ClosureTy<'tcx> where
     F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
@@ -661,16 +640,10 @@ fn parse_closure_ty_<'a, 'tcx, F>(st: &mut PState<'a, 'tcx>,
     F: FnMut(DefIdSource, ast::DefId) -> ast::DefId,
 {
     let unsafety = parse_unsafety(next(st));
-    let onceness = parse_onceness(next(st));
-    let store = parse_trait_store_(st, conv);
-    let bounds = parse_existential_bounds_(st, conv);
     let sig = parse_sig_(st, conv);
     let abi = parse_abi_set(st);
     ty::ClosureTy {
         unsafety: unsafety,
-        onceness: onceness,
-        store: store,
-        bounds: bounds,
         sig: sig,
         abi: abi,
     }

src/librustc/metadata/tyencode.rs

@@ -305,17 +305,6 @@ pub fn enc_trait_ref<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>,
     enc_substs(w, cx, s.substs);
 }
 
-pub fn enc_trait_store(w: &mut SeekableMemWriter, cx: &ctxt, s: ty::TraitStore) {
-    match s {
-        ty::UniqTraitStore => mywrite!(w, "~"),
-        ty::RegionTraitStore(re, m) => {
-            mywrite!(w, "&");
-            enc_region(w, cx, re);
-            enc_mutability(w, m);
-        }
-    }
-}
-
 fn enc_unsafety(w: &mut SeekableMemWriter, p: ast::Unsafety) {
     match p {
         ast::Unsafety::Normal => mywrite!(w, "n"),
@@ -329,13 +318,6 @@ fn enc_abi(w: &mut SeekableMemWriter, abi: Abi) {
     mywrite!(w, "]")
 }
 
-fn enc_onceness(w: &mut SeekableMemWriter, o: ast::Onceness) {
-    match o {
-        ast::Once => mywrite!(w, "o"),
-        ast::Many => mywrite!(w, "m")
-    }
-}
-
 pub fn enc_bare_fn_ty<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>,
                                 ft: &ty::BareFnTy<'tcx>) {
     enc_unsafety(w, ft.unsafety);
@@ -346,9 +328,6 @@ pub fn enc_bare_fn_ty<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>,
 pub fn enc_closure_ty<'a, 'tcx>(w: &mut SeekableMemWriter, cx: &ctxt<'a, 'tcx>,
                                 ft: &ty::ClosureTy<'tcx>) {
     enc_unsafety(w, ft.unsafety);
-    enc_onceness(w, ft.onceness);
-    enc_trait_store(w, cx, ft.store);
-    enc_existential_bounds(w, cx, &ft.bounds);
     enc_fn_sig(w, cx, &ft.sig);
     enc_abi(w, ft.abi);
 }

src/librustc/middle/astencode.rs

@@ -515,17 +515,6 @@ impl tr for ty::BoundRegion {
     }
 }
 
-impl tr for ty::TraitStore {
-    fn tr(&self, dcx: &DecodeContext) -> ty::TraitStore {
-        match *self {
-            ty::RegionTraitStore(r, m) => {
-                ty::RegionTraitStore(r.tr(dcx), m)
-            }
-            ty::UniqTraitStore => ty::UniqTraitStore
-        }
-    }
-}
-
 // ______________________________________________________________________
 // Encoding and decoding of freevar information
 

src/librustc/middle/infer/combine.rs

@@ -202,39 +202,6 @@ pub trait Combine<'tcx> : Sized {
                          sig: sig})
     }
 
-    fn closure_tys(&self, a: &ty::ClosureTy<'tcx>,
-                   b: &ty::ClosureTy<'tcx>) -> cres<'tcx, ty::ClosureTy<'tcx>> {
-
-        let store = match (a.store, b.store) {
-            (ty::RegionTraitStore(a_r, a_m),
-             ty::RegionTraitStore(b_r, b_m)) if a_m == b_m => {
-                let r = try!(self.contraregions(a_r, b_r));
-                ty::RegionTraitStore(r, a_m)
-            }
-
-            _ if a.store == b.store => {
-                a.store
-            }
-
-            _ => {
-                return Err(ty::terr_sigil_mismatch(expected_found(self, a.store, b.store)))
-            }
-        };
-        let unsafety = try!(self.unsafeties(a.unsafety, b.unsafety));
-        let onceness = try!(self.oncenesses(a.onceness, b.onceness));
-        let bounds = try!(self.existential_bounds(&a.bounds, &b.bounds));
-        let sig = try!(self.binders(&a.sig, &b.sig));
-        let abi = try!(self.abi(a.abi, b.abi));
-        Ok(ty::ClosureTy {
-            unsafety: unsafety,
-            onceness: onceness,
-            store: store,
-            bounds: bounds,
-            sig: sig,
-            abi: abi,
-        })
-    }
-
     fn fn_sigs(&self, a: &ty::FnSig<'tcx>, b: &ty::FnSig<'tcx>) -> cres<'tcx, ty::FnSig<'tcx>> {
         if a.variadic != b.variadic {
             return Err(ty::terr_variadic_mismatch(expected_found(self, a.variadic, b.variadic)));
@@ -356,31 +323,6 @@ pub trait Combine<'tcx> : Sized {
 
     fn regions(&self, a: ty::Region, b: ty::Region) -> cres<'tcx, ty::Region>;
 
-    fn trait_stores(&self,
-                    vk: ty::terr_vstore_kind,
-                    a: ty::TraitStore,
-                    b: ty::TraitStore)
-                    -> cres<'tcx, ty::TraitStore> {
-        debug!("{}.trait_stores(a={:?}, b={:?})", self.tag(), a, b);
-
-        match (a, b) {
-            (ty::RegionTraitStore(a_r, a_m),
-             ty::RegionTraitStore(b_r, b_m)) if a_m == b_m => {
-                self.contraregions(a_r, b_r).and_then(|r| {
-                    Ok(ty::RegionTraitStore(r, a_m))
-                })
-            }
-
-            _ if a == b => {
-                Ok(a)
-            }
-
-            _ => {
-                Err(ty::terr_trait_stores_differ(vk, expected_found(self, a, b)))
-            }
-        }
-    }
-
     fn trait_refs(&self,
                   a: &ty::TraitRef<'tcx>,
                   b: &ty::TraitRef<'tcx>)

src/librustc/middle/ty.rs

@@ -17,7 +17,6 @@ pub use self::InferTy::*;
 pub use self::InferRegion::*;
 pub use self::ImplOrTraitItemId::*;
 pub use self::UnboxedClosureKind::*;
-pub use self::TraitStore::*;
 pub use self::ast_ty_to_ty_cache_entry::*;
 pub use self::Variance::*;
 pub use self::AutoAdjustment::*;
@@ -61,7 +60,7 @@ use middle::ty;
 use middle::ty_fold::{self, TypeFoldable, TypeFolder};
 use middle::ty_walk::TypeWalker;
 use util::ppaux::{note_and_explain_region, bound_region_ptr_to_string};
-use util::ppaux::{trait_store_to_string, ty_to_string};
+use util::ppaux::ty_to_string;
 use util::ppaux::{Repr, UserString};
 use util::common::{memoized, ErrorReported};
 use util::nodemap::{NodeMap, NodeSet, DefIdMap, DefIdSet};
@@ -247,14 +246,6 @@ pub struct mt<'tcx> {
     pub mutbl: ast::Mutability,
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Show)]
-pub enum TraitStore {
-    /// Box<Trait>
-    UniqTraitStore,
-    /// &Trait and &mut Trait
-    RegionTraitStore(Region, ast::Mutability),
-}
-
 #[derive(Clone, Copy, Show)]
 pub struct field_ty {
     pub name: Name,
@@ -1041,11 +1032,8 @@ pub struct BareFnTy<'tcx> {
 #[derive(Clone, PartialEq, Eq, Hash, Show)]
 pub struct ClosureTy<'tcx> {
     pub unsafety: ast::Unsafety,
-    pub onceness: ast::Onceness,
-    pub store: TraitStore,
-    pub bounds: ExistentialBounds<'tcx>,
-    pub sig: PolyFnSig<'tcx>,
     pub abi: abi::Abi,
+    pub sig: PolyFnSig<'tcx>,
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Show)]
@@ -1545,7 +1533,6 @@ pub enum type_err<'tcx> {
     terr_onceness_mismatch(expected_found<Onceness>),
     terr_abi_mismatch(expected_found<abi::Abi>),
     terr_mutability,
-    terr_sigil_mismatch(expected_found<TraitStore>),
     terr_box_mutability,
     terr_ptr_mutability,
     terr_ref_mutability,
@@ -1559,7 +1546,6 @@ pub enum type_err<'tcx> {
     terr_regions_no_overlap(Region, Region),
     terr_regions_insufficiently_polymorphic(BoundRegion, Region),
     terr_regions_overly_polymorphic(BoundRegion, Region),
-    terr_trait_stores_differ(terr_vstore_kind, expected_found<TraitStore>),
     terr_sorts(expected_found<Ty<'tcx>>),
     terr_integer_as_char,
     terr_int_mismatch(expected_found<IntVarValue>),
@@ -4194,19 +4180,6 @@ pub fn ty_fn_args<'tcx>(fty: Ty<'tcx>) -> ty::Binder<Vec<Ty<'tcx>>> {
     ty_fn_sig(fty).inputs()
 }
 
-pub fn ty_closure_store(fty: Ty) -> TraitStore {
-    match fty.sty {
-        ty_unboxed_closure(..) => {
-            // Close enough for the purposes of all the callers of this
-            // function (which is soon to be deprecated anyhow).
-            UniqTraitStore
-        }
-        ref s => {
-            panic!("ty_closure_store() called on non-closure type: {:?}", s)
-        }
-    }
-}
-
 pub fn ty_fn_ret<'tcx>(fty: Ty<'tcx>) -> Binder<FnOutput<'tcx>> {
     match fty.sty {
         ty_bare_fn(_, ref f) => f.sig.output(),
@@ -4751,13 +4724,6 @@ impl<'tcx> Repr<'tcx> for ty::type_err<'tcx> {
 /// afterwards to present additional details, particularly when it comes to lifetime-related
 /// errors.
 pub fn type_err_to_str<'tcx>(cx: &ctxt<'tcx>, err: &type_err<'tcx>) -> String {
-    fn tstore_to_closure(s: &TraitStore) -> String {
-        match s {
-            &UniqTraitStore => "proc".to_string(),
-            &RegionTraitStore(..) => "closure".to_string()
-        }
-    }
-
     match *err {
         terr_cyclic_ty => "cyclic type of infinite size".to_string(),
         terr_mismatch => "types differ".to_string(),
@@ -4776,11 +4742,6 @@ pub fn type_err_to_str<'tcx>(cx: &ctxt<'tcx>, err: &type_err<'tcx>) -> String {
                     values.expected,
                     values.found)
         }
-        terr_sigil_mismatch(values) => {
-            format!("expected {}, found {}",
-                    tstore_to_closure(&values.expected),
-                    tstore_to_closure(&values.found))
-        }
         terr_mutability => "values differ in mutability".to_string(),
         terr_box_mutability => {
             "boxed values differ in mutability".to_string()
@@ -4828,11 +4789,6 @@ pub fn type_err_to_str<'tcx>(cx: &ctxt<'tcx>, err: &type_err<'tcx>) -> String {
                      found bound lifetime parameter {}",
                     bound_region_ptr_to_string(cx, br))
         }
-        terr_trait_stores_differ(_, ref values) => {
-            format!("trait storage differs: expected `{}`, found `{}`",
-                    trait_store_to_string(cx, (*values).expected),
-                    trait_store_to_string(cx, (*values).found))
-        }
         terr_sorts(values) => {
             // A naive approach to making sure that we're not reporting silly errors such as:
             // (expected closure, found closure).
@@ -7338,11 +7294,8 @@ impl ReferencesError for Region
 
 impl<'tcx> Repr<'tcx> for ClosureTy<'tcx> {
     fn repr(&self, tcx: &ctxt<'tcx>) -> String {
-        format!("ClosureTy({},{},{:?},{},{},{})",
+        format!("ClosureTy({},{},{})",
                 self.unsafety,
-                self.onceness,
-                self.store,
-                self.bounds.repr(tcx),
                 self.sig.repr(tcx),
                 self.abi)
     }
@@ -7373,5 +7326,5 @@ impl<'a, 'tcx> Repr<'tcx> for ParameterEnvironment<'a, 'tcx> {
             self.free_substs.repr(tcx),
             self.implicit_region_bound.repr(tcx),
             self.caller_bounds.repr(tcx))
-        }
     }
+}

src/librustc/middle/ty_fold.rs

@@ -124,10 +124,6 @@ pub trait TypeFolder<'tcx> : Sized {
         r
     }
 
-    fn fold_trait_store(&mut self, s: ty::TraitStore) -> ty::TraitStore {
-        super_fold_trait_store(self, s)
-    }
-
     fn fold_existential_bounds(&mut self, s: &ty::ExistentialBounds<'tcx>)
                                -> ty::ExistentialBounds<'tcx> {
         super_fold_existential_bounds(self, s)
@@ -225,12 +221,6 @@ impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for VecPerParamSpace<T> {
     }
 }
 
-impl<'tcx> TypeFoldable<'tcx> for ty::TraitStore {
-    fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> ty::TraitStore {
-        folder.fold_trait_store(*self)
-    }
-}
-
 impl<'tcx> TypeFoldable<'tcx> for Ty<'tcx> {
     fn fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Ty<'tcx> {
         folder.fold_ty(*self)
@@ -699,11 +689,8 @@ pub fn super_fold_closure_ty<'tcx, T: TypeFolder<'tcx>>(this: &mut T,
                                                         -> ty::ClosureTy<'tcx>
 {
     ty::ClosureTy {
-        store: fty.store.fold_with(this),
         sig: fty.sig.fold_with(this),
         unsafety: fty.unsafety,
-        onceness: fty.onceness,
-        bounds: fty.bounds.fold_with(this),
         abi: fty.abi,
     }
 }
@@ -726,17 +713,6 @@ pub fn super_fold_mt<'tcx, T: TypeFolder<'tcx>>(this: &mut T,
             mutbl: mt.mutbl}
 }
 
-pub fn super_fold_trait_store<'tcx, T: TypeFolder<'tcx>>(this: &mut T,
-                                                         trait_store: ty::TraitStore)
-                                                         -> ty::TraitStore {
-    match trait_store {
-        ty::UniqTraitStore => ty::UniqTraitStore,
-        ty::RegionTraitStore(r, m) => {
-            ty::RegionTraitStore(r.fold_with(this), m)
-        }
-    }
-}
-
 pub fn super_fold_existential_bounds<'tcx, T: TypeFolder<'tcx>>(
     this: &mut T,
     bounds: &ty::ExistentialBounds<'tcx>)