rubinius-melbourne 2.1.0.0 → 2.2.0.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (33) hide show
  1. checksums.yaml +4 -4
  2. data/Rakefile +1 -1
  3. data/ext/rubinius/melbourne/extconf.rb +4 -13
  4. data/ext/rubinius/melbourne/grammar.cpp +4788 -4044
  5. data/ext/rubinius/melbourne/grammar.y +919 -485
  6. data/ext/rubinius/melbourne/melbourne.cpp +3 -8
  7. data/ext/rubinius/melbourne/node.hpp +25 -1
  8. data/ext/rubinius/melbourne/node_types.cpp +74 -66
  9. data/ext/rubinius/melbourne/node_types.hpp +5 -1
  10. data/ext/rubinius/melbourne/node_types.rb +5 -0
  11. data/ext/rubinius/melbourne/parser_state.hpp +40 -15
  12. data/ext/rubinius/melbourne/symbols.cpp +6 -0
  13. data/ext/rubinius/melbourne/symbols.hpp +3 -0
  14. data/ext/rubinius/melbourne/visitor.cpp +75 -52
  15. data/lib/rubinius/melbourne/version.rb +2 -2
  16. data/lib/rubinius/melbourne.rb +2 -2
  17. data/rubinius-melbourne.gemspec +1 -4
  18. data/spec/array_spec.rb +20 -0
  19. data/spec/custom/matchers/parse_as.rb +2 -1
  20. data/spec/defn_spec.rb +556 -265
  21. data/spec/defs_spec.rb +63 -40
  22. data/spec/dstr_spec.rb +1 -2
  23. data/spec/ensure_spec.rb +12 -8
  24. data/spec/flip2_spec.rb +38 -2
  25. data/spec/hash_spec.rb +47 -0
  26. data/spec/iter_spec.rb +371 -244
  27. data/spec/lambda_spec.rb +107 -0
  28. data/spec/lit_spec.rb +16 -0
  29. data/spec/masgn_spec.rb +97 -301
  30. data/spec/rescue_spec.rb +12 -6
  31. data/spec/spec_helper.rb +6 -7
  32. data/spec/while_spec.rb +9 -6
  33. metadata +4 -16
data/spec/defs_spec.rb CHANGED
@@ -1,73 +1,96 @@
1
1
  describe "A Defs node" do
2
2
  parse <<-ruby do
3
- def self.x(y)
4
- (y + 1)
5
- end
3
+ def self.m() end
6
4
  ruby
7
5
 
8
- [:defs,
9
- [:self],
10
- :x,
11
- [:args, :y],
12
- [:scope, [:block, [:call, [:lvar, :y], :+, [:arglist, [:lit, 1]]]]]]
6
+ [:defs, [:self], :m, [:args], [:scope, [:block, [:nil]]]]
13
7
  end
14
8
 
15
9
  parse <<-ruby do
16
- def self.setup(ctx)
17
- bind = allocate
18
- bind.context = ctx
19
- return bind
20
- end
10
+ a = ""
11
+ def a.m() end
21
12
  ruby
22
13
 
23
- [:defs,
24
- [:self],
25
- :setup,
26
- [:args, :ctx],
27
- [:scope,
28
- [:block,
29
- [:lasgn, :bind, [:call, nil, :allocate, [:arglist]]],
30
- [:attrasgn, [:lvar, :bind], :context=, [:arglist, [:lvar, :ctx]]],
31
- [:return, [:lvar, :bind]]]]]
14
+ [:block,
15
+ [:lasgn, :a, [:str, ""]],
16
+ [:defs, [:lvar, :a], :m, [:args], [:scope, [:block, [:nil]]]]]
32
17
  end
33
18
 
34
19
  parse <<-ruby do
35
- def self.empty(*)
36
- end
20
+ a = ""
21
+ def (a.b).m() end
37
22
  ruby
38
23
 
39
- [:defs, [:self], :empty, [:args, :*], [:scope, [:block, [:nil]]]]
24
+ [:block,
25
+ [:lasgn, :a, [:str, ""]],
26
+ [:defs,
27
+ [:call, [:lvar, :a], :b, [:arglist]],
28
+ :m,
29
+ [:args],
30
+ [:scope, [:block, [:nil]]]]]
40
31
  end
41
32
 
42
33
  parse <<-ruby do
43
- def self.empty
44
- end
34
+ def x.m(a=1, (b, (c, *d), *e)) end
45
35
  ruby
46
36
 
47
- [:defs, [:self], :empty, [:args], [:scope, [:block, [:nil]]]]
37
+ [:defs,
38
+ [:call, nil, :x, [:arglist]],
39
+ :m,
40
+ [:args,
41
+ :a,
42
+ [:masgn,
43
+ [:array,
44
+ [:lasgn, :b],
45
+ [:masgn, [:array, [:lasgn, :c], [:splat, [:lasgn, :d]]]],
46
+ [:splat, [:lasgn, :e]]],
47
+ [:lvar, :"_:1"]],
48
+ [:block, [:lasgn, :a, [:lit, 1]]]],
49
+ [:scope, [:block, [:nil]]]]
48
50
  end
49
51
 
50
52
  parse <<-ruby do
51
- def (a.b).empty(*)
52
- end
53
+ def x.m(a, b=1, *c, d, e:, f: 2, g:, **k, &l) end
53
54
  ruby
54
55
 
55
56
  [:defs,
56
- [:call, [:call, nil, :a, [:arglist]], :b, [:arglist]],
57
- :empty,
58
- [:args, :*],
57
+ [:call, nil, :x, [:arglist]],
58
+ :m,
59
+ [:args,
60
+ :a,
61
+ :b,
62
+ :"*c",
63
+ :d,
64
+ :e,
65
+ :f,
66
+ :g,
67
+ :"**k",
68
+ :"&l",
69
+ [:block, [:lasgn, :b, [:lit, 1]]],
70
+ [:block, [:e, :f, :g, :"**k"], [[:lasgn, :f, [:lit, 2]]]]],
59
71
  [:scope, [:block, [:nil]]]]
60
72
  end
61
73
 
62
74
  parse <<-ruby do
63
- x = "a"
64
- def x.m(a)
65
- a
66
- end
75
+ def x.m a, b=1, *c, d, e:, f: 2, g:, **k, &l
76
+ end
67
77
  ruby
68
78
 
