irb 1.9.1 → 1.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ed98e2ce49cea18e608a64f8e5f5e310064a373b944de0474d49e21613b5be6
-  data.tar.gz: 679dea24c5f90242c1f0f427b42bc0d90caafb6ad8ec73da6d11181bb5645f9f
+  metadata.gz: ce85a9eb69af7fbbb8cb41a6d34029502d2b6712d916b7a3823176e2769cdcf8
+  data.tar.gz: 711b52081eb0a97eee4901844b33e8cf9657316c8dde29c9eeb41d3a6998f78e
 SHA512:
-  metadata.gz: 41a6d57dc51eb6d17c6aa3c7a635d576d4d21d3e5b6eab92becb3862060fae0fdbd34cc0975bca219a7cc6c5808657b417f5aae1dc9606649fe4f82bcce8c467
-  data.tar.gz: d7499712f5310d00f6a47b8581749c1e34a69fe3984cb3efbe9d1ce1825d65dcfd471e17831cee56ca3dda7d0a17cabc5b36f6511f151c1b7472b9042e9c173f
+  metadata.gz: 300f29f4e769be7ede8371fc7f667fb543eb7d8dd9249b062993074c2bdbb5808a3322cb4bb6a0ff58bd79c2d6e82a3bbac0f78b6a117e0095c63fbfe9431fb8
+  data.tar.gz: 997b64b19a2902c6a9bc47ee4aff909b133f13e829456cc4fe4cf33b6ca425c8619f58ffda7be71bdd3dde1b91e2d23ba24bad9e9045b612fc190e6ac3fa42e7

data/Gemfile

@@ -16,9 +16,9 @@ gem "reline", github: "ruby/reline" if ENV["WITH_LATEST_RELINE"] == "true"
 gem "rake"
 gem "test-unit"
 gem "test-unit-ruby-core"
-gem "debug", github: "ruby/debug"
 
-if RUBY_VERSION >= "3.0.0"
-  gem "rbs"
-  gem "prism", ">= 0.17.1"
+gem "debug", github: "ruby/debug", platforms: [:mri, :mswin]
+
+if RUBY_VERSION >= "3.0.0" && !is_truffleruby
+  gem "repl_type_completor"
 end

data/README.md

@@ -119,6 +119,7 @@ IRB
   source         Loads a given file in the current session.
   irb_info       Show information about IRB.
   show_cmds      List all available commands and their description.
+  history        Shows the input history. `-g [query]` or `-G [query]` allows you to filter the output.
 
 Multi-irb (DEPRECATED)
   irb            Start a child IRB.
@@ -237,11 +238,11 @@ However, there are also some limitations to be aware of:
 
 ## Type Based Completion
 
-IRB's default completion `IRB::RegexpCompletor` uses Regexp. IRB has another experimental completion `IRB::TypeCompletion` that uses type analysis.
+IRB's default completion `IRB::RegexpCompletor` uses Regexp. IRB has another experimental completion `IRB::TypeCompletor` that uses type analysis.
 
-### How to Enable IRB::TypeCompletion
+### How to Enable IRB::TypeCompletor
 
-To enable IRB::TypeCompletion, run IRB with `--type-completor` option
+To enable IRB::TypeCompletor, run IRB with `--type-completor` option
 ```
 $ irb --type-completor
 ```
@@ -249,14 +250,14 @@ Or write the code below to IRB's rc-file.
 ```ruby
 IRB.conf[:COMPLETOR] = :type # default is :regexp
 ```
-You also need `gem prism` and `gem rbs` to use this feature.
+You also need `gem repl_type_completor` to use this feature.
 
 To check if it's enabled, type `irb_info` into IRB and see the `Completion` section.
 ```
 irb(main):001> irb_info
 ...
 # Enabled
-Completion: Autocomplete, TypeCompletion::Completor(Prism: 0.17.1, RBS: 3.3.0)
+Completion: Autocomplete, ReplTypeCompletor: 0.1.0, Prism: 0.18.0, RBS: 3.3.0
 # Not enabled
 Completion: Autocomplete, RegexpCompletor
 ...
@@ -265,7 +266,7 @@ If you have `sig/` directory or `rbs_collection.lock.yaml` in current directory,
 
 ### Advantage over Default IRB::RegexpCompletor
 
-IRB::TypeCompletion can autocomplete chained methods, block parameters and more if type information is available.
+IRB::TypeCompletor can autocomplete chained methods, block parameters and more if type information is available.
 These are some examples IRB::RegexpCompletor cannot complete.
 
 ```ruby
