brakeman 4.4.0 → 5.0.0

data/bundle/ruby/{2.5.0/gems/ruby_parser-3.12.0/lib → 2.7.0/gems/ruby_parser-legacy-1.0.0/lib/ruby_parser/legacy}/ruby19_parser.y

@@ -78,7 +78,7 @@ rule
                     }
                     tLCURLY top_compstmt tRCURLY
                     {
-                      result = new_iter s(:preexe), nil, val[3]
+                      result = new_iter s(:preexe), 0, val[3]
                     }
 
         bodystmt: compstmt opt_rescue opt_else opt_ensure
@@ -533,8 +533,9 @@ rule
 
                 | reswords
                     {
+                      (sym, _line), = val
                       lexer.lex_state = :expr_end
-                      result = val[0]
+                      result = sym
                     }
 
             fsym: fname | symbol
@@ -2106,8 +2107,8 @@ end
 
 ---- inner
 
-require "ruby_lexer"
-require "ruby_parser_extras"
+require "ruby_parser/legacy/ruby_lexer"
+require "ruby_parser/legacy/ruby_parser_extras"
 
 # :stopdoc:
 

data/bundle/ruby/{2.5.0/gems/ruby_parser-3.12.0/lib → 2.7.0/gems/ruby_parser-legacy-1.0.0/lib/ruby_parser/legacy}/ruby_lexer.rb

@@ -3,7 +3,7 @@
 
 $DEBUG = true if ENV["DEBUG"]
 
-class RubyLexer
+class RubyParser::Legacy::RubyLexer
 
   # :stopdoc:
   HAS_ENC = "".respond_to? :encoding
@@ -34,6 +34,10 @@ class RubyLexer
   STR_SSYM   = STR_FUNC_SYMBOL
   STR_DSYM   = STR_FUNC_SYMBOL | STR_FUNC_EXPAND
 
+  EXPR_BEG_ANY =  [:expr_beg, :expr_mid,  :expr_class  ]
+  EXPR_ARG_ANY =  [:expr_arg, :expr_cmdarg,            ]
+  EXPR_END_ANY =  [:expr_end, :expr_endarg, :expr_endfn]
+
   ESCAPES = {
     "a"    => "\007",
     "b"    => "\010",
@@ -77,7 +81,7 @@ class RubyLexer
   attr_accessor :brace_nest
   attr_accessor :cmdarg
   attr_accessor :command_start
-  attr_accessor :command_state
+  attr_accessor :cmd_state # temporary--ivar to avoid passing everywhere
   attr_accessor :last_state
   attr_accessor :cond
   attr_accessor :extra_lineno
@@ -121,8 +125,8 @@ class RubyLexer
     self.version = v
     @lex_state = :expr_none
 
-    self.cmdarg = RubyParserStuff::StackState.new(:cmdarg, $DEBUG)
-    self.cond   = RubyParserStuff::StackState.new(:cond, $DEBUG)
+    self.cond   = RubyParser::Legacy::RubyParserStuff::StackState.new(:cond, $DEBUG)
+    self.cmdarg = RubyParser::Legacy::RubyParserStuff::StackState.new(:cmdarg, $DEBUG)
 
     reset
   end
@@ -343,23 +347,30 @@ class RubyLexer
   end
 
   def is_arg?
-    in_lex_state? :expr_arg, :expr_cmdarg
+    in_lex_state?(*EXPR_ARG_ANY)
   end
 
   def is_beg?
-    in_lex_state? :expr_beg, :expr_value, :expr_mid, :expr_class, :expr_labelarg
+    # TODO: in_lex_state?(*EXPR_BEG_ANY) || lex_state == [:expr_arg, :expr_labeled]
+    in_lex_state?(*EXPR_BEG_ANY, :expr_value, :expr_labeled)
   end
 
   def is_end?
-    in_lex_state? :expr_end, :expr_endarg, :expr_endfn
+    in_lex_state?(*EXPR_END_ANY)
+  end
+
+  def lvar_defined? id
+    # TODO: (dyna_in_block? && dvar_defined?(id)) || local_id?(id)
+    self.parser.env[id.to_sym] == :lvar
   end
 
+
   def ruby22_label?
     ruby22plus? and is_label_possible?
   end
 
   def is_label_possible?
-    (in_lex_state?(:expr_beg, :expr_endfn) && !command_state) || is_arg?
+    (in_lex_state?(:expr_beg, :expr_endfn) && !cmd_state) || is_arg?
   end
 
   def is_label_suffix?
@@ -370,6 +381,10 @@ class RubyLexer
     is_arg? and space_seen and c !~ /\s/
   end
 
+  def lambda_beginning?
+    lpar_beg && lpar_beg == paren_nest
+  end
+
   def matched
     ss.matched
   end
@@ -411,20 +426,17 @@ class RubyLexer
     nil # TODO
   end
 
-  def process_bracing text
+  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   = :expr_endarg
-
-      # TODO
-      # if (c == '}') {
-      #     if (!brace_nest--) c = tSTRING_DEND;
-      # }
+      self.lex_state   = :expr_endarg # TODO: :expr_end ? Look at 2.6
 
+      return :tSTRING_DEND, matched if brace_nest < 0 unless ruby18 || ruby19
       return :tRCURLY, matched
     when "]" then
       self.paren_nest -= 1
@@ -463,24 +475,30 @@ class RubyLexer
     end
   end
 
-  def process_curly_brace text
+  def process_brace_open text
+    # matching compare/parse23.y:8694
     self.brace_nest += 1
-    if lpar_beg && lpar_beg == paren_nest then
+
+    if lambda_beginning? then
       self.lpar_beg = nil
-      self.paren_nest -= 1
+      self.paren_nest -= 1 # close arg list when lambda opens body
 
       return expr_result(:tLAMBEG, "{")
     end
 
-    token = if is_arg? || in_lex_state?(:expr_end, :expr_endfn) then
-               :tLCURLY      #  block (primary)
-             elsif in_lex_state?(:expr_endarg) then
-               :tLBRACE_ARG  #  block (expr)
-             else
-               :tLBRACE      #  hash
-             end
+    token = case lex_state
+            when :expr_labeled then
+              :tLBRACE     # hash
+            when *EXPR_ARG_ANY, :expr_end, :expr_endfn then
+              :tLCURLY     # block (primary)
+            when :expr_endarg
+              :tLBRACE_ARG # block (expr)
+            else
+              :tLBRACE     # hash
+            end
 
-    self.command_start = true unless token == :tLBRACE
+    # TODO: self.lex_state |= :expr_label if token != :tLBRACE_ARG
+    self.command_start = true if token != :tLBRACE
 
     return expr_result(token, "{")
   end
@@ -519,12 +537,19 @@ class RubyLexer
   def process_lchevron text
     if (!in_lex_state?(:expr_dot, :expr_class) &&
         !is_end? &&
-        (!is_arg? || space_seen)) then
+        (!is_arg? || space_seen)) then # TODO: || in_state(:expr_labeled)
       tok = self.heredoc_identifier
       return tok if tok
     end
 
