So, I'm thinking to implement something like this -

1. make the flow graph for a declaration (decl -> reference -> K violation -> ref -> K violation -> ref)
2. traverse this flow graph -
   1. create declarations/bindings for every constantViolation
   2. update the following reference items in the flow graph to reference this new binding

thoughts or suggestions ?

The way I see it is we're dealing with 2 things here — duplicate declarations (aka K violations) and partial evaluation (where we can statically resolve x to its value and replace identifier with it in y = x case).

It might be simpler to break it in these 2 steps.

@boopathi can you explain your "decl -> reference -> K violation -> ref -> K violation -> ref" chain? why does reference would link back to K violation? How would it look in the above example? I'm trying to understand.

That's the flow graph ... Right now, we don't have the control flow for something that we calculate based on positions and other clues ...

So, for this example -

var a = 1;
foo(a);
a = 2;
bar(a);
var a = a + 3;
baz(a);

We need to rename the references correctly to the corresponding declarations (when replaced). So the flow for a in the example would be - decl -> ref -> k violation -> ref -> k violation -> ref ... so from this graph,

1. we can replace all k violations to new declarations
2. and the references that follow to reference this new declaration.

var a = 1;
foo(a);
var a2 = 2;
bar(a2); // a needs to be updated to a2 and a2's references should point here
var a3 = a2 + 3;
baz(a3);

And we deal with branching and looping accordingly.