Change Log: 2.086.0

With this release DMD will issue an error when a symbol that is privately imported in the scope of an aggregate declaration is used as a member of the aggregate outside of the module where the aggregate is defined. Example:

// a.d
class Foobar
{
    int a;
    this(int a)
    {
        this.a = a;
    }
    static int smeth()
    {
        return 1;
    }
}
void fun() {}

// b.d
struct AST
{
    import a;
}

// c.d
void main()
{
    import b;
    AST.Foobar t;        // triggered a deprecation, but will now trigger an error
    AST.Foobar.smeth();  // error
    AST.fun();           // error
}

Before this patch, if a struct had an aliased this member that defined an opEquals method, the aliased this opEquals would have been preferred instead of the struct one:

struct A
{
    int a, b;
    bool opEquals(ref A rhs) const
    {
        return a == rhs.a && b == rhs.b;
    }
}

struct B
{
    int n;
    A a;
    alias a this;
}

void main()
{
    B a, b;
    assert(a == b);    // rewritten to a.a.opEquals(b.a)
}

Although the compiler generates an opEquals for struct B that does member-wise equality comparison (==), the aliased this one is wrongfully preferred.

This patch corrects this issue by always choosing the defined opEquals (even if it is generated by the compiler) instead of the alias this one. If the behavior prior to this patch is desired, an explicit opEquals needs to be provided.

References: [1] https://issues.dlang.org/show_bug.cgi?id=16657 [2] https://github.com/dlang/dmd/pull/9289 [3] https://github.com/dlang/dlang.org/pull/2593

With this release, the D language compiler implements the full functionality of the copy constructor described extensively in this DIP [1].

Copy constructors are used to initialize a struct instance from another struct of the same type.

A constructor declaration is a copy constructor declaration if and only if it is a constructor declaration that takes only one non-default parameter by reference that is of the same type as typeof(this), followed by any number of default parameters:

struct A
{
    this(ref return scope A rhs) {}                        // copy constructor
    this(ref return scope const A rhs, int b = 7) {}       // copy constructor with default parameter
}

The copy constructor is type checked as a normal constructor.

If a copy constructor is defined, implicit calls to it will be inserted in the following situations:

1. When a variable is explicitly initialized:

struct A
{
    this(ref return scope A rhs) {}
}

void main()
{
    A a;
    A b = a; // copy constructor gets called
}

2. When a parameter is passed by value to a function:

struct A
{
    this(ref return scope A another) {}
}

void fun(A a) {}

void main()
{
    A a;
    fun(a);    // copy constructor gets called
}

3. When a parameter is returned by value from a function and Named Returned Value Optiomization (NRVO) cannot be performed:

struct A
{
    this(ref return scope A another) {}
}

A fun()
{
    A a;
    return a;       // NRVO, no copy constructor call
}

A a;
A gun()
{
    return a;       // cannot perform NRVO, rewrite to: return (A __tmp; __tmp.copyCtor(a));
}

void main()
{
    A a = fun();
    A b = gun();
}

When a copy constructor is defined for a struct, all implicit blitting is disabled for that struct:

struct A
{
    int[] a;
    this(ref return scope A rhs) {}
}

void fun(immutable A) {}

void main()
{
    immutable A a;
    fun(a);          // error: copy constructor cannot be called with types (immutable) immutable
}

The copy constructor can be overloaded with different qualifiers applied to the parameter (copying from a qualified source) or to the copy constructor itself (copying to a qualified destination):

struct A
{
    this(ref return scope A another) {}                        // 1 - mutable source, mutable destination
    this(ref return scope immutable A another) {}              // 2 - immutable source, mutable destination
    this(ref return scope A another) immutable {}              // 3 - mutable source, immutable destination
    this(ref return scope immutable A another) immutable {}    // 4 - immutable source, immutable destination
}