@@ -287,11 +288,11 @@ As a trade-off, completion calculation takes more time than IRB::RegexpCompletor
 
 ### Difference between Steep's Completion
 
-Compared with Steep, IRB::TypeCompletion has some difference and limitations.
+Compared with Steep, IRB::TypeCompletor has some difference and limitations.
 ```ruby
 [0, 'a'].sample.
 # Steep completes intersection of Integer methods and String methods
-# IRB::TypeCompletion completes both Integer and String methods
+# IRB::TypeCompletor completes both Integer and String methods
 ```
 
 Some features like type narrowing is not implemented.
@@ -301,7 +302,7 @@ def f(arg = [0, 'a'].sample)
     arg. # Completes both Integer and String methods
 ```
 
-Unlike other static type checker, IRB::TypeCompletion uses runtime information to provide better completion.
+Unlike other static type checker, IRB::TypeCompletor uses runtime information to provide better completion.
 ```ruby
 irb(main):001> a = [1]
 => [1]

data/Rakefile

@@ -5,7 +5,7 @@ Rake::TestTask.new(:test) do |t|
   t.libs << "test" << "test/lib"
   t.libs << "lib"
   t.ruby_opts << "-rhelper"
-  t.test_files = FileList["test/irb/test_*.rb", "test/irb/type_completion/test_*.rb"]
+  t.test_files = FileList["test/irb/**/test_*.rb"]
 end
 
 # To make sure they have been correctly setup for Ruby CI.
@@ -13,7 +13,7 @@ desc "Run each irb test file in isolation."
 task :test_in_isolation do
   failed = false
 
-  FileList["test/irb/test_*.rb", "test/irb/type_completion/test_*.rb"].each do |test_file|
+  FileList["test/irb/**/test_*.rb"].each do |test_file|
     ENV["TEST"] = test_file
     begin
       Rake::Task["test"].execute

data/lib/irb/cmd/history.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "nop"
+require_relative "../pager"
+
+module IRB
+  # :stopdoc:
+
+  module ExtendCommand
+    class History < Nop
+      category "IRB"
+      description "Shows the input history. `-g [query]` or `-G [query]` allows you to filter the output."
+
+      def self.transform_args(args)
+        match = args&.match(/(-g|-G)\s+(?<grep>.+)\s*\n\z/)
+        return unless match
+
+        "grep: #{Regexp.new(match[:grep]).inspect}"
+      end
+
+      def execute(grep: nil)
+        formatted_inputs = irb_context.io.class::HISTORY.each_with_index.reverse_each.filter_map do |input, index|
+          next if grep && !input.match?(grep)
+
+          header = "#{index}: "
+
+          first_line, *other_lines = input.split("\n")
+          first_line = "#{header}#{first_line}"
+
+          truncated_lines = other_lines.slice!(1..) # Show 1 additional line (2 total)
+          other_lines << "..." if truncated_lines&.any?
+
+          other_lines.map! do |line|
+            " " * header.length + line
+          end
+
+          [first_line, *other_lines].join("\n") + "\n"
+        end
+
+        Pager.page_content(formatted_inputs.join)
+      end
+    end
+  end
+
+  # :startdoc:
+end

data/lib/irb/cmd/show_cmds.rb

@@ -16,6 +16,12 @@ module IRB
         commands_info = IRB::ExtendCommandBundle.all_commands_info
         commands_grouped_by_categories = commands_info.group_by { |cmd| cmd[:category] }
 
+        user_aliases = irb_context.instance_variable_get(:@user_aliases)
+
+        commands_grouped_by_categories["Aliases"] = user_aliases.map do |alias_name, target|
+          { display_name: alias_name, description: "Alias for `#{target}`" }
+        end
+
         if irb_context.with_debugger
           # Remove the original "Debugging" category
           commands_grouped_by_categories.delete("Debugging")

data/lib/irb/cmd/show_source.rb

@@ -27,11 +27,18 @@ module IRB
           puts "Error: Expected a string but got #{str.inspect}"
           return
         end
