parser 2.5.0.0 → 2.5.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 17012e63bed58664c7f879ca77f492e6d551962a
-  data.tar.gz: 1ba7782eabfc5d33ffbcd5a3f5c7ce1b149e0eb1
+  metadata.gz: 9ee63d086cc3d7ade55f51e03ac92d6f88315fb7
+  data.tar.gz: 8efdd495d4866bfb27db7b0b15be94515b18a91f
 SHA512:
-  metadata.gz: 88787ec044608f586f8d1f9f2ced18005d1af68b5ff6f4cfc7633161bb8e6004aac032803da28c2b37255f98023b47c33d322806096239b1166dc117bf6a1459
-  data.tar.gz: 564a7e7e4e75bb412677011482eef36cff953fd023f3b889f0bc922ec0f51e36d6110cd1f01cc18d0d670a286a71aa58b8ad2ef3b268c7582e3afbe4cd45e442
+  metadata.gz: ae6472a338db72f9d422633eeb83fb6ba37f3f07e99f89d8d2661b840a08177aaffb2ffa8677a7d826f86278c94ba2434b68e00e265d43e7da3ca4998fceeb49
+  data.tar.gz: 382b2d934d537bf496e74911a25a7caf286192955a50698f4a0c7b80d5b0f852feebd51d6beb0cd12381052960ab0c4687e26e965a43cab36269ec9919bf730e

data/CHANGELOG.md

@@ -1,8 +1,23 @@
 Changelog
 =========
 
