Explicitly store self_ids use for self locals in methods

marijnh · marijnh · commit c71306b0dbde · 2012-03-08T21:17:32.000+01:00
This makes it possible to move them between crates without confusion, and to instantiate them at a point where the monomorphizing substitutions are known. Issue #1944
diff --git a/src/rustc/metadata/astencode.rs b/src/rustc/metadata/astencode.rs
@@ -191,10 +191,13 @@ fn visit_ids(item: ast::inlined_item, vfn: fn@(ast::node_id)) {
 
             alt fk {
               visit::fk_item_fn(_, tps) |
-              visit::fk_method(_, tps) |
               visit::fk_res(_, tps) {
                 vec::iter(tps) {|tp| vfn(tp.id)}
               }
+              visit::fk_method(_, tps, m) {
+                vfn(m.self_id);
+                vec::iter(tps) {|tp| vfn(tp.id)}
+              }
               visit::fk_anon(_) |
               visit::fk_fn_block {
               }
diff --git a/src/rustc/metadata/astencode_gen.rs b/src/rustc/metadata/astencode_gen.rs
@@ -3938,7 +3938,7 @@ fn serialize_163<S: std::serialization::serializer>(s: S,
     s.emit_rec(/*syntax::ast::ident*//*[syntax::ast::attribute]*/
                /*[syntax::ast::ty_param]*//*syntax::ast::fn_decl*/
                /*syntax::ast::blk*//*syntax::ast::node_id*/
-               /*syntax::codemap::span*/
+               /*syntax::codemap::span*//*syntax::ast::node_id*/
                {||
                    {
                        s.emit_rec_field("ident", 0u,
@@ -3954,7 +3954,9 @@ fn serialize_163<S: std::serialization::serializer>(s: S,
                        s.emit_rec_field("id", 5u,
                                         {|| serialize_27(s, v.id) });
                        s.emit_rec_field("span", 6u,
-                                        {|| serialize_19(s, v.span) })
+                                        {|| serialize_19(s, v.span) });
+                       s.emit_rec_field("self_id", 7u,
+                                        {|| serialize_27(s, v.self_id) })
                    }
                });
 }
@@ -7845,6 +7847,8 @@ fn deserialize_163<S: std::serialization::deserializer>(s: S) ->
 
                /*syntax::codemap::span*/
 
+               /*syntax::ast::node_id*/
+
                {||
                    {ident:
                         s.read_rec_field("ident", 0u, {|| deserialize_1(s) }),
@@ -7858,8 +7862,10 @@ fn deserialize_163<S: std::serialization::deserializer>(s: S) ->
                         s.read_rec_field("body", 4u, {|| deserialize_82(s) }),
                     id: s.read_rec_field("id", 5u, {|| deserialize_27(s) }),
                     span:
-                        s.read_rec_field("span", 6u,
-                                         {|| deserialize_19(s) }),}
+                        s.read_rec_field("span", 6u, {|| deserialize_19(s) }),
+                    self_id:
+                        s.read_rec_field("self_id", 7u,
+                                         {|| deserialize_27(s) }),}
                })
 
 }