-
-        source = SourceFinder.new(@irb_context).find_source(str)
+        if str.include? " -s"
+          str, esses = str.split(" -")
+          s_count = esses.count("^s").zero? ? esses.size : 1
+          source = SourceFinder.new(@irb_context).find_source(str, s_count)
+        else
+          source = SourceFinder.new(@irb_context).find_source(str)
+        end
 
         if source
           show_source(source)
+        elsif s_count
+          puts "Error: Couldn't locate a super definition for #{str}"
         else
           puts "Error: Couldn't locate a definition for #{str}"
         end

data/lib/irb/completion.rb

@@ -93,6 +93,27 @@ module IRB
     end
   end
 
+  class TypeCompletor < BaseCompletor # :nodoc:
+    def initialize(context)
+      @context = context
+    end
+
+    def inspect
+      ReplTypeCompletor.info
+    end
+
+    def completion_candidates(preposing, target, _postposing, bind:)
+      result = ReplTypeCompletor.analyze(preposing + target, binding: bind, filename: @context.irb_path)
+      return [] unless result
+      result.completion_candidates.map { target + _1 }
+    end
+
+    def doc_namespace(preposing, matched, _postposing, bind:)
+      result = ReplTypeCompletor.analyze(preposing + matched, binding: bind, filename: @context.irb_path)
+      result&.doc_namespace('')
+    end
+  end
+
   class RegexpCompletor < BaseCompletor # :nodoc:
     using Module.new {
       refine ::Binding do

data/lib/irb/context.rb

@@ -146,9 +146,21 @@ module IRB
         @newline_before_multiline_output = true
       end
 
-      @command_aliases = IRB.conf[:COMMAND_ALIASES]
+      @user_aliases = IRB.conf[:COMMAND_ALIASES].dup
+      @command_aliases = @user_aliases.merge(KEYWORD_ALIASES)
     end
 
+    # because all input will eventually be evaluated as Ruby code,
+    # command names that conflict with Ruby keywords need special workaround
+    # we can remove them once we implemented a better command system for IRB
+    KEYWORD_ALIASES = {
+      :break => :irb_break,
+      :catch => :irb_catch,
+      :next => :irb_next,
+    }.freeze
+
+    private_constant :KEYWORD_ALIASES
+
     private def build_completor
       completor_type = IRB.conf[:COMPLETOR]
       case completor_type
@@ -164,26 +176,22 @@ module IRB
       RegexpCompletor.new
     end
 
-    TYPE_COMPLETION_REQUIRED_PRISM_VERSION = '0.17.1'
-
     private def build_type_completor
-      unless Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0') && RUBY_ENGINE != 'truffleruby'
-        warn 'TypeCompletion requires RUBY_VERSION >= 3.0.0'
+      if RUBY_ENGINE == 'truffleruby'
+        # Avoid SynatxError. truffleruby does not support endless method definition yet.
+        warn 'TypeCompletor is not supported on TruffleRuby yet'
         return
       end
+
       begin
-        require 'prism'
+        require 'repl_type_completor'
       rescue LoadError => e
-        warn "TypeCompletion requires Prism: #{e.message}"
+        warn "TypeCompletor requires `gem repl_type_completor`: #{e.message}"
         return
       end
-      unless Gem::Version.new(Prism::VERSION) >= Gem::Version.new(TYPE_COMPLETION_REQUIRED_PRISM_VERSION)
-        warn "TypeCompletion requires Prism::VERSION >= #{TYPE_COMPLETION_REQUIRED_PRISM_VERSION}"
-        return
-      end
-      require 'irb/type_completion/completor'
-      TypeCompletion::Types.preload_in_thread
-      TypeCompletion::Completor.new
+
+      ReplTypeCompletor.preload_rbs
+      TypeCompletor.new(self)
     end
 
     def save_history=(val)

data/lib/irb/debug.rb

@@ -57,6 +57,24 @@ module IRB
           DEBUGGER__::ThreadClient.prepend(SkipPathHelperForIRB)
         end
 
+        if !@output_modifier_defined && !DEBUGGER__::CONFIG[:no_hint]
+          irb_output_modifier_proc = Reline.output_modifier_proc
+
+          Reline.output_modifier_proc = proc do |output, complete:|
+            unless output.strip.empty?
+              cmd = output.split(/\s/, 2).first
+
+              if !complete && DEBUGGER__.commands.key?(cmd)
+                output = output.sub(/\n$/, " # debug command\n")
+              end
+            end
+
+            irb_output_modifier_proc.call(output, complete: complete)
+          end
+
+          @output_modifier_defined = true
+        end
+
         true
       end
 

data/lib/irb/extend-command.rb

@@ -191,6 +191,12 @@ module IRB # :nodoc:
       [
         :irb_show_cmds, :ShowCmds, "cmd/show_cmds",
         [:show_cmds, NO_OVERRIDE],
+      ],
+
+      [
+        :irb_history, :History, "cmd/history",
+        [:history, NO_OVERRIDE],
+        [:hist, NO_OVERRIDE],
       ]
     ]
 

