I have some old software (in
a language that's not dead but is dead to me ;-)) that implements
a basic pattern-matching and -rewriting system for source code. I am considering resurrecting this code, translating it into
a modern language, and open-sourcing the project as
a refactoring power-tool. Before I go much further, I want to know if anything like this exists already (my google-fu is fanning air on this tonight).
Here's how it works:
the pattern-matching part matches source-code patterns spanning multiple lines of code using
a template with binding variables,
the pattern-rewriting part uses
a template to rewrite the matched code, inserting the contents of the bound variables from the matching template
matching and rewriting templates are associated (1:1) by
a simple (unconditional) rewrite rule
the software operates on the abstract syntax tree (AST) of the input application, and outputs
a modified AST which can then be regenerated into new source code
for example, suppose we find
a bunch of while-loops that really should be for-loops. The following template will match the while-loop pattern:
Template oldLoopPtrn
int @cnt@ = 0;
while (@cnt@ < @max@)
{
… @body@
++@cnt@;
}
End_Template
while the following template will specify the output rewrite pattern:
Template newLoopPtrn
for(int @cnt@ = 0; @cnt@ < @max@; @cnt@++)
{
@body@
}
End_Template
and
a simple rule to associate them
Rule oldLoopPtrn --> newLoopPtrn
so code that looks like this
int i=0;
while(i<arrlen)
{
printf("element %d: %f\n",i,arr[i]);
++i;
}
gets automatically rewritten to look like this
for(int i = 0; i < arrlen; i++)
{
printf("element %d: %f\n",i,arr[i]);
}
The closest thing I've seen like this is some of the code-refactoring tools, but they seem to be geared towards interactive rewriting of selected snippets, not wholesale automated changes.
I believe that this kind of tool could supercharge refactoring, and would work on multiple languages (even HTML/CSS). I also believe that converting and polishing the code base would be
a huge project that I simply cannot do alone in any reasonable amount of time.
So, anything like this out there already? If not, any obvious features (besides rewrite-rule conditions) to consider?
EDIT: The one feature of this system that I like very much is that the template patterns are fairly obvious and easy to read because they're written in the same language as the target source code, not in some esoteric mutated regex/BNF format.
