Handle self correctly when translating classes

This change uses the same code for handling the "self" reference for
classes as is already used for impls/ifaces. This allows removing the
extra maybe_self_id argument (which was just for classes) to trans_closure
that I added before. I also rewrote the translation for class ctors so
that it doesn't generate new AST nodes (instead translating directly).

Also changed visit so that it visits class ctors correctly with visit_fn,
and changed typestate to not do return-checking when visiting a class ctor.

Author: catamorphism

src/rustc/metadata/astencode.rs

@@ -201,7 +201,7 @@ fn visit_ids(item: ast::inlined_item, vfn: fn@(ast::node_id)) {
 
             alt fk {
               visit::fk_item_fn(_, tps) |
-              visit::fk_res(_, tps) {
+              visit::fk_res(_, tps) | visit::fk_ctor(_, tps) {
                 vec::iter(tps) {|tp| vfn(tp.id)}
               }
               visit::fk_method(_, tps, m) {

src/rustc/middle/resolve.rs

@@ -570,7 +570,8 @@ 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, _) | 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, []) }
     };

src/rustc/middle/trans/base.rs

@@ -383,7 +383,7 @@ fn trans_expr_fn(bcx: block,
             ccx.tcx, id, proto, cap_clause);
         let {llbox, cdata_ty, bcx} = build_closure(bcx, cap_vars, ck, id);
         trans_closure(ccx, sub_path, decl, body, llfn, no_self,
-                      bcx.fcx.param_substs, id, none, {|fcx|
+                      bcx.fcx.param_substs, id, {|fcx|
             load_environment(fcx, cdata_ty, cap_vars, ck);
         });
         llbox
@@ -395,7 +395,7 @@ fn trans_expr_fn(bcx: block,
       ast::proto_uniq { trans_closure_env(ty::ck_uniq) }
       ast::proto_bare {
         trans_closure(ccx, sub_path, decl, body, llfn, no_self, none,
-                      id, none, {|_fcx|});
+                      id, {|_fcx|});
         C_null(T_opaque_box_ptr(ccx))
       }
     };

src/rustc/middle/trans/closure.rs

@@ -119,6 +119,9 @@ type crate_ctxt = {
      shape_cx: shape::ctxt,
      crate_map: ValueRef,
      dbg_cx: option<debuginfo::debug_ctxt>,
+     // Mapping from class constructors to parent class --
+     // used in base::trans_closure
+     class_ctors: hashmap<ast::node_id, ast::node_id>,
      mutable do_not_commit_warning_issued: bool};
 
 // Types used for llself.
@@ -175,10 +178,6 @@ type fn_ctxt = @{
     // a user-defined function.
     id: ast::node_id,
 
-    // The expr for the "self" object (only if this function corresponds
-    // to a class constructor function)
-    self_id: option<@ast::expr>,
-
     // If this function is being monomorphized, this contains the type
     // substitutions used.
     param_substs: option<param_substs>,

src/rustc/middle/trans/common.rs

@@ -24,7 +24,7 @@ fn trans_impl(ccx: @crate_ctxt, path: path, name: ast::ident,
             let llfn = get_item_val(ccx, m.id);
             trans_fn(ccx, sub_path + [path_name(m.ident)], m.decl, m.body,
                      llfn, impl_self(ty::node_id_to_type(ccx.tcx, m.self_id)),
-                     none, m.id, none);
+                     none, m.id);
         }
     }
 }

src/rustc/middle/trans/impl.rs

@@ -818,8 +818,7 @@ fn trans_crust_fn(ccx: @crate_ctxt, path: ast_map::path, decl: ast::fn_decl,
             ccx, path + [ast_map::path_name("__rust_abi")]);
         let llty = type_of_fn_from_ty(ccx, t);
         let llfndecl = decl_internal_cdecl_fn(ccx.llmod, ps, llty);
-        trans_fn(ccx, path, decl, body, llfndecl, no_self, none, id,
-                 none);
+        trans_fn(ccx, path, decl, body, llfndecl, no_self, none, id);
         ret llfndecl;
     }
 

src/rustc/middle/trans/native.rs

@@ -111,7 +111,8 @@ fn check_states_against_conditions(fcx: fn_ctxt,
 
     /* Check that the return value is initialized */
     let post = aux::block_poststate(fcx.ccx, f_body);
-    if !promises(fcx, post, fcx.enclosing.i_return) &&
+    let is_ctor = alt fk { visit::fk_ctor(_,_) { true } _ { false } };
+    if !is_ctor && !promises(fcx, post, fcx.enclosing.i_return) &&
        !ty::type_is_nil(ty::ty_fn_ret(ty::node_id_to_type(
            fcx.ccx.tcx, id))) &&
        f_decl.cf == return_val {

src/rustc/middle/tstate/ck.rs

@@ -18,18 +18,21 @@ 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
 }
 
 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, _)
+          | 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) { tps }
+      fk_item_fn(_, tps) | fk_method(_, tps, _) | fk_res(_, tps)
+          | fk_ctor(_, tps) { tps }
       fk_anon(_) | fk_fn_block { [] }
     }
 }
@@ -138,8 +141,9 @@ fn visit_item<E>(i: @item, e: E, v: vt<E>) {
           for m in members {
              v.visit_class_item(m.span, m.node.privacy, m.node.decl, e, v);
           }
-          visit_fn_decl(ctor.node.dec, e, v);
-          v.visit_block(ctor.node.body, 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);
       }
       item_iface(tps, methods) {
         v.visit_ty_params(tps, e, v);

src/rustc/syntax/visit.rs

@@ -1,4 +1,3 @@
-// xfail-test
 class cat {
   priv {
     let mutable meows : uint;