Change Log: 2.105.0

alias this declarations can now be written using the same alias new = old; syntax as other alias declarations.

struct S
{
    int n;
    alias this = n;
    // Equivalent to:
    //alias n this;
}

In 2.104, throwing qualified types was deprecated.

It is also unsafe to catch an exception as immutable, inout or shared. This is because the exception may still be accessible through another mutable or non-shared reference. Catching an exception with those qualifiers is now deprecated.

auto e = new Exception("first");
try {
        throw e;
} catch(immutable Exception ie) { // now an error
        e.msg = "second";
        assert(ie.msg == "first"); // would fail
}

enum on a function declaration had no effect other than being equivalent to the auto storage class when no return type was present. That syntax could be confused with enum manifest constants and is now an error:

enum void f1() { }  // error
enum f2() { }       // error

Instead, remove enum and use auto where necessary:

void f1() { }
auto f2() { }

Since 2.095.0, defining the same function multiple times in a module is not allowed, since it would result in symbol clashes at link time. Overloading a function with different parameter types is still allowed of course, and works because D mangles symbol names including parameter types. However, some external linkages (such as extern(C), extern(Windows)) don't do this, so overloading them can also result in symbol clashes at link time. Therefore, doing this was deprecated in that release as well.

This deprecation now turned into an error. As a corrective action, give the function D or C++ linkage, or use a unique function name.

// Error:
extern(C) float square(float x) { return x * x; }
extern(C) double square(double x) { return x * x; }

// Corrective action:
extern(C) float squaref(float x) { return x * x; }
extern(C) double squared(double x) { return x * x; }

// Or:
float square(float x) { return x * x; }
double square(double x) { return x * x; }

When a private method was overloaded with a public method that came after it, you could access the private overload as if it was public.

After a deprecation period starting with 2.094, this code is now an error.

Example:

struct Foo
{
    private void test(int) { }
    public void test(string) { }
}
...
Foo().test(3);

This is Apple's new operating system for their VR/AR device Vision Pro.

Previous to this version, an expression like (IdentifierOrBasicType)(Expression) would be considered a c-style cast, and disallowed, even if the IdentifierOrBasicType could be used as a callable. This is now allowed, as long as the expression is a call, or a construction.

struct S { int x; }
int foo(int x) { return x; }
auto bar = &foo;

// these were previously disallowed
auto s = (S)(5);   // equivalent to S(5)
auto f = (foo)(5); // equivalent to foo(5)
auto b = (bar)(5); // equivalent to bar(5)
auto i = (int)(5); // equivalent to int(5), not a cast.

// these are not allowed
auto bad = (int)5; // Error: C style cast illegal, use `cast(int)5`
auto bad2 = (ubyte)(12345); // Error: cannot implicitly convert expression `12345` of type `int` to `ubyte`

See Bugzilla 24025: Expressions contained in parentheses should not be assumed to be C casts

These headers give access to the Linux Input Subsystem userspace API, which is used to read input from e.g. keyboards, touch screens, and game controllers, or to emulate input devices. You can now import them through core.sys.linux:

import core.sys.linux.input; // linux/input.h
import core.sys.linux.input_event_codes; // linux/input-event-codes.h
import core.sys.linux.uinput; // linux/uinput.h

The garbage collector gained a compile-time option to enable integration with Valgrind's memcheck tool. When it is enabled, the GC will communicate with Valgrind and inform it which memory access operations are valid and which are not.

The integration allows catching memory errors in D programs which mix safe (GC) and unsafe (manual) memory management, for example:

import core.memory;

void main()
{
    auto arr = new int[3];
    GC.free(arr.ptr);
    arr[1] = 42; // use after free
}

To use it, obtain the DMD source code, then include the garbage collector and lifetime implementation into your program's compilation and compile with the -debug=VALGRIND option:

git clone -b v2.105.0 --depth=1 https://github.com/dlang/dmd
dmd -g -debug=VALGRIND program.d -Idmd/druntime/src dmd/druntime/src/{core/internal/gc/impl/conservative/gc,rt/lifetime,etc/valgrind/valgrind}.d
valgrind --tool=memcheck ./program

The option is compatible with other GC debugging build options, such as MEMSTOMP and SENTINEL.

Dub users can try the following equivalent recipe:

git clone -b v2.105.0 --depth=1 https://github.com/dlang/dmd
cat >> dub.sdl <<EOF
debugVersions "VALGRIND"
sourceFiles "dmd/druntime/src/core/internal/gc/impl/conservative/gc.d"
sourceFiles "dmd/druntime/src/rt/lifetime.d"
sourceFiles "dmd/druntime/src/etc/valgrind/valgrind.d"
importPaths "dmd/druntime/src"
EOF
dub build
valgrind --tool=memcheck ./program

Until now, permutations used a template constraint to check if the passed types could be used. If they were not, it was very tedious to figure out why.

As the template constraint is not used for overload resolution the constrains are moved into static asserts with expressive error messages.

A new enum representing the instruction set architecture for the targeted system was added. It is intended for cases where a targeted CPU's ISA is only needed at runtime, such as providing human-readable messages as demonstrated below.

import std.stdio;
import std.system;

void main()
{
    writeln("Hello ", instructionSetArchitecture, " world!");
}

You can now specify --d-versions=Xyz to basically insert version = Xyz; into all D source files. This is the same as specifying versions in your dub.sdl / dub.json file, but from the CLI and unrelated to any build types or configurations.