-Not released (2018-02-16)
--------------------------
+v2.5.0.1 (2018-02-21)
+---------------------
+
+Features implemented:
+ * builders/default: __ENCODING__: emit as s(:__ENCODING__) via AST opt-in. (whitequark)
+ * ruby25.y: Extract expr_value_do rule. This commit tracks upstream commit ruby/ruby@508533f. (Ilya Bylich)
+ * ruby25.y: Extract begin_block rule. This commit tracks upstream commit ruby/ruby@762d23c. (Ilya Bylich)
+ * ruby25.y: Allow class and method definition in the while condition. (#432) (Ilya Bylich)
+ * ruby25: Allow `-> do rescue; end`. (#431) (Ilya Bylich)
+
+Bugs fixed:
+ * parser/current: latest released Ruby series is 2.5.x. (whitequark)
+ * builders/default: x[], x[]=1: emit as s(:index), s(:indexasgn) via AST opt-in. (whitequark)
+ * lexer.rl: "#{-> foo {}}": fix parsing of interpolated lambda with open args. (Ilya Bylich)
+
+v2.5.0.0 (2018-02-16)
+---------------------
 
 API modifications:
  * Parser::Current: bump to 2.2.9 and 2.3.6. (Stan Hu)

data/README.md

@@ -24,8 +24,10 @@ below for explanation of `emit_*` calls):
 
     require 'parser/current'
     # opt-in to most recent AST format:
-    Parser::Builders::Default.emit_lambda = true
+    Parser::Builders::Default.emit_lambda   = true
     Parser::Builders::Default.emit_procarg0 = true
+    Parser::Builders::Default.emit_encoding = true
+    Parser::Builders::Default.emit_index    = true
 
 Parse a chunk of code:
 

data/Rakefile

@@ -104,7 +104,7 @@ task :changelog do
 
       current_version = "#{$1} (#{date})" if version =~ /(v[\d\w.]+)/
       current_version = "Not released (#{date})" \
-        if version =~ /(^| |\/)#{Regexp.escape branch}$/
+        if version =~ /(^| |\/)#{Regexp.escape branch}$/ && !branch.start_with?('v')
 
       next if current_version.nil?
       changelog[current_version] # add a hash

data/doc/AST_FORMAT.md

@@ -1081,18 +1081,6 @@ Format:
      ~ selector
        ^ operator
  ~~~~~~~~~ expression
-
-(send (lvar :foo) :[] (int 1))
-"foo[i]"
-    ~~~ selector
- ~~~~~~ expression
-
-(send (lvar :bar) :[]= (int 1) (int 2) (lvar :baz))
-"bar[1, 2] = baz"
-    ~~~~~~ selector
-           ^ operator
- ~~~~~~~~~~~~~~~ expression
-
 ~~~
 
 ### To superclass
@@ -1135,6 +1123,26 @@ Format:
  ~~~~~~~~~~ expression
 ~~~
 
+### Indexing
+
+Format:
+
+~~~
+(index (lvar :foo) (int 1))
+"foo[1]"
+    ^ begin
+      ^ end
+ ~~~~~~ expression
+
+(indexasgn (lvar :bar) (int 1) (int 2) (lvar :baz))
+"bar[1, 2] = baz"
+    ^ begin
+         ^ end
+           ^ operator
+ ~~~~~~~~~~~~~~~ expression
+
+~~~
+
 ### Passing a literal block
 
 ~~~
@@ -1676,3 +1684,35 @@ Format:
                  ~~ selector
  ~~~~~~~~~~~~~~~~~~~~~~ expression
 ~~~
+
+## Special constants
+
+### File
+
+Format:
+
+~~~
+(__FILE__)
+"__FILE__"
+ ~~~~~~~~ expression
+~~~
+
+### Line
+
+Format:
+
+~~~
+(__LINE__)
+"__LINE__"
+ ~~~~~~~~ expression
+~~~
+
+### Encoding
+
+Format:
+
+~~~
+(__ENCODING__)
+"__ENCODING__"
+ ~~~~~~~~~~~~ expression
+~~~

data/lib/parser.rb

@@ -47,6 +47,7 @@ module Parser
     require 'parser/source/map/keyword'
     require 'parser/source/map/definition'
     require 'parser/source/map/send'
+    require 'parser/source/map/index'
     require 'parser/source/map/condition'
     require 'parser/source/map/ternary'
     require 'parser/source/map/for'

data/lib/parser/builders/default.rb

@@ -31,10 +31,10 @@ module Parser
       # all new code should set this attribute to true.
       #
       # If set to false (the default), arguments of `m { |a| }` are emitted as
-      # `s(:args, s(:arg, :a))`
+      # `s(:args, s(:arg, :a))`.
       #
       # If set to true, arguments of `m { |a| }` are emitted as
-      # `s(:args, s(:procarg0, :a))
+      # `s(:args, s(:procarg0, :a)).
       #
       # @return [Boolean]
       attr_accessor :emit_procarg0
@@ -42,12 +42,54 @@ module Parser
 
     @emit_procarg0 = false
 
+    class << self
+      ##
+      # AST compatibility attribute; locations of `__ENCODING__` are not the same
+      # as locations of `Encoding::UTF_8` causing problems during rewriting,
+      # all new code should set this attribute to true.
+      #
+      # If set to false (the default), `__ENCODING__` is emitted as
+      # ` s(:const, s(:const, nil, :Encoding), :UTF_8)`.
+      #
+      # If set to true, `__ENCODING__` is emitted as
+      # `s(:__ENCODING__)`.
+      #
+      # @return [Boolean]
+      attr_accessor :emit_encoding
+    end
+
+    @emit_encoding = false
+
+    class << self
+      ##
+      # AST compatibility attribute; indexed assignment, `x[] = 1`, is not
+      # semantically equivalent to calling the method directly, `x.[]=(1)`.
+      # Specifically, in the former case, the expression's value is always 1,
+      # and in the latter case, the expression's value is the return value
+      # of the `[]=` method.
+      #
+      # If set to false (the default), `self[1]` is emitted as
+      # `s(:send, s(:self), :[], s(:int, 1))`, and `self[1] = 2` is
+      # emitted as `s(:send, s(:self), :[]=, s(:int, 1), s(:int, 2))`.
+      #
+      # If set to true, `self[1]` is emitted as
+      # `s(:index, s(:self), s(:int, 1))`, and `self[1] = 2` is
+      # emitted as `s(:indexasgn, s(:self), s(:int, 1), s(:int, 2))`.
+      #
+      # @return [Boolean]
+      attr_accessor :emit_index
+    end
+
+    @emit_index = false
+
     class << self
       ##
       # @api private
       def modernize
         @emit_lambda = true
         @emit_procarg0 = true
+        @emit_encoding = true
+        @emit_index = true
       end
     end
 
@@ -56,7 +98,7 @@ module Parser
     attr_accessor :parser
 
     ##
-    # If set to true, `__FILE__` and `__LINE__` are transformed to
+    # If set to true (the default), `__FILE__` and `__LINE__` are transformed to
     # literal nodes. For example, `s(:str, "lib/foo.rb")` and `s(:int, 10)`.
     #
     # If set to false, `__FILE__` and `__LINE__` are emitted as-is,
@@ -424,8 +466,12 @@ module Parser
         end
 
       when :__ENCODING__
-        n(:const, [ n(:const, [ nil, :Encoding], nil), :UTF_8 ],
-          node.loc.dup)
+        if !self.class.emit_encoding
+          n(:const, [ n(:const, [ nil, :Encoding], nil), :UTF_8 ],
+            node.loc.dup)
+        else
+          node
+        end
 
       when :ident
         name, = *node
@@ -515,12 +561,16 @@ module Parser
 
     def op_assign(lhs, op_t, rhs)
       case lhs.type
-      when :gvasgn, :ivasgn, :lvasgn, :cvasgn, :casgn, :send, :csend
+      when :gvasgn, :ivasgn, :lvasgn, :cvasgn, :casgn, :send, :csend, :index
         operator   = value(op_t)[0..-1].to_sym
         source_map = lhs.loc.
                         with_operator(loc(op_t)).
                         with_expression(join_exprs(lhs, rhs))
 
+        if lhs.type  == :index
+          lhs = lhs.updated(:indexasgn)
+        end
+
         case operator
         when :'&&'
           n(:and_asgn, [ lhs, rhs ], source_map)
@@ -785,7 +835,7 @@ module Parser
         diagnostic :error, :block_and_blockarg, nil, last_arg.loc.expression, [loc(begin_t)]
       end
 
-      if [:send, :csend, :super, :zsuper, :lambda].include?(method_call.type)
+      if [:send, :csend, :index, :super, :zsuper, :lambda].include?(method_call.type)
         n(:block, [ method_call, args, body ],
           block_map(method_call.loc.expression, begin_t, end_t))
       else
@@ -825,14 +875,24 @@ module Parser
     end
 
     def index(receiver, lbrack_t, indexes, rbrack_t)
-      n(:send, [ receiver, :[], *indexes ],
-        send_index_map(receiver, lbrack_t, rbrack_t))
+      if self.class.emit_index
+        n(:index, [ receiver, *indexes ],
+          index_map(receiver, lbrack_t, rbrack_t))
+      else
+        n(:send, [ receiver, :[], *indexes ],
+          send_index_map(receiver, lbrack_t, rbrack_t))
+      end
     end
 
     def index_asgn(receiver, lbrack_t, indexes, rbrack_t)
-      # Incomplete method call.
-      n(:send, [ receiver, :[]=, *indexes ],
-        send_index_map(receiver, lbrack_t, rbrack_t))
+      if self.class.emit_index
+        n(:indexasgn, [ receiver, *indexes ],
+          index_map(receiver, lbrack_t, rbrack_t))
+      else
+        # Incomplete method call.
+        n(:send, [ receiver, :[]=, *indexes ],
+          send_index_map(receiver, lbrack_t, rbrack_t))
+      end
     end
 
     def binary_op(receiver, operator_t, arg)
@@ -1411,6 +1471,11 @@ module Parser
                             expr_l)
     end
 
