path: root/test/prism/snapshots/unparser/corpus/literal/assignment.txt

@ ProgramNode (location: (1,0)-(51,17))
├── locals: [:a, :b, :foo, :c, :x]
└── statements:
    @ StatementsNode (location: (1,0)-(51,17))
    └── body: (length: 43)
        ├── @ GlobalVariableWriteNode (location: (1,0)-(1,6))
        │   ├── name: :$a
        │   ├── name_loc: (1,0)-(1,2) = "$a"
        │   ├── value:
        │   │   @ IntegerNode (location: (1,5)-(1,6))
        │   │   ├── flags: decimal
        │   │   └── value: 1
        │   └── operator_loc: (1,3)-(1,4) = "="
        ├── @ MultiWriteNode (location: (2,0)-(2,17))
        │   ├── lefts: (length: 2)
        │   │   ├── @ GlobalVariableTargetNode (location: (2,1)-(2,3))
        │   │   │   └── name: :$a
        │   │   └── @ GlobalVariableTargetNode (location: (2,5)-(2,7))
        │   │       └── name: :$b
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (2,0)-(2,1) = "("
        │   ├── rparen_loc: (2,7)-(2,8) = ")"
        │   ├── operator_loc: (2,9)-(2,10) = "="
        │   └── value:
        │       @ ArrayNode (location: (2,11)-(2,17))
        │       ├── flags: ∅
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (2,12)-(2,13))
        │       │   │   ├── flags: decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (2,15)-(2,16))
        │       │       ├── flags: decimal
        │       │       └── value: 2
        │       ├── opening_loc: (2,11)-(2,12) = "["
        │       └── closing_loc: (2,16)-(2,17) = "]"
        ├── @ MultiWriteNode (location: (3,0)-(3,13))
        │   ├── lefts: (length: 2)
        │   │   ├── @ MultiTargetNode (location: (3,1)-(3,5))
        │   │   │   ├── lefts: (length: 1)
        │   │   │   │   └── @ LocalVariableTargetNode (location: (3,2)-(3,3))
        │   │   │   │       ├── name: :a
        │   │   │   │       └── depth: 0
        │   │   │   ├── rest:
        │   │   │   │   @ ImplicitRestNode (location: (3,3)-(3,4))
        │   │   │   ├── rights: (length: 0)
        │   │   │   ├── lparen_loc: (3,1)-(3,2) = "("
        │   │   │   └── rparen_loc: (3,4)-(3,5) = ")"
        │   │   └── @ LocalVariableTargetNode (location: (3,7)-(3,8))
        │   │       ├── name: :b
        │   │       └── depth: 0
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (3,0)-(3,1) = "("
        │   ├── rparen_loc: (3,8)-(3,9) = ")"
        │   ├── operator_loc: (3,10)-(3,11) = "="
        │   └── value:
        │       @ IntegerNode (location: (3,12)-(3,13))
        │       ├── flags: decimal
        │       └── value: 1
        ├── @ MultiWriteNode (location: (4,0)-(4,9))
        │   ├── lefts: (length: 0)
        │   ├── rest:
        │   │   @ SplatNode (location: (4,1)-(4,3))
        │   │   ├── operator_loc: (4,1)-(4,2) = "*"
        │   │   └── expression:
        │   │       @ LocalVariableTargetNode (location: (4,2)-(4,3))
        │   │       ├── name: :a
        │   │       └── depth: 0
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (4,0)-(4,1) = "("
        │   ├── rparen_loc: (4,3)-(4,4) = ")"
        │   ├── operator_loc: (4,5)-(4,6) = "="
        │   └── value:
        │       @ ArrayNode (location: (4,7)-(4,9))
        │       ├── flags: ∅
        │       ├── elements: (length: 0)
        │       ├── opening_loc: (4,7)-(4,8) = "["
        │       └── closing_loc: (4,8)-(4,9) = "]"
        ├── @ MultiWriteNode (location: (5,0)-(5,15))
        │   ├── lefts: (length: 0)
        │   ├── rest:
        │   │   @ SplatNode (location: (5,1)-(5,5))
        │   │   ├── operator_loc: (5,1)-(5,2) = "*"
        │   │   └── expression:
        │   │       @ LocalVariableTargetNode (location: (5,2)-(5,5))
        │   │       ├── name: :foo
        │   │       └── depth: 0
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (5,0)-(5,1) = "("
        │   ├── rparen_loc: (5,5)-(5,6) = ")"
        │   ├── operator_loc: (5,7)-(5,8) = "="
        │   └── value:
        │       @ ArrayNode (location: (5,9)-(5,15))
        │       ├── flags: ∅
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (5,10)-(5,11))
        │       │   │   ├── flags: decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (5,13)-(5,14))
        │       │       ├── flags: decimal
        │       │       └── value: 2
        │       ├── opening_loc: (5,9)-(5,10) = "["
        │       └── closing_loc: (5,14)-(5,15) = "]"
        ├── @ MultiWriteNode (location: (6,0)-(6,19))
        │   ├── lefts: (length: 2)
        │   │   ├── @ ClassVariableTargetNode (location: (6,1)-(6,4))
        │   │   │   └── name: :@@a
        │   │   └── @ ClassVariableTargetNode (location: (6,6)-(6,9))
        │   │       └── name: :@@b
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (6,0)-(6,1) = "("
        │   ├── rparen_loc: (6,9)-(6,10) = ")"
        │   ├── operator_loc: (6,11)-(6,12) = "="
        │   └── value:
        │       @ ArrayNode (location: (6,13)-(6,19))
        │       ├── flags: ∅
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (6,14)-(6,15))
        │       │   │   ├── flags: decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (6,17)-(6,18))
        │       │       ├── flags: decimal
        │       │       └── value: 2
        │       ├── opening_loc: (6,13)-(6,14) = "["
        │       └── closing_loc: (6,18)-(6,19) = "]"
        ├── @ MultiWriteNode (location: (7,0)-(7,17))
        │   ├── lefts: (length: 2)
        │   │   ├── @ InstanceVariableTargetNode (location: (7,1)-(7,3))
        │   │   │   └── name: :@a
        │   │   └── @ InstanceVariableTargetNode (location: (7,5)-(7,7))
        │   │       └── name: :@b
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (7,0)-(7,1) = "("
        │   ├── rparen_loc: (7,7)-(7,8) = ")"
        │   ├── operator_loc: (7,9)-(7,10) = "="
        │   └── value:
        │       @ ArrayNode (location: (7,11)-(7,17))
        │       ├── flags: ∅
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (7,12)-(7,13))
        │       │   │   ├── flags: decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (7,15)-(7,16))
        │       │       ├── flags: decimal
        │       │       └── value: 2
        │       ├── opening_loc: (7,11)-(7,12) = "["
        │       └── closing_loc: (7,16)-(7,17) = "]"
        ├── @ MultiWriteNode (location: (8,0)-(8,25))
        │   ├── lefts: (length: 2)
        │   │   ├── @ LocalVariableTargetNode (location: (8,1)-(8,2))
        │   │   │   ├── name: :a
        │   │   │   └── depth: 0
        │   │   └── @ MultiTargetNode (location: (8,4)-(8,10))
        │   │       ├── lefts: (length: 2)
        │   │       │   ├── @ LocalVariableTargetNode (location: (8,5)-(8,6))
        │   │       │   │   ├── name: :b
        │   │       │   │   └── depth: 0
        │   │       │   └── @ LocalVariableTargetNode (location: (8,8)-(8,9))
        │   │       │       ├── name: :c
        │   │       │       └── depth: 0
        │   │       ├── rest: ∅
        │   │       ├── rights: (length: 0)
        │   │       ├── lparen_loc: (8,4)-(8,5) = "("
        │   │       └── rparen_loc: (8,9)-(8,10) = ")"
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (8,0)-(8,1) = "("
        │   ├── rparen_loc: (8,10)-(8,11) = ")"
        │   ├── operator_loc: (8,12)-(8,13) = "="
        │   └── value:
        │       @ ArrayNode (location: (8,14)-(8,25))
        │       ├── flags: ∅
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (8,15)-(8,16))
        │       │   │   ├── flags: decimal
        │       │   │   └── value: 1
        │       │   └── @ ArrayNode (location: (8,18)-(8,24))
        │       │       ├── flags: ∅
        │       │       ├── elements: (length: 2)
        │       │       │   ├── @ IntegerNode (location: (8,19)-(8,20))
        │       │       │   │   ├── flags: decimal
        │       │       │   │   └── value: 2
        │       │       │   └── @ IntegerNode (location: (8,22)-(8,23))
        │       │       │       ├── flags: decimal
        │       │       │       └── value: 3
        │       │       ├── opening_loc: (8,18)-(8,19) = "["
        │       │       └── closing_loc: (8,23)-(8,24) = "]"
        │       ├── opening_loc: (8,14)-(8,15) = "["
        │       └── closing_loc: (8,24)-(8,25) = "]"
        ├── @ MultiWriteNode (location: (9,0)-(9,15))
        │   ├── lefts: (length: 1)
        │   │   └── @ LocalVariableTargetNode (location: (9,1)-(9,2))
        │   │       ├── name: :a
        │   │       └── depth: 0
        │   ├── rest:
        │   │   @ SplatNode (location: (9,4)-(9,5))
        │   │   ├── operator_loc: (9,4)-(9,5) = "*"
        │   │   └── expression: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (9,0)-(9,1) = "("
        │   ├── rparen_loc: (9,5)-(9,6) = ")"
        │   ├── operator_loc: (9,7)-(9,8) = "="
        │   └── value:
        │       @ ArrayNode (location: (9,9)-(9,15))
        │       ├── flags: ∅
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (9,10)-(9,11))
        │       │   │   ├── flags: decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (9,13)-(9,14))
        │       │       ├── flags: decimal
        │       │       └── value: 2
        │       ├── opening_loc: (9,9)-(9,10) = "["
        │       └── closing_loc: (9,14)-(9,15) = "]"
        ├── @ MultiWriteNode (location: (10,0)-(10,18))
        │   ├── lefts: (length: 1)
        │   │   └── @ LocalVariableTargetNode (location: (10,1)-(10,2))
        │   │       ├── name: :a
        │   │       └── depth: 0
        │   ├── rest:
        │   │   @ SplatNode (location: (10,4)-(10,8))
        │   │   ├── operator_loc: (10,4)-(10,5) = "*"
        │   │   └── expression:
        │   │       @ LocalVariableTargetNode (location: (10,5)-(10,8))
        │   │       ├── name: :foo
        │   │       └── depth: 0
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (10,0)-(10,1) = "("
        │   ├── rparen_loc: (10,8)-(10,9) = ")"
        │   ├── operator_loc: (10,10)-(10,11) = "="
        │   └── value:
        │       @ ArrayNode (location: (10,12)-(10,18))
        │       ├── flags: ∅
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (10,13)-(10,14))
        │       │   │   ├── flags: decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (10,16)-(10,17))
        │       │       ├── flags: decimal
        │       │       └── value: 2
        │       ├── opening_loc: (10,12)-(10,13) = "["
        │       └── closing_loc: (10,17)-(10,18) = "]"
        ├── @ MultiWriteNode (location: (11,0)-(11,15))
        │   ├── lefts: (length: 2)
        │   │   ├── @ LocalVariableTargetNode (location: (11,1)-(11,2))
        │   │   │   ├── name: :a
        │   │   │   └── depth: 0
        │   │   └── @ LocalVariableTargetNode (location: (11,4)-(11,5))
        │   │       ├── name: :b
        │   │       └── depth: 0
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (11,0)-(11,1) = "("
        │   ├── rparen_loc: (11,5)-(11,6) = ")"
        │   ├── operator_loc: (11,7)-(11,8) = "="
        │   └── value:
        │       @ ArrayNode (location: (11,9)-(11,15))
        │       ├── flags: ∅
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (11,10)-(11,11))
        │       │   │   ├── flags: decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (11,13)-(11,14))
        │       │       ├── flags: decimal
        │       │       └── value: 2
        │       ├── opening_loc: (11,9)-(11,10) = "["
        │       └── closing_loc: (11,14)-(11,15) = "]"
        ├── @ MultiWriteNode (location: (12,0)-(12,12))
        │   ├── lefts: (length: 2)
        │   │   ├── @ LocalVariableTargetNode (location: (12,1)-(12,2))
        │   │   │   ├── name: :a
        │   │   │   └── depth: 0
        │   │   └── @ LocalVariableTargetNode (location: (12,4)-(12,5))
        │   │       ├── name: :b
        │   │       └── depth: 0
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (12,0)-(12,1) = "("
        │   ├── rparen_loc: (12,5)-(12,6) = ")"
        │   ├── operator_loc: (12,7)-(12,8) = "="
        │   └── value:
        │       @ LocalVariableReadNode (location: (12,9)-(12,12))
        │       ├── name: :foo
        │       └── depth: 0
        ├── @ MultiWriteNode (location: (13,0)-(13,10))
        │   ├── lefts: (length: 1)
        │   │   └── @ LocalVariableTargetNode (location: (13,1)-(13,2))
        │   │       ├── name: :a
        │   │       └── depth: 0
        │   ├── rest:
        │   │   @ ImplicitRestNode (location: (13,2)-(13,3))
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (13,0)-(13,1) = "("
        │   ├── rparen_loc: (13,3)-(13,4) = ")"
        │   ├── operator_loc: (13,5)-(13,6) = "="
        │   └── value:
        │       @ LocalVariableReadNode (location: (13,7)-(13,10))
        │       ├── name: :foo
        │       └── depth: 0
        ├── @ MultiWriteNode (location: (14,0)-(14,23))
        │   ├── lefts: (length: 2)
        │   │   ├── @ CallTargetNode (location: (14,1)-(14,6))
        │   │   │   ├── flags: ∅
        │   │   │   ├── receiver:
        │   │   │   │   @ LocalVariableReadNode (location: (14,1)-(14,2))
        │   │   │   │   ├── name: :a
        │   │   │   │   └── depth: 0
        │   │   │   ├── call_operator_loc: (14,2)-(14,3) = "."
        │   │   │   ├── name: :foo=
        │   │   │   └── message_loc: (14,3)-(14,6) = "foo"
        │   │   └── @ CallTargetNode (location: (14,8)-(14,13))
        │   │       ├── flags: ∅
        │   │       ├── receiver:
        │   │       │   @ LocalVariableReadNode (location: (14,8)-(14,9))
        │   │       │   ├── name: :a
        │   │       │   └── depth: 0
        │   │       ├── call_operator_loc: (14,9)-(14,10) = "."
        │   │       ├── name: :bar=
        │   │       └── message_loc: (14,10)-(14,13) = "bar"
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (14,0)-(14,1) = "("
        │   ├── rparen_loc: (14,13)-(14,14) = ")"
        │   ├── operator_loc: (14,15)-(14,16) = "="
        │   └── value:
        │       @ ArrayNode (location: (14,17)-(14,23))
        │       ├── flags: ∅
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (14,18)-(14,19))
        │       │   │   ├── flags: decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (14,21)-(14,22))
        │       │       ├── flags: decimal
        │       │       └── value: 2
        │       ├── opening_loc: (14,17)-(14,18) = "["
        │       └── closing_loc: (14,22)-(14,23) = "]"
        ├── @ MultiWriteNode (location: (15,0)-(15,24))
        │   ├── lefts: (length: 2)
        │   │   ├── @ IndexTargetNode (location: (15,1)-(15,8))
        │   │   │   ├── flags: attribute_write
        │   │   │   ├── receiver:
        │   │   │   │   @ LocalVariableReadNode (location: (15,1)-(15,2))
        │   │   │   │   ├── name: :a
        │   │   │   │   └── depth: 0
        │   │   │   ├── opening_loc: (15,2)-(15,3) = "["
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (15,3)-(15,7))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ SplatNode (location: (15,3)-(15,7))
        │   │   │   │           ├── operator_loc: (15,3)-(15,4) = "*"
        │   │   │   │           └── expression:
        │   │   │   │               @ LocalVariableReadNode (location: (15,4)-(15,7))
        │   │   │   │               ├── name: :foo
        │   │   │   │               └── depth: 0
        │   │   │   ├── closing_loc: (15,7)-(15,8) = "]"
        │   │   │   └── block: ∅
        │   │   └── @ IndexTargetNode (location: (15,10)-(15,14))
        │   │       ├── flags: attribute_write
        │   │       ├── receiver:
        │   │       │   @ LocalVariableReadNode (location: (15,10)-(15,11))
        │   │       │   ├── name: :a
        │   │       │   └── depth: 0
        │   │       ├── opening_loc: (15,11)-(15,12) = "["
        │   │       ├── arguments:
        │   │       │   @ ArgumentsNode (location: (15,12)-(15,13))
        │   │       │   ├── flags: ∅
        │   │       │   └── arguments: (length: 1)
        │   │       │       └── @ IntegerNode (location: (15,12)-(15,13))
        │   │       │           ├── flags: decimal
        │   │       │           └── value: 1
        │   │       ├── closing_loc: (15,13)-(15,14) = "]"
        │   │       └── block: ∅
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (15,0)-(15,1) = "("
        │   ├── rparen_loc: (15,14)-(15,15) = ")"
        │   ├── operator_loc: (15,16)-(15,17) = "="
        │   └── value:
        │       @ ArrayNode (location: (15,18)-(15,24))
        │       ├── flags: ∅
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (15,19)-(15,20))
        │       │   │   ├── flags: decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (15,22)-(15,23))
        │       │       ├── flags: decimal
        │       │       └── value: 2
        │       ├── opening_loc: (15,18)-(15,19) = "["
        │       └── closing_loc: (15,23)-(15,24) = "]"
        ├── @ MultiWriteNode (location: (16,0)-(16,21))
        │   ├── lefts: (length: 2)
        │   │   ├── @ IndexTargetNode (location: (16,1)-(16,5))
        │   │   │   ├── flags: attribute_write
        │   │   │   ├── receiver:
        │   │   │   │   @ LocalVariableReadNode (location: (16,1)-(16,2))
        │   │   │   │   ├── name: :a
        │   │   │   │   └── depth: 0
        │   │   │   ├── opening_loc: (16,2)-(16,3) = "["
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (16,3)-(16,4))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (16,3)-(16,4))
        │   │   │   │           ├── flags: decimal
        │   │   │   │           └── value: 0
        │   │   │   ├── closing_loc: (16,4)-(16,5) = "]"
        │   │   │   └── block: ∅
        │   │   └── @ IndexTargetNode (location: (16,7)-(16,11))
        │   │       ├── flags: attribute_write
        │   │       ├── receiver:
        │   │       │   @ LocalVariableReadNode (location: (16,7)-(16,8))
        │   │       │   ├── name: :a
        │   │       │   └── depth: 0
        │   │       ├── opening_loc: (16,8)-(16,9) = "["
        │   │       ├── arguments:
        │   │       │   @ ArgumentsNode (location: (16,9)-(16,10))
        │   │       │   ├── flags: ∅
        │   │       │   └── arguments: (length: 1)
        │   │       │       └── @ IntegerNode (location: (16,9)-(16,10))
        │   │       │           ├── flags: decimal
        │   │       │           └── value: 1
        │   │       ├── closing_loc: (16,10)-(16,11) = "]"
        │   │       └── block: ∅
        │   ├── rest: ∅
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (16,0)-(16,1) = "("
        │   ├── rparen_loc: (16,11)-(16,12) = ")"
        │   ├── operator_loc: (16,13)-(16,14) = "="
        │   └── value:
        │       @ ArrayNode (location: (16,15)-(16,21))
        │       ├── flags: ∅
        │       ├── elements: (length: 2)
        │       │   ├── @ IntegerNode (location: (16,16)-(16,17))
        │       │   │   ├── flags: decimal
        │       │   │   └── value: 1
        │       │   └── @ IntegerNode (location: (16,19)-(16,20))
        │       │       ├── flags: decimal
        │       │       └── value: 2
        │       ├── opening_loc: (16,15)-(16,16) = "["
        │       └── closing_loc: (16,20)-(16,21) = "]"
        ├── @ MultiWriteNode (location: (17,0)-(17,12))
        │   ├── lefts: (length: 0)
        │   ├── rest:
        │   │   @ SplatNode (location: (17,1)-(17,7))
        │   │   ├── operator_loc: (17,1)-(17,2) = "*"
        │   │   └── expression:
        │   │       @ CallTargetNode (location: (17,2)-(17,7))
        │   │       ├── flags: ∅
        │   │       ├── receiver:
        │   │       │   @ LocalVariableReadNode (location: (17,2)-(17,3))
        │   │       │   ├── name: :c
        │   │       │   └── depth: 0
        │   │       ├── call_operator_loc: (17,3)-(17,4) = "."
        │   │       ├── name: :foo=
        │   │       └── message_loc: (17,4)-(17,7) = "foo"
        │   ├── rights: (length: 0)
        │   ├── lparen_loc: (17,0)-(17,1) = "("
        │   ├── rparen_loc: (17,7)-(17,8) = ")"
        │   ├── operator_loc: (17,9)-(17,10) = "="
        │   └── value:
        │       @ IntegerNode (location: (17,11)-(17,12))
        │       ├── flags: decimal
        │       └── value: 1
        ├── @ ConstantPathWriteNode (location: (18,0)-(18,13))
        │   ├── target:
        │   │   @ ConstantPathNode (location: (18,0)-(18,5))
        │   │   ├── parent: ∅
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (18,2)-(18,5))
        │   │   │   └── name: :Foo
        │   │   └── delimiter_loc: (18,0)-(18,2) = "::"
        │   ├── operator_loc: (18,6)-(18,7) = "="
        │   └── value:
        │       @ ConstantPathNode (location: (18,8)-(18,13))
        │       ├── parent: ∅
        │       ├── child:
        │       │   @ ConstantReadNode (location: (18,10)-(18,13))
        │       │   └── name: :Bar
        │       └── delimiter_loc: (18,8)-(18,10) = "::"
        ├── @ ClassVariableWriteNode (location: (19,0)-(19,7))
        │   ├── name: :@@a
        │   ├── name_loc: (19,0)-(19,3) = "@@a"
        │   ├── value:
        │   │   @ IntegerNode (location: (19,6)-(19,7))
        │   │   ├── flags: decimal
        │   │   └── value: 1
        │   └── operator_loc: (19,4)-(19,5) = "="
        ├── @ InstanceVariableWriteNode (location: (20,0)-(20,6))
        │   ├── name: :@a
        │   ├── name_loc: (20,0)-(20,2) = "@a"
        │   ├── value:
        │   │   @ IntegerNode (location: (20,5)-(20,6))
        │   │   ├── flags: decimal
        │   │   └── value: 1
        │   └── operator_loc: (20,3)-(20,4) = "="
        ├── @ ConstantWriteNode (location: (21,0)-(21,9))
        │   ├── name: :CONST
        │   ├── name_loc: (21,0)-(21,5) = "CONST"
        │   ├── value:
        │   │   @ IntegerNode (location: (21,8)-(21,9))
        │   │   ├── flags: decimal
        │   │   └── value: 1
        │   └── operator_loc: (21,6)-(21,7) = "="
        ├── @ ConstantPathWriteNode (location: (22,0)-(22,23))
        │   ├── target:
        │   │   @ ConstantPathNode (location: (22,0)-(22,19))
        │   │   ├── parent:
        │   │   │   @ ConstantPathNode (location: (22,0)-(22,12))
        │   │   │   ├── parent:
        │   │   │   │   @ ConstantReadNode (location: (22,0)-(22,4))
        │   │   │   │   └── name: :Name
        │   │   │   ├── child:
        │   │   │   │   @ ConstantReadNode (location: (22,6)-(22,12))
        │   │   │   │   └── name: :Spaced
        │   │   │   └── delimiter_loc: (22,4)-(22,6) = "::"
        │   │   ├── child:
        │   │   │   @ ConstantReadNode (location: (22,14)-(22,19))
        │   │   │   └── name: :CONST
        │   │   └── delimiter_loc: (22,12)-(22,14) = "::"
        │   ├── operator_loc: (22,20)-(22,21) = "="
        │   └── value:
        │       @ IntegerNode (location: (22,22)-(22,23))
        │       ├── flags: decimal
        │       └── value: 1
        ├── @ LocalVariableWriteNode (location: (23,0)-(23,16))
        │   ├── name: :a
        │   ├── depth: 0
        │   ├── name_loc: (23,0)-(23,1) = "a"
        │   ├── value:
        │   │   @ ParenthesesNode (location: (23,4)-(23,16))
        │   │   ├── body:
        │   │   │   @ StatementsNode (location: (23,5)-(23,15))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ MultiWriteNode (location: (23,5)-(23,15))
        │   │   │           ├── lefts: (length: 2)
        │   │   │           │   ├── @ LocalVariableTargetNode (location: (23,6)-(23,7))
        │   │   │           │   │   ├── name: :b
        │   │   │           │   │   └── depth: 0
        │   │   │           │   └── @ LocalVariableTargetNode (location: (23,9)-(23,10))
        │   │   │           │       ├── name: :c
        │   │   │           │       └── depth: 0
        │   │   │           ├── rest: ∅
        │   │   │           ├── rights: (length: 0)
        │   │   │           ├── lparen_loc: (23,5)-(23,6) = "("
        │   │   │           ├── rparen_loc: (23,10)-(23,11) = ")"
        │   │   │           ├── operator_loc: (23,12)-(23,13) = "="
        │   │   │           └── value:
        │   │   │               @ IntegerNode (location: (23,14)-(23,15))
        │   │   │               ├── flags: decimal
        │   │   │               └── value: 1
        │   │   ├── opening_loc: (23,4)-(23,5) = "("
        │   │   └── closing_loc: (23,15)-(23,16) = ")"
        │   └── operator_loc: (23,2)-(23,3) = "="
        ├── @ LocalVariableWriteNode (location: (24,0)-(24,5))
        │   ├── name: :a
        │   ├── depth: 0
        │   ├── name_loc: (24,0)-(24,1) = "a"
        │   ├── value:
        │   │   @ IntegerNode (location: (24,4)-(24,5))
        │   │   ├── flags: decimal
        │   │   └── value: 1
        │   └── operator_loc: (24,2)-(24,3) = "="
        ├── @ LocalVariableWriteNode (location: (25,0)-(25,11))
        │   ├── name: :foo
        │   ├── depth: 0
        │   ├── name_loc: (25,0)-(25,3) = "foo"
        │   ├── value:
        │   │   @ CallNode (location: (25,6)-(25,11))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (25,6)-(25,9) = "foo"
        │   │   ├── opening_loc: (25,9)-(25,10) = "("
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: (25,10)-(25,11) = ")"
        │   │   └── block: ∅
        │   └── operator_loc: (25,4)-(25,5) = "="
        ├── @ CallNode (location: (26,0)-(26,9))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (26,0)-(26,3))
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: (26,3)-(26,4) = "."
        │   ├── name: :[]=
        │   ├── message_loc: (26,4)-(26,7) = "[]="
        │   ├── opening_loc: (26,7)-(26,8) = "("
        │   ├── arguments: ∅
        │   ├── closing_loc: (26,8)-(26,9) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (27,0)-(27,13))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (27,0)-(27,3))
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: (27,3)-(27,4) = "."
        │   ├── name: :[]=
        │   ├── message_loc: (27,4)-(27,7) = "[]="
        │   ├── opening_loc: (27,7)-(27,8) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (27,8)-(27,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ IntegerNode (location: (27,8)-(27,9))
        │   │       │   ├── flags: decimal
        │   │       │   └── value: 1
        │   │       └── @ IntegerNode (location: (27,11)-(27,12))
        │   │           ├── flags: decimal
        │   │           └── value: 2
        │   ├── closing_loc: (27,12)-(27,13) = ")"
        │   └── block: ∅
        ├── @ CallNode (location: (28,0)-(28,11))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (28,0)-(28,3))
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: (28,3)-(28,4) = "."
        │   ├── name: :[]=
        │   ├── message_loc: (28,4)-(28,7) = "[]="
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (28,7)-(28,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ TrueNode (location: (28,7)-(28,11))
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (29,0)-(29,19))
        │   ├── flags: attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (29,0)-(29,3))
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (29,3)-(29,11) = "[*index]"
        │   ├── opening_loc: (29,3)-(29,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (29,4)-(29,19))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ SplatNode (location: (29,4)-(29,10))
        │   │       │   ├── operator_loc: (29,4)-(29,5) = "*"
        │   │       │   └── expression:
        │   │       │       @ CallNode (location: (29,5)-(29,10))
        │   │       │       ├── flags: variable_call, ignore_visibility
        │   │       │       ├── receiver: ∅
        │   │       │       ├── call_operator_loc: ∅
        │   │       │       ├── name: :index
        │   │       │       ├── message_loc: (29,5)-(29,10) = "index"
        │   │       │       ├── opening_loc: ∅
        │   │       │       ├── arguments: ∅
        │   │       │       ├── closing_loc: ∅
        │   │       │       └── block: ∅
        │   │       └── @ CallNode (location: (29,14)-(29,19))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :value
        │   │           ├── message_loc: (29,14)-(29,19) = "value"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (29,10)-(29,11) = "]"
        │   └── block: ∅
        ├── @ CallNode (location: (30,0)-(30,17))
        │   ├── flags: attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (30,0)-(30,3))
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (30,3)-(30,9) = "[1..2]"
        │   ├── opening_loc: (30,3)-(30,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (30,4)-(30,17))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ RangeNode (location: (30,4)-(30,8))
        │   │       │   ├── flags: ∅
        │   │       │   ├── left:
        │   │       │   │   @ IntegerNode (location: (30,4)-(30,5))
        │   │       │   │   ├── flags: decimal
        │   │       │   │   └── value: 1
        │   │       │   ├── right:
        │   │       │   │   @ IntegerNode (location: (30,7)-(30,8))
        │   │       │   │   ├── flags: decimal
        │   │       │   │   └── value: 2
        │   │       │   └── operator_loc: (30,5)-(30,7) = ".."
        │   │       └── @ CallNode (location: (30,12)-(30,17))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :value
        │   │           ├── message_loc: (30,12)-(30,17) = "value"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (30,8)-(30,9) = "]"
        │   └── block: ∅
        ├── @ CallNode (location: (31,0)-(31,9))
        │   ├── flags: attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (31,0)-(31,3))
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (31,3)-(31,5) = "[]"
        │   ├── opening_loc: (31,3)-(31,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (31,8)-(31,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (31,8)-(31,9))
        │   │           ├── flags: decimal
        │   │           └── value: 1
        │   ├── closing_loc: (31,4)-(31,5) = "]"
        │   └── block: ∅
        ├── @ CallNode (location: (32,0)-(32,17))
        │   ├── flags: attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (32,0)-(32,3))
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (32,3)-(32,9) = "[a, b]"
        │   ├── opening_loc: (32,3)-(32,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (32,4)-(32,17))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 3)
        │   │       ├── @ LocalVariableReadNode (location: (32,4)-(32,5))
        │   │       │   ├── name: :a
        │   │       │   └── depth: 0
        │   │       ├── @ LocalVariableReadNode (location: (32,7)-(32,8))
        │   │       │   ├── name: :b
        │   │       │   └── depth: 0
        │   │       └── @ CallNode (location: (32,12)-(32,17))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :value
        │   │           ├── message_loc: (32,12)-(32,17) = "value"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (32,8)-(32,9) = "]"
        │   └── block: ∅
        ├── @ CallNode (location: (33,0)-(33,18))
        │   ├── flags: attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (33,0)-(33,3))
        │   │   ├── name: :foo
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (33,3)-(33,10) = "[index]"
        │   ├── opening_loc: (33,3)-(33,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (33,4)-(33,18))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ CallNode (location: (33,4)-(33,9))
        │   │       │   ├── flags: variable_call, ignore_visibility
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── name: :index
        │   │       │   ├── message_loc: (33,4)-(33,9) = "index"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   └── block: ∅
        │   │       └── @ CallNode (location: (33,13)-(33,18))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :value
        │   │           ├── message_loc: (33,13)-(33,18) = "value"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (33,9)-(33,10) = "]"
        │   └── block: ∅
        ├── @ LocalVariableWriteNode (location: (34,0)-(34,7))
        │   ├── name: :x
        │   ├── depth: 0
        │   ├── name_loc: (34,0)-(34,1) = "x"
        │   ├── value:
        │   │   @ StringNode (location: (34,4)-(34,7))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (34,4)-(34,6) = "%("
        │   │   ├── content_loc: (34,6)-(34,6) = ""
        │   │   ├── closing_loc: (34,6)-(34,7) = ")"
        │   │   └── unescaped: ""
        │   └── operator_loc: (34,2)-(34,3) = "="
        ├── @ CallNode (location: (35,0)-(35,7))
        │   ├── flags: attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (35,0)-(35,1))
        │   │   ├── name: :x
        │   │   └── depth: 0
        │   ├── call_operator_loc: (35,1)-(35,2) = "."
        │   ├── name: :x=
        │   ├── message_loc: (35,2)-(35,3) = "x"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (35,4)-(35,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (35,4)-(35,7))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (35,4)-(35,6) = "%("
        │   │           ├── content_loc: (35,6)-(35,6) = ""
        │   │           ├── closing_loc: (35,6)-(35,7) = ")"
        │   │           └── unescaped: ""
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (36,0)-(36,12))
        │   ├── flags: attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (36,0)-(36,1))
        │   │   ├── name: :x
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (36,1)-(36,6) = "[%()]"
        │   ├── opening_loc: (36,1)-(36,2) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (36,2)-(36,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 2)
        │   │       ├── @ StringNode (location: (36,2)-(36,5))
        │   │       │   ├── flags: ∅
        │   │       │   ├── opening_loc: (36,2)-(36,4) = "%("
        │   │       │   ├── content_loc: (36,4)-(36,4) = ""
        │   │       │   ├── closing_loc: (36,4)-(36,5) = ")"
        │   │       │   └── unescaped: ""
        │   │       └── @ CallNode (location: (36,9)-(36,12))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (36,9)-(36,12) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (36,5)-(36,6) = "]"
        │   └── block: ∅
        ├── @ IndexOrWriteNode (location: (37,0)-(37,14))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (37,0)-(37,1))
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (37,1)-(37,2) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (37,2)-(37,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (37,2)-(37,5))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (37,2)-(37,4) = "%("
        │   │           ├── content_loc: (37,4)-(37,4) = ""
        │   │           ├── closing_loc: (37,4)-(37,5) = ")"
        │   │           └── unescaped: ""
        │   ├── closing_loc: (37,5)-(37,6) = "]"
        │   ├── block: ∅
        │   ├── operator_loc: (37,7)-(37,10) = "||="
        │   └── value:
        │       @ CallNode (location: (37,11)-(37,14))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :bar
        │       ├── message_loc: (37,11)-(37,14) = "bar"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        ├── @ InstanceVariableOrWriteNode (location: (38,0)-(38,10))
        │   ├── name: :@a
        │   ├── name_loc: (38,0)-(38,2) = "@a"
        │   ├── operator_loc: (38,3)-(38,6) = "||="
        │   └── value:
        │       @ StringNode (location: (38,7)-(38,10))
        │       ├── flags: ∅
        │       ├── opening_loc: (38,7)-(38,9) = "%("
        │       ├── content_loc: (38,9)-(38,9) = ""
        │       ├── closing_loc: (38,9)-(38,10) = ")"
        │       └── unescaped: ""
        ├── @ LocalVariableWriteNode (location: (39,0)-(39,14))
        │   ├── name: :x
        │   ├── depth: 0
        │   ├── name_loc: (39,0)-(39,1) = "x"
        │   ├── value:
        │   │   @ InterpolatedStringNode (location: (39,4)-(39,14))
        │   │   ├── flags: ∅
        │   │   ├── opening_loc: (39,4)-(39,14) = "<<-HEREDOC"
        │   │   ├── parts: (length: 3)
        │   │   │   ├── @ StringNode (location: (40,0)-(40,2))
        │   │   │   │   ├── flags: frozen
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── content_loc: (40,0)-(40,2) = "  "
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── unescaped: "  "
        │   │   │   ├── @ EmbeddedStatementsNode (location: (40,2)-(40,5))
        │   │   │   │   ├── opening_loc: (40,2)-(40,4) = "\#{"
        │   │   │   │   ├── statements: ∅
        │   │   │   │   └── closing_loc: (40,4)-(40,5) = "}"
        │   │   │   └── @ StringNode (location: (40,5)-(41,0))
        │   │   │       ├── flags: frozen
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (40,5)-(41,0) = "\n"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "\n"
        │   │   └── closing_loc: (41,0)-(42,0) = "HEREDOC\n"
        │   └── operator_loc: (39,2)-(39,3) = "="
        ├── @ CallNode (location: (42,0)-(42,14))
        │   ├── flags: attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (42,0)-(42,1))
        │   │   ├── name: :x
        │   │   └── depth: 0
        │   ├── call_operator_loc: (42,1)-(42,2) = "."
        │   ├── name: :x=
        │   ├── message_loc: (42,2)-(42,3) = "x"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (42,4)-(42,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (42,4)-(42,14))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (42,4)-(42,14) = "<<-HEREDOC"
        │   │           ├── parts: (length: 3)
        │   │           │   ├── @ StringNode (location: (43,0)-(43,2))
        │   │           │   │   ├── flags: frozen
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (43,0)-(43,2) = "  "
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "  "
        │   │           │   ├── @ EmbeddedStatementsNode (location: (43,2)-(43,5))
        │   │           │   │   ├── opening_loc: (43,2)-(43,4) = "\#{"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── closing_loc: (43,4)-(43,5) = "}"
        │   │           │   └── @ StringNode (location: (43,5)-(44,0))
        │   │           │       ├── flags: frozen
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (43,5)-(44,0) = "\n"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "\n"
        │   │           └── closing_loc: (44,0)-(45,0) = "HEREDOC\n"
        │   ├── closing_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (45,0)-(45,16))
        │   ├── flags: attribute_write
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (45,0)-(45,1))
        │   │   ├── name: :x
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]=
        │   ├── message_loc: (45,1)-(45,3) = "[]"
        │   ├── opening_loc: (45,1)-(45,2) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (45,6)-(45,16))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (45,6)-(45,16))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (45,6)-(45,16) = "<<-HEREDOC"
        │   │           ├── parts: (length: 3)
        │   │           │   ├── @ StringNode (location: (46,0)-(46,2))
        │   │           │   │   ├── flags: frozen
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (46,0)-(46,2) = "  "
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "  "
        │   │           │   ├── @ EmbeddedStatementsNode (location: (46,2)-(46,5))
        │   │           │   │   ├── opening_loc: (46,2)-(46,4) = "\#{"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── closing_loc: (46,4)-(46,5) = "}"
        │   │           │   └── @ StringNode (location: (46,5)-(47,0))
        │   │           │       ├── flags: frozen
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (46,5)-(47,0) = "\n"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "\n"
        │   │           └── closing_loc: (47,0)-(48,0) = "HEREDOC\n"
        │   ├── closing_loc: (45,2)-(45,3) = "]"
        │   └── block: ∅
        ├── @ IndexOrWriteNode (location: (48,0)-(48,21))
        │   ├── flags: ∅
        │   ├── receiver:
        │   │   @ LocalVariableReadNode (location: (48,0)-(48,1))
        │   │   ├── name: :a
        │   │   └── depth: 0
        │   ├── call_operator_loc: ∅
        │   ├── opening_loc: (48,1)-(48,2) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (48,2)-(48,12))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (48,2)-(48,12))
        │   │           ├── flags: ∅
        │   │           ├── opening_loc: (48,2)-(48,12) = "<<-HEREDOC"
        │   │           ├── parts: (length: 3)
        │   │           │   ├── @ StringNode (location: (49,0)-(49,2))
        │   │           │   │   ├── flags: frozen
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (49,0)-(49,2) = "  "
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "  "
        │   │           │   ├── @ EmbeddedStatementsNode (location: (49,2)-(49,5))
        │   │           │   │   ├── opening_loc: (49,2)-(49,4) = "\#{"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── closing_loc: (49,4)-(49,5) = "}"
        │   │           │   └── @ StringNode (location: (49,5)-(50,0))
        │   │           │       ├── flags: frozen
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (49,5)-(50,0) = "\n"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "\n"
        │   │           └── closing_loc: (50,0)-(51,0) = "HEREDOC\n"
        │   ├── closing_loc: (48,12)-(48,13) = "]"
        │   ├── block: ∅
        │   ├── operator_loc: (48,14)-(48,17) = "||="
        │   └── value:
        │       @ CallNode (location: (48,18)-(48,21))
        │       ├── flags: variable_call, ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :bar
        │       ├── message_loc: (48,18)-(48,21) = "bar"
        │       ├── opening_loc: ∅
        │       ├── arguments: ∅
        │       ├── closing_loc: ∅
        │       └── block: ∅
        └── @ InstanceVariableOrWriteNode (location: (51,0)-(51,17))
            ├── name: :@a
            ├── name_loc: (51,0)-(51,2) = "@a"
            ├── operator_loc: (51,3)-(51,6) = "||="
            └── value:
                @ InterpolatedStringNode (location: (51,7)-(51,17))
                ├── flags: ∅
                ├── opening_loc: (51,7)-(51,17) = "<<-HEREDOC"
                ├── parts: (length: 3)
                │   ├── @ StringNode (location: (52,0)-(52,2))
                │   │   ├── flags: frozen
                │   │   ├── opening_loc: ∅
                │   │   ├── content_loc: (52,0)-(52,2) = "  "
                │   │   ├── closing_loc: ∅
                │   │   └── unescaped: "  "
                │   ├── @ EmbeddedStatementsNode (location: (52,2)-(52,5))
                │   │   ├── opening_loc: (52,2)-(52,4) = "\#{"
                │   │   ├── statements: ∅
                │   │   └── closing_loc: (52,4)-(52,5) = "}"
                │   └── @ StringNode (location: (52,5)-(53,0))
                │       ├── flags: frozen
                │       ├── opening_loc: ∅
                │       ├── content_loc: (52,5)-(53,0) = "\n"
                │       ├── closing_loc: ∅
                │       └── unescaped: "\n"
                └── closing_loc: (53,0)-(54,0) = "HEREDOC\n"