ruby_parser 2.0.5 → 3.0.0.a1

data/test/test_ruby_parser.rb

@@ -1,6 +1,9 @@
 #!/usr/local/bin/ruby
 
+ENV['VERBOSE'] = "1"
+
 require 'rubygems'
+gem "minitest"
 require 'minitest/autorun'
 require 'ruby_parser'
 
@@ -8,13 +11,21 @@ $: << File.expand_path('~/Work/p4/zss/src/ParseTree/dev/test')
 
 require 'pt_testcase'
 
-class RubyParser
+class Ruby18Parser # FIX
+  def process input
+    parse input
+  end
+end
+
+class Ruby19Parser
   def process input
     parse input
   end
 end
 
 class RubyParserTestCase < ParseTreeTestCase
+  attr_accessor :result, :processor
+
   def self.previous key
     "Ruby"
   end
@@ -27,88 +38,95 @@ class RubyParserTestCase < ParseTreeTestCase
 
     super
   end
-end
 
-class TestRubyParser < RubyParserTestCase
-  def setup
-    super
-
-    # puts self.name
+  def assert_parse rb, pt
+    self.result = processor.parse rb
+    assert_equal pt, result
+  end
 
-    @processor = RubyParser.new
+  def assert_parse_line rb, pt, line
+    assert_parse rb, pt
+    assert_equal line, result.line,   "call should have line number"
   end
+end
 
+module TestRubyParser
   def test_attrasgn_array_lhs
     rb = '[1, 2, 3, 4][from .. to] = ["a", "b", "c"]'
     pt = s(:attrasgn,
            s(:array, s(:lit, 1), s(:lit, 2), s(:lit, 3), s(:lit, 4)),
            :[]=,
-           s(:arglist,
-             s(:dot2,
-               s(:call, nil, :from, s(:arglist)),
-               s(:call, nil, :to, s(:arglist))),
-             s(:array, s(:str, "a"), s(:str, "b"), s(:str, "c"))))
-
-    result = @processor.parse(rb)
+           s(:dot2,
+             s(:call, nil, :from),
+             s(:call, nil, :to)),
+           s(:array, s(:str, "a"), s(:str, "b"), s(:str, "c")))
 
-    assert_equal pt, result
+    assert_parse rb, pt
   end
 
   def test_block_append
     head = s(:args)
     tail = s(:zsuper)
     expected = s(:block, s(:args), s(:zsuper))
-    assert_equal expected, @processor.block_append(head, tail)
+    assert_equal expected, processor.block_append(head, tail)
   end
 
   def test_block_append_begin_begin
     head = s(:begin, s(:args))
     tail = s(:begin, s(:args))
     expected = s(:block, s(:args), s(:begin, s(:args)))
-    assert_equal expected, @processor.block_append(head, tail)
+    assert_equal expected, processor.block_append(head, tail)
   end
 
   def test_block_append_block
     head = s(:block, s(:args))
     tail = s(:zsuper)
     expected = s(:block, s(:args), s(:zsuper))
-    assert_equal expected, @processor.block_append(head, tail)
+    assert_equal expected, processor.block_append(head, tail)
   end
 
   def test_block_append_nil_head
     head = nil
     tail = s(:zsuper)
     expected = s(:zsuper)
-    assert_equal expected, @processor.block_append(head, tail)
+    assert_equal expected, processor.block_append(head, tail)
   end
 
   def test_block_append_nil_tail
     head = s(:args)
     tail = nil
     expected = s(:args)
-    assert_equal expected, @processor.block_append(head, tail)
+    assert_equal expected, processor.block_append(head, tail)
   end
 
   def test_block_append_tail_block
-    head = s(:call, nil, :f1, s(:arglist))
+    head = s(:call, nil, :f1)
     tail = s(:block, s(:undef, s(:lit, :x)), s(:undef, s(:lit, :y)))
     expected = s(:block,
-                 s(:call, nil, :f1, s(:arglist)),
+                 s(:call, nil, :f1),
                  s(:block, s(:undef, s(:lit, :x)), s(:undef, s(:lit, :y))))
-    assert_equal expected, @processor.block_append(head, tail)
+    assert_equal expected, processor.block_append(head, tail)
+  end
+
+  def test_call_array_arg
+    rb = "1 == [:b, :c]"
+    pt = s(:call, s(:lit, 1), :==, s(:array, s(:lit, :b), s(:lit, :c)))
+
+    assert_parse rb, pt
   end
 
   def test_call_env
