irb 1.3.6 → 1.4.1

data/lib/irb/ruby-lex.rb

@@ -30,26 +30,31 @@ class RubyLex
     @prompt = nil
   end
 
-  def self.compile_with_errors_suppressed(code)
-    line_no = 1
+  def self.compile_with_errors_suppressed(code, line_no: 1)
     begin
       result = yield code, line_no
     rescue ArgumentError
+      # Ruby can issue an error for the code if there is an
+      # incomplete magic comment for encoding in it. Force an
+      # expression with a new line before the code in this
+      # case to prevent magic comment handling.  To make sure
+      # line numbers in the lexed code remain the same,
+      # decrease the line number by one.
       code = ";\n#{code}"
-      line_no = 0
+      line_no -= 1
       result = yield code, line_no
     end
     result
   end
 
   # io functions
-  def set_input(io, p = nil, &block)
+  def set_input(io, p = nil, context: nil, &block)
     @io = io
     if @io.respond_to?(:check_termination)
       @io.check_termination do |code|
         if Reline::IOGate.in_pasting?
           lex = RubyLex.new
-          rest = lex.check_termination_in_prev_line(code)
+          rest = lex.check_termination_in_prev_line(code, context: context)
           if rest
             Reline.delete_text
             rest.bytes.reverse_each do |c|
@@ -61,7 +66,7 @@ class RubyLex
           end
         else
           code.gsub!(/\s*\z/, '').concat("\n")
-          ltype, indent, continue, code_block_open = check_state(code)
+          ltype, indent, continue, code_block_open = check_state(code, context: context)
           if ltype or indent > 0 or continue or code_block_open
             false
           else
@@ -74,7 +79,7 @@ class RubyLex
       @io.dynamic_prompt do |lines|
         lines << '' if lines.empty?
         result = []
-        tokens = self.class.ripper_lex_without_warning(lines.map{ |l| l + "\n" }.join)
+        tokens = self.class.ripper_lex_without_warning(lines.map{ |l| l + "\n" }.join, context: context)
         code = String.new
         partial_tokens = []
         unprocessed_tokens = []
@@ -82,26 +87,28 @@ class RubyLex
         tokens.each do |t|
           partial_tokens << t
           unprocessed_tokens << t
-          if t[2].include?("\n")
-            t_str = t[2]
+          if t.tok.include?("\n")
+            t_str = t.tok
             t_str.each_line("\n") do |s|
               code << s << "\n"
-              ltype, indent, continue, code_block_open = check_state(code, partial_tokens)
+              ltype, indent, continue, code_block_open = check_state(code, partial_tokens, context: context)
               result << @prompt.call(ltype, indent, continue || code_block_open, @line_no + line_num_offset)
               line_num_offset += 1
             end
             unprocessed_tokens = []
           else
-            code << t[2]
+            code << t.tok
           end
         end
+
         unless unprocessed_tokens.empty?
-          ltype, indent, continue, code_block_open = check_state(code, unprocessed_tokens)
+          ltype, indent, continue, code_block_open = check_state(code, unprocessed_tokens, context: context)
           result << @prompt.call(ltype, indent, continue || code_block_open, @line_no + line_num_offset)
         end
         result
       end
     end
+
     if p.respond_to?(:call)
       @input = p
     elsif block_given?
@@ -129,28 +136,38 @@ class RubyLex
     :on_param_error
   ]
 
-  def self.ripper_lex_without_warning(code)
+  def self.ripper_lex_without_warning(code, context: nil)
     verbose, $VERBOSE = $VERBOSE, nil
+    if context
+      lvars = context&.workspace&.binding&.local_variables
+      if lvars && !lvars.empty?
+        code = "#{lvars.join('=')}=nil\n#{code}"
+        line_no = 0
+      else
+        line_no = 1
+      end
+    end
     tokens = nil
-    compile_with_errors_suppressed(code) do |inner_code, line_no|
+    compile_with_errors_suppressed(code, line_no: line_no) do |inner_code, line_no|
       lexer = Ripper::Lexer.new(inner_code, '-', line_no)
       if lexer.respond_to?(:scan) # Ruby 2.7+
         tokens = []
         pos_to_index = {}
         lexer.scan.each do |t|
-          if pos_to_index.has_key?(t[0])
-            index = pos_to_index[t[0]]
+          next if t.pos.first == 0
+          if pos_to_index.has_key?(t.pos)
+            index = pos_to_index[t.pos]
             found_tk = tokens[index]
