Change Log: 2.084.0

Aliases can be created directly from the traits that return symbol(s) or tuples. This includes getMember, allMembers, derivedMembers, parent, getOverloads, getVirtualFunctions, getVirtualMethods, getUnitTests, getAttributes and finally getAliasThis. Previously an AliasSeq was necessary in order to alias their return. Now the grammar allows to write shorter declarations:

struct Foo
{
    static int a;
}

alias oldWay = AliasSeq!(__traits(getMember, Foo, "a"))[0];
alias newWay = __traits(getMember, Foo, "a");

To permit this it was more interesting to include __trait in the basic types rather than just changing the alias syntax. So additionally, wherever a type appears a __trait can be used, for example in a variable declaration:

struct Foo { static struct Bar {} }
const(__traits(getMember, Foo, "Bar")) fooBar;
static assert(is(typeof(fooBar) == const(Foo.Bar)));

Option("check=[assert|bounds|in|invariant|out|switch][=[on|off]]", `Overrides default, -boundscheck, -release and -unittest options to enable or disable specific checks.

• assert: assertion checking
• bounds: array bounds
• in: in contracts
• invariant: class/struct invariants
• out: out contracts
• switch: switch default

• on or not specified: specified check is enabled.
• off: specified check is disabled.

It covers action taken when an assert fails, a bounds check fails, or a final switch error happens. D means the usual D behavior of throwing an Error, C means call the C runtime library assert failure function, and halt means halt the program execution.

The halt is the main addition here, it enables very lightweight assert's.

Before this release -color wouldn't output colorized console output if the terminal detection failed. With this release, a new option auto is introduced for -color=<value> which will continue to be the default:

• auto: enable colorized output if a tty is detected (default)
• on: always use colored output.
• off: never use colored output.

Hence, it is now possible to use -color (a shortcut for -color=on) to force DMD to emit colorized console output. For example, this will now use colorized console output:

> echo $(echo "test" | dmd -color - 2>&1)
__stdin.d(2): Error: no identifier for declarator test

This is useful to debug errors in compilation and provides source for debuggers to show when requested.

Prior to this release, binary literals without any digits after the prefix 0b were considered valid. This has now been deprecated.

auto foo = 0b;   // deprecated
auto bar = 0b_;  // deprecated
auto baz = 0b0;  // conforming equivalent

This linkage is completely unused, being an heritage from a few decades ago. Additionally, it's only supported by DMD and cause mangling ambiguity.

// a.d
import std.stdio;

// b.d
import a;

void main()
{
    std.stdio.writefln("foo");         // deprecation before patch, now errors
}

In order to compile the example successfully, public needs to be added to the import located in a.d : public import std.stdio; or import std.stdio; needs to be added to b.d.

Before this version, anything including extern(C++) templates was not correctly mangled on OSX, Linux, and FreeBSD, leading to linker errors.

This allows code interfacing with C++ that uses wchar_t to link correctly. It replaces wchar (Windows) and dchar (Posix) as the memory type for the DRuntime alias wchar_t.

Added core.stdcpp.array, which links against C++ std::array

Add D header file core.sys.darwin.crt_externs for libc/crt_externs.h on Darwin.

object.destroy() now receives an initialize argument to specify whether to re-initialize the object after destruction.

Added core.stdcpp.string_view, which links against C++ std::string_view

std.random.unpredictableSeed now has an overloaded version std.random.unpredictableSeed!UIntType that can be used to produce seeds of any unsigned type UIntType.

import std.random : unpredictableSeed;

auto a = unpredictableSeed!uint;
static assert(is(typeof(a) == uint));

auto b = unpredictableSeed!ulong;
static assert(is(typeof(b) == ulong));

// The old syntax still works.
uint c = unpredictableSeed;

Additionally the implementation quality of unpredictableSeed has been improved, speeding it up and eliminating an obvious pattern in the high bit. (Bear in mind that unpredictableSeed is still not cryptographically secure.)

The add command adds a dependency to the dub.json/dub.sdl recipe file.

Running dub add vibe-d queries the latest version for vibe-d from the registry, then rewrites your recipe file with the new dependency added.

dub.json:

  "dependencies": {
      "vibe-d": "~>X.Y.Z"
  }

dub.sdl:

dependency "vibe-d" version="~>X.Y.Z"

It is also possible to add multiple packages at once and explicitly add a simple version specification for some of them.

For example the command dub add vibe-d='~>0.8.2' mir-algorithm=3.1.21 would add the given 2 dependencies to the recipe file without querying the registry.

Packages with and without version-specifier can be mixed in a single invocation.

The can also be used to overwrite existing dependencies of the same name with different version specifications.

With this release, one can call dub from build commands in the following way:

    // dub.sdl:
    preBuildCommands "$DUB run --single somebuildscript.d"

This is useful if dub is not in the $PATH, or if several versions of dub are installed.

$DUB is also accessible as environment variable in the build commands processes.

$DUB points to the running executable, unless it is used as a library. In such case, $DUB will resolve to the first dub executable found in $PATH.

DUB now supports commands preRunCommands which are executed before the target run and postRunCommands which are executed after the target run. Environment variable DUB_TARGET_EXIT_STATUS contains the target executable call status and is available in postRunCommands.

Dub single-file packages e.g. app.d can now be called without .d extension. In addition to dub app.d --param you can call dub app --param.

Also files without .d extension are supported now as single-file packages.

JSON files are now sorted before being written to dub.json. This is to prevent the order of the JSON properties from changing when dub.json is updated.

Using version identifiers to configure certain features can often lead to unnecessary rebuilds of dependencies that don't use those version identifiers. In order to improve the build cache efficiency, dub gained a new experimental --filter-versions switch.

When --filter-versions is passed to any build, test, or generate command, dub will grep for all the version identifiers packages actually use and only apply those during building. This allows for example to reuse a cached build for a library between two applications using different version identifiers when the library isn't using any of those itself.

The following regular expressions used to grep for version identifiers.

enum verRE = ctRegex!`(?:^|\s)version\s*\(\s*([^\s]*?)\s*\)`;
enum debVerRE = ctRegex!`(?:^|\s)debug\s*\(\s*([^\s]*?)\s*\)`;

For packages that use version identifiers in mixins or auto-generated sources, the list of applicable version identifiers can be specified explicitly in the package file.

dub.json:

"-versionFilters": ["Have_vibe_d"]
"-versionFilters-posix": ["UseUnixSockets", "UseMMap"]
"-debugVersionFilters": ["ValidateRequests"]

dub.sdl:

x:versionFilters "Have_vibe_d"
x:versionFilters "UseUnixSockets" "UseMMap" platform="posix"
x:debugVersionFilters "ValidateRequests"

Note that the inferred version identifiers are cached and grepping is generally very fast, so explicitly specifying version identifiers should only be used if necessary.

Also note that specifying either of versionFilters or debugVersionFilters will disable inference for both of them.

The reservered version identifier none can be used for packages that don't use any version identifiers or debug version identifiers at all.

dub.json:

"-versionFilters": ["none"]

dub.sdl:

x:debugVersionFilters "none"