In the thread "Slow performance compared to C++, ideas?" Manu is arguing
that methods should be non-virtual by default. The problem he is having
is that developers will forget to declare methods as final.
This issue got me think if there's a way to automatically detect that a
method is virtual that shouldn't be.
If one modifies druntime to take advantage out of RTInfo. If I
understand everything correctly RTInfo will be instantiated once for
each user defined type. With that and the help of a UDA you can check
that all methods that should be final really are final. Something like:
struct virtual {} // the UDA
class Foo
{
void a () {} // static assert, not declared as @virtual
@virtual void b () {} // ok
@virtual final void c () {} // static assert, declared as final and
@virtual
final d () {} // ok
}
checkVirtual!(Foo);
import std.typetuple;
void checkVirtual (T) ()
{
static if (!is(T == class))
return;
foreach (m ; __traits(derivedMembers, T))
{
alias TypeTuple!(__traits(getAttributes, mixin("T." ~ m))) attrs;
enum methodName = T.stringof ~ "." ~ m.stringof;
static if (staticIndexOf!(virtual, attrs) != -1)
{
static if (!__traits(isVirtualMethod, mixin("T." ~ m)))
static assert (false, "Method " ~ methodName ~ " marked
as @virtual is not virtual");
}
else
{
static if (__traits(isVirtualMethod, mixin("T." ~ m)))
static assert (false, "Method " ~ methodName ~ " is
virtual but not marked as @virtual");
}
}
}
--
/Jacob Carlborg
