How are renamed identifiers shown?

[jpienaar]

Hey,

I started trying out the tool earlier today, adding a new language using the tree-sitter approach. I was wondering if renamed identifiers are detected/could be shown differently? Currently it is shown as if renamed is updated. Well unless the tree-sitter grammar I'm using to try it out on new language isn't working correctly and these are in fact not being detected as renames, which could be happening.

Thanks

[jrfaller]

Hi @jpienaar and thanks a lot for the feedback!

In GumTree, there are 6 kinds of edit actions: insert a node, delete a node, update a node label, move a subtree, insert a subtree, and delete a subtree.

Renamed identifiers (when correctly detected) are displayed with the update a node label action (displayed graphically in orange). There is no dedicated "rename" action. Still, normally most update actions are renamings (except for instance a change of comparison operator that might also be an update label).

Maybe I did not understand fully the question, so don't hesitate to post a concrete example to illustrate what you would want?

Cheers!

[jpienaar]

Thanks (and sorry I missed that you answered until now).

I'm interested in a case where I have different kinds of identifiers where I'd like to not show renaming at all. E.g., for the subset of updates that are detected as renames, I'd like to not show it (my input changes some names quite often, but its not load bearing names, but I don't want to just ignore them unless rename).

So as an example

func.func @simple2() {
  %cst1 = arith.constant 1.0 : f32
  %cst2 = arith.constant 2.0 : f32
  %add = arith.addf %cst1, %cst2 : f32
  return
}

and

func.func @simple2() {
  %c1 = arith.constant 1.0 : f32
  %cst2 = arith.constant 2.0 : f32
  %add = arith.addf %c1, %cst2 : f32
  return
}

are equivalent, while I'd want to flag

func.func @simple2() {
  %cst1 = arith.constant 1.0 : f32
  %cst2 = arith.constant 2.0 : f32
  %add = arith.addf %cst2, %cst1 : f32
  return
}

(I probably shouldn't have used floating point add as an example, but that's much higher level operation semantics than I'd expect to embedded in checking at this level :)). And so in the first case, if detected, I'd not want it to highlight the change (as the files are rather large and it could result in a lot of highlighting).

Re detecting, is there a way I could see if it was detected as a rename? Perhaps in textdiff or one.

[jrfaller]

OK! If I understand correctly, I think one way to have the behavior you wish is to remove the label from these nodes. This way, there won't be any update action shown on them. WDYT?

[jpienaar]

That could work yes. If removing the label, would the DAG matching still work? (E.g., it would still flag switched operands and the like). Also, how do I remove the label? (Is it a config option like flatten?)

[jrfaller]

Yes the DAG matching would still work especially if you do not remove the labels of all nodes. How to proceed, this is a good question ;-). Maybe I could add a label-ignored operation in the configuration?

[jpienaar]

That would be great. So it's kept for parsing but ignored for printing diffs. So just a structural element but spelling ignored. That sound useful generally :-)

[jrfaller]

OK it has landed the main branch of the tree-sitter-parser project! You can try it out :-)

[jpienaar]

I'm not sure if it works (but I haven't read the GumTree paper so could be missing how its supposed to work). I started with the grammar as is, but there the node in define is the same as the node name in the use. Simplified something like

$op: $ => seq($.id, '=', $.name, '(', $id, ')')

so if I ignore before, I ignore after too (as both as id). So it wouldn't catch if one switched things around. I tried changing it to have a different name in the result as in the use, but that didn't work (it flags the rename in use then).

For id, I don't want it ignored as much as I want the "equivalence" classes verified. Now this may be a bit esoteric (as diffing IR rather than programming language), but consider it as diffing an original and an obfuscated program :) Its probably difficult to reproduce or test without a checked in grammar or example, if I were to do it as a Python program (not sure which of the grammars is the easiest here, so chose Python as I figured it would be simpler than C and most recently used non C language of mine). I'd want

x = 1
y = x + 1

equal to

z = 1
y = z + 1

but unequal to

x = 1
y = 1 + x

An alternative may be to try and run preprocessor on this, but feels like then may end up reimplementing detection that's already here. It could also be that this explodes in complexity without some specialized preprocessing but haven't though as deeply/don't understand the domain as well.

[jrfaller]

OK I see what you want but it seems very specific to diffing IR representations. I think the best in this case is that you traverse the AST on your side and make the label abstraction you need according to the semantic you implemented, WDYT?