ruby_parser 3.0.0.a9 → 3.0.0.a10

data/lib/ruby19_parser.y

@@ -260,6 +260,8 @@ rule
                     compstmt tRCURLY
                     {
                       result = new_iter nil, val[2], val[4]
+                      result.line = val[1]
+
                       self.env.unextend
                     }
 
@@ -994,7 +996,7 @@ rule
                     }
                 | tLAMBDA lambda
                     {
-                      result = val[1]
+                      result = val[1] # TODO: fix lineno
                     }
                 | kIF expr_value then compstmt if_tail kEND
                     {
@@ -1194,9 +1196,6 @@ rule
                     }
 
           f_marg: f_norm_arg
-                    {
-                      result = assignable val[0]
-                    }
                 | tLPAREN f_margs rparen
                     {
                       result = val[1]
@@ -1213,114 +1212,116 @@ rule
 
          f_margs: f_marg_list
                     {
-                      result = block_var val[0], nil, nil
+                      args, = val
+
+                      result = block_var args
                     }
                 | f_marg_list tCOMMA tSTAR f_norm_arg
                     {
-                      result = block_var val[0], val[3], nil
+                      args, _, _, splat = val
+
+                      result = block_var args, "*#{splat}".to_sym
                     }
                 | f_marg_list tCOMMA tSTAR f_norm_arg tCOMMA f_marg_list
                     {
-                      raise "no10\non: #{val.inspect}"
+                      args, _, _, splat, _, args2 = val
+
+                      result = block_var args, "*#{splat}".to_sym, args2
                     }
                 | f_marg_list tCOMMA tSTAR
                     {
-                      raise "no11\non: #{val.inspect}"
+                      args, _, _ = val
+
+                      result = block_var args, :*
                     }
                 | f_marg_list tCOMMA tSTAR tCOMMA f_marg_list
                     {
-                      raise "no12\non: #{val.inspect}"
+                      args, _, _, _, args2 = val
+
+                      result = block_var args, :*, args2
                     }
                 | tSTAR f_norm_arg
                     {
-                      raise "no13\non: #{val.inspect}"
+                      _, splat = val
+
+                      result = block_var :"*#{splat}"
                     }
                 | tSTAR f_norm_arg tCOMMA f_marg_list
                     {
-                      raise "no14\non: #{val.inspect}"
+                      _, splat, _, args = val
+
+                      result = block_var :"*#{splat}", args
                     }
                 | tSTAR
                     {
-                      raise "no15\non: #{val.inspect}"
+                      result = block_var :*
                     }
                 | tSTAR tCOMMA f_marg_list
                     {
-                      raise "no16\non: #{val.inspect}"
+                      _, _, args = val
+
+                      result = block_var :*, args
                     }
 
      block_param: f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg opt_f_block_arg
                     {
-                      result = block_args19 val, "1"
+                      result = args val
                     }
                 | f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
                     {
-                      result = block_args19 val, "2"
+                      result = args val
                     }
                 | f_arg tCOMMA f_block_optarg opt_f_block_arg
                     {
-                      arg, _, opt, block = val
-
-                      result = arg
-                      result.concat opt[1..-1].map { |s| s[1] }
-                      result << "&#{block.last}".to_sym if block
-                      result << opt
+                      result = args val
                     }
                 | f_arg tCOMMA f_block_optarg tCOMMA f_arg opt_f_block_arg
                     {
-                      result = block_args19 val, "4"
+                      result = args val
                     }
                 | f_arg tCOMMA f_rest_arg opt_f_block_arg
                     {
-                      result = block_args19 val, "5"
+                      result = args val
                     }
                 | f_arg tCOMMA
                     {
-                      result = block_args19 val, "6"
+                      result = args val
                     }
                 | f_arg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
                     {
-                      result = block_args19 val, "7"
+                      result = args val
                     }
                 | f_arg opt_f_block_arg
                     {
-                      result = block_args19 val, "8"
+                      result = args val
                     }
                 | f_block_optarg tCOMMA f_rest_arg opt_f_block_arg
                     {
-                      result = block_args19 val, "9"
+                      result = args val
                     }
                 | f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
                     {
-                      result = block_args19 val, "10"
+                      result = args val
                     }
                 | f_block_optarg opt_f_block_arg
                     {
-                      opt, block = val
-
-                      result = s(:args)
-                      result.concat opt[1..-1].map { |s| s[1] }
-                      result << "&#{block.last}".to_sym if block
-                      result << opt
+                      result = args val
                     }
                 | f_block_optarg tCOMMA f_arg opt_f_block_arg
                     {
-                      result = block_args19 val, "12"
+                      result = args val
                     }
                 | f_rest_arg opt_f_block_arg
                     {
-                      result = block_args19 val, "13"
+                      result = args val
                     }
                 | f_rest_arg tCOMMA f_arg opt_f_block_arg
                     {
-                      rest, _, args, block = val
-
-                      result = args
-                      result[1,0] = rest
-                      result << "&#{block.last}".to_sym if block
+                      result = args val
                     }
                 | f_block_arg
                     {
-                      result = block_args19 val, "15"
+                      result = args val
                     }
 
  opt_block_param: none
@@ -1362,23 +1363,18 @@ rule
 
           lambda: f_larglist lambda_body
                     {
-                      case val[0].size
-                      when 1
-                        args = 0
-                      when 2
-                        args = s(:lasgn, val[0][1])
-                      else
-                        vars = val[0][1..-1].map { |name| s(:lasgn, name) }
-                        args = s(:masgn, s(:array, *vars))
-                      end
+                      args, body = val
+
+                      args = 0 if args == s(:args)
 
                       call = new_call nil, :lambda
-                      result = s(:iter, call, args, val[1])
+                      result = new_iter call, args, body
                     }
 
      f_larglist: tLPAREN2 f_args opt_bv_decl rparen
                     {
                       result = val[1]
+                      raise "not yet: #{val.inspect}" if val[2]
                     }
                 | f_args
                     {
@@ -1405,9 +1401,9 @@ rule
                     }
                     compstmt kEND
                     {
-                      vars   = val[2]
+                      args   = val[2]
                       body   = val[4]
-                      result = new_iter nil, vars, body
+                      result = new_iter nil, args, body
                       result.line = val[1]
 
                       self.env.unextend
@@ -1486,12 +1482,12 @@ rule
                     }
                     compstmt tRCURLY
                     {
-                      # REFACTOR
-                      args   = val[2]
-                      body   = val[4]
+                      _, line, args, _, body, _ = val
+
                       result = new_iter nil, args, body
+                      result.line = line
+
                       self.env.unextend
-                      result.line = val[1]
                     }
                 | kDO
                     {
@@ -1504,11 +1500,12 @@ rule
                     }
                     compstmt kEND
                     {
-                      args = val[2]
-                      body = val[4]
+                      _, line, args, _, body, _ = val
+
                       result = new_iter nil, args, body
+                      result.line = line
+
                       self.env.unextend
-                      result.line = val[1]
                     }
 
        case_body: kWHEN
@@ -1526,7 +1523,7 @@ rule
 
       opt_rescue: kRESCUE exc_list exc_var then compstmt opt_rescue
                     {
-                      klasses, var, body, rest = val[1], val[2], val[4], val[5]
+                      _, klasses, var, _, body, rest = val
 
                       klasses ||= s(:array)
                       klasses << node_assign(var, s(:gvar, :"$!")) if var
@@ -1554,11 +1551,9 @@ rule
 
       opt_ensure: kENSURE compstmt
                     {
-                      if (val[1] != nil) then
-                        result = val[1]
-                      else
-                        result = s(:nil)
-                      end
+                      _, body = val
+
+                      result = body || s(:nil)
                     }
                 | none
 
@@ -1707,7 +1702,7 @@ regexp_contents: none
                       when nil then
                         result = s(:evstr)
                       else
-                        raise "unknown rescue body: #{val[2].inspect}"
+                        raise "unknown string body: #{val[2].inspect}"
                       end
                     }
 
@@ -1770,7 +1765,15 @@ keyword_variable: kNIL      { result = s(:nil)   }
                 | kFALSE    { result = s(:false) }
                 | k__FILE__ { result = s(:str, self.file) }
                 | k__LINE__ { result = s(:lit, lexer.src.current_line) }
-                | k__ENCODING__ { result = s(:str, "Unsupported!") }
+                | k__ENCODING__ 
+                    { 
+                      result = 
+                        if defined? Encoding then
+                          s(:const, Encoding::UTF_8)
+                        else
+                          s(:str, "Unsupported!")
+                        end
+                    }
 
          var_ref: user_variable
                     {
@@ -1826,63 +1829,63 @@ keyword_variable: kNIL      { result = s(:nil)   }
 
           f_args: f_arg tCOMMA f_optarg tCOMMA f_rest_arg opt_f_block_arg
                     {
-                      result = args19 val
+                      result = args val
                     }
                 | f_arg tCOMMA f_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
                     {
-                      result = args19 val
+                      result = args val
                     }
                 | f_arg tCOMMA f_optarg              opt_f_block_arg
                     {
-                      result = args19 val
+                      result = args val
                     }
                 | f_arg tCOMMA f_optarg tCOMMA f_arg opt_f_block_arg
                     {
-                      result = args19 val
+                      result = args val
                     }
                 | f_arg tCOMMA            f_rest_arg opt_f_block_arg
                     {
-                      result = args19 val
+                      result = args val
                     }
                 | f_arg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
                     {
-                      result = args19 val
+                      result = args val
                     }
                 | f_arg                             opt_f_block_arg
                     {
-                      result = args19 val
+                      result = args val
                     }
                 |           f_optarg tCOMMA f_rest_arg opt_f_block_arg
                     {
-                      result = args19 val
+                      result = args val
                     }
                 | f_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_f_block_arg
                     {
-                      result = args19 val
+                      result = args val
                     }
                 |           f_optarg                opt_f_block_arg
                     {
-                      result = args19 val
+                      result = args val
                     }
                 | f_optarg tCOMMA f_arg opt_f_block_arg
                     {
-                      result = args19 val
+                      result = args val
                     }
                 |                        f_rest_arg opt_f_block_arg
                     {
-                      result = args19 val
+                      result = args val
                     }
                 |           f_rest_arg tCOMMA f_arg opt_f_block_arg
                     {
-                      result = args19 val
+                      result = args val
                     }
                 |                                       f_block_arg
                     {
-                      result = args19 val
+                      result = args val
                     }
                 |
                     {
-                      result = args19 val
+                      result = args val
                     }
 
        f_bad_arg: tCONSTANT
@@ -1912,9 +1915,6 @@ keyword_variable: kNIL      { result = s(:nil)   }
                     }
 
       f_arg_item: f_norm_arg
-                    # { # TODO
-                    #   result = assignable val[0]
-                    # }
                 | tLPAREN f_margs rparen
                     {
                       result = val[1]
@@ -1925,7 +1925,7 @@ keyword_variable: kNIL      { result = s(:nil)   }
                       case val[0]
                       when Symbol then
                         result = s(:args)
-                        result << val[0].to_sym
+                        result << val[0]
                       when Sexp then
                         result = val[0]
                       else
@@ -1934,8 +1934,15 @@ keyword_variable: kNIL      { result = s(:nil)   }
                     }
                 | f_arg tCOMMA f_arg_item
                     {
-                      val[0] << val[2]
-                      result = val[0]
+                      list, _, item = val
+
+                      if list.sexp_type == :args then
+                        result = list
+                      else
+                        result = s(:args, list)
+                      end
+
+                      result << item
                     }
 
            f_opt: tIDENTIFIER tEQL arg_value
@@ -1991,7 +1998,7 @@ keyword_variable: kNIL      { result = s(:nil)   }
                       identifier = val[1].to_sym
 
                       self.env[identifier] = :lvar
-                      result = s(:block_arg, identifier.to_sym)
+                      result = "&#{identifier}".to_sym
                     }
 
  opt_f_block_arg: tCOMMA f_block_arg

