parser 0.9.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f90753aea951ab24c817278f94b4e1844151e496
-  data.tar.gz: 49a0cd6eb5dbf0fec9900f1d927ac20bdd8b90fd
+  metadata.gz: 5e0c9d9727b2d7da39af4c37f2fa324be928ece6
+  data.tar.gz: 5a9dc8e99c54aad863aeae920641064af6aa57ee
 SHA512:
-  metadata.gz: 01192b4d7d2b63f8348b2af97b567796f5aedfbb6562843dfce4590f1b15479997693e2b3d688ad3969d542ead2e4ab69389e6b5060da9f0b332ac165ee73c40
-  data.tar.gz: fdcbb3072c1c66d2d1ab3f54eb05f595eeab30860f9b59b5d1e472dc3ae681fdf3cb9376b2fd0945ef97cbabfb10a4f1959b4231ba9e0b8c9ee426625b5a14b5
+  metadata.gz: 4086430fbdc0d756d3d5c6b54501126793b03080a3657f64cd7889637ce73f6f38a36256c0dbee200a8204fe57743703c0407933e11993b875fa3742c01e440a
+  data.tar.gz: 1fc63b05dd53df335802bc7cd393685303f0eb5e73e895f391c6a6c26306832a22fd1a7b61d2abf9b6b94731e876655fd1fdde1dafac0e97a544ae128ab0a63e

data/AST_FORMAT.md

@@ -718,7 +718,7 @@ Format:
 
 Format:
 ```
-(splatarg :foo)
+(restarg :foo)
 "*foo"
  ~~~~ expression
   ~~~ name
@@ -730,7 +730,7 @@ Begin of the `expression` points to `*`.
 
 Format:
 ```
-(splatarg)
+(restarg)
 "*"
  ^ expression
 ```
@@ -747,7 +747,7 @@ Format:
 
 Begin of the `expression` points to `&`.
 
-### Ruby 1.8 expression arguments
+### Expression arguments
 
 Ruby 1.8 allows to use arbitrary expressions as block arguments,
 such as `@var` or `foo.bar`. Such expressions should be treated as
@@ -761,14 +761,14 @@ Format:
 (args (arg_expr (send (send nil :foo) :a=)))
 "|foo.a|"
 
-(args (splatarg_expr (ivasgn :@bar)))
+(args (restarg_expr (ivasgn :@bar)))
 "|*@bar|"
 
 (args (blockarg_expr (ivasgn :@bar)))
 "|&@bar|"
 ```
 
-### Ruby 1.9 and later block shadow arguments
+### Block shadow arguments
 
 Format:
 ```
@@ -780,13 +780,23 @@ Format:
 
 Format:
 ```
-(def :f (args (arg :a) (mlhs (arg :foo) (splatarg :bar))))
+(def :f (args (arg :a) (mlhs (arg :foo) (restarg :bar))))
 "def f(a, (foo, *bar)); end"
           ^ begin   ^ end
           ~~~~~~~~~~~ expression
 ```
 
-### Keyword argument
+### Required keyword argument
+
+Format:
+```
+(kwarg :foo (int 1))
+"foo:"
+ ~~~~ expression
+ ~~~~ name
+```
+
+### Optional keyword argument
 
 Format:
 ```
@@ -800,7 +810,7 @@ Format:
 
 Format:
 ```
-(kwsplat :foo)
+(kwrestarg :foo)
 "**foo"
  ~~~~~ expression
    ~~~ name
@@ -810,7 +820,7 @@ Format:
 
 Format:
 ```
-(kwsplat)
+(kwrestarg)
 "**"
  ~~ expression
 ```

data/README.md

@@ -14,9 +14,9 @@ _Parser_ is a Ruby parser written in pure Ruby.
 
 Parse a chunk of code:
 ``` ruby
-require 'parser/ruby19'
+require 'parser/ruby20'
 
-p Parser::Ruby19.parse("2 + 2")
+p Parser::Ruby20.parse("2 + 2")
 # (send
 #   (int 2) :+
 #   (int 2))
