cleanup: s/impl Copy/#[derive(Copy)]/g

src/compiletest/common.rs

@@ -13,7 +13,7 @@ use std::fmt;
 use std::str::FromStr;
 
 #[cfg(stage0)] // NOTE: remove impl after snapshot
-#[derive(Clone, PartialEq, Show)]
+#[derive(Clone, Copy, PartialEq, Show)]
 pub enum Mode {
     CompileFail,
     RunFail,
@@ -26,7 +26,7 @@ pub enum Mode {
 }
 
 #[cfg(not(stage0))] // NOTE: remove cfg after snapshot
-#[derive(Clone, PartialEq, Debug)]
+#[derive(Clone, Copy, PartialEq, Debug)]
 pub enum Mode {
     CompileFail,
     RunFail,
@@ -38,9 +38,6 @@ pub enum Mode {
     Codegen
 }
 
-
-impl Copy for Mode {}
-
 impl FromStr for Mode {
     fn from_str(s: &str) -> Option<Mode> {
         match s {

src/doc/reference.md

@@ -1680,8 +1680,8 @@ specific type.
 Implementations are defined with the keyword `impl`.
 
 ```
+# #[derive(Copy)]
 # struct Point {x: f64, y: f64};
-# impl Copy for Point {}
 # type Surface = i32;
 # struct BoundingBox {x: f64, y: f64, width: f64, height: f64};
 # trait Shape { fn draw(&self, Surface); fn bounding_box(&self) -> BoundingBox; }

src/etc/unicode.py

@@ -392,15 +392,13 @@ def emit_grapheme_module(f, grapheme_table, grapheme_cats):
     use core::slice;
 
     #[allow(non_camel_case_types)]
-    #[derive(Clone)]
+    #[derive(Clone, Copy)]
     pub enum GraphemeCat {
 """)
     for cat in grapheme_cats + ["Any"]:
         f.write("        GC_" + cat + ",\n")
     f.write("""    }
 
-    impl Copy for GraphemeCat {}
-
     fn bsearch_range_value_table(c: char, r: &'static [(char, char, GraphemeCat)]) -> GraphemeCat {
         use core::cmp::Ordering::{Equal, Less, Greater};
         match r.binary_search(|&(lo, hi, _)| {

src/libcore/ops.rs

@@ -445,10 +445,9 @@ rem_float_impl! { f64, fmod }
 /// ```
 /// use std::ops::Neg;
 ///
+/// #[derive(Copy)]
 /// struct Foo;
 ///
-/// impl Copy for Foo {}
-///
 /// impl Neg for Foo {
 ///     type Output = Foo;
 ///
@@ -522,10 +521,9 @@ neg_uint_impl! { u64, i64 }
 /// ```
 /// use std::ops::Not;
 ///
+/// #[derive(Copy)]
 /// struct Foo;
 ///
-/// impl Copy for Foo {}
-///
 /// impl Not for Foo {
 ///     type Output = Foo;
 ///

src/librustc_llvm/diagnostic.rs

@@ -37,6 +37,8 @@ impl OptimizationDiagnosticKind {
     }
 }
 
+#[allow(raw_pointer_derive)]
+#[derive(Copy)]
 pub struct OptimizationDiagnostic {
     pub kind: OptimizationDiagnosticKind,
     pub pass_name: *const c_char,
@@ -45,8 +47,6 @@ pub struct OptimizationDiagnostic {
     pub message: TwineRef,
 }
 
-impl Copy for OptimizationDiagnostic {}
-
 impl OptimizationDiagnostic {
     unsafe fn unpack(kind: OptimizationDiagnosticKind, di: DiagnosticInfoRef)
             -> OptimizationDiagnostic {

src/libstd/os.rs

@@ -813,6 +813,8 @@ pub struct MemoryMap {
 }
 
 /// Type of memory map
+#[allow(raw_pointer_derive)]
+#[derive(Copy)]
 pub enum MemoryMapKind {
     /// Virtual memory map. Usually used to change the permissions of a given
     /// chunk of memory.  Corresponds to `VirtualAlloc` on Windows.
@@ -823,9 +825,9 @@ pub enum MemoryMapKind {
     MapVirtual
 }
 
-impl Copy for MemoryMapKind {}
-
 /// Options the memory map is created with
+#[allow(raw_pointer_derive)]
+#[derive(Copy)]
 pub enum MapOption {
     /// The memory should be readable
     MapReadable,
@@ -852,8 +854,6 @@ pub enum MapOption {
     MapNonStandardFlags(c_int),
 }
 
-impl Copy for MapOption {}
-
 /// Possible errors when creating a map.
 #[derive(Copy, Show)]
 pub enum MapError {

src/libunicode/lib.rs

@@ -82,4 +82,5 @@ mod std {
     pub use core::clone;
     pub use core::cmp;
     pub use core::fmt;
+    pub use core::marker;
 }

src/libunicode/tables.rs

@@ -7801,13 +7801,12 @@ pub mod charwidth {
 }
 
 pub mod grapheme {
-    use core::marker::Copy;
     use core::slice::SliceExt;
     pub use self::GraphemeCat::*;
     use core::result::Result::{Ok, Err};
 
     #[allow(non_camel_case_types)]
-    #[derive(Clone)]
+    #[derive(Clone, Copy)]
     pub enum GraphemeCat {
         GC_LV,
         GC_LVT,
@@ -7821,8 +7820,6 @@ pub mod grapheme {
         GC_Any,
     }
 
-    impl Copy for GraphemeCat {}
-
     fn bsearch_range_value_table(c: char, r: &'static [(char, char, GraphemeCat)]) -> GraphemeCat {
         use core::cmp::Ordering::{Equal, Less, Greater};
         match r.binary_search_by(|&(lo, hi, _)| {

src/libunicode/u_str.rs

@@ -410,16 +410,14 @@ pub struct Utf16Items<'a> {
     iter: slice::Iter<'a, u16>
 }
 /// The possibilities for values decoded from a `u16` stream.
-#[derive(PartialEq, Eq, Clone, Show)]
+#[derive(Copy, PartialEq, Eq, Clone, Show)]
 pub enum Utf16Item {
     /// A valid codepoint.
     ScalarValue(char),
     /// An invalid surrogate without its pair.
     LoneSurrogate(u16)
 }
 
-impl Copy for Utf16Item {}
-
 impl Utf16Item {
     /// Convert `self` to a `char`, taking `LoneSurrogate`s to the
     /// replacement character (U+FFFD).

src/test/auxiliary/issue-14422.rs

@@ -23,10 +23,9 @@ mod src {
     pub mod hidden_core {
         use super::aliases::B;
 
+        #[derive(Copy)]
         pub struct A;
 
-        impl Copy for A {}
-
         pub fn make() -> B { A }
 
         impl A {

src/test/auxiliary/issue13213aux.rs

@@ -13,19 +13,18 @@
 
 pub use private::P;
 
+#[derive(Copy)]
 pub struct S {
     p: P,
 }
 
 mod private {
+    #[derive(Copy)]
     pub struct P {
         p: i32,
     }
     pub const THREE: P = P { p: 3 };
-    impl Copy for P {}
 }
 
 pub static A: S = S { p: private::THREE };
 
-impl Copy for S {}
-

src/test/auxiliary/method_self_arg1.rs

@@ -17,10 +17,9 @@ static mut COUNT: u64 = 1;
 
 pub fn get_count() -> u64 { unsafe { COUNT } }
 
+#[derive(Copy)]
 pub struct Foo;
 
-impl Copy for Foo {}
-
 impl Foo {
     pub fn foo(self, x: &Foo) {
         unsafe { COUNT *= 2; }

src/test/auxiliary/method_self_arg2.rs

@@ -17,10 +17,9 @@ static mut COUNT: u64 = 1;
 
 pub fn get_count() -> u64 { unsafe { COUNT } }
 
+#[derive(Copy)]
 pub struct Foo;
 
-impl Copy for Foo {}
-
 impl Foo {
     pub fn run_trait(self) {
         unsafe { COUNT *= 17; }

src/test/auxiliary/xcrate_unit_struct.rs

@@ -12,33 +12,28 @@
 
 // used by the rpass test
 
+#[derive(Copy)]
 pub struct Struct;
 
-impl Copy for Struct {}
-
+#[derive(Copy)]
 pub enum Unit {
     UnitVariant,
     Argument(Struct)
 }
 
-impl Copy for Unit {}
-
+#[derive(Copy)]
 pub struct TupleStruct(pub uint, pub &'static str);
 
-impl Copy for TupleStruct {}
-
 // used by the cfail test
 
+#[derive(Copy)]
 pub struct StructWithFields {
     foo: int,
 }
 
-impl Copy for StructWithFields {}
-
+#[derive(Copy)]
 pub enum EnumWithVariants {
     EnumVariant,
     EnumVariantArg(int)
 }
 
-impl Copy for EnumWithVariants {}
-

src/test/bench/noise.rs

@@ -16,13 +16,12 @@ use std::f32::consts::PI;
 use std::num::Float;
 use std::rand::{Rng, StdRng};
 
+#[derive(Copy)]
 struct Vec2 {
     x: f32,
     y: f32,
 }
 
-impl Copy for Vec2 {}
-
 fn lerp(a: f32, b: f32, v: f32) -> f32 { a * (1.0 - v) + b * v }
 
 fn smooth(v: f32) -> f32 { v * v * (3.0 - 2.0 * v) }

src/test/bench/shootout-chameneos-redux.rs

@@ -54,14 +54,13 @@ fn print_complements() {
     }
 }
 
+#[derive(Copy)]
 enum Color {
     Red,
     Yellow,
     Blue,
 }
 
-impl Copy for Color {}
-
 impl fmt::Show for Color {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let str = match *self {
@@ -73,13 +72,12 @@ impl fmt::Show for Color {
     }
 }
 
+#[derive(Copy)]
 struct CreatureInfo {
     name: uint,
     color: Color
 }
 
-impl Copy for CreatureInfo {}
-
 fn show_color_list(set: Vec<Color>) -> String {
     let mut out = String::new();
     for col in set.iter() {

src/test/bench/shootout-fannkuch-redux.rs

@@ -61,12 +61,12 @@ fn next_permutation(perm: &mut [i32], count: &mut [i32]) {
     }
 }
 
+#[derive(Copy)]
 struct P {
     p: [i32; 16],
 }
 
-impl Copy for P {}
-
+#[derive(Copy)]
 struct Perm {
     cnt: [i32; 16],
     fact: [u32; 16],
@@ -75,8 +75,6 @@ struct Perm {
     perm: P,
 }
 
-impl Copy for Perm {}
-
 impl Perm {
     fn new(n: u32) -> Perm {
         let mut fact = [1; 16];

src/test/bench/shootout-fasta-redux.rs

@@ -103,13 +103,12 @@ fn sum_and_scale(a: &'static [AminoAcid]) -> Vec<AminoAcid> {
     result
 }
 
+#[derive(Copy)]
 struct AminoAcid {
     c: u8,
     p: f32,
 }
 
-impl Copy for AminoAcid {}
-
 struct RepeatFasta<'a, W:'a> {
     alu: &'static str,
     out: &'a mut W

src/test/bench/shootout-k-nucleotide.rs

@@ -60,11 +60,9 @@ static OCCURRENCES: [&'static str;5] = [
 
 // Code implementation
 
-#[derive(PartialEq, PartialOrd, Ord, Eq)]
+#[derive(Copy, PartialEq, PartialOrd, Ord, Eq)]
 struct Code(u64);
 
-impl Copy for Code {}
-
 impl Code {
     fn hash(&self) -> u64 {
         let Code(ret) = *self;

src/test/bench/shootout-nbody.rs

@@ -94,14 +94,13 @@ static BODIES: [Planet;N_BODIES] = [
     },
 ];
 
+#[derive(Copy)]
 struct Planet {
     x: f64, y: f64, z: f64,
     vx: f64, vy: f64, vz: f64,
     mass: f64,
 }
 
-impl Copy for Planet {}
-
 fn advance(bodies: &mut [Planet;N_BODIES], dt: f64, steps: int) {
     for _ in range(0, steps) {
         let mut b_slice = bodies.as_mut_slice();