Change Log: 2.089.0

Up until this version it was allowed to shadow a variable in a foreach loop, although it is dissallowed in a normal for loop. This patch makes the behavior of the foreach loop consistent with the for loop one. To fix any issues encountered, rename the variable inside the foreach body that shadows the one from the upper scope.

With Bugzilla 20138 fixed, IsExpressions now correctly match combinations of the qualifiers const, inout, and shared.

Examples that failed previously but pass now:

static assert(is(shared(const int) U == shared U) && is(U == const int));
static assert(is(shared(inout int) U == inout U) && is(U == shared int));

Note that the behavior of code like the following changes:

static if (is(T U == const U) { ...}
else static if (is(T U == shared const U)) { ... }

The second case will never be reached, because the first one now matches when T is shared const. To get the old behavior, switch the order.

This was already true for string mixins, but since template mixins introduce a new scope, symbols inside them got mangled as D symbols. However, users often use extern(C) inside a mixin template to automatically generate boilerplate code that should be accessible from C.

// library code
mixin template WasmEntryPoint() {
    extern(C) export void _start() {
        // boilerplate code
    }
}

mixin template UseGpuInsteadOfIntegratedGraphics() {
    extern(C) export uint NvOptimusEnablement = 0x00000001;
    extern(C) export int AmdPowerXpressRequestHighPerformance = 1;
}

// application code
mixin WasmEntryPoint;
mixin UseGpuInsteadOfIntegratedGraphics;

static assert(_start.mangleof == "_start");
static assert(NvOptimusEnablement.mangleof == "NvOptimusEnablement");

Previously, _start would be mangled like _D9onlineapp8__mixin46_startUkZv and users had to manually add pragma(mangle, "_start") or use a string mixin instead. With the new behavior this is not necessary anymore for extern(C), as well as extern(Windows) and extern(Objective-C). extern(C++) remains unchanged since it already always mangles to C++, even in nested scopes.

There is a possibility this breaks code if you mix in different extern(C) declarations with the same name in the global scope of multiple modules.

import core.stdc.stdio;

mixin template GenPrintCallback(string text) {
    extern(C):

    auto textLength = text.length;
    auto textPointer = text.ptr;

    void callBackOnly() {
        printf("%.*s\n", textLength, textPointer);
    }

    mixin(`auto `, text, ` = &callBackOnly;`);
}

mixin GenPrintCallback!"foo";

// in a different module:
mixin GenPrintCallback!"bar";

In this case textLength, textPointer and callBackOnly will be defined multiple times, so the linker either picks one or raises and error. The solution is to not make variables extern(C) and make C callback functions anonymous:

import core.stdc.stdio;

mixin template GenPrintCallback(string text) {

    auto textLength = text.length; // not below an extern(C): anymore
    auto textPointer = text.ptr;

    alias FunT = extern(C) void function();
    enum FunT callBackOnly = () {
        printf("%.*s\n", textLength, textPointer);
    };

    mixin(`auto `, text, ` = callBackOnly;`);
}

The default linker when building with -m32 under Windows has been changed from link.exe to optlink.exe to avoid calling the wrong linker when both the Digital Mars tool chain and the Microsoft compiler tools are found in the PATH environment variable.

On POSIX, dmd passes -L-prefixed compiler flags through the linker driver (cc by default) to the linker (e.g. ld) by prepending them with -Xlinker. Therefore, it was not possible to pass flags directly to the linker driver.

This release adds a new compiler flag, -Xcc, which specifies a flag to pass to the linker driver. This switch has already existed in the LDC compiler for several releases. Some use cases for it would be -nostartfiles, -pthread, and -static, which can now be specified as -Xcc=-nostartfiles, -Xcc=-pthread, and -Xcc=-static respectively.

Note that it was previously also possible to specify linker driver options by setting the CC environment variable, e.g. CC='cc -pthread' dmd ..., or by setting the CC variable to point to a custom linker driver wrapper script. -Xcc improves on this through composability and better opportunities for integration into build systems.

See also:

• Issue 6952
• GCC Link Options

Added core.atomic.atomicFetchAdd and core.atomic.atomicFetchSub to the atomic suite.

The predicates that operate on the wstatus value reported by wait(2) are now marked pure and @safe, allowing them to be used in functions with those attributes.

std.traits.Unconst works like std.traits.Unqual, but removes only const, inout and immutable qualifiers from a type.

The ldc2 driver now supports

• some more command-line options (coverage, profiling, keeping stack frame),
• separate linking,
• cross-compilation by specifying the target triple (LDC -mtriple) as --arch, e.g., --arch=x86_64-pc-windows-msvc. Check out https://wiki.dlang.org/Cross-compiling_with_LDC for how to setup LDC.

Dub supports now command lint, which will execute D-Scanner on the dub package. By default dub lint will execute style check. Import paths to dependent dub packages will be passed to D-Scanner.

dub lint

Dub now supports version specifications of the form ^x.y.z. This corresponds to a "semver compatible version", ie. any version up from x.y.z with the same major number. If the major number is 0, only the same version matches. This corresponds to the versions listed on https://semver.org/ as compatible with the public API of the version given. ^x.y is equivalent to ^x.y.0.