I do not understand copy constructors

[Learner]

On Thursday, 12 August 2021 at 09:14:02 UTC, Paul Backus wrote:
> On Thursday, 12 August 2021 at 08:42:27 UTC, Learner wrote:
>>     struct A {
>>         int[] data
>>         this(ref return scope A rhs) { data = ths.data.dup; }
>>     }
>>
>>     Generating an `inout` copy constructor for `struct B` 
>> failed, therefore instances of it are uncopyable
>>
>> What is an `inout` copy constructor? What should I change in A?
>
> When the compiler generates a copy constructor for a struct, it 
> generates it with the following signature:
>
> ```d
> this(ref return scope inout(typeof(this)) src) inout
> ```
>
> (Source: 
> https://dlang.org/spec/struct.html#implicit-copy-constructors)
>
> Notice that both the `src` object and the object being 
> constructed (`this`) are qualified with `inout`.
>
> `inout` is a special type qualifier that allows the same 
> function to be used for mutable, `const`, and `immutable` 
> arguments. To make this work, the compiler imposes heavy 
> restrictions on what you can do with an `inout`-qualified 
> object--only operations that are valid on mutable, `const`, 
> *and* `immutable` objects are allowed for `inout`.
>
> (Source: https://dlang.org/spec/function.html#inout-functions)
>
> `A`'s copy constructor does not have any type qualifiers on its 
> `rhs` argument or its `this` reference, so both default to 
> mutable. In other words: `A`'s copy constructor can only be 
> used to construct a mutable copy from a mutable original 
> object. It *cannot* be used to construct an `inout` copy from 
> an `inout` object.
>
> In order to make the generated copy constructor work, you need 
> to give `A` a copy constructor that can copy `inout` objects. 
> There are two possibilities here:
>
> 1. Make `A`'s copy constructor `inout`: `this(ref return scope 
> inout A rhs) inout`
> 2. Make `A`'s copy constructor `const`: `this(ref return scope 
> const A rhs) const`

While option 2. is not working:

     struct A {
         int[] data;
         this(ref return scope const A rhs) const {}
     }
     Error: Generating an `inout` copy constructor for `struct A` 
failed, therefore instances of it are uncopyable

Option .1 actually works, with an empty body, while it fails with 
the actual body:

     struct A {
         int[] data;
         this(ref return scope inout A rhs) inout { data = 
rhs.data.dup; }
     }
     Error: cannot implicitly convert expression 
`dup(cast(const(int)[])rhs.data)` of type `int[]` to 
`inout(int[])`

It seems that there is no easy way to transition from a postblit 
to a copy constructor, no?