Change Log: 2.085.0

Aliases can be created directly from the traits that return symbol(s) or tuples. This includes getMember, allMembers, derivedMembers, parent, getOverloads, getVirtualFunctions, getVirtualMethods, getUnitTests, getAttributes and finally getAliasThis. Previously an AliasSeq was necessary in order to alias their return. Now the grammar allows to write shorter declarations:

struct Foo
{
    static int a;
}

alias oldWay = AliasSeq!(__traits(getMember, Foo, "a"))[0];
alias newWay = __traits(getMember, Foo, "a");

To permit this it was more interesting to include __trait in the basic types rather than just changing the alias syntax. So additionally, wherever a type appears a __trait can be used, for example in a variable declaration:

struct Foo { static struct Bar {} }
const(__traits(getMember, Foo, "Bar")) fooBar;
static assert(is(typeof(fooBar) == const(Foo.Bar)));

Option("check=[assert|bounds|in|invariant|out|switch][=[on|off]]", `Overrides default, -boundscheck, -release and -unittest options to enable or disable specific checks.

• assert: assertion checking
• bounds: array bounds
• in: in contracts
• invariant: class/struct invariants
• out: out contracts
• switch: switch default

• on or not specified: specified check is enabled.
• off: specified check is disabled.

It covers action taken when an assert fails, a bounds check fails, or a final switch error happens. D means the usual D behavior of throwing an Error, C means call the C runtime library assert failure function, and halt means halt the program execution.

The halt is the main addition here, it enables very lightweight assert's.

Before this release -color wouldn't output colorized console output if the terminal detection failed. With this release, a new option auto is introduced for -color=<value> which will continue to be the default:

• auto: enable colorized output if a tty is detected (default)
• on: always use colored output.
• off: never use colored output.

Hence, it is now possible to use -color (a shortcut for -color=on) to force DMD to emit colorized console output. For example, this will now use colorized console output:

> echo $(echo "test" | dmd -color - 2>&1)
__stdin.d(2): Error: no identifier for declarator test

This is useful to debug errors in compilation and provides source for debuggers to show when requested.

Prior to this release, binary literals without any digits after the prefix 0b were considered valid. This has now been deprecated.

auto foo = 0b;   // deprecated
auto bar = 0b_;  // deprecated
auto baz = 0b0;  // conforming equivalent

This linkage is completely unused, being an heritage from a few decades ago. Additionally, it's only supported by DMD and cause mangling ambiguity.

// a.d
import std.stdio;

// b.d
import a;

void main()
{
    std.stdio.writefln("foo");         // deprecation before patch, now errors
}

In order to compile the example successfully, public needs to be added to the import located in a.d : public import std.stdio; or import std.stdio; needs to be added to b.d.

Before this version, anything including extern(C++) templates was not correctly mangled on OSX, Linux, and FreeBSD, leading to linker errors.

This allows code interfacing with C++ that uses wchar_t to link correctly. It replaces wchar (Windows) and dchar (Posix) as the memory type for the DRuntime alias wchar_t.

Added core.stdcpp.array, which links against C++ std::array

Add D header file core.sys.darwin.crt_externs for libc/crt_externs.h on Darwin.

object.destroy() now receives an initialize argument to specify whether to re-initialize the object after destruction.

Added core.stdcpp.string_view, which links against C++ std::string_view

std.random.unpredictableSeed now has an overloaded version std.random.unpredictableSeed!UIntType that can be used to produce seeds of any unsigned type UIntType.

import std.random : unpredictableSeed;

auto a = unpredictableSeed!uint;
static assert(is(typeof(a) == uint));

auto b = unpredictableSeed!ulong;
static assert(is(typeof(b) == ulong));

// The old syntax still works.
uint c = unpredictableSeed;

Additionally the implementation quality of unpredictableSeed has been improved, speeding it up and eliminating an obvious pattern in the high bit. (Bear in mind that unpredictableSeed is still not cryptographically secure.)