irb 1.13.2 → 1.15.2

data/lib/irb/ruby-lex.rb

@@ -36,29 +36,6 @@ module IRB
       :massign,
     ]
 
-    class TerminateLineInput < StandardError
-      def initialize
-        super("Terminate Line Input")
-      end
-    end
-
-    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 -= 1
-        result = yield code, line_no
-      end
-      result
-    end
-
     ERROR_TOKENS = [
       :on_parse_error,
       :compile_error,
@@ -68,70 +45,102 @@ module IRB
       :on_param_error
     ]
 
-    def self.generate_local_variables_assign_code(local_variables)
-      "#{local_variables.join('=')}=nil;" unless local_variables.empty?
+    LTYPE_TOKENS = %i[
+      on_heredoc_beg on_tstring_beg
+      on_regexp_beg on_symbeg on_backtick
+      on_symbols_beg on_qsymbols_beg
+      on_words_beg on_qwords_beg
+    ]
+
+    class TerminateLineInput < StandardError
+      def initialize
+        super("Terminate Line Input")
+      end
     end
 
-    # Some part of the code is not included in Ripper's token.
-    # Example: DATA part, token after heredoc_beg when heredoc has unclosed embexpr.
-    # With interpolated tokens, tokens.map(&:tok).join will be equal to code.
-    def self.interpolate_ripper_ignored_tokens(code, tokens)
-      line_positions = [0]
-      code.lines.each do |line|
-        line_positions << line_positions.last + line.bytesize
+    class << self
+      def 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 -= 1
+          result = yield code, line_no
+        end
+        result
+      end
+
+      def generate_local_variables_assign_code(local_variables)
+        "#{local_variables.join('=')}=nil;" unless local_variables.empty?
       end
-      prev_byte_pos = 0
-      interpolated = []
-      prev_line = 1
-      tokens.each do |t|
-        line, col = t.pos
-        byte_pos = line_positions[line - 1] + col
-        if prev_byte_pos < byte_pos
-          tok = code.byteslice(prev_byte_pos...byte_pos)
+
+      # Some part of the code is not included in Ripper's token.
+      # Example: DATA part, token after heredoc_beg when heredoc has unclosed embexpr.
+      # With interpolated tokens, tokens.map(&:tok).join will be equal to code.
+      def interpolate_ripper_ignored_tokens(code, tokens)
+        line_positions = [0]
+        code.lines.each do |line|
+          line_positions << line_positions.last + line.bytesize
+        end
+        prev_byte_pos = 0
+        interpolated = []
+        prev_line = 1
+        tokens.each do |t|
+          line, col = t.pos
+          byte_pos = line_positions[line - 1] + col
+          if prev_byte_pos < byte_pos
+            tok = code.byteslice(prev_byte_pos...byte_pos)
+            pos = [prev_line, prev_byte_pos - line_positions[prev_line - 1]]
+            interpolated << Ripper::Lexer::Elem.new(pos, :on_ignored_by_ripper, tok, 0)
+            prev_line += tok.count("\n")
+          end
+          interpolated << t
+          prev_byte_pos = byte_pos + t.tok.bytesize
+          prev_line += t.tok.count("\n")
+        end
+        if prev_byte_pos < code.bytesize
+          tok = code.byteslice(prev_byte_pos..)
           pos = [prev_line, prev_byte_pos - line_positions[prev_line - 1]]
           interpolated << Ripper::Lexer::Elem.new(pos, :on_ignored_by_ripper, tok, 0)
-          prev_line += tok.count("\n")
         end
-        interpolated << t
-        prev_byte_pos = byte_pos + t.tok.bytesize
-        prev_line += t.tok.count("\n")
-      end
-      if prev_byte_pos < code.bytesize
-        tok = code.byteslice(prev_byte_pos..)
-        pos = [prev_line, prev_byte_pos - line_positions[prev_line - 1]]
-        interpolated << Ripper::Lexer::Elem.new(pos, :on_ignored_by_ripper, tok, 0)
+        interpolated
       end
