parser 2.3.1.4 → 2.3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 17bdbdce7c902877c996867706727505f780def2
-  data.tar.gz: 469882a9f9140cf06de8fd9d2c9d2eb80b9a9f55
+  metadata.gz: 73ca61e5ab86f82798f86bc14407c958d2b08a40
+  data.tar.gz: 9d88b4bc43581891ee5612e9c1c1d2288aa6fcc7
 SHA512:
-  metadata.gz: 0ab79279d208273259b37fa4091690f70814c211f96d4dd408c38a634dc66604b52f30ea8cd504319ac1fff7ed599db85321b6d8b08945b7389fd62a564b370c
-  data.tar.gz: 1ff67f781e7dc36b4edf4271c7c95a35f0aaa0f7b1627f8aac2079f53e420dfa8ae1ce31b60d4619205a9ea9cd5936bb04916014b0da90a428ceb4501b8b3b41
+  metadata.gz: c5c8232ddd5b94e0aff2dddec620201e99ad7db4bc4d7362e2feb2d5d4fb7456f861d6905750325cc4429e4f9a2946d9ff475d6ae3f5914af78c45fbe3e3a21e
+  data.tar.gz: 61255e34c1b006ec82b946aa173c6e2e4a48f7491db05392e0d667c3e834dfbb598e204eefd6e871a8d4bec2d254e71a1de5e65bf1db8917dfe06b76f26b34b1

data/CHANGELOG.md

@@ -1,6 +1,19 @@
 Changelog
 =========
 
+v2.3.2.0 (2016-11-20)
+---------------------
+
+API modifications:
+ * parser/current: update 2.3 branch to 2.3.2. (whitequark)
+ * Introduce (procarg0) node for a single required block argument. (Ilya Bylich)
+
+Bugs fixed:
+ * {macruby,ruby{19,20,21,22,23,24}}.y: "x::A += m x": treat as constant assignment. (whitequark)
+ * ruby24.y: "x += raise y rescue nil": bind rescue tighter than tOP_ASGN. (whitequark)
+ * ruby24.y: "x = raise y rescue nil": bind rescue tighter than =. (whitequark)
+ * Builders::Default: "begin; else; 1; end": fix a crash. (whitequark)
+
 v2.3.1.4 (2016-09-19)
 ---------------------
 
@@ -92,7 +105,7 @@ Bugs fixed:
  * Add :csend to Parser::Meta::NODE_TYPES (Markus Schirp)
  * lexer/dedenter: "\<\<x\n  y\\n  z\nx": don't dedent after escaped newline. (whitequark)
 
-v2.3.1.4 (2016-01-16)
+v2.3.2.0 (2016-01-16)
 ---------------------
 
 v2.3.0.1 (2016-01-14)

data/README.md

