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

Diff for: 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] {

Diff for: 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]),
 }
 

Diff for: 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;

Diff for: 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,

Diff for: 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;

Diff for: 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);

Diff for: 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)

Diff for: 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)

Diff for: 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
 }
 

Diff for: 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();

Diff for: src/rustc/middle/ast_map.rs

@@ -204,16 +204,16 @@ fn map_item(i: @item, cx: ctx, v: vt) {
             cx.map.insert(nitem.id, node_native_item(nitem, abi, @cx.path));
         }
       }
-      item_class(_, _, items, ctor, _) {
+      item_class(tps, ifces, items, ctor, _) {
+          let (_, ms) = ast_util::split_class_items(items);
+          // Map iface refs to their parent classes. This is
+          // so we can find the self_ty
+          vec::iter(ifces) {|p| cx.map.insert(p.id,
+                                  node_item(i, item_path)); };
           let d_id = ast_util::local_def(i.id);
           let p = extend(cx, i.ident);
-          for items.each {|ci|
            // only need to handle methods
-           alt ci.node {
-             class_method(m) { map_method(d_id, p, m, cx); }
-             _ {}
-           }
-          }
+          vec::iter(ms) {|m| map_method(d_id, p, m, cx); }
       }
       _ { }
     }

Diff for: src/rustc/middle/resolve.rs

@@ -9,6 +9,7 @@ import metadata::{csearch, cstore};
 import driver::session::session;
 import util::common::*;
 import std::map::{int_hash, str_hash, hashmap};
+import vec::each;
 import syntax::codemap::span;
 import syntax::visit;
 import visit::vt;
@@ -402,6 +403,11 @@ fn maybe_insert(e: @env, id: node_id, def: option<def>) {
     }
 }
 
+fn resolve_iface_ref(p: @iface_ref, sc: scopes, e: @env) {
+    maybe_insert(e, p.id,
+       lookup_path_strict(*e, sc, p.path.span, p.path, ns_type));
+}
+
 fn resolve_names(e: @env, c: @ast::crate) {
     e.used_imports.track = true;
     let v =
@@ -431,9 +437,10 @@ fn resolve_names(e: @env, c: @ast::crate) {
         alt i.node {
            ast::item_class(_, ifaces, _, _, _) {
              /* visit the iface paths... */
-             for ifaces.each {|p|
-               maybe_insert(e, p.id,
-                 lookup_path_strict(*e, sc, p.path.span, p.path, ns_type))};
+              for ifaces.each {|p| resolve_iface_ref(p, sc, e)};
+           }
+           ast::item_impl(_, ifce, _, _) {
+               option::iter(ifce, {|p| resolve_iface_ref(p, sc, e)});
            }
            _ {}
         }
@@ -535,7 +542,7 @@ fn visit_item_with_scope(e: @env, i: @ast::item, sc: scopes, v: vt<scopes>) {
     alt i.node {
       ast::item_impl(tps, ifce, sty, methods) {
         visit::visit_ty_params(tps, sc, v);
-        alt ifce { some(ty) { v.visit_ty(ty, sc, v); } _ {} }
+        option::iter(ifce) {|p| visit::visit_path(p.path, sc, v)};
         v.visit_ty(sty, sc, v);
         for methods.each {|m|
             v.visit_ty_params(m.tps, sc, v);
@@ -1109,20 +1116,20 @@ fn lookup_in_scope(e: env, sc: scopes, sp: span, name: ident, ns: namespace,
                 }
                 ret some(df);
             }
-                      _ {}
-                  }
-             if left_fn {
-                left_fn_level2 = true;
-            } else if ns != ns_module {
+            _ {}
+        }
+        if left_fn {
+           left_fn_level2 = true;
+        } else if ns != ns_module {
                 left_fn = scope_is_fn(hd);
                 alt scope_closes(hd) {
                   some(node_id) { closing += [node_id]; }
                   _ { }
                 }
             }
             sc = *tl;
-          }
         }
+      }
     };
 }
 
@@ -2103,6 +2110,8 @@ fn check_exports(e: @env) {
 // Impl resolution
 
 type method_info = {did: def_id, n_tps: uint, ident: ast::ident};
+/* what are the did and ident here? */
+/* ident = the name of the impl */
 type _impl = {did: def_id, ident: ast::ident, methods: [@method_info]};
 type iscopes = list<@[@_impl]>;
 
@@ -2177,6 +2186,12 @@ fn find_impls_in_view_item(e: env, vi: @ast::view_item,
     }
 }
 
+/*
+  Given an item <i>, adds one record to the mutable vec
+  <impls> if the item is an impl; zero or more records if the
+  item is a class; and none otherwise. Each record describes
+  one interface implemented by i.
+ */
 fn find_impls_in_item(e: env, i: @ast::item, &impls: [@_impl],
                       name: option<ident>,
                       ck_exports: option<@indexed_mod>) {
@@ -2196,6 +2211,20 @@ fn find_impls_in_item(e: env, i: @ast::item, &impls: [@_impl],
                         })}];
         }
       }
+      ast::item_class(tps, ifces, items, _, _) {
+          let (_, mthds) = ast_util::split_class_items(items);
+          let n_tps = tps.len();
+          vec::iter(ifces) {|p|
+              // The def_id, in this case, identifies the combination of
+              // class and iface
+              impls += [@{did: local_def(p.id),
+                         ident: i.ident,
+                         methods: vec::map(mthds, {|m|
+                                      @{did: local_def(m.id),
+                                          n_tps: n_tps + m.tps.len(),
+                                          ident: m.ident}})}];
+          }
+      }
       _ {}
     }
 }

Diff for: src/rustc/middle/trans/alt.rs

@@ -164,7 +164,7 @@ fn enter_opt(tcx: ty::ctxt, m: match, opt: opt, col: uint,
         alt p.node {
           ast::pat_enum(_, subpats) {
             if opt_eq(tcx, variant_opt(tcx, p.id), opt) {
-              some(option::get_or_default(subpats,
+              some(option::get_default(subpats,
                      vec::from_elem(variant_size, dummy))) }
             else { none }
           }

Diff for: src/rustc/middle/trans/base.rs

@@ -1963,7 +1963,7 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, real_substs: [ty::t],
     let mono_ty = ty::subst_tps(ccx.tcx, substs, item_ty);
     let llfty = type_of_fn_from_ty(ccx, mono_ty);
 
-    let depth = option::get_or_default(ccx.monomorphizing.find(fn_id), 0u);
+    let depth = option::get_default(ccx.monomorphizing.find(fn_id), 0u);
     // Random cut-off -- code that needs to instantiate the same function
     // recursively more than ten times can probably safely be assumed to be
     // causing an infinite expansion.