rustc: fix fallout of adding the 'tcx lifetime to Ty.

Author: eddyb

src/librustc/back/link.rs

@@ -196,11 +196,11 @@ fn truncated_hash_result(symbol_hasher: &mut Sha256) -> String {
 
 
 // This calculates STH for a symbol, as defined above
-fn symbol_hash(tcx: &ty::ctxt,
-               symbol_hasher: &mut Sha256,
-               t: Ty,
-               link_meta: &LinkMeta)
-               -> String {
+fn symbol_hash<'tcx>(tcx: &ty::ctxt<'tcx>,
+                     symbol_hasher: &mut Sha256,
+                     t: Ty<'tcx>,
+                     link_meta: &LinkMeta)
+                     -> String {
     // NB: do *not* use abbrevs here as we want the symbol names
     // to be independent of one another in the crate.
 
@@ -219,7 +219,7 @@ fn symbol_hash(tcx: &ty::ctxt,
     hash
 }
 
-fn get_symbol_hash(ccx: &CrateContext, t: Ty) -> String {
+fn get_symbol_hash<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, t: Ty<'tcx>) -> String {
     match ccx.type_hashcodes().borrow().find(&t) {
         Some(h) => return h.to_string(),
         None => {}
@@ -320,8 +320,8 @@ pub fn exported_name(path: PathElems, hash: &str) -> String {
     mangle(path, Some(hash))
 }
 
-pub fn mangle_exported_name(ccx: &CrateContext, path: PathElems,
-                            t: Ty, id: ast::NodeId) -> String {
+pub fn mangle_exported_name<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, path: PathElems,
+                                      t: Ty<'tcx>, id: ast::NodeId) -> String {
     let mut hash = get_symbol_hash(ccx, t);
 
     // Paths can be completely identical for different nodes,
@@ -345,9 +345,9 @@ pub fn mangle_exported_name(ccx: &CrateContext, path: PathElems,
     exported_name(path, hash.as_slice())
 }
 
-pub fn mangle_internal_name_by_type_and_seq(ccx: &CrateContext,
-                                            t: Ty,
-                                            name: &str) -> String {
+pub fn mangle_internal_name_by_type_and_seq<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
+                                                      t: Ty<'tcx>,
+                                                      name: &str) -> String {
     let s = ppaux::ty_to_string(ccx.tcx(), t);
     let path = [PathName(token::intern(s.as_slice())),
                 gensym_name(name)];

src/librustc/driver/driver.rs

@@ -368,7 +368,7 @@ pub struct CrateAnalysis<'tcx> {
 /// structures carrying the results of the analysis.
 pub fn phase_3_run_analysis_passes<'tcx>(sess: Session,
                                          ast_map: ast_map::Map<'tcx>,
-                                         type_arena: &'tcx TypedArena<ty::t_box_>,
+                                         type_arena: &'tcx TypedArena<ty::TyS<'tcx>>,
                                          name: String) -> CrateAnalysis<'tcx> {
     let time_passes = sess.time_passes();
     let krate = ast_map.krate();

src/librustc/driver/pretty.rs

@@ -94,7 +94,7 @@ impl PpSourceMode {
     fn call_with_pp_support<'tcx, A, B>(&self,
                                         sess: Session,
                                         ast_map: Option<ast_map::Map<'tcx>>,
-                                        type_arena: &'tcx TypedArena<ty::t_box_>,
+                                        type_arena: &'tcx TypedArena<ty::TyS<'tcx>>,
                                         id: String,
                                         payload: B,
                                         f: |&PrinterSupport, B| -> A) -> A {

src/librustc/lint/builtin.rs

@@ -471,7 +471,8 @@ declare_lint!(BOX_POINTERS, Allow,
 pub struct BoxPointers;
 
 impl BoxPointers {
-    fn check_heap_type(&self, cx: &Context, span: Span, ty: Ty) {
+    fn check_heap_type<'a, 'tcx>(&self, cx: &Context<'a, 'tcx>,
+                                 span: Span, ty: Ty<'tcx>) {
         let mut n_uniq = 0i;
         ty::fold_ty(cx.tcx, ty, |t| {
             match ty::get(t).sty {

src/librustc/lint/context.rs

@@ -545,30 +545,30 @@ impl<'a, 'tcx> Context<'a, 'tcx> {
 impl<'a, 'tcx> AstConv<'tcx> for Context<'a, 'tcx>{
     fn tcx<'a>(&'a self) -> &'a ty::ctxt<'tcx> { self.tcx }
 
-    fn get_item_ty(&self, id: ast::DefId) -> ty::Polytype {
+    fn get_item_ty(&self, id: ast::DefId) -> ty::Polytype<'tcx> {
         ty::lookup_item_type(self.tcx, id)
     }
 
-    fn get_trait_def(&self, id: ast::DefId) -> Rc<ty::TraitDef> {
+    fn get_trait_def(&self, id: ast::DefId) -> Rc<ty::TraitDef<'tcx>> {
         ty::lookup_trait_def(self.tcx, id)
     }
 
-    fn ty_infer(&self, _span: Span) -> Ty {
+    fn ty_infer(&self, _span: Span) -> Ty<'tcx> {
         infer::new_infer_ctxt(self.tcx).next_ty_var()
     }
 
-    fn associated_types_of_trait_are_valid(&self, _: Ty, _: ast::DefId)
+    fn associated_types_of_trait_are_valid(&self, _: Ty<'tcx>, _: ast::DefId)
                                            -> bool {
         // FIXME(pcwalton): This is wrong.
         true
     }
 
     fn associated_type_binding(&self,
                                _: Span,
-                               _: Option<Ty>,
+                               _: Option<Ty<'tcx>>,
                                trait_id: ast::DefId,
                                associated_type_id: ast::DefId)
-                               -> Ty {
+                               -> Ty<'tcx> {
         // FIXME(pcwalton): This is wrong.
         let trait_def = self.get_trait_def(trait_id);
         let index = ty::associated_type_parameter_index(self.tcx,

src/librustc/metadata/csearch.rs

@@ -121,8 +121,8 @@ pub fn get_enum_variant_defs(cstore: &cstore::CStore, enum_id: ast::DefId)
     decoder::get_enum_variant_defs(&*cstore.intr, &*cdata, enum_id.node)
 }
 
-pub fn get_enum_variants(tcx: &ty::ctxt, def: ast::DefId)
-                      -> Vec<Rc<ty::VariantInfo>> {
+pub fn get_enum_variants<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId)
+                               -> Vec<Rc<ty::VariantInfo<'tcx>>> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_enum_variants(cstore.intr.clone(), &*cdata, def.node, tcx)
@@ -135,8 +135,8 @@ pub fn get_impl_items(cstore: &cstore::CStore, impl_def_id: ast::DefId)
     decoder::get_impl_items(&*cdata, impl_def_id.node)
 }
 
-pub fn get_impl_or_trait_item(tcx: &ty::ctxt, def: ast::DefId)
-                              -> ty::ImplOrTraitItem {
+pub fn get_impl_or_trait_item<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId)
+                                    -> ty::ImplOrTraitItem<'tcx> {
     let cdata = tcx.sess.cstore.get_crate_data(def.krate);
     decoder::get_impl_or_trait_item(tcx.sess.cstore.intr.clone(),
                                     &*cdata,
@@ -164,15 +164,17 @@ pub fn get_item_variances(cstore: &cstore::CStore,
     decoder::get_item_variances(&*cdata, def.node)
 }
 
-pub fn get_provided_trait_methods(tcx: &ty::ctxt,
-                                  def: ast::DefId)
-                               -> Vec<Rc<ty::Method>> {
+pub fn get_provided_trait_methods<'tcx>(tcx: &ty::ctxt<'tcx>,
+                                        def: ast::DefId)
+                                        -> Vec<Rc<ty::Method<'tcx>>> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_provided_trait_methods(cstore.intr.clone(), &*cdata, def.node, tcx)
 }
 
-pub fn get_supertraits(tcx: &ty::ctxt, def: ast::DefId) -> Vec<Rc<ty::TraitRef>> {
+pub fn get_supertraits<'tcx>(tcx: &ty::ctxt<'tcx>,
+                             def: ast::DefId)
+                             -> Vec<Rc<ty::TraitRef<'tcx>>> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_supertraits(&*cdata, def.node, tcx)
@@ -211,22 +213,22 @@ pub fn get_struct_field_attrs(cstore: &cstore::CStore, def: ast::DefId) -> HashM
     decoder::get_struct_field_attrs(&*cdata)
 }
 
-pub fn get_type(tcx: &ty::ctxt,
-                def: ast::DefId)
-             -> ty::Polytype {
+pub fn get_type<'tcx>(tcx: &ty::ctxt<'tcx>,
+                      def: ast::DefId)
+                      -> ty::Polytype<'tcx> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_type(&*cdata, def.node, tcx)
 }
 
-pub fn get_trait_def(tcx: &ty::ctxt, def: ast::DefId) -> ty::TraitDef {
+pub fn get_trait_def<'tcx>(tcx: &ty::ctxt<'tcx>, def: ast::DefId) -> ty::TraitDef<'tcx> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_trait_def(&*cdata, def.node, tcx)
 }
 
-pub fn get_field_type(tcx: &ty::ctxt, class_id: ast::DefId,
-                      def: ast::DefId) -> ty::Polytype {
+pub fn get_field_type<'tcx>(tcx: &ty::ctxt<'tcx>, class_id: ast::DefId,
+                            def: ast::DefId) -> ty::Polytype<'tcx> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(class_id.krate);
     let all_items = reader::get_doc(rbml::Doc::new(cdata.data()), tag_items);
@@ -253,17 +255,18 @@ pub fn get_field_type(tcx: &ty::ctxt, class_id: ast::DefId,
 
 // Given a def_id for an impl, return the trait it implements,
 // if there is one.
-pub fn get_impl_trait(tcx: &ty::ctxt,
-                      def: ast::DefId) -> Option<Rc<ty::TraitRef>> {
+pub fn get_impl_trait<'tcx>(tcx: &ty::ctxt<'tcx>,
+                            def: ast::DefId)
+                            -> Option<Rc<ty::TraitRef<'tcx>>> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     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: &ty::ctxt,
-                        def: ast::DefId)
-                        -> typeck::vtable_res {
+pub fn get_impl_vtables<'tcx>(tcx: &ty::ctxt<'tcx>,
+                              def: ast::DefId)
+                              -> typeck::vtable_res<'tcx> {
     let cstore = &tcx.sess.cstore;
     let cdata = cstore.get_crate_data(def.krate);
     decoder::get_impl_vtables(&*cdata, def.node, tcx)

src/librustc/metadata/decoder.rs

@@ -221,39 +221,44 @@ fn variant_disr_val(d: rbml::Doc) -> Option<ty::Disr> {
     })
 }
 
-fn doc_type(doc: rbml::Doc, tcx: &ty::ctxt, cdata: Cmd) -> Ty {
+fn doc_type<'tcx>(doc: rbml::Doc, tcx: &ty::ctxt<'tcx>, cdata: Cmd) -> Ty<'tcx> {
     let tp = reader::get_doc(doc, tag_items_data_item_type);
     parse_ty_data(tp.data, cdata.cnum, tp.start, tcx,
                   |_, did| translate_def_id(cdata, did))
 }
 
-fn doc_method_fty(doc: rbml::Doc, tcx: &ty::ctxt, cdata: Cmd) -> ty::BareFnTy {
+fn doc_method_fty<'tcx>(doc: rbml::Doc, tcx: &ty::ctxt<'tcx>,
+                        cdata: Cmd) -> ty::BareFnTy<'tcx> {
     let tp = reader::get_doc(doc, tag_item_method_fty);
     parse_bare_fn_ty_data(tp.data, cdata.cnum, tp.start, tcx,
                           |_, did| translate_def_id(cdata, did))
 }
 
-pub fn item_type(_item_id: ast::DefId, item: rbml::Doc,
-                 tcx: &ty::ctxt, cdata: Cmd) -> Ty {
+pub fn item_type<'tcx>(_item_id: ast::DefId, item: rbml::Doc,
+                       tcx: &ty::ctxt<'tcx>, cdata: Cmd) -> Ty<'tcx> {
     doc_type(item, tcx, cdata)
 }
 
-fn doc_trait_ref(doc: rbml::Doc, tcx: &ty::ctxt, cdata: Cmd) -> ty::TraitRef {
+fn doc_trait_ref<'tcx>(doc: rbml::Doc, tcx: &ty::ctxt<'tcx>, cdata: Cmd)
+                       -> ty::TraitRef<'tcx> {
     parse_trait_ref_data(doc.data, cdata.cnum, doc.start, tcx,
                          |_, did| translate_def_id(cdata, did))
 }
 
-fn item_trait_ref(doc: rbml::Doc, tcx: &ty::ctxt, cdata: Cmd) -> ty::TraitRef {
+fn item_trait_ref<'tcx>(doc: rbml::Doc, tcx: &ty::ctxt<'tcx>, cdata: Cmd)
+                        -> ty::TraitRef<'tcx> {
     let tp = reader::get_doc(doc, tag_item_trait_ref);
     doc_trait_ref(tp, tcx, cdata)
 }
 
-fn doc_bounds(doc: rbml::Doc, tcx: &ty::ctxt, cdata: Cmd) -> ty::ParamBounds {
+fn doc_bounds<'tcx>(doc: rbml::Doc, tcx: &ty::ctxt<'tcx>, cdata: Cmd)
+                    -> ty::ParamBounds<'tcx> {
     parse_bounds_data(doc.data, cdata.cnum, doc.start, tcx,
                       |_, did| translate_def_id(cdata, did))
 }
 
-fn trait_def_bounds(doc: rbml::Doc, tcx: &ty::ctxt, cdata: Cmd) -> ty::ParamBounds {
+fn trait_def_bounds<'tcx>(doc: rbml::Doc, tcx: &ty::ctxt<'tcx>, cdata: Cmd)
+                          -> ty::ParamBounds<'tcx> {
     let d = reader::get_doc(doc, tag_trait_def_bounds);
     doc_bounds(d, tcx, cdata)
 }
@@ -350,9 +355,9 @@ fn item_to_def_like(item: rbml::Doc, did: ast::DefId, cnum: ast::CrateNum)
     }
 }
 
-pub fn get_trait_def(cdata: Cmd,
-                     item_id: ast::NodeId,
-                     tcx: &ty::ctxt) -> ty::TraitDef
+pub fn get_trait_def<'tcx>(cdata: Cmd,
+                           item_id: ast::NodeId,
+                           tcx: &ty::ctxt<'tcx>) -> ty::TraitDef<'tcx>
 {
     let item_doc = lookup_item(item_id, cdata.data());
     let generics = doc_generics(item_doc, tcx, cdata, tag_item_generics);
@@ -365,8 +370,8 @@ pub fn get_trait_def(cdata: Cmd,
     }
 }
 
-pub fn get_type(cdata: Cmd, id: ast::NodeId, tcx: &ty::ctxt)
-    -> ty::Polytype {
+pub fn get_type<'tcx>(cdata: Cmd, id: ast::NodeId, tcx: &ty::ctxt<'tcx>)
+    -> ty::Polytype<'tcx> {
 
     let item = lookup_item(id, cdata.data());
 
@@ -400,20 +405,21 @@ pub fn get_repr_attrs(cdata: Cmd, id: ast::NodeId) -> Vec<attr::ReprAttr> {
     }
 }
 
-pub fn get_impl_trait(cdata: Cmd,
-                      id: ast::NodeId,
-                      tcx: &ty::ctxt) -> Option<Rc<ty::TraitRef>>
+pub fn get_impl_trait<'tcx>(cdata: Cmd,
+                            id: ast::NodeId,
+                            tcx: &ty::ctxt<'tcx>)
+                            -> Option<Rc<ty::TraitRef<'tcx>>>
 {
     let item_doc = lookup_item(id, cdata.data());
     reader::maybe_get_doc(item_doc, tag_item_trait_ref).map(|tp| {
         Rc::new(doc_trait_ref(tp, tcx, cdata))
     })
 }
 
-pub fn get_impl_vtables(cdata: Cmd,
-                        id: ast::NodeId,
-                        tcx: &ty::ctxt)
-                        -> typeck::vtable_res
+pub fn get_impl_vtables<'tcx>(cdata: Cmd,
+                              id: ast::NodeId,
+                              tcx: &ty::ctxt<'tcx>)
+                              -> typeck::vtable_res<'tcx>
 {
     let item_doc = lookup_item(id, cdata.data());
     let vtables_doc = reader::get_doc(item_doc, tag_item_impl_vtables);
@@ -679,8 +685,8 @@ pub fn get_enum_variant_defs(intr: &IdentInterner,
     }).collect()
 }
 
