Allow classes to be cast to ifaces that are in the same crate

I had to xfail one existing test case (class-implements-int) because,
I think, of the same bug described in #2272.

Author: catamorphism

src/libcore/vec.rs

@@ -448,7 +448,7 @@ fn map<T, U>(v: [T], f: fn(T) -> U) -> [U] {
 }
 
 #[doc = "
-Apply a function eo each element of a vector and return a concatenation
+Apply a function to each element of a vector and return a concatenation
 of each result vector
 "]
 fn flat_map<T, U>(v: [T], f: fn(T) -> [U]) -> [U] {

src/librustsyntax/ast.rs

@@ -636,6 +636,10 @@ enum attr_style { attr_outer, attr_inner, }
 #[auto_serialize]
 type attribute_ = {style: attr_style, value: meta_item};
 
+/*
+  iface_refs appear in both impls and in classes that implement ifaces.
+  resolve maps each iface_ref's id to its defining iface.
+ */
 #[auto_serialize]
 type iface_ref = {path: @path, id: node_id};
 
@@ -661,14 +665,14 @@ enum item_ {
              node_id /* dtor id */, node_id /* ctor id */,
              region_param),
     item_class([ty_param], /* ty params for class */
-               [iface_ref],   /* ifaces this class implements */
+               [@iface_ref],   /* ifaces this class implements */
                [@class_member], /* methods, etc. */
                                /* (not including ctor) */
                class_ctor,
                region_param
                ),
     item_iface([ty_param], [ty_method]),
-    item_impl([ty_param], option<@ty> /* iface */,
+    item_impl([ty_param], option<@iface_ref> /* iface */,
               @ty /* self */, [@method]),
 }
 

src/librustsyntax/ast_util.rs

@@ -2,20 +2,20 @@ import codemap::span;
 import ast::*;
 
 fn spanned<T: copy>(lo: uint, hi: uint, t: T) -> spanned<T> {
-    ret respan(mk_sp(lo, hi), t);
+    respan(mk_sp(lo, hi), t)
 }
 
 fn respan<T: copy>(sp: span, t: T) -> spanned<T> {
-    ret {node: t, span: sp};
+    {node: t, span: sp}
 }
 
 fn dummy_spanned<T: copy>(t: T) -> spanned<T> {
-    ret respan(dummy_sp(), t);
+    respan(dummy_sp(), t)
 }
 
 /* assuming that we're not in macro expansion */
 fn mk_sp(lo: uint, hi: uint) -> span {
-    ret {lo: lo, hi: hi, expn_info: none};
+    {lo: lo, hi: hi, expn_info: none}
 }
 
 // make this a const, once the compiler supports it
@@ -334,6 +334,16 @@ impl inlined_item_methods for inlined_item {
         }
     }
 }
+
+/* True if d is either a def_self, or a chain of def_upvars
+ referring to a def_self */
+fn is_self(d: ast::def) -> bool {
+  alt d {
+    def_self(_)        { true }
+    def_upvar(_, d, _) { is_self(*d) }
+    _                  { false }
+  }
+}
 // Local Variables:
 // mode: rust
 // fill-column: 78;

src/librustsyntax/fold.rs

@@ -279,9 +279,7 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
               let ctor_id   = fld.new_id(ctor.node.id);
               item_class(
                   typms,
-                  vec::map(ifaces, {|p|
-                      {path: fld.fold_path(p.path),
-                       id: fld.new_id(p.id)}}),
+                  vec::map(ifaces, {|p| fold_iface_ref(p, fld) }),
                   vec::map(items, fld.fold_class_item),
                   {node: {body: ctor_body,
                           dec: ctor_decl,
@@ -290,7 +288,8 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
                   rp)
           }
           item_impl(tps, ifce, ty, methods) {
-            item_impl(tps, option::map(ifce, fld.fold_ty), fld.fold_ty(ty),
+              item_impl(tps, option::map(ifce, {|p| fold_iface_ref(p, fld)}),
+                        fld.fold_ty(ty),
                       vec::map(methods, fld.fold_method))
           }
           item_iface(tps, methods) { item_iface(tps, methods) }
@@ -305,6 +304,10 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
         };
 }
 
