---

yaml
---
r: 275935
b: refs/heads/master
c: 1d2846d
h: refs/heads/master
i:
  275933: 99529da
  275931: b76cc4b
  275927: 4ac1ab7
  275919: 514f7e8
  275903: bce9c94

Author: fabricedesre

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 8f552181895921a377ab8c235340ea3d80ec7fc0
+refs/heads/master: 1d2846dcdaaffb36a30949e529dba81fe8aa2634
 refs/heads/snap-stage3: 235d77457d80b549dad3ac36d94f235208a1eafb
 refs/heads/try: 49312a405e14a449b98fe0056b12a40ac128be4a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

trunk/src/libcore/clone.rs

@@ -75,17 +75,6 @@ pub trait Clone : Sized {
     }
 }
 
-// FIXME(aburka): this method is used solely by #[derive] to
-// assert that every component of a type implements Clone.
-//
-// This should never be called by user code.
-#[doc(hidden)]
-#[inline(always)]
-#[unstable(feature = "derive_clone_copy",
-           reason = "deriving hack, should not be public",
-           issue = "0")]
-pub fn assert_receiver_is_clone<T: Clone + ?Sized>(_: &T) {}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, T: ?Sized> Clone for &'a T {
     /// Returns a shallow copy of the reference.

trunk/src/libsyntax_ext/deriving/clone.rs

@@ -11,68 +11,26 @@
 use deriving::generic::*;
 use deriving::generic::ty::*;
 
-use syntax::ast::{Expr, ItemKind, Generics, MetaItem, VariantData};
-use syntax::attr::{self, AttrMetaMethods};
+use syntax::ast::{MetaItem, Expr, VariantData};
 use syntax::codemap::Span;
 use syntax::ext::base::{ExtCtxt, Annotatable};
 use syntax::ext::build::AstBuilder;
 use syntax::parse::token::InternedString;
 use syntax::ptr::P;
 