-            if ERROR_TOKENS.include?(found_tk[1]) && !ERROR_TOKENS.include?(t[1])
+            if ERROR_TOKENS.include?(found_tk.event) && !ERROR_TOKENS.include?(t.event)
               tokens[index] = t
             end
           else
-            pos_to_index[t[0]] = tokens.size
+            pos_to_index[t.pos] = tokens.size
             tokens << t
           end
         end
       else
-        tokens = lexer.parse
+        tokens = lexer.parse.reject { |it| it.pos.first == 0 }
       end
     end
     tokens
@@ -160,17 +177,17 @@ class RubyLex
 
   def find_prev_spaces(line_index)
     return 0 if @tokens.size == 0
-    md = @tokens[0][2].match(/(\A +)/)
+    md = @tokens[0].tok.match(/(\A +)/)
     prev_spaces = md.nil? ? 0 : md[1].count(' ')
     line_count = 0
     @tokens.each_with_index do |t, i|
-      if t[2].include?("\n")
-        line_count += t[2].count("\n")
+      if t.tok.include?("\n")
+        line_count += t.tok.count("\n")
         if line_count >= line_index
           return prev_spaces
         end
         if (@tokens.size - 1) > i
-          md = @tokens[i + 1][2].match(/(\A +)/)
+          md = @tokens[i + 1].tok.match(/(\A +)/)
           prev_spaces = md.nil? ? 0 : md[1].count(' ')
         end
       end
@@ -182,7 +199,7 @@ class RubyLex
     if @io.respond_to?(:auto_indent) and context.auto_indent_mode
       @io.auto_indent do |lines, line_index, byte_pointer, is_newline|
         if is_newline
-          @tokens = self.class.ripper_lex_without_warning(lines[0..line_index].join("\n"))
+          @tokens = self.class.ripper_lex_without_warning(lines[0..line_index].join("\n"), context: context)
           prev_spaces = find_prev_spaces(line_index)
           depth_difference = check_newline_depth_difference
           depth_difference = 0 if depth_difference < 0
@@ -191,8 +208,8 @@ class RubyLex
           code = line_index.zero? ? '' : lines[0..(line_index - 1)].map{ |l| l + "\n" }.join
           last_line = lines[line_index]&.byteslice(0, byte_pointer)
           code += last_line if last_line
-          @tokens = self.class.ripper_lex_without_warning(code)
-          corresponding_token_depth = check_corresponding_token_depth
+          @tokens = self.class.ripper_lex_without_warning(code, context: context)
+          corresponding_token_depth = check_corresponding_token_depth(lines, line_index)
           if corresponding_token_depth
             corresponding_token_depth
           else
@@ -203,8 +220,8 @@ class RubyLex
     end
   end
 
-  def check_state(code, tokens = nil)
-    tokens = self.class.ripper_lex_without_warning(code) unless tokens
+  def check_state(code, tokens = nil, context: nil)
+    tokens = self.class.ripper_lex_without_warning(code, context: context) unless tokens
     ltype = process_literal_type(tokens)
     indent = process_nesting_level(tokens)
     continue = process_continue(tokens)
@@ -280,18 +297,18 @@ class RubyLex
 
   def process_continue(tokens = @tokens)
     # last token is always newline
-    if tokens.size >= 2 and tokens[-2][1] == :on_regexp_end
+    if tokens.size >= 2 and tokens[-2].event == :on_regexp_end
       # end of regexp literal
       return false
-    elsif tokens.size >= 2 and tokens[-2][1] == :on_semicolon
+    elsif tokens.size >= 2 and tokens[-2].event == :on_semicolon
       return false
-    elsif tokens.size >= 2 and tokens[-2][1] == :on_kw and ['begin', 'else', 'ensure'].include?(tokens[-2][2])
+    elsif tokens.size >= 2 and tokens[-2].event == :on_kw and ['begin', 'else', 'ensure'].include?(tokens[-2].tok)
       return false
-    elsif !tokens.empty? and tokens.last[2] == "\\\n"
+    elsif !tokens.empty? and tokens.last.tok == "\\\n"
       return true
-    elsif tokens.size >= 1 and tokens[-1][1] == :on_heredoc_end # "EOH\n"
+    elsif tokens.size >= 1 and tokens[-1].event == :on_heredoc_end # "EOH\n"
       return false
