Silicon Valley D Meetup January 28, 2016

[Adam D. Ruppe via Digitalmars-d-announce]

On Friday, 29 January 2016 at 08:01:54 UTC, Ali Çehreli wrote:
> Why didn't you say hi? :)


There was no chat box!

I'm pretty uncomfortable with the whole video and audio thing. I 
think I sound terrible and look just as bad. I prefer reading and 
writing.


> I think we were seeing just two connections: Luís and us.

Yeah, I only saw the two boxes and myself, and I turned my camera 
+ mic off.

> Is there a reason why only auto functions have attribute 
> inference? Why not infer all attributes unless they are 
> overridden by explicit attributes?

The big reason is that for non-template functions, the body isn't 
necessarily there and it affects mangling.

So if you tried to do the whole .di thing and wrote:

void foo() { ... } // implicitly @safe implementation

and accessed it via

void foo(); // not marked, but no body so cannot be inferred...


You'd get linker errors because the bodyless one now has a 
different mangled name from being unable to infer.


This can also be relevant with inheritance:


class Base {
    void foo() { a+b; } // implicitly @safe
}

class Derived : Base {
    void foo() { *(cast(void*) 0) = 0; } // totally @system
}


What happens then? Is Derived.foo an error because it cannot 
override the implicitly @safe interface of Base.foo?

I think: yes, that's exactly what should happen.


But, what if you import an interface file again:

class Base {
    void foo();
}


Can we still make it an error? Eh, not reliably. And then the 
danger is: here, Base.foo *appears* to be @system, so the 
compiler will let you override it.

But in the file that uses it, with the full definition, the 
compiler inferred it to be @safe.


@safe useMyClass(Base base) {
    base.foo(); // allowed, it thinks foo is @safe
}



then the other module, compiled separately via bodyless 
interface, does:


useMyClass(new Derived());


...and it compiles because Derived *it believes* implements the 
Base interface correctly.... but now the @safe guarantee was just 
blown wide open.



With templates, the body must be present at *all* uses, even if 
compiled separately, so it doesn't fall victim to this, but other 
functions do bring a few worries.


(though, on the other hand, using a .di file, you could always 
just lie about the attributes anyway and the compiler trusts 
you... so maybe we aren't in that great of a position to begin 
with and this shouldn't be a blocker....)