+    def index_map(receiver_e, lbrack_t, rbrack_t)
+      Source::Map::Index.new(loc(lbrack_t), loc(rbrack_t),
+                             receiver_e.loc.expression.join(loc(rbrack_t)))
+    end
+
     def send_index_map(receiver_e, lbrack_t, rbrack_t)
       Source::Map::Send.new(nil, loc(lbrack_t).join(loc(rbrack_t)),
                             nil, nil,

data/lib/parser/current.rb

@@ -67,8 +67,8 @@ module Parser
 
   else # :nocov:
     # Keep this in sync with released Ruby.
-    warn_syntax_deviation 'parser/ruby24', '2.4.x'
-    require 'parser/ruby24'
-    CurrentRuby = Ruby24
+    warn_syntax_deviation 'parser/ruby25', '2.5.x'
+    require 'parser/ruby25'
+    CurrentRuby = Ruby25
   end
 end

data/lib/parser/lexer.rl

@@ -89,7 +89,7 @@ class Parser::Lexer
 
   REGEXP_META_CHARACTERS = Regexp.union(*"\\$()*+.<>?[]^{|}".chars).freeze
 
-  attr_reader   :source_buffer
+  attr_reader   :source_buffer, :last_token
 
   attr_accessor :diagnostics
   attr_accessor :static_env
@@ -175,6 +175,9 @@ class Parser::Lexer
 
     # State before =begin / =end block comment
     @cs_before_block_comment = self.class.lex_en_line_begin
+
+    # Last emitted token
+    @last_token = nil
   end
 
   def source_buffer=(source_buffer)
@@ -325,6 +328,7 @@ class Parser::Lexer
     token = [ type, [ value, range(s, e) ] ]
 
     @token_queue.push(token)
+    @last_token = token
 
     @tokens.push(token) if @tokens
 
@@ -1433,12 +1437,12 @@ class Parser::Lexer
       w_space* e_lbrace
       => {
         if @lambda_stack.last == @paren_nest
-          p = @ts - 1
-          fgoto expr_end;
+          @lambda_stack.pop
+          emit(:tLAMBEG, '{'.freeze, @te - 1, @te)
         else
           emit(:tLCURLY, '{'.freeze, @te - 1, @te)
-          fnext expr_value; fbreak;
         end
+        fnext expr_value; fbreak;
       };
 
       #

data/lib/parser/meta.rb

@@ -22,7 +22,7 @@ module Parser
         and not or if when case while until while_post
         until_post for break next redo return resbody
         kwbegin begin retry preexe postexe iflipflop eflipflop
-        shadowarg complex rational __FILE__ __LINE__
+        shadowarg complex rational __FILE__ __LINE__ __ENCODING__
       ).map(&:to_sym).to_set.freeze
 
   end # Meta

