ParseTree 1.7.1 → 2.0.0

data/lib/unified_ruby.rb

@@ -0,0 +1,147 @@
+
+module UnifiedRuby
+  def rewrite_bmethod(exp)
+    exp[0] = :scope
+
+    args =
+      if exp.masgn and exp.masgn.dasgn_curr then
+        arg = exp.masgn(true).dasgn_curr(true).sexp_body
+        raise "nope: #{arg.size}" unless arg.size == 1
+        s(:args, :"*#{arg.last}")
+      else
+        args = exp.dasgn_curr(true)
+        if args then
+          s(:args, *args.sexp_body)
+        else
+          exp.delete_at 1 # nil
+          s(:args)
+        end
+      end
+
+    exp = s(:scope, s(:block, *exp.sexp_body)) unless exp.block
+    exp.block.insert 1, args
+    exp.find_and_replace_all(:dvar, :lvar)
+
+    exp
+  end
+
+  ##
+  # :defn is one of the most complex of all the ASTs in ruby. We do
+  # one of 3 different translations:
+  #
+  # 1) From:
+  #
+  #   s(:defn, :name, s(:scope, s(:block, s(:args, ...), ...)))
+  #   s(:defn, :name, s(:bmethod, s(:masgn, s(:dasgn_curr, :args)), s(:block, ...)))
+  #   s(:defn, :name, s(:fbody, s(:bmethod, s(:masgn, s(:dasgn_curr, :splat)), s(:block, ...))))
+  #
+  # to:
+  #
+  #   s(:defn, :name, s(:args, ...), s(:scope, s:(block, ...)))
+  #
+  # 2) From:
+  #
+  #   s(:defn, :writer=, s(:attrset, :@name))
+  #
+  # to:
+  #
+  #   s(:defn, :writer=, s(:args), s(:attrset, :@name))
+  #
+  # 3) From:
+  #
+  #   s(:defn, :reader, s(:ivar, :@name))
+  #
+  # to:
+  #
+  #   s(:defn, :reader, s(:args), s(:ivar, :@name))
+  #
+  #
+
+  def rewrite_defn(exp)
+    weirdo = exp.ivar || exp.attrset
+
+    # move args up
+    args = exp.scope.block.args(true) unless weirdo
+    exp.insert 2, args if args
+
+    # move block_arg up and in
+    block_arg = exp.scope.block.block_arg(true) rescue nil
+    exp.args << block_arg if block_arg
+
+    # patch up attr_accessor methods
+    exp.insert 2, s(:args) if weirdo
+
+    exp
+  end
+
+  def rewrite_dmethod(exp)
+    exp.shift # type
+    exp.shift # dmethod name
+    exp.shift # scope / block / body
+  end
+
+  def rewrite_fbody(exp)
+    return *exp.sexp_body
+  end
+
+  def rewrite_fcall(exp)
+    exp[0] = :call
+    exp.insert 1, nil
+    exp.push nil if exp.size <= 3
+
+    args = exp[-1]
+    if Array === args and args.first == :array then
+      args[0] = :arglist
+    elsif args.nil? then
+      exp[-1] = s(:arglist)
+    else
+      exp[-1] = s(:arglist, args) unless args.nil?
+    end
+
+    exp
+  end
+
+  def rewrite_resbody(exp) # TODO: clean up and move to unified
+    result = s()
+
+    code = result
+    while exp and exp.first == :resbody do
+      code << exp.shift
+      list = exp.shift || s(:array)
+      body = exp.shift rescue nil
+      exp  = exp.shift rescue nil
+
+      # code may be nil, :lasgn, or :block
+      case body.first
+      when nil then
+        # do nothing
+      when :lasgn then
+        # TODO: check that it is assigning $!
+        list << body
+        body = nil
+      when :block then
+        # TODO: check that it is assigning $!
+        list << body.delete_at(1) if body[1].first == :lasgn
+      else
+        # do nothing (expression form)
+      end if body
+
+      code << list << body
+      if exp then
+        code = s()
+        result << code
+      end
+    end
+
+    raise unless result.first == :resbody
+    raise unless Sexp === result[1] and result[1].first == :array
+    raise unless result[2].nil? or (Sexp === result[2] and ! result[2].empty?)
+
+    result
+  end
+
+  def rewrite_vcall(exp)
+    exp.push nil
+    rewrite_fcall(exp)
+  end
+end

