librustc: Remove the Copy bound from the language.

Author: pcwalton

src/libextra/flate.rs

@@ -87,7 +87,6 @@ mod tests {
     use std::rand::RngUtil;
 
     #[test]
-    #[allow(non_implicitly_copyable_typarams)]
     fn test_flate_round_trip() {
         let mut r = rand::rng();
         let mut words = ~[];

src/libextra/future.rs

@@ -145,7 +145,6 @@ pub fn spawn<A:Send>(blk: ~fn() -> A) -> Future<A> {
     return from_port(port);
 }
 
-#[allow(non_implicitly_copyable_typarams)]
 #[cfg(test)]
 mod test {
     use future::*;

src/libextra/par.rs

@@ -1,4 +1,4 @@
-// Cloneright 2012 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //

src/libextra/test.rs

@@ -671,7 +671,6 @@ fn get_concurrency() -> uint {
     else { threads * SCHED_OVERCOMMIT }
 }
 
-#[allow(non_implicitly_copyable_typarams)]
 pub fn filter_tests(
     opts: &TestOpts,
     tests: ~[TestDescAndFn]) -> ~[TestDescAndFn]

src/librustc/metadata/tydecode.rs

@@ -561,9 +561,6 @@ fn parse_bounds(st: &mut PState, conv: conv_did) -> ty::ParamBounds {
             'S' => {
                 param_bounds.builtin_bounds.add(ty::BoundSend);
             }
-            'C' => {
-                param_bounds.builtin_bounds.add(ty::BoundCopy);
-            }
             'K' => {
                 param_bounds.builtin_bounds.add(ty::BoundFreeze);
             }

src/librustc/metadata/tyencode.rs

@@ -400,7 +400,6 @@ fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: &ty::ParamBounds) {
     for bs.builtin_bounds.each |bound| {
         match bound {
             ty::BoundSend => w.write_char('S'),
-            ty::BoundCopy => w.write_char('C'),
             ty::BoundFreeze => w.write_char('K'),
             ty::BoundStatic => w.write_char('O'),
             ty::BoundSized => w.write_char('Z'),

src/librustc/middle/borrowck/mod.rs

@@ -586,7 +586,7 @@ impl BorrowckCtxt {
                 ty::ty_closure(ref cty) if cty.sigil == ast::BorrowedSigil =>
                     "a non-copyable stack closure (capture it in a new closure, \
                      e.g. `|x| f(x)`, to override)",
-                _ if !ty::type_is_copyable(tcx, ty) =>
+                _ if ty::type_moves_by_default(tcx, ty) =>
                     "non-copyable (perhaps you meant to use clone()?)",
                 _ => default_msg,
             }

src/librustc/middle/kind.rs

@@ -29,22 +29,19 @@ use syntax::{visit, ast_util};
 // of the following attributes.
 //
 //  send: Things that can be sent on channels or included in spawned closures.
-//  copy: Things that can be copied.
 //  freeze: Things thare are deeply immutable. They are guaranteed never to
 //    change, and can be safely shared without copying between tasks.
 //  'static: Things that do not contain borrowed pointers.
 //
 // Send includes scalar types as well as classes and unique types containing
 // only sendable types.
 //
-// Copy includes boxes, closure and unique types containing copyable types.
-//
 // Freeze include scalar types, things without non-const fields, and pointers
 // to freezable things.
 //
 // This pass ensures that type parameters are only instantiated with types
 // whose kinds are equal or less general than the way the type parameter was
-// annotated (with the `Send`, `Copy` or `Freeze` bound).
+// annotated (with the `Send` or `Freeze` bound).
 //
 // It also verifies that noncopyable kinds are not copied. Sendability is not
 // applied, since none of our language primitives send. Instead, the sending

src/librustc/middle/lang_items.rs

@@ -13,7 +13,7 @@
 // Language items are items that represent concepts intrinsic to the language
 // itself. Examples are:
 //
-// * Traits that specify "kinds"; e.g. "Freeze", "Copy", "Send".
+// * Traits that specify "kinds"; e.g. "Freeze", "Send".
 //
 // * Traits that represent operators; e.g. "Add", "Sub", "Index".
 //
@@ -33,63 +33,62 @@ use std::hashmap::HashMap;
 
 pub enum LangItem {
     FreezeTraitLangItem,               // 0
-    CopyTraitLangItem,                 // 1
-    SendTraitLangItem,                 // 2
-    SizedTraitLangItem,                // 3
-
-    DropTraitLangItem,                 // 4
-
-    AddTraitLangItem,                  // 5
-    SubTraitLangItem,                  // 6
-    MulTraitLangItem,                  // 7
-    DivTraitLangItem,                  // 8
-    RemTraitLangItem,                  // 9
-    NegTraitLangItem,                  // 10
-    NotTraitLangItem,                  // 11
+    SendTraitLangItem,                 // 1
+    SizedTraitLangItem,                // 2
+
+    DropTraitLangItem,                 // 3
+
+    AddTraitLangItem,                  // 4
+    SubTraitLangItem,                  // 5
+    MulTraitLangItem,                  // 6
+    DivTraitLangItem,                  // 7
+    RemTraitLangItem,                  // 8
+    NegTraitLangItem,                  // 9
+    NotTraitLangItem,                  // 10
     BitXorTraitLangItem,               // 11
-    BitAndTraitLangItem,               // 13
-    BitOrTraitLangItem,                // 14
-    ShlTraitLangItem,                  // 15
-    ShrTraitLangItem,                  // 16
-    IndexTraitLangItem,                // 17
-
-    EqTraitLangItem,                   // 18
-    OrdTraitLangItem,                  // 19
-
-    StrEqFnLangItem,                   // 20
-    UniqStrEqFnLangItem,               // 21
-    AnnihilateFnLangItem,              // 22
-    LogTypeFnLangItem,                 // 23
-    FailFnLangItem,                    // 24
-    FailBoundsCheckFnLangItem,         // 25
-    ExchangeMallocFnLangItem,          // 26
-    ClosureExchangeMallocFnLangItem,   // 27
-    ExchangeFreeFnLangItem,            // 28
-    MallocFnLangItem,                  // 29
-    FreeFnLangItem,                    // 30
-    BorrowAsImmFnLangItem,             // 31
-    BorrowAsMutFnLangItem,             // 32
-    ReturnToMutFnLangItem,             // 33
-    CheckNotBorrowedFnLangItem,        // 34
-    StrDupUniqFnLangItem,              // 35
-    RecordBorrowFnLangItem,            // 36
-    UnrecordBorrowFnLangItem,          // 37
-
-    StartFnLangItem,                   // 38
-
-    TyDescStructLangItem,              // 39
-    TyVisitorTraitLangItem,            // 40
-    OpaqueStructLangItem,              // 41
+    BitAndTraitLangItem,               // 12
+    BitOrTraitLangItem,                // 13
+    ShlTraitLangItem,                  // 14
+    ShrTraitLangItem,                  // 15
+    IndexTraitLangItem,                // 16
+
+    EqTraitLangItem,                   // 17
+    OrdTraitLangItem,                  // 18
+
+    StrEqFnLangItem,                   // 19
+    UniqStrEqFnLangItem,               // 20
+    AnnihilateFnLangItem,              // 21
+    LogTypeFnLangItem,                 // 22
+    FailFnLangItem,                    // 23
+    FailBoundsCheckFnLangItem,         // 24
+    ExchangeMallocFnLangItem,          // 25
+    ClosureExchangeMallocFnLangItem,   // 26
+    ExchangeFreeFnLangItem,            // 27
+    MallocFnLangItem,                  // 28
+    FreeFnLangItem,                    // 29
+    BorrowAsImmFnLangItem,             // 30
+    BorrowAsMutFnLangItem,             // 31
+    ReturnToMutFnLangItem,             // 32
+    CheckNotBorrowedFnLangItem,        // 33
+    StrDupUniqFnLangItem,              // 34
+    RecordBorrowFnLangItem,            // 35
+    UnrecordBorrowFnLangItem,          // 36
+
+    StartFnLangItem,                   // 37
+
+    TyDescStructLangItem,              // 38
+    TyVisitorTraitLangItem,            // 39
+    OpaqueStructLangItem,              // 40
 }
 
 pub struct LanguageItems {
-    items: [Option<def_id>, ..42]
+    items: [Option<def_id>, ..41]
 }
 
 impl LanguageItems {
     pub fn new() -> LanguageItems {
         LanguageItems {
-            items: [ None, ..42 ]
+            items: [ None, ..41 ]
         }
     }
 
@@ -100,52 +99,51 @@ impl LanguageItems {
     pub fn item_name(index: uint) -> &'static str {
         match index {
             0  => "freeze",
-            1  => "copy",
-            2  => "send",
-            3  => "sized",
-
-            4  => "drop",
-
-            5  => "add",
-            6  => "sub",
-            7  => "mul",
-            8  => "div",
-            9  => "rem",
-            10 => "neg",
-            11 => "not",
-            12 => "bitxor",
-            13 => "bitand",
-            14 => "bitor",
-            15 => "shl",
-            16 => "shr",
-            17 => "index",
-            18 => "eq",
-            19 => "ord",
-
-            20 => "str_eq",
-            21 => "uniq_str_eq",
-            22 => "annihilate",
-            23 => "log_type",
-            24 => "fail_",
-            25 => "fail_bounds_check",
-            26 => "exchange_malloc",
-            27 => "closure_exchange_malloc",
-            28 => "exchange_free",
-            29 => "malloc",
-            30 => "free",
-            31 => "borrow_as_imm",
-            32 => "borrow_as_mut",
-            33 => "return_to_mut",
-            34 => "check_not_borrowed",
-            35 => "strdup_uniq",
-            36 => "record_borrow",
-            37 => "unrecord_borrow",
-
-            38 => "start",
-
-            39 => "ty_desc",
-            40 => "ty_visitor",
-            41 => "opaque",
+            1  => "send",
+            2  => "sized",
+
+            3  => "drop",
+
+            4  => "add",
+            5  => "sub",
+            6  => "mul",
+            7  => "div",
+            8  => "rem",
+            9  => "neg",
+            10 => "not",
+            11 => "bitxor",
+            12 => "bitand",
+            13 => "bitor",
+            14 => "shl",
+            15 => "shr",
+            16 => "index",
+            17 => "eq",
+            18 => "ord",
+
+            19 => "str_eq",
+            20 => "uniq_str_eq",
+            21 => "annihilate",
+            22 => "log_type",
+            23 => "fail_",
+            24 => "fail_bounds_check",
+            25 => "exchange_malloc",
+            26 => "closure_exchange_malloc",
+            27 => "exchange_free",
+            28 => "malloc",
+            29 => "free",
+            30 => "borrow_as_imm",
+            31 => "borrow_as_mut",
+            32 => "return_to_mut",
+            33 => "check_not_borrowed",
+            34 => "strdup_uniq",
+            35 => "record_borrow",
+            36 => "unrecord_borrow",
+
+            37 => "start",
+
+            38 => "ty_desc",
+            39 => "ty_visitor",
+            40 => "opaque",
 
             _ => "???"
         }
@@ -164,9 +162,6 @@ impl LanguageItems {
     pub fn freeze_trait(&self) -> Option<def_id> {
         self.items[FreezeTraitLangItem as uint]
     }
-    pub fn copy_trait(&self) -> Option<def_id> {
-        self.items[CopyTraitLangItem as uint]
-    }
     pub fn send_trait(&self) -> Option<def_id> {
         self.items[SendTraitLangItem as uint]
     }
@@ -308,7 +303,6 @@ impl<'self> LanguageItemCollector<'self> {
         let mut item_refs = HashMap::new();
 
         item_refs.insert(@"freeze", FreezeTraitLangItem as uint);
-        item_refs.insert(@"copy", CopyTraitLangItem as uint);
         item_refs.insert(@"send", SendTraitLangItem as uint);
         item_refs.insert(@"sized", SizedTraitLangItem as uint);
 

src/librustc/middle/lint.rs

@@ -76,7 +76,6 @@ pub enum lint {
     path_statement,
     implicit_copies,
     unrecognized_lint,
-    non_implicitly_copyable_typarams,
     deprecated_pattern,
     non_camel_case_types,
     non_uppercase_statics,
@@ -182,13 +181,6 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         default: warn
      }),
 
-    ("non_implicitly_copyable_typarams",
-     LintSpec {
-        lint: non_implicitly_copyable_typarams,
-        desc: "passing non implicitly copyable types as copy type params",
-        default: warn
-     }),
-
     ("implicit_copies",
      LintSpec {
         lint: implicit_copies,