Generic classes and generic class methods work cross-crate

Classes can have ty params now. So can methods inside classes.
That was probably true before, but now it should still work if you
call methods in a class that's defined in a different crate. Yay!

Author: catamorphism

src/librustsyntax/ast.rs

@@ -643,7 +643,7 @@ enum item_ {
     item_native_mod(native_mod),
     item_ty(@ty, [ty_param]),
     item_enum([variant], [ty_param]),
-    item_res(fn_decl /* dtor */, [ty_param], blk,
+    item_res(fn_decl /* dtor */, [ty_param], blk /* dtor body */,
              node_id /* dtor id */, node_id /* ctor id */),
     item_class([ty_param], /* ty params for class */
                [@class_member], /* methods, etc. */
@@ -703,6 +703,7 @@ enum inlined_item {
     ii_item(@item),
     ii_method(def_id /* impl id */, @method),
     ii_native(@native_item),
+    ii_ctor(class_ctor, ident, [ty_param], def_id /* parent id */)
 }
 
 //

src/librustsyntax/ast_util.rs

@@ -302,6 +302,7 @@ impl inlined_item_methods for inlined_item {
           ii_item(i) { i.ident }
           ii_native(i) { i.ident }
           ii_method(_, m) { m.ident }
+          ii_ctor(_, nm, _, _) { nm }
         }
     }
 
@@ -310,6 +311,7 @@ impl inlined_item_methods for inlined_item {
           ii_item(i) { i.id }
           ii_native(i) { i.id }
           ii_method(_, m) { m.id }
+          ii_ctor(ctor, _, _, _) { ctor.node.id }
         }
     }
 
@@ -318,6 +320,9 @@ impl inlined_item_methods for inlined_item {
           ii_item(i) { v.visit_item(i, e, v) }
           ii_native(i) { v.visit_native_item(i, e, v) }
           ii_method(_, m) { visit::visit_method_helper(m, e, v) }
+          ii_ctor(ctor, nm, tps, parent_id) {
+              visit::visit_class_ctor_helper(ctor, nm, tps, parent_id, e, v);
+          }
         }
     }
 }

src/librustsyntax/fold.rs

@@ -14,6 +14,8 @@ export noop_fold_ty;
 export noop_fold_block;
 export wrap;
 export fold_ty_param;
+export fold_ty_params;
+export fold_fn_decl;
 
 type ast_fold = @mut a_f;
 