69
- [:block,
70
- [:lasgn, :x, [:str, "a"]],
71
- [:defs, [:lvar, :x], :m, [:args, :a], [:scope, [:block, [:lvar, :a]]]]]
79
+ [:defs,
80
+ [:call, nil, :x, [:arglist]],
81
+ :m,
82
+ [:args,
83
+ :a,
84
+ :b,
85
+ :"*c",
86
+ :d,
87
+ :e,
88
+ :f,
89
+ :g,
90
+ :"**k",
91
+ :"&l",
92
+ [:block, [:lasgn, :b, [:lit, 1]]],
93
+ [:block, [:e, :f, :g, :"**k"], [[:lasgn, :f, [:lit, 2]]]]],
94
+ [:scope, [:block, [:nil]]]]
72
95
  end
73
96
  end
data/spec/dstr_spec.rb CHANGED
@@ -52,8 +52,7 @@ describe "A Dstr node" do
52
52
  [:dstr,
53
53
  "",
54
54
  [:evstr, [:lit, 22]],
55
- [:str, "aa"],
56
- [:str, "cd"],
55
+ [:str, "aacd"],
57
56
  [:evstr, [:lit, 44]],
58
57
  [:str, "55"],
59
58
  [:evstr, [:lit, 66]]]
data/spec/ensure_spec.rb CHANGED
@@ -60,20 +60,20 @@ describe "An Ensure node" do
60
60
 
61
61
  parse <<-ruby do
62
62
  begin
63
- 14
63
+ a = 14
64
64
  return 2
65
65
  ensure
66
66
  13
67
67
  end
68
68
  ruby
69
69
 
70
- [:ensure, [:block, [:lit, 14], [:return, [:lit, 2]]], [:lit, 13]]
70
+ [:ensure, [:block, [:lasgn, :a, [:lit, 14]], [:return, [:lit, 2]]], [:lit, 13]]
71
71
  end
72
72
 
73
73
  parse <<-ruby do
74
74
  begin
75
75
  begin
76
- 14
76
+ a = 14
77
77
  return 2
78
78
  ensure
79
79
  13
@@ -84,17 +84,19 @@ describe "An Ensure node" do
84
84
  ruby
85
85
 
86
86
  [:ensure,
87
- [:ensure, [:block, [:lit, 14], [:return, [:lit, 2]]], [:lit, 13]],
87
+ [:ensure,
88
+ [:block, [:lasgn, :a, [:lit, 14]], [:return, [:lit, 2]]],
89
+ [:lit, 13]],
88
90
  [:lit, 15]]
89
91
  end
90
92
 
91
93
  parse <<-ruby do
92
94
  begin
93
- 14
95
+ a = 14
94
96
  return 2
95
97
  ensure
96
98
  begin
97
- 15
99
+ b = 15
98
100
  return 3
99
101
  ensure
100
102
  16
@@ -103,7 +105,9 @@ describe "An Ensure node" do
103
105
  ruby
104
106
 
105
107
  [:ensure,
106
- [:block, [:lit, 14], [:return, [:lit, 2]]],
107
- [:ensure, [:block, [:lit, 15], [:return, [:lit, 3]]], [:lit, 16]]]
108
+ [:block, [:lasgn, :a, [:lit, 14]], [:return, [:lit, 2]]],
109
+ [:ensure,
110
+ [:block, [:lasgn, :b, [:lit, 15]], [:return, [:lit, 3]]],
111
+ [:lit, 16]]]
108
112
  end
109
113
  end
data/spec/flip2_spec.rb CHANGED
@@ -1,6 +1,6 @@
1
1
  describe "A Flip2 node" do
2
2
  parse <<-ruby do
3
- x = if ((i % 4) == 0)..((i % 3) == 0) then
3
+ x = if ((i % 4) == 0)..((i % 3) == 0)
4
4
  i
5
5
  else
6
6
  nil
@@ -24,7 +24,7 @@ describe "A Flip2 node" do
24
24
  end
25
25
 
26
26
  parse <<-ruby do
27
- if 1..2.a?(b) then
27
+ if 1..2.a?(b)
28
28
  nil
29
29
  end
30
30
  ruby
@@ -36,4 +36,40 @@ describe "A Flip2 node" do
36
36
  [:nil],
37
37
  nil]
38
38
  end
39
+
40
+ parse <<-ruby do
41
+ x, y = 1, 2
42
+ if x..y.a?(b)
43
+ nil
44
+ end
45
+ ruby
46
+
47
+ [:block,
48
+ [:masgn,
49
+ [:array, [:lasgn, :x], [:lasgn, :y]],
50
+ [:array, [:lit, 1], [:lit, 2]]],
51
+ [:if,
52
+ [:flip2,
53
+ [:lvar, :x],
54
+ [:call, [:lvar, :y], :a?, [:arglist, [:call, nil, :b, [:arglist]]]]],
55
+ [:nil],
56
+ nil]]
57
+ end
58
+
59
+ parse <<-ruby do
60
+ if x..y.a?(b)
61
+ nil
62
+ end
63
+ ruby
64
+
65
+ [:if,
66
+ [:flip2,
67
+ [:call, nil, :x, [:arglist]],
68
+ [:call,
69
+ [:call, nil, :y, [:arglist]],
70
+ :a?,
71
+ [:arglist, [:call, nil, :b, [:arglist]]]]],
72
+ [:nil],
73
+ nil]
74
+ end
39
75
  end
data/spec/hash_spec.rb CHANGED
@@ -24,4 +24,51 @@ describe "A Hash node" do
24
24
  [:lasgn, :a, [:lit, 1]],
25
25
  [:hash, [:lit, :a], [:lvar, :a]]]
26
26
  end
27
+
28
+ parse <<-ruby do
29
+ { **{ a: 1, b: 2 }, b: 2 }
30
+ ruby
31
+
32
+ [:hash,
33
+ [:hash_splat],
34
+ [:hash, [:lit, :a], [:lit, 1], [:lit, :b], [:lit, 2]],
35
+ [:lit, :b],
36
+ [:lit, 2]]
37
+ end
38
+
39
+ parse <<-ruby do
40
+ { a: 1, **{ b: 2 }, c: 3 }
41
+ ruby
42
+
43
+ [:hash,
44
+ [:lit, :a],
45
+ [:lit, 1],
46
+ [:hash_splat],
47
+ [:hash, [:lit, :b], [:lit, 2]],
48
+ [:lit, :c],
49
+ [:lit, 3]]
50
+ end
51
+
52
+ parse <<-ruby do
53
+ h = { a: 1 }
54
+ { b: 2, **h }
55
+ ruby
56
+
57
+ [:block,
58
+ [:lasgn, :h, [:hash, [:lit, :a], [:lit, 1]]],
59
+ [:hash, [:lit, :b], [:lit, 2], [:hash_splat], [:lvar, :h]]]
60
+ end
61
+
62
+ parse <<-ruby do
63
+ { a: 1, **h, c: 3 }
64
+ ruby
65
+
66
+ [:hash,
67
+ [:lit, :a],
68
+ [:lit, 1],
69
+ [:hash_splat],
70
+ [:call, nil, :h, [:arglist]],
71
+ [:lit, :c],
72
+ [:lit, 3]]
73
+ end
27
74
  end
