Discarded return values

[Simen Kjærås]

On Tuesday, 30 January 2018 at 14:01:00 UTC, bauss wrote:
> unittest {
>     auto a = foo();          // This should fail, because a is 
> never used.

No it shouldn't. It is assigned to a variable, as the constraint 
said.


>     // This should also fail, because b is never used actually 
> used afterwards.
>     auto b = foo()
>     b.morph();

No it shouldn't. It is assigned to a variable, as the constraint 
said.


>    // This should fail, because d does not use c.
>    // A simply analysis of d will not work, you'll have to 
> track all passed values to d and whether they themselves should 
> be tracked with the attribute.
>    auto c = foo();
>    d(c);

No it shouldn't. It is assigned to a variable, as the constraint 
said.


>   // Same as above, should fail too since d doesn't use the 
> return value
>   d(foo());

No it shouldn't. It is passed to a function, as the constraint 
said.


> }
>
> The above is going to be very complex to implement in the 
> compiler.
>
> Sure a simple check if it has just been assigned to a variable 
> would work fine, but in the reality people would most likely 
> just do something like this then:
>
> auto unused = foo();
>
> And there ... we "hacked" our way around the attribute.

Yes, that's the point. Now it's visible that you're discarding 
the result.

The point isn't actually to make sure people keep the variable 
around - that'd be silly - it's to inform the programmer that 
potentially important information is discarded, and to stop the 
programmer from calling mutating functions on a temporary return 
value where it will have no effect.

For pure functions, this gives a warning:

auto fun() pure { return 3; }

unittest {
     fun(); // calling without side effects discards return value
}

Does that in any way whatsoever stop me from assigning the return 
value to a variable and then ignoring it? No. But doing so would 
make me an idiot. The compiler suggests I cast it to void if I 
really intended to discard the result. The reason for this is 
cast(void) is relatively easy to grep for, and sticks out like a 
sore thumb when looking through the code.


> So for it to work it has to track every single return value 
> from a function that implements the attribute and that is 
> borderline impossible to get correct.

No it's not. It's *perfectly* impossible the way your scheme 
works. What does this function do to its parameters?

extern(C) void foo(S s);

In other words, your idea of perfectly tracking how a value is 
used cannot be implemented at all. Trying to equate that with 
what I'm asking is disingenuous.

--
   Simen