First batch of ruby 4.0 backports

.github/workflows/cruby-bindings.yml

@@ -32,6 +32,7 @@ jobs:
         with:
           repository: ruby/ruby
           path: ruby/ruby
+          ref: ruby_4_0
           fetch-depth: 1
       - name: Install libraries
         run: |

config.yml

@@ -17,6 +17,8 @@ errors:
   - ARGUMENT_FORWARDING_UNBOUND
   - ARGUMENT_NO_FORWARDING_AMPERSAND
   - ARGUMENT_NO_FORWARDING_ELLIPSES
+  - ARGUMENT_NO_FORWARDING_ELLIPSES_LAMBDA
+  - ARGUMENT_NO_FORWARDING_ELLIPSES_BLOCK
   - ARGUMENT_NO_FORWARDING_STAR
   - ARGUMENT_NO_FORWARDING_STAR_STAR
   - ARGUMENT_SPLAT_AFTER_ASSOC_SPLAT

snapshots/4.0/leading_logical.txt

@@ -1,10 +1,10 @@
-@ ProgramNode (location: (1,0)-(21,5))
+@ ProgramNode (location: (1,0)-(15,4))
 ├── flags: ∅
 ├── locals: []
 └── statements:
-    @ StatementsNode (location: (1,0)-(21,5))
+    @ StatementsNode (location: (1,0)-(15,4))
     ├── flags: ∅
-    └── body: (length: 8)
+    └── body: (length: 4)
         ├── @ AndNode (location: (1,0)-(3,4))
         │   ├── flags: newline
         │   ├── left:
@@ -62,50 +62,22 @@
         │   │   ├── flags: static_literal, decimal
         │   │   └── value: 3
         │   └── operator_loc: (11,0)-(11,3) = "and"
-        ├── @ OrNode (location: (13,0)-(15,4))
-        │   ├── flags: newline
-        │   ├── left:
-        │   │   @ OrNode (location: (13,0)-(14,4))
-        │   │   ├── flags: ∅
-        │   │   ├── left:
-        │   │   │   @ IntegerNode (location: (13,0)-(13,1))
-        │   │   │   ├── flags: static_literal, decimal
-        │   │   │   └── value: 1
-        │   │   ├── right:
-        │   │   │   @ IntegerNode (location: (14,3)-(14,4))
-        │   │   │   ├── flags: static_literal, decimal
-        │   │   │   └── value: 2
-        │   │   └── operator_loc: (14,0)-(14,2) = "or"
-        │   ├── right:
-        │   │   @ IntegerNode (location: (15,3)-(15,4))
-        │   │   ├── flags: static_literal, decimal
-        │   │   └── value: 3
-        │   └── operator_loc: (15,0)-(15,2) = "or"
-        ├── @ IntegerNode (location: (17,0)-(17,1))
-        │   ├── flags: newline, static_literal, decimal
-        │   └── value: 1
-        ├── @ CallNode (location: (18,0)-(18,6))
-        │   ├── flags: newline, variable_call, ignore_visibility
-        │   ├── receiver: ∅
-        │   ├── call_operator_loc: ∅
-        │   ├── name: :andfoo
-        │   ├── message_loc: (18,0)-(18,6) = "andfoo"
-        │   ├── opening_loc: ∅
-        │   ├── arguments: ∅
-        │   ├── closing_loc: ∅
-        │   ├── equal_loc: ∅
-        │   └── block: ∅
-        ├── @ IntegerNode (location: (20,0)-(20,1))
-        │   ├── flags: newline, static_literal, decimal
-        │   └── value: 2
-        └── @ CallNode (location: (21,0)-(21,5))
-            ├── flags: newline, variable_call, ignore_visibility
-            ├── receiver: ∅
-            ├── call_operator_loc: ∅
-            ├── name: :orfoo
-            ├── message_loc: (21,0)-(21,5) = "orfoo"
-            ├── opening_loc: ∅
-            ├── arguments: ∅
-            ├── closing_loc: ∅
-            ├── equal_loc: ∅
-            └── block: ∅
+        └── @ OrNode (location: (13,0)-(15,4))
+            ├── flags: newline
+            ├── left:
+            │   @ OrNode (location: (13,0)-(14,4))
+            │   ├── flags: ∅
+            │   ├── left:
+            │   │   @ IntegerNode (location: (13,0)-(13,1))
+            │   │   ├── flags: static_literal, decimal
+            │   │   └── value: 1
+            │   ├── right:
+            │   │   @ IntegerNode (location: (14,3)-(14,4))
+            │   │   ├── flags: static_literal, decimal
+            │   │   └── value: 2
+            │   └── operator_loc: (14,0)-(14,2) = "or"
+            ├── right:
+            │   @ IntegerNode (location: (15,3)-(15,4))
+            │   ├── flags: static_literal, decimal
+            │   └── value: 3
+            └── operator_loc: (15,0)-(15,2) = "or"

