Sure. Check out Program Transformation Tools (PTS). Such tools provide a means to define a grammar, use that grammar to parse source text to ASTs, and prettyprint ASTs back to text. More importantly, the same grammar is used to read source-to-source transformation rules, that allow you to express transformations directly (or express compound transformations in terms of sets of rewrites). Such transformations use the expressed patterns to match against the ASTs, and modify the ASTs; these transformations, being structure based, are not confused by layout or whitespace.
As an example, our DMS Software Reengineering Toolkit let you write rules in the form if you see this, replace it by that, taking the general form:
rule rule_name(pattern_variables)
: pattern_syntax_category -> replacement_syntax_category
= metaquote pattern_text_in_specified_language metaquote
=> metaquote replacement_text_in_specified_language metaquote
if condition_over_bound_pattern_variables;
where
- rule is syntax introducing a rule,
- rule_name gives the rule a name to distinguish it from other rules,
- pattern_variables is a list of pairs n:c of a pattern
variable name n and syntax category c which n must satisfy,
- pattern_syntax_category is a syntax category that the pattern_text must satisfy,
- replacement_syntax_category is a syntax category that the replacement_text must satisfy. Usually, and in all examples given here,
the same as pattern_syntax_category ; when using rewrite rules to translate between languages, these often differ because the syntax categories in the languages differ.
- metaquote is the " character, which seperates the rule language syntax from that of the pattern or replacement language syntax
- pattern_text_in_specified_language is a well-formed fragment of the source language, containing pattern variables n written as \n; any match of pattern binds the pattern variables to subtrees. If \n occurs twice in pattern, both instances must be identical.
- replacement_text_in_specified_language is a well-formed fragment of the target langauge. A found pattern is replaced by the replacement, with any pattern variables in the replacement substitued by the bound pattern variable value
- if is syntax introducing a condition
- condition_over_bound_pattern_variables is a constraint that the pattern variables must satisfy after a pattern match has been found. This is often used to check context conditions that must be satisified.
DMS will let you write and apply the following example transformations (including some of OP's examples):
default domain Java~v8; -- specify v8 dialect of Java to manipulate
rule reduce_strength_squared(e: term):
:product -> product
= "\e ^ 2 " ==> "\e * \e "
if no_side_effects(e);
rule optimize_divide_by_self(e: term):
:product -> product
= " \e / \e " => " 1 " if is_not_zero(e);
rule accumulate_string(n: IDENTIFIER, a: expression, b: left_hand_side)
: statement -> statement
= "for (String \s: \a) { \b.add(\s); }"
=> "\b.addAll(\a);";
rule eliminate_useless_if(x: expression, s: statement)
: statement -> statement
= "if (\x) \s; else \s; " -- generalizes OP's example
=> "\s;";
rule left_factor_ternary(x: expression; t: left_hand_side; a: expression; b:expression)
: statement -> statement
= "if (\x) { \t = \a;} else {\t = \b;} "
=> "\t = \x ? \a : \b ";
rule convert_to_diamond( T1: qualified_path, T2: qualified_path,
C: qualified_path,
i: IDENTIFIER, a: arglist)
:statement -> statement
= "\T1<\T2> \i = new \C<\T2>(\a);"
=> "\T1<\T2> \i = new \C<>(\a);"
rule merge_multi_catch( b:body, i1: IDENTIFIER, e1: qualified_path,
i2: IDENTIFIER, eh: body )
:statement -> statement
= "try { \b }
catch ( \i1: \e1 ) { \eh }
catch ( \i2: \e1 ) { \eh }";
=> "try { \b }
catch ( \i1, \i2: \e1 ) { \eh }";
More sophisticated transformations are possible, including those that affect parts of the program that are far apart and even across source file boundaries. These usually require some additional metaprogramming (not discussed here) and often some additional checks on the context, e.g., that identifiers are of the right type, etc. [DMS has full symbol tables for Java to support this].
Other PTS can express rules in similar way. Most of them don't provide support for deeper semantic facts such as symbol tables or types, although the claim is that you can program those yourself. Experience shows this is a lot of work, and you really want it to be right. (Who wants their transformation to damage the code because it is operating on bad information?).