-pub fn get_enum_variants(intr: Rc<IdentInterner>, cdata: Cmd, id: ast::NodeId,
-                     tcx: &ty::ctxt) -> Vec<Rc<ty::VariantInfo>> {
+pub fn get_enum_variants<'tcx>(intr: Rc<IdentInterner>, cdata: Cmd, id: ast::NodeId,
+                               tcx: &ty::ctxt<'tcx>) -> Vec<Rc<ty::VariantInfo<'tcx>>> {
     let data = cdata.data();
     let items = reader::get_doc(rbml::Doc::new(data), tag_items);
     let item = find_item(id, items);
@@ -783,11 +789,11 @@ pub fn get_trait_item_name_and_kind(intr: Rc<IdentInterner>,
     }
 }
 
-pub fn get_impl_or_trait_item(intr: Rc<IdentInterner>,
-                              cdata: Cmd,
-                              id: ast::NodeId,
-                              tcx: &ty::ctxt)
-                              -> ty::ImplOrTraitItem {
+pub fn get_impl_or_trait_item<'tcx>(intr: Rc<IdentInterner>,
+                                    cdata: Cmd,
+                                    id: ast::NodeId,
+                                    tcx: &ty::ctxt<'tcx>)
+                                    -> ty::ImplOrTraitItem<'tcx> {
     let method_doc = lookup_item(id, cdata.data());
 
     let def_id = item_def_id(method_doc, cdata);
@@ -857,11 +863,11 @@ pub fn get_item_variances(cdata: Cmd, id: ast::NodeId) -> ty::ItemVariances {
     Decodable::decode(&mut decoder).unwrap()
 }
 
-pub fn get_provided_trait_methods(intr: Rc<IdentInterner>,
-                                  cdata: Cmd,
-                                  id: ast::NodeId,
-                                  tcx: &ty::ctxt)
-                                  -> Vec<Rc<ty::Method>> {
+pub fn get_provided_trait_methods<'tcx>(intr: Rc<IdentInterner>,
+                                        cdata: Cmd,
+                                        id: ast::NodeId,
+                                        tcx: &ty::ctxt<'tcx>)
+                                        -> Vec<Rc<ty::Method<'tcx>>> {
     let data = cdata.data();
     let item = lookup_item(id, data);
     let mut result = Vec::new();
@@ -889,8 +895,8 @@ pub fn get_provided_trait_methods(intr: Rc<IdentInterner>,
 }
 
 /// Returns the supertraits of the given trait.
-pub fn get_supertraits(cdata: Cmd, id: ast::NodeId, tcx: &ty::ctxt)
-                    -> Vec<Rc<ty::TraitRef>> {
+pub fn get_supertraits<'tcx>(cdata: Cmd, id: ast::NodeId, tcx: &ty::ctxt<'tcx>)
+                             -> Vec<Rc<ty::TraitRef<'tcx>>> {
     let mut results = Vec::new();
     let item_doc = lookup_item(id, cdata.data());
     reader::tagged_docs(item_doc, tag_item_super_trait_ref, |trait_doc| {
@@ -1385,11 +1391,11 @@ pub fn is_typedef(cdata: Cmd, id: ast::NodeId) -> bool {
     }
 }
 
-fn doc_generics(base_doc: rbml::Doc,
-                tcx: &ty::ctxt,
-                cdata: Cmd,
-                tag: uint)
-                -> ty::Generics
+fn doc_generics<'tcx>(base_doc: rbml::Doc,
+                      tcx: &ty::ctxt<'tcx>,
+                      cdata: Cmd,
+                      tag: uint)
+                      -> ty::Generics<'tcx>
 {
     let doc = reader::get_doc(base_doc, tag);