Is it possible to work with AST inside D code?

Question

I'm not talking about dynamic programming. My wish is to work in compile time with constructions like:

obj.where(x => x.some_val >= 14); // <-- LINQ-style :D

To have a possibility to work directly with AST of single-expression function-argument:

(>=)
  |--(14)
  +--(.)
      |--(x)
      +--(some_val)

Now I've got only the idea to use some special class for x-objects with all operators (like +/-/*/./...) strongly overridden in some crazy dirty way to collect the information about anonymous function AST structure (if and only if this class is the only class to use in this single-expression function).

Like tiny AST for single r-value.

Is it technically possible somehow?

Answer 1

If you want to generate code at compile time, then you can use strings with string mixins. e.g.

string foo(string name, int value)
{
    return format("auto %s = %s;", name, value);
}

void bar()
{
    mixin(foo("i", 42));
    assert(i == 42);
}

That's not a particular interesting example, but as long as you can manipulate strings into the code you want, then you can mix them in, which allows for all kinds of code generation possibilities (both useful and abusive).

However, there is no way to actually manipulate the AST in D. As mentioned in Richard's answer as well as the comments, Walter is strongly against adding such capabilities to the language. So, it's highly unlikely that D will ever have them. But given how much you can do with string mixins, a lot of what someone might want to do with AST macros can be done with string mixins. They allow you to generate pretty much any code that you might want to. They just don't allow you to manipulate existing code.

Answer 2

Nope, and Walter has been fairly against it in the past e.g. AST macros.