parser 0.9.2 → 1.0.0

data/test/test_lexer.rb

@@ -880,10 +880,10 @@ class TestLexer < MiniTest::Unit::TestCase
   end
 
   def test_identifier_equals_tilde
-    @lex.state = :expr_fname # can only set via parser's defs
+    @lex.state = :expr_fname
     util_lex_token("identifier=~",
-                   :tIDENTIFIER, "identifier",
-                   :tMATCH, "=~")
+                   :tIDENTIFIER, "identifier=",
+                   :tTILDE,      "~")
   end
 
   def test_identifier_gt

data/test/test_parser.rb

@@ -430,16 +430,16 @@ class TestParser < MiniTest::Unit::TestCase
         ALL_VERSIONS - %w(1.8))
   end
 
-  # def test_hash_kwsplat
-  #   assert_parses(
-  #     s(:hash,
-  #       s(:pair, s(:symbol, :foo), s(:int, 2))
-  #       s(:kwsplat, s(:lvar, :bar))),
-  #     %q[{ foo: 2, **bar }],
-  #     %q{          ^^ operator (kwsplat)
-  #       |          ~~~~~ expression (kwsplat)},
-  #       %w(2.0))
-  # end
+  def test_hash_kwsplat
+    assert_parses(
+      s(:hash,
+        s(:pair, s(:sym, :foo), s(:int, 2)),
+        s(:kwsplat, s(:lvar, :bar))),
+      %q[{ foo: 2, **bar }],
+      %q{          ^^ operator (kwsplat)
+        |          ~~~~~ expression (kwsplat)},
+        %w(2.0))
+  end
 
   def test_hash_no_hashrocket
     assert_parses(
@@ -447,7 +447,6 @@ class TestParser < MiniTest::Unit::TestCase
       %q[{ 1, 2 }],
       %q{^ begin
         |       ^ end
-        |   ^ operator (pair)
         |  ~~~~ expression (pair)
         |~~~~~~~~ expression},
       %w(1.8))
@@ -1479,23 +1478,66 @@ class TestParser < MiniTest::Unit::TestCase
       %q{def f(foo=1, bar=2); nil; end})
   end
 
-  def test_splatarg_named
+  def test_restarg_named
     assert_parses(
       s(:def, :f,
-        s(:args, s(:splatarg, :foo)),
+        s(:args, s(:restarg, :foo)),
         s(:nil)),
       %q{def f(*foo); nil; end},
-      %q{       ~~~ name (args.splatarg)
-        |      ~~~~ expression (args.splatarg)})
+      %q{       ~~~ name (args.restarg)
+        |      ~~~~ expression (args.restarg)})
   end
 