data/lib/ruby_parser_extras.rb

@@ -85,7 +85,7 @@ class RPStringScanner < StringScanner
 end
 
 module RubyParserStuff
-  VERSION = '3.0.0.a9' unless constants.include? "VERSION" # SIGH
+  VERSION = '3.0.0.a10' unless constants.include? "VERSION" # SIGH
 
   attr_accessor :lexer, :in_def, :in_single, :file
   attr_reader :env, :comments
@@ -115,154 +115,76 @@ module RubyParserStuff
     node1
   end
 
-  def block_var ary, splat, block
-    ary ||= s(:array)
-
-    if splat then
-      if splat == s(:splat) then
-        ary << splat
+  def clean_mlhs sexp
+    case sexp.sexp_type
+    when :masgn then
+      if sexp.size == 2 and sexp[1].sexp_type == :array then
+        s(:masgn, *sexp[1][1..-1].map { |sub| clean_mlhs sub })
       else
-        ary << s(:splat, splat)
+        sexp
       end
+    when :gasgn, :iasgn, :lasgn, :cvasgn then
+      if sexp.size == 2 then
+        sexp.last
+      else
+        sexp # optional value
+      end
+    else
+      raise "unsupported type: #{sexp.inspect}"
     end
+  end
 
-    if block then
-      block[-1] = :"&#{block[-1]}"
-      ary << block
-    end
-
-    result = if ary.length > 2 or ary.splat then
-               s(:masgn, ary)
-             else
-               ary.last
-             end
-
+  def block_var *args
+    result = self.args args
+    result[0] = :masgn
     result
   end
 
