9249e6a1e2
Changes #[derive(Copy, Clone)] to use a faster impl of Clone when both derives are present, and there are no generics in the type. The faster impl is simply returning *self (which works because the type is also Copy). See the comments in libsyntax_ext/deriving/clone.rs for more details. There are a few types which are Copy but not Clone, in violation of the definition of Copy. These include large arrays and tuples. The very existence of these types is arguably a bug, but in order for this optimization not to change the applicability of #[derive(Copy, Clone)], the faster Clone impl also injects calls to a new function, core::clone::assert_receiver_is_clone, to verify that all members are actually Clone. This is not a breaking change, because pursuant to RFC 1521, any type that implements Copy should not do any observable work in its Clone impl.
49 lines
1.3 KiB
Rust
49 lines
1.3 KiB
Rust
// Copyright 2016 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.
|
|
|
|
//! Test that #[derive(Copy, Clone)] produces a shallow copy
|
|
//! even when a member violates RFC 1521
|
|
|
|
use std::sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT, Ordering};
|
|
|
|
/// A struct that pretends to be Copy, but actually does something
|
|
/// in its Clone impl
|
|
#[derive(Copy)]
|
|
struct Liar;
|
|
|
|
/// Static cooperating with the rogue Clone impl
|
|
static CLONED: AtomicBool = ATOMIC_BOOL_INIT;
|
|
|
|
impl Clone for Liar {
|
|
fn clone(&self) -> Self {
|
|
// this makes Clone vs Copy observable
|
|
CLONED.store(true, Ordering::SeqCst);
|
|
|
|
*self
|
|
}
|
|
}
|
|
|
|
/// This struct is actually Copy... at least, it thinks it is!
|
|
#[derive(Copy, Clone)]
|
|
struct Innocent(Liar);
|
|
|
|
impl Innocent {
|
|
fn new() -> Self {
|
|
Innocent(Liar)
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
let _ = Innocent::new().clone();
|
|
// if Innocent was byte-for-byte copied, CLONED will still be false
|
|
assert!(!CLONED.load(Ordering::SeqCst));
|
|
}
|
|
|