Change Log: 2.102.0

They work just like the bit fields in ImportC do.

https://github.com/dlang/dlang.org/pull/3190

struct B
{
    int x:3, y:2;
}

static assert(B.sizeof == 4);

int vaporator(B b)
{
    b.x = 4;
    b.y = 2;
    return b.x + b.y; // returns 6
}

To complement __traits(classInstanceSize), providing the required alignment for manual buffers etc.:

align(__traits(classInstanceAlignment, C))
void[__traits(classInstanceSize, C)] buffer;

extern(C) isn't a requirement for CRT con/destructors anymore when using the default void () signature.

It allows code to distinguish whether it's being compiled with optimizations enabled (the -O flag was provided). This is orthogonal to whether -release mode is active - for that see the predefined versions assert, D_NoBoundsChecks, D_Invariants, etc.

Up until now, the compiler accepted in and out contracts of nothrow functions to throw exceptions and call throwing functions. As this breaks nothrow guarantees, a deprecation notice is now triggered.

// deprecated:
float sqrt(float n) nothrow
in
{
    if (n < 0)
        throw new Exception("n must be positive");
}
do
{
    // ...
}

// fix: remove nothrow attribute or use assertions
float sqrt(float n) nothrow
in
{
    assert(n >= 0);
}
do
{
    // ...
}

The problem is that it only provides a single number namespace without any meaning. It's better to use version identifiers describing the feature they enable. See also this thread on the forum.

// now deprecated:
version = 3;
version (2) { }

debug = 4;
debug (5) { }

// use identifiers instead:
version = HasX;

version (HasX)
    void x() { /* ... */ }
else
    void x() {}

The scope attribute has existed for a long time, but the compiler would only verify its semantics when the -preview=dip1000 switch was passed, to avoid breaking code. Pointers or references stored in a scope variable are not allowed to escape the scope in which the variable is defined.

Usually, it is not necessary to mark variables scope, since the Garbage Collector (GC) takes care of freeing memory. However, D allows creating pointers / slices that point to local variables, which use Stack-based memory allocation and are destructed at the end of their scope. It is important that in @safe code, creating such pointers is either disallowed, or has scope semantics enforced, but the compiler would formerly fail to do that:

@safe:
int[] getSlice()
{
    int[4] stackBuffer;
    int[] slice = stackBuffer[]; // slice points to local variable allocated on stack
    return slice; // dangling pointer!
}

struct S
{
    int x;

    int* get()
    {
        int* y = &this.x; // this struct instance could be a local variable
        return y; // dangerous!
    }
}

Starting with this release, scope semantics are enforced in @safe code on pointers to stack memory, but only as deprecation warnings. Eventually, they will be turned into errors. To turn them into errors immediately, use -preview=dip1000. To disable the deprecations, use -revert=dip1000.

Note that the original DIP1000 text is outdated, so please refer to the specification pages for documentation:

• Scope and Return Parameters
• scope Attribute
• Scope Parameters
• Return Scope Parameters
• Ref Return Scope Parameters
• Inferred scope parameters in pure functions

The following features/bugfixes/improvements were implemented for the experimental C++ header generator:

• Overriding virtual functions are now marked with the override keyword when generating C++11 compatible headers.
• Final virtual functions are now marked with the final keyword when generating C++11 compatible headers.

Note: The header generator is still considered experimental, so please submit any bugs encountered to the bug tracker.

The compiler allows implicitly converting a return value with indirections to immutable if it determines the result must be unique. Formerly, this check would inspect the types of the indirections, and forget to take into account conversions, such as int[] to void[]:

int[] f(ref void[] m) pure
{
    auto result = new int[5];
    m = result;
    return result;
}

void main()
{
    void[] v;
    immutable x = f(v);
    // `v` is now a mutable alias to immutable variable `x`
}

This was filed as issue 15660, which has been fixed some time ago by making the check more strict: the called function must be strongly pure. However, to avoid breaking code, the fix was only active with the -preview=dip1000 switch. Since it is unrelated to dip1000 (which is about scope pointers), the fix has been moved to a new -preview=fixImmmutableConv switch.

