Reference value of structs not optimized or inlined?

[Jeremie Pelletier]

downs Wrote:

> Walter Bright wrote:
> > Jeremie Pelletier wrote:
> >> Isn't it possible to make 'const ref S' or 'in S' generate the same
> >> machine code as 'in S*'? To me it would seem the semantics of the two
> >> are the same, with 'const S*' being useful syntax for C compatibility
> >> while 'in S' and 'const ref S' are both D syntax.
> > 
> > The thing about const is it only specifies a read only view of an
> > object, it does *not* specify that the referenced object will not
> > change. That is why pass by value cannot be "optimized" to be pass by
> > reference.
> > 
> 
> To elaborate on this, consider this case:
> 
> import std.stdio;
> 
> struct X { int v; }
> 
> void test(X x, void delegate() dg) { writefln(x.v); dg(); writefln(x.v); }
> 
> void main() {
>   X ecks;
>   test(ecks, { ecks.v = 17; });
> }

Ok, I understand why it cant be done for 'in S' but I don't see why 'const ref S' cannot have the same semantics as 'in S*', unless 'ref' doesn't mean that the struct is implicitly dereferenced.

Here is some code to illustrate my point of view:

struct S { int i; }
S s;

void Stuff() { s.i++; }

void Foo(in S* s) {
    writefln(s.i);
    Stuff();
    writefln(s.i);
}
void Bar(const ref S s) {
    writefln(s.i);
    Stuff();
    writefln(s.i);
}

int main() {
    // Those both do the exact same thing
    Foo(&s);
    Bar(s);
}

If they are meant to have different semantics, then when is a good time to use ref? It would seem to me 'in S*' and 'S*' carry both behaviors you want in a referenced parameter: const and mutable. In any case only the reference is passed by value, not the struct itself.

If the method calls another method which modifies the const view on the reference, then it should be a logic error from the programmer (good old shooting yourself in the foot) without the compiler getting in the way. Making fool-proof language semantics is a good idea, but IMO it shouldn't impact performance, or else any bit of code looking for time critical performance will never use the syntax that makes D shine, and a lot of confusion will spread around as both types of syntax are used. It also makes it confusing to interface with IDL.

Alls I'm suggesting is that 'const ref S' and 'ref S' generate the same machine code as 'in S*' and 'S*', which would prevent us from using different syntax to get the performance boost, when in the end the intended behavior is the same.