rubinius-melbourne 2.1.0.0 → 2.2.0.0

data/spec/lambda_spec.rb

@@ -0,0 +1,107 @@
+describe "A Lambda node" do
+  parse "-> { }" do
+    [:lambda, [:args], [:scope, [:nil]]]
+  end
+
+  parse "-> { x }" do
+    [:lambda, [:args], [:scope, [:call, nil, :x, [:arglist]]]]
+  end
+
+  parse "->(a) { }" do
+    [:lambda, [:args, :a], [:scope, [:nil]]]
+  end
+
+  parse "->(a, b) { }" do
+    [:lambda, [:args, :a, :b], [:scope, [:nil]]]
+  end
+
+  parse "-> (a, b) { }" do
+    [:lambda, [:args, :a, :b], [:scope, [:nil]]]
+  end
+
+  parse "-> a, b { x }" do
+    [:lambda, [:args, :a, :b], [:scope, [:call, nil, :x, [:arglist]]]]
+  end
+
+  parse "-> (a, (b, (c, *d), *e)) { }" do
+    [:lambda,
+     [:args,
+      :a,
+      [:masgn,
+       [:array,
+        [:lasgn, :b],
+        [:masgn, [:array, [:lasgn, :c], [:splat, [:lasgn, :d]]]],
+        [:splat, [:lasgn, :e]]],
+       [:lvar, :"_:1"]]],
+     [:scope, [:nil]]]
+  end
+
+  parse "-> (a=1) { }" do
+    [:lambda, [:args, :a, [:block, [:lasgn, :a, [:lit, 1]]]], [:scope, [:nil]]]
+  end
+
+  parse "-> (*) { }" do
+    [:lambda, [:args, :*], [:scope, [:nil]]]
+  end
+
+  parse "-> (*a) { }" do
+    [:lambda, [:args, :"*a"], [:scope, [:nil]]]
+  end
+
+  parse "-> (a=1, b) { }" do
+    [:lambda, [:args, :a, :b, [:block, [:lasgn, :a, [:lit, 1]]]], [:scope, [:nil]]]
+  end
+
+  parse "-> (*, a) { }" do
+    [:lambda, [:args, :*, :a], [:scope, [:nil]]]
+  end
+
+  parse "-> (*a, b, c:) { }" do
+    [:lambda, [:args, :"*a", :b, :c, [:block, [:c]]], [:scope, [:nil]]]
+  end
+
+  parse "-> (*a, b, c:, **) { }" do
+    [:lambda, [:args, :"*a", :b, :c, :**, [:block, [:c, :**]]], [:scope, [:nil]]]
+  end
+
+  parse "-> (a: 1, b:) { }" do
+    [:lambda,
+     [:args, :a, :b, [:block, [:a, :b], [[:lasgn, :a, [:lit, 1]]]]],
+     [:scope, [:nil]]]
+  end
+
+  parse "-> (a: 1, b:, &l) { }" do
+    [:lambda,
+     [:args, :a, :b, :"&l", [:block, [:a, :b], [[:lasgn, :a, [:lit, 1]]]]],
+     [:scope, [:nil]]]
+  end
+
+  parse "-> (a: 1, b: 2, **k) { }" do
+    [:lambda,
+     [:args,
+      :a,
+      :b,
+      :"**k",
+      [:block,
+       [:a, :b, :"**k"],
+       [[:lasgn, :a, [:lit, 1]], [:lasgn, :b, [:lit, 2]]]]],
+     [:scope, [:nil]]]
+  end
+
+  parse "-> a, b=1, *c, d, e:, f: 2, g:, **k, &l { x + a }" do
+    [:lambda,
+     [:args,
+      :a,
+      :b,
+      :"*c",
+      :d,
+      :e,
+      :f,
+      :g,
+      :"**k",
+      :"&l",
+      [:block, [:lasgn, :b, [:lit, 1]]],
+      [:block, [:e, :f, :g, :"**k"], [[:lasgn, :f, [:lit, 2]]]]],
+     [:scope, [:call, [:call, nil, :x, [:arglist]], :+, [:arglist, [:lvar, :a]]]]]
+  end
+end

