Struct copy constructor with inout

[Paul Backus]

On Tuesday, 14 November 2023 at 08:50:34 UTC, dhs wrote:
> ```d
> struct S2
> {
>     this(ref inout S2 s) inout { writeln("copy"); }
>     int i;
> }
>
> void test()
> {
>     const(S1) s1;
>     S1 ss1 = s1; // error, ss1 not qualified as const
>
>     const(S2) s2;
>     S2 ss2 = s2; // fine, why?
> }
> ```
>
> Isn't "inout" supposed to copy the const-ness of its parameter 
> to the constructor's attribute? In other words: why doesn't 
> ss2=s2 fail here?

Because `S2` is a pure value type and contains no pointers or 
references, the compiler allows `const(S2)` to implicitly convert 
to `S2`. This is documented in the spec under ["Implicit 
Qualifier Conversions"][1], and you can verify it with a `static 
assert`:

```d
static assert(is(const(S2) : S2)); // ok
```

In order to prevent this conversion, you can replace `int i` with 
`int* p`:

```d
struct S3
{
     this(ref inout S2 s) inout { writeln("copy"); }
     int *p;
}

void test()
{
     const(S3) s3;
     S3 ss3 = s3;
     // Error: cannot implicitly convert expression
     // `s3` of type `const(S3)` to `S3`
}
```

[1]: 
https://dlang.org/spec/const3.html#implicit_qualifier_conversions