Please consider the following program:
import std.exception;

void main()
{
    struct A {
        int a;

        @disable this(this);
        @disable ref A opAssign(const ref A);

        ref A opOpAssign(string op: "~")(int data) {
            a += data;

            return this;
        }
    }

    auto a = A(2);

    a ~= 3;

    assertThrown!Exception(a ~= 3);
}

Compilation (dmd 2.066.1) fails on the assertThrown line:
Error: struct test.main.A is not copyable because it is annotated with @disable

What I do not understand is why A should need to be copyable. Where is the copy made? I'm guessing this is because of the lazy definition of the expression, but still I don't see any reason to create a copy.

Help?
Shachar

On Mon, 15 Dec 2014 16:01:35 +0200
Shachar Shemesh via Digitalmars-d <digitalmars-d@puremagic.com> wrote:

> Please consider the following program:
> import std.exception;
> 
> void main()
> {
>      struct A {
>          int a;
> 
>          @disable this(this);
>          @disable ref A opAssign(const ref A);
> 
>          ref A opOpAssign(string op: "~")(int data) {
>              a += data;
> 
>              return this;
>          }
>      }
> 
>      auto a = A(2);
> 
>      a ~= 3;
> 
>      assertThrown!Exception(a ~= 3);
> }
> 
> Compilation (dmd 2.066.1) fails on the assertThrown line:
> Error: struct test.main.A is not copyable because it is annotated with
> @disable
> 
> What I do not understand is why A should need to be copyable. Where is the copy made? I'm guessing this is because of the lazy definition of the expression, but still I don't see any reason to create a copy.

yes, this is due to `lazy` in assrtThrown. what `lazy` does is actually
creating a lambda. then compiler tries to deduce the type of the
expression and it got `A`. so it generates the code like
`A expression`. it can't see `ref` there, as `a` type is `A`, not
`ref A`.

you can workaround that with creating the necessary lambda manually:

  assertThrown!Exception((ref A aa) { aa ~= 3; }(a));


tl;dr: no, it's not a bug in the compiler. but the error message is misleading and you are required to understang some internals to make sense out of it.

On Monday, 15 December 2014 at 14:33:51 UTC, ketmar via Digitalmars-d wrote:
> On Mon, 15 Dec 2014 16:01:35 +0200
> Shachar Shemesh via Digitalmars-d <digitalmars-d@puremagic.com> wrote:
>
>> Please consider the following program:
>> import std.exception;
>> 
>> void main()
>> {
>>      struct A {
>>          int a;
>> 
>>          @disable this(this);
>>          @disable ref A opAssign(const ref A);
>> 
>>          ref A opOpAssign(string op: "~")(int data) {
>>              a += data;
>> 
>>              return this;
>>          }
>>      }
>> 
>>      auto a = A(2);
>> 
>>      a ~= 3;
>> 
>>      assertThrown!Exception(a ~= 3);
>> }
>> 
>> Compilation (dmd 2.066.1) fails on the assertThrown line:
>> Error: struct test.main.A is not copyable because it is annotated with @disable
>> 
>> What I do not understand is why A should need to be copyable. Where is the copy made? I'm guessing this is because of the lazy definition of the expression, but still I don't see any reason to create a copy.
>
> yes, this is due to `lazy` in assrtThrown. what `lazy` does is actually
> creating a lambda. then compiler tries to deduce the type of the
> expression and it got `A`. so it generates the code like
> `A expression`. it can't see `ref` there, as `a` type is `A`, not
> `ref A`.
>
> you can workaround that with creating the necessary lambda manually:
>
>   assertThrown!Exception((ref A aa) { aa ~= 3; }(a));
>
>
> tl;dr: no, it's not a bug in the compiler. but the error message is
> misleading and you are required to understang some internals to make
> sense out of it.

Another point against storage class ref.

On Monday, 15 December 2014 at 15:00:56 UTC, Marc Schütz wrote:
> On Monday, 15 December 2014 at 14:33:51 UTC, ketmar via Digitalmars-d wrote:
>> On Mon, 15 Dec 2014 16:01:35 +0200
>> Shachar Shemesh via Digitalmars-d <digitalmars-d@puremagic.com> wrote:
>>
>>> Please consider the following program:
>>> import std.exception;
>>> 
>>> void main()
>>> {
>>>     struct A {
>>>         int a;
>>> 
>>>         @disable this(this);
>>>         @disable ref A opAssign(const ref A);
>>> 
>>>         ref A opOpAssign(string op: "~")(int data) {
>>>             a += data;
>>> 
>>>             return this;
>>>         }
>>>     }
>>> 
>>>     auto a = A(2);
>>> 
>>>     a ~= 3;
>>> 
>>>     assertThrown!Exception(a ~= 3);
>>> }
>>> 
>>> Compilation (dmd 2.066.1) fails on the assertThrown line:
>>> Error: struct test.main.A is not copyable because it is annotated with @disable
>>> 
>>> What I do not understand is why A should need to be copyable. Where is the copy made? I'm guessing this is because of the lazy definition of the expression, but still I don't see any reason to create a copy.
>>
>> yes, this is due to `lazy` in assrtThrown. what `lazy` does is actually
>> creating a lambda. then compiler tries to deduce the type of the
>> expression and it got `A`. so it generates the code like
>> `A expression`. it can't see `ref` there, as `a` type is `A`, not
>> `ref A`.
>>
>> you can workaround that with creating the necessary lambda manually:
>>
>>  assertThrown!Exception((ref A aa) { aa ~= 3; }(a));
>>
>>
>> tl;dr: no, it's not a bug in the compiler. but the error message is
>> misleading and you are required to understang some internals to make
>> sense out of it.
>
> Another point against storage class ref.

Perhaps. I would say lazy should be clever enough to work this out.