Change Log: 2.095.0

If an aggregate declaration contains a private method and a public method in the same overload set it is possible to call the private method from a different module.

Example:

==============================
module foo;

struct Foo
{
  import std : writeln;

  private int _x;

  private ref int x() return
  {
    writeln("ref int");
    return _x;
  }

  int x() const
  {
    writeln("int");
    return _x;
  }
}
============================

---
module main;


void main()
{
  import std : writeln;
  import foo : Foo;


  auto f = Foo();
  f.x = 3;              // ok to call private method
  writeln(f);
}
===========================

A common issue when dealing with deprecations is to have it trigger in library code, for example having a deprecated alias this, or a hook (opApply, range primitives...) being called by a function deeply nested inside Phobos.

In such cases, finding out where the instantiation comes from can be quite tedious. From this release, if a deprecation is triggered inside a template, the compiler will show the template instantiation trace, just like it already does on error. The same limit apply (6 frames, recursive templates are compressed), and -v can be used to lift it.

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

• Enums are no longer emitted in macros and enum class is used when the C++ standard set from -extern-std= is c++11 or later.
• Forward referenced declarations are now properly indented.
• Default functions parameters are properly emitted
• Tuple members/parameters/variables are emitted as individual variables using the compiler internal names instead of causing an assertion failure.
• Interfaces are now emitted as base classes.
• Aggregate members will be emitted with proper protection levels
• Protected enums in aggregates are emitted again
• Private member methods are no longer emitted
• No auto-generated default constructor for unions
• No longer ignores declarations nested inside an extern block, e.g. extern(D) extern(C++) void foo() {}
• Opaque enums no longer cause segfaults & are properly exported for C++ 11
• C++11 constructs are avoided when compiling with -extern-std=c++98.
• Using typeof(null) type no longer causes an assertion failure.
• The base type of floating point literals is propagated into the header
• NaN, Infinity are emitted using NAN/INFINITY from math.h.
• Final classes are marked as final
• immutable is emitted as const instead of mutable
• Identifier chains in templates are printed completely
• Proper vtable layout is ensured by emitting hidden placeholders for virtual functions that are not extern(C|C++).
• Fixed missing const for class members/methods
• Templated class declarations are now emitted
• Manifest constants that are not extern(C|C++) are no longer emitted.

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

Previously, multiple definitions of identical functions within a module were not recognized, although they have the same mangling. This was problematic because a binary cannot contain multiple definitions of a symbol, which caused undefined behavior depending on the compiler backend.

DMD will now raise an error message if there are conflicting implementations within a single module:

void foo() {}
void foo() {} // error

Multiple declarations are still allowed as long as there is at most one definition:

void bar(int);
void bar(int) { }
void bar(int);

DMD will issue a deprecation for mangling schemes that don't support overloading (extern(C|Windows|System)):

extern(C):
void foo(int) { }
void foo(double) { } // deprecation

This deprecation will become an error in 2.105.

This unused linkage was deprecated in https://dlang.org/changelog/2.084.0.html#deprecated_extern_pascal and has now been removed.

The compiler now accepts c++20 as a supported standard for -extern-std=. Currently this only changes the value of __traits(getTargetInfo, "cppStd"), though new types may be added in the future.

The default setting for -extern-std= has been updated to c++11.

Declarations with extern(C++) linkage are no longer guaranteed to link with code compiled by a C++98 compiler. Additionally, C++ headers generated by -HC will use constructs only available from C++11 onwards.

If compatibility with older C++ compilers is required, you must now pass -extern-std=c++98 on the command-line.

As per Liskov, in contracts can only loosen the conditions placed on the method they appear on. Currently this is enforced by automatically "oring" together the in contract with the in contract on the parent method, creating a combined contract that is necessarily looser than the parent.

However, this leads to odd behavior like this code passing:

class A
{
    void foo(int i) in (i > 0) { }
}
class B : A
{
    void foo(int i) in (i < 0) { }
}
unittest { (new B).foo(5); }

That is because the in contract of B.foo is implicitly super.in() || i < 0, ie. i > 0 || i < 0

With -preview=inclusiveincontracts, this code will now fail with an AssertError. To reach the previous behavior, you would have to write out in (i > 0 || i < 0); that is, you explicitly include the parent's in contract in the child's.

It's now possible to declare [Objective-C protocols][objc_protocol]. In D, this is declared using the interface keyword.

To match the behavior of protocols in Objective-C, some additional changes have been made:

• It's possible to declare optional methods in an interface. This is done

• It's possible to have static methods in an interface. This method is

Example:

import core.attribute : optional, selector;
import std.stdio : writeln;

struct objc_selector;
alias SEL = objc_selector*;

extern (C) SEL sel_registerName(in char* str);

extern (Objective-C)
extern class NSObject
{
    static NSObject alloc() @selector("alloc");
    NSObject init() @selector("init");
}

extern (Objective-C)
interface Foo
{
    bool respondsToSelector(SEL sel) @selector("respondsToSelector:");
    void foo() @selector("foo");

    // this is an optional method
    @optional void bar() @selector("bar");
}

extern (Objective-C)
class Bar : NSObject, Foo
{
    override static Bar alloc() @selector("alloc");
    override Bar init() @selector("init");