data/spec/lit_spec.rb

@@ -27,6 +27,22 @@ describe "A Lit node" do
     [:lit, 1]
   end
 
+  parse "3r" do
+    [:lit, (3/1)]
+  end
+
+  parse "1/3r" do
+    [:call, [:lit, 1], :/, [:arglist, [:lit, (3/1)]]]
+  end
+
+  parse "2i" do
+    [:lit, (0+2i)]
+  end
+
+  parse "3+2i" do
+    [:call, [:lit, 3], :+, [:arglist, [:lit, (0+2i)]]]
+  end
+
   parse "8000_0000" do
     [:lit, 80000000]
   end

data/spec/masgn_spec.rb

@@ -1,375 +1,171 @@
 describe "A Masgn node" do
-  parse "a, b.c = b.c, true" do
-    [:masgn,
-     [:array,
-      [:lasgn, :a],
-      [:attrasgn, [:call, nil, :b, [:arglist]], :c=, [:arglist]]],
-     [:array, [:call, [:call, nil, :b, [:arglist]], :c, [:arglist]], [:true]]]
+  parse "a = 1, 2, 3" do
+    [:lasgn, :a, [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]
   end
 
-  parse "a, b = 1, 2, 3" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b]],
-     [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]
-  end
-
-  parse "a, b = c, d" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b]],
-     [:array, [:call, nil, :c, [:arglist]], [:call, nil, :d, [:arglist]]]]
+  parse "a = *x" do
+    [:lasgn, :a, [:splat, [:call, nil, :x, [:arglist]]]]
   end
 
-  parse "a, b, *c = 1, 2, *[3, 4]" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b], [:splat, [:lasgn, :c]]],
-     [:array, [:lit, 1], [:lit, 2], [:lit, 3], [:lit, 4]]]
+  parse "a, = []" do
+    [:masgn, [:array, [:lasgn, :a]], [:array]]
   end
 
-  parse "a.b, a.c, _ = q" do
+  parse "a, b = b, a" do
     [:masgn,
-     [:array,
-      [:attrasgn, [:call, nil, :a, [:arglist]], :b=, [:arglist]],
-      [:attrasgn, [:call, nil, :a, [:arglist]], :c=, [:arglist]],
-      [:lasgn, :_]],
-     [:to_ary, [:call, nil, :q, [:arglist]]]]
-  end
-
-  parse <<-ruby do
-      a, i, j = [], 1, 2
-      a[i], a[j] = a[j], a[i]
-    ruby
-
-    [:block,
-     [:masgn,
-      [:array, [:lasgn, :a], [:lasgn, :i], [:lasgn, :j]],
-      [:array, [:array], [:lit, 1], [:lit, 2]]],
-     [:masgn,
-      [:array,
-       [:attrasgn, [:lvar, :a], :[]=, [:arglist, [:lvar, :i]]],
-       [:attrasgn, [:lvar, :a], :[]=, [:arglist, [:lvar, :j]]]],
-      [:array,
-       [:call, [:lvar, :a], :[], [:arglist, [:lvar, :j]]],
-       [:call, [:lvar, :a], :[], [:arglist, [:lvar, :i]]]]]]
-  end
-
-  parse <<-ruby do
-      c, d, e, f = [], 1, 2, 3
-      a, *b = c[d] = f(e, f, c)
-    ruby
-
-    [:block,
-     [:masgn,
-      [:array, [:lasgn, :c], [:lasgn, :d], [:lasgn, :e], [:lasgn, :f]],
-      [:array, [:array], [:lit, 1], [:lit, 2], [:lit, 3]]],
-     [:masgn,
-      [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]],
-      [:to_ary,
-       [:attrasgn,
-        [:lvar, :c],
-        :[]=,
-        [:arglist,
-         [:lvar, :d],
-         [:call, nil, :f, [:arglist, [:lvar, :e], [:lvar, :f], [:lvar, :c]]]]]]]]
+     [:array, [:lasgn, :a], [:lasgn, :b]],
+     [:array, [:lvar, :b], [:lvar, :a]]]
   end
 