data/lib/parser/ruby24.y

@@ -850,7 +850,28 @@ rule
                     }
 
     command_args:   {
-                      @lexer.cmdarg.push(true)
+                      # When branch gets invoked by RACC's lookahead
+                      # and command args start with '[' or '('
+                      # we need to put `true` to the cmdarg stack
+                      # **before** `false` pushed by lexer
+                      #   m [], n
+                      #     ^
+                      # Right here we have cmdarg [...0] because
+                      # lexer pushed it on '['
+                      # We need to modify cmdarg stack to [...10]
+                      #
+                      # For all other cases (like `m n` or `m n, []`) we simply put 1 to the stack
+                      # and later lexer pushes corresponding bits on top of it.
+                      last_token = @lexer.last_token[0]
+                      lookahead = last_token == :tLBRACK || last_token == :tLPAREN_ARG
+
+                      if lookahead
+                        top = @lexer.cmdarg.pop
+                        @lexer.cmdarg.push(true)
+                        @lexer.cmdarg.push(top)
+                      else
+                        @lexer.cmdarg.push(true)
+                      end
                     }
                   call_args
                     {
@@ -1836,7 +1857,7 @@ regexp_contents: # nothing
                     }
                     compstmt tSTRING_DEND
                     {
-                      @lexer.cond.lexpop
+                      @lexer.cond.pop
                       @lexer.cmdarg.pop
 
                       result = @builder.begin(val[0], val[2], val[3])

data/lib/parser/ruby25.y

@@ -71,9 +71,14 @@ rule
                     }
 
         top_stmt: stmt
-                | klBEGIN tLCURLY top_compstmt tRCURLY
+                | klBEGIN begin_block
                     {
-                      result = @builder.preexe(val[0], val[1], val[2], val[3])
+                      result = @builder.preexe(val[0], *val[1])
+                    }
+
+     begin_block: tLCURLY top_compstmt tRCURLY
+                    {
+                      result = val
                     }
 
         bodystmt: compstmt opt_rescue opt_else opt_ensure
@@ -115,7 +120,7 @@ rule
                     }
 
    stmt_or_begin: stmt
-                | klBEGIN tLCURLY top_compstmt tRCURLY
+                | klBEGIN begin_block
                     {
                       diagnostic :error, :begin_in_method, nil, val[0]
                     }
@@ -273,6 +278,15 @@ rule
 
       expr_value: expr
 
+   expr_value_do:   {
+                      @lexer.cond.push(true)
+                    }
+                  expr_value do
+                    {
+                      @lexer.cond.pop
+                      result = [ val[1], val[2] ]
+                    }
+
     command_call: command
                 | block_command
 
@@ -846,7 +860,28 @@ rule
                     }
 
     command_args:   {
-                      @lexer.cmdarg.push(true)
+                      # When branch gets invoked by RACC's lookahead
+                      # and command args start with '[' or '('
+                      # we need to put `true` to the cmdarg stack
+                      # **before** `false` pushed by lexer
+                      #   m [], n
+                      #     ^
+                      # Right here we have cmdarg [...0] because
+                      # lexer pushed it on '['
+                      # We need to modify cmdarg stack to [...10]
+                      #
+                      # For all other cases (like `m n` or `m n, []`) we simply put 1 to the stack
+                      # and later lexer pushes corresponding bits on top of it.
+                      last_token = @lexer.last_token[0]
+                      lookahead = last_token == :tLBRACK || last_token == :tLPAREN_ARG
+
+                      if lookahead
+                        top = @lexer.cmdarg.pop
+                        @lexer.cmdarg.push(true)
+                        @lexer.cmdarg.push(top)
+                      else
+                        @lexer.cmdarg.push(true)
+                      end
                     }
                   call_args
                     {
@@ -1039,31 +1074,13 @@ rule
                                                   else_,  else_t,
                                                   val[3], val[5])
                     }
-                | kWHILE
+                | kWHILE expr_value_do compstmt kEND
                     {
-                      @lexer.cond.push(true)
-                    }
-                    expr_value do
-                    {
-                      @lexer.cond.pop
+                      result = @builder.loop(:while, val[0], *val[1], val[2], val[3])
                     }
-                    compstmt kEND
+                | kUNTIL expr_value_do compstmt kEND
                     {
-                      result = @builder.loop(:while, val[0], val[2], val[3],
-                                             val[5], val[6])
-                    }
-                | kUNTIL
-                    {
-                      @lexer.cond.push(true)
-                    }
-                    expr_value do
-                    {
-                      @lexer.cond.pop
-                    }
-                    compstmt kEND
-                    {
-                      result = @builder.loop(:until, val[0], val[2], val[3],
-                                             val[5], val[6])
+                      result = @builder.loop(:until, val[0], *val[1], val[2], val[3])
                     }
                 | kCASE expr_value opt_terms case_body kEND
                     {
@@ -1081,24 +1098,15 @@ rule
                                              when_bodies, else_t, else_body,
                                              val[3])
                     }
