Change Log:

When a conditional expression is the left operand of an assign expression, they would be parsed as an assignment to the result of the conditional. This has now been deprecated. To preserve the existing behaviour, add parentheses for the conditional without including the assignment:

bool test;
int a, b, c;
...
test ? a = b : c = 2;   // Deprecated
(test ? a = b : c) = 2; // Equivalent

This makes the intent clearer, because the first statement can easily be misread as the following code:

test ? a = b : (c = 2);

When writing debug code, one isn't interested in the type safety, but a pleasant debugging experience. The type checker already allowed to escape pure and @nogc within debug statement. With this release, @system code can be called from debug statements too:

void main()
{
    int[] arr = [1, 2];
    debug unsafeCode(arr);
}

@system void unsafeCode(T)(T[] arr)
{
    import core.stdc.stdio;
    printf("arr.ptr: %p", arr.ptr);
}

opDot was the D1 analog to alias this. However, alias this covers all use cases of opDot, but ensures safety.

struct S
{
    int a, b;
}
struct T
{
    S s;

    S* opDot()
    {
        return &s;
    }
}

void main()
{
    T t;
    t.a = 4;
    assert(t.a == 4);
    t.b = 5;
}

With alias this:

struct S
{
    int a, b;
}
struct T
{
    S s;

    alias s this;
}

void main() @safe
{
    T t;
    t.a = 4;
    assert(t.a == 4);
    t.b = 5;
}

Example

template AliasSeq(TList...)
{
    alias AliasSeq = TList;
}

enum MyEnum
{
    @("uda0") value0,
    @disable value1,
    deprecated value2  // Deprecation: enum member `main.MyEnum.value2` is deprecated
}

static assert(__traits(getAttributes, MyEnum.value0) == AliasSeq!("uda0"));

void main()
{
    auto v1 = MyEnum.value1;  // Error: enum member `main.MyEnum.value1` cannot be used because it is annotated with `@disable`
}

The deprecation period for C-style array declarations has expired. Beginning with this release, declaring arrays with C-style syntax will result in an error.

int a[2];  // Error: instead of C-style syntax, use D-style `int a[2]`
int[2] b;  // OK

It used to ignore the const and was missing the $$C escape prefix.

extern(C++) struct foo(T) {}

extern(C++) void test(foo!(const(char)) a) {}
// New
static assert(test.mangleof == "?test@@YAXU?$foo@$$CBD@@@Z");
// Old
//static assert(test.mangleof == "?test@@YAXU?$foo@D@@@Z");

Direct interop of D size_t and C++ size_t was working before 2.079, on all platforms except for 32-bit OS X. By mangling D long as C++ long long on 64-bit OS X starting with 2.079, size_t interop broke on a more relevant platform. With new/fixed aliases, e.g., core.stdc.stdint.int64_t, core.stdc.stdint.uint64_t and core.stdc.config.cpp_size_t, there are now proper tools for portable C++ interop wrt. integers. Reverting to the previous C++ mangling on 64-bit OS X (C++ long) may save mixed D/C++ code bases from the need of manual adaptations by skipping the 2.079 and 2.080 DMD versions.

User-defined attributes on function arguments behave analogous to existing UDAs:

void test(A)(@(22) A a)
{
    static assert([__traits(getAttributes, a)] == [22]);
}

When an exception is throw and not caught, a stacktrace is printed. On Linux, FreeBSD and DragonFlyBSD this stacktrace includes the filenames and line numbers, if the application was built with debug info enabled. This feature has now been added to macOS.

This requires support from the compiler since debug info is stripped by the linker on macOS.

Example:

void bar()
{
    throw new Exception("bar");
}

void foo()
{
    bar();
}

void main()
{
    foo();
}

Compiling the above code, with debug info enabled, by running: dmd -g main.d. When running the application it will produce an output similar to:

[email protected](3): bar
main.d:3 void main.bar() [0x71afdfb]
main.d:8 void main.foo() [0x71afe0c]
main.d:13 _Dmain [0x71afd78]

object.destroy() was crashing when called with an extern(C++) class. It now correctly destructs and resets the object to init.

Previously it was only possible to disable the trapping of exception by setting the global variable rt_trapExceptions to false. Now you can, for example, immediately open gdb at the uncaught exception:

> gdb -ex run --args  --DRT-trapExceptions=0
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/usr/lib/libthread_db.so.1".
uncaught exception
object.Exception@src/rt_trap_exceptions_drt.d(4): foo
––––––––––
src/rt_trap_exceptions_drt.d:4 void rt_trap_exceptions_drt.test() [0x55591026]
src/rt_trap_exceptions_drt.d:9 _Dmain [0x55591058]

