Monomorphize class constructors, support generic classes and class methods

Allow class methods to have type parameters (this is a change from the
original classes proposal).

Add test cases for classes with type parameters, and classes with methods
that have their own type parameters.

Author: catamorphism

src/librustsyntax/parse/parser.rs

@@ -2062,11 +2062,24 @@ fn parse_item_res(p: parser, attrs: [ast::attribute]) -> @ast::item {
                 attrs);
 }
 
+// Instantiates ident <i> with references to <typarams> as arguments
+fn ident_to_path_tys(p: parser, i: ast::ident,
+                     typarams: [ast::ty_param]) -> @ast::path {
+    let s = p.last_span;
+    let p_: ast::path_ = {global: false, idents: [i],
+          types: vec::map(typarams,
+            {|tp| @{id: p.get_id(),
+                   node: ast::ty_path(ident_to_path(s, tp.ident),
+                                      p.get_id()),
+                        span: s}})};
+    @spanned(s.lo, s.hi, p_)
+}
+
 fn parse_item_class(p: parser, attrs: [ast::attribute]) -> @ast::item {
     let lo = p.last_span.lo;
     let class_name = parse_value_ident(p);
-    let class_path = ident_to_path(p.last_span, class_name);
     let ty_params = parse_ty_params(p);
+    let class_path = ident_to_path_tys(p, class_name, ty_params);
     expect(p, token::LBRACE);
     let mut ms: [@ast::class_member] = [];
     let ctor_id = p.get_id();
@@ -2104,15 +2117,16 @@ fn parse_item_class(p: parser, attrs: [ast::attribute]) -> @ast::item {
 enum class_contents { ctor_decl(ast::fn_decl, ast::blk, codemap::span),
                       members([@ast::class_member]) }
 
-fn parse_class_item(p:parser, class_name:@ast::path) -> class_contents {
+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;
         // Can ctors have attrs?
             // result type is always the type of the class
         let decl_ = parse_fn_decl(p, ast::impure_fn);
         let decl = {output: @{id: p.get_id(),
-                              node: ast::ty_path(class_name, p.get_id()),
-                              span: decl_.output.span}
+                      node: ast::ty_path(class_name_with_tps, p.get_id()),
+                      span: decl_.output.span}
                     with decl_};
         let body = parse_block(p);
         ret ctor_decl(decl, body, ast_util::mk_sp(lo, p.last_span.hi));

src/rustc/middle/kind.rs

@@ -189,10 +189,26 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
                 let did = ast_util::def_id_of_def(cx.tcx.def_map.get(e.id));
                 ty::lookup_item_type(cx.tcx, did).bounds
               }
-              expr_field(_, _, _) {
+              expr_field(base, _, _) {
                 alt cx.method_map.get(e.id) {
                   typeck::method_static(did) {
-                    ty::lookup_item_type(cx.tcx, did).bounds
+                   /*
+                        If this is a class method, we want to use the
+                        class bounds plus the method bounds -- otherwise the
+                        indices come out wrong. So we check base's type...
+                   */
+                   let mut bounds = ty::lookup_item_type(cx.tcx, did).bounds;
+                   alt ty::get(ty::node_id_to_type(cx.tcx, base.id)).struct {
+                        ty::ty_class(parent_id, ts) {
+                            /* ...and if it has a class type, prepend the
+                               class bounds onto the method bounds */
+                            bounds =
+                             @(*ty::lookup_item_type(cx.tcx, parent_id).bounds
+                               + *bounds);
+                        }
+                        _ { }
+                      }
+                      bounds
                   }
                   typeck::method_param(ifce_id, n_mth, _, _) |
                   typeck::method_iface(ifce_id, n_mth) {

src/rustc/middle/trans/base.rs

@@ -950,7 +950,7 @@ fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
       ty::ty_class(did, tps) {
           // a class is like a record type
         let mut i: int = 0;
-        for vec::each(ty::class_items_as_fields(cx.tcx(), did)) {|fld|
+        for vec::each(ty::class_items_as_fields(cx.tcx(), did, tps)) {|fld|
             let llfld_a = GEPi(cx, av, [0, i]);
             cx = f(cx, llfld_a, fld.mt.ty);
             i += 1;
@@ -1983,8 +1983,13 @@ fn monomorphic_fn(ccx: @crate_ctxt, fn_id: ast::def_id, real_substs: [ty::t],
             set_inline_hint(lldecl);
             trans_res_ctor(ccx, pt, decl, fn_id.node, psubsts, lldecl);
           }
-          ast::item_class(_, _, ctor) {
-            ccx.sess.unimpl("monomorphic class constructor");
+          ast::item_class(tps, _, ctor) {
+            set_inline_hint_if_appr(i.attrs, lldecl);
+            let tp_tys: [ty::t] = ty::ty_params_to_tys(ccx.tcx, tps);
+            trans_class_ctor(ccx, pt, ctor.node.dec, ctor.node.body, lldecl,
+                 option::get_or_default(psubsts,
+                   {tys:tp_tys, vtables: none, bounds: @[]}),
+              fn_id.node, i.id, ctor.span);
           }
         }
       }
@@ -2238,7 +2243,8 @@ fn trans_rec_field_inner(bcx: block, val: ValueRef, ty: ty::t,
                          field: ast::ident, sp: span) -> lval_result {
     let fields = alt ty::get(ty).struct {
             ty::ty_rec(fs) { fs }
-            ty::ty_class(did,_) { ty::class_items_as_fields(bcx.tcx(), did) }
+            ty::ty_class(did,ts) {
+                ty::class_items_as_fields(bcx.tcx(), did, ts) }
             // Constraint?
             _ { bcx.tcx().sess.span_bug(sp, "trans_rec_field:\
                  base expr has non-record type"); }
@@ -4255,6 +4261,61 @@ fn trans_const(ccx: @crate_ctxt, e: @ast::expr, id: ast::node_id) {
     llvm::LLVMSetGlobalConstant(g, True);
 }
 
+fn trans_class_ctor(ccx: @crate_ctxt, path: path, decl: ast::fn_decl,
+                    body: ast::blk, llctor_decl: ValueRef,
+                    psubsts: param_substs, ctor_id: ast::node_id,
+                    parent_id: ast::node_id, sp: span) {
+  // Add ctor to the ctor map
+  ccx.class_ctors.insert(ctor_id, parent_id);
+  // Translate the ctor
+
+  // Set up the type for the result of the ctor
+  // kludgy -- this wouldn't be necessary if the typechecker
+  // special-cased constructors, then we could just look up
+  // the ctor's return type.
+  let rslt_ty =  ty::mk_class(ccx.tcx, local_def(parent_id),
+                                    psubsts.tys);
+  // Make the fn context
+  let fcx = new_fn_ctxt_w_id(ccx, path, llctor_decl, ctor_id,
+                                   some(psubsts), some(sp));
+  // FIXME: need to substitute into the fn arg types too?
+  create_llargs_for_fn_args(fcx, no_self, decl.inputs);
+  let mut bcx_top = top_scope_block(fcx, some(sp));
+  let lltop = bcx_top.llbb;
+  bcx_top = copy_args_to_allocas(fcx, bcx_top, decl.inputs,
+              ty::ty_fn_args(node_id_type(bcx_top, ctor_id)));
+
+  // We *don't* want self to be passed to the ctor -- that
+  // wouldn't make sense
+  // So we initialize it here
+  let selfptr = alloc_ty(bcx_top, rslt_ty);
+  // initialize fields to zero
+  let fields = ty::class_items_as_fields(bcx_top.tcx(),
+                                         local_def(parent_id),
+                                         psubsts.tys);
+  let mut bcx = bcx_top;
+  // Initialize fields to zero so init assignments can validly
+  // drop their LHS
+  for field in fields {
+     let ix = field_idx_strict(bcx.tcx(), sp, field.ident, fields);
+     bcx = zero_alloca(bcx, GEPi(bcx, selfptr, [0, ix]),
+                       field.mt.ty);
+  }
+
+  // note we don't want to take *or* drop self.
+  fcx.llself = some({v: selfptr, t: rslt_ty});
+
+  // Translate the body of the ctor
+  bcx = trans_block(bcx_top, body, ignore);
+  let lval_res = {bcx: bcx, val: selfptr, kind: owned};
+  // Generate the return expression
+  bcx = store_temp_expr(bcx, INIT, fcx.llretptr, lval_res,
+                        rslt_ty, true);
+  cleanup_and_leave(bcx, none, some(fcx.llreturn));
+  Unreachable(bcx);
+  finish_fn(fcx, lltop);
+}
+
 fn trans_item(ccx: @crate_ctxt, item: ast::item) {
     let _icx = ccx.insn_ctxt("trans_item");
     let path = alt check ccx.tcx.items.get(item.id) {
@@ -4322,62 +4383,15 @@ fn trans_item(ccx: @crate_ctxt, item: ast::item) {
         native::trans_native_mod(ccx, native_mod, abi);
       }
       ast::item_class(tps, items, ctor) {
-        // FIXME factor our ctor translation, call from monomorphic_fn
-        let llctor_decl = get_item_val(ccx, ctor.node.id);
-        // Add ctor to the ctor map
-        ccx.class_ctors.insert(ctor.node.id, item.id);
-        // Translate the ctor
-
-        // Set up the type for the result of the ctor
-        // kludgy -- this wouldn't be necessary if the typechecker
-        // special-cased constructors, then we could just look up
-        // the ctor's return type.
-        let ty_args = vec::from_fn(tps.len(), {|i|
-            ty::mk_param(ccx.tcx, i, local_def(tps[i].id))
-        });
-        let rslt_ty =  ty::mk_class(ccx.tcx,
-                                    local_def(item.id),
-                                    ty_args);
-
-        // Make the fn context
-        let fcx = new_fn_ctxt_w_id(ccx, *path, llctor_decl, ctor.node.id,
-                                      // substs?
-                                      none, some(ctor.span));
-        create_llargs_for_fn_args(fcx, no_self, ctor.node.dec.inputs);
-        let mut bcx_top = top_scope_block(fcx, some(ctor.span));
-        let lltop = bcx_top.llbb;
-        bcx_top = copy_args_to_allocas(fcx, bcx_top, ctor.node.dec.inputs,
-           ty::ty_fn_args(node_id_type(bcx_top, ctor.node.id)));
-
-        // We *don't* want self to be passed to the ctor -- that
-        // wouldn't make sense
-        // So we initialize it here
-        let selfptr = alloc_ty(bcx_top, rslt_ty);
-        // initialize fields to zero
-        let fields = ty::class_items_as_fields(bcx_top.tcx(),
-                                               local_def(item.id));
-        let mut bcx = bcx_top;
-        // Initialize fields to zero so init assignments can validly
-        // drop their LHS
-        for field in fields {
-           let ix = field_idx_strict(bcx.tcx(), ctor.span, field.ident,
-                                     fields);
-           bcx = zero_alloca(bcx, GEPi(bcx, selfptr, [0, ix]),
-                                       field.mt.ty);
+        if tps.len() == 0u {
+          let psubsts = {tys: ty::ty_params_to_tys(ccx.tcx, tps),
+                         vtables: none,
+                         bounds: @[]};
+          trans_class_ctor(ccx, *path, ctor.node.dec, ctor.node.body,
+                         get_item_val(ccx, ctor.node.id), psubsts,
+                         ctor.node.id, item.id, ctor.span);
         }
-
-        // note we don't want to take *or* drop self.
-        fcx.llself = some({v: selfptr, t: rslt_ty});
-
-        // Translate the body of the ctor
-        bcx = trans_block(bcx_top, ctor.node.body, ignore);
-        let lval_res = {bcx: bcx, val: selfptr, kind: owned};
-        // Generate the return expression
-        bcx = store_temp_expr(bcx, INIT, fcx.llretptr, lval_res,
-                              rslt_ty, true);
-        cleanup_and_leave(bcx, none, some(fcx.llreturn));
-        Unreachable(bcx);
-        finish_fn(fcx, lltop);
+        // If there are ty params, the ctor will get monomorphized
 
         // Translate methods
         let (_, ms) = ast_util::split_class_items(items);

src/rustc/middle/trans/shape.rs

@@ -369,10 +369,10 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t, ty_param_map: [uint]) -> [u8] {
         s
       }
       ty::ty_iface(_, _) { [shape_box_fn] }
-      ty::ty_class(did, _) {
+      ty::ty_class(did, ts) {
         // same as records
         let mut s = [shape_struct], sub = [];
-        for f:field in ty::class_items_as_fields(ccx.tcx, did) {
+        for f:field in ty::class_items_as_fields(ccx.tcx, did, ts) {
             sub += shape_of(ccx, f.mt.ty, ty_param_map);
         }
         add_substr(s, sub);

src/rustc/middle/trans/type_of.rs

@@ -81,11 +81,11 @@ fn type_of(cx: @crate_ctxt, t: ty::t) -> TypeRef {
       }
       ty::ty_opaque_closure_ptr(_) { T_opaque_box_ptr(cx) }
       ty::ty_constr(subt,_) { type_of(cx, subt) }
-      ty::ty_class(did, _) {
+      ty::ty_class(did, ts) {
         // only instance vars are record fields at runtime
         let fields = lookup_class_fields(cx.tcx, did);
         let tys = vec::map(fields) {|f|
-            let t = ty::lookup_field_type(cx.tcx, did, f.id);
+            let t = ty::lookup_field_type(cx.tcx, did, f.id, ts);
             type_of(cx, t)
         };
         T_struct(tys)

src/rustc/middle/trans/type_use.rs

@@ -1,4 +1,4 @@
-// Determines the ways in which a generic function body is dependant
+// Determines the ways in which a generic function body depends
 // on its type parameters. Used to aggressively reuse compiled
 // function bodies for different types.
 
@@ -80,7 +80,7 @@ fn type_uses_for(ccx: @crate_ctxt, fn_id: def_id, n_tps: uint)
         }
       }
       ast_map::node_ctor(@{node: item_class(_, _, ctor), _}, _) {
-        ccx.sess.unimpl("type uses in class constructor");
+        handle_body(cx, ctor.node.body);
       }
     }
     let uses = vec::from_mut(cx.uses);

src/rustc/middle/tstate/auxiliary.rs

@@ -197,6 +197,20 @@ type pred_args = spanned<pred_args_>;
 // for this local.
 type constr_arg_use = spanned<constr_arg_general_<inst>>;
 
+/*
+  A constraint is either an init constraint, referring to the initialization
+  state of a variable (not initialized, definitely initialized, or maybe
+  initialized) or a predicate constraint, referring to the truth value of a
+  predicate on variables (definitely false, maybe true, or definitely true).
+
+  cinit and ninit represent init constraints, while cpred and npred
+  represent predicate constraints.
+
+  In a predicate constraint, the <path> field (and the <def_id> field
+  in the npred constructor) names a user-defined function that may
+  be the operator in a "check" expression in the source.
+ */
+
 enum constraint {
     cinit(uint, span, ident),