-    @processor.env[:a] = :lvar
-    expected = s(:call, s(:lvar, :a), :happy, s(:arglist))
+    processor.env[:a] = :lvar
+    rb = "a.happy"
+    pt = s(:call, s(:lvar, :a), :happy)
 
-    assert_equal expected, @processor.parse('a.happy')
+    assert_parse rb, pt
   end
 
   def test_dasgn_icky2
     rb = "a do\n  v = nil\n  begin\n    yield\n  rescue Exception => v\n    break\n  end\nend"
     pt = s(:iter,
-           s(:call, nil, :a, s(:arglist)),
+           s(:call, nil, :a),
            nil,
            s(:block,
              s(:lasgn, :v, s(:nil)),
@@ -118,96 +136,125 @@ class TestRubyParser < RubyParserTestCase
                  s(:array, s(:const, :Exception), s(:lasgn, :v, s(:gvar, :$!))),
                  s(:break)))))
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_class_comments
     rb = "# blah 1\n# blah 2\n\nclass X\n  # blah 3\n  def blah\n    # blah 4\n  end\nend"
     pt = s(:class, :X, nil,
-           s(:scope,
-             s(:defn, :blah, s(:args), s(:scope, s(:block, s(:nil))))))
+           s(:defn, :blah, s(:args), s(:nil)))
 
-    actual = @processor.parse(rb)
-    assert_equal pt, actual
+    assert_parse rb, pt
 
-    assert_equal "# blah 1\n# blah 2\n\n", actual.comments
-    assert_equal "# blah 3\n", actual.scope.defn.comments
+    assert_equal "# blah 1\n# blah 2\n\n", result.comments
+    assert_equal "# blah 3\n", result.defn.comments
   end
 
   def test_module_comments
     rb = "# blah 1\n  \n  # blah 2\n\nmodule X\n  # blah 3\n  def blah\n    # blah 4\n  end\nend"
     pt = s(:module, :X,
-           s(:scope,
-             s(:defn, :blah, s(:args), s(:scope, s(:block, s(:nil))))))
+           s(:defn, :blah, s(:args), s(:nil)))
 
-    actual = @processor.parse(rb)
-    assert_equal pt, actual
-    assert_equal "# blah 1\n\n# blah 2\n\n", actual.comments
-    assert_equal "# blah 3\n", actual.scope.defn.comments
+    assert_parse rb, pt
+    assert_equal "# blah 1\n\n# blah 2\n\n", result.comments
+    assert_equal "# blah 3\n", result.defn.comments
   end
 
   def test_defn_comments
     rb = "# blah 1\n# blah 2\n\ndef blah\nend"
-    pt = s(:defn, :blah, s(:args), s(:scope, s(:block, s(:nil))))
+    pt = s(:defn, :blah, s(:args), s(:nil))
 
-    actual = @processor.parse(rb)
-    assert_equal pt, actual
-    assert_equal "# blah 1\n# blah 2\n\n", actual.comments
+    assert_parse rb, pt
+    assert_equal "# blah 1\n# blah 2\n\n", result.comments
   end
 
   def test_defs_comments
     rb = "# blah 1\n# blah 2\n\ndef self.blah\nend"
-    pt = s(:defs, s(:self), :blah, s(:args), s(:scope, s(:block)))
+    pt = s(:defs, s(:self), :blah, s(:args))
 
-    actual = @processor.parse(rb)
-    assert_equal pt, actual
-    assert_equal "# blah 1\n# blah 2\n\n", actual.comments
+    assert_parse rb, pt
+    assert_equal "# blah 1\n# blah 2\n\n", result.comments
   end
 
   def test_do_bug # TODO: rename
     rb = "a 1\na.b do |c|\n  # do nothing\nend"
     pt = s(:block,
-           s(:call, nil, :a, s(:arglist, s(:lit, 1))),
+           s(:call, nil, :a, s(:lit, 1)),
            s(:iter,
-             s(:call, s(:call, nil, :a, s(:arglist)), :b, s(:arglist)),
+             s(:call, s(:call, nil, :a), :b),
              s(:lasgn, :c)))
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
+  end
+
+  def test_bug_comment_eq_begin
+    rb = "\n\n#\n=begin\nblah\n=end\n\n"
+    pt = nil
+    exp = rb.strip + "\n"
+
+    assert_parse rb, pt
+    assert_equal exp, processor.lexer.comments
+  end
+
+  def test_bug_call_arglist_parens
+    rb = 'g ( 1), 2'
+    pt = s(:call, nil, :g, s(:lit, 1), s(:lit, 2))
+
+    assert_parse rb, pt
+
+    rb = <<-CODE
+      def f
+        g ( 1), 2
+      end
+    CODE
+
+    pt = s(:defn, :f, s(:args),
+           s(:call, nil, :g, s(:lit, 1), s(:lit, 2)))
+
+    assert_parse rb, pt
+
+    rb = <<-CODE
+      def f()
+        g (1), 2
+      end
+    CODE
+
+    assert_parse rb, pt
   end
 
   def test_dstr_evstr
     rb = "\"#\{'a'}#\{b}\""