data/lib/irb/history.rb

@@ -60,7 +60,7 @@ module IRB
         end
 
         File.open(history_file, (append_history ? 'a' : 'w'), 0o600, encoding: IRB.conf[:LC_MESSAGES]&.encoding) do |f|
-          hist = history.map{ |l| l.split("\n").join("\\\n") }
+          hist = history.map{ |l| l.scrub.split("\n").join("\\\n") }
           unless append_history
             begin
               hist = hist.last(num) if hist.size > num and num > 0

data/lib/irb/init.rb

@@ -82,6 +82,7 @@ module IRB # :nodoc:
     @CONF[:USE_LOADER] = false
     @CONF[:IGNORE_SIGINT] = true
     @CONF[:IGNORE_EOF] = false
+    @CONF[:USE_PAGER] = true
     @CONF[:EXTRA_DOC_DIRS] = []
     @CONF[:ECHO] = nil
     @CONF[:ECHO_ON_ASSIGNMENT] = nil
@@ -188,10 +189,6 @@ module IRB # :nodoc:
       # Symbol aliases
       :'$' => :show_source,
       :'@' => :whereami,
-      # Keyword aliases
-      :break => :irb_break,
-      :catch => :irb_catch,
-      :next => :irb_next,
     }
   end
 
@@ -285,6 +282,8 @@ module IRB # :nodoc:
         end
       when "--noinspect"
         @CONF[:INSPECT_MODE] = false
+      when "--no-pager"
+        @CONF[:USE_PAGER] = false
       when "--singleline", "--readline", "--legacy"
         @CONF[:USE_SINGLELINE] = true
       when "--nosingleline", "--noreadline"

data/lib/irb/lc/help-message

@@ -22,6 +22,7 @@ Usage:  irb.rb [options] [programfile] [arguments]
                     Show truncated result on assignment (default).
   --inspect         Use 'inspect' for output.
   --noinspect       Don't use 'inspect' for output.
+  --no-pager        Don't use pager.
   --multiline       Use multiline editor module (default).
   --nomultiline     Don't use multiline editor module.
   --singleline      Use single line editor module.

data/lib/irb/pager.rb

@@ -7,9 +7,9 @@ module IRB
     PAGE_COMMANDS = [ENV['RI_PAGER'], ENV['PAGER'], 'less', 'more'].compact.uniq
 
     class << self
-      def page_content(content)
+      def page_content(content, **options)
         if content_exceeds_screen_height?(content)
-          page do |io|
+          page(**options) do |io|
             io.puts content
           end
         else
@@ -17,8 +17,8 @@ module IRB
         end
       end
 
-      def page
-        if STDIN.tty? && pager = setup_pager
+      def page(retain_content: false)
+        if should_page? && pager = setup_pager(retain_content: retain_content)
           begin
             pid = pager.pid
             yield pager
@@ -40,6 +40,10 @@ module IRB
 
       private
 
+      def should_page?
+        IRB.conf[:USE_PAGER] && STDIN.tty? && (ENV.key?("TERM") && ENV["TERM"] != "dumb")
+      end
+
       def content_exceeds_screen_height?(content)
         screen_height, screen_width = begin
           Reline.get_screen_size
@@ -55,19 +59,20 @@ module IRB
           pageable_height * screen_width < Reline::Unicode.calculate_width(content, true)
       end
 
-      def setup_pager
+      def setup_pager(retain_content:)
         require 'shellwords'
 
-        PAGE_COMMANDS.each do |pager|
-          pager = Shellwords.split(pager)
-          next if pager.empty?
+        PAGE_COMMANDS.each do |pager_cmd|
+          cmd = Shellwords.split(pager_cmd)
+          next if cmd.empty?
 
