Obj system? What obj system?

Removes the obj system from the compiler.

Closes #1484

Author: marijnh

src/comp/back/abi.rs

@@ -46,7 +46,7 @@ const tydesc_field_cmp_glue: int = 10;
 const tydesc_field_shape: int = 11;
 const tydesc_field_shape_tables: int = 12;
 const tydesc_field_n_params: int = 13;
-const tydesc_field_obj_params: int = 14;
+const tydesc_field_obj_params: int = 14; // FIXME unused
 const n_tydesc_fields: int = 15;
 
 const cmp_glue_op_eq: uint = 0u;
@@ -55,19 +55,6 @@ const cmp_glue_op_lt: uint = 1u;
 
 const cmp_glue_op_le: uint = 2u;
 
-const obj_field_vtbl: int = 0;
-
-const obj_field_box: int = 1;
-
-const obj_body_elt_tydesc: int = 0;
-
-const obj_body_elt_typarams: int = 1;
-
-const obj_body_elt_fields: int = 2;
-
-// The base object to which an anonymous object is attached.
-const obj_body_elt_inner_obj: int = 3;
-
 // The two halves of a closure: code and environment.
 const fn_field_code: int = 0;
 const fn_field_box: int = 1;

src/comp/metadata/encoder.rs

@@ -126,18 +126,6 @@ fn encode_module_item_paths(ebml_w: ebml::writer, module: _mod, path: [str],
             ebml::end_tag(ebml_w);
             encode_tag_variant_paths(ebml_w, variants, path, index);
           }
