Fix Compound Statements

[Aaron3154518]

Currently compound statements are not properly handled in our code. Here are some proposed solutions:

Many compound statements include a new scope (such as if statements). Thus we must distinguish between old/new variables. Old variables exist outside of the new scope, new variables are created within the new scope and cannot leave it.

New Variables:

• Perform SSA renames on all new variables within the compound statment --OR--
• Only generate a type declaration for the first write to a new variable. (currently we generate a type declaration for each instance, which is a syntax error)

Old Variables:

• Do not perform SSA renaming (This creates renames in a new scope which can't be accessed by future statements)
• When renaming from a future statement, do not stop at this statement's writes but instead rename until the previous write. (due to the previous change)
• Do not generate any type declarations for these variables.
• Summary: This method causes compound statements to write to the same variables as exist outside their scope, ensuring that these changes also exist outside the scope. --OR--
• Perform normal SSA on each sub-statement of the compound statement, excluding the first write to a variable.
• When renaming from a future statements, we would need to rename past the compound statement to the previous write as well.
• Can't generate type decl on final write.
• If there are no previous writes, we need to add one.
• Summary: This is the same as method 1 but it applies more SSA within the compound statement.

[Aaron3154518]

That's a lot of words for Old Variables so here's an example:

Original code: S1: int foo = 90; S2: if (condition) { int foo = foo + 1; // None of these changes persist outside the if int bar = foo; int foo = bar * 2; // Duplicate type declarations } S3: int baz = foo - 9; S4: int foo = foo * 2;

Method 1: S1: int foo__w__1 = 90; // Same rename as the writes in S2 S2: if (condition) { foo__w__1 = foo__w__1 + 1; // No type decl, no rename int bar = foo__w__1; // New variable so we are allowed to generate type decl foo__w__1 = bar * 2; } S3: int baz = foo__w__1 - 9; S4: int foo = foo__w__1 * 2;

Method 2: S1: int foo__w__2 = 90; // w__3, didn't get renamed until after S2 S2: if (condition) { int foo__w__1 = foo__w__2 + 1; // Don't perform SSA on the first write int bar = foo__w__1; foo__w__2 = bar * 2; // The last write to foo will have the same rename as outside this scope, no type decl } S3: int baz = foo__w__2 - 9; S4: int foo = foo__w__2 * 2;

[Aaron3154518]

@cathieO When you get the chance, can you look over this an point out anything I missed/other solutions and give general thoughts? It's a lot, but I can go over it at Wednesday's meeting with better explanations.

[Aaron3154518]

Compound statements can be broken up.

[Aaron3154518]

non-issue