-    pt = s(:dstr, "a", s(:evstr, s(:call, nil, :b, s(:arglist))))
+    pt = s(:dstr, "a", s(:evstr, s(:call, nil, :b)))
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_dstr_str
     rb = "\"#\{'a'} b\""
     pt = s(:str, "a b")
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_empty
     rb = ""
     pt = nil
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_evstr_evstr
     rb = "\"#\{a}#\{b}\""
-    pt = s(:dstr, "", s(:evstr, s(:call, nil, :a, s(:arglist))), s(:evstr, s(:call, nil, :b, s(:arglist))))
+    pt = s(:dstr, "", s(:evstr, s(:call, nil, :a)), s(:evstr, s(:call, nil, :b)))
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_evstr_str
     rb = "\"#\{a} b\""
-    pt = s(:dstr, "", s(:evstr, s(:call, nil, :a, s(:arglist))), s(:str, " b"))
+    pt = s(:dstr, "", s(:evstr, s(:call, nil, :a)), s(:str, " b"))
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_lasgn_env
@@ -215,8 +262,8 @@ class TestRubyParser < RubyParserTestCase
     pt = s(:lasgn, :a, s(:lit, 42))
     expected_env = { :a => :lvar }
 
-    assert_equal pt, @processor.parse(rb)
-    assert_equal expected_env, @processor.env.all
+    assert_parse rb, pt
+    assert_equal expected_env, processor.env.all
   end
 
   def test_list_append
@@ -224,22 +271,22 @@ class TestRubyParser < RubyParserTestCase
     b = s(:lit, 2)
     c = s(:lit, 3)
 
-    result = @processor.list_append(s(:array, b.dup), c.dup)
+    result = processor.list_append(s(:array, b.dup), c.dup)
 
     assert_equal s(:array, b, c), result
 
-    result = @processor.list_append(b.dup, c.dup)
+    result = processor.list_append(b.dup, c.dup)
 
     assert_equal s(:array, b, c), result
 
-    result = @processor.list_append(result, a.dup)
+    result = processor.list_append(result, a.dup)
 
     assert_equal s(:array, b, c, a), result
 
     lhs, rhs = s(:array, s(:lit, :iter)), s(:when, s(:const, :BRANCHING), nil)
     expected = s(:array, s(:lit, :iter), s(:when, s(:const, :BRANCHING), nil))
 
-    assert_equal expected, @processor.list_append(lhs, rhs)
+    assert_equal expected, processor.list_append(lhs, rhs)
   end
 
   def test_list_prepend
@@ -247,56 +294,56 @@ class TestRubyParser < RubyParserTestCase
     b = s(:lit, 2)
     c = s(:lit, 3)
 
-    result = @processor.list_prepend(b.dup, s(:array, c.dup))
+    result = processor.list_prepend(b.dup, s(:array, c.dup))
 
     assert_equal s(:array, b, c), result
 
-    result = @processor.list_prepend(b.dup, c.dup)
+    result = processor.list_prepend(b.dup, c.dup)
 
     assert_equal s(:array, b, c), result
 