@@ -8165,7 +8171,7 @@ fn serialize_164<S: std::serialization::serializer>(s: S,
 
     s.emit_enum("syntax::ast::def",
                 /*syntax::ast::def_id*//*syntax::ast::purity*/
-                /*syntax::ast::node_id*/
+                /*syntax::ast::def_id*/
                 /*syntax::ast::def_id*/
                 /*syntax::ast::def_id*/
                 /*syntax::ast::def_id*/
@@ -8528,7 +8534,7 @@ fn deserialize_164<S: std::serialization::deserializer>(s: S) ->
     s.read_enum("syntax::ast::def",
                 /*syntax::ast::def_id*//*syntax::ast::purity*/
 
-                /*syntax::ast::node_id*/
+                /*syntax::ast::def_id*/
 
                 /*syntax::ast::def_id*/
 
diff --git a/src/rustc/metadata/encoder.rs b/src/rustc/metadata/encoder.rs
@@ -442,9 +442,11 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
             ebml_w.end_tag();
         }
         alt ifce {
-          some(_) {
+          some(t) {
             encode_symbol(ecx, ebml_w, item.id);
-            let i_ty = ty::lookup_item_type(tcx, local_def(item.id)).ty;
+            let i_ty = alt check t.node {
+              ty_path(_, id) { ty::node_id_to_type(tcx, id) }
+            };
             ebml_w.start_tag(tag_impl_iface);
             write_type(ecx, ebml_w, i_ty);
             ebml_w.end_tag();
diff --git a/src/rustc/middle/ast_map.rs b/src/rustc/middle/ast_map.rs
@@ -132,6 +132,8 @@ fn map_arm(arm: arm, cx: ctx, v: vt) {
 fn map_method(impl_did: def_id, impl_path: @path,
               m: @method, cx: ctx) {
     cx.map.insert(m.id, node_method(m, impl_did, impl_path));
+    cx.map.insert(m.self_id, node_local(cx.local_id));
+    cx.local_id += 1u;
 }
 
 fn map_item(i: @item, cx: ctx, v: vt) {
diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs
@@ -530,8 +530,8 @@ fn visit_item_with_scope(e: @env, i: @ast::item, sc: scopes, v: vt<scopes>) {
         v.visit_ty(sty, sc, v);
         for m in methods {
             v.visit_ty_params(m.tps, sc, v);
-            let msc = cons(scope_method(i.id, tps + m.tps), @sc);
-            v.visit_fn(visit::fk_method(m.ident, []),
+            let msc = cons(scope_method(m.self_id, tps + m.tps), @sc);
+            v.visit_fn(visit::fk_method(m.ident, [], m),
                        m.decl, m.body, m.span, m.id, msc, v);
         }
       }
@@ -590,7 +590,7 @@ fn visit_fn_with_scope(e: @env, fk: visit::fn_kind, decl: ast::fn_decl,
     for c: @ast::constr in decl.constraints { resolve_constr(e, c, sc, v); }
     let scope = alt fk {
       visit::fk_item_fn(_, tps) | visit::fk_res(_, tps) |
-      visit::fk_method(_, tps) { scope_bare_fn(decl, id, tps) }
+      visit::fk_method(_, tps, _) { scope_bare_fn(decl, id, tps) }
       visit::fk_anon(ast::proto_bare) { scope_bare_fn(decl, id, []) }
       visit::fk_anon(_) | visit::fk_fn_block { scope_fn_expr(decl, id, []) }
     };
diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs
@@ -2136,7 +2136,7 @@ fn monomorphic_fn(ccx: crate_ctxt, fn_id: ast::def_id, substs: [ty::t],
                            (*tvs).len() == 1u, [], psubsts, lldecl);
       }
       ast_map::node_method(mth, impl_def_id, _) {
-        let selfty = ty::lookup_item_type(ccx.tcx, impl_def_id).ty;
+        let selfty = ty::node_id_to_type(ccx.tcx, mth.self_id);
         let selfty = ty::substitute_type_params(ccx.tcx, substs, selfty);
         trans_fn(ccx, pt, mth.decl, mth.body, lldecl,
                  impl_self(selfty), [], psubsts, fn_id.node, none);
@@ -2315,7 +2315,7 @@ fn trans_local_var(cx: block, def: ast::def) -> local_var_result {
         assert (cx.fcx.lllocals.contains_key(nid));
         ret take_local(cx.fcx.lllocals, nid);
       }
-      ast::def_self(nid) {
+      ast::def_self(_) {
         let slf = option::get(cx.fcx.llself);
         let ptr = PointerCast(cx, slf.v,
                               T_ptr(type_of_or_i8(cx.ccx(), slf.t)));
@@ -4343,7 +4343,7 @@ fn trans_item(ccx: crate_ctxt, item: ast::item) {
         }
       }
       ast::item_impl(tps, _, _, ms) {
-        impl::trans_impl(ccx, *path, item.ident, ms, item.id, tps);
+        impl::trans_impl(ccx, *path, item.ident, ms, tps);
       }
       ast::item_res(decl, tps, body, dtor_id, ctor_id) {
         let llctor_decl = get_item_val(ccx, ctor_id);
diff --git a/src/rustc/middle/trans/impl.rs b/src/rustc/middle/trans/impl.rs
@@ -44,14 +44,13 @@ import std::map::hashmap;
 // are referenced (ccx.method_map and ccx.dict_map).
 
 fn trans_impl(ccx: crate_ctxt, path: path, name: ast::ident,
-              methods: [@ast::method], id: ast::node_id,
-              tps: [ast::ty_param]) {
+              methods: [@ast::method], tps: [ast::ty_param]) {
     let sub_path = path + [path_name(name)];
     for m in methods {
         let llfn = get_item_val(ccx, m.id);
         let m_bounds = param_bounds(ccx, tps + m.tps);
         trans_fn(ccx, sub_path + [path_name(m.ident)], m.decl, m.body,
-                 llfn, impl_self(ty::node_id_to_type(ccx.tcx, id)),
+                 llfn, impl_self(ty::node_id_to_type(ccx.tcx, m.self_id)),
                  m_bounds, none, m.id, none);
     }
 }
diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs
@@ -2157,8 +2157,13 @@ fn iface_methods(cx: ctxt, id: ast::def_id) -> @[method] {
 
 fn impl_iface(cx: ctxt, id: ast::def_id) -> option<t> {
     if id.crate == ast::local_crate {
-        let t = cx.tcache.get(id).ty;
-        if get(t).struct == ty_nil { none } else { some(t) }
+        alt cx.items.get(id.node) {
+          ast_map::node_item(@{node: ast::item_impl(
+              _, some(@{node: ast::ty_path(_, id), _}), _, _), _}, _) {
+            some(node_id_to_type(cx, id))
+          }
+          _ { none }
+        }
     } else {
         csearch::get_impl_iface(cx, id)
     }
diff --git a/src/rustc/middle/typeck.rs b/src/rustc/middle/typeck.rs
@@ -106,7 +106,7 @@ fn ty_param_bounds_and_ty_for_def(fcx: @fn_ctxt, sp: span, defn: ast::def) ->
         let typ = ty::mk_var(fcx.ccx.tcx, lookup_local(fcx, sp, nid));
         ret {bounds: @[], ty: typ};
       }
-      ast::def_self(id) {
+      ast::def_self(_) {
         alt get_self_info(fcx.ccx) {
           some(self_impl(impl_t)) {
             ret {bounds: @[], ty: impl_t};
@@ -362,8 +362,8 @@ fn ast_ty_to_ty(tcx: ty::ctxt, mode: mode, &&ast_ty: @ast::ty) -> ty::t {
             }
             ty::mk_param(tcx, n, id)
           }
-          ast::def_self(iface_id) {
-            alt check tcx.items.get(iface_id) {
+          ast::def_self(self_id) {
+            alt check tcx.items.get(self_id) {
               ast_map::node_item(@{node: ast::item_iface(tps, _), _}, _) {
                 if vec::len(tps) != vec::len(path.node.types) {
                     tcx.sess.span_err(ast_ty.span, "incorrect number of type \
@@ -850,7 +850,12 @@ mod collect {
           ast::item_impl(tps, ifce, selfty, ms) {
             let i_bounds = ty_param_bounds(tcx, m_collect, tps);
             let my_methods = [];
+            let selfty = ast_ty_to_ty(tcx, m_collect, selfty);
+            write_ty(tcx, it.id, selfty);
+            tcx.tcache.insert(local_def(it.id), {bounds: i_bounds,
+                                                 ty: selfty});
             for m in ms {
+                write_ty(tcx, m.self_id, selfty);
                 let bounds = ty_param_bounds(tcx, m_collect, m.tps);
                 let mty = ty_of_method(tcx, m_collect, m);
                 my_methods += [{mty: mty, id: m.id, span: m.span}];
@@ -860,15 +865,15 @@ mod collect {
                                       ty: fty});
                 write_ty(tcx, m.id, fty);
             }
-            let selfty = ast_ty_to_ty(tcx, m_collect, selfty);
-            write_ty(tcx, it.id, selfty);
             alt ifce {
               some(t) {
                 let iface_ty = ast_ty_to_ty(tcx, m_collect, t);
-                tcx.tcache.insert(local_def(it.id),
-                                     {bounds: i_bounds, ty: iface_ty});
                 alt ty::get(iface_ty).struct {
                   ty::ty_iface(did, tys) {
+                    // Store the iface type in the type node
+                    alt check t.node {
+                      ast::ty_path(_, t_id) { write_ty(tcx, t_id, iface_ty); }
+                    }
                     if did.crate == ast::local_crate {
                         ensure_iface_methods(tcx, did.node);
                     }
@@ -906,11 +911,7 @@ mod collect {
                   }
                 }
               }
-              _ {
-                // Store the bounds with a nil type.
-                tcx.tcache.insert(local_def(it.id), {bounds: i_bounds,
-                                                     ty: ty::mk_nil(tcx)});
-              }
+              _ {}
             }
           }
           ast::item_res(decl, tps, _, dtor_id, ctor_id) {
@@ -1665,8 +1666,8 @@ fn impl_self_ty(tcx: ty::ctxt, did: ast::def_id) -> {n_tps: uint, ty: ty::t} {
           }
         }
     } else {
-        let tpt = csearch::get_type(tcx, did);
-        {n_tps: vec::len(*tpt.bounds), ty: tpt.ty}
+        let ity = ty::lookup_item_type(tcx, did);
+        {n_tps: vec::len(*ity.bounds), ty: ity.ty}
     }
 }
 
diff --git a/src/rustc/syntax/ast.rs b/src/rustc/syntax/ast.rs
@@ -424,7 +424,7 @@ enum ret_style {
 
 type method = {ident: ident, attrs: [attribute],
                tps: [ty_param], decl: fn_decl, body: blk,
-               id: node_id, span: span};
+               id: node_id, span: span, self_id: node_id};
 
 type _mod = {view_items: [@view_item], items: [@item]};
 
diff --git a/src/rustc/syntax/ast_util.rs b/src/rustc/syntax/ast_util.rs
@@ -41,7 +41,7 @@ fn def_id_of_def(d: def) -> def_id {
       def_use(id) |
       def_class(id) | def_class_field(_, id) | def_class_method(_, id) { id }
 
-      def_self(id) | def_arg(id, _) | def_local(id, _) |
+      def_arg(id, _) | def_local(id, _) | def_self(id) |
       def_upvar(id, _, _) | def_binding(id) {
         local_def(id)
       }
diff --git a/src/rustc/syntax/fold.rs b/src/rustc/syntax/fold.rs
@@ -301,7 +301,8 @@ fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method {
           decl: fold_fn_decl(m.decl, fld),
           body: fld.fold_block(m.body),
           id: fld.new_id(m.id),
-          span: fld.new_span(m.span)};
+          span: fld.new_span(m.span),
+          self_id: fld.new_id(m.self_id)};
 }
 
 
diff --git a/src/rustc/syntax/parse/parser.rs b/src/rustc/syntax/parse/parser.rs
@@ -1931,7 +1931,8 @@ fn parse_method(p: parser) -> @ast::method {
     let (inner_attrs, body) = parse_inner_attrs_and_block(p, true);
     let attrs = attrs + inner_attrs;
     @{ident: ident, attrs: attrs, tps: tps, decl: decl, body: body,
-      id: p.get_id(), span: ast_util::mk_sp(lo, body.span.hi)}
+      id: p.get_id(), span: ast_util::mk_sp(lo, body.span.hi),
+      self_id: p.get_id()}
 }
 
 fn parse_item_iface(p: parser, attrs: [ast::attribute]) -> @ast::item {
diff --git a/src/rustc/syntax/visit.rs b/src/rustc/syntax/visit.rs
@@ -14,22 +14,22 @@ enum vt<E> { mk_vt(visitor<E>), }
 
 enum fn_kind {
     fk_item_fn(ident, [ty_param]), //< an item declared with fn()
-    fk_method(ident, [ty_param]),
+    fk_method(ident, [ty_param], @method),
     fk_res(ident, [ty_param]),
     fk_anon(proto),  //< an anonymous function like fn@(...)
     fk_fn_block,     //< a block {||...}
 }
 
 fn name_of_fn(fk: fn_kind) -> ident {
     alt fk {
-      fk_item_fn(name, _) | fk_method(name, _) | fk_res(name, _) { name }
+      fk_item_fn(name, _) | fk_method(name, _, _) | fk_res(name, _) { name }
       fk_anon(_) | fk_fn_block { "anon" }
     }
 }
 
 fn tps_of_fn(fk: fn_kind) -> [ty_param] {
     alt fk {
-      fk_item_fn(_, tps) | fk_method(_, tps) | fk_res(_, tps) { tps }
+      fk_item_fn(_, tps) | fk_method(_, tps, _) | fk_res(_, tps) { tps }
       fk_anon(_) | fk_fn_block { [] }
     }
 }
@@ -256,7 +256,7 @@ fn visit_fn_decl<E>(fd: fn_decl, e: E, v: vt<E>) {
 // because it is not a default impl of any method, though I doubt that really
 // clarifies anything. - Niko
 fn visit_method_helper<E>(m: @method, e: E, v: vt<E>) {
-    v.visit_fn(fk_method(m.ident, m.tps), m.decl, m.body, m.span,
+    v.visit_fn(fk_method(m.ident, m.tps, m), m.decl, m.body, m.span,
                m.id, e, v);
 }
 

Original file line number	Diff line number	Diff line change
`@@ -191,10 +191,13 @@ fn visit_ids(item: ast::inlined_item, vfn: fn@(ast::node_id)) {`
`191`	`191`
`192`	`192`	`alt fk {`
`193`	`193`	`visit::fk_item_fn(_, tps) \|`
`194`		`- visit::fk_method(_, tps) \|`
`195`	`194`	`visit::fk_res(_, tps) {`
`196`	`195`	`vec::iter(tps) {\|tp\| vfn(tp.id)}`
`197`	`196`	`}`
	`197`	`+ visit::fk_method(_, tps, m) {`
	`198`	`+ vfn(m.self_id);`
	`199`	`+ vec::iter(tps) {\|tp\| vfn(tp.id)}`
	`200`	`+ }`
`198`	`201`	`visit::fk_anon(_) \|`
`199`	`202`	`visit::fk_fn_block {`
`200`	`203`	`}`
Original file line number	Diff line number	Diff line change
`@@ -132,6 +132,8 @@ fn map_arm(arm: arm, cx: ctx, v: vt) {`
`132`	`132`	`fn map_method(impl_did: def_id, impl_path: @path,`
`133`	`133`	`m: @method, cx: ctx) {`
`134`	`134`	`cx.map.insert(m.id, node_method(m, impl_did, impl_path));`
	`135`	`+ cx.map.insert(m.self_id, node_local(cx.local_id));`
	`136`	`+ cx.local_id += 1u;`
`135`	`137`	`}`
`136`	`138`
`137`	`139`	`fn map_item(i: @item, cx: ctx, v: vt) {`
Original file line number	Diff line number	Diff line change
`@@ -2136,7 +2136,7 @@ fn monomorphic_fn(ccx: crate_ctxt, fn_id: ast::def_id, substs: [ty::t],`
`2136`	`2136`	`(*tvs).len() == 1u, [], psubsts, lldecl);`
`2137`	`2137`	`}`
`2138`	`2138`	`ast_map::node_method(mth, impl_def_id, _) {`
`2139`		`- let selfty = ty::lookup_item_type(ccx.tcx, impl_def_id).ty;`
	`2139`	`+ let selfty = ty::node_id_to_type(ccx.tcx, mth.self_id);`
`2140`	`2140`	`let selfty = ty::substitute_type_params(ccx.tcx, substs, selfty);`
`2141`	`2141`	`trans_fn(ccx, pt, mth.decl, mth.body, lldecl,`
`2142`	`2142`	`impl_self(selfty), [], psubsts, fn_id.node, none);`
`@@ -2315,7 +2315,7 @@ fn trans_local_var(cx: block, def: ast::def) -> local_var_result {`
`2315`	`2315`	`assert (cx.fcx.lllocals.contains_key(nid));`
`2316`	`2316`	`ret take_local(cx.fcx.lllocals, nid);`
`2317`	`2317`	`}`
`2318`		`- ast::def_self(nid) {`
	`2318`	`+ ast::def_self(_) {`
`2319`	`2319`	`let slf = option::get(cx.fcx.llself);`
`2320`	`2320`	`let ptr = PointerCast(cx, slf.v,`
`2321`	`2321`	`T_ptr(type_of_or_i8(cx.ccx(), slf.t)));`
`@@ -4343,7 +4343,7 @@ fn trans_item(ccx: crate_ctxt, item: ast::item) {`
`4343`	`4343`	`}`
`4344`	`4344`	`}`
`4345`	`4345`	`ast::item_impl(tps, _, _, ms) {`
`4346`		`- impl::trans_impl(ccx, *path, item.ident, ms, item.id, tps);`
	`4346`	`+ impl::trans_impl(ccx, *path, item.ident, ms, tps);`
`4347`	`4347`	`}`
`4348`	`4348`	`ast::item_res(decl, tps, body, dtor_id, ctor_id) {`
`4349`	`4349`	`let llctor_decl = get_item_val(ccx, ctor_id);`
Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ fn ty_param_bounds_and_ty_for_def(fcx: @fn_ctxt, sp: span, defn: ast::def) ->`
`106`	`106`	`let typ = ty::mk_var(fcx.ccx.tcx, lookup_local(fcx, sp, nid));`
`107`	`107`	`ret {bounds: @[], ty: typ};`
`108`	`108`	`}`
`109`		`- ast::def_self(id) {`
	`109`	`+ ast::def_self(_) {`
`110`	`110`	`alt get_self_info(fcx.ccx) {`
`111`	`111`	`some(self_impl(impl_t)) {`
`112`	`112`	`ret {bounds: @[], ty: impl_t};`
`@@ -362,8 +362,8 @@ fn ast_ty_to_ty(tcx: ty::ctxt, mode: mode, &&ast_ty: @ast::ty) -> ty::t {`
`362`	`362`	`}`
`363`	`363`	`ty::mk_param(tcx, n, id)`
`364`	`364`	`}`
`365`		`- ast::def_self(iface_id) {`
`366`		`- alt check tcx.items.get(iface_id) {`
	`365`	`+ ast::def_self(self_id) {`
	`366`	`+ alt check tcx.items.get(self_id) {`
`367`	`367`	`ast_map::node_item(@{node: ast::item_iface(tps, _), _}, _) {`
`368`	`368`	`if vec::len(tps) != vec::len(path.node.types) {`
`369`	`369`	`tcx.sess.span_err(ast_ty.span, "incorrect number of type \`
`@@ -850,7 +850,12 @@ mod collect {`
`850`	`850`	`ast::item_impl(tps, ifce, selfty, ms) {`
`851`	`851`	`let i_bounds = ty_param_bounds(tcx, m_collect, tps);`
`852`	`852`	`let my_methods = [];`
	`853`	`+ let selfty = ast_ty_to_ty(tcx, m_collect, selfty);`
	`854`	`+ write_ty(tcx, it.id, selfty);`
	`855`	`+ tcx.tcache.insert(local_def(it.id), {bounds: i_bounds,`
	`856`	`+ ty: selfty});`
`853`	`857`	`for m in ms {`
	`858`	`+ write_ty(tcx, m.self_id, selfty);`
`854`	`859`	`let bounds = ty_param_bounds(tcx, m_collect, m.tps);`
`855`	`860`	`let mty = ty_of_method(tcx, m_collect, m);`
`856`	`861`	`my_methods += [{mty: mty, id: m.id, span: m.span}];`
`@@ -860,15 +865,15 @@ mod collect {`
`860`	`865`	`ty: fty});`
`861`	`866`	`write_ty(tcx, m.id, fty);`
`862`	`867`	`}`
`863`		`- let selfty = ast_ty_to_ty(tcx, m_collect, selfty);`
`864`		`- write_ty(tcx, it.id, selfty);`
`865`	`868`	`alt ifce {`
`866`	`869`	`some(t) {`
`867`	`870`	`let iface_ty = ast_ty_to_ty(tcx, m_collect, t);`
`868`		`- tcx.tcache.insert(local_def(it.id),`
`869`		`- {bounds: i_bounds, ty: iface_ty});`
`870`	`871`	`alt ty::get(iface_ty).struct {`
`871`	`872`	`ty::ty_iface(did, tys) {`
	`873`	`+ // Store the iface type in the type node`
	`874`	`+ alt check t.node {`
	`875`	`+ ast::ty_path(_, t_id) { write_ty(tcx, t_id, iface_ty); }`
	`876`	`+ }`
`872`	`877`	`if did.crate == ast::local_crate {`
`873`	`878`	`ensure_iface_methods(tcx, did.node);`
`874`	`879`	`}`
`@@ -906,11 +911,7 @@ mod collect {`
`906`	`911`	`}`
`907`	`912`	`}`
`908`	`913`	`}`
`909`		`- _ {`
`910`		`- // Store the bounds with a nil type.`
`911`		`- tcx.tcache.insert(local_def(it.id), {bounds: i_bounds,`
`912`		`- ty: ty::mk_nil(tcx)});`
`913`		`- }`
	`914`	`+ _ {}`
`914`	`915`	`}`
`915`	`916`	`}`
`916`	`917`	`ast::item_res(decl, tps, _, dtor_id, ctor_id) {`
`@@ -1665,8 +1666,8 @@ fn impl_self_ty(tcx: ty::ctxt, did: ast::def_id) -> {n_tps: uint, ty: ty::t} {`
`1665`	`1666`	`}`
`1666`	`1667`	`}`
`1667`	`1668`	`} else {`
`1668`		`- let tpt = csearch::get_type(tcx, did);`
`1669`		`- {n_tps: vec::len(*tpt.bounds), ty: tpt.ty}`
	`1669`	`+ let ity = ty::lookup_item_type(tcx, did);`
	`1670`	`+ {n_tps: vec::len(*ity.bounds), ty: ity.ty}`
`1670`	`1671`	`}`
`1671`	`1672`	`}`
`1672`	`1673`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ fn def_id_of_def(d: def) -> def_id {`
`41`	`41`	`def_use(id) \|`
`42`	`42`	`def_class(id) \| def_class_field(_, id) \| def_class_method(_, id) { id }`
`43`	`43`
`44`		`- def_self(id) \| def_arg(id, _) \| def_local(id, _) \|`
	`44`	`+ def_arg(id, _) \| def_local(id, _) \| def_self(id) \|`
`45`	`45`	`def_upvar(id, _, _) \| def_binding(id) {`
`46`	`46`	`local_def(id)`
`47`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -301,7 +301,8 @@ fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method {`
`301`	`301`	`decl: fold_fn_decl(m.decl, fld),`
`302`	`302`	`body: fld.fold_block(m.body),`
`303`	`303`	`id: fld.new_id(m.id),`
`304`		`- span: fld.new_span(m.span)};`
	`304`	`+ span: fld.new_span(m.span),`
	`305`	`+ self_id: fld.new_id(m.self_id)};`
`305`	`306`	`}`
`306`	`307`
`307`	`308`
Original file line number	Diff line number	Diff line change
`@@ -1931,7 +1931,8 @@ fn parse_method(p: parser) -> @ast::method {`
`1931`	`1931`	`let (inner_attrs, body) = parse_inner_attrs_and_block(p, true);`
`1932`	`1932`	`let attrs = attrs + inner_attrs;`
`1933`	`1933`	`@{ident: ident, attrs: attrs, tps: tps, decl: decl, body: body,`
`1934`		`- id: p.get_id(), span: ast_util::mk_sp(lo, body.span.hi)}`
	`1934`	`+ id: p.get_id(), span: ast_util::mk_sp(lo, body.span.hi),`
	`1935`	`+ self_id: p.get_id()}`
`1935`	`1936`	`}`
`1936`	`1937`
`1937`	`1938`	`fn parse_item_iface(p: parser, attrs: [ast::attribute]) -> @ast::item {`
Original file line number	Diff line number	Diff line change
`@@ -14,22 +14,22 @@ enum vt<E> { mk_vt(visitor<E>), }`
`14`	`14`
`15`	`15`	`enum fn_kind {`
`16`	`16`	`fk_item_fn(ident, [ty_param]), //< an item declared with fn()`
`17`		`- fk_method(ident, [ty_param]),`
	`17`	`+ fk_method(ident, [ty_param], @method),`
`18`	`18`	`fk_res(ident, [ty_param]),`
`19`	`19`	`fk_anon(proto), //< an anonymous function like fn@(...)`
`20`	`20`	`fk_fn_block, //< a block {\|\|...}`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`fn name_of_fn(fk: fn_kind) -> ident {`
`24`	`24`	`alt fk {`
`25`		`- fk_item_fn(name, _) \| fk_method(name, _) \| fk_res(name, _) { name }`
	`25`	`+ fk_item_fn(name, _) \| fk_method(name, _, _) \| fk_res(name, _) { name }`
`26`	`26`	`fk_anon(_) \| fk_fn_block { "anon" }`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`fn tps_of_fn(fk: fn_kind) -> [ty_param] {`
`31`	`31`	`alt fk {`
`32`		`- fk_item_fn(_, tps) \| fk_method(_, tps) \| fk_res(_, tps) { tps }`
	`32`	`+ fk_item_fn(_, tps) \| fk_method(_, tps, _) \| fk_res(_, tps) { tps }`
`33`	`33`	`fk_anon(_) \| fk_fn_block { [] }`
`34`	`34`	`}`
`35`	`35`	`}`
`@@ -256,7 +256,7 @@ fn visit_fn_decl<E>(fd: fn_decl, e: E, v: vt<E>) {`
`256`	`256`	`// because it is not a default impl of any method, though I doubt that really`
`257`	`257`	`// clarifies anything. - Niko`
`258`	`258`	`fn visit_method_helper<E>(m: @method, e: E, v: vt<E>) {`
`259`		`- v.visit_fn(fk_method(m.ident, m.tps), m.decl, m.body, m.span,`
	`259`	`+ v.visit_fn(fk_method(m.ident, m.tps, m), m.decl, m.body, m.span,`
`260`	`260`	`m.id, e, v);`
`261`	`261`	`}`
`262`	`262`