-    elsif tokens.size >= 2 and defined?(Ripper::EXPR_BEG) and tokens[-2][3].anybits?(Ripper::EXPR_BEG | Ripper::EXPR_FNAME) and tokens[-2][2] !~ /\A\.\.\.?\z/
+    elsif tokens.size >= 2 and defined?(Ripper::EXPR_BEG) and tokens[-2].state.anybits?(Ripper::EXPR_BEG | Ripper::EXPR_FNAME) and tokens[-2].tok !~ /\A\.\.\.?\z/
       # end of literal except for regexp
       # endless range at end of line is not a continue
       return true
@@ -301,7 +318,7 @@ class RubyLex
 
   def check_code_block(code, tokens = @tokens)
     return true if tokens.empty?
-    if tokens.last[1] == :on_heredoc_beg
+    if tokens.last.event == :on_heredoc_beg
       return true
     end
 
@@ -373,7 +390,7 @@ class RubyLex
     end
 
     if defined?(Ripper::EXPR_BEG)
-      last_lex_state = tokens.last[3]
+      last_lex_state = tokens.last.state
       if last_lex_state.allbits?(Ripper::EXPR_BEG)
         return false
       elsif last_lex_state.allbits?(Ripper::EXPR_DOT)
@@ -398,14 +415,14 @@ class RubyLex
     tokens.each_with_index { |t, index|
       # detecting one-liner method definition
       if in_oneliner_def.nil?
-        if t[3].allbits?(Ripper::EXPR_ENDFN)
+        if t.state.allbits?(Ripper::EXPR_ENDFN)
           in_oneliner_def = :ENDFN
         end
       else
-        if t[3].allbits?(Ripper::EXPR_ENDFN)
+        if t.state.allbits?(Ripper::EXPR_ENDFN)
           # continuing
-        elsif t[3].allbits?(Ripper::EXPR_BEG)
-          if t[2] == '='
+        elsif t.state.allbits?(Ripper::EXPR_BEG)
+          if t.tok == '='
             in_oneliner_def = :BODY
           end
         else
@@ -417,14 +434,14 @@ class RubyLex
         end
       end
 
-      case t[1]
+      case t.event
       when :on_lbracket, :on_lbrace, :on_lparen, :on_tlambeg
         indent += 1
       when :on_rbracket, :on_rbrace, :on_rparen
         indent -= 1
       when :on_kw
-        next if index > 0 and tokens[index - 1][3].allbits?(Ripper::EXPR_FNAME)
-        case t[2]
+        next if index > 0 and tokens[index - 1].state.allbits?(Ripper::EXPR_FNAME)
+        case t.tok
         when 'do'
           syntax_of_do = take_corresponding_syntax_to_kw_do(tokens, index)
           indent += 1 if syntax_of_do == :method_calling
@@ -432,7 +449,7 @@ class RubyLex
           indent += 1
         when 'if', 'unless', 'while', 'until'
           # postfix if/unless/while/until must be Ripper::EXPR_LABEL
-          indent += 1 unless t[3].allbits?(Ripper::EXPR_LABEL)
+          indent += 1 unless t.state.allbits?(Ripper::EXPR_LABEL)
         when 'end'
           indent -= 1
         end
@@ -444,14 +461,14 @@ class RubyLex
 
   def is_method_calling?(tokens, index)
     tk = tokens[index]
-    if tk[3].anybits?(Ripper::EXPR_CMDARG) and tk[1] == :on_ident
+    if tk.state.anybits?(Ripper::EXPR_CMDARG) and tk.event == :on_ident
       # The target method call to pass the block with "do".
       return true
-    elsif tk[3].anybits?(Ripper::EXPR_ARG) and tk[1] == :on_ident
-      non_sp_index = tokens[0..(index - 1)].rindex{ |t| t[1] != :on_sp }
+    elsif tk.state.anybits?(Ripper::EXPR_ARG) and tk.event == :on_ident
+      non_sp_index = tokens[0..(index - 1)].rindex{ |t| t.event != :on_sp }
       if non_sp_index
         prev_tk = tokens[non_sp_index]
-        if prev_tk[3].anybits?(Ripper::EXPR_DOT) and prev_tk[1] == :on_period
+        if prev_tk.state.anybits?(Ripper::EXPR_DOT) and prev_tk.event == :on_period
           # The target method call with receiver to pass the block with "do".
           return true
         end
@@ -462,21 +479,21 @@ class RubyLex
 
   def take_corresponding_syntax_to_kw_do(tokens, index)
     syntax_of_do = nil
-    # Finding a syntax correnponding to "do".
+    # Finding a syntax corresponding to "do".
     index.downto(0) do |i|
       tk = tokens[i]
       # In "continue", the token isn't the corresponding syntax to "do".
-      non_sp_index = tokens[0..(i - 1)].rindex{ |t| t[1] != :on_sp }
+      non_sp_index = tokens[0..(i - 1)].rindex{ |t| t.event != :on_sp }
       first_in_fomula = false
       if non_sp_index.nil?
         first_in_fomula = true
-      elsif [:on_ignored_nl, :on_nl, :on_comment].include?(tokens[non_sp_index][1])
+      elsif [:on_ignored_nl, :on_nl, :on_comment].include?(tokens[non_sp_index].event)
         first_in_fomula = true
       end
       if is_method_calling?(tokens, i)
         syntax_of_do = :method_calling
         break if first_in_fomula
-      elsif tk[1] == :on_kw && %w{while until for}.include?(tk[2])
+      elsif tk.event == :on_kw && %w{while until for}.include?(tk.tok)
         # A loop syntax in front of "do" found.
         #
         #   while cond do # also "until" or "for"
@@ -493,18 +510,18 @@ class RubyLex
 
   def is_the_in_correspond_to_a_for(tokens, index)
     syntax_of_in = nil
-    # Finding a syntax correnponding to "do".
+    # Finding a syntax corresponding to "do".
     index.downto(0) do |i|
       tk = tokens[i]
       # In "continue", the token isn't the corresponding syntax to "do".
-      non_sp_index = tokens[0..(i - 1)].rindex{ |t| t[1] != :on_sp }
+      non_sp_index = tokens[0..(i - 1)].rindex{ |t| t.event != :on_sp }
       first_in_fomula = false
       if non_sp_index.nil?
         first_in_fomula = true
-      elsif [:on_ignored_nl, :on_nl, :on_comment].include?(tokens[non_sp_index][1])
+      elsif [:on_ignored_nl, :on_nl, :on_comment].include?(tokens[non_sp_index].event)
         first_in_fomula = true
       end
-      if tk[1] == :on_kw && tk[2] == 'for'
+      if tk.event == :on_kw && tk.tok == 'for'
         # A loop syntax in front of "do" found.
         #
         #   while cond do # also "until" or "for"
@@ -526,14 +543,14 @@ class RubyLex
     @tokens.each_with_index do |t, index|
       # detecting one-liner method definition
       if in_oneliner_def.nil?
-        if t[3].allbits?(Ripper::EXPR_ENDFN)
+        if t.state.allbits?(Ripper::EXPR_ENDFN)
           in_oneliner_def = :ENDFN
         end
       else
-        if t[3].allbits?(Ripper::EXPR_ENDFN)
+        if t.state.allbits?(Ripper::EXPR_ENDFN)
           # continuing
-        elsif t[3].allbits?(Ripper::EXPR_BEG)
-          if t[2] == '='
+        elsif t.state.allbits?(Ripper::EXPR_BEG)
+          if t.tok == '='
             in_oneliner_def = :BODY
           end
         else
@@ -545,7 +562,7 @@ class RubyLex
         end
       end
 
-      case t[1]
+      case t.event
       when :on_ignored_nl, :on_nl, :on_comment
         if index != (@tokens.size - 1) and in_oneliner_def != :BODY
           depth_difference = 0
@@ -555,15 +572,16 @@ class RubyLex
       when :on_sp
         next
       end
-      case t[1]
+
+      case t.event
       when :on_lbracket, :on_lbrace, :on_lparen, :on_tlambeg
         depth_difference += 1
         open_brace_on_line += 1
       when :on_rbracket, :on_rbrace, :on_rparen
         depth_difference -= 1 if open_brace_on_line > 0
       when :on_kw
-        next if index > 0 and @tokens[index - 1][3].allbits?(Ripper::EXPR_FNAME)
-        case t[2]
+        next if index > 0 and @tokens[index - 1].state.allbits?(Ripper::EXPR_FNAME)
+        case t.tok
         when 'do'
           syntax_of_do = take_corresponding_syntax_to_kw_do(@tokens, index)
           depth_difference += 1 if syntax_of_do == :method_calling
@@ -571,7 +589,7 @@ class RubyLex
           depth_difference += 1
         when 'if', 'unless', 'while', 'until', 'rescue'
           # postfix if/unless/while/until/rescue must be Ripper::EXPR_LABEL
-          unless t[3].allbits?(Ripper::EXPR_LABEL)
+          unless t.state.allbits?(Ripper::EXPR_LABEL)
             depth_difference += 1
           end
         when 'else', 'elsif', 'ensure', 'when'
@@ -588,7 +606,7 @@ class RubyLex
     depth_difference
   end
 
-  def check_corresponding_token_depth
+  def check_corresponding_token_depth(lines, line_index)
     corresponding_token_depth = nil
     is_first_spaces_of_line = true
     is_first_printable_of_line = true
@@ -596,17 +614,22 @@ class RubyLex
     spaces_at_line_head = 0
     open_brace_on_line = 0
     in_oneliner_def = nil
+
+    if heredoc_scope?
+      return lines[line_index][/^ */].length
+    end
+
     @tokens.each_with_index do |t, index|
       # detecting one-liner method definition
       if in_oneliner_def.nil?
-        if t[3].allbits?(Ripper::EXPR_ENDFN)
+        if t.state.allbits?(Ripper::EXPR_ENDFN)
           in_oneliner_def = :ENDFN
         end
       else
-        if t[3].allbits?(Ripper::EXPR_ENDFN)
+        if t.state.allbits?(Ripper::EXPR_ENDFN)
           # continuing
-        elsif t[3].allbits?(Ripper::EXPR_BEG)
-          if t[2] == '='
+        elsif t.state.allbits?(Ripper::EXPR_BEG)
+          if t.tok == '='
             in_oneliner_def = :BODY
           end
         else
@@ -623,7 +646,7 @@ class RubyLex
         end
       end
 
-      case t[1]
+      case t.event
       when :on_ignored_nl, :on_nl, :on_comment
         if in_oneliner_def != :BODY
           corresponding_token_depth = nil
@@ -634,11 +657,12 @@ class RubyLex
         end
         next
       when :on_sp
-        spaces_at_line_head = t[2].count(' ') if is_first_spaces_of_line
+        spaces_at_line_head = t.tok.count(' ') if is_first_spaces_of_line
         is_first_spaces_of_line = false
         next
       end
-      case t[1]
+
+      case t.event
       when :on_lbracket, :on_lbrace, :on_lparen, :on_tlambeg
         spaces_of_nest.push(spaces_at_line_head + open_brace_on_line * 2)
         open_brace_on_line += 1
@@ -651,8 +675,8 @@ class RubyLex
         end
         open_brace_on_line -= 1
       when :on_kw
-        next if index > 0 and @tokens[index - 1][3].allbits?(Ripper::EXPR_FNAME)
-        case t[2]
+        next if index > 0 and @tokens[index - 1].state.allbits?(Ripper::EXPR_FNAME)
+        case t.tok
         when 'do'
           syntax_of_do = take_corresponding_syntax_to_kw_do(@tokens, index)
           if syntax_of_do == :method_calling
@@ -661,16 +685,20 @@ class RubyLex
         when 'def', 'case', 'for', 'begin', 'class', 'module'
           spaces_of_nest.push(spaces_at_line_head)
         when 'rescue'
-          unless t[3].allbits?(Ripper::EXPR_LABEL)
+          unless t.state.allbits?(Ripper::EXPR_LABEL)
             corresponding_token_depth = spaces_of_nest.last
           end
         when 'if', 'unless', 'while', 'until'
           # postfix if/unless/while/until must be Ripper::EXPR_LABEL
-          unless t[3].allbits?(Ripper::EXPR_LABEL)
+          unless t.state.allbits?(Ripper::EXPR_LABEL)
             spaces_of_nest.push(spaces_at_line_head)
           end
-        when 'else', 'elsif', 'ensure', 'when', 'in'
+        when 'else', 'elsif', 'ensure', 'when'
           corresponding_token_depth = spaces_of_nest.last
+        when 'in'
+          if in_keyword_case_scope?
+            corresponding_token_depth = spaces_of_nest.last
+          end
         when 'end'
           if is_first_printable_of_line
             corresponding_token_depth = spaces_of_nest.pop
@@ -692,7 +720,10 @@ class RubyLex
     end_type = []
     while i < tokens.size
       t = tokens[i]
-      case t[1]
+      case t.event
+      when *end_type.last
+        start_token.pop
+        end_type.pop
       when :on_tstring_beg
         start_token << t
         end_type << [:on_tstring_end, :on_label_end]
@@ -700,10 +731,14 @@ class RubyLex
         start_token << t
         end_type << :on_regexp_end
       when :on_symbeg
-        acceptable_single_tokens = %i{on_ident on_const on_op on_cvar on_ivar on_gvar on_kw}
-        if (i + 1) < tokens.size and acceptable_single_tokens.all?{ |st| tokens[i + 1][1] != st }
-          start_token << t
-          end_type << :on_tstring_end
+        acceptable_single_tokens = %i{on_ident on_const on_op on_cvar on_ivar on_gvar on_kw on_int on_backtick}
+        if (i + 1) < tokens.size
+          if acceptable_single_tokens.all?{ |st| tokens[i + 1].event != st }
+            start_token << t
+            end_type << :on_tstring_end
+          else
+            i += 1
+          end
         end
       when :on_backtick
         start_token << t
@@ -714,20 +749,19 @@ class RubyLex
       when :on_heredoc_beg
         start_token << t
         end_type << :on_heredoc_end
-      when *end_type.last
-        start_token.pop
-        end_type.pop
       end
       i += 1
     end
-    start_token.last.nil? ? '' : start_token.last
+    start_token.last.nil? ? nil : start_token.last
   end
 
   def process_literal_type(tokens = @tokens)
     start_token = check_string_literal(tokens)
-    case start_token[1]
+    return nil if start_token == ""
+
+    case start_token&.event
     when :on_tstring_beg
-      case start_token[2]
+      case start_token&.tok
       when ?"      then ?"
       when /^%.$/  then ?"
       when /^%Q.$/ then ?"
@@ -742,7 +776,7 @@ class RubyLex
     when :on_qsymbols_beg then ?]
     when :on_symbols_beg  then ?]
     when :on_heredoc_beg
