syntax: Make #[derive(Copy)] imply #[derive(Clone)]

Author: erickt

src/libcore/fmt/mod.rs

@@ -14,6 +14,7 @@
 
 use cell::{Cell, RefCell, Ref, RefMut, BorrowState};
 use char::CharExt;
+#[cfg(stage0)]
 use clone::Clone;
 use iter::Iterator;
 use marker::{Copy, PhantomData, Sized};
@@ -141,6 +142,7 @@ pub struct ArgumentV1<'a> {
     formatter: fn(&Void, &mut Formatter) -> Result,
 }
 
+#[cfg(stage0)]
 impl<'a> Clone for ArgumentV1<'a> {
     fn clone(&self) -> ArgumentV1<'a> {
         *self

src/liblibc/lib.rs

@@ -2091,6 +2091,7 @@ pub mod types {
                     pub __ss_align: i64,
                     pub __ss_pad2: [u8; 112],
                 }
+                #[cfg(stage0)]
                 impl ::core::clone::Clone for sockaddr_storage {
                     fn clone(&self) -> sockaddr_storage { *self }
                 }
@@ -2154,6 +2155,7 @@ pub mod types {
                     pub sun_family: sa_family_t,
                     pub sun_path: [c_char; 104]
                 }
+                #[cfg(stage0)]
                 impl ::core::clone::Clone for sockaddr_un {
                     fn clone(&self) -> sockaddr_un { *self }
                 }
@@ -2369,6 +2371,7 @@ pub mod types {
                     pub __sig: c_long,
                     pub __opaque: [c_char; 56]
                 }
+                #[cfg(stage0)]
                 impl ::core::clone::Clone for pthread_attr_t {
                     fn clone(&self) -> pthread_attr_t { *self }
                 }

src/librand/isaac.rs

@@ -187,6 +187,7 @@ impl IsaacRng {
 }
 
 // Cannot be derived because [u32; 256] does not implement Clone
+#[cfg(stage0)]
 impl Clone for IsaacRng {
     fn clone(&self) -> IsaacRng {
         *self
@@ -432,6 +433,7 @@ impl Isaac64Rng {
 }
 
 // Cannot be derived because [u32; 256] does not implement Clone
+#[cfg(stage0)]
 impl Clone for Isaac64Rng {
     fn clone(&self) -> Isaac64Rng {
         *self

src/librustc/middle/liveness.rs

@@ -153,6 +153,7 @@ impl LiveNode {
     fn get(&self) -> usize { let LiveNode(v) = *self; v }
 }
 
+#[cfg(stage0)]
 impl Clone for LiveNode {
     fn clone(&self) -> LiveNode {
         LiveNode(self.get())

src/librustc_borrowck/borrowck/move_data.rs

@@ -84,6 +84,7 @@ impl MovePathIndex {
     }
 }
 
+#[cfg(stage0)]
 impl Clone for MovePathIndex {
     fn clone(&self) -> MovePathIndex {
         MovePathIndex(self.get())

src/libstd/net/addr.rs

@@ -206,10 +206,13 @@ impl fmt::Debug for SocketAddrV6 {
     }
 }
 
+#[cfg(stage0)]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Clone for SocketAddrV4 {
     fn clone(&self) -> SocketAddrV4 { *self }
 }
+
+#[cfg(stage0)]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Clone for SocketAddrV6 {
     fn clone(&self) -> SocketAddrV6 { *self }

src/libstd/net/ip.rs

@@ -174,6 +174,7 @@ impl fmt::Debug for Ipv4Addr {
     }
 }
 
+#[cfg(stage0)]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Clone for Ipv4Addr {
     fn clone(&self) -> Ipv4Addr { *self }
@@ -417,6 +418,7 @@ impl fmt::Debug for Ipv6Addr {
     }
 }
 
+#[cfg(stage0)]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Clone for Ipv6Addr {
     fn clone(&self) -> Ipv6Addr { *self }

src/libsyntax/ast_map/mod.rs

@@ -148,6 +148,7 @@ enum MapEntry<'ast> {
     RootInlinedParent(&'ast InlinedParent)
 }
 
+#[cfg(stage0)]
 impl<'ast> Clone for MapEntry<'ast> {
     fn clone(&self) -> MapEntry<'ast> {
         *self

src/libsyntax/ext/deriving/bounds.rs

@@ -8,13 +8,19 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use ast::{MetaItem, Item};
-use codemap::Span;
+use abi;
+use ast::{self, MetaItem, Item};
+use codemap::{Span, respan};
 use ext::base::ExtCtxt;
+use ext::build::AstBuilder;
 use ext::deriving::generic::*;
 use ext::deriving::generic::ty::*;
+use owned_slice::OwnedSlice;
+use parse::token::{InternedString, special_idents};
 use ptr::P;
 
+use super::clone;
+
 pub fn expand_deriving_unsafe_bound(cx: &mut ExtCtxt,
                                     span: Span,
                                     _: &MetaItem,
@@ -30,21 +36,114 @@ pub fn expand_deriving_copy(cx: &mut ExtCtxt,
                             item: &Item,
                             push: &mut FnMut(P<Item>))
 {
-    let path = Path::new(vec![
-        if cx.use_std { "std" } else { "core" },
-        "marker",
-        "Copy",
-    ]);
-
     let trait_def = TraitDef {
         span: span,
         attributes: Vec::new(),
-        path: path,
+        path: path_std!(cx, core::marker::Copy),
         additional_bounds: Vec::new(),
         generics: LifetimeBounds::empty(),
         methods: Vec::new(),
         associated_types: Vec::new(),
     };
 
     trait_def.expand(cx, mitem, item, push);
+
+    expand_deriving_clone_when_copy(cx, span, mitem, item, push)
+}
+
+fn expand_deriving_clone_when_copy(cx: &mut ExtCtxt,
+                                   span: Span,
+                                   mitem: &MetaItem,
+                                   item: &Item,
+                                   push: &mut FnMut(P<Item>))
+{
+    // For generic types we need to destructure our value in order to recursively call clone.
+    // However, as an optimization for non-generic types, we can just generate:
+    //
+    // impl<...> Clone for $ty {
+    //     fn clone(&self) -> Self { *self }
+    // }
+    //
+    // But the generic deriving helpers do not support generating such a simple method. So we'll
+    // build this method by hand. However, we want to take advantage of generic deriving generating
+    // the `Generics` for us. So we'll generate an empty impl, then later on add our method. It's
+    // not pretty, but it works until we get a more general purpose ast builder.
+    match item.node {
+        ast::ItemStruct(_, ref generics) | ast::ItemEnum(_, ref generics) => {
+            if generics.is_type_parameterized() {
+                clone::expand_deriving_clone(cx, span, mitem, item, push);
+                return;
+            }
+        }
+        _ => {
+            cx.span_err(mitem.span, "`derive` may only be applied to structs and enums");
+            return;
+        }
+    }
+
+    let trait_def = TraitDef {
+        span: span,
+        attributes: Vec::new(),
+        path: path_std!(cx, core::clone::Clone),
+        additional_bounds: Vec::new(),
+        generics: LifetimeBounds::empty(),
+        methods: Vec::new(),
+        associated_types: Vec::new(),
+    };
+
+    // We want to use the `cx` to build our ast, but it's passed by `&mut` to the expand method. So
+    // we'll extract out the generated item by way of an option.
+    let mut expanded_item = None;
+
+    trait_def.expand(cx, mitem, item, &mut |item: P<ast::Item>| {
+        expanded_item = Some(item);
+    });
+
+    let expanded_item = expanded_item.unwrap().map(|mut item| {
+        match item.node {
+            ast::ItemImpl(_, _, _, _, ref ty, ref mut impl_items) => {
+                let self_arg = ast::Arg::new_self(span, ast::MutImmutable, special_idents::self_);
+                let decl = cx.fn_decl(vec![self_arg], ty.clone());
+
+                let sig = ast::MethodSig {
+                    unsafety: ast::Unsafety::Normal,
+                    abi: abi::Rust,
+                    decl: decl.clone(),
+                    generics: ast::Generics {
+                        lifetimes: Vec::new(),
+                        ty_params: OwnedSlice::empty(),
+                        where_clause: ast::WhereClause {
+                            id: ast::DUMMY_NODE_ID,
+                            predicates: Vec::new(),
+                        }
+                    },
+                    explicit_self: respan(
+                        span,
+                        ast::SelfRegion(None, ast::MutImmutable, cx.ident_of("self")),
+                    ),
+                };
+
+                let block = cx.block_expr(cx.expr_deref(span, cx.expr_self(span)));
+
+                let inline = cx.meta_word(span, InternedString::new("inline"));
+                let attrs = vec!(cx.attribute(span, inline));
+
+                impl_items.push(P(ast::ImplItem {
+                    id: ast::DUMMY_NODE_ID,
+                    ident: cx.ident_of("clone"),
+                    vis: ast::Visibility::Inherited,
+                    attrs: attrs,
+                    node: ast::ImplItem_::MethodImplItem(sig, block),
+                    span: span,
+                }));
+            }
+            _ => {
+                cx.span_bug(span, "we should have gotten an impl")
+            }
+        };
+
+        item
+    });
+
+    push(expanded_item)
 }

src/libsyntax/ext/deriving/mod.rs

@@ -92,6 +92,21 @@ fn expand_derive(cx: &mut ExtCtxt,
             cx.span_warn(mitem.span, "empty trait list in `derive`");
         }
 
+        // FIXME: This can be removed after a snapshot
+        let mut seen_copy = false;
+
+        for titem in traits.iter() {
+            match titem.node {
+                MetaWord(ref tname) => {
+                    match &**tname {
+                        "Copy" => { seen_copy = true; }
+                        _ => { }
+                    }
+                }
+                _ => { }
+            }
+        }
+
         for titem in traits.iter().rev() {
             let tname = match titem.node {
                 MetaWord(ref tname) => tname,
@@ -109,6 +124,9 @@ fn expand_derive(cx: &mut ExtCtxt,
                 continue;
             }
 
+            // FIXME: This can be removed after a snapshot
+            if seen_copy && &**tname == "Clone" { continue; }
+
             // #[derive(Foo, Bar)] expands to #[derive_Foo] #[derive_Bar]
             item.attrs.push(cx.attribute(titem.span, cx.meta_word(titem.span,
                 intern_and_get_ident(&format!("derive_{}", tname)))));