On Tuesday, 9 February 2016 at 16:32:07 UTC, Steven Schveighoffer wrote:
> I think the rules at the moment are that the compiler allows implicit conversion if the return value could not have come from any of the parameters. But what it may not consider is if the parameters could be return values themselves via a reference!

AFAIK it just traverse members and search for exactly match with return
type. Even more there is different checks for "pure" and "unique owned
result".

import std.stdio;

int[] f(void[] a) @safe pure
{
    return cast(int[])a;
}

void main() @safe
{
    int[] a = new int[4];

    immutable b = a.f();
    writeln(b);
    a[0] = 1;
    writeln(b);
}

This works until you change void[] to int[].
And error message is about casting to immutable not about purity.

This is terribly because if there is a code:

int[] f(SophisticatedClass a){...}
immutable a = f(new SophisticatedClass);

that was working last 100 years but then somebody adds member
of type int[] into SophisticatedClass.field.field.field
You take sort of this:
Error: cannot implicitly convert expression (f(a)) of type int[] to immutable(int[])

It's hard to prove that result is unique. So maybe don't try to do?