Does a type that implements copy get moved if possible?

If you pass a type into a function that is not a pointer type and it implements Copy, does Rust copy it only if necessary?

Here is some specific code:

#[derive(Clone, Copy)]
struct Data([u8; 2]);

#[derive(Clone, Copy)]
struct Buffer(Data);

fn do_something(id: Buffer) {
    println!("{}", id.0.0[0]);
}

fn create_buffer() -> Buffer {
   Buffer(Data([0x01, 0x01]))
}

fn main() {
    let buffer = create_buffer();

    // Since we don't use buffer again in this function, copy trait isn't necessary on Buffer.
    // But, "Buffer" does implement the Copy trait. Will Rust copy it anyway?
    do_something(buffer);
}

If rust does not copy it, are there rules to this behavior or is it entirely up to the compiler to decide? Can I rely on this not being copied?

What if I were to call do_something(buffer) twice? Does it copy twice, or move once and copy once? This requires the copy trait to even compile so I expect at least 1 copy.

do_something(buffer);
do_something(buffer);