Update notes in YAML fixtures added for assignment operators

Author: andrykonchin

spec/truffle/parsing/fixtures/operators/&&=/attribute_assignment_with_explicit_self_receiver.yaml

@@ -1,12 +1,10 @@
 subject: "&&="
 description: "Assign attribute with explicit self receiver (self.b &&= c)"
 notes: >
-  `a.b &&= c` is translated into `a.b && a.b = c` in the following way:
+  Method call when receiver is `self` means a private or protected method could be successfully called.
   
-  ```ruby
-  value_0 = a # execute receiver only once
-  value_0.b && value_0.b=(c)
-  ```
+  In AST it's represented with RubyCallNode's field dispatchConfig.
+  `dispatchConfig = PRIVATE` means a method visibility is ignored.
 focused_on_node: "org.truffleruby.language.defined.DefinedWrapperNode"
 ruby: |
   self.foo &&= 42

spec/truffle/parsing/fixtures/operators/&&=/attribute_assignment_with_safe_navigation_operator.yaml

@@ -1,12 +1,22 @@
 subject: "&&="
 description: "Assign attribute with safe navigation operator (a&.b &&= c)"
 notes: >
-  `a.b &&= c` is translated into `a.b && a.b = c` in the following way:
+  Safe navigation means `nil` is returned when a not supported method is called on `nil`.
   
-  ```ruby
-  value_0 = a # execute receiver only once
-  value_0.b && value_0.b=(c)
-  ```
+  So actual code looks like:
+    ```ruby
+    if receiver == nil
+      return nil
+    else
+      ...
+    end
+    ```
+  
+  This is implemented with the following AST:
+    (UnlessNodeGen
+      (IsNilNode
+        (ReadLocalVariableNode)) # %value_0
+      (AndNodeGen ...))
 focused_on_node: "org.truffleruby.language.defined.DefinedWrapperNode"
 ruby: |
   a&.foo &&= 42

spec/truffle/parsing/fixtures/operators/&&=/reference_assignment_with_block_argument.yaml

@@ -1,14 +1,8 @@
 subject: "&&="
 description: "Assign an referenced element with block argument (a[&b] &&= c)"
 notes: >
-  `a[b] &&= c` is translated into `a[b] && a[b] = c` in the following way:
-  
-  ```ruby
-  value_1 = b
-  opelementassign_0 = a
-  
-  opelementassign_0[value_1] && opelementassign_0[value_1] = c
-  ```
+  A block argument should be stored in RubyCallNode#block field and not in
+  a #arguments field with positional ones.
 yarp_specific: true # wasn't supported
 focused_on_node: "org.truffleruby.language.control.SequenceNode"
 ruby: |

spec/truffle/parsing/fixtures/operators/&&=/reference_assignment_with_explicit_self_receiver.yaml

@@ -1,14 +1,10 @@
 subject: "&&="
 description: "Assign an referenced element with explicit self receiver (self[a] &&= b)"
 notes: >
-  `a[b] &&= c` is translated into `a[b] && a[b] = c` in the following way:
+  Method call when receiver is `self` means a private or protected method could be successfully called.
   
-  ```ruby
-  temp_arg1 = b
-  temp_receiver = a
-  
-  temp_receiver[temp_arg1] && temp_receiver[temp_arg1] = c
-  ```
+  In AST it's represented with RubyCallNode's field dispatchConfig.
+  `dispatchConfig = PRIVATE` means a method visibility is ignored.
 yarp_specific: true # don't put self into a local variable and fixed call node and set ignoreVisibility=true
 focused_on_node: "org.truffleruby.language.control.SequenceNode"
 ruby: |

spec/truffle/parsing/fixtures/operators/&&=/reference_assignment_with_multiple_indexes.yaml

@@ -1,16 +1,7 @@
 subject: "&&="
 description: "Assign an element referenced with multiple indexes (a[b, c, d] &&= e)"
 notes: >
-  `a[b, c, d] &&= e` is translated into `a[b, c, d] && a[b, c, d] = e` in the following way:
-  
-  ```ruby
-  temp_arg1 = b
-  temp_arg2 = c
-  temp_arg3 = d
-  temp_receiver = a
-  
-  temp_receiver[temp_arg1] && temp_receiver[temp_arg1] = c
-  ```
+  All the arguments should be assigned to local variables to evaluate them only once.
 focused_on_node: "org.truffleruby.language.control.SequenceNode"
 ruby: |
   foo[42, 43, 44] &&= 100500

spec/truffle/parsing/fixtures/operators/&&=/reference_assignment_with_nested_splatted_argument.yaml

@@ -1,18 +1,9 @@
 subject: "&&="
 description: "Assign an element referenced with nested splatted argument (a[*[*b]] &&= c)"
 notes: >
