another cool RTInfo trick - i want in runtime

[Namespace]

On Thursday, 16 January 2014 at 19:13:42 UTC, Adam D. Ruppe wrote:
> On Thursday, 16 January 2014 at 18:44:54 UTC, Namespace wrote:
>> I guess that could work pretty well for a C++ friend emulation 
>> with UDA's! Were not you the one who wanted to show me an 
>> example for that with using RTInfo?
>
> I've played with rtinfo a lot before, but I don't remember 
> doing C++ friend emulation...
>
>> Offer your way the possibility to check automatically for null 
>> references? With an UDA e.g. @safe_ref or @not_null
>
> I think those would be better done with the type info, like 
> NotNull!t.
>
> What's cool about the RTInfo thing though is it is checked on 
> everything, so it can check for the *absence* of a UDA as well 
> as for the presence.
>
> You might say something must not have any nullable references 
> unless specially marked. The rtinfo checker can confirm that: 
> loop over all members, if it is potentially nullable and isn't 
> marked with either NotNull or 
> @i_know_this_is_nullable_and_that_is_ok, it can throw an error.
>
> It is possible to do that kind of thing with static assert on 
> the module level too.... sort of. See, the module level one for 
> one can be forgotten and it can't access nested things in 
> functions:
>
> void foo() {
>   struct InnerStruct {}
> }
>
> // can't see foo.InnerStuct here!
> static assert(ModulePassesCheck!(mixin("this_module")));
>
>
> But RTInfo *does* see InnerStruct, and you don't have to 
> remember to add the check to your module too.

All right, it wasn't you, it was Andrej Mitrovic on my thread 
http://forum.dlang.org/thread/pdshwedjqgquoibxhrxa@forum.dlang.org#post-mailman.1977.1381065059.1719.digitalmars-d-learn:40puremagic.com

The problem on a library NotNull struct is: nobody will use it, 
because it requires NotNull on both sides, by the caller and by 
the callee:

----
class A { }

void safe_foo(NotNull!A na) { }

void main() {
     NotNull!A na = NotNull!A(new A());
     safe_foo(na);
}
----

Which is a lot more effor than:

----
class A { }

void safe_foo(@safe_ref A na) { }

void main() {
     A a = new A();
     safe_foo(a);
}
----

because it moves the check to the callee.