DIP 50 - AST macros

[dennis luehring]

Am 14.11.2013 08:50, schrieb Jacob Carlborg:
> On 2013-11-14 02:56, deadalnix wrote:
>
>> I think the whole point of macro is to NOT add too much feature to the
>> language.
>>
>> See for instance the example I gave before to create generator. This can
>> be added with extra language support (C# async/await is an example). But
>> with macro, the feature can be implemented as a library.
>>
>> It is NOT achievable with expression templates.
>>
>> I can say with certainty that the async/await mechanism is heavily used
>> in some codebases and with great benefit. It is being added to all
>> languages one after another.
>>
>> The idea behind macros is that instead of adding new feature to the
>> language, the language should propose a toolkit to build these features
>> as library.
>
> Agree, good points.
>
>> I don't think the time has come for macros in D. As discussed before, it
>> seems like filling the gap in existing feature is more important than
>> adding new ones. This should however be considered very seriously when
>> the gaps has been filled.
>
> Unfortunately I don't think we will have a feature freeze from now until
> those gaps has been filled. Most likely there will be added a couple of
> small features that could have been solved by AST macros. The problem
> with that is that each of these features, in themselves, are way to
> small to add AST macros for. So instead we get new features and even
> less chance of adding AST macros.
>
> Example. There's a bug report about adding support for C++ namespaces.
> That should be solveable with library code. It's just mangling and we
> already have pragma(mangle).
>
> pragma(mangle, namespace("foo::bar")) extern(C++) void x ();
>
> The problem here is that "x" needs to be mangled as well.
>
> pragma(mangle, namespace("foo::bar", x)) extern(C++) void x ();
>
> The above doesn't work due to forward reference errors.
>
> pragma(mangle, namespace("foo::bar", void function (), "x")) extern(C++)
> void x ();
>
> The problem with the above is that we now need to repeat the signature
> and the name of the function.
>
> With AST macros:
>
> macro namespace (Context context, Ast!(string) name, Declaration
> declaration) { ... }
>
> @namespace("foo::bar") extern (C++) void x ();
>
> This works because the macro receives the whole declaration that is "x"
> and "x" is replaced with whatever the macro returns:
>
> pragma(mangle, "mangled_name_of_x") extern (C++) void x ();
>
> Since it uses the same syntax as UDA's you it can look like real
> namespaces in C++:
>
> @namespace("foo::bar") extern (C++)
> {
>       void x ();
>       void y ();
> }
>

perfect for the DIP example section - more of these please :)