-                | kFOR for_var kIN
-                    {
-                      @lexer.cond.push(true)
-                    }
-                    expr_value do
+                | kFOR for_var kIN expr_value_do compstmt kEND
                     {
-                      @lexer.cond.pop
-                    }
-                    compstmt kEND
-                    {
-                      result = @builder.for(val[0], val[1],
-                                            val[2], val[4],
-                                            val[5], val[7], val[8])
+                      result = @builder.for(val[0], val[1], val[2], *val[3], val[4], val[5])
                     }
                 | kCLASS cpath superclass
                     {
                       @static_env.extend_static
                       @lexer.push_cmdarg
+                      @lexer.push_cond
                       @context.push(:class)
                     }
                     bodystmt kEND
@@ -1113,6 +1121,7 @@ rule
                                                   val[4], val[5])
 
                       @lexer.pop_cmdarg
+                      @lexer.pop_cond
                       @static_env.unextend
                       @context.pop
                     }
@@ -1120,6 +1129,7 @@ rule
                     {
                       @static_env.extend_static
                       @lexer.push_cmdarg
+                      @lexer.push_cond
                       @context.push(:sclass)
                     }
                     bodystmt kEND
@@ -1128,6 +1138,7 @@ rule
                                                    val[5], val[6])
 
                       @lexer.pop_cmdarg
+                      @lexer.pop_cond
                       @static_env.unextend
                       @context.pop
                     }
@@ -1152,6 +1163,7 @@ rule
                     {
                       @static_env.extend_static
                       @lexer.push_cmdarg
+                      @lexer.push_cond
                       @context.push(:def)
                     }
                     f_arglist bodystmt kEND
@@ -1160,6 +1172,7 @@ rule
                                   val[3], val[4], val[5])
 
                       @lexer.pop_cmdarg
+                      @lexer.pop_cond
                       @static_env.unextend
                       @context.pop
                     }
@@ -1171,6 +1184,7 @@ rule
                     {
                       @static_env.extend_static
                       @lexer.push_cmdarg
+                      @lexer.push_cond
                       @context.push(:defs)
                     }
                     f_arglist bodystmt kEND
@@ -1179,6 +1193,7 @@ rule
                                   val[4], val[6], val[7], val[8])
 
                       @lexer.pop_cmdarg
+                      @lexer.pop_cond
                       @static_env.unextend
                       @context.pop
                     }
@@ -1497,7 +1512,7 @@ opt_block_args_tail:
                     {
                       @context.push(:lambda)
                     }