data/spec/iter_spec.rb CHANGED
@@ -11,501 +11,637 @@ describe "An Iter node" do
11
11
  [:call, nil, :m, [:arglist, [:iter, [:args], [:call, nil, :x, [:arglist]]]]]
12
12
  end
13
13
 
14
- parse "m { || x }" do
15
- [:call, nil, :m, [:arglist, [:iter, [:args], [:call, nil, :x, [:arglist]]]]]
14
+ parse "m { || }" do
15
+ [:call, nil, :m, [:arglist, [:iter, [:args], [:nil]]]]
16
+ end
17
+
18
+ parse "m { |; x| }" do
19
+ [:call, nil, :m, [:arglist, [:iter, [:args], [:nil]]]]
20
+ end
21
+
22
+ parse "m { |; x, y| x - y + z }" do
23
+ [:call,
24
+ nil,
25
+ :m,
26
+ [:arglist, [:iter, [:args], [:block, [[:lvar, :x], [:lvar, :y]]]]]]
27
+ end
28
+
29
+ parse "m { |a| }" do
30
+ [:call, nil, :m, [:arglist, [:iter, [:args, :a], [:nil]]]]
16
31
  end
17
32
 
18
- parse "m { |a| a + x }" do
33
+ parse "m { |a, (b, c)| }" do
19
34
  [:call,
20
35
  nil,
21
36
  :m,
22
37
  [:arglist,
23
38
  [:iter,
24
- [:args, :a],
25
- [:call, [:lvar, :a], :+, [:arglist, [:call, nil, :x, [:arglist]]]]]]]
39
+ [:args,
40
+ :a,
41
+ [:masgn, [:array, [:lasgn, :b], [:lasgn, :c]], [:lvar, :"_:1"]]],
42
+ [:nil]]]]
26
43
  end
27
44
 
28
- parse "m { |*| x }" do
45
+ parse "m { |a; x| }" do
46
+ [:call, nil, :m, [:arglist, [:iter, [:args, :a], [:block, [[:lvar, :x]]]]]]
47
+ end
48
+
49
+ parse "m { |a=1| }" do
29
50
  [:call,
30
51
  nil,
31
52
  :m,
32
- [:arglist, [:iter, [:args, :*], [:call, nil, :x, [:arglist]]]]]
53
+ [:arglist, [:iter, [:args, :a, [:block, [:lasgn, :a, [:lit, 1]]]], [:nil]]]]
33
54
  end
34
55
 
35
- parse "m { |*c| x; c }" do
56
+ parse "m { |a=1, (b, (c, *d), *e)| }" do
36
57
  [:call,
37
58
  nil,
38
59
  :m,
39
60
  [:arglist,
40
61
  [:iter,
41
- [:args, :"*c"],
42
- [:block, [:call, nil, :x, [:arglist]], [:lvar, :c]]]]]
62
+ [:args,
63
+ :a,
64
+ [:masgn,
65
+ [:array,
66
+ [:lasgn, :b],
67
+ [:masgn, [:array, [:lasgn, :c], [:splat, [:lasgn, :d]]]],
68
+ [:splat, [:lasgn, :e]]],
69
+ [:lvar, :"_:1"]],
70
+ [:block, [:lasgn, :a, [:lit, 1]]]],
71
+ [:nil]]]]
43
72
  end
44
73
 
45
- parse "m { |a, | a + x }" do
74
+ parse "m { |a=1; x| }" do
46
75
  [:call,
47
76
  nil,
48
77
  :m,
49
78
  [:arglist,
50
79
  [:iter,
51
- [:args, :a],
52
- [:call, [:lvar, :a], :+, [:arglist, [:call, nil, :x, [:arglist]]]]]]]
80
+ [:args, :a, [:block, [:lasgn, :a, [:lit, 1]]]],
81
+ [:block, [[:lvar, :x]]]]]]
82
+ end
83
+
84
+ parse "m { |*| }" do
85
+ [:call, nil, :m, [:arglist, [:iter, [:args, :*], [:nil]]]]
86
+ end
87
+
88
+ parse "m { |*; x| }" do
89
+ [:call, nil, :m, [:arglist, [:iter, [:args, :*], [:block, [[:lvar, :x]]]]]]
90
+ end
91
+
92
+ parse "m { |*a| }" do
93
+ [:call, nil, :m, [:arglist, [:iter, [:args, :"*a"], [:nil]]]]
94
+ end
95
+
96
+ parse "m { |*a; x| }" do
97
+ [:call, nil, :m, [:arglist, [:iter, [:args, :"*a"], [:block, [[:lvar, :x]]]]]]
98
+ end
99
+
100
+ parse "m { |a:| }" do
101
+ [:call, nil, :m, [:arglist, [:iter, [:args, :a, [:block, [:a]]], [:nil]]]]
53
102
  end
54
103
 
55
- parse "m { |a, *| a + x }" do
104
+ parse "m { |a:; x| }" do
56
105
  [:call,
57
106
  nil,
58
107
  :m,
59
- [:arglist,
60
- [:iter,
61
- [:args, :a, :*],
62
- [:call, [:lvar, :a], :+, [:arglist, [:call, nil, :x, [:arglist]]]]]]]
108
+ [:arglist, [:iter, [:args, :a, [:block, [:a]]], [:block, [[:lvar, :x]]]]]]
63
109
  end
64
110
 
65
- parse "m { |a, *c| a + x; c }" do
111
+ parse "m { |a: 1| }" do
66
112
  [:call,
67
113
  nil,
68
114
  :m,
69
115
  [:arglist,
70
- [:iter,
71
- [:args, :a, :"*c"],
72
- [:block,
73
- [:call, [:lvar, :a], :+, [:arglist, [:call, nil, :x, [:arglist]]]],
74
- [:lvar, :c]]]]]
116
+ [:iter, [:args, :a, [:block, [:a], [[:lasgn, :a, [:lit, 1]]]]], [:nil]]]]
75
117
  end