-  def args arg, optarg, rest_arg, block_arg, post_arg = nil
-    arg ||= s(:args)
+  def block_var18 ary, splat, block
+    ary ||= s(:array)
 
-    result = arg
-    if optarg then
-      optarg[1..-1].each do |lasgn| # FIX clean sexp iter
-        raise "wtf? #{lasgn.inspect}" unless lasgn[0] == :lasgn
-        result << lasgn[1]
-      end
+    if splat then
+      splat = splat[1] unless Symbol === splat
+      ary << "*#{splat}".to_sym
     end
 
-    result << rest_arg  if rest_arg
+    ary << "&#{block[1]}".to_sym if block
 
-    result << :"&#{block_arg.last}" if block_arg
-    result << optarg    if optarg # TODO? huh - processed above as well
-    post_arg[1..-1].each {|pa| result << pa } if post_arg
-
-    result
+    if ary.length > 2 or ary.splat then # HACK
+      s(:masgn, *ary[1..-1])
+    else
+      ary.last
+    end
   end
 
-  def args19 vals # TODO: migrate to args once 1.8 tests pass as well
+  def args args
     result = s(:args)
-    block  = nil
 
-    vals.each do |val|
-      case val
+    args.each do |arg|
+      case arg
       when Sexp then
-        case val.first
-        when :args then
-          val[1..-1].each do |name|
-            result << name
-          end
+        case arg.sexp_type
+        when :args, :block, :array then
+          result.concat arg[1..-1]
         when :block_arg then
