diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs
index a1981e1d2832..ded36db2cf8c 100644
--- a/src/comp/driver/rustc.rs
+++ b/src/comp/driver/rustc.rs
@@ -108,7 +108,7 @@ fn parse_input_src(sess: session::session, cfg: &ast::crate_cfg, infile: str)
     ret {crate: crate, src: src};
 }
 
-fn time<T>(do_it: bool, what: str, thunk: fn() -> T) -> T {
+fn time<@T>(do_it: bool, what: str, thunk: fn() -> T) -> T {
     if !do_it { ret thunk(); }
     let start = std::time::precise_time_s();
     let rv = thunk();
diff --git a/src/comp/front/attr.rs b/src/comp/front/attr.rs
index e199d10fbd18..5701ff33f975 100644
--- a/src/comp/front/attr.rs
+++ b/src/comp/front/attr.rs
@@ -189,7 +189,7 @@ fn require_unique_names(sess: &session::session, metas: &[@ast::meta_item]) {
     }
 }
 
-fn span<T>(item: &T) -> ast::spanned<T> {
+fn span<@T>(item: &T) -> ast::spanned<T> {
     ret {node: item, span: ast_util::dummy_sp()};
 }
 
diff --git a/src/comp/front/test.rs b/src/comp/front/test.rs
index d9cda6e601ad..8e0b71caf848 100644
--- a/src/comp/front/test.rs
+++ b/src/comp/front/test.rs
@@ -170,7 +170,7 @@ fn mk_test_module(cx: &test_ctxt) -> @ast::item {
     ret @item;
 }
 
-fn nospan<T>(t: &T) -> ast::spanned<T> {
+fn nospan<@T>(t: &T) -> ast::spanned<T> {
     ret {node: t, span: dummy_sp()};
 }
 
diff --git a/src/comp/middle/kind.rs b/src/comp/middle/kind.rs
index 4ffdcc95ff3f..9a0d251e44e9 100644
--- a/src/comp/middle/kind.rs
+++ b/src/comp/middle/kind.rs
@@ -76,6 +76,7 @@ import syntax::ast_util;
 import syntax::visit;
 
 import std::vec;
+import std::option;
 
 import ast::kind;
 import ast::kind_unique;
@@ -135,7 +136,20 @@ fn check_expr(tcx: &ty::ctxt, e: &@ast::expr) {
     alt e.node {
       ast::expr_move(a, b) { need_shared_lhs_rhs(tcx, a, b, "<-"); }
       ast::expr_assign(a, b) { need_shared_lhs_rhs(tcx, a, b, "="); }
+      ast::expr_assign_op(_, a, b) { need_shared_lhs_rhs(tcx, a, b, "op="); }
       ast::expr_swap(a, b) { need_shared_lhs_rhs(tcx, a, b, "<->"); }
+      ast::expr_copy(a) {
+        need_expr_kind(tcx, a, ast::kind_shared, "'copy' operand");
+      }
+      ast::expr_ret(option::some(a)) {
+        need_expr_kind(tcx, a, ast::kind_shared, "'ret' operand");
+      }
+      ast::expr_be(a) {
+        need_expr_kind(tcx, a, ast::kind_shared, "'be' operand");
+      }
+      ast::expr_fail(option::some(a)) {
+        need_expr_kind(tcx, a, ast::kind_shared, "'fail' operand");
+      }
       ast::expr_call(callee, _) {
         let tpt = ty::expr_ty_params_and_ty(tcx, callee);
 
diff --git a/src/comp/syntax/ast_util.rs b/src/comp/syntax/ast_util.rs
index e3b16702b762..e89889fa0276 100644
--- a/src/comp/syntax/ast_util.rs
+++ b/src/comp/syntax/ast_util.rs
@@ -3,7 +3,7 @@ import std::option;
 import codemap::span;
 import ast::*;
 
-fn respan<T>(sp: &span, t: &T) -> spanned<T> { ret {node: t, span: sp}; }
+fn respan<@T>(sp: &span, t: &T) -> spanned<T> { ret {node: t, span: sp}; }
 
 /* assuming that we're not in macro expansion */
 fn mk_sp(lo: uint, hi: uint) -> span {
diff --git a/src/comp/syntax/parse/parser.rs b/src/comp/syntax/parse/parser.rs
index 495d1372d79b..aa553e32e394 100644
--- a/src/comp/syntax/parse/parser.rs
+++ b/src/comp/syntax/parse/parser.rs
@@ -222,7 +222,7 @@ fn expect_gt(p: &parser) {
     }
 }
 
-fn spanned<T>(lo: uint, hi: uint, node: &T) -> spanned<T> {
+fn spanned<@T>(lo: uint, hi: uint, node: &T) -> spanned<T> {
     ret {node: node, span: ast_util::mk_sp(lo, hi)};
 }
 
diff --git a/src/comp/syntax/util/interner.rs b/src/comp/syntax/util/interner.rs
index 31656886a453..3d1a495fb2ee 100644
--- a/src/comp/syntax/util/interner.rs
+++ b/src/comp/syntax/util/interner.rs
@@ -33,7 +33,7 @@ fn intern<@T>(itr: &interner<T>, val: &T) -> uint {
     }
 }
 
-fn get<T>(itr: &interner<T>, idx: uint) -> T { ret itr.vect[idx]; }
+fn get<@T>(itr: &interner<T>, idx: uint) -> T { ret itr.vect[idx]; }
 
 fn len<T>(itr: &interner<T>) -> uint { ret vec::len(itr.vect); }
 
diff --git a/src/lib/task.rs b/src/lib/task.rs
index 2e88f12f6c0f..52181528b4fd 100644
--- a/src/lib/task.rs
+++ b/src/lib/task.rs
@@ -38,10 +38,6 @@ type task_context = {regs: x86_registers, next: *u8};
 
 resource rust_task_ptr(task: *rust_task) { rustrt::drop_task(task); }
 
-fn get_task_ptr(id: task) -> rust_task_ptr {
-    ret rust_task_ptr(rustrt::get_task_pointer(id));
-}
-
 type task = int;
 type task_id = task;
 
@@ -107,7 +103,7 @@ fn spawn_inner(thunk: -fn(), notify: option<comm::chan<task_notification>>) ->
     // stack.
 
     // set up the task pointer
-    let task_ptr = get_task_ptr(id);
+    let task_ptr = rust_task_ptr(rustrt::get_task_pointer(id));
     let regs = ptr::addr_of((**task_ptr).ctx.regs);
     (*regs).edx = cast(*task_ptr);;
     (*regs).esp = cast((**task_ptr).stack_ptr);
diff --git a/src/lib/unsafe.rs b/src/lib/unsafe.rs
index 6e1b4b3b7c3b..0d382655b419 100644
--- a/src/lib/unsafe.rs
+++ b/src/lib/unsafe.rs
@@ -9,7 +9,7 @@ native "rust" mod rustrt {
 }
 
 // Casts the value at `src` to U. The two types must have the same length.
-fn reinterpret_cast<T, U>(src: &T) -> U { ret rusti::cast(src); }
+fn reinterpret_cast<T, @U>(src: &T) -> U { ret rusti::cast(src); }
 
 fn leak<@T>(thing: -T) {
     rustrt::leak(thing);
diff --git a/src/lib/util.rs b/src/lib/util.rs
index 24a14b1fa921..6041da4d0d0d 100644
--- a/src/lib/util.rs
+++ b/src/lib/util.rs
@@ -1,6 +1,6 @@
 
 
-fn id<T>(x: &T) -> T { ret x; }
+fn id<@T>(x: &T) -> T { ret x; }
 
 
 /* FIXME (issue #141):  See test/run-pass/constrained-type.rs.  Uncomment
diff --git a/src/test/compile-fail/block-copy.rs b/src/test/compile-fail/block-copy.rs
index 6a6c708cf881..76b05792f2fc 100644
--- a/src/test/compile-fail/block-copy.rs
+++ b/src/test/compile-fail/block-copy.rs
@@ -1,4 +1,4 @@
-// error-pattern: non-copyable
+// error-pattern: mismatched kinds
 
 fn lol(f: &block()) -> block() { ret f; }
 fn main() { let i = 8; let f = lol(block () { log_err i; }); f(); }
diff --git a/src/test/compiletest/procsrv.rs b/src/test/compiletest/procsrv.rs
index 6e464038b185..efbc26f669a5 100644
--- a/src/test/compiletest/procsrv.rs
+++ b/src/test/compiletest/procsrv.rs
@@ -150,7 +150,7 @@ fn worker(p: port<request>) {
     }
 }
 
-fn with_lib_path<T>(path: &str, f: fn() -> T) -> T {
+fn with_lib_path<@T>(path: &str, f: fn() -> T) -> T {
     let maybe_oldpath = getenv(util::lib_path_env_var());
     append_lib_path(path);
     let res = f();
diff --git a/src/test/run-pass/auto-instantiate.rs b/src/test/run-pass/auto-instantiate.rs
index f8d9ebbb587e..e06da60789c3 100644
--- a/src/test/run-pass/auto-instantiate.rs
+++ b/src/test/run-pass/auto-instantiate.rs
@@ -2,6 +2,6 @@
 
 
 // -*- rust -*-
-fn f<T, U>(x: &T, y: &U) -> {a: T, b: U} { ret {a: x, b: y}; }
+fn f<@T, @U>(x: &T, y: &U) -> {a: T, b: U} { ret {a: x, b: y}; }
 
 fn main() { log f({x: 3, y: 4, z: 5}, 4).a.x; log f(5, 6).a; }
diff --git a/src/test/run-pass/autobind.rs b/src/test/run-pass/autobind.rs
index 536db525d5c9..ebf2bd432d4e 100644
--- a/src/test/run-pass/autobind.rs
+++ b/src/test/run-pass/autobind.rs
@@ -1,4 +1,4 @@
-fn f<T>(x: &[T]) -> T { ret x[0]; }
+fn f<@T>(x: &[T]) -> T { ret x[0]; }
 
 fn g(act: fn(&[int]) -> int) -> int { ret act([1, 2, 3]); }
 
diff --git a/src/test/run-pass/box-unbox.rs b/src/test/run-pass/box-unbox.rs
index e27954d4d655..08633a572a3e 100644
--- a/src/test/run-pass/box-unbox.rs
+++ b/src/test/run-pass/box-unbox.rs
@@ -2,7 +2,7 @@
 
 type box<T> = {c: @T};
 
-fn unbox<T>(b: &box<T>) -> T { ret *b.c; }
+fn unbox<@T>(b: &box<T>) -> T { ret *b.c; }
 
 fn main() {
     let foo: int = 17;
diff --git a/src/test/run-pass/fixed-point-bind-box.rs b/src/test/run-pass/fixed-point-bind-box.rs
index 4ca1cdb34c9d..57dcc98b2a86 100644
--- a/src/test/run-pass/fixed-point-bind-box.rs
+++ b/src/test/run-pass/fixed-point-bind-box.rs
@@ -1,8 +1,8 @@
-fn fix_help<A, B>(f: @fn(@fn(&A) -> B, &A) -> B, x: &A) -> B {
+fn fix_help<A, @B>(f: @fn(@fn(&A) -> B, &A) -> B, x: &A) -> B {
     ret f(@bind fix_help(f, _), x);
 }
 
-fn fix<A, B>(f: @fn(@fn(&A) -> B, &A) -> B) -> @fn(&A) -> B {
+fn fix<A, @B>(f: @fn(@fn(&A) -> B, &A) -> B) -> @fn(&A) -> B {
     ret @bind fix_help(f, _);
 }
 
diff --git a/src/test/run-pass/generic-alias-box.rs b/src/test/run-pass/generic-alias-box.rs
index 8d58c580fba5..3250b88ab824 100644
--- a/src/test/run-pass/generic-alias-box.rs
+++ b/src/test/run-pass/generic-alias-box.rs
@@ -1,6 +1,6 @@
 
 
-fn id<T>(t: &T) -> T { ret t; }
+fn id<@T>(t: &T) -> T { ret t; }
 
 fn main() {
     let expected = @100;
diff --git a/src/test/run-pass/generic-bind-2.rs b/src/test/run-pass/generic-bind-2.rs
index 499bc2a25d1f..5c149ad59360 100644
--- a/src/test/run-pass/generic-bind-2.rs
+++ b/src/test/run-pass/generic-bind-2.rs
@@ -1,6 +1,6 @@
 
 
-fn id<T>(t: &T) -> T { ret t; }
+fn id<@T>(t: &T) -> T { ret t; }
 
 fn main() {
     let t = {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7};
diff --git a/src/test/run-pass/generic-bind.rs b/src/test/run-pass/generic-bind.rs
index 97b000ee1b52..01156f579004 100644
--- a/src/test/run-pass/generic-bind.rs
+++ b/src/test/run-pass/generic-bind.rs
@@ -1,6 +1,6 @@
 
 
-fn id<T>(t: &T) -> T { ret t; }
+fn id<@T>(t: &T) -> T { ret t; }
 
 fn main() {
     let t = {_0: 1, _1: 2, _2: 3, _3: 4, _4: 5, _5: 6, _6: 7};
diff --git a/src/test/run-pass/generic-derived-type.rs b/src/test/run-pass/generic-derived-type.rs
index d0b98b1068e2..c11dce2ac7b4 100644
--- a/src/test/run-pass/generic-derived-type.rs
+++ b/src/test/run-pass/generic-derived-type.rs
@@ -1,8 +1,8 @@
 
 
-fn g<X>(x: &X) -> X { ret x; }
+fn g<@X>(x: &X) -> X { ret x; }
 
-fn f<T>(t: &T) -> {a: T, b: T} {
+fn f<@T>(t: &T) -> {a: T, b: T} {
     type pair = {a: T, b: T};
 
     let x: pair = {a: t, b: t};
diff --git a/src/test/run-pass/generic-fn-infer.rs b/src/test/run-pass/generic-fn-infer.rs
index 4c6597e97d75..559fa4d04465 100644
--- a/src/test/run-pass/generic-fn-infer.rs
+++ b/src/test/run-pass/generic-fn-infer.rs
@@ -4,6 +4,6 @@
 // -*- rust -*-
 
 // Issue #45: infer type parameters in function applications
-fn id<T>(x: &T) -> T { ret x; }
+fn id<@T>(x: &T) -> T { ret x; }
 
 fn main() { let x: int = 42; let y: int = id(x); assert (x == y); }
diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs
index 5eb4e0aae328..940e0fe5aed7 100644
--- a/src/test/run-pass/generic-fn.rs
+++ b/src/test/run-pass/generic-fn.rs
@@ -2,7 +2,7 @@
 
 
 // -*- rust -*-
-fn id<T>(x: &T) -> T { ret x; }
+fn id<@T>(x: &T) -> T { ret x; }
 
 type triple = {x: int, y: int, z: int};
 
diff --git a/src/test/run-pass/generic-obj-with-derived-type.rs b/src/test/run-pass/generic-obj-with-derived-type.rs
index 05552db04ffa..0bc1fafa4955 100644
--- a/src/test/run-pass/generic-obj-with-derived-type.rs
+++ b/src/test/run-pass/generic-obj-with-derived-type.rs
@@ -1,6 +1,6 @@
 
 
-obj handle<T>(data: T) {
+obj handle<@T>(data: T) {
     fn get() -> T { ret data; }
 }
 
diff --git a/src/test/run-pass/generic-obj.rs b/src/test/run-pass/generic-obj.rs
index f22addc8b512..6653014b0246 100644
--- a/src/test/run-pass/generic-obj.rs
+++ b/src/test/run-pass/generic-obj.rs
@@ -1,6 +1,6 @@
 
 
-obj buf<T>(data: {_0: T, _1: T, _2: T}) {
+obj buf<@T>(data: {_0: T, _1: T, _2: T}) {
     fn get(i: int) -> T {
         if i == 0 {
             ret data._0;
diff --git a/src/test/run-pass/generic-tup.rs b/src/test/run-pass/generic-tup.rs
index 8cacf51e9b51..ac15998c1ccd 100644
--- a/src/test/run-pass/generic-tup.rs
+++ b/src/test/run-pass/generic-tup.rs
@@ -1,4 +1,4 @@
-fn get_third<T>(t: &(T, T, T)) -> T { let (_, _, x) = t; ret x; }
+fn get_third<@T>(t: &(T, T, T)) -> T { let (_, _, x) = t; ret x; }
 
 fn main() {
     log get_third((1, 2, 3));
diff --git a/src/test/run-pass/issue-333.rs b/src/test/run-pass/issue-333.rs
index 12afefe57b11..b5304234b987 100644
--- a/src/test/run-pass/issue-333.rs
+++ b/src/test/run-pass/issue-333.rs
@@ -1,5 +1,5 @@
-fn quux<T>(x: &T) -> T { let f = id::<T>; ret f(x); }
+fn quux<@T>(x: &T) -> T { let f = id::<T>; ret f(x); }
 
-fn id<T>(x: &T) -> T { ret x; }
+fn id<@T>(x: &T) -> T { ret x; }
 
 fn main() { assert (quux(10) == 10); }
diff --git a/src/test/run-pass/newtype-polymorphic.rs b/src/test/run-pass/newtype-polymorphic.rs
index fc3002ba6627..27fbaee6a777 100644
--- a/src/test/run-pass/newtype-polymorphic.rs
+++ b/src/test/run-pass/newtype-polymorphic.rs
@@ -1,8 +1,8 @@
 tag myvec<X> = [X];
 
-fn myvec_deref<X>(mv: &myvec<X>) -> [X] { ret *mv; }
+fn myvec_deref<@X>(mv: &myvec<X>) -> [X] { ret *mv; }
 
-fn myvec_elt<X>(mv: &myvec<X>) -> X { ret mv[0]; }
+fn myvec_elt<@X>(mv: &myvec<X>) -> X { ret mv[0]; }
 
 fn main() {
     let mv = myvec([1, 2, 3]);
diff --git a/src/test/run-pass/ret-none.rs b/src/test/run-pass/ret-none.rs
index b56db9f9c700..841753d7ad19 100644
--- a/src/test/run-pass/ret-none.rs
+++ b/src/test/run-pass/ret-none.rs
@@ -2,6 +2,6 @@
 
 tag option<T> { none; some(T); }
 
-fn f<T>() -> option<T> { ret none; }
+fn f<@T>() -> option<T> { ret none; }
 
 fn main() { f::<int>(); }