76
118
 
77
- parse "m { |a, b| a + x; b }" do
119
+ parse "m { |a: 1; x| }" do
78
120
  [:call,
79
121
  nil,
80
122
  :m,
81
123
  [:arglist,
82
124
  [:iter,
83
- [:args, :a, :b],
84
- [:block,
85
- [:call, [:lvar, :a], :+, [:arglist, [:call, nil, :x, [:arglist]]]],
86
- [:lvar, :b]]]]]
125
+ [:args, :a, [:block, [:a], [[:lasgn, :a, [:lit, 1]]]]],
126
+ [:block, [[:lvar, :x]]]]]]
127
+ end
128
+
129
+ parse "m { |**| }" do
130
+ [:call, nil, :m, [:arglist, [:iter, [:args, :**, [:block, [:**]]], [:nil]]]]
87
131
  end
88
132
 
89
- parse "m { |a, b, | a + x; b }" do
133
+ parse "m { |**; x| }" do
90
134
  [:call,
91
135
  nil,
92
136
  :m,
93
- [:arglist,
94
- [:iter,
95
- [:args, :a, :b],
96
- [:block,
97
- [:call, [:lvar, :a], :+, [:arglist, [:call, nil, :x, [:arglist]]]],
98
- [:lvar, :b]]]]]
137
+ [:arglist, [:iter, [:args, :**, [:block, [:**]]], [:block, [[:lvar, :x]]]]]]
138
+ end
139
+
140
+ parse "m { |**k| }" do
141
+ [:call,
142
+ nil,
143
+ :m,
144
+ [:arglist, [:iter, [:args, :"**k", [:block, [:"**k"]]], [:nil]]]]
99
145
  end
100
146
 
101
- parse "m { |a, b, *| a + x; b }" do
147
+ parse "m { |**k; x| }" do
102
148
  [:call,
103
149
  nil,
104
150
  :m,
105
151
  [:arglist,
106
- [:iter,
107
- [:args, :a, :b, :*],
108
- [:block,
109
- [:call, [:lvar, :a], :+, [:arglist, [:call, nil, :x, [:arglist]]]],
110
- [:lvar, :b]]]]]
152
+ [:iter, [:args, :"**k", [:block, [:"**k"]]], [:block, [[:lvar, :x]]]]]]
153
+ end
154
+
155
+ parse "m { |&b| }" do
156
+ [:call, nil, :m, [:arglist, [:iter, [:args, :"&b"], [:nil]]]]
157
+ end
158
+
159
+ parse "m { |&b; x| }" do
160
+ [:call, nil, :m, [:arglist, [:iter, [:args, :"&b"], [:block, [[:lvar, :x]]]]]]
161
+ end
162
+
163
+ parse "m { |a, | }" do
164
+ [:call, nil, :m, [:arglist, [:iter, [:args, :a, :*], [:nil]]]]
165
+ end
166
+
167
+ parse "m { |a,; x| }" do
168
+ [:call, nil, :m, [:arglist, [:iter, [:args, :a, :*], [:block, [[:lvar, :x]]]]]]
111
169
  end
112
170
 
113
- masgn_rest_arg_block = lambda do |g|
114
- g.push :self
171
+ parse "m { |a, b| }" do
172
+ [:call, nil, :m, [:arglist, [:iter, [:args, :a, :b], [:nil]]]]
173
+ end
115
174
 
116
- g.in_block_send :m, :rest, -3 do |d|
117
- d.push_local 0
118
- d.push :self
119
- d.send :x, 0, true
120
- d.send :+, 1, false
121
- d.pop
122
- d.push_local 1
123
- d.pop
124
- d.push_local 2
125
- end
175
+ parse "m { |a, b; x| }" do
176
+ [:call, nil, :m, [:arglist, [:iter, [:args, :a, :b], [:block, [[:lvar, :x]]]]]]
126
177
  end
127
178
 
128
- parse "m { |a, b, *c| a + x; b; c }" do
179
+ parse "m { |a, b=1| }" do
129
180
  [:call,
130
181
  nil,
131
182
  :m,
132
183
  [:arglist,
133
- [:iter,
134
- [:args, :a, :b, :"*c"],
135
- [:block,
136
- [:call, [:lvar, :a], :+, [:arglist, [:call, nil, :x, [:arglist]]]],
137
- [:lvar, :b],
138
- [:lvar, :c]]]]]
184
+ [:iter, [:args, :a, :b, [:block, [:lasgn, :b, [:lit, 1]]]], [:nil]]]]
185
+ end
186
+
187
+ parse "m { |a, *| }" do
188
+ [:call, nil, :m, [:arglist, [:iter, [:args, :a, :*], [:nil]]]]
139
189
  end
140
190
 
141
- parse "m do |a, b, *c| a + x; b; c end" do
191
+ parse "m { |a, *b| }" do
192
+ [:call, nil, :m, [:arglist, [:iter, [:args, :a, :"*b"], [:nil]]]]
193
+ end
194
+
195
+ parse "m { |a, b:| }" do
196
+ [:call, nil, :m, [:arglist, [:iter, [:args, :a, :b, [:block, [:b]]], [:nil]]]]
197
+ end
198
+
199
+ parse "m { |a, b: 1| }" do
142
200
  [:call,
143
201
  nil,
144
202
  :m,
145
203
  [:arglist,
146
- [:iter,
147
- [:args, :a, :b, :"*c"],
148
- [:block,
149
- [:call, [:lvar, :a], :+, [:arglist, [:call, nil, :x, [:arglist]]]],
150
- [:lvar, :b],
151
- [:lvar, :c]]]]]
204
+ [:iter, [:args, :a, :b, [:block, [:b], [[:lasgn, :b, [:lit, 1]]]]], [:nil]]]]
152
205
  end
153
206
 
154
- parse "m { n = 1; n }" do
207
+ parse "m { |a, **| }" do
155
208
  [:call,
156
209
  nil,
157
210
  :m,
158
- [:arglist, [:iter, [:args], [:block, [:lasgn, :n, [:lit, 1]], [:lvar, :n]]]]]
211
+ [:arglist, [:iter, [:args, :a, :**, [:block, [:**]]], [:nil]]]]
159
212
  end
160
213
 