-                  compstmt kEND
+                  bodystmt kEND
                     {
                       result = [ val[0], val[2], val[3] ]
                       @context.pop
@@ -1839,7 +1854,7 @@ regexp_contents: # nothing
                     }
                     compstmt tSTRING_DEND
                     {
-                      @lexer.cond.lexpop
+                      @lexer.cond.pop
                       @lexer.cmdarg.pop
 
                       result = @builder.begin(val[0], val[2], val[3])

data/lib/parser/source/buffer.rb

@@ -29,7 +29,7 @@ module Parser
       # @api private
       #
       ENCODING_RE =
-        /\A\#\s*(en)?coding\s*[:=]\s*
+        /[\s#](en)?coding\s*[:=]\s*
           (
             # Special-case: there's a UTF8-MAC encoding.
             (utf8-mac)
@@ -63,6 +63,8 @@ module Parser
           encoding_line = first_line
         end
 
+        return nil if encoding_line[0] != '#'
+
         if (result = ENCODING_RE.match(encoding_line))
           Encoding.find(result[3] || result[4] || result[6])
         else

data/lib/parser/source/map/index.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Parser
+  module Source
+
+    class Map::Index < Map
+      attr_reader :begin
+      attr_reader :end
+      attr_reader :operator
+
+      def initialize(begin_l, end_l, expression_l)
+        @begin, @end = begin_l, end_l
+        @operator = nil
+
+        super(expression_l)
+      end
+
+      ##
+      # @api private
+      #
+      def with_operator(operator_l)
+        with { |map| map.update_operator(operator_l) }
+      end
+
+      protected
+
+      def update_operator(operator_l)
+        @operator = operator_l
+      end
+    end
+
+  end
+end

data/lib/parser/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Parser
-  VERSION = '2.5.0.0'
+  VERSION = '2.5.0.1'
 end

data/test/test_encoding.rb

@@ -87,4 +87,12 @@ class TestEncoding < Minitest::Test
     assert_equal Encoding::KOI8_R, recognize('#encoding:koi8-r')
     assert_equal Encoding::KOI8_R, recognize('#coding:koi8-r')
   end
+
+  def test_underscore_and_star_characters
+    assert_equal Encoding::KOI8_R, recognize('# -*- encoding: koi8-r -*-')
+  end
+
+  def test_garbage_around_encoding_comment
+    assert_equal Encoding::KOI8_R, recognize('# 1$# -*- &)* encoding: koi8-r 1$# -*- &)*')
+  end
 end

data/test/test_parser.rb

@@ -924,11 +924,22 @@ class TestParser < Minitest::Test
   end
 
   def test___ENCODING__
+    assert_parses(
+      s(:__ENCODING__),
+      %q{__ENCODING__},
+      %q{~~~~~~~~~~~~ expression},
+      SINCE_1_9)
+  end
+
+  def test___ENCODING___legacy_
+    Parser::Builders::Default.emit_encoding = false
     assert_parses(
       s(:const, s(:const, nil, :Encoding), :UTF_8),
       %q{__ENCODING__},
       %q{~~~~~~~~~~~~ expression},
       SINCE_1_9)
+  ensure
+    Parser::Builders::Default.emit_encoding = true
   end
 
   # defined?
@@ -1270,13 +1281,14 @@ class TestParser < Minitest::Test
       s(:masgn,
         s(:mlhs,
           s(:send, s(:self), :a=),
-          s(:send, s(:self), :[]=, s(:int, 1), s(:int, 2))),
+          s(:indexasgn, s(:self), s(:int, 1), s(:int, 2))),
         s(:lvar, :foo)),
       %q{self.a, self[1, 2] = foo},
-      %q{~~~~~~ expression (mlhs.send/1)
-        |     ~ selector (mlhs.send/1)
-        |            ~~~~~~ selector (mlhs.send/2)
-        |        ~~~~~~~~~~ expression (mlhs.send/2)})
+      %q{~~~~~~ expression (mlhs.send)
+        |     ~ selector (mlhs.send)
+        |            ^ begin (mlhs.indexasgn)
+        |                 ^ end (mlhs.indexasgn)
+        |        ~~~~~~~~~~ expression (mlhs.indexasgn)})
 
     assert_parses(
       s(:masgn,
@@ -1541,20 +1553,21 @@ class TestParser < Minitest::Test
   def test_op_asgn_index
     assert_parses(
       s(:op_asgn,
-        s(:send, s(:lvar, :foo), :[],
+        s(:indexasgn, s(:lvar, :foo),
           s(:int, 0), s(:int, 1)), :+,
         s(:int, 2)),
       %q{foo[0, 1] += 2},
       %q{          ^^ operator
-        |   ~~~~~~ selector (send)
-        |~~~~~~~~~ expression (send)
+        |   ^ begin (indexasgn)
+        |        ^ end (indexasgn)
+        |~~~~~~~~~ expression (indexasgn)
         |~~~~~~~~~~~~~~ expression})
   end
 
   def test_op_asgn_index_cmd
     assert_parses(
       s(:op_asgn,
-        s(:send, s(:lvar, :foo), :[],
+        s(:indexasgn, s(:lvar, :foo),
           s(:int, 0), s(:int, 1)), :+,
         s(:send, nil, :m, s(:lvar, :foo))),
       %q{foo[0, 1] += m foo})
@@ -1610,13 +1623,14 @@ class TestParser < Minitest::Test
 
     assert_parses(
       s(:or_asgn,
-        s(:send, s(:lvar, :foo), :[],
+        s(:indexasgn, s(:lvar, :foo),
           s(:int, 0), s(:int, 1)),
         s(:int, 2)),
       %q{foo[0, 1] ||= 2},
       %q{          ^^^ operator
-        |   ~~~~~~ selector (send)
-        |~~~~~~~~~ expression (send)
+        |   ^ begin (indexasgn)
+        |        ^ end (indexasgn)
+        |~~~~~~~~~ expression (indexasgn)
         |~~~~~~~~~~~~~~~ expression})
   end
 
@@ -1633,13 +1647,14 @@ class TestParser < Minitest::Test
 
     assert_parses(
       s(:and_asgn,
-        s(:send, s(:lvar, :foo), :[],
+        s(:indexasgn, s(:lvar, :foo),
           s(:int, 0), s(:int, 1)),
         s(:int, 2)),
       %q{foo[0, 1] &&= 2},
       %q{          ^^^ operator
-        |   ~~~~~~ selector (send)
-        |~~~~~~~~~ expression (send)
+        |   ^ begin (indexasgn)
+        |        ^ end (indexasgn)
+        |~~~~~~~~~ expression (indexasgn)
         |~~~~~~~~~~~~~~~ expression})
   end
 
@@ -2617,6 +2632,7 @@ class TestParser < Minitest::Test
         s(:arg, :a)),
       %q{|a|}
     )
+  ensure
     Parser::Builders::Default.emit_procarg0 = true
   end
 
@@ -3346,22 +3362,47 @@ class TestParser < Minitest::Test
   end
 
   def test_send_index
+    assert_parses(
+      s(:index, s(:lvar, :foo),
+        s(:int, 1), s(:int, 2)),
+      %q{foo[1, 2]},
+      %q{   ^ begin
+        |        ^ end
+        |~~~~~~~~~ expression})
+  end
+
+  def test_send_index_legacy
+    Parser::Builders::Default.emit_index = false
     assert_parses(
       s(:send, s(:lvar, :foo), :[],
         s(:int, 1), s(:int, 2)),
       %q{foo[1, 2]},
       %q{   ~~~~~~ selector
         |~~~~~~~~~ expression})
+  ensure
+    Parser::Builders::Default.emit_index = true
   end
 
   def test_send_index_cmd
     assert_parses(
-      s(:send, s(:lvar, :foo), :[],
+      s(:index, s(:lvar, :foo),
         s(:send, nil, :m, s(:lvar, :bar))),
       %q{foo[m bar]})
   end
 
   def test_send_index_asgn
+    assert_parses(
+      s(:indexasgn, s(:lvar, :foo),
+        s(:int, 1), s(:int, 2), s(:int, 3)),
+      %q{foo[1, 2] = 3},
+      %q{   ^ begin
+        |        ^ end
+        |          ^ operator
+        |~~~~~~~~~~~~~ expression})
+  end
+
+  def test_send_index_asgn_legacy
+    Parser::Builders::Default.emit_index = false
     assert_parses(
       s(:send, s(:lvar, :foo), :[]=,
         s(:int, 1), s(:int, 2), s(:int, 3)),
@@ -3369,6 +3410,8 @@ class TestParser < Minitest::Test
       %q{   ~~~~~~ selector
         |          ^ operator
         |~~~~~~~~~~~~~ expression})
+  ensure
+    Parser::Builders::Default.emit_index = true
   end
 
   def test_send_lambda
@@ -3473,6 +3516,7 @@ class TestParser < Minitest::Test
         |    ^ end
         |~~~~~ expression},
       SINCE_1_9)
+  ensure
     Parser::Builders::Default.emit_lambda = true
   end
 
@@ -3698,7 +3742,7 @@ class TestParser < Minitest::Test
 
   def test_args_args_comma
     assert_parses(
-      s(:send, s(:lvar, :foo), :[],
+      s(:index, s(:lvar, :foo),
         s(:lvar, :bar)),
       %q{foo[bar,]},
       %q{},
@@ -3739,7 +3783,7 @@ class TestParser < Minitest::Test
 
   def test_args_assocs_comma
     assert_parses(
-      s(:send, s(:lvar, :foo), :[],
+      s(:index, s(:lvar, :foo),
         s(:hash, s(:pair, s(:sym, :baz), s(:int, 1)))),
       %q{foo[:baz => 1,]},
       %q{},
@@ -3763,7 +3807,7 @@ class TestParser < Minitest::Test
 
   def test_args_args_assocs_comma
     assert_parses(
-      s(:send, s(:lvar, :foo), :[],
+      s(:index, s(:lvar, :foo),
         s(:lvar, :bar),
         s(:hash, s(:pair, s(:sym, :baz), s(:int, 1)))),
       %q{foo[bar, :baz => 1,]},
@@ -5776,8 +5820,8 @@ class TestParser < Minitest::Test
 
     assert_parses(
       s(:op_asgn,
-        s(:send,
-          s(:lvar, :foo), :[],
+        s(:indexasgn,
+          s(:lvar, :foo),
           s(:int, 0)), :+,
         s(:rescue,
           s(:send, nil, :raise,
@@ -5865,8 +5909,8 @@ class TestParser < Minitest::Test
 
     assert_parses(
       s(:op_asgn,
-        s(:send,
-          s(:lvar, :foo), :[],
+        s(:indexasgn,
+          s(:lvar, :foo),
           s(:int, 0)), :+,
         s(:rescue,
           s(:send, nil, :raise,
@@ -6484,6 +6528,136 @@ class TestParser < Minitest::Test
     end
   end
 
+  def test_method_definition_in_while_cond
+    assert_parses(
+      s(:while,
+        s(:def, :foo,
+          s(:args),
+          s(:block,
+            s(:send, nil, :tap),
+            s(:args), nil)),
+        s(:break)),
+      %q{while def foo; tap do end; end; break; end},
+      %q{},
+      SINCE_2_5)
+
+    assert_parses(
+      s(:while,
+        s(:defs,
+          s(:self), :foo,
+          s(:args),
+          s(:block,
+            s(:send, nil, :tap),
+            s(:args), nil)),
+        s(:break)),
+      %q{while def self.foo; tap do end; end; break; end},
+      %q{},
+      SINCE_2_5)
+
+    assert_parses(
+      s(:while,
+        s(:def, :foo,
+          s(:args,
+            s(:optarg, :a,
+              s(:block,
+                s(:send, nil, :tap),
+                s(:args), nil))), nil),
+        s(:break)),
+      %q{while def foo a = tap do end; end; break; end},
+      %q{},
+      SINCE_2_5)
+
+    assert_parses(
+      s(:while,
+        s(:defs,
+          s(:self), :foo,
+          s(:args,
+            s(:optarg, :a,
+              s(:block,
+                s(:send, nil, :tap),
+                s(:args), nil))), nil),
+        s(:break)),
+      %q{while def self.foo a = tap do end; end; break; end},
+      %q{},
+      SINCE_2_5)
+  end
+
+  def test_class_definition_in_while_cond
+    assert_parses(
+      s(:while,
+        s(:class,
+          s(:const, nil, :Foo), nil,
+          s(:block,
+            s(:send, nil, :tap),
+            s(:args), nil)),
+        s(:break)),
+      %q{while class Foo; tap do end; end; break; end},
+      %q{},
+      SINCE_2_5)
+
+    assert_parses(
+      s(:while,
+        s(:class,
+          s(:const, nil, :Foo), nil,
+          s(:lvasgn, :a,
+            s(:block,
+              s(:send, nil, :tap),
+              s(:args), nil))),
+        s(:break)),
+      %q{while class Foo a = tap do end; end; break; end},
+      %q{},
+      SINCE_2_5)
+
+    assert_parses(
+      s(:while,
+        s(:sclass,
+          s(:self),
+          s(:block,
+            s(:send, nil, :tap),
+            s(:args), nil)),
+        s(:break)),
+      %q{while class << self; tap do end; end; break; end},
+      %q{},
+      SINCE_2_5)
+
+    assert_parses(
+      s(:while,
+        s(:sclass,
+          s(:self),
+          s(:lvasgn, :a,
+            s(:block,
+              s(:send, nil, :tap),
+              s(:args), nil))),
+        s(:break)),
+      %q{while class << self; a = tap do end; end; break; end},
+      %q{},
+      SINCE_2_5)
+  end
+
+  def test_rescue_in_lambda_block
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'kRESCUE'}],
+      %q{-> do rescue; end},
+      %q{      ~~~~~~ location},
+      SINCE_1_9 - SINCE_2_5)
+
+    assert_parses(
+      s(:block,
+        s(:lambda),
+        s(:args),
+        s(:rescue, nil,
+          s(:resbody, nil, nil, nil), nil)),
+      %q{-> do rescue; end},
+      %q{      ~~~~~~ keyword (rescue.resbody)},
+      SINCE_2_5)
+
+    assert_diagnoses(
+      [:error, :unexpected_token, { :token => 'kRESCUE'}],
+      %q{-> { rescue; }},
+      %q{     ~~~~~~ location},
+      SINCE_1_9)
+  end
+
   def test_ruby_bug_13547
     assert_diagnoses(
       [:error, :unexpected_token, { :token => 'tLCURLY' }],
@@ -6559,8 +6733,8 @@ class TestParser < Minitest::Test
 
     assert_parses(
       s(:block,
-        s(:send,
-          s(:send, nil, :meth), :[]),
+        s(:index,
+          s(:send, nil, :meth)),
         s(:args), nil),
       %q{meth[] {}},
       %q{},
@@ -6583,4 +6757,28 @@ class TestParser < Minitest::Test
       %q{m /foo/x {}},
       SINCE_2_4)
   end
+
+  def test_bug_447
+    assert_parses(
+      s(:block,
+        s(:send, nil, :m,
+          s(:array)),
+        s(:args), nil),
+      %q{m [] do end},
+      %q{},
+      ALL_VERSIONS)
+  end
+
+  def test_bug_435
+    assert_parses(
+      s(:dstr,
+        s(:begin,
+          s(:block,
+            s(:lambda),
+            s(:args,
+              s(:arg, :foo)), nil))),
+      %q{"#{-> foo {}}"},
+      %q{},
+      SINCE_1_9)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parser
 version: !ruby/object:Gem::Version
-  version: 2.5.0.0
+  version: 2.5.0.1
 platform: ruby
 authors:
 - whitequark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-16 00:00:00.000000000 Z
+date: 2018-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ast
@@ -230,6 +230,7 @@ files:
 - lib/parser/source/map/definition.rb
 - lib/parser/source/map/for.rb
 - lib/parser/source/map/heredoc.rb
+- lib/parser/source/map/index.rb
 - lib/parser/source/map/keyword.rb
 - lib/parser/source/map/objc_kwarg.rb
 - lib/parser/source/map/operator.rb