Code shared from the Rust Playground

playground.rs

use std::borrow::Cow;

// An user-defined enum
#[derive(Clone)]
enum Foo<'a, T> {
    // Some fields that are not copy..
    A(String),
    B {
        // Some other are..
        a: usize,
        // Some are generics..
        b: T,
    },
    // Some are references
    C(&'a str),
}

// What is expected to be generated
enum ButcheredFoo<'cow, 'a: 'cow, T: Clone> {
    // Note that we are not creating Cow<'cow, String> here, perhaps thanks to
    // an attribute macro
    A(Cow<'cow, str>),
    B {
        // What is copy should be copied (defined with an attribute macro)
        a: usize,
        // What is uncertain should stay in a cow, but note the trait bound for
        // T
        b: Cow<'cow, T>,
    },
    // References are copy, so they should be copied, but note the trait bound
    // for 'a
    C(&'a str)
}

impl<'a, T: Clone> Foo<'a, T> {
    fn butcher<'cow>(this: Cow<'cow, Foo<'a, T>>) -> ButcheredFoo<'cow, 'a, T> {
        use Cow::*;
        use Foo::*;
        
        match this {
            Borrowed(this) => match this {
                A(a) => ButcheredFoo::A(Borrowed(a)),
                B { a, b } => ButcheredFoo::B {
                    a: *a,
                    b: Borrowed(b),
                },
                C(a) => ButcheredFoo::C(a),
            },
            Owned(this) => match this {
                A(a) => ButcheredFoo::A(Owned(a)),
                B { a, b } => ButcheredFoo::B {
                    a,
                    b: Owned(b),
                },
                C(a) => ButcheredFoo::C(a),
            }
        }
    }
}