An expression statement of type void that has no side effects should be discarded since it has no effect. The compiler, generally, does not allow such statements, however, in the case of return statements this error is circumvented. For example:

struct StackBuffer
{
    auto opIndex(size_t i)
    {
        return arr[i];
    }

private:
    void[] arr;
}

Although this code compiles, any call to opIndex is going to result in an error because the return type must either be stored somewhere (and variables cannot be of type void) or the call will have no effect.

Starting with this release, returning a discarded void value from a function is deprecated. Such code can be deleted as it most certainly is dead code.

ISO C does not specify a typeof operator, but it is a widely-implemented vendor extension. ImportC now implements this extension as well.

Only the form typeof(...) is recognized, other compilers also support (or only support one of) __typeof__(...) and __typeof(...). Imported C using these forms will need to be normalized with #defines.

This release removes the -transition=markdown, which prints markdown substitutions made when processing markdown in ddoc documentation blocks, and -revert=markdown switches which disables markdown substitutions in ddoc documentation blocks.

Markdown substitutions have been the default for some time now, and as of this release is always performed.

This allows two associative array references to point to the same associative array instance before any keys have been inserted.

int[string] a = new int[string];
auto b = a;
...
a["seven"] = 7;
assert(b["seven"] == 7);

Note: Calling new is not needed before inserting keys on a null associative array reference - the instance will be allocated if it doesn't exist.

The intent of -preview=in is to make in the go-to storage class for input parameters in D. However, it is D centric, as it is an enhanced version of scope const ref. As non-extern(D) functions usually are expected to match a specific ABI, using in is hardly a good idea.

As C++ also has a "go to" storage class for input parameters (const T&), in can also be applied on extern(C++) function in order to bind to const T& parameters. This also allows to expose a closer API for a function than via const ref, as in will allow to bind rvalues to const T&, as in C++.

DIP 1043---Shortened Method Syntax has been accepted, the flag -preview=shortenedMethods is no longer required to write shortened function bodies:

int add(int x, int y) pure => x + y;

// equivalent full function body:
int add(int x, int y) pure
{
    return x + y;
}

The preview flag will still work until it is deprecated in a future release.

Trojan Source: Invisible Vulnerabilities shows how they can be used to maliciously hide code in various programming languages. D is also affected.

To prevent this, the compiler now raises an error when they appear in source files. If you need a string literal containing directionality overrides, use escape sequences instead:

string s = "\u202E\u2066";

The compilation of some projects require more stack space than previously available. Now DMD has the same limit as LDC, which increased its stack limit in its 1.29.0 release.

The feature flag core.cpuid.avx512f has been added to allow detection at run-time CPUs with 512-bit vector support.

The option was introduced in 2.072.2 to help transition code that relied on the old faulty cycle checker for module constructors. It now prints a warning and does the same as the default, --DRT-oncycle=abort. See also: Order of Static Construction in the specification.

As the SIGUSR ones might be used by 'system' libraries (e.g., Android Dalvik VM or LLVM libFuzzer), while the SIGRT ones are reserved for user-defined purposes and less likely to collide.

The used signals can still be customized with an early call to core.thread.osthread.thread_setGCSignals().

RefCounted is only available for @system code, because of the possibility of escaping a reference to its payload past the end of its lifetime. a modified copy of it, std.typecons.SafeRefCounted has been added. Also added is a borrow function, that lets one safely access and modify the payload. -preview=dip1000 prevents escaping a reference to it in @safe code.

@safe pure nothrow void fun()
{
    import std.typecons;

    auto rcInt = safeRefCounted(5);
    assert(rcInt.borrow!(theInt => theInt) == 5);
    auto sameInt = rcInt;
    assert(sameInt.borrow!"a" == 5);

    // using `ref` in the function
    auto arr = [0, 1, 2, 3, 4, 5, 6];
    sameInt.borrow!(ref (x) => arr[x]) = 10;
    assert(arr == [0, 1, 2, 3, 4, 10, 6]);

    // modifying the payload via an alias
    sameInt.borrow!"a*=2";
    assert(rcInt.borrow!"a" == 10);
}