-#[derive(PartialEq)]
-enum Mode { Deep, Shallow }
-
 pub fn expand_deriving_clone(cx: &mut ExtCtxt,
                              span: Span,
                              mitem: &MetaItem,
                              item: &Annotatable,
                              push: &mut FnMut(Annotatable))
 {
-    // check if we can use a short form
-    //
-    // the short form is `fn clone(&self) -> Self { *self }`
-    //
-    // we can use the short form if:
-    // - the item is Copy (unfortunately, all we can check is whether it's also deriving Copy)
-    // - there are no generic parameters (after specialization this limitation can be removed)
-    //      if we used the short form with generics, we'd have to bound the generics with
-    //      Clone + Copy, and then there'd be no Clone impl at all if the user fills in something
-    //      that is Clone but not Copy. and until specialization we can't write both impls.
-    let bounds;
-    let substructure;
-    match *item {
-        Annotatable::Item(ref annitem) => {
-            match annitem.node {
-                ItemKind::Struct(_, Generics { ref ty_params, .. }) |
-                ItemKind::Enum(_, Generics { ref ty_params, .. })
-                    if ty_params.is_empty()
-                        && attr::contains_name(&annitem.attrs, "derive_Copy") => {
-
-                    bounds = vec![Literal(path_std!(cx, core::marker::Copy))];
-                    substructure = combine_substructure(Box::new(|c, s, sub| {
-                        cs_clone("Clone", c, s, sub, Mode::Shallow)
-                    }));
-                }
-
-                _ => {
-                    bounds = vec![];
-                    substructure = combine_substructure(Box::new(|c, s, sub| {
-                        cs_clone("Clone", c, s, sub, Mode::Deep)
-                    }));
-                }
-            }
-        }
-
-        _ => cx.span_bug(span, "#[derive(Clone)] on trait item or impl item")
-    }
-
     let inline = cx.meta_word(span, InternedString::new("inline"));
     let attrs = vec!(cx.attribute(span, inline));
     let trait_def = TraitDef {
         span: span,
         attributes: Vec::new(),
         path: path_std!(cx, core::clone::Clone),
-        additional_bounds: bounds,
+        additional_bounds: Vec::new(),
         generics: LifetimeBounds::empty(),
         is_unsafe: false,
         methods: vec!(
@@ -84,7 +42,9 @@ pub fn expand_deriving_clone(cx: &mut ExtCtxt,
                 ret_ty: Self_,
                 attributes: attrs,
                 is_unsafe: false,
-                combine_substructure: substructure,
+                combine_substructure: combine_substructure(Box::new(|c, s, sub| {
+                    cs_clone("Clone", c, s, sub)
+                })),
             }
         ),
         associated_types: Vec::new(),
@@ -96,24 +56,14 @@ pub fn expand_deriving_clone(cx: &mut ExtCtxt,
 fn cs_clone(
     name: &str,
     cx: &mut ExtCtxt, trait_span: Span,
-    substr: &Substructure,
-    mode: Mode) -> P<Expr> {
+    substr: &Substructure) -> P<Expr> {
     let ctor_path;
     let all_fields;
-    let fn_path = match mode {
-        Mode::Shallow => cx.std_path(&["clone", "assert_receiver_is_clone"]),
-        Mode::Deep  => cx.std_path(&["clone", "Clone", "clone"]),
-    };
+    let fn_path = cx.std_path(&["clone", "Clone", "clone"]);
     let subcall = |field: &FieldInfo| {
         let args = vec![cx.expr_addr_of(field.span, field.self_.clone())];
 
-        let span = if mode == Mode::Shallow {
-            // set the expn ID so we can call the unstable method
-            Span { expn_id: cx.backtrace(), .. trait_span }
-        } else {
-            field.span
-        };
-        cx.expr_call_global(span, fn_path.clone(), args)
+        cx.expr_call_global(field.span, fn_path.clone(), args)
     };
 
     let vdata;
@@ -139,41 +89,29 @@ fn cs_clone(
         }
     }
 
-    match mode {
-        Mode::Shallow => {
-            cx.expr_block(cx.block(trait_span,
-                                   all_fields.iter()
-                                             .map(subcall)
-                                             .map(|e| cx.stmt_expr(e))
-                                             .collect(),
-                                   Some(cx.expr_deref(trait_span, cx.expr_self(trait_span)))))
-        }
-        Mode::Deep => {
-            match *vdata {
-                VariantData::Struct(..) => {
-                    let fields = all_fields.iter().map(|field| {
-                        let ident = match field.name {
-                            Some(i) => i,
-                            None => {
-                                cx.span_bug(trait_span,
-                                            &format!("unnamed field in normal struct in \
-                                                     `derive({})`", name))
-                            }
-                        };
-                        cx.field_imm(field.span, ident, subcall(field))
-                    }).collect::<Vec<_>>();
+    match *vdata {
+        VariantData::Struct(..) => {
+            let fields = all_fields.iter().map(|field| {
+                let ident = match field.name {
+                    Some(i) => i,
+                    None => {
+                        cx.span_bug(trait_span,
+                                    &format!("unnamed field in normal struct in \
+                                             `derive({})`", name))
+                    }
+                };
+                cx.field_imm(field.span, ident, subcall(field))
+            }).collect::<Vec<_>>();
 
-                    cx.expr_struct(trait_span, ctor_path, fields)
-                }
-                VariantData::Tuple(..) => {
-                    let subcalls = all_fields.iter().map(subcall).collect();
-                    let path = cx.expr_path(ctor_path);
-                    cx.expr_call(trait_span, path, subcalls)
-                }
-                VariantData::Unit(..) => {
-                    cx.expr_path(ctor_path)
-                }
-            }
+            cx.expr_struct(trait_span, ctor_path, fields)
+        }
+        VariantData::Tuple(..) => {
+            let subcalls = all_fields.iter().map(subcall).collect();
+            let path = cx.expr_path(ctor_path);
+            cx.expr_call(trait_span, path, subcalls)
+        }
+        VariantData::Unit(..) => {
+            cx.expr_path(ctor_path)
         }
     }
 }

trunk/src/libsyntax_ext/deriving/decodable.rs

@@ -74,7 +74,7 @@ fn expand_deriving_decodable_imp(cx: &mut ExtCtxt,
                 },
                 explicit_self: None,
                 args: vec!(Ptr(Box::new(Literal(Path::new_local(typaram))),
-                           Borrowed(None, Mutability::Mutable))),
+                            Borrowed(None, Mutability::Mutable))),
                 ret_ty: Literal(Path::new_(
                     pathvec_std!(cx, core::result::Result),
                     None,

trunk/src/libsyntax_ext/deriving/encodable.rs

@@ -150,7 +150,7 @@ fn expand_deriving_encodable_imp(cx: &mut ExtCtxt,
                 },
                 explicit_self: borrowed_explicit_self(),
                 args: vec!(Ptr(Box::new(Literal(Path::new_local(typaram))),
-                           Borrowed(None, Mutability::Mutable))),
+                            Borrowed(None, Mutability::Mutable))),
                 ret_ty: Literal(Path::new_(
                     pathvec_std!(cx, core::result::Result),
                     None,

trunk/src/libsyntax_ext/deriving/generic/mod.rs

@@ -857,7 +857,6 @@ impl<'a> MethodDef<'a> {
                      explicit_self: ast::ExplicitSelf,
                      arg_types: Vec<(Ident, P<ast::Ty>)> ,
                      body: P<Expr>) -> ast::ImplItem {
-
         // create the generics that aren't for Self
         let fn_generics = self.generics.to_generics(cx, trait_.span, type_ident, generics);
 
@@ -991,7 +990,6 @@ impl<'a> MethodDef<'a> {
             body = cx.expr_match(trait_.span, arg_expr.clone(),
                                      vec!( cx.arm(trait_.span, vec!(pat.clone()), body) ))
         }
-
         body
     }
 

trunk/src/llvm

@@ -1 +1 @@
-Subproject commit 25c7dc370359433ca02f29919dfa36f94432155e
+Subproject commit 751345228a0ef03fd147394bb5104359b7a808be

trunk/src/rustllvm/llvm-auto-clean-trigger

@@ -1,4 +1,4 @@
 # If this file is modified, then llvm will be forcibly cleaned and then rebuilt.
 # The actual contents of this file do not matter, but to trigger a change on the
 # build bots then the contents should be changed so git updates the mtime.
-2016-03-18
+2016-04-26

trunk/src/test/compile-fail/deriving-copyclone.rs

@@ -12,6 +12,8 @@
 //
 // (Compare with compile-fail/move-out-of-array-1.rs)
 
+// pretty-expanded FIXME #23616
+
 #[derive(Copy, Clone)]
 struct C { _x: u8 }
 

trunk/src/test/run-pass/copy-out-of-array-1.rs

@@ -16,6 +16,8 @@
 // did not consider that a match (something I would like to revise in
 // a later PR).
 
+// pretty-expanded FIXME #23616
+
 #![allow(dead_code)]
 
 use std::marker::PhantomData;

trunk/src/test/run-pass/deriving-copyclone.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// pretty-expanded FIXME #23616
+
 use std::ops::Deref;
 
 struct Root {

trunk/src/test/run-pass/hrtb-opt-in-copy.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// pretty-expanded FIXME #23616
+
 #![allow(unknown_features)]
 #![feature(box_syntax)]