-    result = @processor.list_prepend(a.dup, result)
+    result = processor.list_prepend(a.dup, result)
 
     assert_equal s(:array, a, b, c), result
   end
 
   def test_literal_concat_dstr_dstr
     lhs      = s(:dstr, "Failed to download spec ",
-                 s(:evstr, s(:call, nil, :spec_name, s(:arglist))),
+                 s(:evstr, s(:call, nil, :spec_name)),
                  s(:str, " from "),
-                 s(:evstr, s(:call, nil, :source_uri, s(:arglist))),
+                 s(:evstr, s(:call, nil, :source_uri)),
                  s(:str, ":\n"))
     rhs      = s(:dstr, "\t",
                  s(:evstr, s(:call, s(:ivar, :@fetch_error), :message)))
     expected = s(:dstr, "Failed to download spec ",
-                 s(:evstr, s(:call, nil, :spec_name, s(:arglist))),
+                 s(:evstr, s(:call, nil, :spec_name)),
                  s(:str, " from "),
-                 s(:evstr, s(:call, nil, :source_uri, s(:arglist))),
+                 s(:evstr, s(:call, nil, :source_uri)),
                  s(:str, ":\n"),
                  s(:str, "\t"),
                  s(:evstr, s(:call, s(:ivar, :@fetch_error), :message)))
 
-    assert_equal expected, @processor.literal_concat(lhs, rhs)
+    assert_equal expected, processor.literal_concat(lhs, rhs)
   end
 
   def test_literal_concat_dstr_evstr
-    lhs, rhs = s(:dstr, "a"), s(:evstr, s(:call, nil, :b, s(:arglist)))
-    expected = s(:dstr, "a", s(:evstr, s(:call, nil, :b, s(:arglist))))
+    lhs, rhs = s(:dstr, "a"), s(:evstr, s(:call, nil, :b))
+    expected = s(:dstr, "a", s(:evstr, s(:call, nil, :b)))
 
-    assert_equal expected, @processor.literal_concat(lhs, rhs)
+    assert_equal expected, processor.literal_concat(lhs, rhs)
   end
 
   def test_literal_concat_evstr_evstr
     lhs, rhs = s(:evstr, s(:lit, 1)), s(:evstr, s(:lit, 2))
     expected = s(:dstr, "", s(:evstr, s(:lit, 1)), s(:evstr, s(:lit, 2)))
 
-    assert_equal expected, @processor.literal_concat(lhs, rhs)
+    assert_equal expected, processor.literal_concat(lhs, rhs)
   end
 
   def test_literal_concat_str_evstr
     lhs, rhs = s(:str, ""), s(:evstr, s(:str, "blah"))
 
-    assert_equal s(:str, "blah"), @processor.literal_concat(lhs, rhs)
+    assert_equal s(:str, "blah"), processor.literal_concat(lhs, rhs)
   end
 
   def test_logop_12
@@ -304,7 +351,7 @@ class TestRubyParser < RubyParserTestCase
     rhs = s(:lit, 2)
     exp = s(:and, s(:lit, 1), s(:lit, 2))
 
-    assert_equal exp, @processor.logop(:and, lhs, rhs)
+    assert_equal exp, processor.logop(:and, lhs, rhs)
   end
 
   def test_logop_1234_5
@@ -320,7 +367,7 @@ class TestRubyParser < RubyParserTestCase
                   s(:lit, 4),
                   s(:lit, 5)))))
 
-    assert_equal exp, @processor.logop(:and, lhs, rhs)
+    assert_equal exp, processor.logop(:and, lhs, rhs)
   end
 
   def test_logop_123_4
@@ -334,7 +381,7 @@ class TestRubyParser < RubyParserTestCase
                 s(:lit, 3),
                 s(:lit, 4))))
 
-    assert_equal exp, @processor.logop(:and, lhs, rhs)
+    assert_equal exp, processor.logop(:and, lhs, rhs)
   end
 
   def test_logop_12_3
@@ -342,27 +389,37 @@ class TestRubyParser < RubyParserTestCase
     rhs = s(:lit, 3)
     exp = s(:and, s(:lit, 1), s(:and, s(:lit, 2), s(:lit, 3)))
 
-    assert_equal exp, @processor.logop(:and, lhs, rhs)
+    assert_equal exp, processor.logop(:and, lhs, rhs)
   end
 
   def test_logop_nested_mix