void main()
{
    A a;
    immutable A ia;

    A a2 = a;      // calls 1
    A a3 = ia;     // calls 2
    immutable A a4 = a;     // calls 3
    immutable A a5 = ia;    // calls 4
}

The inout qualifier may be applied to the copy constructor parameter in order to specify that mutable, const, or immutable types are treated the same:

struct A
{
    this(ref return scope inout A rhs) immutable {}
}

void main()
{
    A r1;
    const(A) r2;
    immutable(A) r3;

    // All call the same copy constructor because `inout` acts like a wildcard
    immutable(A) a = r1;
    immutable(A) b = r2;
    immutable(A) c = r3;
}

A copy constructor is generated implicitly by the compiler for a struct S if all of the following conditions are met:

1. S does not explicitly declare any copy constructors;
2. S defines at least one direct member that has a copy constructor, and that member is not overlapped (by means of union) with any other member.

If the restrictions above are met, the following copy constructor is generated:

this(ref return scope inout(S) src) inout
{
    foreach (i, ref inout field; src.tupleof)
        this.tupleof[i] = field;
}

If the generated copy constructor fails to type check, it will receive the @disable attribute.

f an union S has fields that define a copy constructor, whenever an object of type S is initialized by copy, an error will be issued. The same rule applies to overlapped fields (anonymous unions).

A struct that defines a copy constructor is not a POD.

[1] https://github.com/dlang/DIPs/blob/master/DIPs/accepted/DIP1018.md

HexString literals are obsolete.

Prior to this release, usage of hex string literals would emit a deprecation warning. Starting with this release they will emit an error.

Use std.conv.hexString instead.

With this release DMD will issue an error when a symbol that is privately and selectively imported in module A is accessed in module B that imports module A non-selectively. Example:

// a.d
import fun : foo;

// b.d
import a;

void main()
{
    foo();     // deprecation up until now; error from now on
}

To make the above code compile, the import in a.d needs to be made public.

