Change Log: 2.112.0

Similar to auto ref parameters in 2.111, it's now deprecated to declare an auto ref return type without putting those two keywords next to each other as well.

ref auto int f() => 3;
auto { ref int g() => 3; }

// Correction:
auto ref f() => 3;
auto ref g() => 3;

The compiler now accepts c++23 as a supported standard for -extern-std=. Currently this only changes the value of __traits(getTargetInfo, "cppStd").

These map to a single x86_64 instruction and have accordingly been optimized via inline assembly.

import core.int128;

ulong a, b;
Cent product128 = mul(a, b);

ulong divisor64 = …;
ulong modulus64;
ulong quotient64 = udivmod(product128, divisor64, modulus64);

macOS 15.4 has introduced an undocumented ABI change to the format of thread local variable section, which causes almost all executable built with previous D compiler versions to crash during initialization, if they use DRuntime. This release introduces a mitigation for this issue that is backwards compatible with previous versions of macOS.

This prevents linking errors when using -betterC. For example:

import core.sys.posix.stdlib;
import core.sys.posix.unistd;

extern(C) int main()
{
    int status, pid = vfork();
    if (pid == 0)
    {
        // ...
        return 0;
    }

    waitpid(pid, &status, 0);
    if (WIFEXITED(status))
    {
        // ...
    }
    return 0;
}

This would fail to compile with the -betterC flag:

Error: undefined reference to `core.sys.posix.sys.wait.WIFEXITED(int)`
       referenced from `main`

The reason is that WIFEXITED is a C macro that was translated to a D function in druntime, which requires linking with druntime to use. Now that it's a template, it will be lazily instantiated and the program compiles.

The new lazyCache function provides a lazily evaluated range caching mechanism. Unlike cache, which eagerly evaluates range elements during construction, lazyCache defers evaluation until elements are explicitly requested.

auto result = iota(-4, 5).map!(a => tuple(a, expensiveComputation(a)))().lazyCache();
// No computations performed at this point

auto firstElement = result.front;
// First element is now evaluated

See the std.algorithm.iteration.lazyCache documentation for more details.

These functions are variants of the existing text, wtext, and dtext functions. Instead of returning a string, they write their output to an output range.

Like text, writeText can accept an interpolated expression sequence as an argument.

Example:

import std.conv : writeText;
import std.array : appender;

auto output = appender!string();
output.writeText(i"2 + 2 == $(2 + 2)");
assert(output.data == "2 + 2 == 4");

dub was passing -I instead of -P-I as is required by those compilers

In case the root package directory doesn't contain a dub.selections.json file, dub now looks in parent directories too and potentially uses the first (deepest) one it finds - if and only if that JSON file contains an optional new "inheritable": true flag.

This allows using a 'central' dub.selections.json file for a repository containing multiple dub projects, making it automatically apply to all builds in that source tree if located in the repository root directory (unless a local dub.selections.json overrides it).

Such an inherited selections file is never mutated when running dub for a nested project, i.e., changes are always saved to a local dub.selections.json file. E.g., when running dub upgrade for a nested project.