I've been listening in on this and the talk about @nogc on constructors highlights the need to me of having more attribute inference. Yes, it works on templates, but not all methods are templates.

int add(int a, int b) { return a+b; }

OK, cool, but what if you want to call that in a @nogc context? Or a nothrow context? Or a @safe context? Won't work!

@safe nothrow @nogc
int add(int a, int b) { return a+b; }

It just gets silly listing it like that. What abotu

import std.conv;
class Foo {
   this(int a) { this.a = a; }
   int a;
}

@nogc void foo() {
   ubyte[__traits(classInstanceSize, Foo)] buffer;
   Foo foo = emplace!Foo(buffer[], 2);
}

That won't work because the ctor is not explicitly marked @nogc!


l.d(9): Error: @nogc function 'l.foo' cannot call non-@nogc function 'std.conv.emplace!(Foo, int).emplace'


Since emplace itself is a template, it isn't the problem... it is Foo's constructor. It isn't a template and isn't marked @nogc, so it won't propagate.



You can fix it by marking `@nogc this(int a) {....}`

But isn't this getting silly? Everything needs half a dozen attributes!



It'd be nice if we could do some kind of implicit cast in the template if the function body is available for inspection. Or something.

In the real world, I rarely see people defensively putting @nogc on functions like this, but that limits down the line :(

Reply via email to