-    lhs = s(:or, s(:call, nil, :a, s(:arglist)), s(:call, nil, :b, s(:arglist)))
-    rhs = s(:and, s(:call, nil, :c, s(:arglist)), s(:call, nil, :d, s(:arglist)))
+    lhs = s(:or, s(:call, nil, :a), s(:call, nil, :b))
+    rhs = s(:and, s(:call, nil, :c), s(:call, nil, :d))
     exp = s(:or,
-            s(:or, s(:call, nil, :a, s(:arglist)), s(:call, nil, :b, s(:arglist))),
-            s(:and, s(:call, nil, :c, s(:arglist)), s(:call, nil, :d, s(:arglist))))
+            s(:or, s(:call, nil, :a), s(:call, nil, :b)),
+            s(:and, s(:call, nil, :c), s(:call, nil, :d)))
 
     lhs.paren = true
     rhs.paren = true
 
-    assert_equal exp, @processor.logop(:or, lhs, rhs)
+    assert_equal exp, processor.logop(:or, lhs, rhs)
   end
 
   def test_str_evstr
     rb = "\"a #\{b}\""
-    pt = s(:dstr, "a ", s(:evstr, s(:call, nil, :b, s(:arglist))))
+    pt = s(:dstr, "a ", s(:evstr, s(:call, nil, :b)))
+
+    assert_parse rb, pt
+  end
+
+  def test_dsym_to_sym
+    pt = s(:alias, s(:lit, :<<), s(:lit, :>>))
 
-    assert_equal pt, @processor.parse(rb)
+    rb = 'alias :<< :>>'
+    assert_parse rb, pt
+
+    rb = 'alias :"<<" :">>"'
+    assert_parse rb, pt
   end
 
   def test_regexp
@@ -375,7 +432,7 @@ class TestRubyParser < RubyParserTestCase
     }
 
     regexps.each do |rb, lit|
-      assert_equal s(:lit, lit), @processor.parse(rb)
+      assert_parse rb, s(:lit, lit)
     end
 
     # TODO: add more including interpolation etc
@@ -383,43 +440,44 @@ class TestRubyParser < RubyParserTestCase
 
   def test_str_pct_Q_nested
     rb = "%Q[before [#\{nest}] after]"
-    pt = s(:dstr, "before [", s(:evstr, s(:call, nil, :nest, s(:arglist))), s(:str, "] after"))
+    pt = s(:dstr, "before [", s(:evstr, s(:call, nil, :nest)), s(:str, "] after"))
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
-#   def test_str_pct_nested_nested
-#     rb = "%{ { #\{ \"#\{1}\" } } }"
-#     pt = s(:dstr, " { ", s(:evstr, s(:lit, 1)), s(:str, " } "))
-
-#     assert_equal pt, @processor.parse(rb)
-#   end
+  # def test_str_pct_nested_nested
+  #   rb = "%{ { #\{ \"#\{1}\" } } }"
+  #   assert_equal " { 1 } ", eval(rb)
+  #   pt = s(:dstr, " { ", s(:evstr, s(:lit, 1)), s(:str, " } "))
+  #
+  #   assert_parse rb, pt
+  # end
 
   def test_str_str
     rb = "\"a #\{'b'}\""
     pt = s(:str, "a b")
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   def test_str_str_str
     rb = "\"a #\{'b'} c\""
     pt = s(:str, "a b c")
 
-    assert_equal pt, @processor.parse(rb)
+    assert_parse rb, pt
   end
 
   STARTING_LINE = {
     "case_nested_inner_no_expr"          => 2,
     "case_no_expr"                       => 2,
     "case_splat"                         => 2,
-    "dstr_heredoc_expand"                => 2,
-    "dstr_heredoc_windoze_sucks"         => 2,
-    "dstr_heredoc_yet_again"             => 2,
-    "str_heredoc"                        => 2,
-    "str_heredoc_call"                   => 2,
-    "str_heredoc_empty"                  => 2,
-    "str_heredoc_indent"                 => 2,
+    "dstr_heredoc_expand"                => 1,
+    "dstr_heredoc_windoze_sucks"         => 1,
+    "dstr_heredoc_yet_again"             => 1,
+    "str_heredoc"                        => 1,
+    "str_heredoc_call"                   => 1,
+    "str_heredoc_empty"                  => 1,
+    "str_heredoc_indent"                 => 1,
     "structure_unused_literal_wwtt"      => 3, # yes, 3... odd test
     "undef_block_1"                      => 2,
     "undef_block_2"                      => 2,
@@ -432,22 +490,17 @@ class TestRubyParser < RubyParserTestCase
     assert_equal expected, @result.line, "should have proper line number"
   end
 
-  def test_position_info
+  def test_parse_line_block
     rb = "a = 42\np a"
     pt = s(:block,
            s(:lasgn, :a, s(:lit, 42)),
-           s(:call, nil, :p, s(:arglist, s(:lvar, :a))))
+           s(:call, nil, :p, s(:lvar, :a)))
 