-          if pager.first == 'less' || pager.first == 'more'
-            pager << '-R' unless pager.include?('-R')
+          if cmd.first == 'less'
+            cmd << '-R' unless cmd.include?('-R')
+            cmd << '-X' if retain_content && !cmd.include?('-X')
           end
 
           begin
-            io = IO.popen(pager, 'w')
+            io = IO.popen(cmd, 'w')
           rescue
             next
           end

data/lib/irb/source_finder.rb

@@ -16,7 +16,7 @@ module IRB
       @irb_context = irb_context
     end
 
-    def find_source(signature)
+    def find_source(signature, s_count = nil)
       context_binding = @irb_context.workspace.binding
       case signature
       when /\A[A-Z]\w*(::[A-Z]\w*)*\z/ # Const::Name
@@ -26,14 +26,13 @@ module IRB
       when /\A(?<owner>[A-Z]\w*(::[A-Z]\w*)*)#(?<method>[^ :.]+)\z/ # Class#method
         owner = eval(Regexp.last_match[:owner], context_binding)
         method = Regexp.last_match[:method]
-        if owner.respond_to?(:instance_method)
-          methods = owner.instance_methods + owner.private_instance_methods
-          file, line = owner.instance_method(method).source_location if methods.include?(method.to_sym)
-        end
+        return unless owner.respond_to?(:instance_method)
+        file, line = method_target(owner, s_count, method, "owner")
       when /\A((?<receiver>.+)(\.|::))?(?<method>[^ :.]+)\z/ # method, receiver.method, receiver::method
         receiver = eval(Regexp.last_match[:receiver] || 'self', context_binding)
         method = Regexp.last_match[:method]
-        file, line = receiver.method(method).source_location if receiver.respond_to?(method, true)
+        return unless receiver.respond_to?(method, true)
+        file, line = method_target(receiver, s_count, method, "receiver")
       end
       if file && line && File.exist?(file)
         Source.new(file: file, first_line: line, last_line: find_end(file, line))
@@ -60,5 +59,26 @@ module IRB
       end
       first_line
     end
+
+    def method_target(owner_receiver, s_count, method, type)
+      case type
+      when "owner"
+        target_method = owner_receiver.instance_method(method)
+        return target_method.source_location unless s_count
+      when "receiver"
+        if s_count
+          target_method = owner_receiver.class.instance_method(method)
+        else
+          target_method = method
+          return owner_receiver.method(method).source_location
+        end
+      end
+      s_count.times do |s|
+        target_method = target_method.super_method if target_method
+      end
+      target_method.nil? ? nil : target_method.source_location
+    rescue NameError
+      nil
+    end
   end
 end

data/lib/irb/version.rb

@@ -5,7 +5,7 @@
 #
 
 module IRB # :nodoc:
-  VERSION = "1.9.1"
+  VERSION = "1.10.1"
   @RELEASE_VERSION = VERSION
-  @LAST_UPDATE_DATE = "2023-11-21"
+  @LAST_UPDATE_DATE = "2023-12-05"
 end

data/lib/irb.rb

@@ -20,6 +20,7 @@ require_relative "irb/color"
 require_relative "irb/version"
 require_relative "irb/easter-egg"
 require_relative "irb/debug"
+require_relative "irb/pager"
 
 # IRB stands for "interactive Ruby" and is a tool to interactively execute Ruby
 # expressions read from the standard input.
@@ -697,7 +698,7 @@ module IRB
     end
 
     def handle_exception(exc)
-      if exc.backtrace && exc.backtrace[0] =~ /\/irb(2)?(\/.*|-.*|\.rb)?:/ && exc.class.to_s !~ /^IRB/ &&
+      if exc.backtrace[0] =~ /\/irb(2)?(\/.*|-.*|\.rb)?:/ && exc.class.to_s !~ /^IRB/ &&
          !(SyntaxError === exc) && !(EncodingError === exc)
         # The backtrace of invalid encoding hash (ex. {"\xAE": 1}) raises EncodingError without lineno.
         irb_bug = true
@@ -705,45 +706,49 @@ module IRB
         irb_bug = false
       end
 
