diff --git a/src/libextra/par.rs b/src/libextra/par.rs
index 1c686843ab09..74ebf525e00a 100644
--- a/src/libextra/par.rs
+++ b/src/libextra/par.rs
@@ -85,7 +85,7 @@ fn map_slices<A:Clone + Send,B:Clone + Send>(
 }
 
 /// A parallel version of map.
-pub fn map<A:Copy + Clone + Send,B:Copy + Clone + Send>(
+pub fn map<A:Clone + Send,B:Clone + Send>(
     xs: &[A], fn_factory: &fn() -> ~fn(&A) -> B) -> ~[B] {
     vec::concat(map_slices(xs, || {
         let f = fn_factory();
@@ -96,7 +96,7 @@ pub fn map<A:Copy + Clone + Send,B:Copy + Clone + Send>(
 }
 
 /// A parallel version of mapi.
-pub fn mapi<A:Copy + Clone + Send,B:Copy + Clone + Send>(
+pub fn mapi<A:Clone + Send,B:Clone + Send>(
         xs: &[A],
         fn_factory: &fn() -> ~fn(uint, &A) -> B) -> ~[B] {
     let slices = map_slices(xs, || {
diff --git a/src/libextra/serialize.rs b/src/libextra/serialize.rs
index 9fec58e74958..53db93313a6e 100644
--- a/src/libextra/serialize.rs
+++ b/src/libextra/serialize.rs
@@ -650,10 +650,7 @@ impl<
     }
 }
 
-impl<
-    S: Encoder,
-    T: Encodable<S> + Copy
-> Encodable<S> for DList<T> {
+impl<S: Encoder, T: Encodable<S>> Encodable<S> for @mut DList<T> {
     fn encode(&self, s: &mut S) {
         do s.emit_seq(self.len()) |s| {
             let mut i = 0;
diff --git a/src/libextra/sort.rs b/src/libextra/sort.rs
index 8a21ea0bd3bc..a11b819dda11 100644
--- a/src/libextra/sort.rs
+++ b/src/libextra/sort.rs
@@ -24,12 +24,12 @@ type Le<'self, T> = &'self fn(v1: &T, v2: &T) -> bool;
  * Has worst case O(n log n) performance, best case O(n), but
  * is not space efficient. This is a stable sort.
  */
-pub fn merge_sort<T:Copy + Clone>(v: &[T], le: Le<T>) -> ~[T] {
+pub fn merge_sort<T:Clone>(v: &[T], le: Le<T>) -> ~[T] {
     type Slice = (uint, uint);
 
     return merge_sort_(v, (0u, v.len()), le);
 
-    fn merge_sort_<T:Copy + Clone>(v: &[T], slice: Slice, le: Le<T>) -> ~[T] {
+    fn merge_sort_<T:Clone>(v: &[T], slice: Slice, le: Le<T>) -> ~[T] {
         let begin = slice.first();
         let end = slice.second();
 
@@ -44,7 +44,7 @@ pub fn merge_sort<T:Copy + Clone>(v: &[T], le: Le<T>) -> ~[T] {
                                     merge_sort_(v, b, |x,y| le(x,y)));
     }
 
-    fn merge<T:Copy + Clone>(le: Le<T>, a: &[T], b: &[T]) -> ~[T] {
+    fn merge<T:Clone>(le: Le<T>, a: &[T], b: &[T]) -> ~[T] {
         let mut rs = vec::with_capacity(a.len() + b.len());
         let a_len = a.len();
         let mut a_ix = 0;
@@ -183,7 +183,7 @@ static MIN_GALLOP: uint = 7;
 static INITIAL_TMP_STORAGE: uint = 128;
 
 #[allow(missing_doc)]
-pub fn tim_sort<T:Copy + Clone + Ord>(array: &mut [T]) {
+pub fn tim_sort<T:Clone + Ord>(array: &mut [T]) {
     let size = array.len();
     if size < 2 {
         return;
@@ -227,7 +227,7 @@ pub fn tim_sort<T:Copy + Clone + Ord>(array: &mut [T]) {
     ms.merge_force_collapse(array);
 }
 
-fn binarysort<T:Copy + Clone + Ord>(array: &mut [T], start: uint) {
+fn binarysort<T:Clone + Ord>(array: &mut [T], start: uint) {
     let size = array.len();
     let mut start = start;
     assert!(start <= size);
@@ -419,7 +419,7 @@ fn MergeState<T>() -> MergeState<T> {
     }
 }
 
-impl<T:Copy + Clone + Ord> MergeState<T> {
+impl<T:Clone + Ord> MergeState<T> {
     fn push_run(&mut self, run_base: uint, run_len: uint) {
         let tmp = RunState{base: run_base, len: run_len};
         self.runs.push(tmp);
@@ -739,10 +739,7 @@ fn copy_vec<T:Clone>(dest: &mut [T],
 }
 
 #[inline]
-fn shift_vec<T:Copy + Clone>(dest: &mut [T],
-                             s1: uint,
-                             s2: uint,
-                             len: uint) {
+fn shift_vec<T:Clone>(dest: &mut [T], s1: uint, s2: uint, len: uint) {
     assert!(s1+len <= dest.len());
 
     let tmp = dest.slice(s2, s2+len).to_owned();
diff --git a/src/libextra/timer.rs b/src/libextra/timer.rs
index d957ac43801e..1cfbeb9e514d 100644
--- a/src/libextra/timer.rs
+++ b/src/libextra/timer.rs
@@ -118,10 +118,8 @@ pub fn sleep(iotask: &IoTask, msecs: uint) {
  * on the provided port in the allotted timeout period, then the result will
  * be a `Some(T)`. If not, then `None` will be returned.
  */
-pub fn recv_timeout<T:Copy + Send>(iotask: &IoTask,
-                                   msecs: uint,
-                                   wait_po: &Port<T>)
-                                   -> Option<T> {
+pub fn recv_timeout<T:Send>(iotask: &IoTask, msecs: uint, wait_po: &Port<T>)
+                            -> Option<T> {
     let (timeout_po, timeout_ch) = stream::<()>();
     let mut timeout_po = timeout_po;
     delayed_send(iotask, msecs, &timeout_ch, ());
diff --git a/src/librust/rust.rs b/src/librust/rust.rs
index adf73a7e7f00..bc97ef0e8ca4 100644
--- a/src/librust/rust.rs
+++ b/src/librust/rust.rs
@@ -43,19 +43,19 @@ impl ValidUsage {
     }
 }
 
-enum Action<'self> {
-    Call(&'self fn:Copy(args: &[~str]) -> ValidUsage),
-    CallMain(&'static str, &'self fn:Copy()),
+enum Action {
+    Call(extern "Rust" fn(args: &[~str]) -> ValidUsage),
+    CallMain(&'static str, extern "Rust" fn()),
 }
 
 enum UsageSource<'self> {
     UsgStr(&'self str),
-    UsgCall(&'self fn:Copy()),
+    UsgCall(extern "Rust" fn()),
 }
 
 struct Command<'self> {
     cmd: &'self str,
-    action: Action<'self>,
+    action: Action,
     usage_line: &'self str,
     usage_full: UsageSource<'self>,
 }
diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs
index 2c1f3dd1918d..e85b3239e805 100644
--- a/src/librustc/driver/driver.rs
+++ b/src/librustc/driver/driver.rs
@@ -199,8 +199,9 @@ pub fn compile_rest(sess: Session,
         //
         // baz! should not use this definition unless foo is enabled.
         crate = time(time_passes, ~"std macros injection", ||
-                     syntax::ext::expand::inject_std_macros(sess.parse_sess, copy cfg,
-                                                             crate));
+                     syntax::ext::expand::inject_std_macros(sess.parse_sess,
+                                                            cfg.clone(),
+                                                            crate));
 
         crate = time(time_passes, ~"configuration 1", ||
                      front::config::strip_unconfigured_items(crate));
diff --git a/src/librustc/front/std_inject.rs b/src/librustc/front/std_inject.rs
index 3d4b22ecd8c7..6865428cd69a 100644
--- a/src/librustc/front/std_inject.rs
+++ b/src/librustc/front/std_inject.rs
@@ -37,7 +37,7 @@ fn no_prelude(attrs: &[ast::attribute]) -> bool {
 }
 
 fn inject_libstd_ref(sess: Session, crate: &ast::crate) -> @ast::crate {
-    fn spanned<T:Copy>(x: T) -> codemap::spanned<T> {
+    fn spanned<T>(x: T) -> codemap::spanned<T> {
         codemap::spanned { node: x, span: dummy_sp() }
     }
 
diff --git a/src/librustc/front/test.rs b/src/librustc/front/test.rs
index 61a530b307c4..e83c5ff6d109 100644
--- a/src/librustc/front/test.rs
+++ b/src/librustc/front/test.rs
@@ -343,7 +343,7 @@ fn mk_test_module(cx: &TestCtxt) -> @ast::item {
     return @item;
 }
 
-fn nospan<T:Copy>(t: T) -> codemap::spanned<T> {
+fn nospan<T>(t: T) -> codemap::spanned<T> {
     codemap::spanned { node: t, span: dummy_sp() }
 }
 
diff --git a/src/librustc/metadata/filesearch.rs b/src/librustc/metadata/filesearch.rs
index 62bbe22a0432..112965127a25 100644
--- a/src/librustc/metadata/filesearch.rs
+++ b/src/librustc/metadata/filesearch.rs
@@ -87,7 +87,7 @@ pub fn mk_filesearch(maybe_sysroot: &Option<@Path>,
     } as @FileSearch
 }
 
-pub fn search<T:Copy>(filesearch: @FileSearch, pick: pick<T>) -> Option<T> {
+pub fn search<T>(filesearch: @FileSearch, pick: pick<T>) -> Option<T> {
     let mut rslt = None;
     for filesearch.for_each_lib_search_path() |lib_search_path| {
         debug!("searching %s", lib_search_path.to_str());
diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs
index d4d20e75c9de..6201283939fa 100644
--- a/src/librustc/middle/astencode.rs
+++ b/src/librustc/middle/astencode.rs
@@ -1282,14 +1282,14 @@ fn test_more() {
 fn test_simplification() {
     let ext_cx = mk_ctxt();
     let item_in = ast::ii_item(quote_item!(
-        fn new_int_alist<B:Copy>() -> alist<int, B> {
+        fn new_int_alist<B>() -> alist<int, B> {
             fn eq_int(a: int, b: int) -> bool { a == b }
             return alist {eq_fn: eq_int, data: ~[]};
         }
     ).get());
     let item_out = simplify_ast(&item_in);
     let item_exp = ast::ii_item(quote_item!(
-        fn new_int_alist<B:Copy>() -> alist<int, B> {
+        fn new_int_alist<B>() -> alist<int, B> {
             return alist {eq_fn: eq_int, data: ~[]};
         }
     ).get());
diff --git a/src/librustc/middle/lint.rs b/src/librustc/middle/lint.rs
index 6d3f50073f27..9fb07927d986 100644
--- a/src/librustc/middle/lint.rs
+++ b/src/librustc/middle/lint.rs
@@ -561,7 +561,7 @@ pub fn each_lint(sess: session::Session,
 // This is used to make the simple visitors used for the lint passes
 // not traverse into subitems, since that is handled by the outer
 // lint visitor.
-fn item_stopping_visitor<E: Copy>(outer: visit::vt<E>) -> visit::vt<E> {
+fn item_stopping_visitor<E>(outer: visit::vt<E>) -> visit::vt<E> {
     visit::mk_vt(@visit::Visitor {
         visit_item: |_i, (_e, _v)| { },
         visit_fn: |fk, fd, b, s, id, (e, v)| {
diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs
index c708331e1c44..2c63079ad8f8 100644
--- a/src/librustc/middle/trans/type_use.rs
+++ b/src/librustc/middle/trans/type_use.rs
@@ -62,7 +62,7 @@ pub fn type_uses_for(ccx: @mut CrateContext, fn_id: def_id, n_tps: uint)
 
     fn store_type_uses(cx: Context, fn_id: def_id) -> @~[type_uses] {
         let Context { uses, ccx } = cx;
-        let uses = @copy *uses; // freeze
+        let uses = @(*uses).clone(); // freeze
         ccx.type_use_cache.insert(fn_id, uses);
         uses
     }
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index 5910eaacc5db..8eefcb154ef2 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -860,7 +860,7 @@ fn mk_rcache() -> creader_cache {
     return @mut HashMap::new();
 }
 
-pub fn new_ty_hash<V:Copy>() -> @mut HashMap<t, V> {
+pub fn new_ty_hash<V>() -> @mut HashMap<t, V> {
     @mut HashMap::new()
 }
 
diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs
index 42b861b73301..4a9e0fddbe73 100644
--- a/src/librustc/middle/typeck/check/mod.rs
+++ b/src/librustc/middle/typeck/check/mod.rs
@@ -1686,10 +1686,10 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
     // through the `unpack` function.  It there is no expected type or
     // resolution is not possible (e.g., no constraints yet present), just
     // returns `none`.
-    fn unpack_expected<O:Copy>(fcx: @mut FnCtxt,
-                                expected: Option<ty::t>,
-                                unpack: &fn(&ty::sty) -> Option<O>)
-                             -> Option<O> {
+    fn unpack_expected<O>(fcx: @mut FnCtxt,
+                          expected: Option<ty::t>,
+                          unpack: &fn(&ty::sty) -> Option<O>)
+                          -> Option<O> {
         match expected {
             Some(t) => {
                 match resolve_type(fcx.infcx(), t, force_tvar) {
diff --git a/src/librustdoc/astsrv.rs b/src/librustdoc/astsrv.rs
index b20d8cab2a4c..16a89122a11c 100644
--- a/src/librustdoc/astsrv.rs
+++ b/src/librustdoc/astsrv.rs
@@ -114,7 +114,8 @@ fn build_ctxt(sess: Session,
     use rustc::front::config;
 
     let ast = syntax::ext::expand::inject_std_macros(sess.parse_sess,
-                                                     copy sess.opts.cfg, ast);
+                                                     sess.opts.cfg.clone(),
+                                                     ast);
     let ast = config::strip_unconfigured_items(ast);
     let ast = syntax::ext::expand::expand_crate(sess.parse_sess,
                                                 sess.opts.cfg.clone(),
diff --git a/src/librustdoc/markdown_index_pass.rs b/src/librustdoc/markdown_index_pass.rs
index e766909b8abd..2c6312e01b20 100644
--- a/src/librustdoc/markdown_index_pass.rs
+++ b/src/librustdoc/markdown_index_pass.rs
@@ -208,8 +208,8 @@ mod test {
                 == ~"impl-of-selectt-u-for-left-right");
         assert!(pandoc_header_id("impl of Condition<'self, T, U>")
                 == ~"impl-of-conditionself-t-u");
-        assert!(pandoc_header_id("impl of Condition<T: Copy + Clone>")
-                == ~"impl-of-conditiont-copy-clone");
+        assert!(pandoc_header_id("impl of Condition<T: Clone>")
+                == ~"impl-of-conditiont-clone");
     }
 
     #[test]
diff --git a/src/librustdoc/tystr_pass.rs b/src/librustdoc/tystr_pass.rs
index f66aeca06ffc..044ab3226053 100644
--- a/src/librustdoc/tystr_pass.rs
+++ b/src/librustdoc/tystr_pass.rs
@@ -394,8 +394,8 @@ mod test {
 
     #[test]
     fn should_add_impl_bounds() {
-        let doc = mk_doc(~"impl<T, U: Copy, V: Copy + Clone> Option<T, U, V> { }");
-        assert!(doc.cratemod().impls()[0].bounds_str == Some(~"<T, U: Copy, V: Copy + Clone>"));
+        let doc = mk_doc(~"impl<T, U, V: Clone> Option<T, U, V> { }");
+        assert!(doc.cratemod().impls()[0].bounds_str == Some(~"<T, U, V: Clone>"));
     }
 
     #[test]
diff --git a/src/librustpkg/tests.rs b/src/librustpkg/tests.rs
index 9d4c2f87a614..b6dabfd0b129 100644
--- a/src/librustpkg/tests.rs
+++ b/src/librustpkg/tests.rs
@@ -839,7 +839,7 @@ fn install_check_duplicates() {
             fail!("package database contains duplicate ID");
         }
         else {
-            contents.push(copy *p);
+            contents.push((*p).clone());
         }
         false
     };
diff --git a/src/libstd/clone.rs b/src/libstd/clone.rs
index 947aa5708c29..f24bc002a2b1 100644
--- a/src/libstd/clone.rs
+++ b/src/libstd/clone.rs
@@ -15,10 +15,9 @@ assign them or pass them as arguments, the receiver will get a copy,
 leaving the original value in place. These types do not require
 allocation to copy and do not have finalizers (i.e. they do not
 contain owned boxes or implement `Drop`), so the compiler considers
-them cheap and safe to copy and automatically implements the `Copy`
-trait for them. For other types copies must be made explicitly,
-by convention implementing the `Clone` trait and calling the
-`clone` method.
+them cheap and safe to copy. For other types copies must be made
+explicitly, by convention implementing the `Clone` trait and calling
+the `clone` method.
 
 */
 
diff --git a/src/libstd/condition.rs b/src/libstd/condition.rs
index 80caa34ce065..100751370174 100644
--- a/src/libstd/condition.rs
+++ b/src/libstd/condition.rs
@@ -47,7 +47,7 @@ impl<T, U> Condition<T, U> {
 
     pub fn raise(&self, t: T) -> U {
         let msg = fmt!("Unhandled condition: %s: %?", self.name, t);
-        self.raise_default(t, || fail!(copy msg))
+        self.raise_default(t, || fail!(msg.clone()))
     }
 
     pub fn raise_default(&self, t: T, default: &fn() -> U) -> U {
@@ -78,7 +78,8 @@ impl<'self, T, U> Condition<'self, T, U> {
     pub fn trap<'a>(&'a self, h: &'a fn(T) -> U) -> Trap<'a, T, U> {
         unsafe {
             let p : *RustClosure = ::cast::transmute(&h);
-            let prev = local_data::get(self.key, |k| k.map(|&x| *x));
+            let prev = local_data::get(::cast::unsafe_copy(&self.key),
+                                       |k| k.map(|&x| *x));
             let h = @Handler { handle: *p, prev: prev };
             Trap { cond: self, handler: h }
         }
@@ -91,7 +92,7 @@ impl<'self, T, U> Condition<'self, T, U> {
 
     pub fn raise_default(&self, t: T, default: &fn() -> U) -> U {
         unsafe {
-            match local_data::pop(self.key) {
+            match local_data::pop(::cast::unsafe_copy(&self.key)) {
                 None => {
                     debug!("Condition.raise: found no handler");
                     default()
@@ -100,12 +101,15 @@ impl<'self, T, U> Condition<'self, T, U> {
                     debug!("Condition.raise: found handler");
                     match handler.prev {
                         None => {}
-                        Some(hp) => local_data::set(self.key, hp)
+                        Some(hp) => {
+                            local_data::set(::cast::unsafe_copy(&self.key),
+                                            hp)
+                        }
                     }
                     let handle : &fn(T) -> U =
                         ::cast::transmute(handler.handle);
                     let u = handle(t);
-                    local_data::set(self.key, handler);
+                    local_data::set(::cast::unsafe_copy(&self.key), handler);
                     u
                 }
             }
diff --git a/src/libstd/kinds.rs b/src/libstd/kinds.rs
index 6c16ecc0d4ef..f2f8f46e7cd9 100644
--- a/src/libstd/kinds.rs
+++ b/src/libstd/kinds.rs
@@ -18,22 +18,13 @@ intrinsic properties of the type. These classifications, often called
 They cannot be implemented by user code, but are instead implemented
 by the compiler automatically for the types to which they apply.
 
-The 3 kinds are
-
-* Copy - types that may be copied without allocation. This includes
-  scalar types and managed pointers, and exludes owned pointers. It
-  also excludes types that implement `Drop`.
+The 2 kinds are
 
 * Send - owned types and types containing owned types.  These types
   may be transferred across task boundaries.
 
 * Freeze - types that are deeply immutable.
 
-`Copy` types include both implicitly copyable types that the compiler
-will copy automatically and non-implicitly copyable types that require
-the `copy` keyword to copy. Types that do not implement `Copy` may
-instead implement `Clone`.
-
 */
 
 #[allow(missing_doc)];
diff --git a/src/libstd/local_data.rs b/src/libstd/local_data.rs
index 168bb7c14f0a..2c1a3bb29a09 100644
--- a/src/libstd/local_data.rs
+++ b/src/libstd/local_data.rs
@@ -59,7 +59,7 @@ use task::local_data_priv::*;
 #[cfg(not(stage0))]
 pub type Key<T> = &'static KeyValue<T>;
 #[cfg(stage0)]
-pub type Key<'self,T> = &'self fn:Copy(v: T);
+pub type Key<'self,T> = &'self fn(v: T);
 
 pub enum KeyValue<T> { Key }
 
diff --git a/src/libstd/num/num.rs b/src/libstd/num/num.rs
index 4468b51c2614..fc199876902f 100644
--- a/src/libstd/num/num.rs
+++ b/src/libstd/num/num.rs
@@ -16,7 +16,6 @@ use cmp::{Eq, ApproxEq, Ord};
 use ops::{Add, Sub, Mul, Div, Rem, Neg};
 use ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
 use option::Option;
-use kinds::Copy;
 
 pub mod strconv;
 
@@ -428,7 +427,7 @@ pub trait FromStrRadix {
 /// - If code written to use this function doesn't care about it, it's
 ///   probably assuming that `x^0` always equals `1`.
 ///
-pub fn pow_with_uint<T:NumCast+One+Zero+Copy+Div<T,T>+Mul<T,T>>(radix: uint, pow: uint) -> T {
+pub fn pow_with_uint<T:NumCast+One+Zero+Div<T,T>+Mul<T,T>>(radix: uint, pow: uint) -> T {
     let _0: T = Zero::zero();
     let _1: T = One::one();
 
diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index 4661bc20403a..ab17c5f175a4 100644
--- a/src/libstd/num/strconv.rs
+++ b/src/libstd/num/strconv.rs
@@ -16,9 +16,8 @@ use core::cmp::{Ord, Eq};
 use ops::{Add, Sub, Mul, Div, Rem, Neg};
 use option::{None, Option, Some};
 use char;
+use str::{StrSlice};
 use str;
-use str::StrSlice;
-use kinds::Copy;
 use vec::{CopyableVector, ImmutableVector, MutableVector};
 use vec::OwnedVector;
 use num::{NumCast, Zero, One, cast, pow_with_uint, Integer};
@@ -466,7 +465,7 @@ priv static DIGIT_E_RADIX: uint = ('e' as uint) - ('a' as uint) + 11u;
  * - Fails if `radix` > 18 and `special == true` due to conflict
  *   between digit and lowest first character in `inf` and `NaN`, the `'i'`.
  */
-pub fn from_str_bytes_common<T:NumCast+Zero+One+Eq+Ord+Copy+Div<T,T>+
+pub fn from_str_bytes_common<T:NumCast+Zero+One+Eq+Ord+Div<T,T>+
                                     Mul<T,T>+Sub<T,T>+Neg<T>+Add<T,T>+
                                     NumStrConv+Clone>(
         buf: &[u8], radix: uint, negative: bool, fractional: bool,
@@ -663,7 +662,7 @@ pub fn from_str_bytes_common<T:NumCast+Zero+One+Eq+Ord+Copy+Div<T,T>+
  * `from_str_bytes_common()`, for details see there.
  */
 #[inline]
-pub fn from_str_common<T:NumCast+Zero+One+Eq+Ord+Copy+Div<T,T>+Mul<T,T>+
+pub fn from_str_common<T:NumCast+Zero+One+Eq+Ord+Div<T,T>+Mul<T,T>+
                               Sub<T,T>+Neg<T>+Add<T,T>+NumStrConv+Clone>(
         buf: &str, radix: uint, negative: bool, fractional: bool,
         special: bool, exponent: ExponentFormat, empty_zero: bool,
diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs
index 8be34896bef6..e3e042a49472 100644
--- a/src/libstd/prelude.rs
+++ b/src/libstd/prelude.rs
@@ -29,7 +29,7 @@ Rust's prelude has three main parts:
 
 // Reexported core operators
 pub use either::{Either, Left, Right};
-pub use kinds::{Copy, Sized};
+pub use kinds::Sized;
 pub use kinds::{Freeze, Send};
 pub use ops::{Add, Sub, Mul, Div, Rem, Neg, Not};
 pub use ops::{BitAnd, BitOr, BitXor};
diff --git a/src/libstd/rand.rs b/src/libstd/rand.rs
index 7d65ba63ff0c..76dbc6291681 100644
--- a/src/libstd/rand.rs
+++ b/src/libstd/rand.rs
@@ -356,7 +356,7 @@ pub trait RngUtil {
      * }
      * ~~~
      */
-    fn choose<T:Copy + Clone>(&mut self, values: &[T]) -> T;
+    fn choose<T:Clone>(&mut self, values: &[T]) -> T;
     /// Choose Some(item) randomly, returning None if values is empty
     fn choose_option<T:Clone>(&mut self, values: &[T]) -> Option<T>;
     /**
@@ -379,7 +379,7 @@ pub trait RngUtil {
      * }
      * ~~~
      */
-    fn choose_weighted<T:Copy + Clone>(&mut self, v : &[Weighted<T>]) -> T;
+    fn choose_weighted<T:Clone>(&mut self, v : &[Weighted<T>]) -> T;
     /**
      * Choose Some(item) respecting the relative weights, returning none if
      * the sum of the weights is 0
@@ -439,7 +439,7 @@ pub trait RngUtil {
      * }
      * ~~~
      */
-    fn shuffle<T:Copy + Clone>(&mut self, values: &[T]) -> ~[T];
+    fn shuffle<T:Clone>(&mut self, values: &[T]) -> ~[T];
     /**
      * Shuffle a mutable vec in place
      *
@@ -532,7 +532,7 @@ impl<R: Rng> RngUtil for R {
     }
 
     /// Choose an item randomly, failing if values is empty
-    fn choose<T:Copy + Clone>(&mut self, values: &[T]) -> T {
+    fn choose<T:Clone>(&mut self, values: &[T]) -> T {
         self.choose_option(values).get()
     }
 
@@ -548,7 +548,7 @@ impl<R: Rng> RngUtil for R {
      * Choose an item respecting the relative weights, failing if the sum of
      * the weights is 0
      */
-    fn choose_weighted<T:Copy + Clone>(&mut self, v: &[Weighted<T>]) -> T {
+    fn choose_weighted<T:Clone>(&mut self, v: &[Weighted<T>]) -> T {
         self.choose_weighted_option(v).get()
     }
 
@@ -591,7 +591,7 @@ impl<R: Rng> RngUtil for R {
     }
 
     /// Shuffle a vec
-    fn shuffle<T:Copy + Clone>(&mut self, values: &[T]) -> ~[T] {
+    fn shuffle<T:Clone>(&mut self, values: &[T]) -> ~[T] {
         let mut m = values.to_owned();
         self.shuffle_mut(m);
         m
diff --git a/src/libstd/task/local_data_priv.rs b/src/libstd/task/local_data_priv.rs
index 75fd6eacc1b3..d5f4973e8c71 100644
--- a/src/libstd/task/local_data_priv.rs
+++ b/src/libstd/task/local_data_priv.rs
@@ -15,6 +15,7 @@ use libc;
 use local_data;
 use prelude::*;
 use ptr;
+use sys;
 use task::rt;
 use util;
 
@@ -156,8 +157,9 @@ unsafe fn get_local_map(handle: Handle) -> &mut TaskLocalMap {
     }
 }
 
-fn key_to_key_value<T: 'static>(key: local_data::Key<T>) -> *libc::c_void {
-    unsafe { cast::transmute(key) }
+unsafe fn key_to_key_value<T: 'static>(key: local_data::Key<T>) -> *libc::c_void {
+    let pair: sys::Closure = cast::transmute_copy(&key);
+    return pair.code as *libc::c_void;
 }
 
 pub unsafe fn local_pop<T: 'static>(handle: Handle,
diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
index 396fdaf2e6a5..df6f77fd6cef 100644
--- a/src/libstd/trie.rs
+++ b/src/libstd/trie.rs
@@ -264,7 +264,8 @@ struct TrieNode<T> {
 impl<T> TrieNode<T> {
     #[inline]
     fn new() -> TrieNode<T> {
-        // FIXME: #5244: [Nothing, ..SIZE] should be possible without Copy
+        // FIXME: #5244: [Nothing, ..SIZE] should be possible without implicit
+        // copyability
         TrieNode{count: 0,
                  children: [Nothing, Nothing, Nothing, Nothing,
                             Nothing, Nothing, Nothing, Nothing,
diff --git a/src/libstd/tuple.rs b/src/libstd/tuple.rs
index 841be4df6e29..6201e753bc99 100644
--- a/src/libstd/tuple.rs
+++ b/src/libstd/tuple.rs
@@ -13,7 +13,6 @@
 #[allow(missing_doc)];
 
 use clone::Clone;
-use kinds::Copy;
 use vec;
 use vec::ImmutableVector;
 use iterator::IteratorUtil;
@@ -86,8 +85,8 @@ pub trait ExtendedTupleOps<A,B> {
 }
 
 impl<'self,
-     A:Copy + Clone,
-     B:Copy + Clone>
+     A:Clone,
+     B:Clone>
      ExtendedTupleOps<A,B> for
      (&'self [A], &'self [B]) {
     #[inline]
@@ -109,10 +108,7 @@ impl<'self,
     }
 }
 
-impl<A:Copy + Clone,
-     B:Copy + Clone>
-     ExtendedTupleOps<A,B> for
-     (~[A], ~[B]) {
+impl<A:Clone, B:Clone> ExtendedTupleOps<A,B> for (~[A], ~[B]) {
     #[inline]
     fn zip(&self) -> ~[(A, B)] {
         match *self {
diff --git a/src/libsyntax/ast_util.rs b/src/libsyntax/ast_util.rs
index 843fd4bdba2c..d0dfb0fb06e5 100644
--- a/src/libsyntax/ast_util.rs
+++ b/src/libsyntax/ast_util.rs
@@ -16,11 +16,13 @@ use opt_vec;
 use parse::token;
 use visit;
 
+use std::cast::unsafe_copy;
+use std::cast;
 use std::hashmap::HashMap;
 use std::int;
+use std::local_data;
 use std::num;
 use std::option;
-use std::local_data;
 
 pub fn path_name_i(idents: &[ident]) -> ~str {
     // FIXME: Bad copies (#2543 -- same for everything else that says "bad")
diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs
index e2f37bd54bd2..230640767c9b 100644
--- a/src/libsyntax/ext/base.rs
+++ b/src/libsyntax/ext/base.rs
@@ -414,7 +414,7 @@ pub enum MapChain<K,V> {
 
 
 // get the map from an env frame
-impl <K: Eq + Hash + IterBytes ,V: Copy> MapChain<K,V>{
+impl <K: Eq + Hash + IterBytes, V> MapChain<K,V>{
 
     // Constructor. I don't think we need a zero-arg one.
     fn new(init: ~HashMap<K,@V>) -> @mut MapChain<K,V> {
diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index ba8e3e729338..2f1d320fef7e 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -693,7 +693,7 @@ pub fn inject_std_macros(parse_sess: @mut parse::ParseSess,
                          cfg: ast::crate_cfg, c: &crate) -> @crate {
     let sm = match parse_item_from_source_str(@"<std-macros>",
                                               std_macros(),
-                                              copy cfg,
+                                              cfg.clone(),
                                               ~[],
                                               parse_sess) {
         Some(item) => item,
@@ -708,7 +708,7 @@ pub fn inject_std_macros(parse_sess: @mut parse::ParseSess,
             ast::_mod {
                 items: items,
                 // FIXME #2543: Bad copy.
-                .. copy *modd
+                .. (*modd).clone()
             }
         },
         .. *default_ast_fold()
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index f0b9258eaeb6..adecbc050a3a 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -473,10 +473,10 @@ impl Parser {
 
     // parse a sequence bracketed by '<' and '>', stopping
     // before the '>'.
-    pub fn parse_seq_to_before_gt<T: Copy>(&self,
-                                           sep: Option<token::Token>,
-                                           f: &fn(&Parser) -> T)
-                                           -> OptVec<T> {
+    pub fn parse_seq_to_before_gt<T>(&self,
+                                     sep: Option<token::Token>,
+                                     f: &fn(&Parser) -> T)
+                                     -> OptVec<T> {
         let mut first = true;
         let mut v = opt_vec::Empty;
         while *self.token != token::GT
@@ -493,10 +493,10 @@ impl Parser {
         return v;
     }
 
-    pub fn parse_seq_to_gt<T: Copy>(&self,
-                                    sep: Option<token::Token>,
-                                    f: &fn(&Parser) -> T)
-                                    -> OptVec<T> {
+    pub fn parse_seq_to_gt<T>(&self,
+                              sep: Option<token::Token>,
+                              f: &fn(&Parser) -> T)
+                              -> OptVec<T> {
         let v = self.parse_seq_to_before_gt(sep, f);
         self.expect_gt();
         return v;
@@ -505,11 +505,11 @@ impl Parser {
     // parse a sequence, including the closing delimiter. The function
     // f must consume tokens until reaching the next separator or
     // closing bracket.
-    pub fn parse_seq_to_end<T: Copy>(&self,
-                                     ket: &token::Token,
-                                     sep: SeqSep,
-                                     f: &fn(&Parser) -> T)
-                                     -> ~[T] {
+    pub fn parse_seq_to_end<T>(&self,
+                               ket: &token::Token,
+                               sep: SeqSep,
+                               f: &fn(&Parser) -> T)
+                               -> ~[T] {
         let val = self.parse_seq_to_before_end(ket, sep, f);
         self.bump();
         val
@@ -518,11 +518,11 @@ impl Parser {
     // parse a sequence, not including the closing delimiter. The function
     // f must consume tokens until reaching the next separator or
     // closing bracket.
-    pub fn parse_seq_to_before_end<T: Copy>(&self,
-                                            ket: &token::Token,
-                                            sep: SeqSep,
-                                            f: &fn(&Parser) -> T)
-                                            -> ~[T] {
+    pub fn parse_seq_to_before_end<T>(&self,
+                                      ket: &token::Token,
+                                      sep: SeqSep,
+                                      f: &fn(&Parser) -> T)
+                                      -> ~[T] {
         let mut first: bool = true;
         let mut v: ~[T] = ~[];
         while *self.token != *ket {
@@ -542,12 +542,12 @@ impl Parser {
     // parse a sequence, including the closing delimiter. The function
     // f must consume tokens until reaching the next separator or
     // closing bracket.
-    pub fn parse_unspanned_seq<T: Copy>(&self,
-                                        bra: &token::Token,
-                                        ket: &token::Token,
-                                        sep: SeqSep,
-                                        f: &fn(&Parser) -> T)
-                                        -> ~[T] {
+    pub fn parse_unspanned_seq<T>(&self,
+                                  bra: &token::Token,
+                                  ket: &token::Token,
+                                  sep: SeqSep,
+                                  f: &fn(&Parser) -> T)
+                                  -> ~[T] {
         self.expect(bra);
         let result = self.parse_seq_to_before_end(ket, sep, f);
         self.bump();
@@ -556,12 +556,12 @@ impl Parser {
 
     // NB: Do not use this function unless you actually plan to place the
     // spanned list in the AST.
-    pub fn parse_seq<T: Copy>(&self,
-                              bra: &token::Token,
-                              ket: &token::Token,
-                              sep: SeqSep,
-                              f: &fn(&Parser) -> T)
-                              -> spanned<~[T]> {
+    pub fn parse_seq<T>(&self,
+                        bra: &token::Token,
+                        ket: &token::Token,
+                        sep: SeqSep,
+                        f: &fn(&Parser) -> T)
+                        -> spanned<~[T]> {
         let lo = self.span.lo;
         self.expect(bra);
         let result = self.parse_seq_to_before_end(ket, sep, f);
diff --git a/src/test/auxiliary/static-methods-crate.rs b/src/test/auxiliary/static-methods-crate.rs
index b5b338531294..180cb18c7459 100644
--- a/src/test/auxiliary/static-methods-crate.rs
+++ b/src/test/auxiliary/static-methods-crate.rs
@@ -35,7 +35,7 @@ impl read for bool {
     }
 }
 
-pub fn read<T:read + Copy>(s: ~str) -> T {
+pub fn read<T:read>(s: ~str) -> T {
     match read::readMaybe(s) {
       Some(x) => x,
       _ => fail!("read failed!")
diff --git a/src/test/bench/shootout-k-nucleotide-pipes.rs b/src/test/bench/shootout-k-nucleotide-pipes.rs
index 64cfa2561a4b..86ab99407b98 100644
--- a/src/test/bench/shootout-k-nucleotide-pipes.rs
+++ b/src/test/bench/shootout-k-nucleotide-pipes.rs
@@ -34,8 +34,8 @@ fn sort_and_fmt(mm: &HashMap<~[u8], uint>, total: uint) -> ~str {
       return (xx as float) * 100f / (yy as float);
    }
 
-   fn le_by_val<TT:Copy + Clone,
-                UU:Copy + Clone + Ord>(
+   fn le_by_val<TT:Clone,
+                UU:Clone + Ord>(
                 kv0: &(TT,UU),
                 kv1: &(TT,UU))
                 -> bool {
@@ -44,8 +44,8 @@ fn sort_and_fmt(mm: &HashMap<~[u8], uint>, total: uint) -> ~str {
       return v0 >= v1;
    }
 
-   fn le_by_key<TT:Copy + Clone + Ord,
-                UU:Copy + Clone>(
+   fn le_by_key<TT:Clone + Ord,
+                UU:Clone>(
                 kv0: &(TT,UU),
                 kv1: &(TT,UU))
                 -> bool {
@@ -55,10 +55,7 @@ fn sort_and_fmt(mm: &HashMap<~[u8], uint>, total: uint) -> ~str {
    }
 
    // sort by key, then by value
-   fn sortKV<TT:Copy + Clone + Ord,
-             UU:Copy + Clone + Ord>(
-             orig: ~[(TT,UU)])
-             -> ~[(TT,UU)] {
+   fn sortKV<TT:Clone + Ord, UU:Clone + Ord>(orig: ~[(TT,UU)]) -> ~[(TT,UU)] {
       return sort::merge_sort(sort::merge_sort(orig, le_by_key), le_by_val);
    }
 
diff --git a/src/test/compile-fail/bad-method-typaram-kind.rs b/src/test/compile-fail/bad-method-typaram-kind.rs
index d5b8f99ada0e..db6db02ded50 100644
--- a/src/test/compile-fail/bad-method-typaram-kind.rs
+++ b/src/test/compile-fail/bad-method-typaram-kind.rs
@@ -9,15 +9,15 @@
 // except according to those terms.
 
 fn foo<T>() {
-    1u.bar::<T>(); //~ ERROR: does not fulfill `Copy`
+    1u.bar::<T>(); //~ ERROR: does not fulfill `Send`
 }
 
 trait bar {
-    fn bar<T:Copy>(&self);
+    fn bar<T:Send>(&self);
 }
 
 impl bar for uint {
-    fn bar<T:Copy>(&self) {
+    fn bar<T:Send>(&self) {
     }
 }
 
diff --git a/src/test/compile-fail/closure-bounds-cant-promote-superkind-in-struct.rs b/src/test/compile-fail/closure-bounds-cant-promote-superkind-in-struct.rs
index 098a395f0174..b38cb8954880 100644
--- a/src/test/compile-fail/closure-bounds-cant-promote-superkind-in-struct.rs
+++ b/src/test/compile-fail/closure-bounds-cant-promote-superkind-in-struct.rs
@@ -9,11 +9,11 @@
 // except according to those terms.
 
 struct X {
-    field: @fn:Copy(),
+    field: @fn:Send(),
 }
 
 fn foo(blk: @fn:()) -> X {
-    return X { field: blk }; //~ ERROR expected bounds `Copy` but found no bounds
+    return X { field: blk }; //~ ERROR expected bounds `Send` but found no bounds
 }
 
 fn main() {
diff --git a/src/test/compile-fail/closure-bounds-copy-cant-capture-noncopyable.rs b/src/test/compile-fail/closure-bounds-copy-cant-capture-noncopyable.rs
deleted file mode 100644
index 0b11da14e71a..000000000000
--- a/src/test/compile-fail/closure-bounds-copy-cant-capture-noncopyable.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::comm;
-
-// If this were legal you could use it to copy captured noncopyables.
-// Issue (#2828)
-
-fn foo(blk: ~fn:Copy()) {
-    blk();
-}
-
-fn main() {
-    let (p,c) = comm::stream();
-    do foo {
-        c.send(()); //~ ERROR does not fulfill `Copy`
-    }
-    p.recv();
-}
diff --git a/src/test/compile-fail/closure-bounds-subtype.rs b/src/test/compile-fail/closure-bounds-subtype.rs
index 0c9220d18ab7..324634ac66db 100644
--- a/src/test/compile-fail/closure-bounds-subtype.rs
+++ b/src/test/compile-fail/closure-bounds-subtype.rs
@@ -2,38 +2,16 @@
 fn take_any(_: &fn:()) {
 }
 
-fn take_copyable(_: &fn:Copy()) {
-}
-
-fn take_copyable_owned(_: &fn:Copy+Send()) {
-}
-
 fn take_const_owned(_: &fn:Freeze+Send()) {
 }
 
 fn give_any(f: &fn:()) {
     take_any(f);
-    take_copyable(f); //~ ERROR expected bounds `Copy` but found no bounds
-    take_copyable_owned(f); //~ ERROR expected bounds `Copy+Send` but found no bounds
-}
-
-fn give_copyable(f: &fn:Copy()) {
-    take_any(f);
-    take_copyable(f);
-    take_copyable_owned(f); //~ ERROR expected bounds `Copy+Send` but found bounds `Copy`
 }
 
 fn give_owned(f: &fn:Send()) {
     take_any(f);
-    take_copyable(f); //~ ERROR expected bounds `Copy` but found bounds `Send`
-    take_copyable_owned(f); //~ ERROR expected bounds `Copy+Send` but found bounds `Send`
-}
-
-fn give_copyable_owned(f: &fn:Copy+Send()) {
-    take_any(f);
-    take_copyable(f);
-    take_copyable_owned(f);
-    take_const_owned(f); //~ ERROR expected bounds `Send+Freeze` but found bounds `Copy+Send`
+    take_const_owned(f); //~ ERROR expected bounds `Freeze+Send` but found bounds `Send`
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/fn-variance-2.rs b/src/test/compile-fail/fn-variance-2.rs
index 61668cbdb9ea..ab5591900346 100644
--- a/src/test/compile-fail/fn-variance-2.rs
+++ b/src/test/compile-fail/fn-variance-2.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn reproduce<T:Copy>(t: T) -> @fn() -> T {
+fn reproduce<T>(t: T) -> @fn() -> T {
     let result: @fn() -> T = || t;
     result
 }
diff --git a/src/test/compile-fail/fn-variance-3.rs b/src/test/compile-fail/fn-variance-3.rs
index 4d145d3f9ea3..630eb4b538d5 100644
--- a/src/test/compile-fail/fn-variance-3.rs
+++ b/src/test/compile-fail/fn-variance-3.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn mk_identity<T:Copy>() -> @fn(T) -> T {
+fn mk_identity<T>() -> @fn(T) -> T {
     let result: @fn(t: T) -> T = |t| t;
     result
 }
diff --git a/src/test/compile-fail/issue-2548.rs b/src/test/compile-fail/issue-2548.rs
index 314f282355db..47087337e340 100644
--- a/src/test/compile-fail/issue-2548.rs
+++ b/src/test/compile-fail/issue-2548.rs
@@ -37,7 +37,7 @@ fn main() {
         let mut res = foo(x);
 
         let mut v = ~[];
-        v = ~[(res)] + v; //~ instantiating a type parameter with an incompatible type `foo`, which does not fulfill `Copy`
+        v = ~[(res)] + v; //~ instantiating a type parameter with an incompatible type `foo`, which does not fulfill `Clone`
         assert_eq!(v.len(), 2);
     }
 
diff --git a/src/test/compile-fail/issue-2611-4.rs b/src/test/compile-fail/issue-2611-4.rs
index 531d4eab5357..c62c28745253 100644
--- a/src/test/compile-fail/issue-2611-4.rs
+++ b/src/test/compile-fail/issue-2611-4.rs
@@ -12,7 +12,7 @@
 // than the trait method it's implementing
 
 trait A {
-  fn b<C:Copy,D>(x: C) -> C;
+  fn b<C,D>(x: C) -> C;
 }
 
 struct E {
@@ -20,7 +20,7 @@ struct E {
 }
 
 impl A for E {
-  fn b<F:Copy + Freeze,G>(_x: F) -> F { fail!() } //~ ERROR type parameter 0 requires `Freeze`
+  fn b<F:Freeze,G>(_x: F) -> F { fail!() } //~ ERROR type parameter 0 requires `Freeze`
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/issue-2611-5.rs b/src/test/compile-fail/issue-2611-5.rs
index 9840650fa2e4..9b8346da5c5d 100644
--- a/src/test/compile-fail/issue-2611-5.rs
+++ b/src/test/compile-fail/issue-2611-5.rs
@@ -12,7 +12,7 @@
 // an impl against a trait
 
 trait A {
-  fn b<C:Copy,D>(&self, x: C) -> C;
+  fn b<C:Clone,D>(&self, x: C) -> C;
 }
 
 struct E {
@@ -21,7 +21,7 @@ struct E {
 
 impl A for E {
   // n.b. The error message is awful -- see #3404
-  fn b<F:Copy,G>(&self, _x: G) -> G { fail!() } //~ ERROR method `b` has an incompatible type
+  fn b<F:Clone,G>(&self, _x: G) -> G { fail!() } //~ ERROR method `b` has an incompatible type
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/kindck-owned-trait-contains.rs b/src/test/compile-fail/kindck-owned-trait-contains.rs
index 33e122867bb3..19b38769d956 100644
--- a/src/test/compile-fail/kindck-owned-trait-contains.rs
+++ b/src/test/compile-fail/kindck-owned-trait-contains.rs
@@ -10,11 +10,11 @@
 
 trait repeat<A> { fn get(&self) -> A; }
 
-impl<A:Copy> repeat<A> for @A {
+impl<A:Clone> repeat<A> for @A {
     fn get(&self) -> A { **self }
 }
 
-fn repeater<A:Copy>(v: @A) -> @repeat<A> {
+fn repeater<A:Clone>(v: @A) -> @repeat<A> {
     // Note: owned kind is not necessary as A appears in the trait type
     @v as @repeat<A> // No
 }
diff --git a/src/test/compile-fail/kindck-owned-trait-scoped.rs b/src/test/compile-fail/kindck-owned-trait-scoped.rs
index 808bfba82985..4dc1c6f2f3ee 100644
--- a/src/test/compile-fail/kindck-owned-trait-scoped.rs
+++ b/src/test/compile-fail/kindck-owned-trait-scoped.rs
@@ -18,11 +18,11 @@ trait foo {
     fn foo(&self, i: &'self int) -> int;
 }
 
-impl<T:Copy> foo for T {
+impl<T:Clone> foo for T {
     fn foo(&self, i: &'self int) -> int {*i}
 }
 
-fn to_foo<T:Copy>(t: T) {
+fn to_foo<T:Clone>(t: T) {
     // This version is ok because, although T may contain borrowed
     // pointers, it never escapes the fn body.  We know this because
     // the type of foo includes a region which will be resolved to
@@ -33,14 +33,14 @@ fn to_foo<T:Copy>(t: T) {
     assert_eq!(x.foo(v), 3);
 }
 
-fn to_foo_2<T:Copy>(t: T) -> @foo {
+fn to_foo_2<T:Clone>(t: T) -> @foo {
     // Not OK---T may contain borrowed ptrs and it is going to escape
     // as part of the returned foo value
     struct F<T> { f: T }
     @F {f:t} as @foo //~ ERROR value may contain borrowed pointers; add `'static` bound
 }
 
-fn to_foo_3<T:Copy + 'static>(t: T) -> @foo {
+fn to_foo_3<T:Clone + 'static>(t: T) -> @foo {
     // OK---T may escape as part of the returned foo value, but it is
     // owned and hence does not contain borrowed ptrs
     struct F<T> { f: T }
diff --git a/src/test/compile-fail/kindck-owned-trait.rs b/src/test/compile-fail/kindck-owned-trait.rs
index c2352e35a46e..73d59ff8af21 100644
--- a/src/test/compile-fail/kindck-owned-trait.rs
+++ b/src/test/compile-fail/kindck-owned-trait.rs
@@ -10,13 +10,13 @@
 
 trait foo { fn foo(&self); }
 
-fn to_foo<T:Copy + foo>(t: T) -> @foo {
+fn to_foo<T:Clone + foo>(t: T) -> @foo {
     @t as @foo
     //~^ ERROR value may contain borrowed pointers; add `'static` bound
     //~^^ ERROR cannot pack type
 }
 
-fn to_foo2<T:Copy + foo + 'static>(t: T) -> @foo {
+fn to_foo2<T:Clone + foo + 'static>(t: T) -> @foo {
     @t as @foo
 }
 
diff --git a/src/test/compile-fail/trait-bounds-cant-coerce.rs b/src/test/compile-fail/trait-bounds-cant-coerce.rs
index a96da398f5a1..72d6b70a7c2c 100644
--- a/src/test/compile-fail/trait-bounds-cant-coerce.rs
+++ b/src/test/compile-fail/trait-bounds-cant-coerce.rs
@@ -14,11 +14,11 @@ trait Foo {
 fn a(_x: ~Foo:Send) {
 }
 
-fn b(_x: ~Foo:Send+Copy) {
+fn b(_x: ~Foo:Send+Clone) {
 }
 
 fn c(x: ~Foo:Freeze+Send) {
-    b(x); //~ ERROR expected bounds `Copy+Send`
+    b(x); //~ ERROR expected bounds `Clone+Send`
 }
 
 fn d(x: ~Foo:) {
diff --git a/src/test/run-pass/auto-instantiate.rs b/src/test/run-pass/auto-instantiate.rs
index 184fef52c8c1..47cf12629013 100644
--- a/src/test/run-pass/auto-instantiate.rs
+++ b/src/test/run-pass/auto-instantiate.rs
@@ -16,7 +16,7 @@
 struct Pair<T, U> { a: T, b: U }
 struct Triple { x: int, y: int, z: int }
 
-fn f<T:Copy,U:Copy>(x: T, y: U) -> Pair<T, U> { return Pair {a: x, b: y}; }
+fn f<T,U>(x: T, y: U) -> Pair<T, U> { return Pair {a: x, b: y}; }
 
 pub fn main() {
     info!("%?", f(Triple {x: 3, y: 4, z: 5}, 4).a.x);
diff --git a/src/test/run-pass/autobind.rs b/src/test/run-pass/autobind.rs
index 0788c74d0785..440ad723a12c 100644
--- a/src/test/run-pass/autobind.rs
+++ b/src/test/run-pass/autobind.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f<T:Copy>(x: ~[T]) -> T { return x[0]; }
+fn f<T>(x: ~[T]) -> T { return x[0]; }
 
 fn g(act: &fn(~[int]) -> int) -> int { return act(~[1, 2, 3]); }
 
diff --git a/src/test/run-pass/cond-macro-no-default.rs b/src/test/run-pass/cond-macro-no-default.rs
index 6b90308f8a86..8bd1a772e55e 100644
--- a/src/test/run-pass/cond-macro-no-default.rs
+++ b/src/test/run-pass/cond-macro-no-default.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn clamp<T:Copy + Ord + Signed>(x: T, mn: T, mx: T) -> T {
+fn clamp<T:Ord + Signed>(x: T, mn: T, mx: T) -> T {
     cond!(
         (x > mx) { return mx; }
         (x < mn) { return mn; }
diff --git a/src/test/run-pass/cond-macro.rs b/src/test/run-pass/cond-macro.rs
index 929752b3f1a0..61a51b672611 100644
--- a/src/test/run-pass/cond-macro.rs
+++ b/src/test/run-pass/cond-macro.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn clamp<T:Copy + Ord + Signed>(x: T, mn: T, mx: T) -> T {
+fn clamp<T:Ord + Signed>(x: T, mn: T, mx: T) -> T {
     cond!(
         (x > mx) { mx }
         (x < mn) { mn }
diff --git a/src/test/run-pass/const-bound.rs b/src/test/run-pass/const-bound.rs
index 05f586f76e95..635ae704e419 100644
--- a/src/test/run-pass/const-bound.rs
+++ b/src/test/run-pass/const-bound.rs
@@ -12,7 +12,7 @@
 // are const.
 
 
-fn foo<T:Copy + Freeze>(x: T) -> T { x }
+fn foo<T:Freeze>(x: T) -> T { x }
 
 struct F { field: int }
 
diff --git a/src/test/run-pass/expr-block-generic-unique1.rs b/src/test/run-pass/expr-block-generic-unique1.rs
index 679210351bd1..0249820410c4 100644
--- a/src/test/run-pass/expr-block-generic-unique1.rs
+++ b/src/test/run-pass/expr-block-generic-unique1.rs
@@ -13,7 +13,7 @@
 // -*- rust -*-
 type compare<T> = @fn(~T, ~T) -> bool;
 
-fn test_generic<T:Copy+Clone>(expected: ~T, eq: compare<T>) {
+fn test_generic<T:Clone>(expected: ~T, eq: compare<T>) {
     let actual: ~T = { expected.clone() };
     assert!((eq(expected, actual)));
 }
diff --git a/src/test/run-pass/expr-fn.rs b/src/test/run-pass/expr-fn.rs
index e4eae9c4c399..cba1bab30046 100644
--- a/src/test/run-pass/expr-fn.rs
+++ b/src/test/run-pass/expr-fn.rs
@@ -19,7 +19,7 @@ fn test_vec() {
 }
 
 fn test_generic() {
-    fn f<T:Copy>(t: T) -> T { t }
+    fn f<T>(t: T) -> T { t }
     assert_eq!(f(10), 10);
 }
 
diff --git a/src/test/run-pass/expr-match-generic-unique1.rs b/src/test/run-pass/expr-match-generic-unique1.rs
index 085d52d6d7f9..0f564e6a7802 100644
--- a/src/test/run-pass/expr-match-generic-unique1.rs
+++ b/src/test/run-pass/expr-match-generic-unique1.rs
@@ -13,7 +13,7 @@
 // -*- rust -*-
 type compare<T> = @fn(~T, ~T) -> bool;
 
-fn test_generic<T:Copy+Clone>(expected: ~T, eq: compare<T>) {
+fn test_generic<T:Clone>(expected: ~T, eq: compare<T>) {
     let actual: ~T = match true {
         true => { expected.clone() },
         _ => fail!("wat")
diff --git a/src/test/run-pass/expr-match-generic-unique2.rs b/src/test/run-pass/expr-match-generic-unique2.rs
index 7ef1fb8cab84..ae88d48bc443 100644
--- a/src/test/run-pass/expr-match-generic-unique2.rs
+++ b/src/test/run-pass/expr-match-generic-unique2.rs
@@ -13,7 +13,7 @@
 
 type compare<T> = @fn(T, T) -> bool;
 
-fn test_generic<T:Copy+Clone>(expected: T, eq: compare<T>) {
+fn test_generic<T:Clone>(expected: T, eq: compare<T>) {
     let actual: T = match true {
         true => expected.clone(),
         _ => fail!("wat")
diff --git a/src/test/run-pass/generic-alias-box.rs b/src/test/run-pass/generic-alias-box.rs
index efb514caba95..2cd505f1f7d2 100644
--- a/src/test/run-pass/generic-alias-box.rs
+++ b/src/test/run-pass/generic-alias-box.rs
@@ -10,7 +10,7 @@
 
 
 
-fn id<T:Copy>(t: T) -> T { return t; }
+fn id<T>(t: T) -> T { return t; }
 
 pub fn main() {
     let expected = @100;
diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs
index 203adf81cecd..7a6cb9470b2a 100644
--- a/src/test/run-pass/generic-alias-unique.rs
+++ b/src/test/run-pass/generic-alias-unique.rs
@@ -10,7 +10,7 @@
 
 
 
-fn id<T:Copy + Send>(t: T) -> T { return t; }
+fn id<T:Send>(t: T) -> T { return t; }
 
 pub fn main() {
     let expected = ~100;
diff --git a/src/test/run-pass/generic-box.rs b/src/test/run-pass/generic-box.rs
index 7248e5770698..a3e933f3ceb0 100644
--- a/src/test/run-pass/generic-box.rs
+++ b/src/test/run-pass/generic-box.rs
@@ -10,7 +10,7 @@
 
 
 
-fn box<T:Copy>(x: Box<T>) -> @Box<T> { return @x; }
+fn box<T>(x: Box<T>) -> @Box<T> { return @x; }
 
 struct Box<T> {x: T, y: T, z: T}
 
diff --git a/src/test/run-pass/generic-drop-glue.rs b/src/test/run-pass/generic-drop-glue.rs
index 19e11197fd91..9592f9ff7361 100644
--- a/src/test/run-pass/generic-drop-glue.rs
+++ b/src/test/run-pass/generic-drop-glue.rs
@@ -11,6 +11,6 @@
 
 struct Pair { x: @int, y: @int }
 
-fn f<T:Copy>(t: T) { let t1: T = t; }
+fn f<T>(t: T) { let t1: T = t; }
 
 pub fn main() { let x = Pair {x: @10, y: @12}; f(x); }
diff --git a/src/test/run-pass/generic-exterior-box.rs b/src/test/run-pass/generic-exterior-box.rs
index 79ee544d4955..b7fe704749c7 100644
--- a/src/test/run-pass/generic-exterior-box.rs
+++ b/src/test/run-pass/generic-exterior-box.rs
@@ -12,7 +12,7 @@
 
 struct Recbox<T> {x: @T}
 
-fn reclift<T:Copy>(t: T) -> Recbox<T> { return Recbox {x: @t}; }
+fn reclift<T>(t: T) -> Recbox<T> { return Recbox {x: @t}; }
 
 pub fn main() {
     let foo: int = 17;
diff --git a/src/test/run-pass/generic-exterior-unique.rs b/src/test/run-pass/generic-exterior-unique.rs
index cc94fca68040..0820923efcfe 100644
--- a/src/test/run-pass/generic-exterior-unique.rs
+++ b/src/test/run-pass/generic-exterior-unique.rs
@@ -10,7 +10,7 @@
 
 struct Recbox<T> {x: ~T}
 
-fn reclift<T:Copy>(t: T) -> Recbox<T> { return Recbox {x: ~t}; }
+fn reclift<T>(t: T) -> Recbox<T> { return Recbox {x: ~t}; }
 
 pub fn main() {
     let foo: int = 17;
diff --git a/src/test/run-pass/generic-fn-infer.rs b/src/test/run-pass/generic-fn-infer.rs
index 7c21bd52d464..092a17bf456c 100644
--- a/src/test/run-pass/generic-fn-infer.rs
+++ b/src/test/run-pass/generic-fn-infer.rs
@@ -14,6 +14,6 @@
 // -*- rust -*-
 
 // Issue #45: infer type parameters in function applications
-fn id<T:Copy>(x: T) -> T { return x; }
+fn id<T>(x: T) -> T { return x; }
 
 pub fn main() { let x: int = 42; let y: int = id(x); assert!((x == y)); }
diff --git a/src/test/run-pass/generic-fn-unique.rs b/src/test/run-pass/generic-fn-unique.rs
index bf4729a05894..3c28b16d3a98 100644
--- a/src/test/run-pass/generic-fn-unique.rs
+++ b/src/test/run-pass/generic-fn-unique.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 
-fn f<T:Copy>(x: ~T) -> ~T { return x; }
+fn f<T>(x: ~T) -> ~T { return x; }
 
 pub fn main() { let x = f(~3); info!(*x); }
diff --git a/src/test/run-pass/generic-fn.rs b/src/test/run-pass/generic-fn.rs
index e5e6beb8c706..34fb22ea0f45 100644
--- a/src/test/run-pass/generic-fn.rs
+++ b/src/test/run-pass/generic-fn.rs
@@ -12,7 +12,7 @@
 
 
 // -*- rust -*-
-fn id<T:Copy>(x: T) -> T { return x; }
+fn id<T>(x: T) -> T { return x; }
 
 struct Triple {x: int, y: int, z: int}
 
diff --git a/src/test/run-pass/generic-tup.rs b/src/test/run-pass/generic-tup.rs
index d09996cc2dae..4a74330f7d67 100644
--- a/src/test/run-pass/generic-tup.rs
+++ b/src/test/run-pass/generic-tup.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn get_third<T:Copy>(t: (T, T, T)) -> T { let (_, _, x) = t; return x; }
+fn get_third<T>(t: (T, T, T)) -> T { let (_, _, x) = t; return x; }
 
 pub fn main() {
     info!(get_third((1, 2, 3)));
diff --git a/src/test/run-pass/generic-unique.rs b/src/test/run-pass/generic-unique.rs
index 8a4fc94135b9..71cc43278602 100644
--- a/src/test/run-pass/generic-unique.rs
+++ b/src/test/run-pass/generic-unique.rs
@@ -10,7 +10,7 @@
 
 struct Triple<T> { x: T, y: T, z: T }
 
-fn box<T:Copy>(x: Triple<T>) -> ~Triple<T> { return ~x; }
+fn box<T>(x: Triple<T>) -> ~Triple<T> { return ~x; }
 
 pub fn main() {
     let x: ~Triple<int> = box::<int>(Triple{x: 1, y: 2, z: 3});
diff --git a/src/test/run-pass/issue-2288.rs b/src/test/run-pass/issue-2288.rs
index 9aef66fd35c5..e951eef37056 100644
--- a/src/test/run-pass/issue-2288.rs
+++ b/src/test/run-pass/issue-2288.rs
@@ -8,25 +8,25 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-trait clam<A:Copy> {
+trait clam<A> {
   fn chowder(&self, y: A);
 }
 struct foo<A> {
   x: A,
 }
 
-impl<A:Copy> clam<A> for foo<A> {
+impl<A> clam<A> for foo<A> {
   fn chowder(&self, y: A) {
   }
 }
 
-fn foo<A:Copy>(b: A) -> foo<A> {
+fn foo<A>(b: A) -> foo<A> {
     foo {
         x: b
     }
 }
 
-fn f<A:Copy>(x: @clam<A>, a: A) {
+fn f<A>(x: @clam<A>, a: A) {
   x.chowder(a);
 }
 
diff --git a/src/test/run-pass/issue-2311-2.rs b/src/test/run-pass/issue-2311-2.rs
index 155f9cff2962..df7c3b6e7d97 100644
--- a/src/test/run-pass/issue-2311-2.rs
+++ b/src/test/run-pass/issue-2311-2.rs
@@ -8,18 +8,18 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-trait clam<A:Copy> { }
+trait clam<A> { }
 struct foo<A> {
     x: A,
 }
 
-impl<A:Copy> foo<A> {
+impl<A> foo<A> {
    pub fn bar<B,C:clam<A>>(&self, c: C) -> B {
      fail!();
    }
 }
 
-fn foo<A:Copy>(b: A) -> foo<A> {
+fn foo<A>(b: A) -> foo<A> {
     foo {
         x: b
     }
diff --git a/src/test/run-pass/issue-2445-b.rs b/src/test/run-pass/issue-2445-b.rs
index c26038afd764..432e8c19d2a9 100644
--- a/src/test/run-pass/issue-2445-b.rs
+++ b/src/test/run-pass/issue-2445-b.rs
@@ -12,18 +12,18 @@ struct c1<T> {
     x: T,
 }
 
-impl<T:Copy> c1<T> {
+impl<T> c1<T> {
     pub fn f1(&self, x: int) {
     }
 }
 
-fn c1<T:Copy>(x: T) -> c1<T> {
+fn c1<T>(x: T) -> c1<T> {
     c1 {
         x: x
     }
 }
 
-impl<T:Copy> c1<T> {
+impl<T> c1<T> {
     pub fn f2(&self, x: int) {
     }
 }
diff --git a/src/test/run-pass/issue-2445.rs b/src/test/run-pass/issue-2445.rs
index 64d607259787..3c0a9355b587 100644
--- a/src/test/run-pass/issue-2445.rs
+++ b/src/test/run-pass/issue-2445.rs
@@ -12,17 +12,17 @@ struct c1<T> {
     x: T,
 }
 
-impl<T:Copy> c1<T> {
+impl<T> c1<T> {
     pub fn f1(&self, x: T) {}
 }
 
-fn c1<T:Copy>(x: T) -> c1<T> {
+fn c1<T>(x: T) -> c1<T> {
     c1 {
         x: x
     }
 }
 
-impl<T:Copy> c1<T> {
+impl<T> c1<T> {
     pub fn f2(&self, x: T) {}
 }
 
diff --git a/src/test/run-pass/issue-2550.rs b/src/test/run-pass/issue-2550.rs
index f59777138903..af0b937f602c 100644
--- a/src/test/run-pass/issue-2550.rs
+++ b/src/test/run-pass/issue-2550.rs
@@ -18,7 +18,7 @@ fn C(x: uint) -> C {
     }
 }
 
-fn f<T:Copy>(_x: T) {
+fn f<T>(_x: T) {
 }
 
 #[deny(non_implicitly_copyable_typarams)]
diff --git a/src/test/run-pass/issue-2611-3.rs b/src/test/run-pass/issue-2611-3.rs
index 7f6535526312..56c18d557f0d 100644
--- a/src/test/run-pass/issue-2611-3.rs
+++ b/src/test/run-pass/issue-2611-3.rs
@@ -12,7 +12,7 @@
 // than the traits require.
 
 trait A {
-  fn b<C:Copy + Freeze,D>(x: C) -> C;
+  fn b<C:Freeze,D>(x: C) -> C;
 }
 
 struct E {
@@ -20,7 +20,7 @@ struct E {
 }
 
 impl A for E {
-  fn b<F:Copy,G>(_x: F) -> F { fail!() } //~ ERROR in method `b`, type parameter 0 has 1 bound, but
+  fn b<F,G>(_x: F) -> F { fail!() } //~ ERROR in method `b`, type parameter 0 has 1 bound, but
 }
 
 fn main() {}
diff --git a/src/test/run-pass/issue-3149.rs b/src/test/run-pass/issue-3149.rs
index e433141c44db..ab64fb4fbfa1 100644
--- a/src/test/run-pass/issue-3149.rs
+++ b/src/test/run-pass/issue-3149.rs
@@ -8,12 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn Matrix4<T:Copy>(m11: T, m12: T, m13: T, m14: T,
-                   m21: T, m22: T, m23: T, m24: T,
-                   m31: T, m32: T, m33: T, m34: T,
-                   m41: T, m42: T, m43: T, m44: T)
-                -> Matrix4<T> {
-
+fn Matrix4<T>(m11: T, m12: T, m13: T, m14: T,
+              m21: T, m22: T, m23: T, m24: T,
+              m31: T, m32: T, m33: T, m34: T,
+              m41: T, m42: T, m43: T, m44: T)
+              -> Matrix4<T> {
     Matrix4 {
         m11: m11, m12: m12, m13: m13, m14: m14,
         m21: m21, m22: m22, m23: m23, m24: m24,
diff --git a/src/test/run-pass/issue-333.rs b/src/test/run-pass/issue-333.rs
index 9791b6cdc530..1217f32826f6 100644
--- a/src/test/run-pass/issue-333.rs
+++ b/src/test/run-pass/issue-333.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn quux<T:Copy>(x: T) -> T { let f = id::<T>; return f(x); }
+fn quux<T>(x: T) -> T { let f = id::<T>; return f(x); }
 
-fn id<T:Copy>(x: T) -> T { return x; }
+fn id<T>(x: T) -> T { return x; }
 
 pub fn main() { assert!((quux(10) == 10)); }
diff --git a/src/test/run-pass/ivec-add.rs b/src/test/run-pass/ivec-add.rs
index 61c63245d702..ecf530f07f30 100644
--- a/src/test/run-pass/ivec-add.rs
+++ b/src/test/run-pass/ivec-add.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn double<T:Copy + Clone>(a: T) -> ~[T] { return ~[a.clone()] + ~[a]; }
+fn double<T:Clone>(a: T) -> ~[T] { return ~[a.clone()] + ~[a]; }
 
 fn double_int(a: int) -> ~[int] { return ~[a] + ~[a]; }
 
diff --git a/src/test/run-pass/monad.rs b/src/test/run-pass/monad.rs
index fe06c973dbfd..eaf9eafa2a5d 100644
--- a/src/test/run-pass/monad.rs
+++ b/src/test/run-pass/monad.rs
@@ -13,11 +13,11 @@
 use std::int;
 
 trait vec_monad<A> {
-    fn bind<B:Copy>(&self, f: &fn(&A) -> ~[B]) -> ~[B];
+    fn bind<B>(&self, f: &fn(&A) -> ~[B]) -> ~[B];
 }
 
 impl<A> vec_monad<A> for ~[A] {
-    fn bind<B:Copy>(&self, f: &fn(&A) -> ~[B]) -> ~[B] {
+    fn bind<B>(&self, f: &fn(&A) -> ~[B]) -> ~[B] {
         let mut r = ~[];
         for self.iter().advance |elt| {
             r.push_all_move(f(elt));
diff --git a/src/test/run-pass/monomorphized-callees-with-ty-params-3314.rs b/src/test/run-pass/monomorphized-callees-with-ty-params-3314.rs
index eb3c1e4cd27c..3146c2a94997 100644
--- a/src/test/run-pass/monomorphized-callees-with-ty-params-3314.rs
+++ b/src/test/run-pass/monomorphized-callees-with-ty-params-3314.rs
@@ -25,7 +25,7 @@ impl Serializable for int {
 
 struct F<A> { a: A }
 
-impl<A:Copy + Serializable> Serializable for F<A> {
+impl<A:Serializable> Serializable for F<A> {
     fn serialize<S:Serializer>(&self, s: S) {
         self.a.serialize(s);
     }
diff --git a/src/test/run-pass/non-boolean-pure-fns.rs b/src/test/run-pass/non-boolean-pure-fns.rs
index c08f52cba159..8257d495d460 100644
--- a/src/test/run-pass/non-boolean-pure-fns.rs
+++ b/src/test/run-pass/non-boolean-pure-fns.rs
@@ -14,15 +14,15 @@ extern mod extra;
 
 use extra::list::*;
 
-fn pure_length_go<T:Copy>(ls: @List<T>, acc: uint) -> uint {
+fn pure_length_go<T>(ls: @List<T>, acc: uint) -> uint {
     match *ls { Nil => { acc } Cons(_, tl) => { pure_length_go(tl, acc + 1u) } }
 }
 
-fn pure_length<T:Copy>(ls: @List<T>) -> uint { pure_length_go(ls, 0u) }
+fn pure_length<T>(ls: @List<T>) -> uint { pure_length_go(ls, 0u) }
 
-fn nonempty_list<T:Copy>(ls: @List<T>) -> bool { pure_length(ls) > 0u }
+fn nonempty_list<T>(ls: @List<T>) -> bool { pure_length(ls) > 0u }
 
-fn safe_head<T:Copy>(ls: @List<T>) -> T {
+fn safe_head<T>(ls: @List<T>) -> T {
     assert!(!is_empty(ls));
     return head(ls);
 }
diff --git a/src/test/run-pass/ret-break-cont-in-block.rs b/src/test/run-pass/ret-break-cont-in-block.rs
index 2b8b7c6a788d..341c1b96e36d 100644
--- a/src/test/run-pass/ret-break-cont-in-block.rs
+++ b/src/test/run-pass/ret-break-cont-in-block.rs
@@ -23,7 +23,7 @@ fn iter<T>(v: ~[T], it: &fn(&T) -> bool) -> bool {
     return true;
 }
 
-fn find_pos<T:Eq + Copy + Clone>(n: T, h: ~[T]) -> Option<uint> {
+fn find_pos<T:Eq + Clone>(n: T, h: ~[T]) -> Option<uint> {
     let mut i = 0u;
     for iter(h.clone()) |e| {
         if *e == n { return Some(i); }
diff --git a/src/test/run-pass/ret-none.rs b/src/test/run-pass/ret-none.rs
index d493f23ba840..b1974f710956 100644
--- a/src/test/run-pass/ret-none.rs
+++ b/src/test/run-pass/ret-none.rs
@@ -12,6 +12,6 @@
 
 enum option<T> { none, some(T), }
 
-fn f<T:Copy>() -> option<T> { return none; }
+fn f<T>() -> option<T> { return none; }
 
 pub fn main() { f::<int>(); }
diff --git a/src/test/run-pass/static-impl.rs b/src/test/run-pass/static-impl.rs
index 0ddc39d6b18c..1588bd1a5a54 100644
--- a/src/test/run-pass/static-impl.rs
+++ b/src/test/run-pass/static-impl.rs
@@ -43,13 +43,13 @@ impl uint_utils for uint {
 trait vec_utils<T> {
     fn length_(&self, ) -> uint;
     fn iter_(&self, f: &fn(&T));
-    fn map_<U:Copy>(&self, f: &fn(&T) -> U) -> ~[U];
+    fn map_<U>(&self, f: &fn(&T) -> U) -> ~[U];
 }
 
 impl<T> vec_utils<T> for ~[T] {
     fn length_(&self) -> uint { self.len() }
     fn iter_(&self, f: &fn(&T)) { for self.iter().advance |x| { f(x); } }
-    fn map_<U:Copy>(&self, f: &fn(&T) -> U) -> ~[U] {
+    fn map_<U>(&self, f: &fn(&T) -> U) -> ~[U] {
         let mut r = ~[];
         for self.iter().advance |elt| {
             r.push(f(elt));
diff --git a/src/test/run-pass/tag-align-dyn-variants.rs b/src/test/run-pass/tag-align-dyn-variants.rs
index 85a4f98d198c..fa3b0a4ea33b 100644
--- a/src/test/run-pass/tag-align-dyn-variants.rs
+++ b/src/test/run-pass/tag-align-dyn-variants.rs
@@ -24,7 +24,7 @@ struct t_rec<A,B> {
     tB: a_tag<A,B>
 }
 
-fn mk_rec<A:Copy,B:Copy>(a: A, b: B) -> t_rec<A,B> {
+fn mk_rec<A,B>(a: A, b: B) -> t_rec<A,B> {
     return t_rec{ chA:0u8, tA:varA(a), chB:1u8, tB:varB(b) };
 }
 
diff --git a/src/test/run-pass/trait-bounds-basic.rs b/src/test/run-pass/trait-bounds-basic.rs
index e0d60d62bb58..cc2c12e41090 100644
--- a/src/test/run-pass/trait-bounds-basic.rs
+++ b/src/test/run-pass/trait-bounds-basic.rs
@@ -21,7 +21,7 @@ fn c(x: ~Foo:Freeze+Send) {
     a(x);
 }
 
-fn d(x: ~Foo:Send+Copy) {
+fn d(x: ~Foo:Send) {
     b(x);
 }
 
diff --git a/src/test/run-pass/trait-generic.rs b/src/test/run-pass/trait-generic.rs
index 5952afa6676b..d6218a6ad8e8 100644
--- a/src/test/run-pass/trait-generic.rs
+++ b/src/test/run-pass/trait-generic.rs
@@ -26,10 +26,10 @@ impl to_str for () {
 }
 
 trait map<T> {
-    fn map<U:Copy>(&self, f: &fn(&T) -> U) -> ~[U];
+    fn map<U>(&self, f: &fn(&T) -> U) -> ~[U];
 }
 impl<T> map<T> for ~[T] {
-    fn map<U:Copy>(&self, f: &fn(&T) -> U) -> ~[U] {
+    fn map<U>(&self, f: &fn(&T) -> U) -> ~[U] {
         let mut r = ~[];
         // FIXME: #7355 generates bad code with Iterator
         for std::uint::range(0, self.len()) |i| {
diff --git a/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs b/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs
index 21f840ca8d34..84d54d9d0df4 100644
--- a/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs
+++ b/src/test/run-pass/trait-inheritance-overloading-xc-exe.rs
@@ -14,7 +14,7 @@
 extern mod trait_inheritance_overloading_xc;
 use trait_inheritance_overloading_xc::{MyNum, MyInt};
 
-fn f<T:Copy + MyNum>(x: T, y: T) -> (T, T, T) {
+fn f<T:MyNum>(x: T, y: T) -> (T, T, T) {
     return (x + y, x - y, x * y);
 }
 
diff --git a/src/test/run-pass/trait-inheritance-overloading.rs b/src/test/run-pass/trait-inheritance-overloading.rs
index 302d3d87df90..d5321ea52983 100644
--- a/src/test/run-pass/trait-inheritance-overloading.rs
+++ b/src/test/run-pass/trait-inheritance-overloading.rs
@@ -33,7 +33,7 @@ impl Eq for MyInt {
 
 impl MyNum for MyInt;
 
-fn f<T:Copy + MyNum>(x: T, y: T) -> (T, T, T) {
+fn f<T:MyNum>(x: T, y: T) -> (T, T, T) {
     return (x + y, x - y, x * y);
 }
 
diff --git a/src/test/run-pass/type-param-constraints.rs b/src/test/run-pass/type-param-constraints.rs
index 216a7a939fe0..8968fe49bc1d 100644
--- a/src/test/run-pass/type-param-constraints.rs
+++ b/src/test/run-pass/type-param-constraints.rs
@@ -11,7 +11,7 @@
 // xfail-fast
 
 fn p_foo<T>(pinned: T) { }
-fn s_foo<T:Copy>(shared: T) { }
+fn s_foo<T>(shared: T) { }
 fn u_foo<T:Send>(unique: T) { }
 
 struct r {
diff --git a/src/test/run-pass/uniq-cc-generic.rs b/src/test/run-pass/uniq-cc-generic.rs
index 2c3424d1f06f..5d115139bdc8 100644
--- a/src/test/run-pass/uniq-cc-generic.rs
+++ b/src/test/run-pass/uniq-cc-generic.rs
@@ -20,7 +20,7 @@ struct Pointy {
     d : ~fn() -> uint,
 }
 
-fn make_uniq_closure<A:Send + Copy>(a: A) -> ~fn() -> uint {
+fn make_uniq_closure<A:Send>(a: A) -> ~fn() -> uint {
     let result: ~fn() -> uint = || ptr::to_unsafe_ptr(&a) as uint;
     result
 }
diff --git a/src/test/run-pass/unique-assign-generic.rs b/src/test/run-pass/unique-assign-generic.rs
index 67ffc797ee4b..eb2638f25688 100644
--- a/src/test/run-pass/unique-assign-generic.rs
+++ b/src/test/run-pass/unique-assign-generic.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f<T:Copy>(t: T) -> T {
+fn f<T>(t: T) -> T {
     let t1 = t;
     t1
 }
diff --git a/src/test/run-pass/unique-generic-assign.rs b/src/test/run-pass/unique-generic-assign.rs
index ab92b10a3320..3805cbe47bf6 100644
--- a/src/test/run-pass/unique-generic-assign.rs
+++ b/src/test/run-pass/unique-generic-assign.rs
@@ -10,7 +10,7 @@
 
 // Issue #976
 
-fn f<T:Copy>(x: ~T) {
+fn f<T>(x: ~T) {
     let _x2 = x;
 }
 pub fn main() { }
diff --git a/src/test/run-pass/unique-kinds.rs b/src/test/run-pass/unique-kinds.rs
index 391881deff66..11425a94ce9e 100644
--- a/src/test/run-pass/unique-kinds.rs
+++ b/src/test/run-pass/unique-kinds.rs
@@ -30,11 +30,11 @@ fn sendable() {
 
 fn copyable() {
 
-    fn f<T:Copy + Eq>(i: T, j: T) {
+    fn f<T:Eq>(i: T, j: T) {
         assert_eq!(i, j);
     }
 
-    fn g<T:Copy + Eq>(i: T, j: T) {
+    fn g<T:Eq>(i: T, j: T) {
         assert!(i != j);
     }
 
diff --git a/src/test/run-pass/vec-matching-fold.rs b/src/test/run-pass/vec-matching-fold.rs
index 05a6dee06cc8..22f1ccb8bbb0 100644
--- a/src/test/run-pass/vec-matching-fold.rs
+++ b/src/test/run-pass/vec-matching-fold.rs
@@ -1,8 +1,7 @@
-fn foldl<T, U: Copy+Clone>(
-    values: &[T],
-    initial: U,
-    function: &fn(partial: U, element: &T) -> U
-) -> U {
+fn foldl<T,U:Clone>(values: &[T],
+                    initial: U,
+                    function: &fn(partial: U, element: &T) -> U)
+                    -> U {
     match values {
         [ref head, ..tail] =>
             foldl(tail, function(initial, head), function),
@@ -10,11 +9,10 @@ fn foldl<T, U: Copy+Clone>(
     }
 }
 
-fn foldr<T, U: Copy+Clone>(
-    values: &[T],
-    initial: U,
-    function: &fn(element: &T, partial: U) -> U
-) -> U {
+fn foldr<T,U:Clone>(values: &[T],
+                    initial: U,
+                    function: &fn(element: &T, partial: U) -> U)
+                    -> U {
     match values {
         [..head, ref tail] =>
             foldr(head, function(tail, initial), function),