Program received signal SIGABRT, Aborted.
0x00007ffff6e7b86b in raise () from /usr/lib/libc.so.6
(gdb) bt full
#0  0x00007ffff6e7b86b in raise () from /usr/lib/libc.so.6
No symbol table info available.
#1  0x00007ffff6e6640e in abort () from /usr/lib/libc.so.6
No symbol table info available.
#2  0x00005555555918cc in _d_throwdwarf (o=0x7ffff7ea4000) at src/rt/dwarfeh.d:233
        eh = 0x7ffff7fa4740
        refcount = 0
        r = 5
#3  0x0000555555591027 in rt_trap_exceptions_drt.test() () at ../../src/object.d:2695
        innerLocal = 20
#4  0x0000555555591059 in D main (args=...) at src/rt_trap_exceptions_drt.d:9
        myLocal = "bar"

This Week in D for an in-depth explanation of rt_trapExceptions

Declarations that were missing from mach-o/getsect.h has been added to core.sys.darwin.mach.getsect.

The require function provides a means to construct a new value when the key is not present.

class C{}
C[string] aa;

auto a = aa.require("a", new C);    // lookup "a", construct if not present

The update function allows different operations to be performed depending on whether a value already exists or needs to be constructed.

class C{}
C[string] aa;

C older;
C newer;
aa.update("a",
{
    newer = new C;
    return newer;
},
(ref C c)
{
    older = c;
    newer = new C;
    return newer;
});

The functions avoid the need to perform multiple key lookups. Further details are available in the spec.

Use the core.stdc package instead.

DMD

> dmd -O -inline -release ./joiner.d && ./joiner
before.joiner   = 57 secs, 834 ms, 289 μs, and 3 hnsecs
new.joiner      = 44 secs, 936 ms, 706 μs, and 5 hnsecs

LDC

> ldmd -O3 -release -inline joiner.d && ./joiner
before.joiner   = 5 secs, 180 ms, 193 μs, and 7 hnsecs
new.joiner      = 3 secs, 168 ms, 560 μs, and 6 hnsecs

The benchmark code can be found here.

Previously, without being stated in the documentation, std.algorithm.remove used to accept any values as offset. This behavior was very error-prone:

import std.algorithm, std.stdio;
[0, 1, 2, 3, 4].remove(1, 3).writeln; // 0, 2, 4  -- correct
[0, 1, 2, 3, 4].remove([1, 3]).writeln; // 0, 3, 4  -- incorrect

With this release, using arrays as individual elements is no longer valid. std.typecons.tuple can be used to explicitly indicate that a range from start to stop (non-enclosing) should be removed:

import std.algorithm, std.stdio, std.typecons;
[0, 1, 2, 3, 4].remove(tuple(1, 3)).writeln; // 0, 3, 4

However, only 2-tuples are allowed to avoid this un-intuitive scenario:

import std.algorithm, std.stdio, std.typecons;
[0, 1, 2, 3, 4].remove(tuple(1, 3, 4)).writeln; // 0, 4?

Due to the fact that Microsoft changes its timezone definitions too frequently to maintain the conversion between the IANA TZ Database names and the names that Microsoft uses in the standard library, several functions in std.datetime.timezone related to getting the time zone independently of the host OS were previously deprecated: TimeZone.getTimeZone, TimeZone.getInstalledTZNames, tzDatabaseNameToWindowsTZName, and windowsTZNameToTZDatabaseName. These functions have now been fully removed.

Instead of TimeZone.getTimeZone, std.datetime.timezone.PosixTimeZone.getTimeZone and std.datetime.timezone.WindowsTimeZone.getTimeZone should be used directly. Instead of Timezone.getInstalledTimeZones, std.datetime.timezone.PosixTimeZone.getInstalledTZNames and std.datetime.timezone.WindowsTimeZone.getInstalledTZNames should be used directly. And any programs looking to convert between the TZ Database names and the Windows names can use std.datetime.timezone.parseTZConversions with the current windowsZones.xml file to get the current conversions (see the documenation for std.datetime.timezone.parseTZConversions for details).

The semantics of std.math.fmin and std.math.fmax have been streamlined with the C functions: if one of the arguments is a NaN, return the other. This involves an additional std.math.isNaN check. Use std.algorithm.comparison.min and std.algorithm.comparison.max for the previous semantics performing a single comparison.

import std.math;
assert(fmin(real.nan, 2.0L) == 2.0L);
assert(fmin(2.0L, real.nan) == 2.0L); // previously: NaN
assert(isNaN(fmin(real.nan, real.nan)));

import std.algorithm.comparison;
assert(min(real.nan, 2.0L) == 2.0L);
assert(isNaN(min(2.0L, real.nan)));
assert(isNaN(min(real.nan, real.nan)));

With this release DUB allows defining additional paths that contain packages in subfolders with the pattern "(name)-(version)/(name)/" by defining a "customCachePaths" field in /etc/dub/settings.json or ~/.dub/settings.json.

"customCachePaths" can be used to provide prebuilt DUB libraries (e.g. for distribution package maintainers).