-      if exc.backtrace
-        order = nil
-        if RUBY_VERSION < '3.0.0'
-          if STDOUT.tty?
-            message = exc.full_message(order: :bottom)
-            order = :bottom
-          else
-            message = exc.full_message(order: :top)
-            order = :top
-          end
-        else # '3.0.0' <= RUBY_VERSION
+      if RUBY_VERSION < '3.0.0'
+        if STDOUT.tty?
+          message = exc.full_message(order: :bottom)
+          order = :bottom
+        else
           message = exc.full_message(order: :top)
           order = :top
         end
-        message = convert_invalid_byte_sequence(message, exc.message.encoding)
-        message = encode_with_invalid_byte_sequence(message, IRB.conf[:LC_MESSAGES].encoding) unless message.encoding.to_s.casecmp?(IRB.conf[:LC_MESSAGES].encoding.to_s)
-        message = message.gsub(/((?:^\t.+$\n)+)/)  { |m|
-          case order
-          when :top
-            lines = m.split("\n")
-          when :bottom
-            lines = m.split("\n").reverse
-          end
-          unless irb_bug
-            lines = lines.map { |l| @context.workspace.filter_backtrace(l) }.compact
-            if lines.size > @context.back_trace_limit
-              omit = lines.size - @context.back_trace_limit
-              lines = lines[0..(@context.back_trace_limit - 1)]
-              lines << "\t... %d levels..." % omit
-            end
+      else # '3.0.0' <= RUBY_VERSION
+        message = exc.full_message(order: :top)
+        order = :top
+      end
+      message = convert_invalid_byte_sequence(message, exc.message.encoding)
+      message = encode_with_invalid_byte_sequence(message, IRB.conf[:LC_MESSAGES].encoding) unless message.encoding.to_s.casecmp?(IRB.conf[:LC_MESSAGES].encoding.to_s)
+      message = message.gsub(/((?:^\t.+$\n)+)/) { |m|
+        case order
+        when :top
+          lines = m.split("\n")
+        when :bottom
+          lines = m.split("\n").reverse
+        end
+        unless irb_bug
+          lines = lines.map { |l| @context.workspace.filter_backtrace(l) }.compact
+          if lines.size > @context.back_trace_limit
+            omit = lines.size - @context.back_trace_limit
+            lines = lines[0..(@context.back_trace_limit - 1)]
+            lines << "\t... %d levels..." % omit
           end
-          lines = lines.reverse if order == :bottom
-          lines.map{ |l| l + "\n" }.join
-        }
-        # The "<top (required)>" in "(irb)" may be the top level of IRB so imitate the main object.
-        message = message.gsub(/\(irb\):(?<num>\d+):in `<(?<frame>top \(required\))>'/)  { "(irb):#{$~[:num]}:in `<main>'" }
-        puts message
+        end
+        lines = lines.reverse if order == :bottom
+        lines.map{ |l| l + "\n" }.join
+      }
+      # The "<top (required)>" in "(irb)" may be the top level of IRB so imitate the main object.
+      message = message.gsub(/\(irb\):(?<num>\d+):in `<(?<frame>top \(required\))>'/) { "(irb):#{$~[:num]}:in `<main>'" }
+      puts message
+      puts 'Maybe IRB bug!' if irb_bug
+    rescue Exception => handler_exc
+      begin
+        puts exc.inspect
+        puts "backtraces are hidden because #{handler_exc} was raised when processing them"
+      rescue Exception
+        puts 'Uninspectable exception occurred'
       end
-      print "Maybe IRB bug!\n" if irb_bug
     end
 
     # Evaluates the given block using the given +path+ as the Context#irb_path
@@ -855,11 +860,12 @@ module IRB
           end
         end
       end
+
       if multiline_p && @context.newline_before_multiline_output?
-        printf @context.return_format, "\n#{str}"
-      else
-        printf @context.return_format, str
+        str = "\n" + str
       end
+
+      Pager.page_content(format(@context.return_format, str), retain_content: true)
     end
 
     # Outputs the local variables to this current session, including
@@ -926,9 +932,11 @@ module IRB
         when "N"
           @context.irb_name
         when "m"
-          truncate_prompt_main(@context.main.to_s)
+          main_str = @context.main.to_s rescue "!#{$!.class}"
+          truncate_prompt_main(main_str)
         when "M"
-          truncate_prompt_main(@context.main.inspect)
+          main_str = @context.main.inspect rescue "!#{$!.class}"
+          truncate_prompt_main(main_str)
         when "l"
           ltype
         when "i"