-          result << :"&#{val.last}"
-        when :block then
-         block = val
-          val[1..-1].each do |lasgn| # FIX clean sexp iter
-            raise "wtf? #{val.inspect}" unless lasgn[0] == :lasgn
-            result << lasgn[1]
-          end
-        when :lasgn then
-          result << val
+          result << :"&#{arg.last}"
+        when :masgn then
+          result << arg
         else
-          raise "unhandled sexp: #{val.inspect}"
+          raise "unhandled: #{arg.inspect}"
         end
       when Symbol then
-        result << val
+        result << arg
       when ",", nil then
         # ignore
       else
-        raise "unhandled val: #{val.inspect} in #{vals.inspect}"
+        raise "unhandled: #{arg.inspect}"
       end
     end
 
-    result << block if block
-
     result
   end
 
-  def block_args19 val, id
-    # HACK OMG THIS CODE IS SOOO UGLY! CLEAN ME
-    untested = %w[1 2 3 4 7 9 10 12 14]
-    raise "no block_args19 #{id}\non: #{val.inspect}" if untested.include? id
-
-    r = s(:array)
-
-    val.compact.each do |v|
-      next if %w[,].include? v
-      case v
-      when Sexp then
-        case v.first
-        when :args then
-          r.concat v[1..-1].map { |s| # FIX: this is a smell
-            case s
-            when Symbol then
-              s(:lasgn, s)
-            when Sexp then
-              s
-            else
-              raise "unhandled type: #{s.inspect}"
-            end
-          }
-        when :block_arg then
-          r << s(:lasgn, :"&#{v.last}")
-        when :lasgn then
-          r << s(:masgn, s(:array, v))
-        when :masgn then
-          r << v
-        else
-          raise "block_args19 #{id} unhandled sexp type:: #{v.inspect}"
-        end
-      when Symbol
-        case v.to_s
-        when /^\*(.+)/ then
-          r << s(:splat, s(:lasgn, $1.to_sym))
-        when /^\*/ then
-          r << s(:splat)
-        else
-          raise "block_args19 #{id} unhandled symbol type:: #{v.inspect}"
-        end
-      else
-        raise "block_args19 #{id} unhandled type:: #{v.inspect}"
-      end
-    end
-
-    if r.size > 2 then
-      r = s(:masgn, r)
-    elsif r.size == 2 then
-      case r.last.first
-      when :splat then
-        r = s(:masgn, r)
-      when :lasgn, :masgn then
-        r = r.last
-      else
-        raise "oh noes!: #{r.inspect}"
-      end
-    else
-      raise "totally borked: #{r.inspect}"
-    end
-
-    r
-  end
-
   def aryset receiver, index
     s(:attrasgn, receiver, :"[]=", *index[1..-1])
   end
@@ -683,10 +605,18 @@ module RubyParserStuff
   end
 
   def new_iter call, args, body
+    body ||= nil
+
+    args ||= s(:args)
+    args = s(:args, args) if Symbol === args
+
     result = s(:iter)
     result << call if call
     result << args
     result << body if body
+
+    args[0] = :args unless args == 0
+
     result
   end