snapshots/and_or_with_suffix.txt

@@ -0,0 +1,139 @@
+@ ProgramNode (location: (1,0)-(17,5))
+├── flags: ∅
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (1,0)-(17,5))
+    ├── flags: ∅
+    └── body: (length: 12)
+        ├── @ CallNode (location: (1,0)-(1,3))
+        │   ├── flags: newline, variable_call, ignore_visibility
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── name: :foo
+        │   ├── message_loc: (1,0)-(1,3) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── block: ∅
+        ├── @ CallNode (location: (2,0)-(2,4))
+        │   ├── flags: newline, ignore_visibility
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── name: :and?
+        │   ├── message_loc: (2,0)-(2,4) = "and?"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── block: ∅
+        ├── @ CallNode (location: (4,0)-(4,3))
+        │   ├── flags: newline, variable_call, ignore_visibility
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── name: :foo
+        │   ├── message_loc: (4,0)-(4,3) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── block: ∅
+        ├── @ CallNode (location: (5,0)-(5,3))
+        │   ├── flags: newline, ignore_visibility
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── name: :or?
+        │   ├── message_loc: (5,0)-(5,3) = "or?"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── block: ∅
+        ├── @ CallNode (location: (7,0)-(7,3))
+        │   ├── flags: newline, variable_call, ignore_visibility
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── name: :foo
+        │   ├── message_loc: (7,0)-(7,3) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── block: ∅
+        ├── @ CallNode (location: (8,0)-(8,4))
+        │   ├── flags: newline, ignore_visibility
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── name: :and!
+        │   ├── message_loc: (8,0)-(8,4) = "and!"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── block: ∅
+        ├── @ CallNode (location: (10,0)-(10,3))
+        │   ├── flags: newline, variable_call, ignore_visibility
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── name: :foo
+        │   ├── message_loc: (10,0)-(10,3) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── block: ∅
+        ├── @ CallNode (location: (11,0)-(11,3))
+        │   ├── flags: newline, ignore_visibility
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── name: :or!
+        │   ├── message_loc: (11,0)-(11,3) = "or!"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── block: ∅
+        ├── @ CallNode (location: (13,0)-(13,3))
+        │   ├── flags: newline, variable_call, ignore_visibility
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── name: :foo
+        │   ├── message_loc: (13,0)-(13,3) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── block: ∅
+        ├── @ CallNode (location: (14,0)-(14,6))
+        │   ├── flags: newline, variable_call, ignore_visibility
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── name: :andbar
+        │   ├── message_loc: (14,0)-(14,6) = "andbar"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── block: ∅
+        ├── @ CallNode (location: (16,0)-(16,3))
+        │   ├── flags: newline, variable_call, ignore_visibility
+        │   ├── receiver: ∅
+        │   ├── call_operator_loc: ∅
+        │   ├── name: :foo
+        │   ├── message_loc: (16,0)-(16,3) = "foo"
+        │   ├── opening_loc: ∅
+        │   ├── arguments: ∅
+        │   ├── closing_loc: ∅
+        │   ├── equal_loc: ∅
+        │   └── block: ∅
+        └── @ CallNode (location: (17,0)-(17,5))
+            ├── flags: newline, variable_call, ignore_visibility
+            ├── receiver: ∅
+            ├── call_operator_loc: ∅
+            ├── name: :orbar
+            ├── message_loc: (17,0)-(17,5) = "orbar"
+            ├── opening_loc: ∅
+            ├── arguments: ∅
+            ├── closing_loc: ∅
+            ├── equal_loc: ∅
+            └── block: ∅