data/test/pt_testcase.rb

@@ -1,3 +1,5 @@
+$TESTING = true
+
 require 'test/unit/testcase'
 require 'sexp_processor' # for deep_clone
 require 'unique'
@@ -9,6 +11,10 @@ class Examples
   def a_method(x); x+1; end
   alias an_alias a_method
 
+  define_method(:bmethod_noargs) do
+    x + 1
+  end
+
   define_method(:unsplatted) do |x|
     x + 1
   end
@@ -133,11 +139,32 @@ class ParseTreeTestCase < Test::Unit::TestCase
                            [:nil]]]
     },
 
+    "block_lasgn" => {
+      "Ruby"        => "x = (y = 1\n(y + 2))",
+      "ParseTree"   => [:lasgn, :x,
+                        [:block,
+                         [:lasgn, :y, [:lit, 1]],
+                         [:call, [:lvar, :y], :+, [:array, [:lit, 2]]]]],
+    },
+
     "block_pass"  => {
       "Ruby"        => "a(&b)",
       "ParseTree"   => [:block_pass, [:vcall, :b], [:fcall, :a]],
     },
 
+    "block_pass_args_and_splat" => {
+      "Ruby" => "def blah(*args, &block)\n  other(42, *args, &block)\nend",
+      "ParseTree" => [:defn, :blah,
+                      [:scope,
+                       [:block,
+                        [:args, "*args".intern],
+                        [:block_arg, :block],
+                        [:block_pass,
+                         [:lvar, :block],
+                         [:fcall, :other,
+                          [:argscat, [:array, [:lit, 42]], [:lvar, :args]]]]]]],
+    },
+
     "block_pass_omgwtf" => {
       "Ruby" => "define_attr_method(:x, :sequence_name, &Proc.new { |*args| nil })",
       "ParseTree" => [:block_pass,
@@ -161,29 +188,26 @@ class ParseTreeTestCase < Test::Unit::TestCase
                          [:fcall, :other, [:splat, [:lvar, :args]]]]]]],
     },
 
-    "block_pass_args_and_splat" => {
-      "Ruby" => "def blah(*args, &block)\n  other(42, *args, &block)\nend",
-      "ParseTree" => [:defn, :blah,
-                      [:scope,
-                       [:block,
-                        [:args, "*args".intern],
-                        [:block_arg, :block],
-                        [:block_pass,
-                         [:lvar, :block],
-                         [:fcall, :other,
-                          [:argscat, [:array, [:lit, 42]], [:lvar, :args]]]]]]],
-    },
-
     "bmethod"  => {
       "Ruby"        => [Examples, :unsplatted],
       "ParseTree"   => [:defn,
                         :unsplatted,
                         [:bmethod,
                          [:dasgn_curr, :x],
-                         [:call, [:dvar, :x], "+".intern, [:array, [:lit, 1]]]]],
+                         [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]],
       "Ruby2Ruby"   => "def unsplatted(x)\n  (x + 1)\nend"
     },
 
+    "bmethod_noargs"  => {
+      "Ruby"        => [Examples, :bmethod_noargs],
+      "ParseTree"   => [:defn,
+                        :bmethod_noargs,
+                        [:bmethod,
+                         nil,
+                         [:call, [:vcall, :x], "+".intern, [:array, [:lit, 1]]]]],
+      "Ruby2Ruby"   => "def bmethod_noargs\n  (x + 1)\nend"
+    },
+
     "bmethod_splat" => {
       "Ruby" => [Examples, :splatted],
       "ParseTree" => [:defn, :splatted,
@@ -218,6 +242,14 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:fcall, :puts, [:array, [:lit, 42]]],
     },
 
+    "call_expr" => {
+      "Ruby"        => "(v = (1 + 1)).zero?",
+      "ParseTree"   => [:call,
+                        [:lasgn, :v,
+                         [:call, [:lit, 1], :+, [:array, [:lit, 1]]]],
+                        :zero?],
+    },
+
     "call_index" => { # see attrasgn_index_equals for opposite
       "Ruby"        => "a[42]",
       "ParseTree"   => [:call, [:vcall, :a], :[], [:array, [:lit, 42]]],
@@ -310,14 +342,6 @@ class ParseTreeTestCase < Test::Unit::TestCase
                              [:fcall, :puts, [:array, [:str, "hello"]]]]]]]]],
     },
 
