OperatorAssignment node and execution

[enebo]

Let's look at some source:

i += 1
@i += 1
$i += 1
foo.bar += 1

And the nodes:

#<YARP::ParseResult:0x00007fba6e7876b8
 @comments=[],
 @errors=[],
 @value=
  ProgramNode(0...35)(
    ScopeNode(0...0)([IDENTIFIER(0...1)("i")]),
    StatementsNode(0...35)(
      [OperatorAssignmentNode(0...6)(
         LocalVariableWriteNode(0...1)((0...1), nil, nil, 0),
         PLUS_EQUAL(2...4)("+="),
         IntegerNode(5...6)()
       ),
       OperatorAssignmentNode(7...14)(
         InstanceVariableWriteNode(7...9)((7...9), nil, nil),
         PLUS_EQUAL(10...12)("+="),
         IntegerNode(13...14)()
       ),
       OperatorAssignmentNode(15...22)(
         GlobalVariableWriteNode(15...17)(
           GLOBAL_VARIABLE(15...17)("$i"),
           nil,
           nil
         ),
         PLUS_EQUAL(18...20)("+="),
         IntegerNode(21...22)()
       ),
       OperatorAssignmentNode(23...35)(
         CallNode(23...30)(
           CallNode(23...26)(
             nil,
             nil,
             IDENTIFIER(23...26)("foo"),
             nil,
             nil,
             nil,
             nil,
             "foo"
           ),
           DOT(26...27)("."),
           IDENTIFIER(27...30)("bar"),
           nil,
           nil,
           nil,
           nil,
           "bar="
         ),
         PLUS_EQUAL(31...33)("+="),
         IntegerNode(34...35)()
       )]
    )
  ),
 @warnings=[]>

In order to get the first 3 assignments we need to examine the type (ex. LocalVariableWrite) and then realize we need to build for a LocalVariableRead. If we look at last one we have to take two nested calls and realize we need to call bar instead of bar=. This is all doable but if you look at how this is done in JRuby and MRI today it looks more like:

RootNode line: 0
  BlockNode line: 0
    LocalAsgnNode*:i line: 0
      OperatorCallNode*:+ line: 0
        LocalVarNode:i line: 0
        ArrayNode line: 0
          FixnumNode line: 0, long: 1
, null
    InstAsgnNode*:@i line: 1
      OperatorCallNode*:+ line: 1
        InstVarNode:@i line: 1
        ArrayNode line: 1
          FixnumNode line: 1, long: 1
, null
    GlobalAsgnNode*:$i line: 2
      OperatorCallNode*:+ line: 2
        GlobalVarNode:$i line: 2
        ArrayNode line: 2
          FixnumNode line: 2, long: 1
, null
    OpAsgnNode* line: 3
      VCallNode*:foo line: 3
      FixnumNode line: 3, long: 1

This tree is more directly just buildable because it emits the accessor with the writer. For non-execution it makes sense that it has to be literal but for execution should we do something more like how it has been done or do we parse apart the write to determine the original read?