snapshots/case_in_in.txt

@@ -0,0 +1,81 @@
+@ ProgramNode (location: (1,0)-(4,3))
+├── flags: ∅
+├── locals: [:event]
+└── statements:
+    @ StatementsNode (location: (1,0)-(4,3))
+    ├── flags: ∅
+    └── body: (length: 1)
+        └── @ CaseMatchNode (location: (1,0)-(4,3))
+            ├── flags: newline
+            ├── predicate:
+            │   @ CallNode (location: (1,5)-(1,9))
+            │   ├── flags: variable_call, ignore_visibility
+            │   ├── receiver: ∅
+            │   ├── call_operator_loc: ∅
+            │   ├── name: :args
+            │   ├── message_loc: (1,5)-(1,9) = "args"
+            │   ├── opening_loc: ∅
+            │   ├── arguments: ∅
+            │   ├── closing_loc: ∅
+            │   ├── equal_loc: ∅
+            │   └── block: ∅
+            ├── conditions: (length: 1)
+            │   └── @ InNode (location: (2,0)-(3,25))
+            │       ├── flags: ∅
+            │       ├── pattern:
+            │       │   @ ArrayPatternNode (location: (2,3)-(2,10))
+            │       │   ├── flags: ∅
+            │       │   ├── constant: ∅
+            │       │   ├── requireds: (length: 1)
+            │       │   │   └── @ LocalVariableTargetNode (location: (2,4)-(2,9))
+            │       │   │       ├── flags: ∅
+            │       │   │       ├── name: :event
+            │       │   │       └── depth: 0
+            │       │   ├── rest: ∅
+            │       │   ├── posts: (length: 0)
+            │       │   ├── opening_loc: (2,3)-(2,4) = "["
+            │       │   └── closing_loc: (2,9)-(2,10) = "]"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (3,2)-(3,25))
+            │       │   ├── flags: ∅
+            │       │   └── body: (length: 1)
+            │       │       └── @ MatchPredicateNode (location: (3,2)-(3,25))
+            │       │           ├── flags: newline
+            │       │           ├── value:
+            │       │           │   @ CallNode (location: (3,2)-(3,15))
+            │       │           │   ├── flags: ∅
+            │       │           │   ├── receiver:
+            │       │           │   │   @ CallNode (location: (3,2)-(3,9))
+            │       │           │   │   ├── flags: variable_call, ignore_visibility
+            │       │           │   │   ├── receiver: ∅
+            │       │           │   │   ├── call_operator_loc: ∅
+            │       │           │   │   ├── name: :context
+            │       │           │   │   ├── message_loc: (3,2)-(3,9) = "context"
+            │       │           │   │   ├── opening_loc: ∅
+            │       │           │   │   ├── arguments: ∅
+            │       │           │   │   ├── closing_loc: ∅
+            │       │           │   │   ├── equal_loc: ∅
+            │       │           │   │   └── block: ∅
+            │       │           │   ├── call_operator_loc: (3,9)-(3,10) = "."
+            │       │           │   ├── name: :event
+            │       │           │   ├── message_loc: (3,10)-(3,15) = "event"
+            │       │           │   ├── opening_loc: ∅
+            │       │           │   ├── arguments: ∅
+            │       │           │   ├── closing_loc: ∅
+            │       │           │   ├── equal_loc: ∅
+            │       │           │   └── block: ∅
+            │       │           ├── pattern:
+            │       │           │   @ PinnedVariableNode (location: (3,19)-(3,25))
+            │       │           │   ├── flags: ∅
+            │       │           │   ├── variable:
+            │       │           │   │   @ LocalVariableReadNode (location: (3,20)-(3,25))
+            │       │           │   │   ├── flags: ∅
+            │       │           │   │   ├── name: :event
+            │       │           │   │   └── depth: 0
+            │       │           │   └── operator_loc: (3,19)-(3,20) = "^"
+            │       │           └── operator_loc: (3,16)-(3,18) = "in"
+            │       ├── in_loc: (2,0)-(2,2) = "in"
+            │       └── then_loc: ∅
+            ├── else_clause: ∅
+            ├── case_keyword_loc: (1,0)-(1,4) = "case"
+            └── end_keyword_loc: (4,0)-(4,3) = "end"