-    result = @processor.parse(rb, "blah.rb")
-
-    assert_equal pt, result
-
-    assert_equal 1, result.line,       "block should have line number"
+    assert_parse_line rb, pt, 1
     assert_equal 1, result.lasgn.line, "lasgn should have line number"
     assert_equal 2, result.call.line,  "call should have line number"
 
-    expected = "blah.rb"
-
+    expected = "(string)"
     assert_equal expected, result.file
     assert_equal expected, result.lasgn.file
     assert_equal expected, result.call.file
@@ -456,25 +509,237 @@ class TestRubyParser < RubyParserTestCase
     assert_same result.file, result.call.file
   end
 
-  def test_position_info2
-    rb = "def x(y)\n  p(y)\n  y *= 2\n  return y;\nend" # TODO: remove () & ;
-    pt = s(:defn, :x, s(:args, :y),
-           s(:scope,
-             s(:block,
-               s(:call, nil, :p, s(:arglist, s(:lvar, :y))),
-               s(:lasgn, :y,
-                 s(:call, s(:lvar, :y), :*, s(:arglist, s(:lit, 2)))),
-               s(:return, s(:lvar, :y)))))
+  def test_parse_line_call_no_args
+    rb = "f do |x, y|\n  x + y\nend"
 
-    result = @processor.parse(rb)
+    pt = s(:iter,
+           s(:call, nil, :f),
+           s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
+           s(:call, s(:lvar, :x), :+, s(:lvar, :y)))
 
-    assert_equal pt, result
+    assert_parse_line rb, pt, 1
+    assert_equal 1, result[1].line,   "call should have line number"
+    assert_equal 1, result[2].line,   "masgn should have line number"
+    assert_equal 2, result[3].line,   "call should have line number"
+  end
 
-    body = result.scope.block
+  def test_parse_line_defn_no_parens
+    pt = s(:defn, :f, s(:args), s(:nil))
 
-    assert_equal 1, result.line,      "defn should have line number"
+    rb = "def f\nend"
+    assert_parse_line rb, pt, 1
+
+    rb = "def f\n\nend"
+    assert_parse_line rb, pt, 1
+  end
+
+  def test_parse_line_defn_complex
+    rb = "def x(y)\n  p(y)\n  y *= 2\n  return y;\nend" # TODO: remove () & ;
+    pt = s(:defn, :x, s(:args, :y),
+           s(:call, nil, :p, s(:lvar, :y)),
+           s(:lasgn, :y, s(:call, s(:lvar, :y), :*, s(:lit, 2))),
+           s(:return, s(:lvar, :y)))
+
+    assert_parse_line rb, pt, 1
+
+    body = result
     assert_equal 2, body.call.line,   "call should have line number"
     assert_equal 3, body.lasgn.line,  "lasgn should have line number"
     assert_equal 4, body.return.line, "return should have line number"
   end
