rubinius-melbourne 2.1.0.0 → 2.2.0.0

data/ext/rubinius/melbourne/symbols.hpp

@@ -56,8 +56,10 @@ namespace MELBOURNE {
   extern ID rb_sHash;
   extern ID rb_sIAsgn;
   extern ID rb_sIf;
+  extern ID rb_sImaginary;
   extern ID rb_sIter;
   extern ID rb_sIVar;
+  extern ID rb_sKwArg;
   extern ID rb_sLAsgn;
   extern ID rb_sLambda;
   extern ID rb_sLit;
@@ -82,6 +84,7 @@ namespace MELBOURNE {
   extern ID rb_sPostExe;
   extern ID rb_sPostArg;
   extern ID rb_sPreExe;
+  extern ID rb_sRational;
   extern ID rb_sRedo;
   extern ID rb_sRegex;
   extern ID rb_sResbody;

data/ext/rubinius/melbourne/visitor.cpp

@@ -577,13 +577,14 @@ namespace MELBOURNE {
 
       node = node->nd_head;
       while (node) {
-        rb_ary_push(array, process_parse_tree(parser_state, ptp, node->nd_head, locals));
-        if (!(node = node->nd_next)) {
-          // @todo: properly process the parse error
-          printf("odd number list for Hash");
-          abort();
+        if(node->nd_head) {
+          rb_ary_push(array, process_parse_tree(parser_state, ptp, node->nd_head, locals));
+          if (!(node = node->nd_next)) break;
+          rb_ary_push(array, process_parse_tree(parser_state, ptp, node->nd_head, locals));
+        } else {
+          // Marker for Hash splat.
+          rb_ary_push(array, Qnil);
         }
-        rb_ary_push(array, process_parse_tree(parser_state, ptp, node->nd_head, locals));
         node = node->nd_next;
       }
       tree = rb_funcall(ptp, rb_sHash, 2, line, array);
@@ -693,61 +694,55 @@ namespace MELBOURNE {
       tree = rb_funcall(ptp, rb_sOptArg, 2, line, args);
       break;
     }
+    case NODE_KW_ARG: {
+      VALUE args = rb_ary_new();
+
+      do {
+        rb_ary_push(args, process_parse_tree(parser_state, ptp, node->nd_body, locals));
+        node = node->nd_next;
+      } while(node);
+
+      tree = rb_funcall(ptp, rb_sKwArg, 2, line, args);
+      break;
+    }
     case NODE_ARGS: {
       VALUE args = Qnil;
       VALUE opts = Qnil;
       VALUE splat = Qnil;
       VALUE post = Qnil;
+      VALUE kwargs = Qnil;
+      VALUE kwrest = Qnil;
       VALUE block = Qnil;
 
       int total_args = 0;
       ID* args_ary = 0;
 
-      NODE* aux = node->nd_args;
-      NODE* post_args = aux->nd_next;
+      struct rb_args_info *ainfo = node->nd_ainfo;
       NODE* masgn = 0;
       NODE* next = 0;
 
-      if(post_args && post_args->nd_next && nd_type(post_args->nd_next) == NODE_AND) {
-        if(post_args->nd_next->nd_head) {
-          if (nd_type(post_args->nd_next->nd_head) == NODE_BLOCK) {
-            masgn = post_args->nd_next->nd_head->nd_head;
-            next = post_args->nd_next->nd_head->nd_next;
-          } else {
-            masgn = post_args->nd_next->nd_head;
-            next = masgn->nd_next;
-            // -1 comes from: mlhs_head tSTAR
-            if(masgn->nd_cnt == -1) next = 0;
-          }
-        } else {
-          masgn = post_args->nd_next->nd_2nd;
-          if(masgn) {
-            next = masgn->nd_next;
-            if (nd_type(masgn) == NODE_BLOCK) {
-              masgn = masgn->nd_head;
-            }
-          }
-        }
-      }
-
-      if(node->nd_argc > 0) {
+      if(ainfo->pre_args_num > 0) {
         total_args = (int)locals[0];
         args_ary = locals + 1;
 
+        masgn = ainfo->pre_init;
+        if(masgn && nd_type(masgn) == NODE_BLOCK) {
+          next = masgn->nd_next;
+          masgn = masgn->nd_head;
+        }
+
         args = rb_ary_new();
-        for(int i = 0; i < node->nd_argc && i < total_args; i++) {
+        for(int i = 0; i < ainfo->pre_args_num && i < total_args; i++) {
           VALUE arg = Qnil;
 
           if(!INTERNAL_ID_P(args_ary[i])) {
             arg = ID2SYM(args_ary[i]);
           } else if(masgn) {
             arg = process_parse_tree(parser_state, ptp, masgn, locals);
-            if(next && nd_type(next) == NODE_BLOCK) {
+
+            if(next) {
               masgn = next->nd_head;
               next = next->nd_next;
-            } else {
-              masgn = next;
-              if(masgn) next = masgn->nd_next;
             }
           }
 
@@ -755,53 +750,73 @@ namespace MELBOURNE {
         }
       }
 
-      if(node->nd_opt) {
-        opts = process_parse_tree(parser_state, ptp, node->nd_opt, locals);
+      if(ainfo->opt_args) {
+        opts = process_parse_tree(parser_state, ptp, ainfo->opt_args, locals);
+      }
+
+      if(ainfo->kw_args) {
+        kwargs = process_parse_tree(parser_state, ptp, ainfo->kw_args, locals);
       }
 
-      if(INTERNAL_ID_P(aux->nd_rest)) {
-        splat = Qtrue;
-      } else if(aux->nd_rest) {
-        if(aux->nd_rest == 1) {
+      if(ainfo->rest_arg) {
+        if(INTERNAL_ID_P(ainfo->rest_arg)) {
+          splat = Qtrue;
+        } else if(ainfo->rest_arg == 1) {
           // m { |a,| ... }
           splat = Qfalse;
         } else {
-          splat = ID2SYM(aux->nd_rest);
+          splat = ID2SYM(ainfo->rest_arg);
+        }
+      }
+
+      if(ainfo->kw_rest_arg) {
+        if(INTERNAL_ID_P(ainfo->kw_rest_arg->nd_vid)) {
+          kwrest = Qtrue;
+        } else {
+          kwrest = ID2SYM(ainfo->kw_rest_arg->nd_vid);
         }
       }
-      if(aux->nd_mid) block = ID2SYM(aux->nd_mid);
 
-      if(post_args && post_args->nd_pid) {
+      if(ainfo->block_arg) block = ID2SYM(ainfo->block_arg);
+
+      if(ainfo->post_args_num > 0) {
         total_args = (int)locals[0];
         args_ary = locals + 1;
 
+        masgn = ainfo->post_init;
+        if(masgn && nd_type(masgn) == NODE_BLOCK) {
+          next = masgn->nd_next;
+          masgn = masgn->nd_head;
+        } else {
+          next = 0;
+        }
+
         int start;
         for(start = 0; start < total_args; start++) {
-          if(args_ary[start] == post_args->nd_pid)
+          if(args_ary[start] == ainfo->first_post_arg)
             break;
         }
 
         post = rb_ary_new();
-        for(int i = 0; i < post_args->nd_argc && start + i < total_args; i++) {
+        for(int i = 0; i < ainfo->post_args_num && start + i < total_args; i++) {
           VALUE arg = Qnil;
 
           if(!INTERNAL_ID_P(args_ary[start + i])) {
             arg = ID2SYM(args_ary[start + i]);
           } else if(masgn) {
             arg = process_parse_tree(parser_state, ptp, masgn, locals);
-            if(next && nd_type(next) == NODE_BLOCK) {
+
+            if(next) {
               masgn = next->nd_head;
               next = next->nd_next;
-            } else {
-              masgn = next;
-              if(masgn) next = masgn->nd_next;
             }
           }
           rb_ary_push(post, arg);
         }
       }
 
-      tree = rb_funcall(ptp, rb_sArgs, 6, line, args, opts, splat, post, block);
+      tree = rb_funcall(ptp, rb_sArgs, 8, line, args, opts, splat,
+                        post, kwargs, kwrest, block);
       break;
     }
     case NODE_LVAR:
@@ -863,6 +878,14 @@ namespace MELBOURNE {
       tree = rb_funcall(ptp, rb_sFloat, 2, line, node->nd_lit);
       break;
 
+    case NODE_IMAGINARY:
+      tree = rb_funcall(ptp, rb_sImaginary, 2, line, node->nd_lit);
+      break;
+
+    case NODE_RATIONAL:
+      tree = rb_funcall(ptp, rb_sRational, 2, line, node->nd_lit);
+      break;
+
     case NODE_NTH_REF:          /* u2 u3 ($1) - u3 is local_cnt('~') ignorable? */
       tree = rb_funcall(ptp, rb_sNthRef, 2, line, INT2FIX(node->nd_nth));
       break;

data/lib/rubinius/melbourne/version.rb

@@ -1,5 +1,5 @@
-module Rubinius::ToolSets.current::ToolSet
+module CodeTools
   class Melbourne
-    VERSION = "2.1.0.0"
+    VERSION = "2.2.0.0"
   end
 end

data/lib/rubinius/melbourne.rb

@@ -1,7 +1,7 @@
-require "rubinius/melbourne/melbourne"
 require "rubinius/melbourne/version"
+require "rubinius/melbourne/melbourne"
 
-module Rubinius::ToolSets.current::ToolSet
+module CodeTools
   class Melbourne
     attr_accessor :transforms
     attr_accessor :magic_handler

data/rubinius-melbourne.gemspec

@@ -1,5 +1,4 @@
 # -*- encoding: utf-8 -*-
-require 'rubinius/toolset'
 require './lib/rubinius/melbourne/version'
 
 Gem::Specification.new do |spec|
@@ -16,9 +15,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.name          = "rubinius-melbourne"
   spec.require_paths = ["lib"]
-  spec.version       = Rubinius::ToolSets.current::ToolSet::Melbourne::VERSION
-
-  spec.add_runtime_dependency     "rubinius-toolset", "~> 2.2"
+  spec.version       = CodeTools::Melbourne::VERSION
 
   spec.add_development_dependency "rubinius-processor", "~> 2.0"
   spec.add_development_dependency "rubinius-compiler", "~> 2.0"

data/spec/array_spec.rb

@@ -23,6 +23,26 @@ describe "An Array node" do
       [:str, "c"]]
   end
 
+  parse "%i[a b c]" do
+    [:array, [:lit, :a], [:lit, :b], [:lit, :c]]
+  end
+
+  parse '%i[a #{@b} c]' do
+    [:array, [:lit, :a], [:lit, :"\#{@b}"], [:lit, :c]]
+  end
+
+  parse "%I[a b c]" do
+    [:array,
+      [:dsym, "a"], [:dsym, "b"], [:dsym, "c"]]
+  end
+
+  parse '%I[a #{@b} c]' do
+    [:array,
+      [:dsym, "a"],
+      [:dsym, "", [:evstr, [:ivar, :@b]]],
+      [:dsym, "c"]]
+  end
+
   parse "[*[1]]" do
     [:splat, [:array, [:lit, 1]]]
   end

data/spec/custom/matchers/parse_as.rb

@@ -10,7 +10,8 @@ class ParseAsMatcher
   end
 
   def matches?(actual)
-    @actual = actual.to_sexp.to_a
+    parse = CodeTools::Melbourne.parse_string actual
+    @actual = parse.to_sexp.to_a
     @actual == @expected
   end
 

data/spec/defn_spec.rb

@@ -1,8 +1,6 @@
 describe "A Defn node" do
   parse <<-ruby do
       def m
-        begin
-        end
       end
     ruby
 
@@ -10,483 +8,776 @@ describe "A Defn node" do
   end
 
   parse <<-ruby do
-      def m
-        return :a
-      ensure
-        return :b
-      end
+      def m() end
+    ruby
+
+    [:defn, :m, [:args], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a) end
+    ruby
+
+    [:defn, :m, [:args, :a], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m((a)) end
     ruby
 
     [:defn,
      :m,
-     [:args],
-     [:scope, [:block, [:ensure, [:return, [:lit, :a]], [:return, [:lit, :b]]]]]]
+     [:args, [:masgn, [:array, [:lasgn, :a]], [:lvar, :"_:1"]]],
+     [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def blah(*args, &block)
-        other(42, *args, &block)
-      end
+      def m((*a, b)) end
     ruby
 
     [:defn,
-     :blah,
-     [:args, :"*args", :"&block"],
-     [:scope,
-      [:block,
-       [:call,
-        nil,
-        :other,
-        [:arglist,
-         [:lit, 42],
-         [:splat, [:lvar, :args]],
-         [:block_pass, [:lvar, :block]]]]]]]
+     :m,
+     [:args,
+      [:masgn, [:array, [:splat, [:lasgn, :a]]], [:lasgn, :b], [:lvar, :"_:1"]]],
+     [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def blah(*args, &block)
-        other(*args, &block)
-      end
+      def m(a=1) end
     ruby
 
     [:defn,
-     :blah,
-     [:args, :"*args", :"&block"],
-     [:scope,
-      [:block,
-       [:call,
-        nil,
-        :other,
-        [:arglist,
-         [:splat, [:lvar, :args]],
-         [:block_pass, [:lvar, :block]]]]]]]
+      :m,
+      [:args, :a, [:block, [:lasgn, :a, [:lit, 1]]]],
+      [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f
-        begin
-          b
-        rescue
-          c
-        end
+      def m(*) end
+    ruby
 
-        d
-      end
+    [:defn, :m, [:args, :*], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(*a) end
+    ruby
+
+    [:defn, :m, [:args, :"*a"], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a:) end
+    ruby
+
+    [:defn, :m, [:args, :a, [:block, [:a]]], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a: 1) end
     ruby
 
     [:defn,
-     :f,
-     [:args],
-     [:scope,
-      [:block,
-       [:rescue,
-        [:call, nil, :b, [:arglist]],
-        [:resbody,
-         [:array, [:const, :StandardError]],
-         [:call, nil, :c, [:arglist]]]],
-       [:call, nil, :d, [:arglist]]]]]
-  end
-
-  parse <<-ruby do
-      def f
-        a
-        begin
-          b
-        rescue
-          c
-        end
-      end
+     :m,
+     [:args, :a, [:block, [:a], [[:lasgn, :a, [:lit, 1]]]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(**) end
+    ruby
+
+    [:defn, :m, [:args, :**, [:block, [:**]]], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(**k) end
+    ruby
+
+    [:defn, :m, [:args, :"**k", [:block, [:"**k"]]], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(&b) end
+    ruby
+
+    [:defn, :m, [:args, :"&b"], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a, b) end
+    ruby
+
+    [:defn, :m, [:args, :a, :b], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a, (b, c)) end
     ruby
 
     [:defn,
-     :f,
-     [:args],
-     [:scope,
-      [:block,
-       [:call, nil, :a, [:arglist]],
-       [:rescue,
-        [:call, nil, :b, [:arglist]],
-        [:resbody,
-         [:array, [:const, :StandardError]],
-         [:call, nil, :c, [:arglist]]]]]]]
-  end
-
-  parse <<-ruby do
-      def f
-        a
-        begin
-          b
-        rescue
-          c
-        end
-        d
-      end
+     :m,
+     [:args, :a, [:masgn, [:array, [:lasgn, :b], [:lasgn, :c]], [:lvar, :"_:1"]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m((a), (b)) end
     ruby
 
     [:defn,
-     :f,
-     [:args],
-     [:scope,
-      [:block,
-       [:call, nil, :a, [:arglist]],
-       [:rescue,
-        [:call, nil, :b, [:arglist]],
-        [:resbody,
-         [:array, [:const, :StandardError]],
-         [:call, nil, :c, [:arglist]]]],
-       [:call, nil, :d, [:arglist]]]]]
+     :m,
+     [:args,
+      [:masgn, [:array, [:lasgn, :a]], [:lvar, :"_:1"]],
+      [:masgn, [:array, [:lasgn, :b]], [:lvar, :"_:2"]]],
+     [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f(&block)
-      end
+      def m((*), (*)) end
     ruby
 
-    [:defn, :f, [:args, :"&block"], [:scope, [:block, [:nil]]]]
+    [:defn,
+     :m,
+     [:args,
+      [:masgn, [:array, [:splat]], [:lvar, :"_:1"]],
+      [:masgn, [:array, [:splat]], [:lvar, :"_:2"]]],
+     [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f(mand, opt = 42, &block)
-      end
+      def m((*a), (*c)) end
     ruby
 
     [:defn,
-     :f,
-     [:args, :mand, :opt, :"&block", [:block, [:lasgn, :opt, [:lit, 42]]]],
+     :m,
+     [:args,
+      [:masgn, [:array, [:splat, [:lasgn, :a]]], [:lvar, :"_:1"]],
+      [:masgn, [:array, [:splat, [:lasgn, :c]]], [:lvar, :"_:2"]]],
      [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f(x, a=x.b)
-      end
+      def m((a, b), (c, d)) end
     ruby
 
     [:defn,
-     :f,
-     [:args, :x, :a, [:block, [:lasgn, :a, [:call, [:lvar, :x], :b, [:arglist]]]]],
+     :m,
+     [:args,
+      [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]], [:lvar, :"_:1"]],
+      [:masgn, [:array, [:lasgn, :c], [:lasgn, :d]], [:lvar, :"_:2"]]],
      [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f(mand, &block)
-      end
+      def m((a, *b), (*c, d)) end
     ruby
 
-    [:defn, :f, [:args, :mand, :"&block"], [:scope, [:block, [:nil]]]]
+    [:defn,
+     :m,
+     [:args,
+      [:masgn, [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]], [:lvar, :"_:1"]],
+      [:masgn, [:array, [:splat, [:lasgn, :c]]], [:lasgn, :d], [:lvar, :"_:2"]]],
+     [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f(mand, opt = 42)
-      end
+      def m((a, b, *c, d), (*e, f, g), (*h)) end
     ruby
 
     [:defn,
-     :f,
-     [:args, :mand, :opt, [:block, [:lasgn, :opt, [:lit, 42]]]],
+     :m,
+     [:args,
+      [:masgn,
+       [:array, [:lasgn, :a], [:lasgn, :b], [:splat, [:lasgn, :c]]],
+       [:lasgn, :d],
+       [:lvar, :"_:1"]],
+      [:masgn,
+       [:array, [:splat, [:lasgn, :e]]],
+       [:lasgn, :f],
+       [:lasgn, :g],
+       [:lvar, :"_:2"]],
+      [:masgn, [:array, [:splat, [:lasgn, :h]]], [:lvar, :"_:3"]]],
      [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f(mand, opt = 42, *rest, &block)
-      end
+      def m(a, (b, (c, *d), *e)) end
     ruby
 
     [:defn,
-     :f,
+     :m,
      [:args,
-      :mand,
-      :opt,
-      :"*rest",
-      :"&block",
-      [:block, [:lasgn, :opt, [:lit, 42]]]],
+      :a,
+      [:masgn,
+       [:array,
+        [:lasgn, :b],
+        [:masgn, [:array, [:lasgn, :c], [:splat, [:lasgn, :d]]]],
+        [:splat, [:lasgn, :e]]],
+       [:lvar, :"_:1"]]],
      [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def x(a, b = 42, *)
-      end
+      def m(a, (b, (c, *d, (e, (*f)), g), (h, (i, j)))) end
     ruby
 
     [:defn,
-     :x,
-     [:args, :a, :b, :*, [:block, [:lasgn, :b, [:lit, 42]]]],
+     :m,
+     [:args,
+      :a,
+      [: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]]]]]],
+       [:lvar, :"_:1"]]],
      [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f(mand, opt = 42, *rest)
-      end
+      def m(a, b=1) end
     ruby
 
     [:defn,
-     :f,
-     [:args, :mand, :opt, :"*rest", [:block, [:lasgn, :opt, [:lit, 42]]]],
+     :m,
+     [:args, :a, :b, [:block, [:lasgn, :b, [:lit, 1]]]],
      [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def empty
-      end
+      def m(a, *) end
     ruby
 
-    [:defn, :empty, [:args], [:scope, [:block, [:nil]]]]
+    [:defn, :m, [:args, :a, :*], [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f(mand)
-      end
+      def m(a, *b) end
     ruby
 
-    [:defn, :f, [:args, :mand], [:scope, [:block, [:nil]]]]
+    [:defn, :m, [:args, :a, :"*b"], [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f(mand, *rest, &block)
-      end
+      def m(a, b:) end
     ruby
 
-    [:defn, :f, [:args, :mand, :"*rest", :"&block"], [:scope, [:block, [:nil]]]]
+    [:defn, :m, [:args, :a, :b, [:block, [:b]]], [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def x(a, *args)
-        p(a, args)
-      end
+      def m(a, b: 1) end
     ruby
 
     [:defn,
-     :x,
-     [:args, :a, :"*args"],
-     [:scope, [:block, [:call, nil, :p, [:arglist, [:lvar, :a], [:lvar, :args]]]]]]
+     :m,
+     [:args, :a, :b, [:block, [:b], [[:lasgn, :b, [:lit, 1]]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f(mand, *rest)
-      end
+      def m(a, **) end
     ruby
 
-    [:defn, :f, [:args, :mand, :"*rest"], [:scope, [:block, [:nil]]]]
+    [:defn, :m, [:args, :a, :**, [:block, [:**]]], [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f(opt = 42, &block)
-      end
+      def m(a, **k) end
     ruby
 
     [:defn,
-     :f,
-     [:args, :opt, :"&block", [:block, [:lasgn, :opt, [:lit, 42]]]],
+     :m,
+     [:args, :a, :"**k", [:block, [:"**k"]]],
      [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f(a = 42, b = '1', c=lambda {|n| n })
-      end
+      def m(a, &b) end
+    ruby
+
+    [:defn, :m, [:args, :a, :"&b"], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a=1, b) end
+    ruby
+
+    [:defn,
+     :m,
+     [:args, :a, :b, [:block, [:lasgn, :a, [:lit, 1]]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a=1, *) end
+    ruby
+
+    [:defn,
+     :m,
+     [:args, :a, :*, [:block, [:lasgn, :a, [:lit, 1]]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a=1, *b) end
+    ruby
+
+    [:defn,
+     :m,
+     [:args, :a, :"*b", [:block, [:lasgn, :a, [:lit, 1]]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a=1, (b, c)) end
+    ruby
+
+    [:defn,
+     :m,
+     [:args,
+      :a,
+      [:masgn, [:array, [:lasgn, :b], [:lasgn, :c]], [:lvar, :"_:1"]],
+      [:block, [:lasgn, :a, [:lit, 1]]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a=1, (b, (c, *d))) end
+    ruby
+
+    [:defn,
+     :m,
+     [:args,
+      :a,
+      [:masgn,
+       [:array,
+        [:lasgn, :b],
+        [:masgn, [:array, [:lasgn, :c], [:splat, [:lasgn, :d]]]]],
+       [:lvar, :"_:1"]],
+      [:block, [:lasgn, :a, [:lit, 1]]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a=1, (b, (c, *d), *e)) end
+    ruby
+
+    [:defn,
+     :m,
+     [:args,
+      :a,
+      [:masgn,
+       [:array,
+        [:lasgn, :b],
+        [:masgn, [:array, [:lasgn, :c], [:splat, [:lasgn, :d]]]],
+        [:splat, [:lasgn, :e]]],
+       [:lvar, :"_:1"]],
+      [:block, [:lasgn, :a, [:lit, 1]]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a=1, (b), (c)) end
+    ruby
+
+    [:defn,
+     :m,
+     [:args,
+      :a,
+      [:masgn, [:array, [:lasgn, :b]], [:lvar, :"_:1"]],
+      [:masgn, [:array, [:lasgn, :c]], [:lvar, :"_:2"]],
+      [:block, [:lasgn, :a, [:lit, 1]]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a=1, (*b), (*c)) end
+    ruby
+
+    [:defn,
+     :m,
+     [:args,
+      :a,
+      [:masgn, [:array, [:splat, [:lasgn, :b]]], [:lvar, :"_:1"]],
+      [:masgn, [:array, [:splat, [:lasgn, :c]]], [:lvar, :"_:2"]],
+      [:block, [:lasgn, :a, [:lit, 1]]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a=1, (b, c), (d, e)) end
+    ruby
+
+    [:defn,
+     :m,
+     [:args,
+      :a,
+      [:masgn, [:array, [:lasgn, :b], [:lasgn, :c]], [:lvar, :"_:1"]],
+      [:masgn, [:array, [:lasgn, :d], [:lasgn, :e]], [:lvar, :"_:2"]],
+      [:block, [:lasgn, :a, [:lit, 1]]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a=1, (b, *c), (*d, e)) end
     ruby
 
     [:defn,
-     :f,
+     :m,
+     [:args,
+      :a,
+      [:masgn, [:array, [:lasgn, :b], [:splat, [:lasgn, :c]]], [:lvar, :"_:1"]],
+      [:masgn, [:array, [:splat, [:lasgn, :d]]], [:lasgn, :e], [:lvar, :"_:2"]],
+      [:block, [:lasgn, :a, [:lit, 1]]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a=1, (b, *c), (d, (*e, f))) end
+    ruby
+
+    [:defn,
+     :m,
+     [:args,
+      :a,
+      [:masgn, [:array, [:lasgn, :b], [:splat, [:lasgn, :c]]], [:lvar, :"_:1"]],
+      [:masgn,
+       [:array,
+        [:lasgn, :d],
+        [:masgn, [:array, [:splat, [:lasgn, :e]]], [:lasgn, :f]]],
+       [:lvar, :"_:2"]],
+      [:block, [:lasgn, :a, [:lit, 1]]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a=1, b:) end
+    ruby
+
+    [:defn,
+     :m,
+     [:args, :a, :b, [:block, [:lasgn, :a, [:lit, 1]]], [:block, [:b]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a=1, b: 2) end
+    ruby
+
+    [:defn,
+     :m,
      [:args,
       :a,
       :b,
-      :c,
-      [:block,
-       [:lasgn, :a, [:lit, 42]],
-       [:lasgn, :b, [:str, "1"]],
-       [:lasgn,
-        :c,
-        [:call, nil, :lambda, [:arglist, [:iter, [:args, :n], [:lvar, :n]]]]]]],
+      [:block, [:lasgn, :a, [:lit, 1]]],
+      [:block, [:b], [[:lasgn, :b, [:lit, 2]]]]],
      [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f(opt = 42)
-      end
+      def m(a=1, **) end
     ruby
 
     [:defn,
-     :f,
-     [:args, :opt, [:block, [:lasgn, :opt, [:lit, 42]]]],
+     :m,
+     [:args, :a, :**, [:block, [:lasgn, :a, [:lit, 1]]], [:block, [:**]]],
      [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f(opt = 42, *rest, &block)
-      end
+      def m(a=1, **k) end
     ruby
 
     [:defn,
-     :f,
-     [:args, :opt, :"*rest", :"&block", [:block, [:lasgn, :opt, [:lit, 42]]]],
+     :m,
+     [:args, :a, :"**k", [:block, [:lasgn, :a, [:lit, 1]]], [:block, [:"**k"]]],
      [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def x(b = 42, *)
-      end
+      def m(a=1, &b) end
     ruby
 
     [:defn,
-     :x,
-     [:args, :b, :*, [:block, [:lasgn, :b, [:lit, 42]]]],
+     :m,
+     [:args, :a, :"&b", [:block, [:lasgn, :a, [:lit, 1]]]],
      [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f(opt = 42, *rest)
-      end
+      def m(*, a) end
+    ruby
+
+    [:defn, :m, [:args, :*, :a], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(*a, b) end
+    ruby
+
+    [:defn, :m, [:args, :"*a", :b], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(*, a:) end
+    ruby
+
+    [:defn, :m, [:args, :*, :a, [:block, [:a]]], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(*a, b:) end
+    ruby
+
+    [:defn, :m, [:args, :"*a", :b, [:block, [:b]]], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(*, a: 1) end
     ruby
 
     [:defn,
-     :f,
-     [:args, :opt, :"*rest", [:block, [:lasgn, :opt, [:lit, 42]]]],
+     :m,
+     [:args, :*, :a, [:block, [:a], [[:lasgn, :a, [:lit, 1]]]]],
      [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def |(o)
-      end
+      def m(*a, b: 1) end
     ruby
 
-    [:defn, :|, [:args, :o], [:scope, [:block, [:nil]]]]
+    [:defn,
+     :m,
+     [:args, :"*a", :b, [:block, [:b], [[:lasgn, :b, [:lit, 1]]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def eql?(resource)
-        (self.uuid == resource.uuid)
-      rescue
-        false
-      end
+      def m(*, **) end
+    ruby
+
+    [:defn, :m, [:args, :*, :**, [:block, [:**]]], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(*a, **) end
+    ruby
+
+    [:defn, :m, [:args, :"*a", :**, [:block, [:**]]], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(*, **k) end
     ruby
 
     [:defn,
-     :eql?,
-     [:args, :resource],
-     [:scope,
-      [:block,
-       [:rescue,
-        [:call,
-         [:call, [:self], :uuid, [:arglist]],
-         :==,
-         [:arglist, [:call, [:lvar, :resource], :uuid, [:arglist]]]],
-        [:resbody, [:array, [:const, :StandardError]], [:false]]]]]]
+     :m,
+     [:args, :*, :"**k", [:block, [:"**k"]]],
+     [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def something?
-      end
+      def m(*a, **k) end
     ruby
 
-    [:defn, :something?, [:args], [:scope, [:block, [:nil]]]]
+    [:defn,
+     :m,
+     [:args, :"*a", :"**k", [:block, [:"**k"]]],
+     [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def x(*)
-      end
+      def m(*, &b) end
     ruby
 
-    [:defn, :x, [:args, :*], [:scope, [:block, [:nil]]]]
+    [:defn, :m, [:args, :*, :"&b"], [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def f(*rest)
-      end
+      def m(*a, &b) end
     ruby
 
-    [:defn, :f, [:args, :"*rest"], [:scope, [:block, [:nil]]]]
+    [:defn, :m, [:args, :"*a", :"&b"], [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def x(a, *)
-        p(a)
-      end
+      def m(a:, b:) end
+    ruby
+
+    [:defn, :m, [:args, :a, :b, [:block, [:a, :b]]], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a:, b: 1) end
     ruby
 
     [:defn,
-     :x,
-     [:args, :a, :*],
-     [:scope, [:block, [:call, nil, :p, [:arglist, [:lvar, :a]]]]]]
+     :m,
+     [:args, :a, :b, [:block, [:a, :b], [[:lasgn, :b, [:lit, 1]]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def zarray
-        a = []
-        return a
-      end
+      def m(a:, **) end
+    ruby
+
+    [:defn, :m, [:args, :a, :**, [:block, [:a, :**]]], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a:, **k) end
     ruby
 
     [:defn,
-     :zarray,
-     [:args],
-     [:scope, [:block, [:lasgn, :a, [:array]], [:return, [:lvar, :a]]]]]
+     :m,
+     [:args, :a, :"**k", [:block, [:a, :"**k"]]],
+     [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      b = 42
-      def a
-        c do
-          begin
-            do_stuff
-          rescue RuntimeError => b
-            puts(b)
-          end
-        end
-      end
+      def m(a:, &b) end
+    ruby
+
+    [:defn, :m, [:args, :a, :"&b", [:block, [:a]]], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a: 1, b:) end
     ruby
 
-    [:block,
-     [:lasgn, :b, [:lit, 42]],
-     [:defn,
+    [:defn,
+     :m,
+     [:args, :a, :b, [:block, [:a, :b], [[:lasgn, :a, [:lit, 1]]]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a: def m(a: 1) a end, b:) end
+    ruby
+
+    [:defn,
+     :m,
+     [:args,
       :a,
-      [:args],
-      [:scope,
-       [:block,
-        [:call,
-         nil,
-         :c,
-         [:arglist,
-          [:iter,
-           [:args],
-           [:rescue,
-            [:call, nil, :do_stuff, [:arglist]],
-            [:resbody,
-             [:array, [:const, :RuntimeError], [:lasgn, :b, [:gvar, :$!]]],
-             [:call, nil, :puts, [:arglist, [:lvar, :b]]]]]]]]]]]]
-  end
-
-  parse <<-ruby do
-      def x(a=0.0,b=0.0)
-        a+b
-      end
+      :b,
+      [:block,
+       [:a, :b],
+       [[:lasgn,
+         :a,
+         [:defn,
+          :m,
+          [:args, :a, [:block, [:a], [[:lasgn, :a, [:lit, 1]]]]],
+          [:scope, [:block, [:lvar, :a]]]]]]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a: 1, b: 2) end
     ruby
 
     [:defn,
-     :x,
+     :m,
      [:args,
       :a,
       :b,
-      [:block, [:lasgn, :a, [:lit, 0.0]], [:lasgn, :b, [:lit, 0.0]]]],
-     [:scope, [:block, [:call, [:lvar, :a], :+, [:arglist, [:lvar, :b]]]]]]
+      [:block, [:a, :b], [[:lasgn, :a, [:lit, 1]], [:lasgn, :b, [:lit, 2]]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def x(*b)
-        a(*b)
-      end
+      def m(a: 1, **) end
     ruby
 
     [:defn,
-     :x,
-     [:args, :"*b"],
-     [:scope, [:block, [:call, nil, :a, [:arglist, [:splat, [:lvar, :b]]]]]]]
+     :m,
+     [:args, :a, :**, [:block, [:a, :**], [[:lasgn, :a, [:lit, 1]]]]],
+     [:scope, [:block, [:nil]]]]
   end
 
   parse <<-ruby do
-      def meth(b)
-        b
+      def m(a: 1, **k) end
+    ruby
+
+    [:defn,
+     :m,
+     [:args, :a, :"**k", [:block, [:a, :"**k"], [[:lasgn, :a, [:lit, 1]]]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a: 1, &b) end
+    ruby
+
+    [:defn,
+     :m,
+     [:args, :a, :"&b", [:block, [:a], [[:lasgn, :a, [:lit, 1]]]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(**, &b) end
+    ruby
+
+    [:defn, :m, [:args, :**, :"&b", [:block, [:**]]], [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(**k, &b) end
+    ruby
+
+    [:defn,
+     :m,
+     [:args, :"**k", :"&b", [:block, [:"**k"]]],
+     [:scope, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m(a, b=1, *c, d, e:, f: 2, g:, **k, &l) end
+    ruby
+
+    [:defn,
+     :m,
+     [: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, [:block, [:nil]]]]
+  end
+
+  parse <<-ruby do
+      def m a, b=1, *c, d, e:, f: 2, g:, **k, &l
       end
     ruby
 
-    [:defn, :meth, [:args, :b], [:scope, [:block, [:lvar, :b]]]]
+    [:defn,
+     :m,
+     [: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, [:block, [:nil]]]]
   end
 end