-    return result(:arg_state, :tLSHFT, "\<\<")
+    if in_arg_state? then
+      self.lex_state = :expr_arg
+    else
+      self.command_start = true if lex_state == :expr_class
+      self.lex_state = :expr_beg
+    end
+
+    return result(lex_state, :tLSHFT, "\<\<")
   end
 
   def process_newline_or_comment text
@@ -534,6 +559,7 @@ class RubyLexer
     if c == '#' then
       ss.pos -= 1
 
+      # TODO: handle magic comments
       while scan(/\s*\#.*(\n+|\z)/) do
         hit = true
         self.lineno += matched.lines.to_a.size
@@ -548,8 +574,21 @@ class RubyLexer
     # Replace a string of newlines with a single one
     self.lineno += matched.lines.to_a.size if scan(/\n+/)
 
-    return if in_lex_state?(:expr_beg, :expr_value, :expr_class,
-                            :expr_fname, :expr_dot)
+    # TODO: remove :expr_value -- audit all uses of it
+    c = in_lex_state?(:expr_beg, :expr_value, :expr_class,
+                      :expr_fname, :expr_dot) && !in_lex_state?(:expr_labeled)
+
+    # TODO: figure out what token_seen is for
+    # TODO: if c || self.lex_state == [:expr_beg, :expr_labeled] then
+    if c || self.lex_state == :expr_labeled then
+      # ignore if !fallthrough?
+      if !c && parser.in_kwarg then
+        # normal newline
+        return result(:expr_beg, :tNL, nil)
+      else
+        return # skip
+      end
+    end
 
     if scan(/([\ \t\r\f\v]*)(\.|&)/) then
       self.space_seen = true unless ss[1].empty?
@@ -742,7 +781,9 @@ class RubyLexer
       token = :tLBRACK2
     end
 
-    return expr_result(token, "[")
+    # TODO: this is done by expr_result except "|EXPR_LABEL")
+    # SET_LEX_STATE(EXPR_BEG|EXPR_LABEL);
+    expr_result token, "["
   end
 
   def possibly_escape_string text, check
@@ -784,11 +825,14 @@ class RubyLexer
   def process_label text
     symbol = possibly_escape_string text, /^"/
 
-    result(:expr_labelarg, :tLABEL, [symbol, self.lineno])
+    result(:expr_labeled, :tLABEL, [symbol, self.lineno]) # TODO: expr_arg|expr_labeled
   end
 
   def process_token text
+    # matching: parse_ident in compare/parse23.y:7989
     # TODO: make this always return [token, lineno]
+    self.last_state = lex_state
+
     token = self.token = text
     token << matched if scan(/[\!\?](?!=)/)
 
@@ -809,25 +853,25 @@ class RubyLexer
 
     if !ruby18 and is_label_possible? and is_label_suffix? then
       scan(/:/)
-      return result(:expr_labelarg, :tLABEL, [token, self.lineno])
+      # TODO: :expr_arg|:expr_labeled
+      return result :expr_labeled, :tLABEL, [token, self.lineno]
     end
 
+    # TODO: mb == ENC_CODERANGE_7BIT && !in_lex_state?(:expr_dot)
     unless in_lex_state? :expr_dot then
       # See if it is a reserved word.
       keyword = if ruby18 then # REFACTOR need 18/19 lexer subclasses
-                  RubyParserStuff::Keyword.keyword18 token
+                  RubyParser::Legacy::RubyParserStuff::Keyword.keyword18 token
                 else
-                  RubyParserStuff::Keyword.keyword19 token
+                  RubyParser::Legacy::RubyParserStuff::Keyword.keyword19 token
                 end
 
       return process_token_keyword keyword if keyword
     end # unless in_lex_state? :expr_dot
 
-    # TODO:
-    # if (mb == ENC_CODERANGE_7BIT && lex_state != EXPR_DOT) {
-
+    # matching: compare/parse23.y:8079
     state = if is_beg? or is_arg? or in_lex_state? :expr_dot then
-              command_state ? :expr_cmdarg : :expr_arg
+              cmd_state ? :expr_cmdarg : :expr_arg
             elsif not ruby18 and in_lex_state? :expr_fname then
               :expr_endfn
             else
@@ -835,8 +879,9 @@ class RubyLexer
             end
 
     if not [:expr_dot, :expr_fname].include? last_state and
-        self.parser.env[token.to_sym] == :lvar then
-      state = :expr_end
+        (tok_id == :tIDENTIFIER) and # not :expr_fname, not attrasgn
+        lvar_defined?(token) then
+      state = :expr_end # TODO: EXPR_END|EXPR_LABEL
     end
 
     token.lineno = self.lineno # yes, on a string. I know... I know...
@@ -845,38 +890,38 @@ class RubyLexer
   end
 
   def process_token_keyword keyword
-    state = keyword.state
+    # matching MIDDLE of parse_ident in compare/parse23.y:8046
+    state = lex_state
+    self.lex_state = keyword.state
 
     value = [token, self.lineno]
 
-    self.command_start = true if state == :expr_beg and lex_state != :expr_fname
+    return result(lex_state, keyword.id0, value) if state == :expr_fname
+
+    self.command_start = true if lex_state == :expr_beg
 
     case
-    when lex_state == :expr_fname then
-      result(state, keyword.id0, keyword.name)
     when keyword.id0 == :kDO then
       case
-      when lpar_beg && lpar_beg == paren_nest then
-        self.lpar_beg = nil
+      when lambda_beginning? then
+        self.lpar_beg = nil # lambda_beginning? == FALSE in the body of "-> do ... end"
         self.paren_nest -= 1
-        expr_result(:kDO_LAMBDA, value)
+        result(lex_state, :kDO_LAMBDA, value)
       when cond.is_in_state then
-        result(state, :kDO_COND, value)
-      when cmdarg.is_in_state && lex_state != :expr_cmdarg then
-        result(state, :kDO_BLOCK, value)
-      when in_lex_state?(:expr_beg, :expr_endarg) then
-        result(state, :kDO_BLOCK, value)
-      when lex_state == :expr_end # eg: a -> do end do end
-        result(state, :kDO_BLOCK, value)
+        result(lex_state, :kDO_COND, value)
+      when cmdarg.is_in_state && state != :expr_cmdarg then
+        result(lex_state, :kDO_BLOCK, value)
+      when [:expr_beg, :expr_endarg].include?(state) then
+        result(lex_state, :kDO_BLOCK, value)
       else
-        result(state, :kDO, value)
+        result(lex_state, :kDO, value)
       end
-    when in_lex_state?(:expr_beg, :expr_value, :expr_labelarg) then
-      result(state, keyword.id0, value)
+    when [:expr_beg, :expr_labeled].include?(state) then
+      result(lex_state, keyword.id0, value)
     when keyword.id0 != keyword.id1 then
-      result(:expr_beg, keyword.id1, value)
+      result(:expr_beg, keyword.id1, value) # TODO: :expr_beg|:expr_label
     else
-      result(state, keyword.id1, value)
+      result(lex_state, keyword.id1, value)
     end
   end
 
@@ -982,8 +1027,8 @@ class RubyLexer
     self.token         = nil
     self.extra_lineno  = 0
 
-    self.cmdarg.reset
     self.cond.reset
+    self.cmdarg.reset
   end
 
   def result lex_state, token, text # :nodoc:
@@ -996,6 +1041,10 @@ class RubyLexer
     RubyParser::V18 === parser
   end
 
+  def ruby19
+    RubyParser::V19 === parser
+  end
+
   def scan re
     ss.scan re
   end
@@ -1201,6 +1250,7 @@ class RubyLexer
   end
 
   def process_string # TODO: rewrite / remove
+    # matches top of parser_yylex in compare/parse23.y:8113
     token = if lex_strterm[0] == :heredoc then
               self.heredoc lex_strterm
             else
@@ -1209,6 +1259,7 @@ class RubyLexer
 
     token_type, c = token
 
+    # matches parser_string_term
     if ruby22plus? && token_type == :tSTRING_END && ["'", '"'].include?(c) then
       if (([:expr_beg, :expr_endfn].include?(lex_state) &&
            !cond.is_in_state) || is_arg?) &&
@@ -1220,7 +1271,8 @@ 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_labelarg : :expr_end
+      # TODO: :expr_beg|:expr_label
+      self.lex_state   = (token_type == :tLABEL_END) ? :expr_label : :expr_end
     end
 
     return token
@@ -1326,6 +1378,7 @@ class RubyLexer
         # TODO: !ISASCII
         return :tSTRING_DVAR, nil
       when scan(/#[{]/) then
+        self.command_start = true
         return :tSTRING_DBEG, nil
       when scan(/#/) then
         string_buffer << '#'
@@ -1340,10 +1393,10 @@ class RubyLexer
   end
 end
 
-require "ruby_lexer.rex"
+require "ruby_parser/legacy/ruby_lexer.rex"
 
 if ENV["RP_LINENO_DEBUG"] then
-  class RubyLexer
+  class RubyParser::Legacy::RubyLexer
     alias :old_lineno= :lineno=
 
     def d o

data/bundle/ruby/{2.5.0/gems/ruby_parser-3.12.0/lib → 2.7.0/gems/ruby_parser-legacy-1.0.0/lib/ruby_parser/legacy}/ruby_lexer.rex

@@ -2,7 +2,7 @@
 #
 # lexical scanner definition for ruby
 
-class RubyLexer
+class RubyParser::Legacy::RubyLexer
 
 macro
 
@@ -27,9 +27,9 @@ start
 
   return process_string if lex_strterm
 
-  self.command_state = self.command_start
+  self.cmd_state = self.command_start
   self.command_start = false
-  self.space_seen    = false
+  self.space_seen    = false # TODO: rename token_seen?
   self.last_state    = lex_state
 
 rule
@@ -41,7 +41,7 @@ rule
 
                 /\n|\#/                 process_newline_or_comment
 
-                /[\]\)\}]/              process_bracing
+                /[\]\)\}]/              process_brace_close
 
 : /\!/
 | in_arg_state? /\!\@/                  { result :expr_arg, :tUBANG, "!@" }