-      interpolated
-    end
 
-    def self.ripper_lex_without_warning(code, local_variables: [])
-      verbose, $VERBOSE = $VERBOSE, nil
-      lvars_code = generate_local_variables_assign_code(local_variables)
-      original_code = code
-      if lvars_code
-        code = "#{lvars_code}\n#{code}"
-        line_no = 0
-      else
-        line_no = 1
-      end
+      def ripper_lex_without_warning(code, local_variables: [])
+        verbose, $VERBOSE = $VERBOSE, nil
+        lvars_code = generate_local_variables_assign_code(local_variables)
+        original_code = code
+        if lvars_code
+          code = "#{lvars_code}\n#{code}"
+          line_no = 0
+        else
+          line_no = 1
+        end
 
-      compile_with_errors_suppressed(code, line_no: line_no) do |inner_code, line_no|
-        lexer = Ripper::Lexer.new(inner_code, '-', line_no)
-        tokens = []
-        lexer.scan.each do |t|
-          next if t.pos.first == 0
-          prev_tk = tokens.last
-          position_overlapped = prev_tk && t.pos[0] == prev_tk.pos[0] && t.pos[1] < prev_tk.pos[1] + prev_tk.tok.bytesize
-          if position_overlapped
-            tokens[-1] = t if ERROR_TOKENS.include?(prev_tk.event) && !ERROR_TOKENS.include?(t.event)
-          else
-            tokens << t
+        compile_with_errors_suppressed(code, line_no: line_no) do |inner_code, line_no|
+          lexer = Ripper::Lexer.new(inner_code, '-', line_no)
+          tokens = []
+          lexer.scan.each do |t|
+            next if t.pos.first == 0
+            prev_tk = tokens.last
+            position_overlapped = prev_tk && t.pos[0] == prev_tk.pos[0] && t.pos[1] < prev_tk.pos[1] + prev_tk.tok.bytesize
+            if position_overlapped
+              tokens[-1] = t if ERROR_TOKENS.include?(prev_tk.event) && !ERROR_TOKENS.include?(t.event)
+            else
+              tokens << t
+            end
           end
+          interpolate_ripper_ignored_tokens(original_code, tokens)
         end
-        interpolate_ripper_ignored_tokens(original_code, tokens)
+      ensure
+        $VERBOSE = verbose
       end
-    ensure
-      $VERBOSE = verbose
     end
 
     def check_code_state(code, local_variables:)
@@ -391,13 +400,6 @@ module IRB
       end
     end
 
-    LTYPE_TOKENS = %i[
-      on_heredoc_beg on_tstring_beg
-      on_regexp_beg on_symbeg on_backtick
-      on_symbols_beg on_qsymbols_beg
-      on_words_beg on_qwords_beg
-    ]
-
     def ltype_from_open_tokens(opens)
       start_token = opens.reverse_each.find do |tok|
         LTYPE_TOKENS.include?(tok.event)

data/lib/irb/ruby_logo.aa

@@ -1,41 +1,41 @@
-TYPE: LARGE
+TYPE: ASCII_LARGE
 