161
- parse "m { n = 1; m { n } }" do
214
+ parse "m { |a, **k| }" do
162
215
  [:call,
163
216
  nil,
164
217
  :m,
165
- [:arglist,
166
- [:iter,
167
- [:args],
168
- [:block,
169
- [:lasgn, :n, [:lit, 1]],
170
- [:call, nil, :m, [:arglist, [:iter, [:args], [:lvar, :n]]]]]]]]
218
+ [:arglist, [:iter, [:args, :a, :"**k", [:block, [:"**k"]]], [:nil]]]]
171
219
  end
172
220
 
173
- parse "n = 1; m { n = 2 }; n" do
174
- [:block,
175
- [:lasgn, :n, [:lit, 1]],
176
- [:call, nil, :m, [:arglist, [:iter, [:args], [:lasgn, :n, [:lit, 2]]]]],
177
- [:lvar, :n]]
221
+ parse "m { |a, &b| }" do
222
+ [:call, nil, :m, [:arglist, [:iter, [:args, :a, :"&b"], [:nil]]]]
178
223
  end
179
224
 
180
- parse "m(a) { |b| a + x }" do
225
+ parse "m { |a=1, b=2| }" do
181
226
  [:call,
182
227
  nil,
183
228
  :m,
184
229
  [:arglist,
185
- [:call, nil, :a, [:arglist]],
186
230
  [:iter,
187
- [:args, :b],
188
- [:call,
189
- [:call, nil, :a, [:arglist]],
190
- :+,
191
- [:arglist, [:call, nil, :x, [:arglist]]]]]]]
231
+ [:args, :a, :b, [:block, [:lasgn, :a, [:lit, 1]], [:lasgn, :b, [:lit, 2]]]],
232
+ [:nil]]]]
192
233
  end
193
234
 
194
- parse <<-ruby do
195
- m { |a|
196
- a + x
197
- }
198
- ruby
199
-
235
+ parse "m { |a=1, b| }" do
200
236
  [:call,
201
237
  nil,
202
238
  :m,
203
239
  [:arglist,
204
- [:iter,
205
- [:args, :a],
206
- [:call, [:lvar, :a], :+, [:arglist, [:call, nil, :x, [:arglist]]]]]]]
240
+ [:iter, [:args, :a, :b, [:block, [:lasgn, :a, [:lit, 1]]]], [:nil]]]]
207
241
  end
208
242
 
209
- parse <<-ruby do
210
- m do |a|
211
- a + x
212
- end
213
- ruby
243
+ parse "m { |a=1, *| }" do
244
+ [:call,
245
+ nil,
246
+ :m,
247
+ [:arglist,
248
+ [:iter, [:args, :a, :*, [:block, [:lasgn, :a, [:lit, 1]]]], [:nil]]]]
249
+ end
214
250
 
251
+ parse "m { |a=1, *b| }" do
215
252
  [:call,
216
253
  nil,
217
254
  :m,
218
255
  [:arglist,
219
- [:iter,
220
- [:args, :a],
221
- [:call, [:lvar, :a], :+, [:arglist, [:call, nil, :x, [:arglist]]]]]]]
256
+ [:iter, [:args, :a, :"*b", [:block, [:lasgn, :a, [:lit, 1]]]], [:nil]]]]
222
257
  end
223
258
 
224
- parse "obj.m { |a| a + x }" do
259
+ parse "m { |a=1, b:| }" do
225
260
  [:call,
226
- [:call, nil, :obj, [:arglist]],
261
+ nil,
227
262
  :m,
228
263
  [:arglist,
229
264
  [:iter,
230
- [:args, :a],
231
- [:call, [:lvar, :a], :+, [:arglist, [:call, nil, :x, [:arglist]]]]]]]
265
+ [:args, :a, :b, [:block, [:lasgn, :a, [:lit, 1]]], [:block, [:b]]],
266
+ [:nil]]]]
232
267
  end
233
268
 
234
- parse "obj.m(x) { |a| a + x }" do
269
+ parse "m { |a=1, b: 2| }" do
235
270
  [:call,
236
- [:call, nil, :obj, [:arglist]],
271
+ nil,
237
272
  :m,
238
273
  [:arglist,
239
- [:call, nil, :x, [:arglist]],
240
274
  [:iter,
241
- [:args, :a],
242
- [:call, [:lvar, :a], :+, [:arglist, [:call, nil, :x, [:arglist]]]]]]]
275
+ [:args,
276
+ :a,
277
+ :b,
278
+ [:block, [:lasgn, :a, [:lit, 1]]],
279
+ [:block, [:b], [[:lasgn, :b, [:lit, 2]]]]],
280
+ [:nil]]]]
243
281
  end
244
282
 
245
- parse "obj.m(a) { |a| a + x }" do
283
+ parse "m { |a=1, **| }" do
246
284
  [:call,
247
- [:call, nil, :obj, [:arglist]],
285
+ nil,
248
286
  :m,
249
287
  [:arglist,
250
- [:call, nil, :a, [:arglist]],
251
288
  [:iter,
252
- [:args, :a],
253
- [:call, [:lvar, :a], :+, [:arglist, [:call, nil, :x, [:arglist]]]]]]]
254
- end
255
-
256
- parse "a = 1; m { |a| a + x }" do
257
- [:block,
258
- [:lasgn, :a, [:lit, 1]],
259
- [:call,
260
- nil,
261
- :m,
262
- [:arglist,
263
- [:iter,
264
- [:args, :a],
265
- [:call, [:lvar, :a], :+, [:arglist, [:call, nil, :x, [:arglist]]]]]]]]
266
- end
267
-
268
- parse <<-ruby do
269
- x = nil
270
- m do |a|
271
- begin
272
- x
273
- rescue Exception => x
274
- break
275
- ensure
276
- x = a
277
- end
278
- end
279
- ruby
280
-
281
- [:block,
282
- [:lasgn, :x, [:nil]],
283
- [:call,
284
- nil,
285
- :m,
286
- [:arglist,
287
- [:iter,
288
- [:args, :a],
289
- [:ensure,
290
- [:rescue,
291
- [:lvar, :x],
292
- [:resbody,
293
- [:array, [:const, :Exception], [:lasgn, :x, [:gvar, :$!]]],
294
- [:break, [:nil]]]],
295
- [:lasgn, :x, [:lvar, :a]]]]]]]
289
+ [:args, :a, :**, [:block, [:lasgn, :a, [:lit, 1]]], [:block, [:**]]],
290
+ [:nil]]]]
296
291
  end
