{"id":1611,"date":"2018-07-04T14:51:33","date_gmt":"2018-07-04T14:51:33","guid":{"rendered":"http:\/\/dlang.org\/blog\/?p=1611"},"modified":"2021-10-08T11:01:45","modified_gmt":"2021-10-08T11:01:45","slug":"dmd-2-081-0-released","status":"publish","type":"post","link":"https:\/\/dlang.org\/blog\/2018\/07\/04\/dmd-2-081-0-released\/","title":{"rendered":"DMD 2.081.0 Released"},"content":{"rendered":"

DMD 2.081.0 is now ready for download<\/a>. Things that stand out in this release are a few deprecations, the implementation of a recently approved DIP (D Improvement Proposal), and quite a bit of work on C++ compatibility. Be sure to check the changelog for details<\/a>.<\/p>\n

\"\"<\/p>\n

Improving C++ interoperability<\/h2>\n

D has had binary compatibility with C from the beginning not only because it made sense, but also because it was relatively easy to implement. C++ is a different beast. Its larger-than-C feature set and the differences between it and D introduce complexities that make implementing binary compatibility across all supported platforms a challenge to get right. Because of this, D\u2019s extern(C++)<\/code> feature has been considered a work in progress since its initial inception.<\/p>\n

DMD 2.081.0 brings several improvements<\/a> to the D <-> C++ story, mostly in the form of name mangling bug fixes and improvements. The mangling of constructors and destructors in extern(C++)<\/code> now properly match the C++ side, as does that of most of D\u2019s operator overloads (where they are semantically equivalent to C++).<\/p>\n

Proper mangling of nullptr_t<\/code> is implemented now as well. On the D side, use typeof(null)<\/code>:<\/p>\n

alias nullptr_t = typeof(null);\r\nextern(C++) void fun(nullptr_t);<\/pre>\n
The alias in the example is not required, but may help with usability and readability when interfacing with C++. As typing null<\/code> everywhere is likely reflexive for most D programmers, nullptr_t<\/code> may be easier to keep in mind than typeof(null)<\/code> for those special C++ cases.<\/p>\n
Most of the D operator overloads in an extern(C++)<\/code> class will now correctly mangle. This means it\u2019s now possible to bind to operator overloads in C++ classes using the standard D opBinary<\/code>, opUnary<\/code>, etc. The exceptions are opCmp<\/code>, which has no compatible C++ implementation, and the C++ operator!<\/code>, which has no compatible D implementation.<\/p>\n
In addition to name mangling improvements, a nasty bug where extern(C++)<\/code> destructors were being placed incorrectly in the C++ virtual table has been fixed, and extern(C++)<\/code> constructors and destructors now semantically match C++. This means mixed-language class hierarchies are now possible and you can now pass extern(C++)<\/code> classes to object.destroy<\/code> when you\u2019re done with them.<\/p>\n
Indirectly related,\u00a0\u00a0__traits(getLinkage, ...)<\/code>\u00a0has been updated to now tell you the ABI with which a struct<\/code>, class<\/code>, or interface<\/code> has been declared, so you can now filter out your extern(C++)<\/code> aggregates from those which are\u00a0extern(D)<\/code> and extern(Objective-C)<\/code>.<\/p>\n
The following shows some of the new features in action. First, the C++ class:<\/p>\n
#include <iostream>\r\nclass CClass {\r\nprivate:\r\n    int _val;\r\npublic:\r\n    CClass(int v) : _val(v) {}\r\n    virtual ~CClass() { std::cout << \"Goodbye #\" << _val << std::endl; }\r\n    virtual int getVal() { return _val; }\r\n    CClass* operator+(CClass const * const rhs);\r\n};\r\n\r\nCClass* CClass::operator+(CClass const * const rhs) {\r\n    return new CClass(_val + rhs->_val);\r\n}<\/pre>\n
And now the D side:<\/p>\n
extern(C++) class CClass\r\n{\r\n    private int _val;\r\n    this(int);\r\n    ~this();\r\n    int getVal();\r\n    CClass opBinary(string op : \"+\")(const CClass foo);\r\n}\r\n\r\nclass DClass : CClass\r\n{\r\n    this(int v)\r\n    {\r\n        super(v);\r\n    }\r\n    ~this() {}\r\n    override extern(C++) int getVal() { return super.getVal() + 10; }\r\n}\r\n\r\nvoid main()\r\n{\r\n    import std.stdio : writeln;\r\n\r\n    writeln(\"CClass linkage: \", __traits(getLinkage, CClass));\r\n    writeln(\"DClass linkage: \", __traits(getLinkage, DClass));\r\n\r\n    DClass clazz1 = new DClass(5);\r\n    scope(exit) destroy(clazz1);\r\n    writeln(\"clazz1._val: \", clazz1.getVal());\r\n\r\n    DClass clazz2 = new DClass(6);\r\n    scope(exit) destroy(clazz2);\r\n    writeln(\"clazz2._val: \", clazz2.getVal());\r\n\r\n    CClass clazz3 = clazz1 + clazz2;\r\n    scope(exit) destroy(clazz3);\r\n    writeln(\"clazz3._val: \", clazz3.getVal);\r\n}<\/pre>\n
Compile the C++ class to an object file with your C++ compiler, then pass the object file to DMD on the command line with the D source module and Bob\u2019s your uncle (just make sure on Windows to pass -m64<\/code> or -m32mscoff<\/code> to dmd<\/code> if you compile the C++ file with the 64-bit or 32-bit Microsoft Build Tools, respectively).<\/p>\n
This is still a work in progress and users diving into the deep end with C++ and D are bound to hit shallow spots more frequently than they would like, but this release marks a major leap forward in C++ interoperability.<\/p>\n
DIP 1009<\/h2>\n
Given the amount of time DIP 1009 spent<\/a> crawling through the DIP review process, it was a big relief for all involved when it was finally approved. The DIP proposed a new syntax for contracts in D. For the uninitiated, the old syntax looked like this:<\/p>\n
int fun(ref int a, int b)\r\nin\r\n{\r\n    \/\/ Preconditions\r\n    assert(a > 0);\r\n    assert(b >= 0, \"b cannot be negative\");\r\n}\r\nout(result) \/\/ (result) is optional if you don't need to test it\r\n{\r\n    \/\/ Postconditions\r\n    assert(result > 0, \"returned result must be positive\");\r\n    assert(a != 0);\r\n}\r\ndo\r\n{\r\n \t\/\/ The function body\r\n    a += b;\r\n    return b * 100;\r\n}<\/pre>\n
Thanks to DIP 1009, starting in DMD 2.081.0 you can do all of that more concisely with the new expression-based contract syntax<\/a>:<\/p>\n
int fun(ref int a, int b)\r\n    in(a > 0)\r\n    in(b >= 0, \"b cannot be negative\")\r\n    out(result; result > 0, \"returned result must be positive\")\r\n    out(; a != 0)\r\n{\r\n    a += b;\r\n    return b * 100;\r\n}<\/pre>\n
Note that result<\/code> is optional in both the old and new out<\/code> contract syntaxes and can be given any name. Also note that the old syntax will continue to work.<\/p>\n
Deprecations<\/h2>\n
There\u2019s not much information to add here beyond what\u2019s already in the changelog<\/a>, but these are cases that users should be aware of:<\/p>\n