struct Foo; // no `#[pin_v2]`, but `Foo: Unpin`

// For `Foo: Unpin`, given that `&pin mut Foo` and `&mut Foo` are mutually coercible,
// I don't think it is reasonable to allow `&mut Foo` but not `&pin mut Foo` here.
let mut x: Pin<&mut _> = &pin mut Foo;

pub struct NotUnpin(PhantomPinned);

pub struct GenericAdt<T> {
    pub x: T,
}

// An ill-formed unconditional `Unpin` for `GenericAdt<T>`.
impl<T> Unpin for GenericAdt<T> {}

pub fn unsound_pin_borrow<T>(
    input: &pin mut GenericAdt<T>,
) -> &pin mut T {
    // This should be an error, or else you can get an `&pin mut NotUnpin`
    // and later an `&mut NotUnpin` via `&mut (*input).x`
    // as `GenericAdt<T>` is `Unpin`.
    &pin mut input.x
}

let mut g = GenericAdt { x: NotUnpin(PhantomPinned) };
let f = &pin mut g; // Ok because of your new added rule.
let x: &pin mut NotUnpin = unsound_pin_borrow(f);
// This will be rejected in pinned patterns checks.
// let ref pin mut GenericAdt { x } = f; 

drop(f); // Kills f, but the pinnedness of x won't expire.

let f: &mut _ = f; // Allowed by coercion.
let x: &mut NotUnpin = &mut f.x; // Unsound! Breaks `Pin`' s safety contract.

struct NotUnpin(PhantomPinned);

struct GenericAdt<T>(T);

impl Drop for GenericAdt<T> {
    // Anyway, an `&mut GenericAdt<T>` is obtained.
    fn drop(&mut self) { /* ... */ }
}

fn foo(mut input: GenericAdt<NotUnpin>) {
    let x: &pin mut _ = &pin mut input; // Allowed by your new rule
    // At `<GenericAdt<NotUnpin> as Drop>::drop`, it obtains an
    // `&mut GenericAdt<NotUnpin>`, which breaks `Pin`'s safety contract.
}