297
292
 
298
- parse "m { next }" do
299
- [:call, nil, :m, [:arglist, [:iter, [:args], [:next]]]]
293
+ parse "m { |a=1, **k| }" do
294
+ [:call,
295
+ nil,
296
+ :m,
297
+ [:arglist,
298
+ [:iter,
299
+ [:args, :a, :"**k", [:block, [:lasgn, :a, [:lit, 1]]], [:block, [:"**k"]]],
300
+ [:nil]]]]
300
301
  end
301
302
 
302
- parse "m { next if x }" do
303
+ parse "m { |a=1, &b| }" do
303
304
  [:call,
304
305
  nil,
305
306
  :m,
306
307
  [:arglist,
307
- [:iter, [:args], [:if, [:call, nil, :x, [:arglist]], [:next], nil]]]]
308
+ [:iter, [:args, :a, :"&b", [:block, [:lasgn, :a, [:lit, 1]]]], [:nil]]]]
309
+ end
310
+
311
+ parse "m { |*, a| }" do
312
+ [:call, nil, :m, [:arglist, [:iter, [:args, :*, :a], [:nil]]]]
313
+ end
314
+
315
+ parse "m { |*a, b| }" do
316
+ [:call, nil, :m, [:arglist, [:iter, [:args, :"*a", :b], [:nil]]]]
308
317
  end
309
318
 
310
- parse "m { next x }" do
319
+ parse "m { |*, a:| }" do
320
+ [:call, nil, :m, [:arglist, [:iter, [:args, :*, :a, [:block, [:a]]], [:nil]]]]
321
+ end
322
+
323
+ parse "m { |*a, b:| }" do
311
324
  [:call,
312
325
  nil,
313
326
  :m,
314
- [:arglist, [:iter, [:args], [:next, [:call, nil, :x, [:arglist]]]]]]
327
+ [:arglist, [:iter, [:args, :"*a", :b, [:block, [:b]]], [:nil]]]]
315
328
  end
316
329
 
317
- parse "m { x = 1; next x }" do
330
+ parse "m { |*, a: 1| }" do
318
331
  [:call,
319
332
  nil,
320
333
  :m,
321
334
  [:arglist,
322
- [:iter, [:args], [:block, [:lasgn, :x, [:lit, 1]], [:next, [:lvar, :x]]]]]]
335
+ [:iter, [:args, :*, :a, [:block, [:a], [[:lasgn, :a, [:lit, 1]]]]], [:nil]]]]
323
336
  end
324
337
 
325
- parse "m { next [1] }" do
326
- [:call, nil, :m, [:arglist, [:iter, [:args], [:next, [:array, [:lit, 1]]]]]]
338
+ parse "m { |*a, b: 1| }" do
339
+ [:call,
340
+ nil,
341
+ :m,
342
+ [:arglist,
343
+ [:iter,
344
+ [:args, :"*a", :b, [:block, [:b], [[:lasgn, :b, [:lit, 1]]]]],
345
+ [:nil]]]]
327
346
  end
328
347
 
329
- parse "m { next *[1] }" do
348
+ parse "m { |*, **| }" do
330
349
  [:call,
331
350
  nil,
332
351
  :m,
333
- [:arglist, [:iter, [:args], [:next, [:splat, [:array, [:lit, 1]]]]]]]
352
+ [:arglist, [:iter, [:args, :*, :**, [:block, [:**]]], [:nil]]]]
334
353
  end
335
354
 
336
- parse "m { next [*[1]] }" do
355
+ parse "m { |*a, **| }" do
337
356
  [:call,
338
357
  nil,
339
358
  :m,
340
- [:arglist, [:iter, [:args], [:next, [:splat, [:array, [:lit, 1]]]]]]]
359
+ [:arglist, [:iter, [:args, :"*a", :**, [:block, [:**]]], [:nil]]]]
341
360
  end
342
361
 
343
- parse "m { next *[1, 2] }" do
362
+ parse "m { |*, **k| }" do
344
363
  [:call,
345
364
  nil,
346
365
  :m,
347
- [:arglist,
348
- [:iter, [:args], [:next, [:splat, [:array, [:lit, 1], [:lit, 2]]]]]]]
366
+ [:arglist, [:iter, [:args, :*, :"**k", [:block, [:"**k"]]], [:nil]]]]
349
367
  end
350
368
 
351
- parse "m { next [*[1, 2]] }" do
369
+ parse "m { |*a, **k| }" do
352
370
  [:call,
353
371
  nil,
354
372
  :m,
355
- [:arglist,
356
- [:iter, [:args], [:next, [:splat, [:array, [:lit, 1], [:lit, 2]]]]]]]
373
+ [:arglist, [:iter, [:args, :"*a", :"**k", [:block, [:"**k"]]], [:nil]]]]
357
374
  end
358
375
 
359
- parse "m { break }" do
360
- [:call, nil, :m, [:arglist, [:iter, [:args], [:break, [:nil]]]]]
376
+ parse "m { |*, &b| }" do
377
+ [:call, nil, :m, [:arglist, [:iter, [:args, :*, :"&b"], [:nil]]]]
378
+ end
379
+
380
+ parse "m { |*a, &b| }" do
381
+ [:call, nil, :m, [:arglist, [:iter, [:args, :"*a", :"&b"], [:nil]]]]
382
+ end
383
+
384
+ parse "m { |a:, b:| }" do
385
+ [:call,
386
+ nil,
387
+ :m,
388
+ [:arglist, [:iter, [:args, :a, :b, [:block, [:a, :b]]], [:nil]]]]
361
389
  end
362
390
 
363
- parse "m { break if x }" do
391
+ parse "m { |a:, b: 1| }" do
364
392
  [:call,
365
393
  nil,
366
394
  :m,
367
395
  [:arglist,
368
396
  [:iter,
369
- [:args],
370
- [:if, [:call, nil, :x, [:arglist]], [:break, [:nil]], nil]]]]
397
+ [:args, :a, :b, [:block, [:a, :b], [[:lasgn, :b, [:lit, 1]]]]],
398
+ [:nil]]]]
371
399
  end
372
400
 
373
- parse "m { break x }" do
401
+ parse "m { |a:, **| }" do
374
402
  [:call,
375
403
  nil,
376
404
  :m,
377
- [:arglist, [:iter, [:args], [:break, [:call, nil, :x, [:arglist]]]]]]
405
+ [:arglist, [:iter, [:args, :a, :**, [:block, [:a, :**]]], [:nil]]]]
378
406
  end