-    "class_super_object"  => {
-      "Ruby"        => "class X < Object\nend",
-      "ParseTree"   => [:class,
-                        :X,
-                        [:const, :Object],
-                        [:scope]],
-    },
-
     "class_super_array"  => {
       "Ruby"        => "class X < Array\nend",
       "ParseTree"   => [:class,
@@ -334,6 +358,14 @@ class ParseTreeTestCase < Test::Unit::TestCase
                         [:scope]],
     },
 
+    "class_super_object"  => {
+      "Ruby"        => "class X < Object\nend",
+      "ParseTree"   => [:class,
+                        :X,
+                        [:const, :Object],
+                        [:scope]],
+    },
+
     "colon2"  => {
       "Ruby"        => "X::Y",
       "ParseTree"   => [:colon2, [:const, :X], :Y],
@@ -458,14 +490,15 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:defn, :something?, [:scope, [:block, [:args], [:nil]]]],
     },
 
-# TODO:
-#   add_test("defn_optargs",
-#            s(:defn, :x,
-#              s(:args, :a, "*args".intern),
-#              s(:scope,
-#                s(:block,
-#                  s(:call, nil, :p,
-#                    s(:arglist, s(:lvar, :a), s(:lvar, :args)))))))
+    "defn_optargs" => {
+      "Ruby"      => "def x(a, *args)\n  p(a, args)\nend",
+      "ParseTree" => [:defn, :x,
+                      [:scope,
+                       [:block,
+                        [:args, :a, "*args".intern],
+                        [:fcall, :p,
+                         [:array, [:lvar, :a], [:lvar, :args]]]]]],
+    },
 
     "defn_or" => {
       "Ruby"        => "def |(o)\n  # do nothing\nend",
@@ -475,15 +508,25 @@ class ParseTreeTestCase < Test::Unit::TestCase
     "defn_rescue" => {
       "Ruby" => "def eql?(resource)\n  (self.uuid == resource.uuid) rescue false\nend",
       "ParseTree" => [:defn, :eql?,
-           [:scope,
-            [:block,
-             [:args, :resource],
-             [:rescue,
-              [:call,
-               [:call, [:self], :uuid],
-               :==,
-               [:array, [:call, [:lvar, :resource], :uuid]]],
-              [:resbody, nil, [:false]]]]]],
+                      [:scope,
+                       [:block,
+                        [:args, :resource],
+                        [:rescue,
+                         [:call,
+                          [:call, [:self], :uuid],
+                          :==,
+                          [:array, [:call, [:lvar, :resource], :uuid]]],
+                         [:resbody, nil, [:false]]]]]],
+    },
+
+    "defn_splat_no_name" => {
+      "Ruby"      => "def x(a, *)\n  p(a)\nend",
+      "ParseTree" => [:defn, :x,
+                      [:scope,
+                       [:block,
+                        [:args, :a, "*".intern],
+                        [:fcall, :p,
+                         [:array, [:lvar, :a]]]]]],
     },
 
     "defn_zarray" => { # tests memory allocation for returns
@@ -668,11 +711,41 @@ end",
       "ParseTree"   => [:hash, [:lit, 1], [:lit, 2], [:lit, 3], [:lit, 4]],
     },
 
+    "hash_rescue"  => {
+      "Ruby"        => "{ 1 => (2 rescue 3) }",
+      "ParseTree"   => [:hash,
+                        [:lit, 1],
+                        [:rescue, [:lit, 2], [:resbody, nil, [:lit, 3]]]],
+    },
+
     "iasgn"  => {
       "Ruby"        => "@a = 4",
       "ParseTree"   => [:iasgn, :@a, [:lit, 4]],
     },
 
+    "if_block_condition" => {
+      "Ruby"        => "if (x = 5\n(x + 1)) then\n  nil\nend",
+      "ParseTree"   => [:if,
+                        [:block,
+                         [:lasgn, :x, [:lit, 5]],
+                         [:call,
+                          [:lvar, :x],
+                          :+,
+                          [:array, [:lit, 1]]]],
+                        [:nil],
+                        nil],
+    },
+
+    "if_lasgn_short" => {
+      "Ruby"        => "if x = obj.x then\n  x.do_it\nend",
+      "ParseTree"   => [:if,
+                        [:lasgn, :x,
+                         [:call, [:vcall, :obj], :x]],
+                        [:call,
+                         [:lvar, :x], :do_it],
+                        nil],
+    },
+
     "iteration1" => {
       "Ruby"        => "loop { }",
       "ParseTree"   => [:iter, [:fcall, :loop], nil],
@@ -811,11 +884,14 @@ end",
                         [:array,  [:vcall, :c], [:vcall, :d]]],
     },
 