-          item_obj(_, tps, ctor_id) {
-            add_to_index(ebml_w, path, index, it.ident);
-            ebml::start_tag(ebml_w, tag_paths_data_item);
-            encode_name(ebml_w, it.ident);
-            encode_def_id(ebml_w, local_def(ctor_id));
-            ebml::end_tag(ebml_w);
-            add_to_index(ebml_w, path, index, it.ident);
-            ebml::start_tag(ebml_w, tag_paths_data_item);
-            encode_name(ebml_w, it.ident);
-            encode_def_id(ebml_w, local_def(it.id));
-            ebml::end_tag(ebml_w);
-          }
           item_iface(_, _) {
             add_to_index(ebml_w, path, index, it.ident);
             ebml::start_tag(ebml_w, tag_paths_data_item);
@@ -366,26 +354,6 @@ fn encode_info_for_item(ecx: @encode_ctxt, ebml_w: ebml::writer, item: @item,
         encode_symbol(ecx, ebml_w, ctor_id);
         ebml::end_tag(ebml_w);
       }
-      item_obj(_, tps, ctor_id) {
-        let fn_ty = node_id_to_monotype(tcx, ctor_id);
-
-        ebml::start_tag(ebml_w, tag_items_data_item);
-        encode_def_id(ebml_w, local_def(item.id));
-        encode_family(ebml_w, 'y' as u8);
-        encode_type_param_bounds(ebml_w, ecx, tps);
-        encode_type(ecx, ebml_w, ty::ty_fn_ret(tcx, fn_ty));
-        encode_name(ebml_w, item.ident);
-        ebml::end_tag(ebml_w);
-
-        index += [{val: ctor_id, pos: ebml_w.writer.tell()}];
-        ebml::start_tag(ebml_w, tag_items_data_item);
-        encode_def_id(ebml_w, local_def(ctor_id));
-        encode_family(ebml_w, 'f' as u8);
-        encode_type_param_bounds(ebml_w, ecx, tps);
-        encode_type(ecx, ebml_w, fn_ty);
-        encode_symbol(ecx, ebml_w, ctor_id);
-        ebml::end_tag(ebml_w);
-      }
       item_impl(tps, ifce, _, methods) {
         ebml::start_tag(ebml_w, tag_items_data_item);
         encode_def_id(ebml_w, local_def(item.id));

src/comp/metadata/tydecode.rs

@@ -246,24 +246,6 @@ fn parse_ty(st: @pstate, conv: conv_did) -> ty::t {
         let func = parse_ty_fn(st, conv);
         ret ty::mk_native_fn(st.tcx, func.inputs, func.output);
       }
-      'O' {
-        assert (next(st) as char == '[');
-        let methods: [ty::method] = [];
-        while peek(st) as char != ']' {
-            let proto;
-            alt next(st) as char {
-              'f' { proto = ast::proto_bare; }
-            }
-            let name = "";
-            while peek(st) as char != '[' {
-                name += str::unsafe_from_byte(next(st));
-            }
-            methods += [{ident: name, tps: @[],
-                         fty: {proto: proto with parse_ty_fn(st, conv)}}];
-        }
-        st.pos += 1u;
-        ret ty::mk_obj(st.tcx, methods);
-      }
       'r' {
         assert (next(st) as char == '[');
         let def = parse_def(st, conv);

src/comp/metadata/tyencode.rs

@@ -157,15 +157,6 @@ fn enc_sty(w: io::writer, cx: @ctxt, st: ty::sty) {
         enc_ty_fn(w, cx, {proto: proto_bare, inputs: args, output: out,
                           ret_style: return_val, constraints: []});
       }
-      ty::ty_obj(methods) {
-        w.write_str("O[");
-        for m: ty::method in methods {
-            enc_proto(w, m.fty.proto);
-            w.write_str(m.ident);
-            enc_ty_fn(w, cx, m.fty);
-        }
-        w.write_char(']');
-      }
       ty::ty_res(def, ty, tps) {
         w.write_str("r[");
         w.write_str(cx.ds(def));

src/comp/middle/alias.rs

@@ -56,8 +56,8 @@ type ctx = {tcx: ty::ctxt,
             mutable silent: bool};
 
 fn check_crate(tcx: ty::ctxt, crate: @ast::crate) -> (copy_map, ref_map) {
-    // Stores information about object fields and function
-    // arguments that's otherwise not easily available.
+    // Stores information about function arguments that's otherwise not easily
+    // available.
     let cx = @{tcx: tcx,
                copy_map: std::map::new_int_hash(),
                ref_map: std::map::new_int_hash(),
@@ -521,7 +521,7 @@ fn ty_can_unsafely_include(cx: ctx, needle: unsafe_ty, haystack: ty::t,
           }
           ty::ty_fn({proto: ast::proto_bare., _}) { ret false; }
           // These may contain anything.
-          ty::ty_fn(_) | ty::ty_obj(_) { ret true; }
+          ty::ty_fn(_) | ty::ty_iface(_, _) { ret true; }
           // A type param may include everything, but can only be
           // treated as opaque downstream, and is thus safe unless we
           // saw mutable fields, in which case the whole thing can be
@@ -536,8 +536,7 @@ fn ty_can_unsafely_include(cx: ctx, needle: unsafe_ty, haystack: ty::t,
 fn def_is_local(d: ast::def) -> bool {
     alt d {
       ast::def_local(_, _) | ast::def_arg(_, _) | ast::def_binding(_) |
-      ast::def_upvar(_, _, _) | ast::def_self(_) |
-      ast::def_obj_field(_, _) { true }
+      ast::def_upvar(_, _, _) | ast::def_self(_) { true }
       _ { false }
     }
 }
@@ -557,10 +556,9 @@ fn copy_is_expensive(tcx: ty::ctxt, ty: ty::t) -> bool {
           ty::ty_nil. | ty::ty_bot. | ty::ty_bool. | ty::ty_int(_) |
           ty::ty_uint(_) | ty::ty_float(_) | ty::ty_type. | ty::ty_native(_) |
           ty::ty_ptr(_) { 1u }
-          ty::ty_box(_) { 3u }
+          ty::ty_box(_) | ty::ty_iface(_, _) { 3u }
           ty::ty_constr(t, _) | ty::ty_res(_, t, _) { score_ty(tcx, t) }
-          ty::ty_fn(_) | ty::ty_native_fn(_, _) |
-          ty::ty_obj(_) { 4u }
+          ty::ty_fn(_) | ty::ty_native_fn(_, _) { 4u }
           ty::ty_str. | ty::ty_vec(_) | ty::ty_param(_, _) { 50u }
           ty::ty_uniq(mt) { 1u + score_ty(tcx, mt.ty) }
           ty::ty_tag(_, ts) | ty::ty_tup(ts) {
@@ -633,17 +631,6 @@ fn expr_root(cx: ctx, ex: @ast::expr, autoderef: bool)
     for d in *base_root.ds {
         if d.mut { unsafe_ty = some(contains(d.outer_t)); break; }
     }
-    alt base_root.ex.node {
-      ast::expr_path(_) {
-        alt cx.tcx.def_map.get(base_root.ex.id) {
-          ast::def_obj_field(_, ast::mut.) {
-            unsafe_ty = some(mut_contains(ty::expr_ty(cx.tcx, base_root.ex)));
-          }
-          _ {}
-        }
-      }
-      _ {}
-    }
     ret {ex: base_root.ex, mut: unsafe_ty};
 }
 

src/comp/middle/ast_map.rs

@@ -6,8 +6,6 @@ import syntax::{visit, codemap};
 
 tag ast_node {
     node_item(@item);
-    node_obj_ctor(@item);
-    node_obj_method(@method);
     node_native_item(@native_item);
     node_method(@method);
     node_expr(@expr);
@@ -62,12 +60,6 @@ fn map_arm(cx: ctx, arm: arm) {
 fn map_item(cx: ctx, i: @item) {
     cx.map.insert(i.id, node_item(i));
     alt i.node {
-      item_obj(ob, _, ctor_id) {
-        cx.map.insert(ctor_id, node_obj_ctor(i));
-        for m in ob.methods {
-            cx.map.insert(m.id, node_obj_method(m));
-        }
-      }
       item_impl(_, _, _, ms) {
         for m in ms { cx.map.insert(m.id, node_method(m)); }
       }
@@ -85,20 +77,11 @@ fn map_native_item(cx: ctx, i: @native_item) {
 
 fn map_expr(cx: ctx, ex: @expr) {
     cx.map.insert(ex.id, node_expr(ex));
-    alt ex.node {
-      expr_anon_obj(ao) {
-        for m in ao.methods {
-            cx.map.insert(m.id, node_obj_method(m));
-        }
-      }
-      _ {}
-    }
 }
 
 fn node_span(node: ast_node) -> codemap::span {
     alt node {
       node_item(item) { item.span }
-      node_obj_ctor(item) { item.span }
       node_native_item(nitem) { nitem.span }
       node_expr(expr) { expr.span }
     }
@@ -120,18 +103,6 @@ mod test {
         assert (node_span(node) == expected);
     }
 
-    #[test]
-    fn test_node_span_obj_ctor() {
-        let expected: codemap::span = ast_util::mk_sp(20u, 30u);
-        let node =
-            node_obj_ctor(@{ident: "test",
-                            attrs: [],
-                            id: 0,
-                            node: item_mod({view_items: [], items: []}),
-                            span: expected});
-        assert (node_span(node) == expected);
-    }
-
     #[test]
     fn test_node_span_native_item() {
         let expected: codemap::span = ast_util::mk_sp(20u, 30u);

src/comp/middle/debuginfo.rs

@@ -727,9 +727,6 @@ fn create_function(fcx: @fn_ctxt) -> @metadata<subprogram_md> {
           }
         }
       }
-      ast_map::node_obj_method(method) | ast_map::node_method(method) {
-        (method.ident, method.decl.output, method.id)
-      }
       ast_map::node_res_ctor(item) {
         alt item.node { ast::item_res(decl, _, _, _, ctor_id) {
           (item.ident, decl.output, ctor_id)

src/comp/middle/gc.rs

@@ -3,7 +3,7 @@
 import lib::llvm::True;
 import lib::llvm::llvm::ValueRef;
 import middle::trans;
-import middle::trans::{get_tydesc, tps_normal};
+import middle::trans::get_tydesc;
 import middle::trans_common::*;
 import middle::ty;
 import option::none;
@@ -43,7 +43,7 @@ fn add_gc_root(cx: @block_ctxt, llval: ValueRef, ty: ty::t) -> @block_ctxt {
     bcx = trans::zero_alloca(bcx, llval, ty);
 
     let ti = none;
-    let td_r = get_tydesc(bcx, ty, false, tps_normal, ti);
+    let td_r = get_tydesc(bcx, ty, false, ti);
     bcx = td_r.result.bcx;
     let lltydesc = td_r.result.val;
 
@@ -147,7 +147,7 @@ fn type_is_gc_relevant(cx: ty::ctxt, ty: ty::t) -> bool {
       }
       ty::ty_constr(sub, _) { ret type_is_gc_relevant(cx, sub); }
       ty::ty_box(_) | ty::ty_uniq(_) | ty::ty_fn(_) |
-      ty::ty_native_fn(_, _) | ty::ty_obj(_) | ty::ty_param(_, _) |
+      ty::ty_native_fn(_, _) | ty::ty_param(_, _) |
       ty::ty_res(_, _, _) { ret true; }
       ty::ty_var(_) {
         fail "ty_var in type_is_gc_relevant";

src/comp/middle/kind.rs

@@ -8,7 +8,7 @@ import driver::session::session;
 // Kind analysis pass. There are three kinds:
 //
 //  sendable: scalar types, and unique types containing only sendable types
-//  copyable: boxes, objects, closures, and uniques containing copyable types
+//  copyable: boxes, closures, and uniques containing copyable types
 //  noncopyable: resources, or unique types containing resources
 //
 // This pass ensures that type parameters are only instantiated with types
@@ -218,7 +218,7 @@ fn maybe_copy(cx: ctx, ex: @expr) {
 }
 
 fn check_copy_ex(cx: ctx, ex: @expr, _warn: bool) {
-    if ty::expr_is_lval(cx.method_map, cx.tcx, ex) &&
+    if ty::expr_is_lval(cx.method_map, ex) &&
        !cx.last_uses.contains_key(ex.id) {
         let ty = ty::expr_ty(cx.tcx, ex);
         check_copy(cx, ty, ex.span);

src/comp/middle/mut.rs

@@ -60,7 +60,7 @@ fn expr_root(tcx: ty::ctxt, ex: @expr, autoderef: bool) ->
                     }
                 }
               }
-              ty::ty_obj(_) { }
+              _ {}
             }
             ds += [@{mut: is_mut, kind: field, outer_t: auto_unbox.t}];
             ds += auto_unbox.ds;
@@ -201,9 +201,6 @@ fn check_move_rhs(cx: @ctx, src: @expr) {
     alt src.node {
       expr_path(p) {
         alt cx.tcx.def_map.get(src.id) {
-          def_obj_field(_, _) {
-            mk_err(cx, src.span, msg_move_out, "object field");
-          }
           def_self(_) {
             mk_err(cx, src.span, msg_move_out, "method self");
           }
@@ -267,7 +264,6 @@ fn is_immutable_def(cx: @ctx, def: def) -> option::t<str> {
       }
       def_arg(_, by_ref.) | def_arg(_, by_val.) |
       def_arg(_, mode_infer.) { some("argument") }
-      def_obj_field(_, imm.) { some("immutable object field") }
       def_self(_) { some("self argument") }
       def_upvar(_, inner, node_id) {
         let ty = ty::node_id_to_monotype(cx.tcx, node_id);