Summary: Safer typesafe variadics
           Product: D
           Version: D2
          Platform: All
        OS/Version: All
            Status: NEW
          Severity: enhancement
          Priority: P2
         Component: DMD

--- Comment #0 from 2010-11-13 10:13:23 PST ---
With DMD 2.050 this D2 program usually asserts at run-time:

class Foo {
    int[] args;
    this(int[] args_...) {
        args = args_;
Foo foo() {
    return new Foo(1, 2, 3); // passes stack data to Foo
void main() {
    assert(foo().args == [1, 2, 3]);

That's the root cause of a bug found by a person in the D.learn group:

Just adding a dup inside the this() avoids the bug. Also, the bug is avoided if
Foo receives arguments like this:

Foo foo() {
    return new Foo([1, 2, 3]);

So this nature of typesafe variadic arguments is bug-prone. There are various
ways to avoid this problem.

One possible solution is to modify the semantics of this kind of arguments
pass, so the code inside the function foo always see an args array allocated on
the heap (it may perform a run-time test, and dup the given arguments only if
the data is on the stack, so in the second example it doesn't dup and saves a
little of RAM and running time).

To restore the original efficient semantics of the typesafe variadics a "scope"
attribute may be added (as the one used to avoid a closure):

class Foo {
    int[] args;
    this(scope int[] args_...) { // unsafe but fast
        args = args_;

This is safer than the current semantics because, as usual in D design, the
safe way is the built-in one and the faster one is on request.

This is just one of the possible ways to avoid this problem.

Configure issuemail:
------- You are receiving this mail because: -------

Reply via email to