ruby_parser 3.14.2 → 3.15.0

data/lib/ruby_lexer.rb

@@ -25,12 +25,6 @@ class RubyLexer
 
   HAS_ENC = "".respond_to? :encoding
 
-  IDENT_CHAR = if HAS_ENC then
-                 /[\w\u0080-\u{10ffff}]/u
-               else
-                 /[\w\x80-\xFF]/n
-               end
-
   TOKENS = {
     "!"   => :tBANG,
     "!="  => :tNEQ,
@@ -162,7 +156,7 @@ class RubyLexer
     indent         = func =~ STR_FUNC_INDENT ? "[ \t]*" : nil
     expand         = func =~ STR_FUNC_EXPAND
     eol            = last_line && last_line.end_with?("\r\n") ? "\r\n" : "\n"
-    eos_re         = /#{indent}#{Regexp.escape eos}(#{eol}|\z)/
+    eos_re         = /#{indent}#{Regexp.escape eos}(\r*\n|\z)/
     err_msg        = "can't match #{eos_re.inspect} anywhere in "
 
     rb_compile_error err_msg if end_of_stream?
@@ -177,10 +171,15 @@ class RubyLexer
 
     if expand then
       case
-      when scan(/#[$@]/) then
-        ss.pos -= 1 # FIX omg stupid
+      when scan(/#(?=\$(-.|[a-zA-Z_0-9~\*\$\?!@\/\\;,\.=:<>\"\&\`\'+]))/) then
+        # TODO: !ISASCII
+        # ?! see parser_peek_variable_name
+        return :tSTRING_DVAR, matched
+      when scan(/#(?=\@\@?[a-zA-Z_])/) then
+        # TODO: !ISASCII
         return :tSTRING_DVAR, matched
       when scan(/#[{]/) then
+        self.command_start = true
         return :tSTRING_DBEG, matched
       when scan(/#/) then
         string_buffer << "#"
@@ -320,6 +319,11 @@ class RubyLexer
     lpar_beg && lpar_beg == paren_nest
   end
 
+  def is_local_id id
+    # maybe just make this false for now
+    self.parser.env[id.to_sym] == :lvar # HACK: this isn't remotely right
+  end
+
   def lvar_defined? id
     # TODO: (dyna_in_block? && dvar_defined?(id)) || local_id?(id)
     self.parser.env[id.to_sym] == :lvar
@@ -338,9 +342,9 @@ class RubyLexer
 
     if scan(/[a-z0-9]{1,2}/i) then # Long-hand (e.g. %Q{}).
       rb_compile_error "unknown type of %string" if ss.matched_size == 2
-      c, beg, short_hand = matched, ss.getch, false
+      c, beg, short_hand = matched, getch, false
     else                               # Short-hand (e.g. %{, %., %!, etc)
-      c, beg, short_hand = "Q", ss.getch, true
+      c, beg, short_hand = "Q", getch, true
     end
 
     if end_of_stream? or c == RubyLexer::EOF or beg == RubyLexer::EOF then
@@ -457,7 +461,7 @@ class RubyLexer
     if text =~ check then
       content.gsub(ESC) { unescape $1 }
     else
-      content.gsub(/\\\\/, "\\").gsub(/\\'/, "'")
+      content.gsub(/\\\\/, "\\").gsub(/\\\'/, "'")
     end
   end
 
@@ -495,16 +499,19 @@ class RubyLexer
   end
 
   def process_brace_close text
-    # matching compare/parse23.y:8561
-    cond.lexpop
-    cmdarg.lexpop
-
     case matched
     when "}" then
       self.brace_nest -= 1
-      self.lex_state   = ruby24minus? ? EXPR_ENDARG : EXPR_END
-
       return :tSTRING_DEND, matched if brace_nest < 0
+    end
+
+    # matching compare/parse26.y:8099
+    cond.pop
+    cmdarg.pop
+
+    case matched
+    when "}" then
+      self.lex_state   = ruby24minus? ? EXPR_ENDARG : EXPR_END
       return :tRCURLY, matched
     when "]" then
       self.paren_nest -= 1
@@ -605,7 +612,7 @@ class RubyLexer
   end
 
   def process_label text
-    symbol = possibly_escape_string text, /^"/
+    symbol = possibly_escape_string text, /^\"/
 
     result EXPR_LAB, :tLABEL, [symbol, self.lineno]
   end
@@ -619,7 +626,7 @@ class RubyLexer
       text = text[0..-2]
     end
 
-    result EXPR_END, :tSTRING, text[1..-2].gsub(/\\\\/, "\\").gsub(/\\'/, "'")
+    result EXPR_END, :tSTRING, text[1..-2].gsub(/\\\\/, "\\").gsub(/\\\'/, "\'")
   end
 
   def process_lchevron text
@@ -791,12 +798,22 @@ class RubyLexer
     c = if scan(/\\/) then
           self.read_escape
         else
-          ss.getch
+          getch
         end
 
     result EXPR_END, :tSTRING, c
   end
 
+  def process_simple_string text
+    replacement = text[1..-2].gsub(ESC) {
+      unescape($1).b.force_encoding Encoding::UTF_8
+    }
+
+    replacement = replacement.b unless replacement.valid_encoding?
+
+    result EXPR_END, :tSTRING, replacement
+  end
+
   def process_slash text
     if is_beg? then
       string STR_REGEXP
@@ -870,16 +887,16 @@ class RubyLexer
 
     if [:tSTRING_END, :tREGEXP_END, :tLABEL_END].include? token_type then
       self.lex_strterm = nil
-      self.lex_state   = (token_type == :tLABEL_END) ? EXPR_PAR : EXPR_END|EXPR_ENDARG
+      self.lex_state   = (token_type == :tLABEL_END) ? EXPR_PAR : EXPR_LIT
     end
 
     return token
   end
 
   def process_symbol text
-    symbol = possibly_escape_string text, /^:"/
+    symbol = possibly_escape_string text, /^:\"/ # stupid emacs
 
-    result EXPR_END|EXPR_ENDARG, :tSYMBOL, symbol
+    result EXPR_LIT, :tSYMBOL, symbol
   end
 
   def process_token text
@@ -928,6 +945,8 @@ class RubyLexer
               EXPR_END
             end
 
+    tok_id = :tIDENTIFIER if tok_id == :tCONSTANT && is_local_id(token)
+
     if last_state !~ EXPR_DOT|EXPR_FNAME and
         (tok_id == :tIDENTIFIER) and # not EXPR_FNAME, not attrasgn
         lvar_defined?(token) then
@@ -951,18 +970,16 @@ class RubyLexer
     self.command_start = true if lex_state =~ EXPR_BEG
 
     case
-    when keyword.id0 == :kDO then
+    when keyword.id0 == :kDO then # parse26.y line 7591
       case
       when lambda_beginning? then
         self.lpar_beg = nil # lambda_beginning? == FALSE in the body of "-> do ... end"
-        self.paren_nest -= 1
+        self.paren_nest -= 1 # TODO: question this?
         result lex_state, :kDO_LAMBDA, value
       when cond.is_in_state then
         result lex_state, :kDO_COND, value
       when cmdarg.is_in_state && state != EXPR_CMDARG then
         result lex_state, :kDO_BLOCK, value
-      when state =~ EXPR_BEG|EXPR_ENDARG then
-        result lex_state, :kDO_BLOCK, value
       else
         result lex_state, :kDO, value
       end
@@ -979,9 +996,9 @@ class RubyLexer
     ss.unscan # put back "_"
 
     if beginning_of_line? && scan(/\__END__(\r?\n|\Z)/) then
-      return [RubyLexer::EOF, RubyLexer::EOF]
-    elsif scan(/\_\w*/) then
-      return process_token matched
+      [RubyLexer::EOF, RubyLexer::EOF]
+    elsif scan(/#{IDENT_CHAR}+/) then
+      process_token matched
     end
   end
 
@@ -1018,7 +1035,7 @@ class RubyLexer
     when scan(/x([0-9a-fA-F]{1,2})/) then # hex constant
       # TODO: force encode everything to UTF-8?
       ss[1].to_i(16).chr.force_encoding Encoding::UTF_8
-    when check(/M-\\[\\MCc]/) then
+    when check(/M-\\./) then
       scan(/M-\\/) # eat it
       c = self.read_escape
       c[0] = (c[0].ord | 0x80).chr
@@ -1032,6 +1049,11 @@ class RubyLexer
       c = self.read_escape
       c[0] = (c[0].ord & 0x9f).chr
       c
+    when check(/(C-|c)\\(?!u|\\)/) then
+      scan(/(C-|c)\\/) # eat it
+      c = read_escape
+      c[0] = (c[0].ord & 0x9f).chr
+      c
     when scan(/C-\?|c\?/) then
       127.chr
     when scan(/(C-|c)(.)/) then
@@ -1040,17 +1062,25 @@ class RubyLexer
       c
     when scan(/^[89]/i) then # bad octal or hex... MRI ignores them :(
       matched
-    when scan(/u([0-9a-fA-F]{4}|\{[0-9a-fA-F]{2,6}\})/) then
-      [ss[1].delete("{}").to_i(16)].pack("U")
-    when scan(/u([0-9a-fA-F]{1,3})/) then
+    when scan(/u(\h{4})/) then
+      [ss[1].to_i(16)].pack("U")
+    when scan(/u(\h{1,3})/) then
       rb_compile_error "Invalid escape character syntax"
+    when scan(/u\{(\h+(?:\s+\h+)*)\}/) then
+      ss[1].split.map { |s| s.to_i(16) }.pack("U*")
     when scan(/[McCx0-9]/) || end_of_stream? then
       rb_compile_error("Invalid escape character syntax")
     else
-      ss.getch
+      getch
     end.dup
   end
 
+  def getch
+    c = ss.getch
+    c = ss.getch if c == "\r" && ss.peek(1) == "\n"
+    c
+  end
+
   def regx_options # TODO: rewrite / remove
     good, bad = [], []
 
@@ -1274,10 +1304,12 @@ class RubyLexer
           s
         when /^[McCx0-9]/ then
           rb_compile_error("Invalid escape character syntax")
-        when /u([0-9a-fA-F]{4}|\{[0-9a-fA-F]{2,6}\})/ then
+        when /u(\h{4})/ then
           [$1.delete("{}").to_i(16)].pack("U")
-        when /u([0-9a-fA-F]{1,3})/ then
+        when /u(\h{1,3})/ then
           rb_compile_error("Invalid escape character syntax")
+        when /u\{(\h+(?:\s+\h+)*)\}/ then
+          $1.split.map { |s| s.to_i(16) }.pack("U*")
         else
           s
         end
@@ -1355,11 +1387,11 @@ class RubyLexer
       # extra fake lex_state names to make things a bit cleaner
 
       EXPR_LAB = EXPR_ARG|EXPR_LABELED
-      EXPR_NUM = EXPR_END|EXPR_ENDARG
+      EXPR_LIT = EXPR_END|EXPR_ENDARG
       EXPR_PAR = EXPR_BEG|EXPR_LABEL
       EXPR_PAD = EXPR_BEG|EXPR_LABELED
 
-      EXPR_LIT = EXPR_NUM # TODO: migrate to EXPR_LIT
+      EXPR_NUM = EXPR_LIT
 
       expr_names.merge!(EXPR_NONE    => "EXPR_NONE",
                         EXPR_BEG     => "EXPR_BEG",

data/lib/ruby_lexer.rex

@@ -6,9 +6,9 @@ class RubyLexer
 
 macro
 
-  IDENT         /^#{IDENT_CHAR}+/o
+  IDENT_CHAR    /[a-zA-Z0-9_[:^ascii:]]/
 
-  ESC           /\\((?>[0-7]{1,3}|x[0-9a-fA-F]{1,2}|M-[^\\]|(C-|c)[^\\]|u[0-9a-fA-F]{1,4}|u\{[0-9a-fA-F]+\}|[^0-7xMCc]))/
+  ESC           /\\((?>[0-7]{1,3}|x\h{1,2}|M-[^\\]|(C-|c)[^\\]|u\h{1,4}|u\{\h+(?:\s+\h+)*\}|[^0-7xMCc]))/
   SIMPLE_STRING /((#{ESC}|\#(#{ESC}|[^\{\#\@\$\"\\])|[^\"\\\#])*)/o
   SSTRING       /((\\.|[^\'])*)/
 
@@ -62,7 +62,7 @@ rule
 |               /\=(?=begin\b)/         { result arg_state, TOKENS[text], text }
 
 ruby22_label?   /\"#{SIMPLE_STRING}\":/o process_label
-                /\"(#{SIMPLE_STRING})\"/o { result EXPR_END, :tSTRING, text[1..-2].gsub(ESC) { unescape $1 } }
+                /\"(#{SIMPLE_STRING})\"/o process_simple_string
                 /\"/                    { string STR_DQUOTE; result nil, :tSTRING_BEG, text }
 
                 /\@\@?\d/               { rb_compile_error "`#{text}` is not allowed as a variable name" }
@@ -164,13 +164,12 @@ was_label?        /\'#{SSTRING}\':?/o   process_label_or_string
 | in_fname?     /\$([1-9]\d*)/                   process_gvar
 |               /\$([1-9]\d*)/                   process_nthref
 |               /\$0/                            process_gvar
-|               /\$[^[:ascii:]]+/                process_gvar
+|               /\$#{IDENT_CHAR}+/               process_gvar
 |               /\$\W|\$\z/                      process_gvar_oddity
-|               /\$\w+/                          process_gvar
 
                 /\_/                    process_underscore
 
-                /#{IDENT}/o             process_token
+                /#{IDENT_CHAR}+/o       process_token
 
                 /\004|\032|\000|\Z/     { [RubyLexer::EOF, RubyLexer::EOF] }
 

data/lib/ruby_lexer.rex.rb

@@ -1,7 +1,7 @@
 # encoding: UTF-8
 #--
 # This file is automatically generated. Do not modify it.
-# Generated by: oedipus_lex version 2.5.1.
+# Generated by: oedipus_lex version 2.5.2.
 # Source: lib/ruby_lexer.rex
 #++
 
@@ -16,8 +16,8 @@ class RubyLexer
   require 'strscan'
 
   # :stopdoc:
-  IDENT         = /^#{IDENT_CHAR}+/o
-  ESC           = /\\((?>[0-7]{1,3}|x[0-9a-fA-F]{1,2}|M-[^\\]|(C-|c)[^\\]|u[0-9a-fA-F]{1,4}|u\{[0-9a-fA-F]+\}|[^0-7xMCc]))/
+  IDENT_CHAR    = /[a-zA-Z0-9_[:^ascii:]]/
+  ESC           = /\\((?>[0-7]{1,3}|x\h{1,2}|M-[^\\]|(C-|c)[^\\]|u\h{1,4}|u\{\h+(?:\s+\h+)*\}|[^0-7xMCc]))/
   SIMPLE_STRING = /((#{ESC}|\#(#{ESC}|[^\{\#\@\$\"\\])|[^\"\\\#])*)/o
   SSTRING       = /((\\.|[^\'])*)/
   INT_DEC       = /[+]?(?:(?:[1-9][\d_]*|0)(?!\.\d)(ri|r|i)?\b|0d[0-9_]+)(ri|r|i)?/i
@@ -160,7 +160,7 @@ class RubyLexer
           when ruby22_label? && (text = ss.scan(/\"#{SIMPLE_STRING}\":/o)) then
             process_label text
           when text = ss.scan(/\"(#{SIMPLE_STRING})\"/o) then
-            action { result EXPR_END, :tSTRING, text[1..-2].gsub(ESC) { unescape $1 } }
+            process_simple_string text
           when text = ss.scan(/\"/) then
             action { string STR_DQUOTE; result nil, :tSTRING_BEG, text }
           when text = ss.scan(/\@\@?\d/) then
@@ -328,16 +328,14 @@ class RubyLexer
               process_nthref text
             when text = ss.scan(/\$0/) then
               process_gvar text
-            when text = ss.scan(/\$[^[:ascii:]]+/) then
+            when text = ss.scan(/\$#{IDENT_CHAR}+/) then
               process_gvar text
             when text = ss.scan(/\$\W|\$\z/) then
               process_gvar_oddity text
-            when text = ss.scan(/\$\w+/) then
-              process_gvar text
             end # group /\$/
           when text = ss.scan(/\_/) then
             process_underscore text
-          when text = ss.scan(/#{IDENT}/o) then
+          when text = ss.scan(/#{IDENT_CHAR}+/o) then
             process_token text
           when ss.skip(/\004|\032|\000|\Z/) then
             action { [RubyLexer::EOF, RubyLexer::EOF] }

data/lib/ruby_parser.rb

@@ -78,10 +78,12 @@ require "ruby23_parser"
 require "ruby24_parser"
 require "ruby25_parser"
 require "ruby26_parser"
+require "ruby27_parser"
 
 class RubyParser # HACK
   VERSIONS.clear # also a HACK caused by racc namespace issues
 
+  class V27 < ::Ruby27Parser; end
   class V26 < ::Ruby26Parser; end
   class V25 < ::Ruby25Parser; end
   class V24 < ::Ruby24Parser; end

data/lib/ruby_parser.yy

@@ -14,6 +14,8 @@ class Ruby24Parser
 class Ruby25Parser
 #elif V == 26
 class Ruby26Parser
+#elif V == 27
+class Ruby27Parser
 #else
 fail "version not specified or supported on code generation"
 #endif
@@ -286,13 +288,15 @@ rule
                     }
                 | primary_value tCOLON2 tCONSTANT tOP_ASGN command_rhs
                     {
-                      result = s(:op_asgn, val[0], val[4], val[2], val[3])
-                      debug20 4, val, result
+                      lhs1, _, lhs2, op, rhs = val
+
+                      result = s(:op_asgn, lhs1, rhs, lhs2.to_sym, op.to_sym)
                     }
                 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_rhs
                     {
-                      result = s(:op_asgn, val[0], val[4], val[2], val[3])
-                      debug20 5, val, result
+                      lhs1, _, lhs2, op, rhs = val
+
+                      result = s(:op_asgn, lhs1, rhs, lhs2.to_sym, op.to_sym)
                     }
                 | backref tOP_ASGN command_rhs
                     {
@@ -1078,12 +1082,39 @@ rule
                     }
 
     command_args:   {
-                      result = lexer.cmdarg.store true
+                      # parse26.y line 2200
+
+                      # If call_args starts with a open paren '(' or
+                      # '[', look-ahead reading of the letters calls
+                      # CMDARG_PUSH(0), but the push must be done
+                      # after CMDARG_PUSH(1). So this code makes them
+                      # consistent by first cancelling the premature
+                      # CMDARG_PUSH(0), doing CMDARG_PUSH(1), and
+                      # finally redoing CMDARG_PUSH(0).
+
+                      result = yychar = self.last_token_type.first
+                      lookahead = [:tLPAREN, :tLPAREN_ARG, :tLPAREN2, :tLBRACK, :tLBRACK2].include?(yychar)
+                      lexer.cmdarg.pop if lookahead
+                      lexer.cmdarg.push true
+                      lexer.cmdarg.push false if lookahead
                     }
                       call_args
                     {
-                      lexer.cmdarg.restore val[0]
-                      result = val[1]
+                      yychar, args = val
+
+                      # call_args can be followed by tLBRACE_ARG (that
+                      # does CMDARG_PUSH(0) in the lexer) but the push
+                      # must be done after CMDARG_POP() in the parser.
+                      # So this code does CMDARG_POP() to pop 0 pushed
+                      # by tLBRACE_ARG, CMDARG_POP() to pop 1 pushed
+                      # by command_args, and CMDARG_PUSH(0) to restore
+                      # back the flag set by tLBRACE_ARG.
+
+                      lookahead = [:tLBRACE_ARG].include?(yychar)
+                      lexer.cmdarg.pop if lookahead
+                      lexer.cmdarg.pop
+                      lexer.cmdarg.push false if lookahead
+                      result = args
                     }
 
        block_arg: tAMPER arg_value
@@ -1101,8 +1132,9 @@ rule
             args: arg_value
                     {
                       arg, = val
+                      lineno = arg.line || lexer.lineno # HACK
 
-                      result = s(:array, arg).line arg.line
+                      result = s(:array, arg).line lineno
                     }
                 | tSTAR arg_value
                     {
@@ -1114,9 +1146,11 @@ rule
                       args, _, id = val
                       result = self.list_append args, id
                     }
-                | args tCOMMA tSTAR { result = lexer.lineno } arg_value
+                | args tCOMMA tSTAR arg_value
                     {
-                      args, _, _, line, id = val
+                      # TODO: the line number from tSTAR has been dropped
+                      args, _, _, id = val
+                      line = lexer.lineno
                       result = self.list_append args, s(:splat, id).line(line)
                     }
 
@@ -1137,7 +1171,6 @@ rule
                     }
                 | args tCOMMA tSTAR arg_value
                     {
-                      # FIX: bad shift/reduce conflict with rhs' comma star prod
                       # TODO: make all tXXXX terminals include lexer.lineno
                       arg, _, _, splat = val
                       result = self.arg_concat arg, splat
@@ -1165,21 +1198,13 @@ rule
                     }
                 | k_begin
                     {
+                      lexer.cmdarg.push false
                       result = self.lexer.lineno
-                      # TODO:
-                      # $<val>1 = cmdarg_stack;
-                      # CMDARG_SET(0);
                     }
                     bodystmt k_end
                     {
-                      # TODO: CMDARG_SET($<val>1);
-                      unless val[2] then
-                        result = s(:nil)
-                      else
-                        result = s(:begin, val[2])
-                      end
-
-                      result.line = val[1]
+                      lexer.cmdarg.pop
+                      result = new_begin val
                     }
                 | tLPAREN_ARG
                     {
@@ -1192,18 +1217,14 @@ rule
                       result = s(:begin).line line
                     }
                 | tLPAREN_ARG
-                    {
-                      result = lexer.cmdarg.store false
-                    }
                     stmt
                     {
                       lexer.lex_state = EXPR_ENDARG
                     }
                     rparen
                     {
-                      _, cmdarg, stmt, _, _, = val
-                      warning "(...) interpreted as grouped expression"
-                      lexer.cmdarg.restore cmdarg
+                      _, stmt, _, _, = val
+                      # warning "(...) interpreted as grouped expression"
                       result = stmt
                     }
                 | tLPAREN compstmt tRPAREN
@@ -1386,48 +1407,61 @@ rule
                     }
                 | k_def fname
                     {
-                      result = [self.in_def, self.lexer.cmdarg.stack.dup]
+                      result = self.in_def
 
-                      self.comments.push self.lexer.comments
-                      self.in_def = true
+                      self.in_def = true # group = local_push
                       self.env.extend
-                      # TODO: local->cmdargs = cmdarg_stack;
-                      # TODO: port local_push_gen and local_pop_gen
-                      lexer.cmdarg.stack.replace [false]
+                      lexer.cmdarg.push false
+                      lexer.cond.push false
+
+                      self.comments.push self.lexer.comments
                     }
                     f_arglist bodystmt { result = lexer.lineno } k_end
                     {
-                      in_def, cmdarg = val[2]
+                      in_def = val[2]
 
                       result = new_defn val
 
-                      lexer.cmdarg.stack.replace cmdarg
+                      lexer.cond.pop # group = local_pop
+                      lexer.cmdarg.pop
                       self.env.unextend
                       self.in_def = in_def
+
                       self.lexer.comments # we don't care about comments in the body
                     }
                 | k_def singleton dot_or_colon
                     {
-                      self.comments.push self.lexer.comments
                       lexer.lex_state = EXPR_FNAME
                     }
                     fname
                     {
-                      self.in_single += 1
+                      result = [self.in_def, lexer.lineno]
+
+                      self.in_single += 1 # TODO: remove?
+
+                      self.in_def = true # local_push
                       self.env.extend
-                      lexer.lex_state = EXPR_ENDFN # force for args
-                      result = [lexer.lineno, self.lexer.cmdarg.stack.dup]
-                      lexer.cmdarg.stack.replace [false]
+                      lexer.cmdarg.push false
+                      lexer.cond.push false
+
+                      lexer.lex_state = EXPR_ENDFN|EXPR_LABEL
+                      self.comments.push self.lexer.comments
                     }
                     f_arglist bodystmt k_end
                     {
-                      _, cmdarg = val[5]
-                      result = new_defs val
+                      _, _recv, _, _, _name, (in_def, _lineno), _args, _body, _ = val
 
-                      lexer.cmdarg.stack.replace cmdarg
+                      result = new_defs val
 
+                      lexer.cond.pop # group = local_pop
+                      lexer.cmdarg.pop
                       self.env.unextend
+                      self.in_def = in_def
+
                       self.in_single -= 1
+
+                      # TODO: restore cur_arg ? what's cur_arg?
+
                       self.lexer.comments # we don't care about comments in the body
                     }
                 | kBREAK
@@ -1712,20 +1746,19 @@ opt_block_args_tail: tCOMMA block_args_tail
                     }
                     f_larglist
                     {
-                      result = lexer.cmdarg.store(false)
+                      lexer.cmdarg.push false
                     }
                     lambda_body
                     {
-                      (line, lpar), args, cmdarg, body = val
+                      (line, lpar), args, _cmdarg, body = val
                       lexer.lpar_beg = lpar
 
-                      lexer.cmdarg.restore cmdarg
-                      lexer.cmdarg.lexpop
+                      lexer.cmdarg.pop
 
                       call = s(:lambda).line line
                       result = new_iter call, args, body
                       result.line = line
-                      self.env.unextend
+                      self.env.unextend # TODO: dynapush & dynapop
                     }
 
      f_larglist: tLPAREN2 f_args opt_bv_decl rparen
@@ -1878,7 +1911,7 @@ opt_block_args_tail: tCOMMA block_args_tail
                     }
 
          do_body:   { self.env.extend :dynamic; result = self.lexer.lineno }
-                    { result = lexer.cmdarg.store(false) }
+                    { lexer.cmdarg.push false }
                     opt_block_param
 #if V >= 25
                     bodystmt
@@ -1886,11 +1919,11 @@ opt_block_args_tail: tCOMMA block_args_tail
                     compstmt
 #endif
                     {
-                      line, cmdarg, param, cmpstmt = val
+                      line, _cmdarg, param, cmpstmt = val
 
                       result = new_do_body param, cmpstmt, line
+                      lexer.cmdarg.pop
                       self.env.unextend
-                      lexer.cmdarg.restore cmdarg
                     }
 
        case_body: k_when
@@ -1990,7 +2023,7 @@ opt_block_args_tail: tCOMMA block_args_tail
 
          xstring: tXSTRING_BEG xstring_contents tSTRING_END
                     {
-                      result = new_xstring val[1]
+                      result = new_xstring val
                       # TODO: dedent?!?! SERIOUSLY?!?
                     }
 
@@ -2132,12 +2165,13 @@ regexp_contents: none
                       result = [lexer.lex_strterm,
                                 lexer.brace_nest,
                                 lexer.string_nest, # TODO: remove
-                                lexer.cond.store,
-                                lexer.cmdarg.store,
                                 lexer.lex_state,
                                 lexer.lineno,
                                ]
 
+                      lexer.cmdarg.push false
+                      lexer.cond.push false
+
                       lexer.lex_strterm = nil
                       lexer.brace_nest  = 0
                       lexer.string_nest = 0
@@ -2149,14 +2183,15 @@ regexp_contents: none
                     {
                       _, memo, stmt, _ = val
 
-                      lex_strterm, brace_nest, string_nest, oldcond, oldcmdarg, oldlex_state, line = memo
+                      lex_strterm, brace_nest, string_nest, oldlex_state, line = memo
+                      # TODO: heredoc_indent
 
                       lexer.lex_strterm = lex_strterm
                       lexer.brace_nest  = brace_nest
                       lexer.string_nest = string_nest
 
-                      lexer.cond.restore oldcond
-                      lexer.cmdarg.restore oldcmdarg
+                      lexer.cmdarg.pop
+                      lexer.cond.pop
 
                       lexer.lex_state = oldlex_state