From 014bf0df341ef63a8f3ce39b6eecc1e11ca41c55 Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Mon, 25 May 2015 19:51:16 +0200 Subject: [PATCH] Clean-up some junk --- src/librustc/metadata/csearch.rs | 14 ---- src/librustc/metadata/decoder.rs | 21 ------ src/librustc/middle/astencode.rs | 92 -------------------------- src/librustc/middle/ty.rs | 109 +------------------------------ src/librustc/middle/ty_fold.rs | 21 ------ 5 files changed, 2 insertions(+), 255 deletions(-) diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs index f834076e8eab5..57b75383bc834 100644 --- a/src/librustc/metadata/csearch.rs +++ b/src/librustc/metadata/csearch.rs @@ -297,15 +297,6 @@ pub fn get_impl_trait<'tcx>(tcx: &ty::ctxt<'tcx>, decoder::get_impl_trait(&*cdata, def.node, tcx) } -// Given a def_id for an impl, return information about its vtables -pub fn get_impl_vtables<'tcx>(tcx: &ty::ctxt<'tcx>, - def: ast::DefId) - -> ty::vtable_res<'tcx> { - let cstore = &tcx.sess.cstore; - let cdata = cstore.get_crate_data(def.krate); - decoder::get_impl_vtables(&*cdata, def.node, tcx) -} - pub fn get_native_libraries(cstore: &cstore::CStore, crate_num: ast::CrateNum) -> Vec<(cstore::NativeLibraryKind, String)> { let cdata = cstore.get_crate_data(crate_num); @@ -414,11 +405,6 @@ pub fn get_repr_attrs(cstore: &cstore::CStore, def: ast::DefId) decoder::get_repr_attrs(&*cdata, def.node) } -pub fn is_associated_type(cstore: &cstore::CStore, def: ast::DefId) -> bool { - let cdata = cstore.get_crate_data(def.krate); - decoder::is_associated_type(&*cdata, def.node) -} - pub fn is_defaulted_trait(cstore: &cstore::CStore, trait_def_id: ast::DefId) -> bool { let cdata = cstore.get_crate_data(trait_def_id.krate); decoder::is_defaulted_trait(&*cdata, trait_def_id.node) diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index ee5fd0202d69e..aaebacf966aad 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -30,7 +30,6 @@ use middle::lang_items; use middle::subst; use middle::ty::{ImplContainer, TraitContainer}; use middle::ty::{self, Ty}; -use middle::astencode::vtable_decoder_helpers; use util::nodemap::FnvHashMap; use std::cell::{Cell, RefCell}; @@ -522,18 +521,6 @@ pub fn get_impl_trait<'tcx>(cdata: Cmd, } } -pub fn get_impl_vtables<'tcx>(cdata: Cmd, - id: ast::NodeId, - tcx: &ty::ctxt<'tcx>) - -> ty::vtable_res<'tcx> -{ - let item_doc = lookup_item(id, cdata.data()); - let vtables_doc = reader::get_doc(item_doc, tag_item_impl_vtables); - let mut decoder = reader::Decoder::new(vtables_doc); - decoder.read_vtable_res(tcx, cdata) -} - - pub fn get_symbol(data: &[u8], id: ast::NodeId) -> String { return item_symbol(lookup_item(id, data)); } @@ -1623,14 +1610,6 @@ fn doc_predicates<'tcx>(base_doc: rbml::Doc, ty::GenericPredicates { predicates: predicates } } -pub fn is_associated_type(cdata: Cmd, id: ast::NodeId) -> bool { - let items = reader::get_doc(rbml::Doc::new(cdata.data()), tag_items); - match maybe_find_item(id, items) { - None => false, - Some(item) => item_sort(item) == Some('t'), - } -} - pub fn is_defaulted_trait(cdata: Cmd, trait_id: ast::NodeId) -> bool { let trait_doc = lookup_item(trait_id, cdata.data()); assert!(item_family(trait_doc) == Family::Trait); diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index b7e57819b93b4..bfc74ccc2437c 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -696,19 +696,6 @@ pub fn encode_cast_kind(ebml_w: &mut Encoder, kind: cast::CastKind) { pub trait vtable_decoder_helpers<'tcx> { fn read_vec_per_param_space(&mut self, f: F) -> VecPerParamSpace where F: FnMut(&mut Self) -> T; - fn read_vtable_res_with_key(&mut self, - tcx: &ty::ctxt<'tcx>, - cdata: &cstore::crate_metadata) - -> (u32, ty::vtable_res<'tcx>); - fn read_vtable_res(&mut self, - tcx: &ty::ctxt<'tcx>, cdata: &cstore::crate_metadata) - -> ty::vtable_res<'tcx>; - fn read_vtable_param_res(&mut self, - tcx: &ty::ctxt<'tcx>, cdata: &cstore::crate_metadata) - -> ty::vtable_param_res<'tcx>; - fn read_vtable_origin(&mut self, - tcx: &ty::ctxt<'tcx>, cdata: &cstore::crate_metadata) - -> ty::vtable_origin<'tcx>; } impl<'tcx, 'a> vtable_decoder_helpers<'tcx> for reader::Decoder<'a> { @@ -720,85 +707,6 @@ impl<'tcx, 'a> vtable_decoder_helpers<'tcx> for reader::Decoder<'a> { let fns = self.read_to_vec(|this| Ok(f(this))).unwrap(); VecPerParamSpace::new(types, selfs, fns) } - - fn read_vtable_res_with_key(&mut self, - tcx: &ty::ctxt<'tcx>, - cdata: &cstore::crate_metadata) - -> (u32, ty::vtable_res<'tcx>) { - self.read_struct("VtableWithKey", 2, |this| { - let autoderef = this.read_struct_field("autoderef", 0, |this| { - Decodable::decode(this) - }).unwrap(); - Ok((autoderef, this.read_struct_field("vtable_res", 1, |this| { - Ok(this.read_vtable_res(tcx, cdata)) - }).unwrap())) - }).unwrap() - } - - fn read_vtable_res(&mut self, - tcx: &ty::ctxt<'tcx>, - cdata: &cstore::crate_metadata) - -> ty::vtable_res<'tcx> - { - self.read_vec_per_param_space( - |this| this.read_vtable_param_res(tcx, cdata)) - } - - fn read_vtable_param_res(&mut self, - tcx: &ty::ctxt<'tcx>, cdata: &cstore::crate_metadata) - -> ty::vtable_param_res<'tcx> { - self.read_to_vec(|this| Ok(this.read_vtable_origin(tcx, cdata))) - .unwrap().into_iter().collect() - } - - fn read_vtable_origin(&mut self, - tcx: &ty::ctxt<'tcx>, cdata: &cstore::crate_metadata) - -> ty::vtable_origin<'tcx> { - self.read_enum("vtable_origin", |this| { - this.read_enum_variant(&["vtable_static", - "vtable_param", - "vtable_error", - "vtable_closure"], - |this, i| { - Ok(match i { - 0 => { - ty::vtable_static( - this.read_enum_variant_arg(0, |this| { - Ok(this.read_def_id_nodcx(cdata)) - }).unwrap(), - this.read_enum_variant_arg(1, |this| { - Ok(this.read_substs_nodcx(tcx, cdata)) - }).unwrap(), - this.read_enum_variant_arg(2, |this| { - Ok(this.read_vtable_res(tcx, cdata)) - }).unwrap() - ) - } - 1 => { - ty::vtable_param( - this.read_enum_variant_arg(0, |this| { - Decodable::decode(this) - }).unwrap(), - this.read_enum_variant_arg(1, |this| { - this.read_uint() - }).unwrap() - ) - } - 2 => { - ty::vtable_closure( - this.read_enum_variant_arg(0, |this| { - Ok(this.read_def_id_nodcx(cdata)) - }).unwrap() - ) - } - 3 => { - ty::vtable_error - } - _ => panic!("bad enum variant") - }) - }) - }).unwrap() - } } // ___________________________________________________________________________ diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index 5ff6ee3c8b081..3ae3f34284a34 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -32,7 +32,6 @@ pub use self::ImplOrTraitItem::*; pub use self::BoundRegion::*; pub use self::sty::*; pub use self::IntVarValue::*; -pub use self::vtable_origin::*; pub use self::MethodOrigin::*; pub use self::CopyImplementationError::*; @@ -402,12 +401,6 @@ pub enum CustomCoerceUnsized { Struct(usize) } -#[derive(Clone, Copy, RustcEncodable, RustcDecodable, PartialEq, PartialOrd, Debug)] -pub struct param_index { - pub space: subst::ParamSpace, - pub index: usize -} - #[derive(Clone, Debug)] pub enum MethodOrigin<'tcx> { // fully statically resolved method @@ -510,46 +503,6 @@ impl MethodCall { // of the method to be invoked pub type MethodMap<'tcx> = RefCell>>; -pub type vtable_param_res<'tcx> = Vec>; - -// Resolutions for bounds of all parameters, left to right, for a given path. -pub type vtable_res<'tcx> = VecPerParamSpace>; - -#[derive(Clone)] -pub enum vtable_origin<'tcx> { - /* - Statically known vtable. def_id gives the impl item - from whence comes the vtable, and tys are the type substs. - vtable_res is the vtable itself. - */ - vtable_static(ast::DefId, subst::Substs<'tcx>, vtable_res<'tcx>), - - /* - Dynamic vtable, comes from a parameter that has a bound on it: - fn foo(a: T) -- a's vtable would have a - vtable_param origin - - The first argument is the param index (identifying T in the example), - and the second is the bound number (identifying baz) - */ - vtable_param(param_index, usize), - - /* - Vtable automatically generated for a closure. The def ID is the - ID of the closure expression. - */ - vtable_closure(ast::DefId), - - /* - Asked to determine the vtable for ty_err. This is the value used - for the vtables of `Self` in a virtual call like `foo.bar()` - where `foo` is of object type. The same value is also used when - type errors occur. - */ - vtable_error, -} - - // For every explicit cast into an object type, maps from the cast // expr to the associated trait ref. pub type ObjectCastMap<'tcx> = RefCell>>; @@ -803,9 +756,6 @@ pub struct ctxt<'tcx> { /// Maps any item's def-id to its stability index. pub stability: RefCell, - /// Maps def IDs to true if and only if they're associated types. - pub associated_types: RefCell>, - /// Caches the results of trait selection. This cache is used /// for things that do not have to do with the parameters in scope. pub selection_cache: traits::SelectionCache<'tcx>, @@ -2816,7 +2766,6 @@ pub fn mk_ctxt<'tcx>(s: Session, node_lint_levels: RefCell::new(FnvHashMap()), transmute_restrictions: RefCell::new(Vec::new()), stability: RefCell::new(stability), - associated_types: RefCell::new(DefIdMap()), selection_cache: traits::SelectionCache::new(), repr_hint_cache: RefCell::new(DefIdMap()), type_impls_copy_cache: RefCell::new(HashMap::new()), @@ -4305,17 +4254,9 @@ pub fn is_type_representable<'tcx>(cx: &ctxt<'tcx>, sp: Span, ty: Ty<'tcx>) } pub fn type_is_trait(ty: Ty) -> bool { - type_trait_info(ty).is_some() -} - -pub fn type_trait_info<'tcx>(ty: Ty<'tcx>) -> Option<&'tcx TyTrait<'tcx>> { match ty.sty { - ty_uniq(ty) | ty_rptr(_, mt { ty, ..}) | ty_ptr(mt { ty, ..}) => match ty.sty { - ty_trait(ref t) => Some(&**t), - _ => None - }, - ty_trait(ref t) => Some(&**t), - _ => None + ty_trait(..) => true, + _ => false } } @@ -5399,26 +5340,6 @@ pub fn impl_or_trait_item<'tcx>(cx: &ctxt<'tcx>, id: ast::DefId) }) } -/// Returns true if the given ID refers to an associated type and false if it -/// refers to anything else. -pub fn is_associated_type(cx: &ctxt, id: ast::DefId) -> bool { - memoized(&cx.associated_types, id, |id: ast::DefId| { - if id.krate == ast::LOCAL_CRATE { - match cx.impl_or_trait_items.borrow().get(&id) { - Some(ref item) => { - match **item { - TypeTraitItem(_) => true, - _ => false, - } - } - None => false, - } - } else { - csearch::is_associated_type(&cx.sess.cstore, id) - } - }) -} - /// Returns the parameter index that the given associated type corresponds to. pub fn associated_type_parameter_index(cx: &ctxt, trait_def: &TraitDef, @@ -7223,32 +7144,6 @@ impl<'tcx> Repr<'tcx> for ty::Predicate<'tcx> { } } -impl<'tcx> Repr<'tcx> for vtable_origin<'tcx> { - fn repr(&self, tcx: &ty::ctxt<'tcx>) -> String { - match *self { - vtable_static(def_id, ref tys, ref vtable_res) => { - format!("vtable_static({:?}:{}, {}, {})", - def_id, - ty::item_path_str(tcx, def_id), - tys.repr(tcx), - vtable_res.repr(tcx)) - } - - vtable_param(x, y) => { - format!("vtable_param({:?}, {})", x, y) - } - - vtable_closure(def_id) => { - format!("vtable_closure({:?})", def_id) - } - - vtable_error => { - format!("vtable_error") - } - } - } -} - pub fn make_substs_for_receiver_types<'tcx>(tcx: &ty::ctxt<'tcx>, trait_ref: &ty::TraitRef<'tcx>, method: &ty::Method<'tcx>) diff --git a/src/librustc/middle/ty_fold.rs b/src/librustc/middle/ty_fold.rs index 19a82e3f35492..6f098a53238b6 100644 --- a/src/librustc/middle/ty_fold.rs +++ b/src/librustc/middle/ty_fold.rs @@ -336,27 +336,6 @@ impl<'tcx> TypeFoldable<'tcx> for ty::MethodOrigin<'tcx> { } } -impl<'tcx> TypeFoldable<'tcx> for ty::vtable_origin<'tcx> { - fn fold_with>(&self, folder: &mut F) -> ty::vtable_origin<'tcx> { - match *self { - ty::vtable_static(def_id, ref substs, ref origins) => { - let r_substs = substs.fold_with(folder); - let r_origins = origins.fold_with(folder); - ty::vtable_static(def_id, r_substs, r_origins) - } - ty::vtable_param(n, b) => { - ty::vtable_param(n, b) - } - ty::vtable_closure(def_id) => { - ty::vtable_closure(def_id) - } - ty::vtable_error => { - ty::vtable_error - } - } - } -} - impl<'tcx> TypeFoldable<'tcx> for ty::BuiltinBounds { fn fold_with>(&self, _folder: &mut F) -> ty::BuiltinBounds { *self