-  `a[b, c, d] &&= e` is translated into `a[b, c, d] && a[b, c, d] = e` in the following way:
-  
-  ```ruby
-  temp_arg1 = b
-  temp_arg2 = c
-  temp_arg3 = d
-  temp_receiver = a
-  
-  temp_receiver[temp_arg1] && temp_receiver[temp_arg1] = c
-  ```
+  Nested * operator shouldn't be desugared
 yarp_specific: true # don't desugar [*a] to a and put only one SplatCastNodeGen to call #to_a only once
-                    # Simplified AST of `foo.[](*[*a], 100500)` and replaced ArrayAppendOneNodeGen by concatenating with array of one element
+                    # Simplified AST of `foo.[]=(*[*a], 100500)` and replaced ArrayAppendOneNodeGen by concatenating with array of one element
 focused_on_node: "org.truffleruby.language.control.SequenceNode"
 ruby: |
   foo[*[*a]] &&= 100500

spec/truffle/parsing/fixtures/operators/&&=/reference_assignment_with_splatted_argument.yaml

@@ -1,17 +1,16 @@
 subject: "&&="
 description: "Assign an element referenced with splatted argument (a[*b] &&= c)"
 notes: >
-  `a[b, c, d] &&= e` is translated into `a[b, c, d] && a[b, c, d] = e` in the following way:
+  Splatting should be specified explicitly for `[]` and `[]=` method calls.
   
+  So `foo[*a] &&= 100500` is desugared into:
   ```ruby
-  temp_arg1 = b
-  temp_arg2 = c
-  temp_arg3 = d
-  temp_receiver = a
+  receiver = foo
+  argument0 = a
   
-  temp_receiver[temp_arg1] && temp_receiver[temp_arg1] = c
+  receiver.[](*argument0) && receiver.[]=(*argument0, 100500)
   ```
-yarp_specific: true # Simplified AST of `foo.[](*a, 100500)` and replaced ArrayAppendOneNodeGen by concatenating with array of one element
+yarp_specific: true # Simplified AST of `foo.[]=(*a, 100500)` and replaced ArrayAppendOneNodeGen by concatenating with array of one element
 focused_on_node: "org.truffleruby.language.control.SequenceNode"
 ruby: |
   foo[*a] &&= 100500

spec/truffle/parsing/fixtures/operators/+=/attribute_assignment_with_explicit_self_receiver.yaml

@@ -1,12 +1,10 @@
 subject: "+="
 description: "Assign attribute with explicit self receiver (self.b += c)"
 notes: >
-  `a.b += c` is translated into `a.b = a.b + c` in the following way:
-
-  ```ruby
-  temp_receiver = a
-  temp_receiver.b = temp_receiver.b + c
-  ```
+  Method call when receiver is `self` means a private or protected method could be successfully called.
+  
+  In AST it's represented with RubyCallNode's field dispatchConfig.
+  `dispatchConfig = PRIVATE` means a method visibility is ignored.
 yarp_specific: true # fixed assigning method call node and set `isAttrAssign = true`
 focused_on_node: "org.truffleruby.language.control.SequenceNode"
 ruby: |

spec/truffle/parsing/fixtures/operators/+=/attribute_assignment_with_safe_navigation_operator.yaml

@@ -1,12 +1,22 @@
 subject: "+="
 description: "Assign attribute with safe navigation operator (a&.b += c)"
 notes: >
-  `a&.b += c` is translated into `a.b = a.b + c` in the following way:
-
-  ```ruby
-  value_0 = a
-  value_0.b = value_0.b + c
-  ```
+  Safe navigation means `nil` is returned when a not supported method is called on `nil`.
+  
+  So actual code looks like:
+    ```ruby
+    if receiver == nil
+      return nil
+    else
+      ...
+    end
+    ```
+  
+  This is implemented with the following AST:
+    (UnlessNodeGen
+      (IsNilNode
+        (ReadLocalVariableNode)) # %value_0
+      (RubyCallNode ...))
 yarp_specific: true # fixed assigning method call node and set `isAttrAssign = true`
 focused_on_node: "org.truffleruby.language.control.SequenceNode"
 ruby: |

spec/truffle/parsing/fixtures/operators/+=/reference_assignment_with_block_argument.yaml

@@ -1,14 +1,8 @@
 subject: "+="
 description: "Assign a referenced element with block argument (a[&b] += c)"
 notes: >
-  `a[b] += c` is translated into `a[b] = a[b] + c` in the following way:
-
-  ```ruby
-  value_1 = b
-  opelementassign_0 = a
-
-  opelementassign_0[value_1] = opelementassign_0[value_1] + c
-  ```
+  A block argument should be stored in RubyCallNode#block field and not in
+  a #arguments field with positional ones.
 yarp_specific: true # wasn't supported
 focused_on_node: "org.truffleruby.language.control.SequenceNode"
 ruby: |