@@ -19,10 +19,15 @@ MacRuby and RubyMotion support sponsored by [CodeClimate](http://codeclimate.com
 
 ## Usage
 
-Parse a chunk of code:
+Load Parser (see the [backwards compatibility](#backwards-compatibility) section
+below for explanation of `emit_*` calls):
 
     require 'parser/current'
-    Parser::Builders::Default.emit_lambda = true # opt-in to most recent AST format
+    # opt-in to most recent AST format:
+    Parser::Builders::Default.emit_lambda = true
+    Parser::Builders::Default.emit_procarg0 = true
+
+Parse a chunk of code:
 
     p Parser::CurrentRuby.parse("2 + 2")
     # (send
@@ -197,6 +202,23 @@ $ ruby-parse -e '(foo) while cond'
 
 (Parser also needs the `(kwbegin)` node type internally, and it is highly problematic to map it back to `(begin)`.)
 
+## Backwards compatibility
+
+Parser does _not_ use semantic versioning. Parser versions are structured as `x.y.z.t`,
+where `x.y.z` indicates the most recent supported Ruby release (support for every
+Ruby release that is chronologically earlier is implied), and `t` is a monotonically
+increasing number.
+
+The public API of Parser as well as the AST format (as listed in the documentation)
+are considered stable forever, although support for old Ruby versions may be removed
+at some point.
+
+Sometimes it is necessary to modify the format of AST nodes that are already being emitted
+in a way that would break existing applications. To avoid such breakage, applications
+must opt-in to these modifications; without explicit opt-in, Parser will continue to emit
+the old AST node format. The most recent set of opt-ins is speified in
+the [usage section](#usage) of this README.
+
 ## Compatibility with Ruby MRI
 
 Unfortunately, Ruby MRI often changes syntax in patchlevel versions. This has happened, at least, for every release since 1.9; for example, commits [c5013452](https://github.com/ruby/ruby/commit/c501345218dc5fb0fae90d56a0c6fd19d38df5bb) and [04bb9d6b](https://github.com/ruby/ruby/commit/04bb9d6b75a55d4000700769eead5a5cb942c25b) were backported all the way from HEAD to 1.9. Moreover, there is no simple way to track these changes.

data/doc/AST_FORMAT.md

@@ -912,6 +912,25 @@ Format:
 
 Begin of the `expression` points to `&`.
 
+### Auto-expanding proc argument (1.9)
+
+In Ruby 1.9 and later, when a proc-like closure (i.e. a closure
+created by capturing a block or with the `proc` method, but not
+with the `->{}` syntax or the `lambda` method) has exactly one
+argument, and it is called with more than one argument, the behavior
+is as if the array of all arguments was instead passed as the sole
+argument. This behavior can be prevented by adding a comma after
+the sole argument (e.g. `|foo,|`).
+
+Format:
+
+~~~
+(procarg0 :foo)
+"|foo|"
+  ~~~ expression
+  ~~~ name
+~~~
+
 ### Expression arguments
 
 Ruby 1.8 allows to use arbitrary expressions as block arguments,

data/lib/parser/ast/processor.rb

@@ -121,6 +121,7 @@ module Parser
       alias on_kwarg          process_argument_node
       alias on_kwoptarg       process_argument_node
       alias on_kwrestarg      process_argument_node
+      alias on_procarg0       process_argument_node
 
       alias on_arg_expr       process_regular_node
       alias on_restarg_expr   process_regular_node

data/lib/parser/builders/default.rb

@@ -22,11 +22,30 @@ module Parser
 
     @emit_lambda = false
 
+    class << self
+      ##
+      # AST compatibility attribute; block arguments of `m { |a| }` are
+      # not semantically equivalent to block arguments of `m { |a,| }` or `m { |a, b| }`,
+      # 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))`
+      #
+      # If set to true, arguments of `m { |a| }` are emitted as
+      # `s(:args, s(:procarg0, :a))
+      #
+      # @return [Boolean]
+      attr_accessor :emit_procarg0
+    end
+
+    @emit_procarg0 = false
+
     class << self
       ##
       # @api private
       def modernize
         @emit_lambda = true
+        @emit_procarg0 = true
       end
     end
 
@@ -637,6 +656,14 @@ module Parser
         arg_prefix_map(amper_t, name_t))
     end
 
+    def procarg0(arg)
+      if self.class.emit_procarg0
+        arg.updated(:procarg0)
+      else
+        arg
+      end
+    end
+
     # Ruby 1.8 block arguments
 
     def arg_expr(expr)
@@ -984,10 +1011,12 @@ module Parser
         end
       elsif else_t
         statements = []
-        if compound_stmt.type == :begin
-          statements += compound_stmt.children
-        else
-          statements.push(compound_stmt)
+        if !compound_stmt.nil?
+          if compound_stmt.type == :begin
+            statements += compound_stmt.children
+          else
+            statements.push(compound_stmt)
+          end
         end
         statements.push(
           n(:begin, [ else_ ],
@@ -1110,7 +1139,7 @@ module Parser
         case this_arg.type
         when :arg, :optarg, :restarg, :blockarg,
              :kwarg, :kwoptarg, :kwrestarg,
-             :shadowarg
+             :shadowarg, :procarg0
 
           this_name, = *this_arg
 

data/lib/parser/current.rb

@@ -55,7 +55,7 @@ module Parser
     CurrentRuby = Ruby22
 
   when /^2\.3\./
-    current_version = '2.3.1'
+    current_version = '2.3.2'
     if RUBY_VERSION != current_version
       warn_syntax_deviation 'parser/ruby23', current_version
     end

data/lib/parser/macruby.y

@@ -206,10 +206,7 @@ rule
                     }
                 | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
                     {
-                      result = @builder.op_assign(
-                                  @builder.call_method(
-                                    val[0], val[1], val[2]),
-                                  val[3], val[4])
+                      diagnostic :error, :const_reassignment, nil, val[3]
                     }
                 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
                     {
@@ -1350,9 +1347,6 @@ rule
                                   concat(val[3])
                     }
                 | f_arg tCOMMA
-                  {
-                    result = [@builder.multi_lhs(nil, val[0], nil)]
-                  }
                 | f_arg tCOMMA                       f_rest_arg tCOMMA f_arg opt_f_block_arg
                     {
                       result = val[0].
@@ -1362,7 +1356,11 @@ rule
                     }
                 | f_arg                                                      opt_f_block_arg
                     {
-                      result = val[0].concat(val[1])
+                      if val[1].empty? && val[0].size == 1
+                        result = [@builder.procarg0(val[0][0])]
+                      else
+                        result = val[0].concat(val[1])
+                      end
                     }
                 | f_block_optarg tCOMMA f_rest_arg              opt_f_block_arg
                     {

data/lib/parser/messages.rb

@@ -48,6 +48,7 @@ module Parser
     :odd_hash                => 'odd number of entries for a hash',
     :singleton_literal       => 'cannot define a singleton method for a literal',
     :dynamic_const           => 'dynamic constant assignment',
+    :const_reassignment      => 'constant re-assignment',
     :module_in_def           => 'module definition in method body',
     :class_in_def            => 'class definition in method body',
     :unexpected_percent_str  => '%{type}: unknown type of percent-literal',

data/lib/parser/ruby18.y

@@ -1259,9 +1259,6 @@ rule
 
        block_var: block_par
                 | block_par tCOMMA
-                  {
-                    result = [@builder.multi_lhs(nil, val[0], nil)]
-                  }
                 | block_par tCOMMA tAMPER lhs
                     {
                       result =  val[0].

data/lib/parser/ruby19.y

@@ -203,10 +203,7 @@ rule
                     }
                 | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
                     {
-                      result = @builder.op_assign(
-                                  @builder.call_method(
-                                    val[0], val[1], val[2]),
-                                  val[3], val[4])
+                      diagnostic :error, :const_reassignment, nil, val[3]
                     }
                 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
                     {
@@ -1330,9 +1327,6 @@ rule
                                   concat(val[3])
                     }
                 | f_arg tCOMMA
-                  {
-                    result = [@builder.multi_lhs(nil, val[0], nil)]
-                  }
                 | f_arg tCOMMA                       f_rest_arg tCOMMA f_arg opt_f_block_arg
                     {
                       result = val[0].
@@ -1342,7 +1336,11 @@ rule
                     }
                 | f_arg                                                      opt_f_block_arg
                     {
-                      result = val[0].concat(val[1])
+                      if val[1].empty? && val[0].size == 1
+                        result = [@builder.procarg0(val[0][0])]
+                      else
+                        result = val[0].concat(val[1])
+                      end
                     }
                 | f_block_optarg tCOMMA f_rest_arg              opt_f_block_arg
                     {

data/lib/parser/ruby20.y

@@ -213,10 +213,9 @@ rule
                     }
                 | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
                     {
-                      result = @builder.op_assign(
-                                  @builder.call_method(
-                                    val[0], val[1], val[2]),
-                                  val[3], val[4])
+                      const  = @builder.const_op_assignable(
+                                  @builder.const_fetch(val[0], val[1], val[2]))
+                      result = @builder.op_assign(const, val[3], val[4])
                     }
                 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
                     {
@@ -1385,9 +1384,6 @@ opt_block_args_tail:
                                   concat(val[3])
                     }
                 | f_arg tCOMMA
-                  {
-                    result = [@builder.multi_lhs(nil, val[0], nil)]
-                  }
                 | f_arg tCOMMA                       f_rest_arg tCOMMA f_arg opt_block_args_tail
                     {
                       result = val[0].
@@ -1397,7 +1393,11 @@ opt_block_args_tail:
                     }
                 | f_arg                                                      opt_block_args_tail
                     {
-                      result = val[0].concat(val[1])
+                      if val[1].empty? && val[0].size == 1
+                        result = [@builder.procarg0(val[0][0])]
+                      else
+                        result = val[0].concat(val[1])
+                      end
                     }
                 | f_block_optarg tCOMMA              f_rest_arg              opt_block_args_tail
                     {

data/lib/parser/ruby21.y

@@ -210,10 +210,9 @@ rule
                     }
                 | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
                     {
-                      result = @builder.op_assign(
-                                  @builder.call_method(
-                                    val[0], val[1], val[2]),
-                                  val[3], val[4])
+                      const  = @builder.const_op_assignable(
+                                  @builder.const_fetch(val[0], val[1], val[2]))
+                      result = @builder.op_assign(const, val[3], val[4])
                     }
                 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
                     {
@@ -1365,9 +1364,6 @@ opt_block_args_tail:
                                   concat(val[3])
                     }
                 | f_arg tCOMMA
-                  {
-                    result = [@builder.multi_lhs(nil, val[0], nil)]
-                  }
                 | f_arg tCOMMA                       f_rest_arg tCOMMA f_arg opt_block_args_tail
                     {
                       result = val[0].
@@ -1377,7 +1373,11 @@ opt_block_args_tail:
                     }
                 | f_arg                                                      opt_block_args_tail
                     {
-                      result = val[0].concat(val[1])
+                      if val[1].empty? && val[0].size == 1
+                        result = [@builder.procarg0(val[0][0])]
+                      else
+                        result = val[0].concat(val[1])
+                      end
                     }
                 | f_block_optarg tCOMMA              f_rest_arg              opt_block_args_tail
                     {

data/lib/parser/ruby22.y

@@ -210,10 +210,9 @@ rule
                     }
                 | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
                     {
-                      result = @builder.op_assign(
-                                  @builder.call_method(
-                                    val[0], val[1], val[2]),
-                                  val[3], val[4])
+                      const  = @builder.const_op_assignable(
+                                  @builder.const_fetch(val[0], val[1], val[2]))
+                      result = @builder.op_assign(const, val[3], val[4])
                     }
                 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
                     {
@@ -1364,9 +1363,6 @@ opt_block_args_tail:
                                   concat(val[3])
                     }
                 | f_arg tCOMMA
-                  {
-                    result = [@builder.multi_lhs(nil, val[0], nil)]
-                  }
                 | f_arg tCOMMA                       f_rest_arg tCOMMA f_arg opt_block_args_tail
                     {
                       result = val[0].
@@ -1376,7 +1372,11 @@ opt_block_args_tail:
                     }
                 | f_arg                                                      opt_block_args_tail
                     {
-                      result = val[0].concat(val[1])
+                      if val[1].empty? && val[0].size == 1
+                        result = [@builder.procarg0(val[0][0])]
+                      else
+                        result = val[0].concat(val[1])
+                      end
                     }
                 | f_block_optarg tCOMMA              f_rest_arg              opt_block_args_tail
                     {

data/lib/parser/ruby23.y

@@ -210,10 +210,9 @@ rule
                     }
                 | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
                     {
-                      result = @builder.op_assign(
-                                  @builder.call_method(
-                                    val[0], val[1], val[2]),
-                                  val[3], val[4])
+                      const  = @builder.const_op_assignable(
+                                  @builder.const_fetch(val[0], val[1], val[2]))
+                      result = @builder.op_assign(const, val[3], val[4])
                     }
                 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
                     {
@@ -1364,9 +1363,6 @@ opt_block_args_tail:
                                   concat(val[3])
                     }
                 | f_arg tCOMMA
-                  {
-                    result = [@builder.multi_lhs(nil, val[0], nil)]
-                  }
                 | f_arg tCOMMA                       f_rest_arg tCOMMA f_arg opt_block_args_tail
                     {
                       result = val[0].
@@ -1376,7 +1372,11 @@ opt_block_args_tail:
                     }
                 | f_arg                                                      opt_block_args_tail
                     {
-                      result = val[0].concat(val[1])
+                      if val[1].empty? && val[0].size == 1
+                        result = [@builder.procarg0(val[0][0])]
+                      else
+                        result = val[0].concat(val[1])
+                      end
                     }
                 | f_block_optarg tCOMMA              f_rest_arg              opt_block_args_tail
                     {

data/lib/parser/ruby24.y

@@ -183,46 +183,45 @@ rule
                     {
                       result = @builder.multi_assign(val[0], val[1], val[2])
                     }
-                | var_lhs tOP_ASGN command_call
+                | var_lhs tOP_ASGN command_rhs
                     {
                       result = @builder.op_assign(val[0], val[1], val[2])
                     }
-                | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN command_call
+                | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN command_rhs
                     {
                       result = @builder.op_assign(
                                   @builder.index(
                                     val[0], val[1], val[2], val[3]),
                                   val[4], val[5])
                     }
-                | primary_value call_op tIDENTIFIER tOP_ASGN command_call
+                | primary_value call_op tIDENTIFIER tOP_ASGN command_rhs
                     {
                       result = @builder.op_assign(
                                   @builder.call_method(
                                     val[0], val[1], val[2]),
                                   val[3], val[4])
                     }
-                | primary_value call_op tCONSTANT tOP_ASGN command_call
+                | primary_value call_op tCONSTANT tOP_ASGN command_rhs
                     {
                       result = @builder.op_assign(
                                   @builder.call_method(
                                     val[0], val[1], val[2]),
                                   val[3], val[4])
                     }
-                | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
+                | primary_value tCOLON2 tCONSTANT tOP_ASGN command_rhs
                     {
-                      result = @builder.op_assign(
-                                  @builder.call_method(
-                                    val[0], val[1], val[2]),
-                                  val[3], val[4])
+                      const  = @builder.const_op_assignable(
+                                  @builder.const_fetch(val[0], val[1], val[2]))
+                      result = @builder.op_assign(const, val[3], val[4])
                     }
-                | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
+                | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_rhs
                     {
                       result = @builder.op_assign(
                                   @builder.call_method(
                                     val[0], val[1], val[2]),
                                   val[3], val[4])
                     }
-                | backref tOP_ASGN command_call
+                | backref tOP_ASGN command_rhs
                     {
                       @builder.op_assign(val[0], val[1], val[2])
                     }
@@ -237,14 +236,21 @@ rule
                     }
                 | expr
 
-    command_asgn: lhs tEQL command_call
+    command_asgn: lhs tEQL command_rhs
                     {
                       result = @builder.assign(val[0], val[1], val[2])
                     }
-                | lhs tEQL command_asgn
+
+     command_rhs: command_call =tOP_ASGN
+                | command_call kRESCUE_MOD stmt
                     {
-                      result = @builder.assign(val[0], val[1], val[2])
+                      rescue_body = @builder.rescue_body(val[1],
+                                        nil, nil, nil,
+                                        nil, val[2])
+
+                      result = @builder.begin_body(val[0], [ rescue_body ])
                     }
+                | command_asgn
 
             expr: command_call
                 | expr kAND expr
@@ -277,15 +283,9 @@ rule
                                   nil, val[3], nil)
                     }
 
- cmd_brace_block: tLBRACE_ARG
+ cmd_brace_block: tLBRACE_ARG brace_body tRCURLY
                     {
-                      @static_env.extend_dynamic
-                    }
-                    opt_block_param compstmt tRCURLY
-                    {
-                      result = [ val[0], val[2], val[3], val[4] ]
-
-                      @static_env.unextend
+                      result = [ val[0], *val[1], val[2] ]
                     }
 
            fcall: operation
@@ -586,75 +586,55 @@ rule
                 | kWHEN     | kYIELD    | kIF           | kUNLESS | kWHILE
                 | kUNTIL
 
-             arg: lhs tEQL arg
+             arg: lhs tEQL arg_rhs
                     {
                       result = @builder.assign(val[0], val[1], val[2])
                     }
-                | lhs tEQL arg kRESCUE_MOD arg
-                    {
-                      rescue_body = @builder.rescue_body(val[3],
-                                        nil, nil, nil,
-                                        nil, val[4])
-
-                      rescue_ = @builder.begin_body(val[2], [ rescue_body ])
-
-                      result  = @builder.assign(val[0], val[1], rescue_)
-                    }
-                | var_lhs tOP_ASGN arg
+                | var_lhs tOP_ASGN arg_rhs
                     {
                       result = @builder.op_assign(val[0], val[1], val[2])
                     }
-                | var_lhs tOP_ASGN arg kRESCUE_MOD arg
-                    {
-                      rescue_body = @builder.rescue_body(val[3],
-                                        nil, nil, nil,
-                                        nil, val[4])
-
-                      rescue_ = @builder.begin_body(val[2], [ rescue_body ])
-
-                      result = @builder.op_assign(val[0], val[1], rescue_)
-                    }
-                | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN arg
+                | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN arg_rhs
                     {
                       result = @builder.op_assign(
                                   @builder.index(
                                     val[0], val[1], val[2], val[3]),
                                   val[4], val[5])
                     }
-                | primary_value call_op tIDENTIFIER tOP_ASGN arg
+                | primary_value call_op tIDENTIFIER tOP_ASGN arg_rhs
                     {
                       result = @builder.op_assign(
                                   @builder.call_method(
                                     val[0], val[1], val[2]),
                                   val[3], val[4])
                     }
-                | primary_value call_op tCONSTANT tOP_ASGN arg
+                | primary_value call_op tCONSTANT tOP_ASGN arg_rhs
                     {
                       result = @builder.op_assign(
                                   @builder.call_method(
                                     val[0], val[1], val[2]),
                                   val[3], val[4])
                     }
-                | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg
+                | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg_rhs
                     {
                       result = @builder.op_assign(
                                   @builder.call_method(
                                     val[0], val[1], val[2]),
                                   val[3], val[4])
                     }
-                | primary_value tCOLON2 tCONSTANT tOP_ASGN arg
+                | primary_value tCOLON2 tCONSTANT tOP_ASGN arg_rhs
                     {
                       const  = @builder.const_op_assignable(
                                   @builder.const_fetch(val[0], val[1], val[2]))
                       result = @builder.op_assign(const, val[3], val[4])
                     }
-                | tCOLON3 tCONSTANT tOP_ASGN arg
+                | tCOLON3 tCONSTANT tOP_ASGN arg_rhs
                     {
                       const  = @builder.const_op_assignable(
                                   @builder.const_global(val[0], val[1]))
                       result = @builder.op_assign(const, val[2], val[3])
                     }
-                | backref tOP_ASGN arg
+                | backref tOP_ASGN arg_rhs
                     {
                       result = @builder.op_assign(val[0], val[1], val[2])
                     }
@@ -804,6 +784,16 @@ rule
                       result = [ @builder.associate(nil, val[0], nil) ]
                     }
 
+         arg_rhs: arg =tOP_ASGN
+                | arg kRESCUE_MOD arg
+                    {
+                      rescue_body = @builder.rescue_body(val[1],
+                                        nil, nil, nil,
+                                        nil, val[2])
+
+                      result = @builder.begin_body(val[0], [ rescue_body ])
+                    }
+
       paren_args: tLPAREN2 opt_call_args rparen
                     {
                       result = val
@@ -1364,9 +1354,6 @@ opt_block_args_tail:
                                   concat(val[3])
                     }
                 | f_arg tCOMMA
-                  {
-                    result = [@builder.multi_lhs(nil, val[0], nil)]
-                  }
                 | f_arg tCOMMA                       f_rest_arg tCOMMA f_arg opt_block_args_tail
                     {
                       result = val[0].
@@ -1376,7 +1363,11 @@ opt_block_args_tail:
                     }
                 | f_arg                                                      opt_block_args_tail
                     {
-                      result = val[0].concat(val[1])
+                      if val[1].empty? && val[0].size == 1
+                        result = [@builder.procarg0(val[0][0])]
+                      else
+                        result = val[0].concat(val[1])
+                      end
                     }
                 | f_block_optarg tCOMMA              f_rest_arg              opt_block_args_tail
                     {
@@ -1498,15 +1489,9 @@ opt_block_args_tail:
                       result = [ val[0], val[1], val[2] ]
                     }
 
-        do_block: kDO_BLOCK
+        do_block: kDO_BLOCK do_body kEND
                     {
-                      @static_env.extend_dynamic
-                    }
-                    opt_block_param compstmt kEND
-                    {
-                      result = [ val[0], val[2], val[3], val[4] ]
-
-                      @static_env.unextend
+                      result = [ val[0], *val[1], val[2] ]
                     }
 
       block_call: command do_block
@@ -1590,23 +1575,31 @@ opt_block_args_tail:
                       result = @builder.index(val[0], val[1], val[2], val[3])
                     }
 
-     brace_block: tLCURLY
+     brace_block: tLCURLY brace_body tRCURLY
                     {
+                      result = [ val[0], *val[1], val[2] ]
+                    }
+                | kDO do_body kEND
+                    {
+                      result = [ val[0], *val[1], val[2] ]
+                    }
+
+      brace_body:   {
                       @static_env.extend_dynamic
                     }
-                    opt_block_param compstmt tRCURLY
+                    opt_block_param compstmt
                     {
-                      result = [ val[0], val[2], val[3], val[4] ]
+                      result = [ val[1], val[2] ]
 
                       @static_env.unextend
                     }
-                | kDO
-                    {
+
+         do_body:   {
                       @static_env.extend_dynamic
                     }
-                 opt_block_param compstmt kEND
+                    opt_block_param compstmt
                     {
-                      result = [ val[0], val[2], val[3], val[4] ]
+                      result = [ val[1], val[2] ]
 
                       @static_env.unextend
                     }