-  parse "a, b.c = d, e" do
+  parse "a, _, b, _, c, _ = x" do
     [:masgn,
      [:array,
       [:lasgn, :a],
-      [:attrasgn, [:call, nil, :b, [:arglist]], :c=, [:arglist]]],
-     [:array, [:call, nil, :d, [:arglist]], [:call, nil, :e, [:arglist]]]]
+      [:lasgn, :_],
+      [:lasgn, :b],
+      [:lasgn, :_],
+      [:lasgn, :c],
+      [:lasgn, :_]],
+     [:call, nil, :x, [:arglist]]]
   end
 
-  parse "*a.m = *b" do
+  parse "a.b, a.c = x" do
     [:masgn,
      [:array,
-      [:splat, [:attrasgn, [:call, nil, :a, [:arglist]], :m=, [:arglist]]]],
-     [:splat, [:call, nil, :b, [:arglist]]]]
+      [:attrasgn, [:call, nil, :a, [:arglist]], :b=, [:arglist]],
+      [:attrasgn, [:call, nil, :a, [:arglist]], :c=, [:arglist]]],
+     [:call, nil, :x, [:arglist]]]
   end
 
-  parse "*a.m = b" do
+  parse "a[0], a[1] = 1, 2" do
     [:masgn,
      [:array,
-      [:splat, [:attrasgn, [:call, nil, :a, [:arglist]], :m=, [:arglist]]]],
-     [:array, [:call, nil, :b, [:arglist]]]]
-  end
-
-  parse "A, B, C = 1, 2, 3" do
-    [:masgn,
-     [:array, [:cdecl, :A], [:cdecl, :B], [:cdecl, :C]],
-     [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]
-  end
-
-  parse "* = 1, 2" do
-    [:masgn, [:array, [:splat]], [:array, [:lit, 1], [:lit, 2]]]
-  end
-
-  parse "*$a = b" do
-    [:masgn,
-     [:array, [:splat, [:gasgn, :$a]]],
-     [:array, [:call, nil, :b, [:arglist]]]]
-  end
-
-  parse "*$a = *b" do
-    [:masgn,
-     [:array, [:splat, [:gasgn, :$a]]],
-     [:splat, [:call, nil, :b, [:arglist]]]]
-  end
-
-  parse "a, @b = c, d" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:iasgn, :@b]],
-     [:array, [:call, nil, :c, [:arglist]], [:call, nil, :d, [:arglist]]]]
-  end
-
-  parse "*@a = b" do
-    [:masgn,
-     [:array, [:splat, [:iasgn, :@a]]],
-     [:array, [:call, nil, :b, [:arglist]]]]
-  end
-
-  parse "*@a = *b" do
-    [:masgn,
-     [:array, [:splat, [:iasgn, :@a]]],
-     [:splat, [:call, nil, :b, [:arglist]]]]
-  end
-
-  parse "@a, $b = 1, 2" do
-    [:masgn,
-     [:array, [:iasgn, :@a], [:gasgn, :$b]],
-     [:array, [:lit, 1], [:lit, 2]]]
-  end
-
-  parse "a, b = (@a = 1), @a" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b]],
-     [:array, [:iasgn, :@a, [:lit, 1]], [:ivar, :@a]]]
-  end
-
-  parse "@@a, @@b = 1, 2" do
-    [:masgn,
-     [:array, [:cvasgn, :@@a], [:cvasgn, :@@b]],
-     [:array, [:lit, 1], [:lit, 2]]]
-  end
-
-  parse "a, b, *c = 1, 2, 3" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b], [:splat, [:lasgn, :c]]],
-     [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]
-  end
-
-  parse "a, b, *c = 1, 2" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b], [:splat, [:lasgn, :c]]],
-     [:array, [:lit, 1], [:lit, 2]]]
-  end
-
-  parse "a, b, c, *d = 1, 2" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b], [:lasgn, :c], [:splat, [:lasgn, :d]]],
+      [:attrasgn, [:call, nil, :a, [:arglist]], :[]=, [:arglist, [:lit, 0]]],
+      [:attrasgn, [:call, nil, :a, [:arglist]], :[]=, [:arglist, [:lit, 1]]]],
      [:array, [:lit, 1], [:lit, 2]]]
   end
 
-  parse "a, b, c = *d" do
-    [:masgn,
-      [:array, [:lasgn, :a], [:lasgn, :b], [:lasgn, :c]],
-      [:splat, [:call, nil, :d, [:arglist]]]]
-  end
-
-  parse "a, b, c = 1, *d" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b], [:lasgn, :c]],
-     [:argscat, [:array, [:lit, 1]], [:call, nil, :d, [:arglist]]]]
-  end
-
-  parse "a, b, *c = *d" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b], [:splat, [:lasgn, :c]]],
-     [:splat, [:call, nil, :d, [:arglist]]]]
+  parse "* = *1" do
+    [:masgn, [:array, [:splat]], [:splat, [:lit, 1]]]
   end
 
-  parse "*a = 1, 2, 3" do
-    [:masgn,
-     [:array, [:splat, [:lasgn, :a]]],
-     [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]
+  parse "*a = nil" do
+    [:masgn, [:array, [:splat, [:lasgn, :a]]], [:nil]]
   end
 
-  parse "*a = b" do
+  parse "*a = x, y, z" do
     [:masgn,
      [:array, [:splat, [:lasgn, :a]]],
-     [:array, [:call, nil, :b, [:arglist]]]]
+     [:array,
+      [:call, nil, :x, [:arglist]],
+      [:call, nil, :y, [:arglist]],
+      [:call, nil, :z, [:arglist]]]]
   end
 
-  parse "*a = *b" do
+  parse "*a = x, y, *z" do
     [:masgn,
      [:array, [:splat, [:lasgn, :a]]],
-     [:splat, [:call, nil, :b, [:arglist]]]]
+     [:argscat,
+      [:array, [:call, nil, :x, [:arglist]], [:call, nil, :y, [:arglist]]],
+      [:call, nil, :z, [:arglist]]]]
   end
 
-  parse "a, (b, c) = [1, [2, 3]]" do
+  parse "a, *b, c = *x" do
     [:masgn,
-     [:array, [:lasgn, :a], [:masgn, [:array, [:lasgn, :b], [:lasgn, :c]]]],
-     [:to_ary, [:array, [:lit, 1], [:array, [:lit, 2], [:lit, 3]]]]]
+     [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]],
+     [:lasgn, :c],
+     [:splat, [:call, nil, :x, [:arglist]]]]
   end
 
-  parse "a, = *[[[1]]]" do
-    [:masgn,
-     [:array, [:lasgn, :a]],
-     [:splat, [:array, [:array, [:array, [:lit, 1]]]]]]
-  end
-
-  parse "a, b, * = c" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b], [:splat]],
-     [:to_ary, [:call, nil, :c, [:arglist]]]]
-  end
-
-  parse "a, b, = c" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b]],
-     [:to_ary, [:call, nil, :c, [:arglist]]]]
-  end
-
-  parse "a, b, c = m d" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b], [:lasgn, :c]],
-     [:to_ary, [:call, nil, :m, [:arglist, [:call, nil, :d, [:arglist]]]]]]
-  end
-
-  parse "a, b, *c = d, e, f, g" do
+  parse "a, b, *c = *[]" do
     [:masgn,
      [:array, [:lasgn, :a], [:lasgn, :b], [:splat, [:lasgn, :c]]],
-     [:array,
-      [:call, nil, :d, [:arglist]],
-      [:call, nil, :e, [:arglist]],
-      [:call, nil, :f, [:arglist]],
-      [:call, nil, :g, [:arglist]]]]
+     [:splat, [:array]]]
   end
 
