brakeman 4.5.0 → 4.5.1

data/bundle/ruby/2.5.0/gems/{ruby_parser-3.13.0 → ruby_parser-3.13.1}/lib/ruby_lexer.rex

@@ -8,7 +8,7 @@ macro
 
   IDENT         /^#{IDENT_CHAR}+/o
 
-  ESC           /\\((?>[0-7]{1,3}|x[0-9a-fA-F]{1,2}|M-[^\\]|(C-|c)[^\\]|u[0-9a-fA-F]+|u\{[0-9a-fA-F]+\}|[^0-7xMCc]))/
+  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]))/
   SIMPLE_STRING /((#{ESC}|\#(#{ESC}|[^\{\#\@\$\"\\])|[^\"\\\#])*)/o
   SSTRING       /((\\.|[^\'])*)/
 
@@ -44,18 +44,17 @@ rule
                 /[\]\)\}]/              process_brace_close
 
 : /\!/
-| in_arg_state? /\!\@/                  { result :expr_arg, :tUBANG, "!@" }
+| is_after_operator? /\!\@/             { result EXPR_ARG, :tUBANG, "!@" }
 |               /\![=~]?/               { result :arg_state, TOKENS[text], text }
 
 : /\./
-|               /\.\.\.?/               { result :expr_beg, TOKENS[text], text }
+|               /\.\.\.?/               { result EXPR_BEG, TOKENS[text], text }
 |               /\.\d/                  { rb_compile_error "no .<digit> floating literal anymore put 0 before dot" }
-|               /\./                    { self.lex_state = :expr_beg; result :expr_dot, :tDOT, "." }
+|               /\./                    { self.lex_state = EXPR_BEG; result EXPR_DOT, :tDOT, "." }
 
                 /\(/                    process_paren
 
-# TODO: :expr_beg|:expr_label
-                /\,/                    { result :expr_beg, TOKENS[text], text }
+                /\,/                    { result EXPR_PAR, TOKENS[text], text }
 
 : /=/
 |               /\=\=\=|\=\=|\=~|\=>|\=(?!begin\b)/ { result arg_state, TOKENS[text], text }
@@ -63,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 { result EXPR_END, :tSTRING, text[1..-2].gsub(ESC) { unescape $1 } }
                 /\"/                    { string STR_DQUOTE; result nil, :tSTRING_BEG, text }
 
                 /\@\@?\d/               { rb_compile_error "`#{text}` is not allowed as a variable name" }
@@ -76,7 +75,7 @@ ruby22_label?   /\"#{SIMPLE_STRING}\":/o process_label
 |               /\:\:/                      process_colon2
 |               /\:/                        process_colon1
 
-                /->/                    { result :expr_endfn, :tLAMBDA, nil }
+                /->/                    { result EXPR_ENDFN, :tLAMBDA, nil }
 
                 /[+-]/                  process_plus_minus
 
@@ -97,57 +96,57 @@ ruby22_label?   /\"#{SIMPLE_STRING}\":/o process_label
 was_label?        /\'#{SSTRING}\':?/o   process_label_or_string
 
 : /\|/
-|               /\|\|\=/                { result :expr_beg, :tOP_ASGN, "||" }
-|               /\|\|/                  { result :expr_beg, :tOROP,    "||" }
-|               /\|\=/                  { result :expr_beg, :tOP_ASGN, "|" }
-|               /\|/                    { result :arg_state, :tPIPE,    "|" }
+|               /\|\|\=/                { result EXPR_BEG, :tOP_ASGN, "||" }
+|               /\|\|/                  { result EXPR_BEG, :tOROP,    "||" }
+|               /\|\=/                  { result EXPR_BEG, :tOP_ASGN, "|" }
+|               /\|/                    { state = is_after_operator? ? EXPR_ARG : EXPR_PAR; result state, :tPIPE, "|" }
 
                 /\{/                    process_brace_open
 
 : /\*/
-|               /\*\*=/                 { result :expr_beg, :tOP_ASGN, "**" }
+|               /\*\*=/                 { result EXPR_BEG, :tOP_ASGN, "**" }
 |               /\*\*/                  { result(:arg_state, space_vs_beginning(:tDSTAR, :tDSTAR, :tPOW), "**") }
-|               /\*\=/                  { result(:expr_beg, :tOP_ASGN, "*") }
+|               /\*\=/                  { result(EXPR_BEG, :tOP_ASGN, "*") }
 |               /\*/                    { result(:arg_state, space_vs_beginning(:tSTAR, :tSTAR, :tSTAR2), "*") }
 
 # TODO: fix result+process_lchevron to set command_start = true
 : /</
 |               /\<\=\>/                { result :arg_state, :tCMP, "<=>"    }
 |               /\<\=/                  { result :arg_state, :tLEQ, "<="     }
-|               /\<\<\=/                { result :expr_beg,  :tOP_ASGN, "<<" }
+|               /\<\<\=/                { result EXPR_BEG,  :tOP_ASGN, "<<" }
 |               /\<\</                  process_lchevron
 |               /\</                    { result :arg_state, :tLT, "<"       }
 
 : />/
 |               /\>\=/                  { result :arg_state, :tGEQ, ">="     }
-|               /\>\>=/                 { result :expr_beg,  :tOP_ASGN, ">>" }
+|               /\>\>=/                 { result EXPR_BEG,  :tOP_ASGN, ">>" }
 |               /\>\>/                  { result :arg_state, :tRSHFT, ">>"   }
 |               /\>/                    { result :arg_state, :tGT, ">"       }
 
 : /\`/
-| expr_fname?   /\`/                   { result(:expr_end, :tBACK_REF2, "`") }
-| expr_dot?     /\`/                   { result((cmd_state ? :expr_cmdarg : :expr_arg), :tBACK_REF2, "`") }
+| expr_fname?   /\`/                   { result(EXPR_END, :tBACK_REF2, "`") }
+| expr_dot?     /\`/                   { result((cmd_state ? EXPR_CMDARG : EXPR_ARG), :tBACK_REF2, "`") }
 |               /\`/                   { string STR_XQUOTE, '`'; result(nil, :tXSTRING_BEG, "`") }
 
                 /\?/                    process_questionmark
 
 : /&/
-|               /\&\&\=/                { result(:expr_beg, :tOP_ASGN, "&&") }
-|               /\&\&/                  { result(:expr_beg, :tANDOP,   "&&") }
-|               /\&\=/                  { result(:expr_beg, :tOP_ASGN, "&" ) }
-|               /\&\./                  { result(:expr_dot, :tLONELY,  "&.") }
+|               /\&\&\=/                { result(EXPR_BEG, :tOP_ASGN, "&&") }
+|               /\&\&/                  { result(EXPR_BEG, :tANDOP,   "&&") }
+|               /\&\=/                  { result(EXPR_BEG, :tOP_ASGN, "&" ) }
+|               /\&\./                  { result(EXPR_DOT, :tLONELY,  "&.") }
 |               /\&/                    process_amper
 
                 /\//                    process_slash
 
 : /\^/
-|               /\^=/                   { result(:expr_beg, :tOP_ASGN, "^") }
+|               /\^=/                   { result(EXPR_BEG, :tOP_ASGN, "^") }
 |               /\^/                    { result(:arg_state, :tCARET, "^") }
 
-                /\;/                    { self.command_start = true; result(:expr_beg, :tSEMI, ";") }
+                /\;/                    { self.command_start = true; result(EXPR_BEG, :tSEMI, ";") }
 
 : /~/
-| in_arg_state? /\~@/                   { result(:arg_state, :tTILDE, "~") }
+| is_after_operator? /\~@/              { result(:arg_state, :tTILDE, "~") }
 |               /\~/                    { result(:arg_state, :tTILDE, "~") }
 
 : /\\/
@@ -165,6 +164,7 @@ 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
 |               /\$\W|\$\z/                      process_gvar_oddity
 |               /\$\w+/                          process_gvar
 

data/bundle/ruby/2.5.0/gems/{ruby_parser-3.13.0 → ruby_parser-3.13.1}/lib/ruby_lexer.rex.rb

@@ -8,11 +8,16 @@
 #
 # lexical scanner definition for ruby
 
+
+##
+# The generated lexer RubyLexer
+
 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]+|u\{[0-9a-fA-F]+\}|[^0-7xMCc]))/
+  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]))/
   SIMPLE_STRING = /((#{ESC}|\#(#{ESC}|[^\{\#\@\$\"\\])|[^\"\\\#])*)/o
   SSTRING       = /((\\.|[^\'])*)/
   INT_DEC       = /[+]?(?:(?:[1-9][\d_]*|0)(?!\.\d)(ri|r|i)?\b|0d[0-9_]+)(ri|r|i)?/i
@@ -24,30 +29,56 @@ class RubyLexer
   NUM_BAD       = /[+]?0[xbd]\b/i
   INT_OCT_BAD   = /[+]?0o?[0-7_]*[89]/i
   FLOAT_BAD     = /[+]?\d[\d_]*_(e|\.)/i
-
+  # :startdoc:
+  # :stopdoc:
   class LexerError < StandardError ; end
   class ScanError < LexerError ; end
+  # :startdoc:
+
+  ##
+  # The file name / path
 
   attr_accessor :filename
+
+  ##
+  # The StringScanner for this lexer.
+
   attr_accessor :ss
+
+  ##
+  # The current lexical state.
+
   attr_accessor :state
 
   alias :match :ss
 
+  ##
+  # The match groups for the current scan.
+
   def matches
     m = (1..9).map { |i| ss[i] }
     m.pop until m[-1] or m.empty?
     m
   end
 
+  ##
+  # Yields on the current action.
+
   def action
     yield
   end
 
+
+  ##
+  # The current scanner class. Must be overridden in subclasses.
+
   def scanner_class
     StringScanner
   end unless instance_methods(false).map(&:to_s).include?("scanner_class")
 
+  ##
+  # Parse the given string.
+
   def parse str
     self.ss     = scanner_class.new str
     self.state  ||= nil
@@ -55,6 +86,9 @@ class RubyLexer
     do_parse
   end
 
+  ##
+  # Read in and parse the file at +path+.
+
   def parse_file path
     self.filename = path
     open path do |f|
@@ -62,12 +96,18 @@ class RubyLexer
     end
   end
 
+  ##
+  # The current location in the parse.
+
   def location
     [
       (filename || "<input>"),
     ].compact.join(":")
   end
 
+  ##
+  # Lex the next token.
+
   def next_token
     return process_string if lex_strterm
     self.cmd_state = self.command_start
@@ -90,24 +130,24 @@ class RubyLexer
             process_brace_close text
           when ss.match?(/\!/) then
             case
-            when in_arg_state? && (ss.skip(/\!\@/)) then
-              action { result :expr_arg, :tUBANG, "!@" }
+            when is_after_operator? && (ss.skip(/\!\@/)) then
+              action { result EXPR_ARG, :tUBANG, "!@" }
             when text = ss.scan(/\![=~]?/) then
               action { result :arg_state, TOKENS[text], text }
             end # group /\!/
           when ss.match?(/\./) then
             case
             when text = ss.scan(/\.\.\.?/) then
-              action { result :expr_beg, TOKENS[text], text }
+              action { result EXPR_BEG, TOKENS[text], text }
             when ss.skip(/\.\d/) then
               action { rb_compile_error "no .<digit> floating literal anymore put 0 before dot" }
             when ss.skip(/\./) then
-              action { self.lex_state = :expr_beg; result :expr_dot, :tDOT, "." }
+              action { self.lex_state = EXPR_BEG; result EXPR_DOT, :tDOT, "." }
             end # group /\./
           when text = ss.scan(/\(/) then
             process_paren text
           when text = ss.scan(/\,/) then
-            action { result :expr_beg, TOKENS[text], text }
+            action { result EXPR_PAR, TOKENS[text], text }
           when ss.match?(/=/) then
             case
             when text = ss.scan(/\=\=\=|\=\=|\=~|\=>|\=(?!begin\b)/) then
@@ -120,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 } }
+            action { result EXPR_END, :tSTRING, text[1..-2].gsub(ESC) { unescape $1 } }
           when text = ss.scan(/\"/) then
             action { string STR_DQUOTE; result nil, :tSTRING_BEG, text }
           when text = ss.scan(/\@\@?\d/) then
@@ -141,7 +181,7 @@ class RubyLexer
               process_colon1 text
             end # group /:/
           when ss.skip(/->/) then
-            action { result :expr_endfn, :tLAMBDA, nil }
+            action { result EXPR_ENDFN, :tLAMBDA, nil }
           when text = ss.scan(/[+-]/) then
             process_plus_minus text
           when ss.match?(/[+\d]/) then
@@ -174,24 +214,24 @@ class RubyLexer
           when ss.match?(/\|/) then
             case
             when ss.skip(/\|\|\=/) then
-              action { result :expr_beg, :tOP_ASGN, "||" }
+              action { result EXPR_BEG, :tOP_ASGN, "||" }
             when ss.skip(/\|\|/) then
-              action { result :expr_beg, :tOROP,    "||" }
+              action { result EXPR_BEG, :tOROP,    "||" }
             when ss.skip(/\|\=/) then
-              action { result :expr_beg, :tOP_ASGN, "|" }
+              action { result EXPR_BEG, :tOP_ASGN, "|" }
             when ss.skip(/\|/) then
-              action { result :arg_state, :tPIPE,    "|" }
+              action { state = is_after_operator? ? EXPR_ARG : EXPR_PAR; result state, :tPIPE, "|" }
             end # group /\|/
           when text = ss.scan(/\{/) then
             process_brace_open text
           when ss.match?(/\*/) then
             case
             when ss.skip(/\*\*=/) then
-              action { result :expr_beg, :tOP_ASGN, "**" }
+              action { result EXPR_BEG, :tOP_ASGN, "**" }
             when ss.skip(/\*\*/) then
               action { result(:arg_state, space_vs_beginning(:tDSTAR, :tDSTAR, :tPOW), "**") }
             when ss.skip(/\*\=/) then
-              action { result(:expr_beg, :tOP_ASGN, "*") }
+              action { result(EXPR_BEG, :tOP_ASGN, "*") }
             when ss.skip(/\*/) then
               action { result(:arg_state, space_vs_beginning(:tSTAR, :tSTAR, :tSTAR2), "*") }
             end # group /\*/
@@ -202,7 +242,7 @@ class RubyLexer
             when ss.skip(/\<\=/) then
               action { result :arg_state, :tLEQ, "<="     }
             when ss.skip(/\<\<\=/) then
-              action { result :expr_beg,  :tOP_ASGN, "<<" }
+              action { result EXPR_BEG,  :tOP_ASGN, "<<" }
             when text = ss.scan(/\<\</) then
               process_lchevron text
             when ss.skip(/\</) then
@@ -213,7 +253,7 @@ class RubyLexer
             when ss.skip(/\>\=/) then
               action { result :arg_state, :tGEQ, ">="     }
             when ss.skip(/\>\>=/) then
-              action { result :expr_beg,  :tOP_ASGN, ">>" }
+              action { result EXPR_BEG,  :tOP_ASGN, ">>" }
             when ss.skip(/\>\>/) then
               action { result :arg_state, :tRSHFT, ">>"   }
             when ss.skip(/\>/) then
@@ -222,9 +262,9 @@ class RubyLexer
           when ss.match?(/\`/) then
             case
             when expr_fname? && (ss.skip(/\`/)) then
-              action { result(:expr_end, :tBACK_REF2, "`") }
+              action { result(EXPR_END, :tBACK_REF2, "`") }
             when expr_dot? && (ss.skip(/\`/)) then
-              action { result((cmd_state ? :expr_cmdarg : :expr_arg), :tBACK_REF2, "`") }
+              action { result((cmd_state ? EXPR_CMDARG : EXPR_ARG), :tBACK_REF2, "`") }
             when ss.skip(/\`/) then
               action { string STR_XQUOTE, '`'; result(nil, :tXSTRING_BEG, "`") }
             end # group /\`/
@@ -233,13 +273,13 @@ class RubyLexer
           when ss.match?(/&/) then
             case
             when ss.skip(/\&\&\=/) then
-              action { result(:expr_beg, :tOP_ASGN, "&&") }
+              action { result(EXPR_BEG, :tOP_ASGN, "&&") }
             when ss.skip(/\&\&/) then
-              action { result(:expr_beg, :tANDOP,   "&&") }
+              action { result(EXPR_BEG, :tANDOP,   "&&") }
             when ss.skip(/\&\=/) then
-              action { result(:expr_beg, :tOP_ASGN, "&" ) }
+              action { result(EXPR_BEG, :tOP_ASGN, "&" ) }
             when ss.skip(/\&\./) then
-              action { result(:expr_dot, :tLONELY,  "&.") }
+              action { result(EXPR_DOT, :tLONELY,  "&.") }
             when text = ss.scan(/\&/) then
               process_amper text
             end # group /&/
@@ -248,15 +288,15 @@ class RubyLexer
           when ss.match?(/\^/) then
             case
             when ss.skip(/\^=/) then
-              action { result(:expr_beg, :tOP_ASGN, "^") }
+              action { result(EXPR_BEG, :tOP_ASGN, "^") }
             when ss.skip(/\^/) then
               action { result(:arg_state, :tCARET, "^") }
             end # group /\^/
           when ss.skip(/\;/) then
-            action { self.command_start = true; result(:expr_beg, :tSEMI, ";") }
+            action { self.command_start = true; result(EXPR_BEG, :tSEMI, ";") }
           when ss.match?(/~/) then
             case
-            when in_arg_state? && (ss.skip(/\~@/)) then
+            when is_after_operator? && (ss.skip(/\~@/)) then
               action { result(:arg_state, :tTILDE, "~") }
             when ss.skip(/\~/) then
               action { result(:arg_state, :tTILDE, "~") }
@@ -288,6 +328,8 @@ class RubyLexer
               process_nthref text
             when text = ss.scan(/\$0/) then
               process_gvar text
+            when text = ss.scan(/\$[^[:ascii:]]+/) then
+              process_gvar text
             when text = ss.scan(/\$\W|\$\z/) then
               process_gvar_oddity text
             when text = ss.scan(/\$\w+/) then

data/bundle/ruby/2.5.0/gems/{ruby_parser-3.13.0 → ruby_parser-3.13.1}/lib/ruby_parser.rb

@@ -9,6 +9,8 @@ class RubyParser
 
   VERSIONS = []
 
+  attr_accessor :current
+
   class Parser < Racc::Parser
     include RubyParserStuff
 
@@ -30,7 +32,7 @@ class RubyParser
   def process s, f = "(string)", t = 10
     e = nil
     VERSIONS.each do |klass|
-      parser = klass.new
+      self.current = parser = klass.new
       begin
         return parser.process s, f, t
       rescue Racc::ParseError, RubyParser::SyntaxError => exc

data/bundle/ruby/2.5.0/gems/{ruby_parser-3.13.0 → ruby_parser-3.13.1}/lib/ruby_parser.yy

@@ -73,7 +73,7 @@ preclow
 rule
 
          program:   {
-                      self.lexer.lex_state = :expr_beg
+                      self.lexer.lex_state = EXPR_BEG
                     }
                     top_compstmt
                     {
@@ -175,7 +175,7 @@ rule
 
             stmt: kALIAS fitem
                     {
-                      lexer.lex_state = :expr_fname
+                      lexer.lex_state = EXPR_FNAME
                       result = self.lexer.lineno
                     }
                     fitem
@@ -302,12 +302,14 @@ rule
                       expr, = val
                       result = value_expr expr
                     }
+#if V >= 24
                 | command_call kRESCUE_MOD stmt
                     {
                       expr, _, resbody = val
                       expr = value_expr expr
                       result = new_rescue(expr, new_resbody(s(:array), resbody))
                     }
+#endif
                 | command_asgn
 
             expr: command_call
@@ -643,14 +645,14 @@ rule
            fname: tIDENTIFIER | tCONSTANT | tFID
                 | op
                     {
-                      lexer.lex_state = :expr_end
+                      lexer.lex_state = EXPR_END
                       result = val[0]
                     }
 
                 | reswords
                     {
                       (sym, _line), = val
-                      lexer.lex_state = :expr_end
+                      lexer.lex_state = EXPR_END
                       result = sym
                     }
 
@@ -669,7 +671,7 @@ rule
                 |
                     undef_list tCOMMA
                     {
-                      lexer.lex_state = :expr_fname
+                      lexer.lex_state = EXPR_FNAME
                     }
                     fitem
                     {
@@ -722,13 +724,21 @@ rule
                     }
                 | primary_value tCOLON2 tCONSTANT tOP_ASGN arg_rhs
                     {
-                      # TODO: assignment
-                      raise "not yet: %p" % [val]
+                      lhs1, _, lhs2, op, rhs = val
+
+                      lhs = s(:colon2, lhs1, lhs2.to_sym).line lhs1.line
+                      result = new_const_op_asgn [lhs, op, rhs]
                     }
-                | tCOLON3 tCONSTANT tOP_ASGN arg_rhs
+                | tCOLON3 tCONSTANT
                     {
-                      # TODO: assignment
-                      raise "not yet: %p" % [val]
+                      result = self.lexer.lineno
+                    }
+                    tOP_ASGN arg_rhs
+                    {
+                      _, lhs, line, op, rhs = val
+
+                      lhs = s(:colon3, lhs.to_sym).line line
+                      result = new_const_op_asgn [lhs, op, rhs]
                     }
                 | backref tOP_ASGN arg_rhs
                     {
@@ -1085,7 +1095,7 @@ rule
                     }
                 | tLPAREN_ARG rparen
                     {
-                      # TODO: lex_state = :expr_endarg in between
+                      # TODO: lex_state = EXPR_ENDARG in between
                       debug20 13, val, result
                     }
                 | tLPAREN_ARG
@@ -1096,7 +1106,7 @@ rule
                     }
                     stmt
                     {
-                      lexer.lex_state = :expr_endarg
+                      lexer.lex_state = EXPR_ENDARG
                     }
                     rparen
                     {
@@ -1296,13 +1306,13 @@ rule
                 | k_def singleton dot_or_colon
                     {
                       self.comments.push self.lexer.comments
-                      lexer.lex_state = :expr_fname
+                      lexer.lex_state = EXPR_FNAME
                     }
                     fname
                     {
                       self.in_single += 1
                       self.env.extend
-                      lexer.lex_state = :expr_endfn # force for args
+                      lexer.lex_state = EXPR_ENDFN # force for args
                       result = [lexer.lineno, self.lexer.cmdarg.stack.dup]
                       lexer.cmdarg.stack.replace [false]
                     }
@@ -1976,7 +1986,7 @@ regexp_contents: none
                       result = lexer.lex_strterm
 
                       lexer.lex_strterm = nil
-                      lexer.lex_state = :expr_beg
+                      lexer.lex_state = EXPR_BEG
                     }
                     string_dvar
                     {
@@ -1997,7 +2007,7 @@ regexp_contents: none
                       lexer.brace_nest  = 0
                       lexer.string_nest = 0
 
-                      lexer.lex_state   = :expr_beg
+                      lexer.lex_state   = EXPR_BEG
                     }
                     compstmt
                     tSTRING_DEND
@@ -2038,7 +2048,7 @@ regexp_contents: none
 
           symbol: tSYMBEG sym
                     {
-                      lexer.lex_state = :expr_end
+                      lexer.lex_state = EXPR_END
                       result = val[1].to_sym
                     }
                 | tSYMBOL
@@ -2050,7 +2060,7 @@ regexp_contents: none
 
             dsym: tSYMBEG xstring_contents tSTRING_END
                     {
-                      lexer.lex_state = :expr_end
+                      lexer.lex_state = EXPR_END
                       result = val[1]
 
                       result ||= s(:str, "")
@@ -2140,7 +2150,7 @@ keyword_variable: kNIL      { result = s(:nil)   }
 
       superclass: tLT
                     {
-                      lexer.lex_state = :expr_beg
+                      lexer.lex_state = EXPR_BEG
                       lexer.command_start = true
                     }
                     expr_value term
@@ -2155,13 +2165,13 @@ keyword_variable: kNIL      { result = s(:nil)   }
        f_arglist: tLPAREN2 f_args rparen
                     {
                       result = val[1]
-                      self.lexer.lex_state = :expr_beg
+                      self.lexer.lex_state = EXPR_BEG
                       self.lexer.command_start = true
                     }
                 |   {
                       result = self.in_kwarg
                       self.in_kwarg = true
-                      # TODO: self.lexer.lex_state |= :expr_label
+                      self.lexer.lex_state |= EXPR_LABEL
                     }
                     f_args term
                     {
@@ -2169,7 +2179,7 @@ keyword_variable: kNIL      { result = s(:nil)   }
 
                       self.in_kwarg = kwarg
                       result = args
-                      lexer.lex_state     = :expr_beg
+                      lexer.lex_state     = EXPR_BEG
                       lexer.command_start = true
                     }
 
@@ -2482,7 +2492,7 @@ keyword_variable: kNIL      { result = s(:nil)   }
        singleton: var_ref
                 | tLPAREN2
                     {
-                      lexer.lex_state = :expr_beg
+                      lexer.lex_state = EXPR_BEG
                     }
                     expr rparen
                     {
@@ -2563,6 +2573,7 @@ end
 
 require "ruby_lexer"
 require "ruby_parser_extras"
+include RubyLexer::State::Values
 
 # :stopdoc: