From 862bc521a16ac764bee4446f60858459c6e04860 Mon Sep 17 00:00:00 2001
From: Eric Holk <eholk@mozilla.com>
Date: Tue, 16 Aug 2011 10:57:44 -0700
Subject: [PATCH] Removing tasks, ports and chans from the compiler.

---
 src/comp/metadata/tydecode.rs                 |   3 -
 src/comp/metadata/tyencode.rs                 |   3 -
 src/comp/middle/gc.rs                         |   3 +-
 src/comp/middle/shape.rs                      |   7 --
 src/comp/middle/trans.rs                      |  45 +-------
 src/comp/middle/tstate/pre_post_conditions.rs |  17 ---
 src/comp/middle/tstate/states.rs              |  25 ----
 src/comp/middle/ty.rs                         | 107 +-----------------
 src/comp/middle/typeck.rs                     |  54 ---------
 src/comp/syntax/ast.rs                        |   5 -
 src/comp/syntax/fold.rs                       |  14 ---
 src/comp/syntax/parse/parser.rs               |  20 ----
 src/comp/syntax/print/pprust.rs               |  34 ------
 src/comp/syntax/visit.rs                      |   8 --
 src/comp/util/ppaux.rs                        |   3 -
 15 files changed, 7 insertions(+), 341 deletions(-)

diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs
index 402855e34da..95933ffec7f 100644
--- a/src/comp/metadata/tydecode.rs
+++ b/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] = ~[];
diff --git a/src/comp/metadata/tyencode.rs b/src/comp/metadata/tyencode.rs
index c9750dfbb86..2b5345a1e72 100644
--- a/src/comp/metadata/tyencode.rs
+++ b/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);
diff --git a/src/comp/middle/gc.rs b/src/comp/middle/gc.rs
index 401ae47c4c8..a555076a30e 100644
--- a/src/comp/middle/gc.rs
+++ b/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;
         }
 
