pure factory function vs immutable(Foo)**

[ag0aep6g via Digitalmars-d-learn]

I feel like I must be missing something here.

This works:

----
alias T = int;

T** f(const T** input) pure
{
     T** output;
     return output;
}

void main()
{
     T i;
     T* p = &i;
     immutable T** r = f(&p);
}
----

`f` is `pure`, its parameter is const, and its return type has mutable 
indirections. That makes it a "pure factory function" [1].

Since `f` is a pure factory function, the compiler can assume that the 
result is not referenced from anywhere else. So I can declare it 
`immutable`.

So far, so good.

Now change `T` to `alias T = immutable int;`. The program gets rejected. 
The error message is: "cannot implicitly convert expression (f(& p)) of 
type immutable(int)** to immutable(int**)".

What changed? `f` can now return a reference to `i`. But that's not a 
problem, because that part of the return type is already `immutable`. 
What would be a problem is if `f` could return a reference to `p`. But 
it can't, as far as I can tell.

Am I missing something or could/should the program be accepted with `T = 
immutable int`? What could `f` do that would break `r`'s immutability?


[1] https://dlang.org/spec/function.html#pure-functions