379
407
 
380
- parse "m { x = 1; break x }" do
408
+ parse "m { |a:, **k| }" do
381
409
  [:call,
382
410
  nil,
383
411
  :m,
384
- [:arglist,
385
- [:iter, [:args], [:block, [:lasgn, :x, [:lit, 1]], [:break, [:lvar, :x]]]]]]
412
+ [:arglist, [:iter, [:args, :a, :"**k", [:block, [:a, :"**k"]]], [:nil]]]]
386
413
  end
387
414
 
388
- parse "m { break [1] }" do
389
- [:call, nil, :m, [:arglist, [:iter, [:args], [:break, [:array, [:lit, 1]]]]]]
415
+ parse "m { |a:, &b| }" do
416
+ [:call,
417
+ nil,
418
+ :m,
419
+ [:arglist, [:iter, [:args, :a, :"&b", [:block, [:a]]], [:nil]]]]
390
420
  end
391
421
 
392
- parse "m { break *[1] }" do
422
+ parse "m { |a: 1, b:| }" do
393
423
  [:call,
394
424
  nil,
395
425
  :m,
396
- [:arglist, [:iter, [:args], [:break, [:splat, [:array, [:lit, 1]]]]]]]
426
+ [:arglist,
427
+ [:iter,
428
+ [:args, :a, :b, [:block, [:a, :b], [[:lasgn, :a, [:lit, 1]]]]],
429
+ [:nil]]]]
397
430
  end
398
431
 
399
- parse "m { break [*[1]] }" do
432
+ parse "m { |a: 1, b: 2| }" do
400
433
  [:call,
401
434
  nil,
402
435
  :m,
403
- [:arglist, [:iter, [:args], [:break, [:splat, [:array, [:lit, 1]]]]]]]
436
+ [:arglist,
437
+ [:iter,
438
+ [:args,
439
+ :a,
440
+ :b,
441
+ [:block, [:a, :b], [[:lasgn, :a, [:lit, 1]], [:lasgn, :b, [:lit, 2]]]]],
442
+ [:nil]]]]
404
443
  end
405
444
 
406
- parse "m { break *[1, 2] }" do
445
+ parse "m { |a: 1, **| }" do
407
446
  [:call,
408
447
  nil,
409
448
  :m,
410
449
  [:arglist,
411
- [:iter, [:args], [:break, [:splat, [:array, [:lit, 1], [:lit, 2]]]]]]]
450
+ [:iter,
451
+ [:args, :a, :**, [:block, [:a, :**], [[:lasgn, :a, [:lit, 1]]]]],
452
+ [:nil]]]]
412
453
  end
413
454
 
414
- parse "m { break [*[1, 2]] }" do
455
+ parse "m { |a: 1, **k| }" do
415
456
  [:call,
416
457
  nil,
417
458
  :m,
418
459
  [:arglist,
419
- [:iter, [:args], [:break, [:splat, [:array, [:lit, 1], [:lit, 2]]]]]]]
460
+ [:iter,
461
+ [:args, :a, :"**k", [:block, [:a, :"**k"], [[:lasgn, :a, [:lit, 1]]]]],
462
+ [:nil]]]]
420
463
  end
421
464
 
422
- parse "m { return }" do
423
- [:call, nil, :m, [:arglist, [:iter, [:args], [:return]]]]
465
+ parse "m { |a: 1, &b| }" do
466
+ [:call,
467
+ nil,
468
+ :m,
469
+ [:arglist,
470
+ [:iter,
471
+ [:args, :a, :"&b", [:block, [:a], [[:lasgn, :a, [:lit, 1]]]]],
472
+ [:nil]]]]
424
473
  end
425
474
 
426
- parse "m { return if x }" do
475
+ parse "m { |**, &b| }" do
427
476
  [:call,
428
477
  nil,
429
478
  :m,
430
- [:arglist,
431
- [:iter, [:args], [:if, [:call, nil, :x, [:arglist]], [:return], nil]]]]
479
+ [:arglist, [:iter, [:args, :**, :"&b", [:block, [:**]]], [:nil]]]]
432
480
  end
433
481
 
434
- parse "m { return x }" do
482
+ parse "m { |**k, &b| }" do
435
483
  [:call,
436
484
  nil,
437
485
  :m,
438
- [:arglist, [:iter, [:args], [:return, [:call, nil, :x, [:arglist]]]]]]
486
+ [:arglist, [:iter, [:args, :"**k", :"&b", [:block, [:"**k"]]], [:nil]]]]
439
487
  end
440
488
 
441
- parse "m { x = 1; return x }" do
489
+ parse "m { n = 1; m { n } }" do
442
490
  [:call,
443
491
  nil,
444
492
  :m,
445
493
  [:arglist,
446
- [:iter, [:args], [:block, [:lasgn, :x, [:lit, 1]], [:return, [:lvar, :x]]]]]]
494
+ [:iter,
495
+ [:args],
496
+ [:block,
497
+ [:lasgn, :n, [:lit, 1]],
498
+ [:call, nil, :m, [:arglist, [:iter, [:args], [:lvar, :n]]]]]]]]
447
499
  end
448
500
 
449
- parse "m { return [1] }" do
450
- [:call, nil, :m, [:arglist, [:iter, [:args], [:return, [:array, [:lit, 1]]]]]]
501
+ parse "m(x) { |a, b=1, *c, d, e:, f: 2, **k, &l| }" do
502
+ [:call,
503
+ nil,
504
+ :m,
505
+ [:arglist,
506
+ [:call, nil, :x, [:arglist]],
507
+ [:iter,
508
+ [:args,
509
+ :a,
510
+ :b,
511
+ :"*c",
512
+ :d,
513
+ :e,
514
+ :f,
515
+ :"**k",
516
+ :"&l",
517
+ [:block, [:lasgn, :b, [:lit, 1]]],
518
+ [:block, [:e, :f, :"**k"], [[:lasgn, :f, [:lit, 2]]]]],
519
+ [:nil]]]]
451
520
  end
452
521
 