    bool respondsToSelector(SEL sel) @selector("respondsToSelector:");

    void foo() @selector("foo")
    {
        writeln("foo");
    }
}

void main()
{
    Foo f = Bar.alloc.init;

    // check, at runtime, if the instance `f` implements the method `bar`
    if (f.respondsToSelector(sel_registerName("bar")))
        f.bar();
    else
        f.foo();
}

[objc_protocol][https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/WorkingwithProtocols/WorkingwithProtocols.html]

Previously only true or false literals were allowed (the spec stated that integers worked, but they did not).

Now the pragma can receive any compile-time expression convertible to bool, this expression will be evaluated only when the target function is actually used.

For example, in the following code all three functions should be inlined:

pragma(inline, canInline("func1"))
void func1() {}

void func2()
{
    pragma(inline, canInline(__traits(identifier, __traits(parent, {}))));
}

pragma(inline, canInline("func3") || true)
void func3() {}

int canInline(string fname)
{
    switch (fname)
    {
        case "func1":
        case "func2":
            return 1;
        default:
            return 0;
    }
}

void main()
{
    func1();
    func2();
    func3();
}

This new trait returns a tuple of strings representing the namespace(s) the symbol resides in. This enables determining what namespaces a given symbol resides in for use in reflection, and can be used directly with an extern(C++) declaration as demonstrated below.

extern(C++, "ns")
struct Foo {}
static assert(__traits(getCppNamespaces, Foo)[0] == "ns");
struct Bar {}
static assert(!__traits(getCppNamespaces, Foo).length);
extern(C++, __traits(getCppNamespaces, Foo)) struct Baz {}
static assert(__traits(getCppNamespaces, Foo) ==  __traits(getCppNamespaces, Baz));

These variables, which are in core.thread.osthread, were accidentally exposed. They shouldn't be accessed directly and have been made private. In order to set GC signals, one should call thread_setGCSignals instead.

By setting the flag doCount to Yes.doCount, the function returns a named tuple. The tuple contains the fields data and count. The field data is of type Target and it contains the result of the original function. The field count is of type size_t and it contains the number of characters consumed. The function is keeping its original behaviour otherwise. Example:

import std.typecons : Flag, Yes, No;

string s1 = "123";
auto a1 = parse!(int, string, Yes.doCount)(s1);
assert(a1.data == 123 && a1.count == 3);

The publicly available extern(C) bindings for getdelim and getline in std.stdio have been deprecated. Any code that still needs it can import the symbol from core.sys.posix.stdio in druntime instead.

JSONValue.get now allows to convert a stored uinteger or integer into any signed or unsigned integer. The conversion is performed with std.conv.to, and throws a ConvException in case of an integer overflow;

auto json = parseJSON(`{"a": 123}`);
writeln(json["a"].get!ubyte);

Before this release dub could only get an exact version for some commands (describe, generate, fetch, etc...). All commands now accept a version specification, such as can be found in dub.json / dub.sdl:

dub fetch 'foo@>0.2.0' dub describe foo@'>=0.3.0 <1.0.0'

Note that commands such as describe will still not fetch from the network.

By default, Dub uses all files it can find under its sourcePaths. However, a common pattern when dealing with multiple targets is to use configurations to represent said targets. In the case those targets are executables, users would be forced to add main files from other configurations to the excludedSourceFiles list, or store the main in a different directory outside of the sourcePaths.

To simplify this workflow, Dub will now exclude files listed in mainSourceFile for other configuration. In case this is not desirable, the files need to be manually added to the sourceFiles list.

If betterC is specified in the buildOptions, visuald project files will also be configured to use betterC.

For projects without a user-defined unittest configuration dub test generates a main file automatically. This main file is now being cached and won't be regenerated won subsequent runs without file changes.

For example:

{
    "name": "example",
    "dependencies": {
        "vibe-d": { "version" : "~>0.9.2", "dflags" : ["-preview=in"] }
    }
}

In this example, -preview=in will be applied to vibe-d and all of its dependencies. Any https://dub.pm/package-format-json.html#build-settings field will be parsed, however only dflags is taken into account when compiling for now.

DFLAGS and LFLAGS will no longer be exported as environment variables by default when invoking pre-generate, pre-build, pre-run, post-generate, post-build, or post-run commands.

If the previous behavior is still desired, they can be accessed using $DFLAGS and $LFLAGS in dub.json E.g.: preGenerateCommands : ["DFLAGS=$DFLAGS env | grep DFLAGS"]

will output DFLAGS environment variable with all the dflags used.

dub now respects the DC environment variable, meaning that DC=ldc2 dub build will behave as dub build --compiler=ldc2. In case both are supplied, the --compiler switch still has priority. Note that when DUB recursively invokes itself, for example in preGenerateCommands, it sets the DC variable to the compiler it is using, meaning that nested dub invocation will now use the same compiler.

Now dub is capable run test command in single mode like: dub test --single yoursinglefile.d

Enables co-existence and parallel compilation of the same project with different settings (e.g. cross compilation) by moving .dub/obj to $DUB_TARGET_PATH/obj.

For list command added optional filtration by name and version specification:

dub list foo dub list foo@'>=0.1.0 <1.0.0'

Basic authentication credentials defined in .netrc file will now be taken into account while connecting to secured repositories.