-  def test_splatarg_unnamed
+  def test_restarg_unnamed
     assert_parses(
       s(:def, :f,
-        s(:args, s(:splatarg)),
+        s(:args, s(:restarg)),
         s(:nil)),
       %q{def f(*); nil; end},
-      %q{      ~ expression (args.splatarg)})
+      %q{      ~ expression (args.restarg)})
+  end
+
+  def test_kwarg
+    assert_parses(
+      s(:def, :f,
+        s(:args, s(:kwarg, :foo)),
+        s(:nil)),
+      %q{def f(foo:); nil; end},
+      %q{      ~~~ name (args.kwarg)
+        |      ~~~~ expression (args.kwarg)},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+  end
+
+  def test_kwoptarg
+    assert_parses(
+      s(:def, :f,
+        s(:args, s(:kwoptarg, :foo, s(:int, 1))),
+        s(:nil)),
+      %q{def f(foo: 1); nil; end},
+      %q{      ~~~ name (args.kwoptarg)
+        |      ~~~~~~ expression (args.kwoptarg)},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  def test_kwrestarg_named
+    assert_parses(
+      s(:def, :f,
+        s(:args, s(:kwrestarg, :foo)),
+        s(:nil)),
+      %q{def f(**foo); nil; end},
+      %q{        ~~~ name (args.kwrestarg)
+        |      ~~~~~ expression (args.kwrestarg)},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
+  def test_kwrestarg_unnamed
+    assert_parses(
+      s(:def, :f,
+        s(:args, s(:kwrestarg)),
+        s(:nil)),
+      %q{def f(**); nil; end},
+      %q{      ~~ expression (args.kwrestarg)},
+      ALL_VERSIONS - %w(1.8 1.9))
   end
 
   def test_blockarg
@@ -1522,7 +1564,7 @@ class TestParser < MiniTest::Unit::TestCase
       s(:args,
         s(:arg, :a),
         s(:optarg, :o, s(:int, 1)),
-        s(:splatarg, :r),
+        s(:restarg, :r),
         s(:blockarg, :b)),
       %q{a, o=1, *r, &b})
 
@@ -1531,7 +1573,7 @@ class TestParser < MiniTest::Unit::TestCase
       s(:args,
         s(:arg, :a),
         s(:optarg, :o, s(:int, 1)),
-        s(:splatarg, :r),
+        s(:restarg, :r),
         s(:arg, :p),
         s(:blockarg, :b)),
       %q{a, o=1, *r, p, &b},
@@ -1559,7 +1601,7 @@ class TestParser < MiniTest::Unit::TestCase
     assert_parses_args(
       s(:args,
         s(:arg, :a),
-        s(:splatarg, :r),
+        s(:restarg, :r),
         s(:blockarg, :b)),
       %q{a, *r, &b})
 
@@ -1567,7 +1609,7 @@ class TestParser < MiniTest::Unit::TestCase
     assert_parses_args(
       s(:args,
         s(:arg, :a),
-        s(:splatarg, :r),
+        s(:restarg, :r),
         s(:arg, :p),
         s(:blockarg, :b)),
       %q{a, *r, p, &b},
@@ -1584,7 +1626,7 @@ class TestParser < MiniTest::Unit::TestCase
     assert_parses_args(
       s(:args,
         s(:optarg, :o, s(:int, 1)),
-        s(:splatarg, :r),
+        s(:restarg, :r),
         s(:blockarg, :b)),
       %q{o=1, *r, &b})
 
@@ -1592,7 +1634,7 @@ class TestParser < MiniTest::Unit::TestCase
     assert_parses_args(
       s(:args,
         s(:optarg, :o, s(:int, 1)),
-        s(:splatarg, :r),
+        s(:restarg, :r),
         s(:arg, :p),
         s(:blockarg, :b)),
       %q{o=1, *r, p, &b},
@@ -1617,14 +1659,14 @@ class TestParser < MiniTest::Unit::TestCase
     #                              f_rest_arg              opt_f_block_arg
     assert_parses_args(
       s(:args,
-        s(:splatarg, :r),
+        s(:restarg, :r),
         s(:blockarg, :b)),
       %q{*r, &b})
 
     #                              f_rest_arg tCOMMA f_arg opt_f_block_arg
     assert_parses_args(
       s(:args,
-        s(:splatarg, :r),
+        s(:restarg, :r),
         s(:arg, :p),
         s(:blockarg, :b)),
       %q{*r, p, &b},
@@ -1642,6 +1684,34 @@ class TestParser < MiniTest::Unit::TestCase
       %q{})
   end
 
+  def test_kwarg_combinations
+    # f_kwarg tCOMMA f_kwrest opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:kwoptarg, :foo, s(:int, 1)),
+        s(:kwoptarg, :bar, s(:int, 2)),
+        s(:kwrestarg, :baz),
+        s(:blockarg, :b)),
+      %q{(foo: 1, bar: 2, **baz, &b)},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    # f_kwarg opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:kwoptarg, :foo, s(:int, 1)),
+        s(:blockarg, :b)),
+      %q{(foo: 1, &b)},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    # f_kwrest opt_f_block_arg
+    assert_parses_args(
+      s(:args,
+        s(:kwrestarg, :baz),
+        s(:blockarg, :b)),
+      %q{**baz, &b},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
   def assert_parses_margs(ast, code, versions=ALL_VERSIONS - %w(1.8))
     assert_parses_args(
       s(:args, ast),
@@ -1663,42 +1733,42 @@ class TestParser < MiniTest::Unit::TestCase
 
     # f_marg_list tCOMMA tSTAR f_norm_arg
     assert_parses_margs(
-      s(:mlhs, s(:arg, :a), s(:splatarg, :s)),
-      %q{(a, *s)})
+      s(:mlhs, s(:arg, :a), s(:restarg, :r)),
+      %q{(a, *r)})
 
     # f_marg_list tCOMMA tSTAR f_norm_arg tCOMMA f_marg_list
     assert_parses_margs(
-      s(:mlhs, s(:arg, :a), s(:splatarg, :s), s(:arg, :p)),
-      %q{(a, *s, p)})
+      s(:mlhs, s(:arg, :a), s(:restarg, :r), s(:arg, :p)),
+      %q{(a, *r, p)})
 
     # f_marg_list tCOMMA tSTAR
     assert_parses_margs(
-      s(:mlhs, s(:arg, :a), s(:splatarg)),
+      s(:mlhs, s(:arg, :a), s(:restarg)),
       %q{(a, *)})
 
     # f_marg_list tCOMMA tSTAR            tCOMMA f_marg_list
     assert_parses_margs(
-      s(:mlhs, s(:arg, :a), s(:splatarg), s(:arg, :p)),
+      s(:mlhs, s(:arg, :a), s(:restarg), s(:arg, :p)),
       %q{(a, *, p)})
 
     # tSTAR f_norm_arg
     assert_parses_margs(
-      s(:mlhs, s(:splatarg, :s)),
-      %q{(*s)})
+      s(:mlhs, s(:restarg, :r)),
+      %q{(*r)})
 
     # tSTAR f_norm_arg tCOMMA f_marg_list
     assert_parses_margs(
-      s(:mlhs, s(:splatarg, :s), s(:arg, :p)),
-      %q{(*s, p)})
+      s(:mlhs, s(:restarg, :r), s(:arg, :p)),
+      %q{(*r, p)})
 
     # tSTAR
     assert_parses_margs(
-      s(:mlhs, s(:splatarg)),
+      s(:mlhs, s(:restarg)),
       %q{(*)})
 
     # tSTAR tCOMMA f_marg_list
     assert_parses_margs(
-      s(:mlhs, s(:splatarg), s(:arg, :p)),
+      s(:mlhs, s(:restarg), s(:arg, :p)),
       %q{(*, p)})
   end
 