diff --git a/src/comp/middle/shape.rs b/src/comp/middle/shape.rs
index 784df07ae4b..cf4c9e2f05a 100644
--- a/src/comp/middle/shape.rs
+++ b/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 = ~[];
diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs
index c800b9327b0..54aff99ffd7 100644
--- a/src/comp/middle/trans.rs
+++ b/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)]);
diff --git a/src/comp/middle/tstate/pre_post_conditions.rs b/src/comp/middle/tstate/pre_post_conditions.rs
index a6541f43c71..c3c265b0745 100644
--- a/src/comp/middle/tstate/pre_post_conditions.rs
+++ b/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 {
diff --git a/src/comp/middle/tstate/states.rs b/src/comp/middle/tstate/states.rs
index c990b036cfe..001c5f7d0e7 100644
--- a/src/comp/middle/tstate/states.rs
+++ b/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 {
diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs
index d10ad3d9a08..11341a0b489 100644
--- a/src/comp/middle/ty.rs
+++ b/src/comp/middle/ty.rs
@@ -62,7 +62,6 @@ export method_ty_to_fn_ty;
 export mk_bool;
 export mk_bot;
 export mk_box;
-export mk_chan;
 export mk_char;
 export mk_constr;
 export mk_ctxt;
@@ -81,12 +80,10 @@ export mk_nil;
 export mk_obj;
 export mk_res;
 export mk_param;
-export mk_port;
 export mk_ptr;
 export mk_rec;
 export mk_str;
 export mk_tag;
-export mk_task;
 export mk_tup;
 export mk_type;
 export mk_uint;
@@ -123,7 +120,6 @@ export ty_native_fn;
 export ty_bool;
 export ty_bot;
 export ty_box;
-export ty_chan;
 export ty_char;
 export ty_constr;
 export ty_constr_arg;
@@ -141,12 +137,10 @@ export ty_nil;
 export ty_obj;
 export ty_res;
 export ty_param;
-export ty_port;
 export ty_ptr;
 export ty_rec;
 export ty_str;
 export ty_tag;
-export ty_task;
 export ty_tup;
 export ty_type;
 export ty_uint;
@@ -169,8 +163,6 @@ export type_is_bool;
 export type_is_bot;
 export type_is_box;
 export type_is_boxed;
-export type_is_chan;
-export type_is_task;
 export type_is_fp;
 export type_is_integral;
 export type_is_native;
@@ -273,9 +265,6 @@ tag sty {
     ty_vec(mt);
     ty_ivec(mt);
     ty_ptr(mt);
-    ty_port(t);
-    ty_chan(t);
-    ty_task;
     ty_rec([field]);
     ty_fn(ast::proto, [arg], t, controlflow, [@constr]);
     ty_native_fn(ast::native_abi, [arg], t);
@@ -356,13 +345,11 @@ const idx_str: uint = 16u;
 
 const idx_istr: uint = 17u;
 
-const idx_task: uint = 18u;
+const idx_type: uint = 18u;
 
-const idx_type: uint = 19u;
+const idx_bot: uint = 19u;
 
-const idx_bot: uint = 20u;
-
-const idx_first_others: uint = 21u;
+const idx_first_others: uint = 20u;
 
 type type_store = interner::interner[@raw_t];
 
@@ -390,7 +377,6 @@ fn populate_type_store(cx: &ctxt) {
     intern(cx, ty_char, none);
     intern(cx, ty_str, none);
     intern(cx, ty_istr, none);
-    intern(cx, ty_task, none);
     intern(cx, ty_type, none);
     intern(cx, ty_bot, none);
     assert (vec::len(cx.ts.vect) == idx_first_others);
@@ -469,7 +455,6 @@ fn mk_raw_ty(cx: &ctxt, st: &sty, in_cname: &option::t[str]) -> @raw_t {
       ty_char. {/* no-op */ }
       ty_str. {/* no-op */ }
       ty_istr. {/* no-op */ }
-      ty_task. {/* no-op */ }
       ty_type. {/* no-op */ }
       ty_native(_) {/* no-op */ }
       ty_param(_,_) { has_params = true; }
@@ -482,8 +467,6 @@ fn mk_raw_ty(cx: &ctxt, st: &sty, in_cname: &option::t[str]) -> @raw_t {
       ty_vec(m) { derive_flags_mt(cx, has_params, has_vars, m); }
       ty_ivec(m) { derive_flags_mt(cx, has_params, has_vars, m); }
       ty_ptr(m) { derive_flags_mt(cx, has_params, has_vars, m); }
-      ty_port(tt) { derive_flags_t(cx, has_params, has_vars, tt); }
-      ty_chan(tt) { derive_flags_t(cx, has_params, has_vars, tt); }
       ty_rec(flds) {
         for f: field in flds {
             derive_flags_mt(cx, has_params, has_vars, f.mt);
@@ -591,12 +574,6 @@ fn mk_imm_vec(cx: &ctxt, typ: &t) -> t {
     ret gen_ty(cx, ty_vec({ty: typ, mut: ast::imm}));
 }
 
-fn mk_port(cx: &ctxt, ty: &t) -> t { ret gen_ty(cx, ty_port(ty)); }
-
-fn mk_chan(cx: &ctxt, ty: &t) -> t { ret gen_ty(cx, ty_chan(ty)); }
-
-fn mk_task(cx: &ctxt) -> t { ret gen_ty(cx, ty_task); }
-
 fn mk_rec(cx: &ctxt, fs: &[field]) -> t { ret gen_ty(cx, ty_rec(fs)); }
 
 fn mk_constr(cx: &ctxt, t: &t, cs: &[@type_constr]) -> t {
@@ -664,14 +641,11 @@ fn walk_ty(cx: &ctxt, walker: ty_walk, ty: t) {
       ty_str. {/* no-op */ }
       ty_istr. {/* no-op */ }
       ty_type. {/* no-op */ }
-      ty_task. {/* no-op */ }
       ty_native(_) {/* no-op */ }
       ty_box(tm) { walk_ty(cx, walker, tm.ty); }
       ty_vec(tm) { walk_ty(cx, walker, tm.ty); }
       ty_ivec(tm) { walk_ty(cx, walker, tm.ty); }
       ty_ptr(tm) { walk_ty(cx, walker, tm.ty); }
-      ty_port(subty) { walk_ty(cx, walker, subty); }
-      ty_chan(subty) { walk_ty(cx, walker, subty); }
       ty_tag(tid, subtys) {
         for subty: t in subtys { walk_ty(cx, walker, subty); }
       }
@@ -737,7 +711,6 @@ fn fold_ty(cx: &ctxt, fld: fold_mode, ty_0: t) -> t {
       ty_istr. {/* no-op */ }
       ty_type. {/* no-op */ }
       ty_native(_) {/* no-op */ }
-      ty_task. {/* no-op */ }
       ty_box(tm) {
         ty = mk_box(cx, {ty: fold_ty(cx, fld, tm.ty), mut: tm.mut});
       }
@@ -751,8 +724,6 @@ fn fold_ty(cx: &ctxt, fld: fold_mode, ty_0: t) -> t {
       ty_ivec(tm) {
         ty = mk_ivec(cx, {ty: fold_ty(cx, fld, tm.ty), mut: tm.mut});
       }
-      ty_port(subty) { ty = mk_port(cx, fold_ty(cx, fld, subty)); }
-      ty_chan(subty) { ty = mk_chan(cx, fold_ty(cx, fld, subty)); }
       ty_tag(tid, subtys) {
         let new_subtys: [t] = ~[];
         for subty: t in subtys { new_subtys += ~[fold_ty(cx, fld, subty)]; }
@@ -862,14 +833,6 @@ fn type_is_bool(cx: &ctxt, ty: &t) -> bool {
     alt struct(cx, ty) { ty_bool. { ret true; } _ { ret false; } }
 }
 
-fn type_is_chan(cx: &ctxt, ty: &t) -> bool {
-    alt struct(cx, ty) { ty_chan(_) { ret true; } _ { ret false; } }
-}
-
-fn type_is_task(cx: &ctxt, ty: &t) -> bool {
-    alt struct(cx, ty) { ty_task. { ret true; } _ { ret false; } }
-}
-
 fn type_is_structural(cx: &ctxt, ty: &t) -> bool {
     alt struct(cx, ty) {
       ty_rec(_) { ret true; }
@@ -967,9 +930,6 @@ fn type_is_boxed(cx: &ctxt, ty: &t) -> bool {
       ty_str. { ret true; }
       ty_vec(_) { ret true; }
       ty_box(_) { ret true; }
-      ty_port(_) { ret true; }
-      ty_chan(_) { ret true; }
-      ty_task. { ret true; }
       _ { ret false; }
     }
 }
@@ -1083,7 +1043,7 @@ fn type_kind(cx: &ctxt, ty: &t) -> ast::kind {
       }
 
       // Those things with refcounts-to-interior are just shared.
-      ty_str. | ty_task. {
+      ty_str. {
         result = kind_shared;
       }
 
@@ -1107,18 +1067,6 @@ fn type_kind(cx: &ctxt, ty: &t) -> ast::kind {
         result = ast::kind_shared;
       }
 
-      // FIXME: remove ports. Ports currently contribute 'shared'
-      ty_port(t) {
-        result = kind::lower_kind(ast::kind_shared,
-                                  type_kind(cx, t));
-      }
-
-      // FIXME: remove chans. Chans currently contribute only
-      // their inner.
-      ty_chan(t) {
-        result = type_kind(cx, t);
-      }
-
       // Pointers and unique boxes / vecs raise pinned to shared,
       // otherwise pass through their pointee kind.
       ty_ptr(tm) | ty_ivec(tm) {
@@ -1205,9 +1153,6 @@ fn type_has_dynamic_size(cx: &ctxt, ty: &t) -> bool {
       ty_vec(_) { ret false; }
       ty_ivec(mt) { ret type_has_dynamic_size(cx, mt.ty); }
       ty_ptr(_) { ret false; }
-      ty_port(_) { ret false; }
-      ty_chan(_) { ret false; }
-      ty_task. { ret false; }
       ty_rec(fields) {
         let i = 0u;
         while i < vec::len[field](fields) {
@@ -1357,9 +1302,6 @@ fn type_owns_heap_mem(cx: &ctxt, ty: &t) -> bool {
       ty_ptr(_) {
         result = false;
       }
-      ty_port(_) { result = false; }
-      ty_chan(_) { result = false; }
-      ty_task. { result = false; }
       ty_var(_) { fail "ty_var in type_owns_heap_mem"; }
       ty_param(_,_) { result = false; }
     }
@@ -1380,8 +1322,7 @@ fn type_is_pod(cx : &ctxt, ty : &t) -> bool {
 
         // Boxed types
         ty_str. | ty_istr. | ty_box(_) | ty_vec(_) | ty_ivec(_) |
-        ty_fn(_,_,_,_,_) | ty_native_fn(_,_,_) | ty_obj(_) | ty_port(_) |
-        ty_chan(_) | ty_task. { result = false; }
+        ty_fn(_,_,_,_,_) | ty_native_fn(_,_,_) | ty_obj(_) { result = false; }
 
         // Structural types
         ty_tag(did, tps) {
@@ -1545,9 +1486,6 @@ fn hash_type_structure(st: &sty) -> uint {
       ty_box(mt) { ret hash_subty(19u, mt.ty); }
       ty_vec(mt) { ret hash_subty(20u, mt.ty); }
       ty_ivec(mt) { ret hash_subty(21u, mt.ty); }
-      ty_port(typ) { ret hash_subty(22u, typ); }
-      ty_chan(typ) { ret hash_subty(23u, typ); }
-      ty_task. { ret 24u; }
       ty_rec(fields) {
         let h = 26u;
         for f: field in fields { h += h << 5u + hash_ty(f.mt.ty); }
@@ -1717,13 +1655,6 @@ fn equal_type_structures(a: &sty, b: &sty) -> bool {
       ty_ptr(mt_a) {
         alt b { ty_ptr(mt_b) { ret equal_mt(mt_a, mt_b); } _ { ret false; } }
       }
-      ty_port(t_a) {
-        alt b { ty_port(t_b) { ret eq_ty(t_a, t_b); } _ { ret false; } }
-      }
-      ty_chan(t_a) {
-        alt b { ty_chan(t_b) { ret eq_ty(t_a, t_b); } _ { ret false; } }
-      }
-      ty_task. { alt b { ty_task. { ret true; } _ { ret false; } } }
       ty_rec(flds_a) {
         alt b {
           ty_rec(flds_b) {
@@ -2626,20 +2557,6 @@ mod unify {
               _ { ret ures_err(terr_mismatch); }
             }
           }
-          ty::ty_port(expected_sub) {
-            alt struct(cx.tcx, actual) {
-              ty::ty_port(actual_sub) {
-                let result = unify_step(cx, expected_sub, actual_sub);
-                alt result {
-                  ures_ok(result_sub) {
-                    ret ures_ok(mk_port(cx.tcx, result_sub));
-                  }
-                  _ { ret result; }
-                }
-              }
-              _ { ret ures_err(terr_mismatch); }
-            }
-          }
           ty::ty_res(ex_id, ex_inner, ex_tps) {
             alt struct(cx.tcx, actual) {
               ty::ty_res(act_id, act_inner, act_tps) {
@@ -2667,20 +2584,6 @@ mod unify {
               _ { ret ures_err(terr_mismatch); }
             }
           }
-          ty::ty_chan(expected_sub) {
-            alt struct(cx.tcx, actual) {
-              ty::ty_chan(actual_sub) {
-                let result = unify_step(cx, expected_sub, actual_sub);
-                alt result {
-                  ures_ok(result_sub) {
-                    ret ures_ok(mk_chan(cx.tcx, result_sub));
-                  }
-                  _ { ret result; }
-                }
-              }
-              _ { ret ures_err(terr_mismatch); }
-            }
-          }
           ty::ty_rec(expected_fields) {
             alt struct(cx.tcx, actual) {
               ty::ty_rec(actual_fields) {
diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs
index f73138b65f1..eeeebc7e9b8 100644
--- a/src/comp/middle/typeck.rs
+++ b/src/comp/middle/typeck.rs
@@ -333,13 +333,6 @@ fn ast_ty_to_ty(tcx: &ty::ctxt, getter: &ty_getter, ast_ty: &@ast::ty) ->
       ast::ty_ptr(mt) {
         typ = ty::mk_ptr(tcx, ast_mt_to_mt(tcx, getter, mt));
       }
-      ast::ty_task. { typ = ty::mk_task(tcx); }
-      ast::ty_port(t) {
-        typ = ty::mk_port(tcx, ast_ty_to_ty(tcx, getter, t));
-      }
-      ast::ty_chan(t) {
-        typ = ty::mk_chan(tcx, ast_ty_to_ty(tcx, getter, t));
-      }
       ast::ty_tup(fields) {
         let flds = vec::map(bind ast_ty_to_ty(tcx, getter, _), fields);
         typ = ty::mk_tup(tcx, flds);
@@ -1984,22 +1977,6 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
         check_binop_type_compat(fcx, expr.span, expr_ty(tcx, lhs),
                                 op);
       }
-      ast::expr_send(lhs, rhs) {
-        require_impure(tcx.sess, fcx.purity, expr.span);
-        let rhs_t = next_ty_var(fcx);
-        let chan_t = ty::mk_chan(tcx, rhs_t);
-        bot = check_expr_with(fcx, lhs, chan_t) |
-              check_expr_with(fcx, rhs, rhs_t);
-        write::ty_only_fixup(fcx, id, chan_t);
-      }
-      ast::expr_recv(lhs, rhs) {
-        require_impure(tcx.sess, fcx.purity, expr.span);
-        let rhs_t = next_ty_var(fcx);
-        let port_t = ty::mk_port(tcx, rhs_t);
-        bot = check_expr_with(fcx, lhs, port_t) |
-              check_expr_with(fcx, rhs, rhs_t);
-        write::ty_only_fixup(fcx, id, rhs_t);
-      }
       ast::expr_if(cond, thn, elsopt) {
         bot = check_expr_with(fcx, cond, ty::mk_bool(tcx)) |
               check_then_else(fcx, thn, elsopt, id, expr.span);
@@ -2187,28 +2164,6 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
         write::ty_only_fixup(fcx, id, t);
         require_impure(tcx.sess, fcx.purity, expr.span);
       }
-      ast::expr_spawn(_, _, f, args) {
-        bot = check_call(fcx, expr.span, f, args, kind_spawn);
-        let fty = expr_ty(tcx, f);
-        let ret_ty = alt structure_of(fcx, expr.span, fty) {
-          ty::ty_fn(_, _, rt, _, _) { rt }
-          ty::ty_native_fn(_, _, rt) { rt }
-          _ { fail "LHS of spawn expr didn't have a function type?!" }
-        };
-
-        demand::simple(fcx, f.span, ty::mk_nil(tcx), ret_ty);
-
-        // make sure they aren't spawning a function with type params
-        if ty::expr_has_ty_params(tcx, f) {
-            tcx.sess.span_fatal(
-                f.span,
-                "spawning functions with type params not allowed (for now)");
-        }
-
-        // FIXME: Other typechecks needed
-        let typ = ty::mk_task(tcx);
-        write::ty_only_fixup(fcx, id, typ);
-      }
       ast::expr_cast(e, t) {
         bot = check_expr(fcx, e);
         let t_1 = ast_ty_to_ty_crate(fcx.ccx, t);
@@ -2360,15 +2315,6 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr,
           }
         }
       }
-      ast::expr_port(typ) {
-        let pt = ty::mk_port(tcx, ast_ty_to_ty_crate_tyvar(fcx, typ));
-        write::ty_only_fixup(fcx, id, pt);
-      }
-      ast::expr_chan(x) {
-        let t = next_ty_var(fcx);
-        check_expr_with(fcx, x, ty::mk_port(tcx, t));
-        write::ty_only_fixup(fcx, id, ty::mk_chan(tcx, t));
-      }
       ast::expr_anon_obj(ao) {
         let fields: [ast::anon_obj_field] = ~[];
         alt ao.fields { none. { } some(v) { fields = v; } }
diff --git a/src/comp/syntax/ast.rs b/src/comp/syntax/ast.rs
index bed8ce31c4c..53e00e8c6b4 100644
--- a/src/comp/syntax/ast.rs
+++ b/src/comp/syntax/ast.rs
@@ -298,7 +298,6 @@ tag expr_ {
     expr_tup([@expr]);
     expr_self_method(ident);
     expr_bind(@expr, [option::t[@expr]]);
-    expr_spawn(spawn_dom, option::t[str], @expr, [@expr]);
     expr_binary(binop, @expr, @expr);
     expr_unary(unop, @expr);
     expr_lit(@lit);
@@ -321,8 +320,6 @@ tag expr_ {
     expr_assign(@expr, @expr);
     expr_swap(@expr, @expr);
     expr_assign_op(binop, @expr, @expr);
-    expr_send(@expr, @expr);
-    expr_recv(@expr, @expr);
     expr_field(@expr, ident);
     expr_index(@expr, @expr);
     expr_path(path);
@@ -340,8 +337,6 @@ tag expr_ {
     /* FIXME Would be nice if expr_check desugared
        to expr_if_check. */
     expr_if_check(@expr, blk, option::t[@expr]);
-    expr_port(@ty);
-    expr_chan(@expr);
     expr_anon_obj(anon_obj);
     expr_mac(mac);
     expr_uniq(@expr);
diff --git a/src/comp/syntax/fold.rs b/src/comp/syntax/fold.rs
index 94dca5ef4cf..9cf9bf3e8b4 100644
--- a/src/comp/syntax/fold.rs
+++ b/src/comp/syntax/fold.rs
@@ -357,10 +357,6 @@ fn noop_fold_expr(e: &expr_, fld: ast_fold) -> expr_ {
             let opt_map_se = bind option::map(fld.fold_expr, _);
             expr_bind(fld.fold_expr(f), vec::map(opt_map_se, args))
           }
-          expr_spawn(spawn_dom, name, f, args) {
-            expr_spawn(spawn_dom, name, fld.fold_expr(f),
-                       fld.map_exprs(fld.fold_expr, args))
-          }
           expr_binary(binop, lhs, rhs) {
             expr_binary(binop, fld.fold_expr(lhs), fld.fold_expr(rhs))
           }
@@ -409,12 +405,6 @@ fn noop_fold_expr(e: &expr_, fld: ast_fold) -> expr_ {
           expr_assign_op(op, el, er) {
             expr_assign_op(op, fld.fold_expr(el), fld.fold_expr(er))
           }
-          expr_send(el, er) {
-            expr_send(fld.fold_expr(el), fld.fold_expr(er))
-          }
-          expr_recv(el, er) {
-            expr_recv(fld.fold_expr(el), fld.fold_expr(er))
-          }
           expr_field(el, id) {
             expr_field(fld.fold_expr(el), fld.fold_ident(id))
           }
@@ -435,10 +425,6 @@ fn noop_fold_expr(e: &expr_, fld: ast_fold) -> expr_ {
             expr_if_check(fld.fold_expr(cond), fld.fold_block(tr),
                           option::map(fld.fold_expr, fl))
           }
-          expr_port(t) {
-            expr_port(fld.fold_ty(t))
-          }
-          expr_chan(e) { expr_chan(fld.fold_expr(e)) }
           expr_anon_obj(ao) { expr_anon_obj(fold_anon_obj(ao)) }
           expr_mac(mac) { expr_mac(fold_mac(mac)) }
           expr_uniq(e) { expr_uniq(fld.fold_expr(e)) }
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index 2d61f6b214a..780d67b4b27 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -1351,21 +1351,6 @@ fn parse_alt_expr(p: &parser) -> @ast::expr {
     ret mk_expr(p, lo, hi, ast::expr_alt(discriminant, arms));
 }
 
-fn parse_spawn_expr(p: &parser) -> @ast::expr {
-    let lo = p.get_last_lo_pos();
-    // FIXME: Parse domain and name
-    // FIXME: why no full expr?
-
-    let fn_expr = parse_bottom_expr(p);
-    let es =
-        parse_seq(token::LPAREN, token::RPAREN, some(token::COMMA),
-                  parse_expr, p);
-    let hi = es.span.hi;
-    ret mk_expr(p, lo, hi,
-                ast::expr_spawn(ast::dom_implicit, option::none, fn_expr,
-                                es.node));
-}
-
 fn parse_expr(p: &parser) -> @ast::expr {
     ret parse_expr_res(p, UNRESTRICTED);
 }
@@ -1614,7 +1599,6 @@ fn stmt_ends_with_semi(stmt: &ast::stmt) -> bool {
               ast::expr_call(_, _) { true }
               ast::expr_self_method(_) { false }
               ast::expr_bind(_, _) { true }
-              ast::expr_spawn(_, _, _, _) { true }
               ast::expr_binary(_, _, _) { true }
               ast::expr_unary(_, _) { true }
               ast::expr_lit(_) { true }
@@ -1632,8 +1616,6 @@ fn stmt_ends_with_semi(stmt: &ast::stmt) -> bool {
               ast::expr_assign(_, _) { true }
               ast::expr_swap(_, _) { true }
               ast::expr_assign_op(_, _, _) { true }
-              ast::expr_send(_, _) { true }
-              ast::expr_recv(_, _) { true }
               ast::expr_field(_, _) { true }
               ast::expr_index(_, _) { true }
               ast::expr_path(_) { true }
@@ -1647,8 +1629,6 @@ fn stmt_ends_with_semi(stmt: &ast::stmt) -> bool {
               ast::expr_log(_, _) { true }
               ast::expr_check(_, _) { true }
               ast::expr_if_check(_, _, _) { false }
-              ast::expr_port(_) { true }
-              ast::expr_chan(_) { true }
               ast::expr_anon_obj(_) { false }
               ast::expr_assert(_) { true }
             }
diff --git a/src/comp/syntax/print/pprust.rs b/src/comp/syntax/print/pprust.rs
index 437b9652261..c3291314c70 100644
--- a/src/comp/syntax/print/pprust.rs
+++ b/src/comp/syntax/print/pprust.rs
@@ -783,13 +783,6 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
         commasep(s, inconsistent, args, print_opt);
         pclose(s);
       }
-      ast::expr_spawn(_, _, e, es) {
-        word_nbsp(s, "spawn");
-        print_expr(s, e);
-        popen(s);
-        commasep_exprs(s, inconsistent, es);
-        pclose(s);
-      }
       ast::expr_binary(op, lhs, rhs) {
         let prec = operator_prec(op);
         print_maybe_parens(s, lhs, prec);
@@ -928,18 +921,6 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
         word_space(s, "=");
         print_expr(s, rhs);
       }
-      ast::expr_send(lhs, rhs) {
-        print_expr(s, lhs);
-        space(s.s);
-        word_space(s, "<|");
-        print_expr(s, rhs);
-      }
-      ast::expr_recv(lhs, rhs) {
-        print_expr(s, lhs);
-        space(s.s);
-        word_space(s, "|>");
-        print_expr(s, rhs);
-      }
       ast::expr_field(expr, id) {
         print_expr_parens_if_unary(s, expr);
         word(s.s, ".");
@@ -997,21 +978,6 @@ fn print_expr(s: &ps, expr: &@ast::expr) {
         pclose(s);
       }
       ast::expr_mac(m) { print_mac(s, m); }
-      ast::expr_port(t) {
-        word(s.s, "port");
-        alt t.node {
-          ast::ty_infer. { }
-          _ { word(s.s, "["); print_type(s, t); word(s.s, "]"); }
-        }
-        popen(s);
-        pclose(s);
-      }
-      ast::expr_chan(expr) {
-        word(s.s, "chan");
-        popen(s);
-        print_expr(s, expr);
-        pclose(s);
-      }
       ast::expr_anon_obj(anon_obj) {
         head(s, "obj");
 
diff --git a/src/comp/syntax/visit.rs b/src/comp/syntax/visit.rs
index c4f6395c72f..2f259ddcc30 100644
--- a/src/comp/syntax/visit.rs
+++ b/src/comp/syntax/visit.rs
@@ -262,10 +262,6 @@ fn visit_expr[E](ex: &@expr, e: &E, v: &vt[E]) {
         v.visit_expr(callee, e, v);
         for eo: option::t[@expr] in args { visit_expr_opt(eo, e, v); }
       }
-      expr_spawn(_, _, callee, args) {
-        v.visit_expr(callee, e, v);
-        visit_exprs(args, e, v);
-      }
       expr_binary(_, a, b) { v.visit_expr(a, e, v); v.visit_expr(b, e, v); }
       expr_unary(_, a) { v.visit_expr(a, e, v); }
       expr_lit(_) { }
@@ -306,8 +302,6 @@ fn visit_expr[E](ex: &@expr, e: &E, v: &vt[E]) {
         v.visit_expr(b, e, v);
         v.visit_expr(a, e, v);
       }
-      expr_send(a, b) { v.visit_expr(a, e, v); v.visit_expr(b, e, v); }
-      expr_recv(a, b) { v.visit_expr(a, e, v); v.visit_expr(b, e, v); }
       expr_field(x, _) { v.visit_expr(x, e, v); }
       expr_index(a, b) { v.visit_expr(a, e, v); v.visit_expr(b, e, v); }
       expr_path(p) { for tp: @ty in p.node.types { v.visit_ty(tp, e, v); } }
@@ -320,8 +314,6 @@ fn visit_expr[E](ex: &@expr, e: &E, v: &vt[E]) {
       expr_log(_, x) { v.visit_expr(x, e, v); }
       expr_check(_, x) { v.visit_expr(x, e, v); }
       expr_assert(x) { v.visit_expr(x, e, v); }
-      expr_port(t) { v.visit_ty(t, e, v); }
-      expr_chan(x) { v.visit_expr(x, e, v); }
       expr_anon_obj(anon_obj) {
         alt anon_obj.fields {
           none. { }
diff --git a/src/comp/util/ppaux.rs b/src/comp/util/ppaux.rs
index 016056152a2..4b1c3a8ad76 100644
--- a/src/comp/util/ppaux.rs
+++ b/src/comp/util/ppaux.rs
@@ -94,10 +94,7 @@ fn ty_to_str(cx: &ctxt, typ: &t) -> str {
       ty_uniq(t) { s += "~" + ty_to_str(cx, t); }
       ty_vec(tm) { s += "vec[" + mt_to_str(cx, tm) + "]"; }
       ty_ivec(tm) { s += "[" + mt_to_str(cx, tm) + "]"; }
-      ty_port(t) { s += "port[" + ty_to_str(cx, t) + "]"; }
-      ty_chan(t) { s += "chan[" + ty_to_str(cx, t) + "]"; }
       ty_type. { s += "type"; }
-      ty_task. { s += "task"; }
       ty_rec(elems) {
         let strs: [str] = ~[];
         for fld: field in elems { strs += ~[field_to_str(cx, fld)]; }