@@ -270,10 +272,12 @@ fn noop_fold_item_underscore(i: item_, fld: ast_fold) -> item_ {
           item_class(typms, items, ctor) {
               let ctor_body = fld.fold_block(ctor.node.body);
               let ctor_decl = fold_fn_decl(ctor.node.dec, fld);
+              let ctor_id   = fld.new_id(ctor.node.id);
               item_class(typms,
                          vec::map(items, fld.fold_class_item),
                          {node: {body: ctor_body,
-                                     dec: ctor_decl with ctor.node}
+                                 dec: ctor_decl,
+                                 id: ctor_id with ctor.node}
                              with ctor})
           }
           item_impl(tps, ifce, ty, methods) {

src/librustsyntax/visit.rs

@@ -18,21 +18,22 @@ enum fn_kind {
     fk_res(ident, [ty_param]),
     fk_anon(proto),  //< an anonymous function like fn@(...)
     fk_fn_block,     //< a block {||...}
-    fk_ctor(ident, [ty_param]) // class constructor
+    fk_ctor(ident, [ty_param], node_id /* self id */,
+            def_id /* parent class id */) // class constructor
 }
 
 fn name_of_fn(fk: fn_kind) -> ident {
     alt fk {
       fk_item_fn(name, _) | fk_method(name, _, _) | fk_res(name, _)
-          | fk_ctor(name, _) { name }
+          | fk_ctor(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)
-          | fk_ctor(_, tps) { tps }
+          | fk_ctor(_, tps, _, _) { tps }
       fk_anon(_) | fk_fn_block { [] }
     }
 }
@@ -141,9 +142,8 @@ fn visit_item<E>(i: @item, e: E, v: vt<E>) {
           for members.each {|m|
              v.visit_class_item(m, e, v);
           }
-          // make up a fake fn so as to call visit_fn on the ctor
-          v.visit_fn(fk_ctor(i.ident, tps), ctor.node.dec,
-                     ctor.node.body, ctor.span, ctor.node.id, e, v);
+          visit_class_ctor_helper(ctor, i.ident, tps,
+                                  ast_util::local_def(i.id), e, v);
       }
       item_iface(tps, methods) {
         v.visit_ty_params(tps, e, v);
@@ -270,6 +270,15 @@ fn visit_method_helper<E>(m: @method, e: E, v: vt<E>) {
                m.id, e, v);
 }
 
+// Similar logic to the comment on visit_method_helper - Tim
+fn visit_class_ctor_helper<E>(ctor: class_ctor, nm: ident, tps: [ty_param],
+                              parent_id: def_id, e: E, v: vt<E>) {
+    v.visit_fn(visit::fk_ctor(nm, tps, ctor.node.self_id,
+                              parent_id), ctor.node.dec,
+               ctor.node.body, ctor.span, ctor.node.id, e, v)
+
+}
+
 fn visit_fn<E>(fk: fn_kind, decl: fn_decl, body: blk, _sp: span,
                _id: node_id, e: E, v: vt<E>) {
     visit_fn_decl(decl, e, v);

src/rustc/metadata/astencode.rs

@@ -1,3 +1,5 @@
+import util::ppaux::ty_to_str;
+
 import syntax::ast;
 import syntax::fold;
 import syntax::visit;
@@ -200,8 +202,14 @@ fn visit_ids(item: ast::inlined_item, vfn: fn@(ast::node_id)) {
             vfn(id);
 
             alt fk {
+              visit::fk_ctor(nm, tps, self_id, parent_id) {
+                vec::iter(tps) {|tp| vfn(tp.id)}
+                vfn(id);
+                vfn(self_id);
+                vfn(parent_id.node);
+              }
               visit::fk_item_fn(_, tps) |
-              visit::fk_res(_, tps) | visit::fk_ctor(_, tps) {
+              visit::fk_res(_, tps) {
                 vec::iter(tps) {|tp| vfn(tp.id)}
               }
               visit::fk_method(_, tps, m) {
@@ -376,6 +384,13 @@ fn simplify_ast(ii: ast::inlined_item) -> ast::inlined_item {
       ast::ii_native(i) {
         ast::ii_native(fld.fold_native_item(i))
       }
+      ast::ii_ctor(ctor, nm, tps, parent_id) {
+        let ctor_body = fld.fold_block(ctor.node.body);
+        let ctor_decl = fold::fold_fn_decl(ctor.node.dec, fld);
+        ast::ii_ctor({node: {body: ctor_body, dec: ctor_decl
+                              with ctor.node}
+            with ctor}, nm, tps, parent_id)
+      }
     }
 }
 
@@ -403,7 +418,17 @@ fn renumber_ast(xcx: extended_decode_ctxt, ii: ast::inlined_item)
       ast::ii_native(i) {
         ast::ii_native(fld.fold_native_item(i))
       }
-    }
+      ast::ii_ctor(ctor, nm, tps, parent_id) {
+        let ctor_body = fld.fold_block(ctor.node.body);
+        let ctor_decl = fold::fold_fn_decl(ctor.node.dec, fld);
+        let new_params = fold::fold_ty_params(tps, fld);
+        let ctor_id = fld.new_id(ctor.node.id);
+        let new_parent = xcx.tr_def_id(parent_id);
+        ast::ii_ctor({node: {body: ctor_body, dec: ctor_decl, id: ctor_id
+                              with ctor.node}
+            with ctor}, nm, new_params, new_parent)
+      }
+     }
 }
 
 // ______________________________________________________________________

src/rustc/metadata/encoder.rs

@@ -368,6 +368,7 @@ fn encode_privacy(ebml_w: ebml::writer, privacy: privacy) {
 /* Returns an index of items in this class */
 fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::writer,
                          id: node_id, path: ast_map::path,
+                         class_tps: [ty_param],
                          items: [@class_member],
                          global_index: @mut[entry<int>])
  -> [entry<int>] {
@@ -397,13 +398,10 @@ fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::writer,
                    but it works for now -- tjc */
                 *global_index += [{val: m.id, pos: ebml_w.writer.tell()}];
                 let impl_path = path + [ast_map::path_name(m.ident)];
-                /*
-                  Recall methods are (currently) monomorphic, and we don't
-                  repeat the class's ty params in the method decl
-                */
                 #debug("encode_info_for_class: doing %s %d", m.ident, m.id);
                 encode_info_for_method(ecx, ebml_w, impl_path,
-                                       should_inline(m.attrs), id, m, []);
+                                       should_inline(m.attrs), id, m,
+                                       class_tps + m.tps);
             }
             _ { /* don't encode private methods */ }
           }
