Change Log: 2.083.0

In order to link against C++ code, it is important to know what C++ runtime the ABI targets.

Supported version identifiers include:

• CppRuntime_Clang
• CppRuntime_DigitalMars
• CppRuntime_Gcc
• CppRuntime_Microsoft
• CppRuntime_Sun

The C++ runtime in use generally depends on the C++ compiler used to build the C++ code that will be linked against. This is contrast to the C runtime, which generally depends on the target system.

This switch was deprecated in v2.075.0 and is now removed, meaning DMD will complain about an unrecognized switch. -gc used to pretend to be C, but debuggers have been D-aware for around a decade.

Takes one argument which must be a type. If the type's default initializer has no non-zero bits then true is returned, otherwise false. isZeroInit will always return true for a class C because C.init is a null reference.

This property was already being computed internally by the compiler so exposing it via __traits is more efficient than re-implementing it in library code.

struct S1
{
    int x;
}

struct S2
{
    int x = -1;
}

static assert(__traits(isZeroInit, S1));
static assert(!__traits(isZeroInit, S2));

void test()
{
    int x = 3;
    static assert(__traits(isZeroInit, typeof(x)));
}

The new syntax allows for keywords to be used for mangling and only changes the mangle of a symbol. It does not provide any feature resembling C++ namespaces. This allows users to structure their C++ in traditional D fashion, utilizing modules. The old syntax extern(C++, foo) would occupy the symbol foo. This meant modules couldn't use this name and match the C++ namespace.

extern(C++, "__traits") void foo();

extern(C++, "std", "chrono") void bar(); // multiple namespace syntax

int std; // no symbol clashing with above extern(C++, "std", ...)

Emits a custom linker directive to the object file, eg:

pragma(linkerDirective, "/alternatename:_pWeakValue=_pDefaultWeakValue");

This is only supported for MS-COFF output.

Since destructors for object fields can now get called by the constructor for that object if the constructor fails, the attributes of the destructors must be covariant with the attributes for the constructor.

I.e. if the constructor is marked @safe, the fields' destructors must also be @safe or @trusted.

Since this behavior was never checked before, this fix causes breakage of existing code. Hence, enabling this behavior is behind the new transition=dtorfields compiler switch. It will eventually become the default behavior, so it is recommended to fix any of these destructor attribute issues.

getTargetInfo accepts a string key as argument to select the target detail of interest.

static if (__traits(getTargetInfo, "cppRuntimeLibrary") == "msvcrtd") { ... }

static assert (__traits(getTargetInfo, "not_a_target_info") == "??"); // <- error: no such targetInfo "not_a_target_info"!

getTargetInfo keys are implementation defined, allowing relevant data for exotic targets. A reliable subset which are always available shall be mentioned in the spec.

std.algorithm.iteration.each is now capable of exiting early. When a No.each std.typecons.Flag is returned from the function that is called by each, the iteration will be aborted early. Analogously, returning Yes.each will continue the iteration. For example:

auto arr = [10, 20, 30];
arr.each!((n) { arr ~= n; return (n == 20) ? No.each : Yes.each; }); // aborts after the second iteration
assert(arr == [10, 20, 30, 10, 20]);

Custom hashing can be implemented in a Hook. If no hashing is specified, then the built-in function will be used. Checked can now be used with associative arrays.

import std.experimental.checkedint;

static struct MyHook
{
    static size_t hookToHash(T)(T payload)
    {
        auto h = typeid(payload).getHash(&payload);
        return h + 0x9e3779b9 + (h << 6) + (h >> 2);
    }
}

auto h = checked!MyHook(142).toHash();

This build option can be used to pass -betterC argument to DMD or LDC:

dub.json:

"buildOptions": ["betterC"]

dub.sdl:

buildOptions "betterC"

When executing external commands, DUB will now set the environment variable DUB_PACKAGE_VERSION. The variable will contain the version of the package being built, as it appears in the output of dub describe.

One application of this addition is to use a pre-build command to save the package version to a source file, in order to compile the version string into the application being built.