Change Log: 2.090.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.

Dub will no longer build dynamicLibrary targetType's as staticLibrary.

Except for x86_omf. This has been disabled due to numerous issues that will lead this to not doing what is expected of it.

No compiler or linker flags have been added at this time, you will need to specify the relevant flag to get the compiler to link dynamically against Phobos.

The $DUB_BUILD_PATH variable is now defined inside the postBuildCommands section. It contains the absolute path in which the package was built, and can be used to copy by-products of the build process to their intended locations.

For example, if an executable exports symbols, you will want to make the resulting import library and symbols export file available somewhere. That can be done with a dub.json section like this:

    "postBuildCommands-windows": [
        "copy /y $DUB_BUILD_PATH\\$DUB_TARGET_NAME.lib $PACKAGE_DIR\\lib"
        "copy /y $DUB_BUILD_PATH\\$DUB_TARGET_NAME.exp $PACKAGE_DIR\\lib"
    ],

Now users can use the documented predefined variables inside custom command directives without the need for a wrapper shell script.

Before this would have failed:

"preBuildCommands": ["$DC -run foo.d"]

It was before possible to run a script that used the $DC environment variable or on POSIX escape the $ with $$DC to make the shell substitute the variable. These workarounds are no longer needed now.

API change: none of the different command directives are no longer substituted with the process environment variables. You now access the raw commands as provided by the user in the recipe. dub describe has been adjusted and now also processes the predefined environment variables as well as the process environment variables.