@@ -415,7 +413,8 @@ fn encode_info_for_class(ecx: @encode_ctxt, ebml_w: ebml::writer,
 
 fn encode_info_for_fn(ecx: @encode_ctxt, ebml_w: ebml::writer,
                       id: node_id, ident: ident, path: ast_map::path,
-                      item: option<@item>, tps: [ty_param], decl: fn_decl) {
+                      item: option<inlined_item>, tps: [ty_param],
+                      decl: fn_decl) {
         ebml_w.start_tag(tag_items_data_item);
         encode_name(ebml_w, ident);
         encode_def_id(ebml_w, local_def(id));
@@ -428,7 +427,7 @@ fn encode_info_for_fn(ecx: @encode_ctxt, ebml_w: ebml::writer,
         encode_path(ebml_w, path, ast_map::path_name(ident));
         alt item {
            some(it) {
-             astencode::encode_inlined_item(ecx, ebml_w, path, ii_item(it));
+             astencode::encode_inlined_item(ecx, ebml_w, path, it);
            }
            none {
              encode_symbol(ecx, ebml_w, id);
@@ -441,7 +440,7 @@ fn encode_info_for_method(ecx: @encode_ctxt, ebml_w: ebml::writer,
                           impl_path: ast_map::path, should_inline: bool,
                           parent_id: node_id,
                           m: @method, all_tps: [ty_param]) {
-    #debug("encode_info_for_method: %d %s", m.id, m.ident);
+    #debug("encode_info_for_method: %d %s %u", m.id, m.ident, all_tps.len());
     ebml_w.start_tag(tag_items_data_item);
     encode_def_id(ebml_w, local_def(m.id));
     encode_family(ebml_w, purity_fn_family(m.decl.purity));
@@ -562,8 +561,8 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
            These come first because we need to write them to make
            the index, and the index needs to be in the item for the
            class itself */
-        let idx = encode_info_for_class(ecx, ebml_w, item.id, path, items,
-                                          index);
+        let idx = encode_info_for_class(ecx, ebml_w, item.id, path, tps,
+                                          items, index);
         /* Index the class*/
         add_to_index();
         /* Now, make an item for the class itself */
@@ -594,6 +593,7 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
                 #debug("Writing %s %d", m.ident, m.id);
                 encode_family(ebml_w, purity_fn_family(m.decl.purity));
                 encode_name(ebml_w, m.ident);
+                encode_type_param_bounds(ebml_w, ecx, tps + m.tps);
                 encode_type(ecx, ebml_w, node_id_to_type(tcx, m.id));
                 encode_def_id(ebml_w, local_def(m.id));
                 ebml_w.end_tag();
@@ -727,7 +727,6 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer,
             alt check ecx.ccx.tcx.items.get(i.id) {
               ast_map::node_item(_, pt) {
                 encode_info_for_item(ecx, ebml_w, i, index, *pt);
-                /* TODO: encode info for class items! */
                 /* encode ctor, then encode items */
                 alt i.node {
                   item_class(tps,_,ctor) {
@@ -737,7 +736,10 @@ fn encode_info_for_items(ecx: @encode_ctxt, ebml_w: ebml::writer,
                           ctor.node.id);
                    *index += [{val: ctor.node.id, pos: ebml_w.writer.tell()}];
                    encode_info_for_fn(ecx, ebml_w, ctor.node.id, i.ident,
-                                      *pt, none, tps, ctor.node.dec)
+                      *pt, if tps.len() > 0u {
+                             some(ii_ctor(ctor, i.ident, tps,
+                                          local_def(i.id))) }
+                           else { none }, tps, ctor.node.dec)
                   }
                   _ {}
                 }

src/rustc/middle/ast_map.rs

@@ -44,10 +44,16 @@ enum ast_node {
     // order they are introduced.
     node_arg(arg, uint),
     node_local(uint),
-    node_ctor(@item, @path),
+    // Constructor for either a resource or a class
+    node_ctor(ident, [ty_param], a_ctor, @path),
     node_block(blk),
 }
 
+enum a_ctor {
+  res_ctor(fn_decl, node_id, codemap::span),
+  class_ctor(@class_ctor, def_id /* ID for parent class */),
+}
+
 type map = std::map::hashmap<node_id, ast_node>;
 type ctx = {map: map, mut path: path,
             mut local_id: uint, sess: session};
@@ -99,7 +105,7 @@ fn map_decoded_item(sess: session, map: map, path: path, ii: inlined_item) {
     // don't decode and instantiate the impl, but just the method, we have to
     // add it to the table now:
     alt ii {
-      ii_item(i) { /* fallthrough */ }
+      ii_item(_) | ii_ctor(_,_,_,_) { /* fallthrough */ }
       ii_native(i) {
         cx.map.insert(i.id, node_native_item(i, native_abi_rust_intrinsic,
                                              @path));
@@ -119,6 +125,16 @@ fn map_fn(fk: visit::fn_kind, decl: fn_decl, body: blk,
         cx.map.insert(a.id, node_arg(a, cx.local_id));
         cx.local_id += 1u;
     }
+    alt fk {
+      visit::fk_ctor(nm, tps, self_id, parent_id) {
+          let ct = @{node: {id: id, self_id: self_id,
+                           dec: decl, body: body},
+                    span: sp};
+          cx.map.insert(id, node_ctor(nm, tps, class_ctor(ct, parent_id),
+                                      @cx.path));
+       }
+       _ {}
+    }
     visit::visit_fn(fk, decl, body, sp, id, cx, v);
 }
 
@@ -166,8 +182,10 @@ fn map_item(i: @item, cx: ctx, v: vt) {
             map_method(impl_did, extend(cx, i.ident), m, cx);
         }
       }
-      item_res(_, _, _, dtor_id, ctor_id) {
-        cx.map.insert(ctor_id, node_ctor(i, item_path));
+      item_res(decl, tps, _, dtor_id, ctor_id) {
+        cx.map.insert(ctor_id, node_ctor(i.ident, tps,
+                                         res_ctor(decl, ctor_id, i.span),
+                                         item_path));
         cx.map.insert(dtor_id, node_item(i, item_path));
       }
       item_enum(vs, _) {
@@ -186,7 +204,6 @@ fn map_item(i: @item, cx: ctx, v: vt) {
         }
       }
       item_class(_, items, ctor) {
-          cx.map.insert(ctor.node.id, node_ctor(i, item_path));
           let d_id = ast_util::local_def(i.id);
           let p = extend(cx, i.ident);
           for items.each {|ci|
@@ -267,7 +284,7 @@ fn node_id_to_str(map: map, id: node_id) -> str {
       some(node_local(_)) { // FIXME: add more info here
         #fmt["local (id=%?)", id]
       }
-      some(node_ctor(_, _)) { // FIXME: add more info here
+      some(node_ctor(_, _, _, _)) { // FIXME: add more info here
         #fmt["node_ctor (id=%?)", id]
       }
       some(node_block(_)) {

src/rustc/middle/mutbl.rs

@@ -214,15 +214,15 @@ fn visit_expr(ex: @expr, &&cx: @ctx, v: visit::vt<@ctx>) {
 
 fn visit_item(item: @item, &&cx: @ctx, v: visit::vt<@ctx>) {
     alt item.node {
-            item_class(tps, items, ctor) {
-                v.visit_ty_params(tps, cx, v);
-                vec::map::<@class_member, ()>(items,
-                    {|i| v.visit_class_item(i, cx, v); });
-                v.visit_fn(visit::fk_ctor(item.ident, tps), ctor.node.dec,
-                           ctor.node.body, ctor.span, ctor.node.id,
-                           @{in_ctor: some(ctor.node.self_id) with *cx}, v);
-            }
-            _ { visit::visit_item(item, cx, v); }
+      item_class(tps, items, ctor) {
+         v.visit_ty_params(tps, cx, v);
+         vec::map::<@class_member, ()>(items,
+             {|i| v.visit_class_item(i, cx, v); });
+         visit::visit_class_ctor_helper(ctor, item.ident, tps,
+                                        ast_util::local_def(item.id),
+                    @{in_ctor: some(ctor.node.self_id) with *cx}, v);
+      }
+      _ { visit::visit_item(item, cx, v); }
     }
 }
 

src/rustc/middle/resolve.rs

@@ -572,7 +572,7 @@ fn visit_fn_with_scope(e: @env, fk: visit::fn_kind, decl: ast::fn_decl,
     for decl.constraints.each {|c| resolve_constr(e, c, sc, v); }
     let scope = alt fk {
       visit::fk_item_fn(_, tps) | visit::fk_res(_, tps) |
-      visit::fk_method(_, tps, _) | visit::fk_ctor(_, tps)
+      visit::fk_method(_, tps, _) | visit::fk_ctor(_, 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, []) }