@@ -1776,39 +1846,39 @@ class TestParser < MiniTest::Unit::TestCase
     # block_par tCOMMA tSTAR
     # f_arg tCOMMA                       f_rest_arg              opt_f_block_arg
     assert_parses_blockargs(
-      s(:args, s(:arg, :a), s(:splatarg, :s), s(:blockarg, :b)),
+      s(:args, s(:arg, :a), s(:restarg, :s), s(:blockarg, :b)),
       %q{|a, *s, &b|})
 
     assert_parses_blockargs(
       s(:args, s(:arg, :a),
-        s(:splatarg_expr, s(:ivasgn, :@s)),
+        s(:restarg_expr, s(:ivasgn, :@s)),
         s(:blockarg_expr, s(:ivasgn, :@b))),
       %q{|a, *@s, &@b|},
       %w(1.8))
 
     assert_parses_blockargs(
-      s(:args, s(:arg, :a), s(:splatarg), s(:blockarg, :b)),
+      s(:args, s(:arg, :a), s(:restarg), s(:blockarg, :b)),
       %q{|a, *, &b|})
 
     assert_parses_blockargs(
       s(:args, s(:arg, :a),
-        s(:splatarg),
+        s(:restarg),
         s(:blockarg_expr, s(:ivasgn, :@b))),
       %q{|a, *, &@b|},
       %w(1.8))
 
     assert_parses_blockargs(
-      s(:args, s(:arg, :a), s(:splatarg, :s)),
+      s(:args, s(:arg, :a), s(:restarg, :s)),
       %q{|a, *s|})
 
     assert_parses_blockargs(
       s(:args, s(:arg, :a),
-        s(:splatarg_expr, s(:ivasgn, :@s))),
+        s(:restarg_expr, s(:ivasgn, :@s))),
       %q{|a, *@s|},
       %w(1.8))
 
     assert_parses_blockargs(
-      s(:args, s(:arg, :a), s(:splatarg)),
+      s(:args, s(:arg, :a), s(:restarg)),
       %q{|a, *|})
 
     # tSTAR lhs tCOMMA tAMPER lhs
