Removing tasks, ports and chans from the compiler.

Author: Eric Holk

src/comp/metadata/tydecode.rs

@@ -219,9 +219,6 @@ fn parse_ty(st: @pstate, sd: str_def) -> ty::t {
       '*' { ret ty::mk_ptr(st.tcx, parse_mt(st, sd)); }
       'V' { ret ty::mk_vec(st.tcx, parse_mt(st, sd)); }
       'I' { ret ty::mk_ivec(st.tcx, parse_mt(st, sd)); }
-      'a' { ret ty::mk_task(st.tcx); }
-      'P' { ret ty::mk_port(st.tcx, parse_ty(st, sd)); }
-      'C' { ret ty::mk_chan(st.tcx, parse_ty(st, sd)); }
       'R' {
         assert (next(st) as char == '[');
         let fields: [ty::field] = ~[];

src/comp/metadata/tyencode.rs

@@ -130,8 +130,6 @@ fn enc_sty(w: &io::writer, cx: &@ctxt, st: &ty::sty) {
       ty::ty_ptr(mt) { w.write_char('*'); enc_mt(w, cx, mt); }
       ty::ty_vec(mt) { w.write_char('V'); enc_mt(w, cx, mt); }
       ty::ty_ivec(mt) { w.write_char('I'); enc_mt(w, cx, mt); }
-      ty::ty_port(t) { w.write_char('P'); enc_ty(w, cx, t); }
-      ty::ty_chan(t) { w.write_char('C'); enc_ty(w, cx, t); }
       ty::ty_rec(fields) {
         w.write_str("R[");
         for field: ty::field in fields {
@@ -188,7 +186,6 @@ fn enc_sty(w: &io::writer, cx: &@ctxt, st: &ty::sty) {
         w.write_str(uint::str(id));
       }
       ty::ty_type. { w.write_char('Y'); }
-      ty::ty_task. { w.write_char('a'); }
       ty::ty_constr(ty, cs) {
         w.write_str("A[");
         enc_ty(w, cx, ty);

src/comp/middle/gc.rs

@@ -35,8 +35,7 @@ fn type_is_gc_relevant(cx: &ty::ctxt, ty: &ty::t) -> bool {
         ty::ty_nil. | ty::ty_bot. | ty::ty_bool. | ty::ty_int. |
         ty::ty_float. | ty::ty_uint. | ty::ty_machine(_) | ty::ty_char. |
         ty::ty_istr. | ty::ty_type. | ty::ty_native(_) | ty::ty_ptr(_) |
-        ty::ty_port(_) | ty::ty_chan(_) | ty::ty_task. | ty::ty_type. |
-        ty::ty_native(_) {
+        ty::ty_type. | ty::ty_native(_) {
             ret false;
         }
 

src/comp/middle/shape.rs

@@ -357,13 +357,6 @@ fn shape_of(ccx : &@crate_ctxt, t : ty::t) -> [u8] {
         add_size_hint(ccx, s, mt.ty);
         add_substr(s, shape_of(ccx, mt.ty));
       }
-      ty::ty_port(t) {
-        s += ~[shape_port];
-        add_substr(s, shape_of(ccx, t));
-      }
-      ty::ty_chan(t) { s += ~[shape_chan]; }
-      ty::ty_task. { s += ~[shape_task]; }
-
       ty::ty_rec(fields) {
         s += ~[shape_struct];
         let sub = ~[];

src/comp/middle/trans.rs

@@ -220,9 +220,6 @@ fn type_of_inner(cx: &@crate_ctxt, sp: &span, t: &ty::t) -> TypeRef {
         } else { llty = T_ivec(type_of_inner(cx, sp, mt.ty)); }
       }
       ty::ty_ptr(mt) { llty = T_ptr(type_of_inner(cx, sp, mt.ty)); }
-      ty::ty_port(t) { llty = T_ptr(T_port(type_of_inner(cx, sp, t))); }
-      ty::ty_chan(t) { llty = T_ptr(T_chan(type_of_inner(cx, sp, t))); }
-      ty::ty_task. { llty = T_taskptr(*cx); }
       ty::ty_rec(fields) {
         let tys: [TypeRef] = ~[];
         for f: ty::field in fields {
@@ -1255,18 +1252,7 @@ fn make_copy_glue(cx: &@block_ctxt, v: ValueRef, t: &ty::t) {
 
     let bcx;
 
-    if ty::type_is_task(bcx_tcx(cx), t) {
-        let task_ptr = cx.build.Load(v);
-        cx.build.Call(bcx_ccx(cx).upcalls.take_task,
-                      ~[cx.fcx.lltaskptr, task_ptr]);
-        bcx = cx;
-    } else if ty::type_is_chan(bcx_tcx(cx), t) {
-        let ptr = cx.build.Load(v);
-        ptr = cx.build.PointerCast(ptr, T_opaque_chan_ptr());
-        cx.build.Call(bcx_ccx(cx).upcalls.take_chan,
-                      ~[cx.fcx.lltaskptr, ptr]);
-        bcx = cx;
-    } else if ty::type_is_boxed(bcx_tcx(cx), t) {
+    if ty::type_is_boxed(bcx_tcx(cx), t) {
         bcx = incr_refcnt_of_boxed(cx, cx.build.Load(v)).bcx;
     } else if (ty::type_is_structural(bcx_tcx(cx), t)) {
         bcx = duplicate_heap_parts_if_necessary(cx, v, t).bcx;
@@ -1342,21 +1328,6 @@ fn make_free_glue(cx: &@block_ctxt, v0: ValueRef, t: &ty::t) {
           ty::ty_uniq(_) {
             fail "free uniq unimplemented";
           }
-          ty::ty_port(_) {
-            let v = cx.build.Load(v0);
-            cx.build.Call(bcx_ccx(cx).upcalls.del_port,
-                          ~[cx.fcx.lltaskptr,
-                            cx.build.PointerCast(v, T_opaque_port_ptr())]);
-            rslt(cx, C_int(0))
-          }
-          ty::ty_chan(_) {
-            let v = cx.build.Load(v0);
-            cx.build.Call(bcx_ccx(cx).upcalls.del_chan,
-                          ~[cx.fcx.lltaskptr,
-                            cx.build.PointerCast(v, T_opaque_chan_ptr())]);
-            rslt(cx, C_int(0))
-          }
-          ty::ty_task. { rslt(cx, C_nil()) }
           ty::ty_obj(_) {
             let box_cell =
                 cx.build.GEP(v0, ~[C_int(0), C_int(abi::obj_field_box)]);
@@ -1450,20 +1421,6 @@ fn make_drop_glue(cx: &@block_ctxt, v0: ValueRef, t: &ty::t) {
           }
           ty::ty_box(_) { decr_refcnt_maybe_free(cx, v0, v0, t) }
           ty::ty_uniq(_) { fail "drop uniq unimplemented"; }
-          ty::ty_port(_) { decr_refcnt_maybe_free(cx, v0, v0, t) }
-          ty::ty_chan(_) {
-            let ptr = cx.build.Load(v0);
-            ptr = cx.build.PointerCast(ptr, T_opaque_chan_ptr());
-            {bcx: cx,
-             val: cx.build.Call(bcx_ccx(cx).upcalls.drop_chan,
-                                ~[cx.fcx.lltaskptr, ptr])}
-          }
-          ty::ty_task. {
-            let task_ptr = cx.build.Load(v0);
-            {bcx: cx,
-             val: cx.build.Call(bcx_ccx(cx).upcalls.drop_task,
-                                ~[cx.fcx.lltaskptr, task_ptr])}
-          }
           ty::ty_obj(_) {
             let box_cell =
                 cx.build.GEP(v0, ~[C_int(0), C_int(abi::obj_field_box)]);

src/comp/middle/tstate/pre_post_conditions.rs

@@ -356,13 +356,6 @@ fn find_pre_post_expr(fcx: &fn_ctxt, e: @expr) {
           _ { }
         }
       }
-      expr_spawn(_, _, operator, operands) {
-        let /* copy */args = operands;
-        args += ~[operator];
-        find_pre_post_exprs(fcx, args, e.id);
-        forget_args_moved_in(fcx, e, callee_modes(fcx, operator.id),
-                             operands);
-      }
       expr_vec(args, _, _) { find_pre_post_exprs(fcx, args, e.id); }
       expr_path(p) {
         let rslt = expr_pp(fcx.ccx, e);
@@ -374,10 +367,6 @@ fn find_pre_post_expr(fcx: &fn_ctxt, e: @expr) {
         find_pre_post_expr(fcx, arg);
         copy_pre_post(fcx.ccx, e.id, arg);
       }
-      expr_chan(arg) {
-        find_pre_post_expr(fcx, arg);
-        copy_pre_post(fcx.ccx, e.id, arg);
-      }
       expr_put(opt) {
         alt opt {
           some(arg) {
@@ -413,10 +402,6 @@ fn find_pre_post_expr(fcx: &fn_ctxt, e: @expr) {
       expr_move(lhs, rhs) { handle_update(fcx, e, lhs, rhs, oper_move); }
       expr_swap(lhs, rhs) { handle_update(fcx, e, lhs, rhs, oper_swap); }
       expr_assign(lhs, rhs) { handle_update(fcx, e, lhs, rhs, oper_assign); }
-      expr_recv(lhs, rhs) {
-        // note inversion of lhs and rhs
-        handle_update(fcx, e, rhs, lhs, oper_assign);
-      }
       expr_assign_op(_, lhs, rhs) {
         /* Different from expr_assign in that the lhs *must*
            already be initialized */
@@ -460,7 +445,6 @@ fn find_pre_post_expr(fcx: &fn_ctxt, e: @expr) {
                               expr_postcond(fcx.ccx, l));
         } else { find_pre_post_exprs(fcx, ~[l, r], e.id); }
       }
-      expr_send(l, r) { find_pre_post_exprs(fcx, ~[l, r], e.id); }
       expr_unary(_, operand) {
         find_pre_post_expr(fcx, operand);
         copy_pre_post(fcx.ccx, e.id, operand);
@@ -585,7 +569,6 @@ fn find_pre_post_expr(fcx: &fn_ctxt, e: @expr) {
       }
       expr_break. { clear_pp(expr_pp(fcx.ccx, e)); }
       expr_cont. { clear_pp(expr_pp(fcx.ccx, e)); }
-      expr_port(_) { clear_pp(expr_pp(fcx.ccx, e)); }
       expr_mac(_) { fcx.ccx.tcx.sess.bug("unexpanded macro"); }
       expr_anon_obj(anon_obj) {
         alt anon_obj.inner_obj {

src/comp/middle/tstate/states.rs

@@ -323,11 +323,6 @@ fn find_pre_post_state_expr(fcx: &fn_ctxt, pres: &prestate, e: @expr) ->
                                      operands,
                                      controlflow_expr(fcx.ccx, operator));
       }
-      expr_spawn(_, _, operator, operands) {
-        ret find_pre_post_state_call(fcx, pres, operator, e.id,
-                                     callee_arg_init_ops(fcx, operator.id),
-                                     operands, return);
-      }
       expr_bind(operator, maybe_args) {
         let args = ~[];
         let callee_ops = callee_arg_init_ops(fcx, operator.id);
@@ -350,9 +345,6 @@ fn find_pre_post_state_expr(fcx: &fn_ctxt, pres: &prestate, e: @expr) ->
       expr_log(_, ex) {
         ret find_pre_post_state_sub(fcx, pres, ex, e.id, none);
       }
-      expr_chan(ex) {
-        ret find_pre_post_state_sub(fcx, pres, ex, e.id, none);
-      }
       expr_mac(_) { fcx.ccx.tcx.sess.bug("unexpanded macro"); }
       expr_put(maybe_e) {
         alt maybe_e {
@@ -407,19 +399,6 @@ fn find_pre_post_state_expr(fcx: &fn_ctxt, pres: &prestate, e: @expr) ->
         // Could be more precise and actually swap the role of
         // lhs and rhs in constraints
       }
-      expr_recv(lhs, rhs) {
-        // Opposite order as most other binary operations,
-        // so not using find_pre_post_state_two
-        let changed =
-            set_prestate_ann(fcx.ccx, e.id, pres) |
-                find_pre_post_state_expr(fcx, pres, lhs) |
-                find_pre_post_state_expr(fcx, expr_poststate(fcx.ccx, lhs),
-                                         rhs);
-        let post = tritv_clone(expr_poststate(fcx.ccx, rhs));
-        forget_in_poststate_still_init(fcx, post, rhs.id);
-        gen_if_local(fcx, post, rhs);
-        ret changed | set_poststate_ann(fcx.ccx, e.id, post);
-      }
       expr_ret(maybe_ret_val) {
         let changed = set_prestate_ann(fcx.ccx, e.id, pres);
         /* normally, everything is true if execution continues after
@@ -467,9 +446,6 @@ fn find_pre_post_state_expr(fcx: &fn_ctxt, pres: &prestate, e: @expr) ->
             ret find_pre_post_state_two(fcx, pres, l, r, e.id, oper_pure);
         }
       }
-      expr_send(l, r) {
-        ret find_pre_post_state_two(fcx, pres, l, r, e.id, oper_pure);
-      }
       expr_assign_op(op, lhs, rhs) {
         ret find_pre_post_state_two(fcx, pres, lhs, rhs, e.id,
                                     oper_assign_op);
@@ -615,7 +591,6 @@ fn find_pre_post_state_expr(fcx: &fn_ctxt, pres: &prestate, e: @expr) ->
       }
       expr_break. { ret pure_exp(fcx.ccx, e.id, pres); }
       expr_cont. { ret pure_exp(fcx.ccx, e.id, pres); }
-      expr_port(_) { ret pure_exp(fcx.ccx, e.id, pres); }
       expr_self_method(_) { ret pure_exp(fcx.ccx, e.id, pres); }
       expr_anon_obj(anon_obj) {
         alt anon_obj.inner_obj {