Direct access to the payload unfortunately has to be @system, though. While -dip1000 could prevent escaping the reference, it is possible to destroy the last reference before the end of it's scope:

int destroyFirstAndUseLater()
{
    import std.typecons;

    auto rc = SafeRefCounted!int(123);
    int* ptr = &rc.refCountedPayload();
    destroy(rc);
    return *ptr; // Reads from freed memory. Don't do this.
}

As a side effect, this enabled us to make std.file.dirEntries @safe with -preview=dip1000.

Some member functions of RefCounted that are @safe are not so in SafeRefCounted. The RefCounted type and refCounted function are still available for the old behaviour. However, their main purpose is backwards compatibility. They are not recommended for new code.

The std.experimental.logger package is now std.logger. The old package and modules are still available and publicly import the new ones. To avoid breakage in modules that compile with deprecations as errors, for now the old modules aren't deprecated, but they will be.

Before this change std.experimental.logger had the capability to disable logging at compile time. It was also possible to set the minimal LogLevel at compile time. The trade-off between gained capability, added complexity, and error-proneness was too heavily tilted towards the second two items. This change removes these compile time features.

To make unsafe code more explicit std.experimental.logger.sharedLog now returns a shared(Logger) instead of a Logger.

This was an attempt to update std.typecons.wrap with an implementation that could work with struct, but it did not go anywhere. See this post on the forum.

This module was initially deprecated in 2.076.1, and has been empty since 2.092.0 when all deprecated symbols were removed in favour of importing std.digest or its submodules instead.

This module is considered out-dated and not up to Phobos' current standards. If you still need it, go to https://github.com/DigitalMars/undeaD

To comply with dip1000, std.socket.Socket methods now all have scope attributes applied to any slice parameters. This includes receive and send flavors, and also setOption. While not technically a breaking change for users of Socket, if you derive from it, you must apply those attributes to your derivatives or it will fail to compile. However, applying the attributes is backwards compatible with previous versions of Phobos, so there is no need for a migration path.

Extend the fill, alignSize, align{2,4} methods of std.outbuffer.OutBuffer to specify value to write when filling (up to an alignment).

For flash device images it is desirable to use 0xff as the fill value, because 0xff is the value of the unprogrammed flash memory cell. Padding with 0 requires to programm the flash cell from 0xff to 0x00, which increases wear and tear on the flash memory device. Usually there is some larger block at the end if the flash memory image, which must be padded up to the size of the flash device (usually a power of two). Instead of padding with 0x00 the PR allows to fill with 0xff instead.

There might be also some other use-cases, where it might be reasonable to fill the alignment gaps with some other value than 0x00, e.g. when debugging and viewing output data in a hex editor. It is easier to spot gaps, when the padded spaces contain a custom value like 0x55 or 0xaa.

A new fill method was added, which allows filling with a user-defined value instead of the 0 as in the previous implementation.

OutBuffer buf = new OutBuffer();
buff.fill( 1234, 42 ); // Fills 1234 bytes with 42 starting at buf.offset
buff.fill( 10 );       // Same as fill0( 10 );

The alignSize, align{2,4} methods were modified to use some user-defined value for padding to the requested alignment boundary.

OutBuffer buf = new OutBuffer();
buf.write(cast(ubyte) 1);
buf.align2(0x55);
assert(buf.toBytes() == "\x01\x55");
buf.write(cast(ubyte) 2);
buf.align4(0x55);
assert(buf.toBytes() == "\x01\x55\x02\x55");
buf.write(cast(ubyte) 3);
buf.alignSize(8, 0x55);
assert(buf.toBytes() == "\x01\x55\x02\x55\x03\x55\x55\x55");