Change Log: 2.067.0

Previously, when a struct allocated on the heap was freed, the destructor was not invoked. This is no longer the case, and these destructors will now be invoked before the memory is freed by the GC.

By adding the appropriate attributes to an asm statement you can tell the compiler how that asm code behaves, thus allowing asm statements to be used in pure, nothrow, @nogc, or @safe functions.

asm pure nothrow @nogc @trusted
{
    // the compiler does not check the attributes
    ret;
}

New optional syntax was added for package protection attribute:

module aaa.bbb.ccc.ddd;

// accessible from any module with aaa.bbb in qualified path
package(aaa.bbb) void foo() {}

// old style, means same as package(aaa.bbb.ccc)
package void bar() {}

In @safe functions it is now required to use return ref to return a reference to a parameter or a field of it.

@safe:
ref int fun(ref int a) { return a; } // ERROR
ref int gun(return ref int a) { return a; } // FINE
ref T hun(T)(ref T a) { return a; } // FINE, templates use deduction

See DIP25 for more details.

A longstanding bug of the with statement was fixed which prevented the idiomatic use of RAII values.

with (File("output.log", "w"))
{
    writeln("Content");
}
// File is automatically closed

A new GC growth policy was implemented that helps to reduce the number of collections by keeping a collection threshold at 2x the size of the used memory. After each collection the used memory and the threshold are recomputed. This allows for an exponential growth of the GC heap, e.g. during program startup, but limits the heap size relative to the actual used memory. The factor 2x is configurable by setting heapSizeFactor.

The heap traversal during the marking phase is now done using tail recursion with a separate compact state stack. This allows to mark very deep heaps (lists) much faster because the previous recursion limit of 50 is eliminated.

You can see a list of all improvements here.

Calls to volatileLoad and volatileStore are recognized by the compiler and guaranteed to not be removed or reordered in the same thread.

void example(uint* address, uint value)
{
    import core.bitop;

    // store value
    volatileStore(address, value);

    // wait until value takes affect
    while (volatileLoad(address) != value)
    { }
}

Note: These intrinsics are currently in core.bitop, but will be moved to core.volatile when volatile is no longer a keyword.

By default, GC options can only be passed on the command line of the program to run, e.g.

app "--DRT-gcopt=profile:1 minPoolSize:16" arguments to app

Available GC options are:

• disable:0|1 - start disabled
• profile:0|1 - enable profiling with summary when terminating program
• initReserve:N - initial memory to reserve in MB
• minPoolSize:N - initial and minimum pool size in MB
• maxPoolSize:N - maximum pool size in MB
• incPoolSize:N - pool size increment MB
• heapSizeFactor:N - targeted heap size to used memory ratio

In addition, --DRT-gcopt=help will show the list of options and their current settings.

Command line options starting with "--DRT-" are filtered out before calling main, so the program will not see them. They are still available via rt_args().

Configuration via the command line can be disabled by declaring a variable for the linker to pick up before using its default from the runtime:

extern(C) __gshared bool rt_cmdline_enabled = false;

Likewise, declare a boolean rt_envvars_enabled to enable configuration via the environment variable "DRT_GCOPT:

extern(C) __gshared bool rt_envvars_enabled = true;

Setting default configuration properties in the executable can be done by specifying an array of options named rt_options:

extern(C) __gshared string[] rt_options = [ "gcopt=initReserve:100 profile:1" ];

Evaluation order of options is rt_options, then environment variables, then command line arguments, i.e. if command line arguments are not disabled, they can override options specified through the environment or embedded in the executable.

Built-in associative arrays now have a .byKeyValue method that returns a forward range iterating over key/value pairs.

void main()
{
    auto aa = ["a": 1];
    foreach (pair; aa.byKeyValue)
    {
        assert(pair.key == "a");
        assert(pair.value == 1);
    }
}

enumerate enables iteration of ranges with an index variable:

void main()
{
    import std.stdio : stdin, stdout;
    import std.range : enumerate;

    foreach (lineNum, line; stdin.byLine().enumerate(1))
        stdout.writefln("line #%s: %s", lineNum, line);
}

handle enables exception handling in range compositions:

import std.algorithm : equal;
import std.range : retro;
import std.utf : UTFException;

auto str = "hello\xFFworld"; // 0xFF is an invalid UTF-8 code unit

auto handled = str.handle!(UTFException, RangePrimitive.access,
        (e, r) => ' '); // Replace invalid code points with spaces

assert(handled.equal("hello world")); // `front` is handled,
assert(handled.retro.equal("dlrow olleh")); // as well as `back`

import std.experimental.logger;

void main()
{
    log("message logging in D");
}