Splitting declaration and initialization using RASCAL - transformation

Question

I'm new to Rascal and experimenting with its transformation/term rewriting abilities.
I want to write a script that splits declarations like:
int x = 5;
into declaration/initializations like:
int x;
x = 5;
How might I go about this? Let's say the language I'm trying to transform is Java.
Thanks for any help.

Answer 1

Sketch of a solution
Good question. There are several ways to do this and I will show the most simplistic one. Note that your example is not the simplest possible example since it requires a conversion from a single statement to a list of statements (i.e., it is not type preserving).
Here is without further ado a complete example, the explanation follows below.
module Decl
import IO;
import ParseTree;
// Decl, a trivial language, to demo simple program trafo
lexical Id = [a-z][a-z0-9]* !>> [a-z0-9] \ Reserved;
lexical Natural = [0-9]+ ;
lexical String = "\"" ![\"]* "\"";
layout Layout = WhitespaceAndComment* !>> [\ \t\n];
lexical WhitespaceAndComment
= [\ \t\n\r]
;
keyword Reserved = "int" | "str" | "if" | "then" | "else" | "fi" | "while" | "do" | "od";
start syntax Program
= {Statement ";"}* body
;
syntax Type
= "int"
| "str"
;
syntax Statement
= Type tp Id var
| Type tp Id var ":=" Expression exp
| Id var ":=" Expression val
| "if" Expression cond "then" {Statement ";"}* thenPart "else" {Statement ";"}* elsePart "fi"
| "while" Expression cond "do" {Statement ";"}* body "od"
;
syntax Expression
= Id name
| String string
| Natural natcon
| bracket "(" Expression e ")"
> left ( Expression lhs "+" Expression rhs
| Expression lhs "-" Expression rhs
)
;
str trafo1 () {
p = parse(#start[Program], "int x := 1").top;
newBody = "";
for(stat <- p.body){
if((Statement) `<Type tp> <Id var> := <Expression exp>` := stat){
newBody += "<tp> <var>; <var> := <exp>";
} else {
newBody += "<stat>";
}
}
return newBody;
}
The major part is a complete grammar of a simple language. The actual transformation is done by trafo1 which does:
Parse the example.
Introduce and initialize newBody (used to build the result).
Iterate over the statements in the given body.
Test for each statement whether it is of the desired form.
If true, append the transformed statement. Note that string templates are used here to build the transformed statement.
If false, append the original statement.
Return the resulting string.
Discussion
The solution style large depends on your goal. Here we just build a string. If desired, you could return the parsed string as result.
Alternatives:
Transform as concrete parse tree (not so easy since some functionality is still lacking but we aim to make this the preferred solution).
First transform to an abstract syntax tree (AST) and perform the transformation on the AST.
Hope this helps you to get started.

Answer 2

I have some more code examples here, which use concrete syntax matching and substitution to arrive at what you want:
module JavaMatch
import lang::java::\syntax::Java15;
// this just replaces exactly these specific kinds of declarations, as the only statement in a block:
CompilationUnit splitInitializersSimple(CompilationUnit u) = visit(u) {
case (Block) `{ int i = 0; }` => (Block) `{int i; i = 0;}`
};
// the next generalizes over any type, variable name or expression, but still one statement in a block:
CompilationUnit splitInitializersSingle(CompilationUnit u) = visit(u) {
case (Block) `{ <Type t> <Id i> = <Expr e>; }`
=> (Block) `{<Type t> <Id i>; <Id i> = <Expr e>;}`
};
// Now we allow more statements around the declaration, and we simply leave them where they are
CompilationUnit splitInitializersInContext(CompilationUnit u) = visit(u) {
case (Block) `{ <BlockStm* pre>
' <Type t> <Id i> = <Expr e>;
' <BlockStm* post>
'}`
=> (Block) `{ <BlockStm* pre>
' <Type t> <Id i>;
' <Id i> = <Expr e>;
' <BlockStm* post>
'}`
};
// But there could be more initializers in the same decl as well, as in int i, j = 0, k; :
CompilationUnit splitInitializersInContext2(CompilationUnit u) = visit(u) {
case (Block) `{ <BlockStm* pre>
' <Type t> <{VarDec ","}+ a>, <Id i>= <Expr e>, <{VarDec ","}+ b>;
' <BlockStm* post>
'}`
=> (Block) `{ <BlockStm* pre>
' <Type t> <{VarDec ","}+ a>, <Id i>, <{VarDec ","}+ b>;
' <Id i> = <Expr e>;
' <BlockStm* post>
'}`
};
// and now we add `innermost` such that not only the first but all occurrences are replaced:
CompilationUnit splitInitializersInContext2(CompilationUnit u) = innermost visit(u) {
case (Block) `{ <BlockStm* pre>
' <Type t> <{VarDec ","}+ a>, <Id i>= <Expr e>, <{VarDec ","}+ b>;
' <BlockStm* post>
'}`
=> (Block) `{ <BlockStm* pre>
' <Type t> <{VarDec ","}+ a>, <Id i>, <{VarDec ","}+ b>;
' <Id i> = <Expr e>;
' <BlockStm* post>
'}`
};
void doIt(loc file) {
start[CompilationUnit] unit = parse(#start[CompilationUnit], file);
unit.top = splitInitializersInContext(unit.top);
writeFile(file, "<unit>");
}
Final remarks, because this is still not fully general:
taking care of modifiers and array types; this will just add more variables to match and carry to the right hand side
the initializers will now occur in reverse order as statements, and in case of data dependency between them this would break
note that the shape of the rule is dependent very much on the Java grammar, since we use concrete syntax matching here. It helps to browse the grammar while you create such code.
this code preserves comments in many places, but not all, in particular in between declarations which are rewritten and in between vardecs which are rewritten the comments will be lost using this code.