digitalmars.D - Primary Type Syntax =?UTF-8?B?4oCV?= The implementation is almost
- Quirin Schroll (56/56) Sep 20 The [DIP Development
The [DIP Development Thread](https://forum.dlang.org/post/oxdddajuvrnzxfxdycob forum.dlang.org). It’s coming to an end… I’m pretty happy with the DIP now and the [proof-of-concept implementation](https://github.com/Bolpat/dmd/tree/PrimaryTypeSyntax) is done. I used some workarounds to get linkage done, but all in all, almost every aspect of the DIP is implemented. You can experiment, or as Andrei has coined: **DESTROY!** If you’re intrigued, but rather new to D compiler development (as I was up until very recently) and you want to play around with it, but have no clue how, here’s what I do to test my implementation: 1. Install DMD. 2. Clone https://github.com/Bolpat/dmd/ 3. Checkout branch `PrimaryTypeSyntax` 4. In a shell, navigate to the `dmd/compiler/src` directory. 5. Compile the new compiler: `dmd -m64 -i dmd/main.d -of=../../dmd.exe -Jdmd/res -J../..` 6. Copy, hardlink, or move the executable (`..\..\dmd.exe` on Windows) to the DMD installation folder under the name `dmd-pts`: `copy /Y ..\..\dmd.exe C:\D\dmd2\windows\bin64\dmd-pts.exe > NUL` Assuming the DMD `bin64` folder is in your `PATH`, compile and run your tests using the newly compiled compiler, e.g.: `dmd-pts -run hello_primary_type_syntax.d` --- The only part that’s missing is semantically applying linkage in template lambdas that aren’t alias declarations. (Yes, it’s that specific; linkage for non-template lambdas works, and in alias declarations, linkage also always works.) For a concrete example of what fails: ```d template t(alias fun) { static assert(is(typeof(fun!int) : extern(C) int function(int))); // FIXME } alias _ = t!(function extern(C) (x) => x); // ~~~~~~~~~ // currently ignored :( ``` The reason is twofold: For `TypeFunction` it seems its `linkage` is generally ignored by the rest of the compiler and while I can barely manage to fumble around with the parser, I don’t see myself addressing this. It would make implementing linkage almost as easy as `ref`, which was pretty easy. Working around that, I used `LinkDeclaration`, which goes well for non-template lambdas as they end up having a type (one that’s not `void`), and it works very well for alias declarations because those can become a `LinkDeclaration`. Only template lambdas that aren’t the right-hand side of an alias are an issue. The parser requires those to be an `Expression`, any would do, but a `FuncExp` is the most reasonable one. The issue is, a `FuncExp` must either wrap a `FuncLiteralDeclaration` or a `TemplateDeclaration` with exactly one member which must be a `FuncLiteralDeclaration`. That’s not much leeway. And using a `DeclarationExp` does not work either, also using a `CommaExp` where I declare the thing and reference it doesn’t work. Maybe someone more experienced with the compiler has an idea…
Sep 20