-                                             -+smJYYN?mm-
-                                   HB"BBYT            TQg  NggT
-                              9Q+g       Nm,T      8g          NJW
-                          YS+              N2NJ"Sg               N?
-                       BQg                  #(  gT Nggggk          J
-                     5j                     NJ    NJ            NNge
-                  #Q                        #JJ     NgT            N(
-                @j                          bj         mT           J
-              Bj                           @/d           NJ         (
-            #q                            #((              NgT     #J
-           5d                            #(t                  mT   $d
-         #q                             @(@J                    NJB;
-        @(                             5d ? HHH H HQmgggggggmN    qD
-       5d                            #uN  2QdH                   E O
-      5                             5JSd  Nd  NJH               @d j
-     Fd                           @J4d     s     NQH           #d  (
-    #(                          #o6d       Nd       NgH       #d  #d
-    4                         B&Od          v          NgT   #d   F
-   #(                       9JGd            NH            NgUd    F
-   #d                    #GJQ                d             NP     $
-   #J                 #U+#Q                  N            Q #     j
-  j /W             BQ+ BQ                     d             NJ   NJ
-  - NjJH      HBIjTQggPJQgW                   N        W     k   #J
- #J  b  HYWgggN       j s    Nag               d     NN      b   #d
- #J  5-              D   s         Ngg         N    d        Nd  F
- Fd BKH2            #+    s             NNgg    J Q           J  ]
- F H @  J           N      y                   K(d            P  I
- F4  E  N?         #d       y                #Q   NJ          E  j
- F   W   Nd        q         m             Bg       NxW       N(H-
- F   d    b       @           m          Hd            gW      vKJ
- NJ  d     K      d            s      Bg                 aT    FDd
-  b #       d    N              m  BQ                      mV  N>
-   e5       Nd  #d              NggggggQWH HHHH              NJ -
-    m7       NW H            N                        HSVO1z=?11-
-      NgTH    bB        kH   WBHWWHBHWmQgg&gggggNNN
-           NNggggggNN
+                                     ,,,;;;;;;;;;;;;;;;;;;;;;;,,
+                                ,,,;;;;;;;;;,,        ,;;;'  ''';;,
+                            ,,;;;'''       ';;;,  ,,;;''         '';,
+                         ,;;''               ;;;;;;;;,,,,,,        ';;
+                      ,;;''                  ;;;;';;;'''';;;;;;;;;,,,;;
+                   ,,;''                     ;;;;   ';;,        ''''';;,
+                 ,;;'                        ;;;'     ';;,            ;;
+               ,;;'                         ,;;;        '';,,         ;;
+             ,;;'                           ;;;            ';;,      ,;;
+            ;;'                            ;;;'              '';,,   ;;;
+          ,;'                             ;;;;                  ';;, ;;'
+        ,;;'                            ,;;;;'        ,,,,,,,,,,,,;;;;;
+       ,;'                             ,;;;;;;;;;;;;;;;;;;;;'''''''';;;
+      ;;'                            ,;;;;;;;;;,,                  ;;;;
+     ;;'                            ,;;;'' ;;, ';;,,              ,;;;;
+    ;;'                           ,;;;'     ;;    '';;,          ,;';;;
+   ;;'                          ,;;;'       ;;,      '';;,,     ,;',;;;
+ ,;;;                         ,;;;'          ;;         '';;,, ,;' ;;;'
+ ;;;;                      ,,;;;'            ;;,            ';;;'  ;;;
+,;;;                     ,;;;;'               ;;            ,;;;   ;;;
+;;;;;                ,,;;;;;'                 ;;,          ,;';;   ;;;
+;;;;;,           ,,;;;;;;;'                    ;;        ,;;' ;;;  ;;;
+;;;;;;;,,,,,,,;;;;;;;;;;;;;;,,,                ;;,      ,;'    ;;  ;;;
+;;' ;;;;;;;;;;''''   ,;';; ''';;;;,,,           ;;    ,;;      ;;  ;;;
+;;  ;;;''            ;; ';;      ''';;;;,,,,    ;;, ,;;'       ;;, ;;
+;; ;;;;,            ;;'  ';;            ''';;;;,,;;;;'         ';; ;;
+;;;;;;';,          ,;;     ;;                 '';;;;,           ;;,;;
+;;; ;; ;;,         ;;       ;;                ,;;' ';;,         ;;;;;
+;; ;;;  ;;,       ;;'        ;;            ,,;''     ';;,       ;;;;;
+;; ;;    ;;       ;;          ;;         ,;;'          '';,      ;;;;
+;;,;;     ;;     ;;'           ;;     ,;;''               ';,,   ;;;'
+ ;;;;     ';;   ,;;             ;;,,;;''                    ';;, ;;;
+ ';;;      ';;  ;;             ,;;;;;;;;;;;;;,,,,,,,,,,,,     ';;;;;
+   ';,      ';,;;'        ,,,;;''        '''''''';;;;;;;;;;;;;;;;;;;
+     ';;,,,  ;;;;  ,,,,;;;;;;,,,,,;;;;;;;;;;;;;;;;;;;''''''''''''''
+       ''';;;;;;;;;;;;;;'''''''''''''''
 TYPE: ASCII
                   ,,,;;;;''''';;;'';,
               ,,;''     ';;,;;;      ',
@@ -57,6 +57,44 @@ TYPE: ASCII
 ;;;  ';  ;'      ';,,''          ';,;;
  ';   ';,;     ,,;''''''''';;;;;;,,;;;
    ';,,;;,,;;;;;;;;;;''''''''''''''
+TYPE: UNICODE_LARGE
+
+                                     ⣀⣤⣴⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣤⣄⡀
+                               ⢀⣀⣤⣴⣾⣿⣿⣿⠿⣿⣿⣿⣿⣦⣀       ⢀⣤⣶⣿⠿⠛⠁⠈⠉⠙⠻⢿⣷⣦⡀
+                           ⢀⣠⣴⣾⡿⠿⠛⠉⠉      ⠈⠙⢿⣿⣷⣤⡀ ⣠⣴⣾⡿⠟⠉         ⠉⠻⣿⣦
+                        ⢀⣤⣶⣿⠟⠋⠁              ⢿⣿⣿⣿⣿⣿⣿⣧⣤⣤⣤⣀⣀⣀⡀       ⠘⢿⣷⡀
+                     ⢀⣠⣾⡿⠟⠉                  ⢸⣿⣿⣿⠟⢿⣿⣯⡙⠛⠛⠛⠿⠿⠿⢿⣿⣿⣶⣶⣶⣦⣤⣬⣿⣧
+                   ⣠⣴⣿⠟⠋                     ⢸⣿⣿⡿  ⠈⠻⣿⣶⣄        ⠉⠉⠉⠙⠛⢻⣿⡆
+                 ⣠⣾⡿⠛⠁                       ⣼⣿⣿⠃    ⠈⠙⢿⣷⣤⡀          ⠈⣿⡇
+               ⣠⣾⡿⠋                         ⢠⣿⣿⡏        ⠙⠻⣿⣦⣀         ⣿⡇
+             ⣠⣾⡿⠋                          ⢀⣿⣿⣿           ⠈⠛⢿⣷⣄⡀     ⢠⣿⡇
+           ⢀⣾⡿⠋                           ⢀⣾⣿⣿⠇              ⠙⠻⣿⣦⣀   ⢸⣿⡇
+         ⢀⣴⣿⠟⠁                           ⢀⣾⣿⣿⡟                 ⠈⠻⢿⣷⣄ ⣾⣿⠇
+        ⢠⣾⡿⠃                            ⣠⣿⣿⣿⣿⠃        ⣀⣀⣀⣀⣀⣀⣀⣀⣤⣤⣤⣤⣽⣿⣿⣿⣿
+       ⣰⣿⠟                             ⣴⣿⣿⣿⣿⣿⣶⣶⣿⣿⣿⣿⣿⠿⠿⠿⠿⠿⠿⠿⠿⠛⠛⠛⠛⠛⠛⠛⠛⣿⣿⣿
+      ⣼⣿⠏                            ⢠⣾⣿⣿⣿⡿⣿⣿⢿⣷⣦⣄                  ⣼⣿⣿⣿
+     ⣼⣿⠃                           ⢀⣴⣿⣿⣿⠟⠋ ⢸⣿⡆⠈⠛⠿⣿⣦⣄⡀             ⣰⣿⣿⣿⡇
+   ⢀⣾⣿⠃                          ⢀⣴⣿⣿⣿⠟⠁    ⣿⣷   ⠈⠙⠻⣿⣶⣄⡀         ⣰⣿⠟⣿⣿⡇
+  ⢀⣾⣿⠇                         ⢀⣴⣿⣿⣿⠟⠁      ⢸⣿⡆      ⠙⠻⢿⣷⣤⣀     ⣰⣿⠏⢠⣿⣿⡇
+ ⢠⣿⣿⡟                        ⢀⣴⣿⣿⡿⠛⠁         ⣿⣷         ⠉⠻⢿⣷⣦⣀ ⣴⣿⠏ ⢸⣿⣿⠃
+ ⣿⣿⣿⡇                      ⣠⣴⣿⣿⡿⠋            ⢸⣿⡆           ⠈⠛⢿⣿⣿⠃  ⢸⣿⣿
+⢠⣿⣿⣿                    ⢀⣴⣾⣿⣿⡿⠋              ⠈⣿⣧            ⢠⣾⣿⣿   ⢸⣿⣿
+⢸⣿⣿⣿⡇                ⣀⣴⣾⣿⣿⣿⡿⠋                 ⢹⣿⡆          ⣴⣿⠟⢹⣿⡀  ⢸⣿⡿
+⢸⣿⡟⣿⣿⣄           ⣀⣤⣶⣿⣿⣿⣿⣿⡟⠉                   ⠈⣿⣷        ⢠⣾⡿⠋ ⢸⣿⡇  ⣼⣿⡇
+⢸⣿⡇⢹⣿⣿⣷⣦⣤⣤⣤⣤⣤⣴⣶⣾⣿⣿⣿⣿⡿⠿⣿⣿⣿⣿⣷⣶⣤⣤⣀⡀               ⢹⣿⡆     ⢀⣴⣿⠟    ⣿⣧  ⣿⣿⡇
+⢸⣿⠃ ⢿⣿⣿⣿⣿⣿⣿⡿⠿⠿⠛⠛⠉⠉⠁  ⢰⣿⠟⣿⣷⡀⠉⠙⠛⠿⢿⣿⣶⣦⣤⣀⡀         ⠈⣿⣷    ⣠⣿⡿⠁     ⢿⣿  ⣿⣿⡇
+⢸⣿ ⢀⣾⣿⣿⠋⠉⠁          ⢀⣿⡿ ⠘⣿⣷⡀     ⠉⠙⠛⠿⠿⣿⣶⣦⣤⣄⣀    ⢹⣿⡄ ⣠⣾⡿⠋       ⢸⣿⡆ ⣿⣿
+⣸⣿⢀⣾⣿⣿⣿⣆            ⣸⣿⠃  ⠘⢿⣷⡀          ⠈⠉⠛⠻⠿⣿⣷⣶⣤⣌⣿⣷⣾⡿⠋         ⠘⣿⡇ ⣿⣿
+⣿⣿⣾⡿⣿⡿⠹⣿⡆          ⢠⣿⡏    ⠈⢿⣷⡀               ⠈⠉⠙⣻⣿⣿⣿⣀           ⣿⣷⢰⣿⣿
+⣿⣿⡿⢁⣿⡇ ⢻⣿⡄         ⣾⣿      ⠈⢿⣷⡀              ⢀⣤⣾⡿⠋⠈⠻⢿⣷⣄         ⢻⣿⢸⣿⡟
+⣿⣿⠁⢸⣿⡇  ⢻⣿⡄       ⢸⣿⠇       ⠈⢿⣷⡀           ⣀⣴⣿⠟⠋     ⠙⢿⣷⣤⡀      ⢸⣿⣿⣿⡇
+⣿⣿ ⢸⣿⠁  ⠈⢿⣷⡀     ⢀⣿⡟         ⠈⢿⣷⡀       ⢀⣤⣾⡿⠛⠁         ⠙⠻⣿⣦⡀    ⠈⣿⣿⣿⡇
+⢸⣿⡄⣿⣿    ⠈⣿⣷⡀    ⣼⣿⠃          ⠈⢿⣷⡀   ⢀⣠⣶⣿⠟⠋              ⠈⠻⣿⣦⣄   ⣿⣿⣿⠇
+⠈⣿⣷⣿⡿     ⠘⣿⣧   ⢠⣿⡏            ⠈⢿⣷⣄⣤⣶⣿⠟⠋                   ⠈⠛⢿⣷⣄ ⢸⣿⣿
+ ⠘⣿⣿⡇      ⠘⣿⣧  ⣾⣿            ⢀⣠⣼⣿⣿⣿⣿⣿⣷⣶⣶⣶⣶⣶⣶⣤⣤⣤⣤⣤⣤⣀⣀⣀⣀⣀⣀⡀    ⠙⢿⣷⣼⣿⣿
+  ⠈⠻⣿⣦⡀     ⠹⣿⣆⢸⣿⠇        ⣀⣠⣴⣾⡿⠟⠋⠁       ⠉⠉⠉⠉⠉⠉⠛⠛⣛⣛⣛⣻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣿⣿⣿⡿
+    ⠈⠻⢿⣷⣦⣄⣀⡀ ⢹⣿⣿⡟ ⢀⣀⣀⣤⣤⣶⣾⣿⣿⣿⣯⣥⣤⣤⣤⣤⣶⣶⣶⣶⣶⣶⣶⣾⣿⣿⣿⣿⠿⠿⠿⠿⠿⠿⠿⠟⠛⠛⠛⠛⠛⠛⠛⠉⠉⠉⠉⠉⠉
+       ⠉⠙⠛⠿⠿⠿⣿⣿⣿⣿⠿⠿⠿⠿⠿⠿⠿⠛⠛⠛⠛⠛⠛⠛⠋⠉⠉⠉⠉⠉⠉⠉
 TYPE: UNICODE
                   ⣀⣤⣴⣾⣿⣿⣿⡛⠛⠛⠛⠛⣻⣿⠿⠛⠛⠶⣤⡀
               ⣀⣴⠾⠛⠉⠁    ⠙⣿⣶⣤⣶⣟⣉     ⠈⠻⣦

data/lib/irb/source_finder.rb

@@ -100,7 +100,7 @@ module IRB
         Source.new(file, line)
       elsif method
         # Method defined with eval, probably in IRB session
-        source = RubyVM::AbstractSyntaxTree.of(method)&.source rescue nil
+        source = RubyVM::InstructionSequence.of(method)&.script_lines&.join rescue nil
         Source.new(file, line, source)
       end
     rescue EvaluationError
@@ -125,9 +125,8 @@ module IRB
     end
 
     def eval_receiver_or_owner(code)
-      context_binding = @irb_context.workspace.binding
-      eval(code, context_binding)
-    rescue NameError
+      @irb_context.workspace.binding.eval(code)
+    rescue Exception
       raise EvaluationError
     end
 

data/lib/irb/statement.rb

@@ -54,6 +54,27 @@ module IRB
       end
     end
 
+    class IncorrectAlias < Statement
+      attr_reader :message
+
+      def initialize(message)
+        @code = ""
+        @message = message
+      end
+
+      def should_be_handled_by_debugger?
+        false
+      end
+
+      def is_assignment?
+        false
+      end
+
+      def suppresses_echo?
+        true
+      end
+    end
+
     class Command < Statement
       attr_reader :command_class, :arg
 
@@ -68,7 +89,7 @@ module IRB
       end
 
       def suppresses_echo?
-        false
+        true
       end
 
       def should_be_handled_by_debugger?

data/lib/irb/version.rb

@@ -5,7 +5,7 @@
 #
 
 module IRB # :nodoc:
-  VERSION = "1.13.2"
+  VERSION = "1.15.2"
   @RELEASE_VERSION = VERSION
-  @LAST_UPDATE_DATE = "2024-06-15"
+  @LAST_UPDATE_DATE = "2025-04-03"
 end

data/lib/irb/workspace.rb

@@ -4,8 +4,6 @@
 #   	by Keiju ISHITSUKA(keiju@ruby-lang.org)
 #
 
-require "delegate"
-
 require_relative "helper_method"
 
 IRB::TOPLEVEL_BINDING = binding
@@ -16,7 +14,7 @@ module IRB # :nodoc:
     # set self to main if specified, otherwise
     # inherit main from TOPLEVEL_BINDING.
     def initialize(*main)
-      if main[0].kind_of?(Binding)
+      if Binding === main[0]
         @binding = main.shift
       elsif IRB.conf[:SINGLE_IRB]
         @binding = TOPLEVEL_BINDING
@@ -70,37 +68,16 @@ EOF
       unless main.empty?
         case @main
         when Module
-          @binding = eval("IRB.conf[:__MAIN__].module_eval('binding', __FILE__, __LINE__)", @binding, __FILE__, __LINE__)
+          @binding = eval("::IRB.conf[:__MAIN__].module_eval('::Kernel.binding', __FILE__, __LINE__)", @binding, __FILE__, __LINE__)
         else
           begin
-            @binding = eval("IRB.conf[:__MAIN__].instance_eval('binding', __FILE__, __LINE__)", @binding, __FILE__, __LINE__)
+            @binding = eval("::IRB.conf[:__MAIN__].instance_eval('::Kernel.binding', __FILE__, __LINE__)", @binding, __FILE__, __LINE__)
           rescue TypeError
             fail CantChangeBinding, @main.inspect
           end
         end
       end
 
-      case @main
-      when Object
-        use_delegator = @main.frozen?
-      else
-        use_delegator = true
-      end
-
-      if use_delegator
-        @main = SimpleDelegator.new(@main)
-        IRB.conf[:__MAIN__] = @main
-        @main.singleton_class.class_eval do
-          private
-          define_method(:binding, Kernel.instance_method(:binding))
-          define_method(:local_variables, Kernel.instance_method(:local_variables))
-          # Define empty method to avoid delegator warning, will be overridden.
-          define_method(:exit) {|*a, &b| }
-          define_method(:exit!) {|*a, &b| }
-        end
-        @binding = eval("IRB.conf[:__MAIN__].instance_eval('binding', __FILE__, __LINE__)", @binding, *@binding.source_location)
-      end
-
       @binding.local_variable_set(:_, nil)
     end
 
@@ -111,6 +88,9 @@ EOF
     attr_reader :main
 
     def load_helper_methods_to_main
+      # Do not load helper methods to frozen objects and BasicObject
+      return unless Object === @main && !@main.frozen?
+
       ancestors = class<<main;ancestors;end
       main.extend ExtendCommandBundle if !ancestors.include?(ExtendCommandBundle)
       main.extend HelpersContainer if !ancestors.include?(HelpersContainer)
@@ -176,11 +156,13 @@ EOF
   end
 
   module HelpersContainer
-    def self.install_helper_methods
-      HelperMethod.helper_methods.each do |name, helper_method_class|
-        define_method name do |*args, **opts, &block|
-          helper_method_class.instance.execute(*args, **opts, &block)
-        end unless method_defined?(name)
+    class << self
+      def install_helper_methods
+        HelperMethod.helper_methods.each do |name, helper_method_class|
+          define_method name do |*args, **opts, &block|
+            helper_method_class.instance.execute(*args, **opts, &block)
+          end unless method_defined?(name)
+        end
       end
     end