@@ -1817,39 +1887,39 @@ class TestParser < MiniTest::Unit::TestCase
     # tSTAR tCOMMA tAMPER lhs
     #                                    f_rest_arg              opt_f_block_arg
     assert_parses_blockargs(
-      s(:args, s(:splatarg, :s), s(:blockarg, :b)),
+      s(:args, s(:restarg, :s), s(:blockarg, :b)),
       %q{|*s, &b|})
 
     assert_parses_blockargs(
       s(:args,
-        s(:splatarg_expr, s(:ivasgn, :@s)),
+        s(:restarg_expr, s(:ivasgn, :@s)),
         s(:blockarg_expr, s(:ivasgn, :@b))),
       %q{|*@s, &@b|},
       %w(1.8))
 
     assert_parses_blockargs(
-      s(:args, s(:splatarg), s(:blockarg, :b)),
+      s(:args, s(:restarg), s(:blockarg, :b)),
       %q{|*, &b|})
 
     assert_parses_blockargs(
       s(:args,
-        s(:splatarg),
+        s(:restarg),
         s(:blockarg_expr, s(:ivasgn, :@b))),
       %q{|*, &@b|},
       %w(1.8))
 
     assert_parses_blockargs(
-      s(:args, s(:splatarg, :s)),
+      s(:args, s(:restarg, :s)),
       %q{|*s|})
 
     assert_parses_blockargs(
       s(:args,
-        s(:splatarg_expr, s(:ivasgn, :@s))),
+        s(:restarg_expr, s(:ivasgn, :@s))),
       %q{|*@s|},
       %w(1.8))
 
     assert_parses_blockargs(
-      s(:args, s(:splatarg)),
+      s(:args, s(:restarg)),
       %q{|*|})
 
     # tAMPER lhs
@@ -1870,7 +1940,7 @@ class TestParser < MiniTest::Unit::TestCase
         s(:arg, :a),
         s(:optarg, :o, s(:int, 1)),
         s(:optarg, :o1, s(:int, 2)),
-        s(:splatarg, :r),
+        s(:restarg, :r),
         s(:blockarg, :b)),
       %q{|a, o=1, o1=2, *r, &b|},
       ALL_VERSIONS - %w(1.8))
@@ -1880,7 +1950,7 @@ class TestParser < MiniTest::Unit::TestCase
       s(:args,
         s(:arg, :a),
         s(:optarg, :o, s(:int, 1)),
-        s(:splatarg, :r),
+        s(:restarg, :r),
         s(:arg, :p),
         s(:blockarg, :b)),
       %q{|a, o=1, *r, p, &b|},