-    "masgn_iasgn"  => {
-      "Ruby"        => "a, @b = c, d",
+    "masgn_argscat"  => {
+      "Ruby"        => "a, b, *c = 1, 2, *[3, 4]",
       "ParseTree"   => [:masgn,
-                        [:array, [:lasgn, :a], [:iasgn, "@b".intern]],
-                        [:array,  [:vcall, :c], [:vcall, :d]]],
+                        [:array, [:lasgn, :a], [:lasgn, :b]],
+                        [:lasgn, :c],
+                        [:argscat,
+                         [:array, [:lit, 1], [:lit, 2]],
+                         [:array, [:lit, 3], [:lit, 4]]]]
     },
 
     "masgn_attrasgn"  => {
@@ -825,6 +901,31 @@ end",
                          [:array, [:vcall, :d], [:vcall, :e]]],
     },
 
+    "masgn_iasgn"  => {
+      "Ruby"        => "a, @b = c, d",
+      "ParseTree"   => [:masgn,
+                        [:array, [:lasgn, :a], [:iasgn, "@b".intern]],
+                        [:array,  [:vcall, :c], [:vcall, :d]]],
+    },
+
+    "masgn_masgn" => {
+      "Ruby"        => "a, (b, c) = [1, [2, 3]]",
+      "ParseTree"   => [:masgn,
+                        [:array,
+                         [:lasgn, :a],
+                         [:masgn,
+                          [:array,
+                           [:lasgn, :b],
+                           [:lasgn, :c]]]],
+                        [:to_ary,
+                         [:array,
+                          [:lit, 1],
+                          [:array,
+                           [:lit, 2],
+                           [:lit, 3]]]]]
+
+    },
+
     "masgn_splat"  => {
       "Ruby"        => "a, b, *c = d, e, f, g",
       "ParseTree"   => [:masgn,
@@ -835,7 +936,6 @@ end",
                          [:vcall, :f], [:vcall, :g]]]
     },
 
-
     "match"  => {
       "Ruby"        => "1 if /x/",
       "ParseTree"   => [:if, [:match, [:lit, /x/]], [:lit, 1], nil],
@@ -994,8 +1094,12 @@ end",
     },
 
     "splat"  => {
-      "Ruby"        => "a(*b)",
-      "ParseTree"   => [:fcall, :a, [:splat, [:vcall, :b]]],
+      "Ruby"        => "def x(*b)\n  a(*b)\nend",
+      "ParseTree"   => [:defn, :x,
+                        [:scope,
+                         [:block,
+                          [:args, :"*b"],
+                          [:fcall, :a, [:splat, [:lvar, :b]]]]]],
     },
 
     # TODO: all supers need to pass args
@@ -1070,6 +1174,12 @@ end",
       "ParseTree"   => [:vcall, :method],
     },
 
+    "while_post" => {
+      "Ruby"        => "begin\n  (1 + 1)\nend while false",
+      "ParseTree"   => [:while, [:false],
+                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], false],
+    },
+
     "while_pre" => {
       "Ruby"        => "while false do\n  (1 + 1)\nend",
       "ParseTree"   => [:while, [:false],
@@ -1081,12 +1191,6 @@ end",
       "ParseTree"   => [:while, [:false], nil, true],
     },
 
-    "while_post" => {
-      "Ruby"        => "begin\n  (1 + 1)\nend while false",
-      "ParseTree"   => [:while, [:false],
-                        [:call, [:lit, 1], :+, [:array, [:lit, 1]]], false],
-    },
-
     "xstr" => {
       "Ruby"        => "`touch 5`",
       "ParseTree"   => [:xstr, 'touch 5'],
@@ -1170,7 +1274,8 @@ end",
 
   def self.inherited(c)
     output_name = c.name.to_s.sub(/^Test/, '')
-    raise "Unknown class #{c}" unless @@testcase_order.include? output_name
+    raise "Unknown class #{c} in @@testcase_order" unless
+      @@testcase_order.include? output_name
 
     input_name = self.previous(output_name)