+
+  def test_parse_line_iter_call_parens
+    rb = "f(a) do |x, y|\n  x + y\nend"
+
+    pt = s(:iter,
+           s(:call, nil, :f, s(:call, nil, :a)),
+           s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
+           s(:call, s(:lvar, :x), :+, s(:lvar, :y)))
+
+    assert_parse_line rb, pt, 1
+
+    assert_equal 1, result[1].line,   "call should have line number"
+    assert_equal 1, result[2].line,   "masgn should have line number"
+    assert_equal 2, result[3].line,   "call should have line number"
+  end
+
+  def test_parse_line_iter_call_no_parens
+    rb = "f a do |x, y|\n  x + y\nend"
+
+    pt = s(:iter,
+           s(:call, nil, :f, s(:call, nil, :a)),
+           s(:masgn, s(:array, s(:lasgn, :x), s(:lasgn, :y))),
+           s(:call, s(:lvar, :x), :+, s(:lvar, :y)))
+
+    assert_parse_line rb, pt, 1
+
+    assert_equal 1, result[1].line,   "call should have line number"
+    assert_equal 1, result[2].line,   "masgn should have line number"
+    assert_equal 2, result[3].line,   "call should have line number"
+  end
+
+  def test_parse_line_heredoc
+    rb = <<-CODE
+      string = <<-HEREDOC
+        very long string
+      HEREDOC
+      puts string
+    CODE
+
+    result = processor.parse rb
+    assert_equal 1, result.lasgn.line
+    assert_equal 4, result.call.line
+  end
+
+  def test_parse_line_newlines
+    rb = "true\n\n"
+    pt = s(:true)
+
+    assert_parse_line rb, pt, 1
+  end
+
+  def test_parse_line_return
+    rb = <<-RUBY
+      def blah
+        if true then
+          return 42
+        end
+      end
+    RUBY
+
+    pt = s(:defn, :blah, s(:args),
+           s(:if, s(:true),
+             s(:return, s(:lit, 42)),
+             nil))
+
+    assert_parse_line rb, pt, 1
+
+    assert_equal 3, result.if.return.line
+    assert_equal 3, result.if.return.lit.line
+  end
+
+  def test_parse_if_not_canonical
+    rb = "if not var.nil? then 'foo' else 'bar'\nend"
+    pt = s(:if,
+           s(:call, s(:call, nil, :var), :nil?),
+           s(:str, "bar"),
+           s(:str, "foo"))
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_if_not_noncanonical
+    rb = "if not var.nil? then 'foo' else 'bar'\nend"
+    pt = s(:if,
+           s(:not,
+             s(:call, s(:call, nil, :var), :nil?)),
+           s(:str, "foo"),
+           s(:str, "bar"))
+
+    processor.canonicalize_conditions = false
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_while_not_canonical
+    rb = "while not var.nil?\n  'foo'\nend"
+    pt = s(:until,
+           s(:call, s(:call, nil, :var), :nil?),
+           s(:str, "foo"), true)
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_while_not_noncanonical
+    rb = "while not var.nil?\n  'foo'\nend"
+    pt = s(:while,
+           s(:not,
+             s(:call, s(:call, nil, :var), :nil?)),
+           s(:str, "foo"), true)
+
+    processor.canonicalize_conditions = false
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_until_not_canonical
+    rb = "until not var.nil?\n  'foo'\nend"
+
+    pt = s(:while,
+           s(:call, s(:call, nil, :var), :nil?),
+           s(:str, "foo"), true)
+
+    assert_parse rb, pt
+  end
+
+  def test_parse_until_not_noncanonical
+    rb = "until not var.nil?\n  'foo'\nend"
+    pt = s(:until,
+           s(:not,
+             s(:call, s(:call, nil, :var), :nil?)),
+           s(:str, "foo"), true)
+
+    processor.canonicalize_conditions = false
+
+    assert_parse rb, pt
+  end
 end
+
+class TestRuby18Parser < RubyParserTestCase
+  include TestRubyParser
+
+  def setup
+    super
+
+    self.processor = Ruby18Parser.new
+  end
+
+  def test_flip2_env_lvar
+    rb = "if a..b then end"
+    pt = s(:if, s(:flip2, s(:call, nil, :a), s(:call, nil, :b)), nil, nil)
+
+    assert_parse rb, pt
+
+    top_env = processor.env.env.first
+
+    assert_kind_of Hash, top_env
+
+    flip = top_env.find { |k,v| k =~ /^flip/ }
+
+    assert flip
+    assert_equal :lvar, flip.last
+  end
+end
+
+class TestRuby19Parser < RubyParserTestCase
+  include TestRubyParser
+
+  def setup
+    super
+
+    self.processor = Ruby19Parser.new
+  end
+
+  # HACK: need to figure out the desired structure and get this working
+  # def test_wtf
+  #   # lambda -> f_larglist lambda_body
+  #   # f_larglist -> f_args opt_bv_decl
+  #   # opt_bv_decl
+  #   # bv_decls
+  #   # bvar
+  #
+  #   rb = "->(a, b=nil) { p [a, b] }"
+  #   pt = s(:iter,
+  #          s(:call, nil, :lambda),
+  #          s(:args, :a, :b,
+  #            s(:block, s(:lasgn, :b, s(nil)))),
+  #          s(:call, nil, :p, s(:array, s(:lvar, :a), s(:lvar, :b))))
+  #
+  #   assert_parse rb, pt
+  #
+  #   rb = "->(a; b) { p [a, b] }"
+  #
+  #   assert_parse rb, pt
+  # end
+end
+