@@ -1909,7 +1979,7 @@ class TestParser < MiniTest::Unit::TestCase
     assert_parses_blockargs(
       s(:args,
         s(:arg, :a),
-        s(:splatarg, :r),
+        s(:restarg, :r),
         s(:arg, :p),
         s(:blockarg, :b)),
       %q{|a, *r, p, &b|},
@@ -1919,7 +1989,7 @@ class TestParser < MiniTest::Unit::TestCase
     assert_parses_blockargs(
       s(:args,
         s(:optarg, :o, s(:int, 1)),
-        s(:splatarg, :r),
+        s(:restarg, :r),
         s(:blockarg, :b)),
       %q{|o=1, *r, &b|},
       ALL_VERSIONS - %w(1.8))
@@ -1928,7 +1998,7 @@ class TestParser < MiniTest::Unit::TestCase
     assert_parses_blockargs(
       s(:args,
         s(:optarg, :o, s(:int, 1)),
-        s(:splatarg, :r),
+        s(:restarg, :r),
         s(:arg, :p),
         s(:blockarg, :b)),
       %q{|o=1, *r, p, &b|},
@@ -1954,13 +2024,41 @@ class TestParser < MiniTest::Unit::TestCase
     #                                    f_rest_arg tCOMMA f_arg opt_f_block_arg
     assert_parses_blockargs(
       s(:args,
-        s(:splatarg, :r),
+        s(:restarg, :r),
         s(:arg, :p),
         s(:blockarg, :b)),
       %q{|*r, p, &b|},
       ALL_VERSIONS - %w(1.8))
   end
 
+  def test_block_kwarg_combinations
+    # f_block_kwarg tCOMMA f_kwrest opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args,
+        s(:kwoptarg, :foo, s(:int, 1)),
+        s(:kwoptarg, :bar, s(:int, 2)),
+        s(:kwrestarg, :baz),
+        s(:blockarg, :b)),
+      %q{|foo: 1, bar: 2, **baz, &b|},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    # f_block_kwarg opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args,
+        s(:kwoptarg, :foo, s(:int, 1)),
+        s(:blockarg, :b)),
+      %q{|foo: 1, &b|},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    # f_kwrest opt_f_block_arg
+    assert_parses_blockargs(
+      s(:args,
+        s(:kwrestarg, :baz),
+        s(:blockarg, :b)),
+      %q{|**baz, &b|},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
   def test_arg_invalid
     assert_diagnoses(
       [:error, :argument_const],
@@ -1983,6 +2081,20 @@ class TestParser < MiniTest::Unit::TestCase
       %q{        ~~~~~ location})
   end
 
+  def test_kwarg_invalid
+    assert_diagnoses(
+      [:error, :argument_const],
+      %q{def foo(Abc: 1); end},
+      %q{        ~~~~ location},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    assert_diagnoses(
+      [:error, :argument_const],
+      %q{def foo(Abc:); end},
+      %q{        ~~~~ location},
+      ALL_VERSIONS - %w(1.8 1.9 2.0))
+  end
+
   def test_arg_label
     assert_parses(
       s(:def, :foo, s(:args),
@@ -2009,18 +2121,6 @@ class TestParser < MiniTest::Unit::TestCase
       ALL_VERSIONS - %w(1.8))
   end
 
-  # def test_kwoptarg
-  #   flunk
-  # end
-
-  # def test_kwsplat_named
-  #   flunk
-  # end
-
-  # def test_kwsplat_unnamed
-  #   flunk
-  # end
-
   #
   # Sends
   #
@@ -2116,6 +2216,34 @@ class TestParser < MiniTest::Unit::TestCase
         |~~~~~~~~~~~~ expression})
   end
 
+  def test_send_plain_cmd_ambiguous_prefix
+    assert_diagnoses(
+      [:warning, :ambiguous_prefix, { :prefix => '+' }],
+      %q{m +foo},
+      %q{  ^ location})
+
+    assert_diagnoses(
+      [:warning, :ambiguous_prefix, { :prefix => '-' }],
+      %q{m -foo},
+      %q{  ^ location})
+
+    assert_diagnoses(
+      [:warning, :ambiguous_prefix, { :prefix => '&' }],
+      %q{m &foo},
+      %q{  ^ location})
+
+    assert_diagnoses(
+      [:warning, :ambiguous_prefix, { :prefix => '*' }],
+      %q{m *foo},
+      %q{  ^ location})
+
+    assert_diagnoses(
+      [:warning, :ambiguous_prefix, { :prefix => '**' }],
+      %q{m **foo},
+      %q{  ^^ location},
+      ALL_VERSIONS - %w(1.8 1.9))
+  end
+
   def test_send_block_chain_cmd
     assert_parses(
       s(:send,
@@ -2160,6 +2288,42 @@ class TestParser < MiniTest::Unit::TestCase
         |                  ^ begin
         |                      ^ end
         |~~~~~~~~~~~~~~~~~~~~~~~ expression})
+
+    assert_parses(
+      s(:block,
+        s(:send,
+          s(:block,
+            s(:send, nil, :meth, s(:int, 1)),
+            s(:args), s(:nil)),
+          :fun, s(:lvar, :bar)),
+        s(:args), s(:nil)),
+      %q{meth 1 do end.fun bar do end},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    assert_parses(
+      s(:block,
+        s(:send,
+          s(:block,
+            s(:send, nil, :meth, s(:int, 1)),
+            s(:args), s(:nil)),
+          :fun, s(:lvar, :bar)),
+        s(:args), s(:nil)),
+      %q{meth 1 do end.fun(bar) {}},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
+
+    assert_parses(
+      s(:block,
+        s(:send,
+          s(:block,
+            s(:send, nil, :meth, s(:int, 1)),
+            s(:args), s(:nil)),
+          :fun),
+        s(:args), s(:nil)),
+      %q{meth 1 do end.fun {}},
+      %q{},
+      ALL_VERSIONS - %w(1.8 1.9))
   end
 
   def test_send_paren_block_cmd