-  parse "a, b, *c = d.e(\"f\")" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b], [:splat, [:lasgn, :c]]],
-     [:to_ary, [:call, [:call, nil, :d, [:arglist]], :e, [:arglist, [:str, "f"]]]]]
+  parse "(*) = x" do
+    [:masgn, [:array, [:splat]], [:call, nil, :x, [:arglist]]]
   end
 
-  parse "a, b, *c = d" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b], [:splat, [:lasgn, :c]]],
-     [:to_ary, [:call, nil, :d, [:arglist]]]]
+  parse "(*) = *x" do
+    [:masgn, [:array, [:splat]], [:splat, [:call, nil, :x, [:arglist]]]]
   end
 
-  parse "a, b = c" do
+  parse "(*a) = (x = 1), *[1]" do
     [:masgn,
-     [:array, [:lasgn, :a], [:lasgn, :b]],
-     [:to_ary, [:call, nil, :c, [:arglist]]]]
-  end
-
-  parse <<-ruby do
-      m do
-        a, b = 1, 2
-        next
-      end
-    ruby
-
-    [:call,
-     nil,
-     :m,
-     [:arglist,
-      [:iter,
-       [:args],
-       [:block,
-        [:masgn,
-         [:array, [:lasgn, :a], [:lasgn, :b]],
-         [:array, [:lit, 1], [:lit, 2]]],
-        [:next]]]]]
-  end
-
-  parse "a, (b, c) = 1" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:masgn, [:array, [:lasgn, :b], [:lasgn, :c]]]],
-     [:to_ary, [:lit, 1]]]
-  end
-
-  parse "a, (b, c) = *1" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:masgn, [:array, [:lasgn, :b], [:lasgn, :c]]]],
-     [:splat, [:lit, 1]]]
-  end
-
-  parse "a, (b, c) = 1, 2, 3" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:masgn, [:array, [:lasgn, :b], [:lasgn, :c]]]],
-     [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]
+     [:array, [:splat, [:lasgn, :a]]],
+     [:array, [:lasgn, :x, [:lit, 1]], [:lit, 1]]]
   end
 
-  parse "a, (b, *c), d = 1, 2, 3, 4" do
+  parse "(*a), *b, c = *x" do
     [:masgn,
-     [:array,
-      [:lasgn, :a],
-      [:masgn, [:array, [:lasgn, :b], [:splat, [:lasgn, :c]]]],
-      [:lasgn, :d]],
-     [:array, [:lit, 1], [:lit, 2], [:lit, 3], [:lit, 4]]]
+     [:array, [:masgn, [:array, [:splat, [:lasgn, :a]]]], [:splat, [:lasgn, :b]]],
+     [:lasgn, :c],
+     [:splat, [:call, nil, :x, [:arglist]]]]
   end
 
-  parse "a, (b, c) = 1, *2" do
+  parse "(*a, b) = m x" do
     [:masgn,
-     [:array, [:lasgn, :a], [:masgn, [:array, [:lasgn, :b], [:lasgn, :c]]]],
-     [:argscat, [:array, [:lit, 1]], [:lit, 2]]]
+     [:array, [:splat, [:lasgn, :a]]],
+     [:lasgn, :b],
+     [:call, nil, :m, [:arglist, [:call, nil, :x, [:arglist]]]]]
   end
 
-  parse "a, (b, *c) = 1" do
+  parse "(*a, b), (*c, d) = 1, 2, 3" do
     [:masgn,
      [:array,
-      [:lasgn, :a],
-      [:masgn, [:array, [:lasgn, :b], [:splat, [:lasgn, :c]]]]],
-     [:to_ary, [:lit, 1]]]
+      [:masgn, [:array, [:splat, [:lasgn, :a]]], [:lasgn, :b]],
+      [:masgn, [:array, [:splat, [:lasgn, :c]]], [:lasgn, :d]]],
+     [:array, [:lit, 1], [:lit, 2], [:lit, 3]]]
   end
 
