On 5/13/21 3:21 PM, PinDPlugga wrote:

> This works but issues a deprecation warning:
> ```
> onlineapp.d(30): Deprecation: returning `this` escapes a reference to parameter `this`
> onlineapp.d(30):        perhaps annotate the parameter with `return`
> Fraction(1, 3)
> ```
> 
> I found several other ways to make this work without the warnings, but I am wondering how to make this particular case work, or if it is not a recommended way, what the proper way would be.

Just follow the recommendation:

```d
ref Fraction reduce() return { // annotated with return
```

This means, "I will return all or part of the parameter passed in" (the parameter being the `this` reference)

-Steve

On 5/13/21 12:40 PM, Steven Schveighoffer wrote:
> On 5/13/21 3:21 PM, PinDPlugga wrote:
> 
>> This works but issues a deprecation warning:
>> ```
>> onlineapp.d(30): Deprecation: returning `this` escapes a reference to parameter `this`
>> onlineapp.d(30):        perhaps annotate the parameter with `return`
>> Fraction(1, 3)
>> ```
>>
>> I found several other ways to make this work without the warnings, but I am wondering how to make this particular case work, or if it is not a recommended way, what the proper way would be.
> 
> Just follow the recommendation:
> 
> ```d
> ref Fraction reduce() return { // annotated with return
> ```
> 
> This means, "I will return all or part of the parameter passed in" (the parameter being the `this` reference)
> 
> -Steve

I was writing this example that shows a use case for the problem (marked with BUG below):

struct Fraction {
    auto n = 0L;
    auto d = 1L;

    // ... other bits ...

    ref Fraction reduce() {
      import std.numeric : gcd;

      // v = gcd(n, d);
      // if (v > 1) {
      //   n /= v;
      //   d /= v;
      // }

      return this;
    }

    // ... etc ...
}

ref foo() {
  import std.stdio : writeln;
  auto f = Fraction(3, 9);

  // BUG: Returns reference to an object on the stack
  return f.reduce();
}

void main() {
  // Refers to a temporary (it would be a copy without the &)
  auto f = &foo();

  // Do some unrelated things hoping that space for dead objects on
  // the stack will be reused.
  import std.stdio;
  import std.random;
  writeln("doing something else: ", uniform(0, 6));

  writeln(f.d); // Access dead and overwritten object (does NOT print
                // 9 on my system)
}

Putting 'return' where Steve shows makes the compiler guard us against this misuse and the program thankfully does not compile.

Ali

On 14.05.21 12:00, PinDPlugga wrote:
> Hi thank you both for your answers. I had understood from an earlier chapter how this could introduce a bug, but I was confused because the warning suggests attaching ```return``` to the parameter, which is empty in the declaration.

`this` is considered a hidden parameter. Every non-static method has it.

> So my next question would be how come ref based operator overloads are not labelled as return and do not show this warning?
> 
> ``` D
> struct Fraction {
>      auto n = 0L;
>      auto d = 1L;
> 
>      ref Fraction opUnary(string op)()
>      if (op == "++") {
>          n += d;
>          return this;
>      }
> }
> 
> ref Fraction foo() {
>      auto f = Fraction(1, 3);
> 
>      // Same bug as with reduce
>      return ++f;
> }
> ```

Note that opUnary is not an ordinary method. It's a template. That means attributes are inferred [1], including the `return` attribute. I.e., the compiler adds `return` to the signature for you, just like Steven suggested you do manually.

Try omitting the return type of `reduce` in your original code:

     ref reduce() { ... }

That also enables attribute inference, and your code will compile.


[1] https://dlang.org/spec/function.html#function-attribute-inference