@@ -24,7 +24,7 @@ p Parser::Ruby19.parse("2 + 2")
 
 Parse a chunk of code and display all diagnostics:
 ``` ruby
-parser = Parser::Ruby19.new
+parser = Parser::Ruby20.new
 parser.diagnostics.consumer = lambda do |diag|
   puts diag.render
 end
@@ -43,10 +43,10 @@ p parser.parse(buffer)
 
 ## Features
 
- * Precise source location reporting.
+ * Precise source location reporting (WIP, no, not really yet).
  * [Documented](AST_FORMAT.md) AST format which is convenient to work with.
  * A simple interface and a powerful, tweakable one.
- * Parses 1.8, 1.9 and 2.0 syntax with backwards-compatible AST formats (WIP, only 1.8 & 1.9 yet).
+ * Parses 1.8, 1.9 and 2.0 syntax with backwards-compatible AST formats.
  * Parsing error recovery.
  * Improved [clang-like][] diagnostic messages with location information.
  * Written in pure Ruby, runs on MRI 1.8.7 or >=1.9.2, JRuby and Rubinius in 1.8 and 1.9 mode.

data/TODO.md

@@ -1,19 +1,8 @@
-# 2.0
-
-1. test for "** interpreted as argument prefix" diagnostic
-6. https://github.com/ruby/ruby/commit/c46bda
-7. https://github.com/ruby/ruby/commit/1ab3974b0efea5155da005ec08a1feee90023d98
-9. https://github.com/ruby/ruby/commit/d6a977f667f9d824cfe95976f3afc31e55580edb
-10. https://github.com/ruby/ruby/commit/8fe3fb4c0f69535b302e124f3afc58dce4be5dbb
-11. https://github.com/ruby/ruby/commit/3380974143d3fdf1721d9e28d6b2d42036f03bd2
-
 # 2.1
 
-1. https://github.com/ruby/ruby/commit/7ea675732ac1dac72f07756498706678d8725719
-2. https://github.com/ruby/ruby/commit/38da1a5398f146a36910fde34b72dc9b3aa7918f
-3. https://github.com/ruby/ruby/commit/e489dc1ff42ad3027319d7d01f4885164fdb410a
-4. https://github.com/ruby/ruby/commit/c07d78eb0e8e9d3a8f9e8c860b362964157ff43a
-5. https://github.com/ruby/ruby/commit/34a95669dad8843e3e9a4af683682ab2f50856dd
+1. https://github.com/ruby/ruby/commit/34a95669dad8843e3e9a4af683682ab2f50856dd
+2. https://github.com/ruby/ruby/commit/c07d78eb0e8e9d3a8f9e8c860b362964157ff43a
+3. https://github.com/ruby/ruby/commit/7ea675732ac1dac72f07756498706678d8725719
 
 # All versions
 

data/bin/parse

@@ -3,4 +3,4 @@
 $LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
 require 'parser/all'
 
-p Parser::Ruby18.parse(ARGF.read)
+p Parser::Ruby20.parse(ARGF.read)

data/lib/parser/base.rb

@@ -76,19 +76,28 @@ module Parser
 
     protected
 
+    def next_token
+      @lexer.advance
+    end
+
     def value_expr(v)
       #p 'value_expr', v
       v
     end
 
-    def next_token
-      @lexer.advance
+    def check_kwarg_name(name_t)
+      case name_t[0]
+      when /^[a-z_]/
+        # OK
+      when /^[A-Z]/
+        diagnostic :error, :argument_const, name_t
+      end
     end
 
-    def diagnostic(level, kind, location_tok, highlights_tok=[])
-      _, location = location_tok
+    def diagnostic(level, kind, location_t, highlights_ts=[])
+      _, location = location_t
 
-      highlights = highlights_tok.map do |token|
+      highlights = highlights_ts.map do |token|
         _, range = token
         range
       end

data/lib/parser/builders/default.rb

@@ -142,6 +142,10 @@ module Parser
       s(:hash, *pairs)
     end
 
+    def kwsplat(dstar_t, arg)
+      s(:kwsplat, arg)
+    end
+
     # Ranges
 
     def range_inclusive(lhs, token, rhs)
@@ -392,19 +396,35 @@ module Parser
       s(:args, *args)
     end
 
-    def arg(token)
-      t(token, :arg, value(token).to_sym)
+    def arg(name_t)
+      t(name_t, :arg, value(name_t).to_sym)
+    end
+
+    def optarg(name_t, eql_t, value)
+      s(:optarg, value(name_t).to_sym, value)
+    end
+
+    def restarg(star_t, name_t=nil)
+      if name_t
+        s(:restarg, value(name_t).to_sym)
+      else
+        t(star_t, :restarg)
+      end
+    end
+
+    def kwarg(name_t)
+      s(:kwarg, value(name_t).to_sym)
     end
 
-    def optarg(token, eql_t, value)
-      s(:optarg, value(token).to_sym, value)
+    def kwoptarg(name_t, value)
+      s(:kwoptarg, value(name_t).to_sym, value)
     end
 
-    def splatarg(star_t, token=nil)
-      if token
-        s(:splatarg, value(token).to_sym)
+    def kwrestarg(dstar_t, name_t=nil)
+      if name_t
+        s(:kwrestarg, value(name_t).to_sym)
       else
-        t(star_t, :splatarg)
+        t(dstar_t, :kwrestarg)
       end
     end
 
@@ -426,13 +446,13 @@ module Parser
       end
     end
 
-    def splatarg_expr(star_t, expr=nil)
+    def restarg_expr(star_t, expr=nil)
       if expr.nil?
-        t(star_t, :splatarg)
+        t(star_t, :restarg)
       elsif expr.type == :lvasgn
-        expr.updated(:splatarg)
+        expr.updated(:restarg)
       else
-        s(:splatarg_expr, expr)
+        s(:restarg_expr, expr)
       end
     end
 

data/lib/parser/lexer.rl

@@ -917,7 +917,7 @@ class Parser::Lexer
       '::'  %{ tm = p - 2 }    # A::B      A :: B
   ;
 
-  # Resolving kDO/kDO_COND/kDO_BLOCK ambiguity requires embegging
+  # Resolving kDO/kDO_COND/kDO_BLOCK ambiguity requires embedding
   # @cond/@cmdarg-related code to e_lbrack, e_lparen and e_lbrace.
 
   e_lbrack = '[' % {
@@ -991,14 +991,10 @@ class Parser::Lexer
       => { emit(KEYWORDS[tok]);
            fnext expr_end; fbreak; };
 
-      bareword
+      bareword [?=!]?
       => { emit(:tIDENTIFIER)
            fnext expr_end; fbreak; };
 
-      bareword ambiguous_ident_suffix
-      => { emit(:tIDENTIFIER, tok(@ts, tm), @ts, tm)
-           fnext expr_end; p = tm - 1; fbreak; };
-
       operator_fname      |
       operator_arithmetic |
       operator_rest
@@ -1114,25 +1110,26 @@ class Parser::Lexer
                )
       => { fhold; fhold; fgoto expr_beg; };
 
-      # x +1
-      # Ambiguous unary operator or regexp literal.
-      c_space+ [+\-/]
+      # x /1
+      # Ambiguous regexp literal.
+      c_space+ '/'
       => {
         diagnostic :warning, Parser::ERRORS[:ambiguous_literal],
                    range(@te - 1, @te)
 
-        fhold; fhold; fgoto expr_beg;
+        fhold; fgoto expr_beg;
       };
 
       # x *1
       # Ambiguous splat, kwsplat or block-pass.
-      c_space+ %{ tm = p } ( '*' | '&' | '**' )
+      c_space+ %{ tm = p } ( '+' | '-' | '*' | '&' | '**' )
       => {
         message = Parser::ERRORS[:ambiguous_prefix] % { :prefix => tok(tm, @te) }
         diagnostic :warning, message,
                    range(tm, @te)
 
-        fhold; fgoto expr_beg;
+        p = tm - 1
+        fgoto expr_beg;
       };
 
       # x ::Foo

data/lib/parser/ruby18.y

@@ -1294,42 +1294,42 @@ rule
                 | block_par tCOMMA tSTAR lhs tCOMMA tAMPER lhs
                     {
                       result =  val[0].
-                                  push(@builder.splatarg_expr(val[2], val[3])).
+                                  push(@builder.restarg_expr(val[2], val[3])).
                                   push(@builder.blockarg_expr(val[5], val[6]))
                     }
                 | block_par tCOMMA tSTAR tCOMMA tAMPER lhs
                     {
                       result =  val[0].
-                                  push(@builder.splatarg_expr(val[2])).
+                                  push(@builder.restarg_expr(val[2])).
                                   push(@builder.blockarg_expr(val[4], val[5]))
                     }
                 | block_par tCOMMA tSTAR lhs
                     {
                       result =  val[0].
-                                  push(@builder.splatarg_expr(val[2], val[3]))
+                                  push(@builder.restarg_expr(val[2], val[3]))
                     }
                 | block_par tCOMMA tSTAR
                     {
                       result =  val[0].
-                                  push(@builder.splatarg_expr(val[2]))
+                                  push(@builder.restarg_expr(val[2]))
                     }
                 | tSTAR lhs tCOMMA tAMPER lhs
                     {
-                      result =  [ @builder.splatarg_expr(val[0], val[1]),
+                      result =  [ @builder.restarg_expr(val[0], val[1]),
                                   @builder.blockarg_expr(val[3], val[4]) ]
                     }
                 | tSTAR tCOMMA tAMPER lhs
                     {
-                      result =  [ @builder.splatarg_expr(val[0]),
+                      result =  [ @builder.restarg_expr(val[0]),
                                   @builder.blockarg_expr(val[2], val[3]) ]
                     }
                 | tSTAR lhs
                     {
-                      result =  [ @builder.splatarg_expr(val[0], val[1]) ]
+                      result =  [ @builder.restarg_expr(val[0], val[1]) ]
                     }
                 | tSTAR
                     {
-                      result =  [ @builder.splatarg_expr(val[0]) ]
+                      result =  [ @builder.restarg_expr(val[0]) ]
                     }
                 | tAMPER lhs
                     {
@@ -1850,11 +1850,11 @@ xstring_contents: # nothing
                     {
                       @static_env.declare val[1][0]
 
-                      result = [ @builder.splatarg(val[0], val[1]) ]
+                      result = [ @builder.restarg(val[0], val[1]) ]
                     }
                 | restarg_mark
                     {
-                      result = [ @builder.splatarg(val[0]) ]
+                      result = [ @builder.restarg(val[0]) ]
                     }
 
      blkarg_mark: tAMPER2 | tAMPER

data/lib/parser/ruby19.y

@@ -1260,47 +1260,47 @@ rule
                       @static_env.declare val[3][0]
 
                       result = val[0].
-                                  push(@builder.splatarg(val[2], val[3]))
+                                  push(@builder.restarg(val[2], val[3]))
                     }
                 | f_marg_list tCOMMA tSTAR f_norm_arg tCOMMA f_marg_list
                     {
                       @static_env.declare val[3][0]
 
                       result = val[0].
-                                  push(@builder.splatarg(val[2], val[3])).
+                                  push(@builder.restarg(val[2], val[3])).
                                   concat(val[5])
                     }
                 | f_marg_list tCOMMA tSTAR
                     {
                       result = val[0].
-                                  push(@builder.splatarg(val[2]))
+                                  push(@builder.restarg(val[2]))
                     }
                 | f_marg_list tCOMMA tSTAR            tCOMMA f_marg_list
                     {
                       result = val[0].
-                                  push(@builder.splatarg(val[2])).
+                                  push(@builder.restarg(val[2])).
                                   concat(val[4])
                     }
                 |                    tSTAR f_norm_arg
                     {
                       @static_env.declare val[1][0]
 
-                      result = [ @builder.splatarg(val[0], val[1]) ]
+                      result = [ @builder.restarg(val[0], val[1]) ]
                     }
                 |                    tSTAR f_norm_arg tCOMMA f_marg_list
                     {
                       @static_env.declare val[1][0]
 
-                      result = [ @builder.splatarg(val[0], val[1]),
+                      result = [ @builder.restarg(val[0], val[1]),
                                  *val[3] ]
                     }
                 |                    tSTAR
                     {
-                      result = [ @builder.splatarg(val[0]) ]
+                      result = [ @builder.restarg(val[0]) ]
                     }
                 |                    tSTAR tCOMMA f_marg_list
                     {
-                      result = [ @builder.splatarg(val[0]),
+                      result = [ @builder.restarg(val[0]),
                                  *val[2] ]
                     }
 
@@ -2046,11 +2046,11 @@ keyword_variable: kNIL
                     {
                       @static_env.declare val[1][0]
 
-                      result = [ @builder.splatarg(val[0], val[1]) ]
+                      result = [ @builder.restarg(val[0], val[1]) ]
                     }
                 | restarg_mark
                     {
-                      result = [ @builder.splatarg(val[0]) ]
+                      result = [ @builder.restarg(val[0]) ]
                     }
 
      blkarg_mark: tAMPER2 | tAMPER
@@ -2110,7 +2110,13 @@ keyword_variable: kNIL
        opt_terms:  | terms
           opt_nl:  | tNL
           rparen: opt_nl tRPAREN
+                    {
+                      result = val[1]
+                    }
         rbracket: opt_nl tRBRACK
+                    {
+                      result = val[1]
+                    }
          trailer:  | tNL | tCOMMA
 
             term: tSEMI