-      start_token[2] =~ /<<[-~]?(['"`])[_a-zA-Z0-9]+\1/
+      start_token&.tok =~ /<<[-~]?(['"`])[_a-zA-Z0-9]+\1/
       case $1
       when ?" then ?"
       when ?' then ?'
@@ -754,8 +788,8 @@ class RubyLex
     end
   end
 
-  def check_termination_in_prev_line(code)
-    tokens = self.class.ripper_lex_without_warning(code)
+  def check_termination_in_prev_line(code, context: nil)
+    tokens = self.class.ripper_lex_without_warning(code, context: context)
     past_first_newline = false
     index = tokens.rindex do |t|
       # traverse first token before last line
@@ -770,6 +804,7 @@ class RubyLex
         false
       end
     end
+
     if index
       first_token = nil
       last_line_tokens = tokens[(index + 1)..(tokens.size - 1)]
@@ -779,6 +814,7 @@ class RubyLex
           break
         end
       end
+
       if first_token.nil?
         return false
       elsif first_token && first_token.state == Ripper::EXPR_DOT
@@ -798,5 +834,28 @@ class RubyLex
     end
     false
   end
+
+  private
+
+  def heredoc_scope?
+    heredoc_tokens = @tokens.select { |t| [:on_heredoc_beg, :on_heredoc_end].include?(t.event) }
+    heredoc_tokens[-1]&.event == :on_heredoc_beg
+  end
+
+  def in_keyword_case_scope?
+    kw_tokens = @tokens.select { |t| t.event == :on_kw && ['case', 'for', 'end'].include?(t.tok) }
+    counter = 0
+    kw_tokens.reverse.each do |t|
+      if t.tok == 'case'
+        return true if counter.zero?
+        counter += 1
+      elsif t.tok == 'for'
+        counter += 1
+      elsif t.tok == 'end'
+        counter -= 1
+      end
+    end
+    false
+  end
 end
 # :startdoc:

data/lib/irb/version.rb

@@ -11,7 +11,7 @@
 #
 
 module IRB # :nodoc:
-  VERSION = "1.3.6"
+  VERSION = "1.4.1"
   @RELEASE_VERSION = VERSION
-  @LAST_UPDATE_DATE = "2021-06-19"
+  @LAST_UPDATE_DATE = "2021-12-25"
 end

data/lib/irb/workspace.rb

@@ -12,6 +12,7 @@
 
 require "delegate"
 
+IRB::TOPLEVEL_BINDING = binding
 module IRB # :nodoc:
   class WorkSpace
     # Creates a new workspace.
@@ -57,6 +58,8 @@ EOF
                           __FILE__,
                           __LINE__ - 3)
         when 4  # binding is a copy of TOPLEVEL_BINDING (default)
+          # Note that this will typically be IRB::TOPLEVEL_BINDING
+          # This is to avoid RubyGems' local variables (see issue #17623)
           @binding = TOPLEVEL_BINDING.dup
         end
       end