@@ -50,10 +50,11 @@ rule
 : /\./
 |               /\.\.\.?/               { result :expr_beg, TOKENS[text], text }
 |               /\.\d/                  { rb_compile_error "no .<digit> floating literal anymore put 0 before dot" }
-|               /\./                    { 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 }
 
 : /=/
@@ -101,7 +102,7 @@ was_label?        /\'#{SSTRING}\':?/o   process_label_or_string
 |               /\|\=/                  { result :expr_beg, :tOP_ASGN, "|" }
 |               /\|/                    { result :arg_state, :tPIPE,    "|" }
 
-                /\{/                    process_curly_brace
+                /\{/                    process_brace_open
 
 : /\*/
 |               /\*\*=/                 { result :expr_beg, :tOP_ASGN, "**" }
@@ -109,22 +110,23 @@ was_label?        /\'#{SSTRING}\':?/o   process_label_or_string
 |               /\*\=/                  { 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 :arg_state, :tOP_ASGN, "<<" }
+|               /\<\<\=/                { result :expr_beg,  :tOP_ASGN, "<<" }
 |               /\<\</                  process_lchevron
 |               /\</                    { result :arg_state, :tLT, "<"       }
 
 : />/
 |               /\>\=/                  { result :arg_state, :tGEQ, ">="     }
-|               /\>\>=/                 { result :arg_state, :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((command_state ? :expr_cmdarg : :expr_arg), :tBACK_REF2, "`") }
+| expr_dot?     /\`/                   { result((cmd_state ? :expr_cmdarg : :expr_arg), :tBACK_REF2, "`") }
 |               /\`/                   { string STR_XQUOTE, '`'; result(nil, :tXSTRING_BEG, "`") }
 
                 /\?/                    process_questionmark