-  parse "a, (b, *c) = 1, 2" do
+  parse "(a, b, *c, d), (*e, f, g), (*h) = x.y, *x.z" do
     [:masgn,
      [:array,
-      [:lasgn, :a],
-      [:masgn, [:array, [:lasgn, :b], [:splat, [:lasgn, :c]]]]],
-     [:array, [:lit, 1], [:lit, 2]]]
+      [:masgn,
+       [:array, [:lasgn, :a], [:lasgn, :b], [:splat, [:lasgn, :c]]],
+       [:lasgn, :d]],
+      [:masgn, [:array, [:splat, [:lasgn, :e]]], [:lasgn, :f], [:lasgn, :g]],
+      [:masgn, [:array, [:splat, [:lasgn, :h]]]]],
+     [:argscat,
+      [:array, [:call, [:call, nil, :x, [:arglist]], :y, [:arglist]]],
+      [:call, [:call, nil, :x, [:arglist]], :z, [:arglist]]]]
   end
 
-  parse "a, (b, *c) = *1" do
+  parse "a, (b, (c, *d), *e) = x[0], *y[0]" do
     [:masgn,
      [:array,
       [:lasgn, :a],
-      [:masgn, [:array, [:lasgn, :b], [:splat, [:lasgn, :c]]]]],
-     [:splat, [:lit, 1]]]
+      [:masgn,
+       [:array,
+        [:lasgn, :b],
+        [:masgn, [:array, [:lasgn, :c], [:splat, [:lasgn, :d]]]],
+        [:splat, [:lasgn, :e]]]]],
+     [:argscat,
+      [:array, [:call, [:call, nil, :x, [:arglist]], :[], [:arglist, [:lit, 0]]]],
+      [:call, [:call, nil, :y, [:arglist]], :[], [:arglist, [:lit, 0]]]]]
   end
 
-  parse "a, (b, *c) = 1, *2" do
+  parse "a, (b, (c, *d, (e, (*f)), g), (h, (i, j), k)) = x.y(q, r)" do
     [:masgn,
      [:array,
       [:lasgn, :a],
-      [:masgn, [:array, [:lasgn, :b], [:splat, [:lasgn, :c]]]]],
-     [:argscat, [:array, [:lit, 1]], [:lit, 2]]]
-  end
-
-  parse "a, (*b) = 1" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:masgn, [:array, [:splat, [:lasgn, :b]]]]],
-     [:to_ary, [:lit, 1]]]
-  end
-
-  parse "a, (*b) = 1, 2" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:masgn, [:array, [:splat, [:lasgn, :b]]]]],
-     [:array, [:lit, 1], [:lit, 2]]]
-  end
-
-  parse "a, (*b) = *1" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:masgn, [:array, [:splat, [:lasgn, :b]]]]],
-     [:splat, [:lit, 1]]]
-  end
-
-  parse "a, (*b) = 1, *2" do
-    [:masgn,
-     [:array, [:lasgn, :a], [:masgn, [:array, [:splat, [:lasgn, :b]]]]],
-     [:argscat, [:array, [:lit, 1]], [:lit, 2]]]
+      [:masgn,
+       [:array,
+        [:lasgn, :b],
+        [:masgn,
+         [:array, [:lasgn, :c], [:splat, [:lasgn, :d]]],
+         [:masgn,
+          [:array, [:lasgn, :e], [:masgn, [:array, [:splat, [:lasgn, :f]]]]]],
+         [:lasgn, :g]],
+        [:masgn,
+         [:array,
+          [:lasgn, :h],
+          [:masgn, [:array, [:lasgn, :i], [:lasgn, :j]]],
+          [:lasgn, :k]]]]]],
+     [:call,
+      [:call, nil, :x, [:arglist]],
+      :y,
+      [:arglist, [:call, nil, :q, [:arglist]], [:call, nil, :r, [:arglist]]]]]
   end
 end