Prior to this release, there was no way to declare a function that would return a reference by using an anonymous function.
(It was possible to return a pointer but it's not worth mentioning.)

Here this function returns by value:

alias fn = () => a += 2;

In order to return by reference, we needed to define a named function to assign from:

ref int func()        // a static or non-nested function to mimic a `function` literal
{                     // or a non-static nested function to mimic a `delegate` literal
    return a += 2;
}
alias fn = func;

Now it's possible to use the ref keyword to indicate a return by reference:

function ref () { return x; }    // `=>` shorthand is there too
delegate ref () { return x; }
ref () { return x; }

For example:

int x = 1;
alias add2 = ref () => x += 2;
add2() += 7;    // add2 as a lvalue
assert(x == 10);

It enables the garbage collector for the compiler, trading compile times for (in some cases, significantly) less memory requirements.

E.g., compiling DMD's test tool d_do_test (dmd -c [-lowmem] test/tools/d_do_test.d) requires about 75% less memory (~1,630 MB -> 410) at the cost of a runtime increase by ~30% (~4.8 secs -> 6.3).

The following traits can now access non-public members:

• getMember
• getOverloads

This fixes a long-standing issue in D where the allMembers trait would correctly return non-public members but those non-public members would be inaccessible to other traits.

See BugZilla issue 15371

This module provides a cross-platform interface for lightweight signaling of other threads. It can be used to start execution of multiple waiting threads simultaneously.

Previously the algorithm was allocating the amount of memory which was equal to the size of the biggest range, that is Ο(max(s.length, t.length)). This is now fixed to be Ο(min(s.length, t.length)). For more details see std.algorithm.comparison.levenshteinDistance.

std.experimental.all allowed the convenient use of all Phobos modules with one import (import std.experimental.all;). With this release, this convenience module has been stabilized and moved to std. From now on, the convenience module can be accessed with import std;:

import std;
void main()
{
    5f.iota.map!exp2.sum; // 31
}

Scripts and experimental code often use long and frequently changing lists of imports from the standard library.

With this release it is possible to use import std; for importing the entire standard library at once. This can be used for fast prototyping or REPLs:

import std;
void main()
{
    6.iota
      .filter!(a => a % 2) // 1 3 5
      .map!(a => a * 2) // 2 6 10
      .tee!writeln // peek into the processed stream
      .substitute(6, -6) // 2 -6 10
      .mean // (2 - 6 + 10) / 3
      .reverseArgs!writefln("Sum: %.2f"); // 2
}

As before, symbol conflicts will only arise if a symbol with collisions is used. In this case, static imports or renamed imports can be used to uniquely select a specific symbol.

The baseline cost for import std; is less than half a second (varying from system to system) and work is in progress to reduce this overhead even further.

The bundled LLD Linker on Windows binaries has been upgraded to 8.0.0.

Command dub init now supports custom dub packages for argument -t.

> dub init -n myPackage --format sdl -t custom-dub-init-dubpackage -- --foo=bar

Dub init will be invoked like before. The package custom-dub-init-dubpackage contains a sub package init-exec which will be invoked afterwards to create a custom package skeleton. Additional arguments could be passed e.g. -- --foo=bar.

DMD's OPTLINK has many limitations. Apart from long-standing issues in the underlying DigitalMars runtime, the maximum number of symbols is limited as well, which is why most big DUB libraries can't be compiled with OPTLINK for years. This has been a cause of grief and pain for many users and impacted the newcomer experience severly.

With this release, dub will no longer use OPTLINK as default on Windows, but use -m32mscoff (MSCOFF) on 32-bit Windows systems and -m64 (MSCOFF) on 64-bit Windows.

Users can still manually instruct dub to use OPTLINK with the --arch=x86 switch of dub:

> dub --arch=x86

Starting with this release, dub run <mypackage> makes sure that the package is available locally. This means that now a dub fetch <mypackage> is no longer required and all a user of a library needs to run your dub package is dub run:

> dub run gitcompatibledubpackage
gitcompatibledubpackage wasn't found locally, but it's available online:
‐--
Description: Example of a DUB package also usable as git submodule. For DUB test suite.
Version: 1.0.4
‐--
Do you want to fetch gitcompatibledubpackage? [Y/n]:

An optional --yes (-y) flag is provided to confirm fetching non-interactively:

> dub run --yes gitcompatibledubpackage
gitcompatibledubpackage wasn't found locally, but it's available online:
‐--
Description: Example of a DUB package also usable as git submodule. For DUB test suite.
Version: 1.0.4
‐--
Fetching gitcompatibledubpackage 1.0.4...
Building package gitcompatibledubpackage in /home/seb/.dub/packages/gitcompatibledubpackage-1.0.4/gitcompatibledubpackage/
Performing "debug" build using dmd for x86_64.
gitcompatibledubpackage 1.0.4: building configuration "exe"...
Linking...
Running ../../.dub/packages/gitcompatibledubpackage-1.0.4/gitcompatibledubpackage/gitcompatibledubpackage
Hello DUB

An optional --non-interactive (-n) flag is provided to skip searching online packages:

> dub run --non-interactive gitcompatibledubpackage
Failed to find a package named 'gitcompatibledubpackage'.

If one wants to run a specific version of a package, it can be passed to dub run too:

> dub run [email protected]
Fetching gitcompatibledubpackage 1.0.3...
Building package gitcompatibledubpackage in /home/seb/.dub/packages/gitcompatibledubpackage-1.0.3/gitcompatibledubpackage/
Performing "debug" build using dmd for x86_64.
gitcompatibledubpackage 1.0.3: building configuration "exe"...
Linking...
Running ../../.dub/packages/gitcompatibledubpackage-1.0.3/gitcompatibledubpackage/gitcompatibledubpackage
Hello DUB

dub list-installed command was deprecated and renamed to list at in 2013.

dub now uses single API request to upgrade/resolve dependencies. For more details, see pull #1366.