Change Log: 2.068.0

In order to fix Issue 14828 compiler helper functions for array bounds checking and assert are now generated only once when a module is compiled, not everytime they are used. This may lead to link errors when using a module without compiling and linking against it.

If you encounter link errors like

undefined reference to '_D5mylib5mymod7__arrayZ'

undefined reference to '_D5mylib5mymod8__assertFiZv'

undefined reference to '_D5mylib5mymod15__unittest_failFiZv'

When compiling with -profile=gc dmd will instrument GC allocations to be traced by the runtime. The runtime accumulates the traces and writes a report to the file profilegc.log upon program termination.

Example:

bytes allocated, type, function, file:line
     171        immutable(char)[] example.concat example.d:4
      24        closure D main example.d:18
      16        example.Klass D main example.d:20
            

Note: GC allocations using the core.memory interface are not profiled.

When the unittest code is not necessary, it will be merely analyzed as the tokens enclosed with paired braces, to speed up compilation.

unittest { auto r = test(); assert(r); }
// If you don't specify -unittest, no AST generated for the unittest block.

unittest { the contents is just ignored. }
// Since 2.067: this had caused parsing error.
//  From 2.068: no error happens, because it's equivalent with:
enum unittest_code = q{ the contents is just ignored. };

A new pragma was added for more fine-grained control of inlining. It must be used together with the -inline switch.

pragma(inline, true) // errors if function isn't inlined
int double(int val) { return 2 * val; }

pragma(inline, false) // never inline
int double(int val) { return 2 * val; }

Read the documentation for more details.

Just like templated functions, functions with an auto return type must always have a function body. The compiler was changed to take advantage of this fact and now also infers attributes for them.

auto foo()() {} // template function
auto bar() {}   // non-template function without return type
void baz() {}   // non-template function with return type

static assert(is(typeof(&foo!()) == void function() pure nothrow @nogc @safe));
static assert(is(typeof(&bar) == void function() pure nothrow @nogc @safe));
static assert(is(typeof(&baz) == void function()));

A parsing limitation was lifted and it's now possible to use an indexed type tuple followed by dot identifiers as typename.

alias TypeTuple(T...) = T;

struct S
{
    alias T = int;
    alias U = TypeTuple!(long, string);
}

alias Pair = TypeTuple!(S, S);

struct X(Types...)   // used tuple parameter
{

    Types[0].T a;     // Types[0] == S, then typeof(a) == S.T == int
    Types[0].U[1] b;  // Types[0].U == S.U, then typeof(b) == S.U[1] == string
}
alias x = X!Pair;

When performing IFTI templated types can now be deduced from a parameter's default argument. This avoids a redundant and error prone declaration of the default type.

void previously(T=int)(T t = 0) { } // it was necessary to also specify a default type
void now(T)(T t = 0) { } // the default type can be deduced from the default argument as int
void main() { previously(); now(); }

Invalid reinterpret casts are now detected in the compiler frontend instead of the backend. This allows to check for possible reinterpret casts during compile time and improves the error messages for invalid casts.

pragma(msg, is(typeof({ void* x; auto y = cast(void delegate())x; })));
// Since 2.067: it prints 'true'
//  From 2.068: it prints 'false'

void test() { void* x; auto y = cast(void delegate())x; }
// Since 2.067: it had reported internal compiler error "Error: e2ir: cannot cast ..."
//  From 2.068: it reports proper frontend error.

Many phobos functions that allocated GC memory were changed to support ranges or were complemented by an alternative supporting ranges. Using ranges often eliminates GC allocations.

setExtension("foo.jpg", ".png"); // allocates a new string
withExtension("foo.jpg", ".png"); // returns a range without allocating

The GC option --DRT-gcopt=profile has been enhanced to accept an additional level 2 that allows profiling API calls grouped by most common operations.

As this instrumentation has an impact on the GC performance even if unused, you have to recompile the GC module with -debug=PROFILE_API, e.g.

dmd test.d -O -inline -debug=PROFILE_API -Ipath-to-druntime/src path-to-druntime/src/gc/gc.d
./test --DRT-gcopt=profile:2

    malloc:  9768628 calls, 531 ms
    realloc: 0 calls, 0 ms
    free:    0 calls, 0 ms
    extend:  1100 calls, 0 ms
    other:   826 calls, 0 ms
    lock time: 160 ms
    GC API: 692 ms
GC summary:   12 MB,   52 GC  331 ms, Pauses  227 ms <    4 ms API  692 ms

The malloc function includes time for GC collections. Lock time (GC synchronization) is measured separately and not included in the other times.

The runtime implementation for associative arrays was rewritten and now uses open addressing with quadratic probing and triangular numbers. This is much more cache friendly than the old separate chaining implementation and can result in ~25% faster lookups for big AAs. Also see druntime#1229.

Note: As the allocation pattern changed (the table is bigger, nodes are smaller) you might see a small drop in performance because the GC manages big allocations less efficiently.