Yesterday I attended a colloquium where Erik van Wyk from University of Minnesota spoke on techniques and tools for making extensible languages. Now extensible language may sound like a strange concept, but it is a fairly simple idea that lies at heart of this:
I want to add this new construct to my language because it may simplify my work. Now that's a pretty basic motivation for us to do some work, so we don't have to do so much work.
van Wyk et al. have developed something called Silver that allows them to specify these extensions using attribute grammars, which is a context-free grammar that has been extended with attributes, semantic rules and conditions. He described how they use forwarding in the attribute grammars to get modularity through refinement of the functionality of the extension.
What this means is that at the core level you could write an extension, say to introduce SQL statements directly in your language, you could introduce
using connection select name, address from customers where balance > `balance and have it automatically converted to
connection.Execute("select name, address from customers where balance > " + balance). This means at the core level your extension is nothing but a macro in the pre-processing sense.
Given your extension at the core level any error reporting, for instance is forwarded, is forwarded to your generated code. This is where the extension refinement comes in, because if you define the appropriate error reporting extensions to your module you could return better errors. And their framework builds further onto this, also making syntax- and control-flow analysis available using two temporal logics, CTL and LTL-FV. You can read more about temporal logics in Logic in Computer Science by Huth and Ryan.
Everything cannot be bliss, however, as this thing requires that the host language is written with these extensions in mind - that is, it has been written in Silver. van Wyk's team is working on both a C and Java implementation, but given the sizes of in particular Java, it probably isn't realistic that they'll get a full model of Java for this. Another problem is, of course, that writing a full-fledged extension requires the programmer to know about attribute grammars, forwarding, temporal logic and a lot of other nitty gritty things. So, get ready to hire me or someone like me.
On a more realistic note I think the ramifications of having support for this in a language are huge as you can customise your language on the basis of your needs very easily. But I don't think it will be feasible until the day that these extensions become easier to write. Until then I'm afraid it will remain an academic exercise, but here's to hoping.