+fn fold_iface_ref(&&p: @iface_ref, fld: ast_fold) -> @iface_ref {
+    @{path: fld.fold_path(p.path), id: fld.new_id(p.id)}
+}
+
 fn noop_fold_method(&&m: @method, fld: ast_fold) -> @method {
     ret @{ident: fld.fold_ident(m.ident),
           attrs: m.attrs,

src/librustsyntax/parse/parser.rs

@@ -5,6 +5,7 @@ import token::{can_begin_expr, is_ident, is_plain_ident};
 import codemap::{span,fss_none};
 import util::interner;
 import ast_util::{spanned, mk_sp, ident_to_path};
+import ast::{node_id};
 import lexer::reader;
 import prec::{op_spec, as_prec};
 import attr::{parse_outer_attrs_or_ext,
@@ -1788,9 +1789,6 @@ fn parse_item_iface(p: parser, attrs: [ast::attribute]) -> @ast::item {
 //    impl name<T> for [T] { ... }
 fn parse_item_impl(p: parser, attrs: [ast::attribute]) -> @ast::item {
     let lo = p.last_span.lo;
-    fn wrap_path(p: parser, pt: @ast::path) -> @ast::ty {
-        @{id: p.get_id(), node: ast::ty_path(pt, p.get_id()), span: pt.span}
-    }
     let mut (ident, tps) = if !is_word(p, "of") {
         if p.token == token::LT { (none, parse_ty_params(p)) }
         else { (some(parse_ident(p)), parse_ty_params(p)) }
@@ -1800,7 +1798,7 @@ fn parse_item_impl(p: parser, attrs: [ast::attribute]) -> @ast::item {
         if option::is_none(ident) {
             ident = some(vec::last(path.idents));
         }
-        some(wrap_path(p, path))
+        some(@{path: path, id: p.get_id()})
     } else { none };
     let ident = alt ident {
         some(name) { name }
@@ -1855,9 +1853,13 @@ fn ident_to_path_tys(p: parser, i: ast::ident,
      }
 }
 
-fn parse_iface_ref_list(p:parser) -> [ast::iface_ref] {
+fn parse_iface_ref(p:parser) -> @ast::iface_ref {
+    @{path: parse_path(p), id: p.get_id()}
+}
+
+fn parse_iface_ref_list(p:parser) -> [@ast::iface_ref] {
     parse_seq_to_before_end(token::LBRACE, seq_sep(token::COMMA),
-                   {|p| {path: parse_path(p), id: p.get_id()}}, p)
+                            parse_iface_ref, p)
 }
 
 fn parse_item_class(p: parser, attrs: [ast::attribute]) -> @ast::item {
@@ -1866,7 +1868,7 @@ fn parse_item_class(p: parser, attrs: [ast::attribute]) -> @ast::item {
     let rp = parse_region_param(p);
     let ty_params = parse_ty_params(p);
     let class_path = ident_to_path_tys(p, class_name, ty_params);
-    let ifaces : [ast::iface_ref] = if eat_word(p, "implements")
+    let ifaces : [@ast::iface_ref] = if eat_word(p, "implements")
                                        { parse_iface_ref_list(p) }
                                     else { [] };
     expect(p, token::LBRACE);
@@ -1918,7 +1920,7 @@ fn parse_single_class_item(p: parser, privcy: ast::privacy)
 enum class_contents { ctor_decl(ast::fn_decl, ast::blk, codemap::span),
                       members([@ast::class_member]) }
 
-fn parse_class_item(p:parser, class_name_with_tps:@ast::path)
+fn parse_class_item(p:parser, class_name_with_tps: @ast::path)
     -> class_contents {
     if eat_word(p, "new") {
         let lo = p.last_span.lo;

src/librustsyntax/print/pprust.rs

@@ -561,14 +561,11 @@ fn print_item(s: ps, &&item: @ast::item) {
         word(s.s, item.ident);
         print_type_params(s, tps);
         space(s.s);
-        alt ifce {
-          some(ty) {
+        option::iter(ifce, {|p|
             word_nbsp(s, "of");
-            print_type(s, ty);
+            print_path(s, p.path, false);
             space(s.s);
-          }
-          _ {}
-        }
+            });
         word_nbsp(s, "for");
         print_type(s, ty);
         space(s.s);

src/librustsyntax/visit.rs

@@ -134,7 +134,7 @@ fn visit_item<E>(i: @item, e: E, v: vt<E>) {
       }
       item_impl(tps, ifce, ty, methods) {
         v.visit_ty_params(tps, e, v);
-        alt ifce { some(ty) { v.visit_ty(ty, e, v); } none {} }
+        option::iter(ifce, {|p| visit_path(p.path, e, v)});
         v.visit_ty(ty, e, v);
         for methods.each {|m|
             visit_method_helper(m, e, v)

src/rustc/metadata/csearch.rs

@@ -160,8 +160,9 @@ fn get_field_type(tcx: ty::ctxt, class_id: ast::def_id,
     ret {bounds: @[], rp: ast::rp_none, ty: ty};
 }
 
-fn get_impl_iface(tcx: ty::ctxt, def: ast::def_id)
-    -> option<ty::t> {
+// Given a def_id for an impl or class, return the iface it implements,
+// or none if it's not for an impl or for a class that implements ifaces
+fn get_impl_iface(tcx: ty::ctxt, def: ast::def_id) -> option<ty::t> {
     let cstore = tcx.sess.cstore;
     let cdata = cstore::get_crate_data(cstore, def.crate);
     decoder::get_impl_iface(cdata, def.node, tcx)

src/rustc/metadata/decoder.rs

@@ -27,7 +27,6 @@ export get_class_method;
 export get_impl_method;
 export lookup_def;
 export lookup_item_name;
-export get_impl_iface;
 export resolve_path;
 export get_crate_attributes;
 export list_crate_metadata;
@@ -157,11 +156,9 @@ fn item_impl_iface(item: ebml::doc, tcx: ty::ctxt, cdata: cmd)
     -> option<ty::t> {
     let mut result = none;
     ebml::tagged_docs(item, tag_impl_iface) {|ity|
-        let t = parse_ty_data(ity.data, cdata.cnum, ity.start, tcx, {|did|
-            translate_def_id(cdata, did)
-        });
-        result = some(t);
-    }
+        result = some(parse_ty_data(ity.data, cdata.cnum, ity.start, tcx,
+                             {|did| translate_def_id(cdata, did)}));
+    };
     result
 }
 

src/rustc/metadata/encoder.rs

@@ -659,9 +659,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         }
         alt ifce {
           some(t) {
-            let i_ty = alt check t.node {
-              ty_path(_, id) { ty::node_id_to_type(tcx, id) }
-            };
+            let i_ty = ty::node_id_to_type(tcx, t.id);
             ebml_w.start_tag(tag_impl_iface);
             write_type(ecx, ebml_w, i_ty);
             ebml_w.end_tag();