453
- parse "m { return *[1] }" do
522
+ parse "m(x, y) { |a, b=1, *c, d, e:, f: 2, **k, &l| }" do
454
523
  [:call,
455
524
  nil,
456
525
  :m,
457
- [:arglist, [:iter, [:args], [:return, [:splat, [:array, [:lit, 1]]]]]]]
526
+ [:arglist,
527
+ [:call, nil, :x, [:arglist]],
528
+ [:call, nil, :y, [:arglist]],
529
+ [:iter,
530
+ [:args,
531
+ :a,
532
+ :b,
533
+ :"*c",
534
+ :d,
535
+ :e,
536
+ :f,
537
+ :"**k",
538
+ :"&l",
539
+ [:block, [:lasgn, :b, [:lit, 1]]],
540
+ [:block, [:e, :f, :"**k"], [[:lasgn, :f, [:lit, 2]]]]],
541
+ [:nil]]]]
458
542
  end
459
543
 
460
- parse "m { return [*[1]] }" do
544
+ parse "x.m { |a, b=1, *c, d, e:, f: 2, **k, &l| }" do
461
545
  [:call,
462
- nil,
546
+ [:call, nil, :x, [:arglist]],
463
547
  :m,
464
- [:arglist, [:iter, [:args], [:return, [:splat, [:array, [:lit, 1]]]]]]]
548
+ [:arglist,
549
+ [:iter,
550
+ [:args,
551
+ :a,
552
+ :b,
553
+ :"*c",
554
+ :d,
555
+ :e,
556
+ :f,
557
+ :"**k",
558
+ :"&l",
559
+ [:block, [:lasgn, :b, [:lit, 1]]],
560
+ [:block, [:e, :f, :"**k"], [[:lasgn, :f, [:lit, 2]]]]],
561
+ [:nil]]]]
465
562
  end
466
563
 
467
- parse "m { return *[1, 2] }" do
564
+ parse "x.m(x, y) { |a, b=1, *c, d, e:, f: 2, **k, &l| }" do
468
565
  [:call,
469
- nil,
566
+ [:call, nil, :x, [:arglist]],
470
567
  :m,
471
568
  [:arglist,
472
- [:iter, [:args], [:return, [:splat, [:array, [:lit, 1], [:lit, 2]]]]]]]
569
+ [:call, nil, :x, [:arglist]],
570
+ [:call, nil, :y, [:arglist]],
571
+ [:iter,
572
+ [:args,
573
+ :a,
574
+ :b,
575
+ :"*c",
576
+ :d,
577
+ :e,
578
+ :f,
579
+ :"**k",
580
+ :"&l",
581
+ [:block, [:lasgn, :b, [:lit, 1]]],
582
+ [:block, [:e, :f, :"**k"], [[:lasgn, :f, [:lit, 2]]]]],
583
+ [:nil]]]]
473
584
  end
474
585
 
475
- parse "m { return [*[1, 2]] }" do
586
+ parse "m { next }" do
587
+ [:call, nil, :m, [:arglist, [:iter, [:args], [:next]]]]
588
+ end
589
+
590
+ parse "m { next 1 }" do
591
+ [:call, nil, :m, [:arglist, [:iter, [:args], [:next, [:lit, 1]]]]]
592
+ end
593
+
594
+ parse "m { x = 1; next x }" do
476
595
  [:call,
477
596
  nil,
478
597
  :m,
479
598
  [:arglist,
480
- [:iter, [:args], [:return, [:splat, [:array, [:lit, 1], [:lit, 2]]]]]]]
599
+ [:iter, [:args], [:block, [:lasgn, :x, [:lit, 1]], [:next, [:lvar, :x]]]]]]
481
600
  end
482
601
 
483
- parse "m { redo }" do
484
- [:call, nil, :m, [:arglist, [:iter, [:args], [:redo]]]]
602
+ parse "m { next *x }" do
603
+ [:call,
604
+ nil,
605
+ :m,
606
+ [:arglist, [:iter, [:args], [:next, [:splat, [:call, nil, :x, [:arglist]]]]]]]
607
+ end
608
+
609
+ parse "m { break }" do
610
+ [:call, nil, :m, [:arglist, [:iter, [:args], [:break, [:nil]]]]]
485
611
  end
486
612
 
487
- parse "m { redo if x }" do
613
+ parse "m { break x }" do
488
614
  [:call,
489
615
  nil,
490
616
  :m,
491
- [:arglist,
492
- [:iter, [:args], [:if, [:call, nil, :x, [:arglist]], [:redo], nil]]]]
617
+ [:arglist, [:iter, [:args], [:break, [:call, nil, :x, [:arglist]]]]]]
618
+ end
619
+
620
+ parse "m { return }" do
621
+ [:call, nil, :m, [:arglist, [:iter, [:args], [:return]]]]
493
622
  end
494
623
 
495
- parse "m(a) { retry }" do
624
+ parse "m { return x }" do
496
625
  [:call,
497
626
  nil,
498
627
  :m,
499
- [:arglist, [:call, nil, :a, [:arglist]], [:iter, [:args], [:retry]]]]
628
+ [:arglist, [:iter, [:args], [:return, [:call, nil, :x, [:arglist]]]]]]
500
629
  end
501
630
 
502
- parse "m(a) { retry if x }" do
631
+ parse "m { x = 1; return x }" do
503
632
  [:call,
504
633
  nil,
505
634
  :m,
506
635
  [:arglist,
507
- [:call, nil, :a, [:arglist]],
508
- [:iter, [:args], [:if, [:call, nil, :x, [:arglist]], [:retry], nil]]]]
636
+ [:iter, [:args], [:block, [:lasgn, :x, [:lit, 1]], [:return, [:lvar, :x]]]]]]
637
+ end
638
+
639
+ parse "m { redo }" do
640
+ [:call, nil, :m, [:arglist, [:iter, [:args], [:redo]]]]
641
+ end
642
+
643
+ parse "m { retry }" do
644
+ [:call, nil, :m, [:arglist, [:iter, [:args], [:retry]]]]
509
645
  end
510
646
 
511
647
  parse "break" do
@@ -524,16 +660,7 @@ describe "An Iter node" do
524
660
  [:next]
525
661
  end
526
662
 
527
- parse <<-ruby do
528
- def x(a)
529
- bar { super }
530
- end
531
- ruby
532
-
533
- [:defn,
534
- :x,
535
- [:args, :a],
536
- [:scope,
537
- [:block, [:call, nil, :bar, [:arglist, [:iter, [:args], [:zsuper]]]]]]]
663
+ parse "m { super }" do
664
+ [:call, nil, :m, [:arglist, [:iter, [:args], [:zsuper]]]]
538
665
  end
539
666
  end