irb 1.17.0 → 1.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a457883af2f8f76b44bca4458e71fb4260244d033ab119f0cbc828b94bce01b5
-  data.tar.gz: 22dca36785746338f9b0928fd0a16d5a36c4766f9360be937869ab7e89e01966
+  metadata.gz: f5228c22000696caa8318b56171e1238202f103e63c470db4d215ce2d0e46625
+  data.tar.gz: ac556bc9f4fe3abfef0310a1330d609d424c1196e4a75ba086bae789b0e973d1
 SHA512:
-  metadata.gz: 284c0962361358e0aed3f0ded870a8f2bacafe1ab52d68df26f6e97e48d92396b75e78ab7a7019fc35d555a2c4016957fe4ac3017828f506d58828d9c83df16c
-  data.tar.gz: 8417bb9569aae0a3397db838c2ca51d45be16b473ee2f986fb0c03168c8f8f5c2800d30f13bb92436c0ca6cc4ff22f70abcf33db12f647e2c157772069735e96
+  metadata.gz: fe37b6ecb5348d4cee255f42fd0be29d75b609b7edf45e0e8b6699dcb2865c4d888fbb282087acbfe2eaa9235890e60f7be80545ddb292b9adb4d4c29fd8b111
+  data.tar.gz: 063aab58e48c5ff5e6bb5ca306ad820469c96a691d1f90d227a045c6fb2d9a5b423c76e4099a213fee21f079c52839556e13b8a8529779df982f418756eb89ff

data/lib/irb/color.rb

@@ -69,6 +69,7 @@ module IRB # :nodoc:
       KEYWORD_IN:         [GREEN],
       KEYWORD_DEF:        [GREEN],
       KEYWORD_DO:         [GREEN],
+      KEYWORD_DO_BLOCK:   [GREEN],
       KEYWORD_DO_LOOP:    [GREEN],
       KEYWORD_FOR:        [GREEN],
       KEYWORD_BEGIN:      [GREEN],
@@ -102,16 +103,17 @@ module IRB # :nodoc:
       STRING_END:         [RED, BOLD],
       __END__:            [GREEN],
       # tokens from syntax tree traversal
-      method_name:        [BLUE, BOLD],
+      method_name:        [CYAN, BOLD],
+      message_name:       [CYAN],
       symbol:             [YELLOW],
       # special colorization
       error:              [RED, REVERSE],
-      const_env:          [CYAN, BOLD],
     }.transform_values do |styles|
       styles.map { |style| "\e[#{style}m" }.join
     end
     CLEAR_SEQ = "\e[#{CLEAR}m"
-    private_constant :TOKEN_SEQS, :CLEAR_SEQ
+    OPERATORS = %i(!= !~ =~ == === <=> > >= < <= & | ^ >> << - + % / * ** -@ +@ ~ ! [] []=)
+    private_constant :TOKEN_SEQS, :CLEAR_SEQ, :OPERATORS
 
     class << self
       def colorable?
@@ -168,12 +170,13 @@ module IRB # :nodoc:
         # IRB::ColorPrinter skips colorizing syntax invalid fragments
         return Reline::Unicode.escape_for_print(code) if ignore_error && !result.success?
 
+        prism_node, prism_tokens = result.value
         errors = result.errors
+
         unless complete
-          errors = errors.reject { |error| error.message =~ /\Aexpected a|unexpected end-of-input|unterminated/ }
+          errors = filter_incomplete_code_errors(errors, prism_tokens)
         end
 
-        prism_node, prism_tokens = result.value
         visitor = ColorizeVisitor.new
         prism_node.accept(visitor)
 
@@ -202,9 +205,7 @@ module IRB # :nodoc:
           next if start_line - 1 < line_index || (start_line - 1 == line_index && start_column < col)
 
           flush.call(start_line - 1, start_column)
-          if type == :CONSTANT && value == 'ENV'
-            color = TOKEN_SEQS[:const_env]
-          elsif type == :__END__
+          if type == :__END__
             color = TOKEN_SEQS[type]
             end_line = start_line
             value = '__END__'
@@ -251,6 +252,31 @@ module IRB # :nodoc:
           super
         end
 
+        def visit_alias_method_node(node)
+          dispatch_alias_method_name node.new_name
+          dispatch_alias_method_name node.old_name
+          super
+        end
+
+        def visit_call_node(node)
+          if node.call_operator_loc.nil? && OPERATORS.include?(node.name)
+            # Operators should not be colored as method call
+          elsif (node.call_operator_loc.nil? || node.call_operator_loc.slice == "::") &&
+              /\A\p{Upper}/.match?(node.name)
+            # Constant-like methods should not be colored as method call
+          else
+            dispatch node.message_loc, :message_name
+          end
+          super
+        end
+
+        def visit_call_operator_write_node(node)
+          dispatch node.message_loc, :message_name
+          super
+        end
+        alias visit_call_and_write_node visit_call_operator_write_node
+        alias visit_call_or_write_node visit_call_operator_write_node
+
         def visit_interpolated_symbol_node(node)
           dispatch node.opening_loc, :symbol
           node.parts.each do |part|
@@ -278,10 +304,41 @@ module IRB # :nodoc:
             dispatch node.closing_loc, :symbol
           end
         end
+
+        private
+
+        def dispatch_alias_method_name(node)
+          if node.type == :symbol_node && node.opening_loc.nil?
+            dispatch node.value_loc, :method_name
+          end
+        end
       end
 
       private
 
+      FILTERED_ERROR_TYPES = [
+        :class_name, :module_name, # `class`, `class owner_module`
+        :write_target_unexpected, # `a, b`
+        :parameter_wild_loose_comma, # `def f(a,`
+        :argument_no_forwarding_star, # `[*`
+        :argument_no_forwarding_star_star, # `f(**`
+        :argument_no_forwarding_ampersand, # `f(&`
+        :def_endless, # `def f =`
+        :embdoc_term, # `=begin`
+      ]
+
+      # Filter out syntax errors that are likely to be caused by incomplete code, to avoid showing misleading error highlights to users.
+      def filter_incomplete_code_errors(errors, tokens)
+        last_non_comment_space_token, = tokens.reverse_each.find do |t,|
+          t.type != :COMMENT && t.type != :EOF && t.type != :IGNORED_NEWLINE && t.type != :NEWLINE
+        end
+        last_offset = last_non_comment_space_token ? last_non_comment_space_token.location.end_offset : 0
+        errors.reject do |error|
+          error.message.match?(/\Aexpected a|unexpected end-of-input|unterminated/) ||
+          (error.location.end_offset == last_offset && FILTERED_ERROR_TYPES.include?(error.type))
+        end
+      end
+
       def without_circular_ref(obj, seen:, &block)
         return false if seen.key?(obj)
         seen[obj] = true

data/lib/irb/command/base.rb

@@ -37,11 +37,46 @@ module IRB
           puts e.message
         end
 
+        # Returns formatted lines for display in the doc dialog popup.
+        def doc_dialog_content(name, width)
+          lines = []
+          lines << Color.colorize(name, [:BOLD, :BLUE]) + Color.colorize(" (command)", [:CYAN])
+          lines << ""
+          lines.concat(wrap_lines(description, width))
+          if help_message
+            lines << ""
+            lines.concat(wrap_lines(help_message, width))
+          end
+          lines
+        end
+
         private
 
         def highlight(text)
           Color.colorize(text, [:BOLD, :BLUE])
         end
+
+        def wrap_lines(text, width)
+          text.lines.flat_map do |line|
+            line = line.chomp
+            next [''] if line.empty?
+            next [line] if line.length <= width
+
+            indent = line[/\A\s*/]
+            parts = line.strip.split(/(\s+)/)
+            result = []
+            current = indent.dup
+            parts.each do |part|
+              if current != indent && current.length + part.length > width
+                result << current.rstrip
+                current = indent.dup
+              end
+              current << part unless current == indent && part.match?(/\A\s+\z/)
+            end
+            result << current.rstrip unless current == indent
+            result
+          end
+        end
       end
 
       def initialize(irb_context)

data/lib/irb/command/internal_helpers.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'prism'
+
 module IRB
   module Command
     # Internal use only, for default command's backward compatibility.
@@ -7,9 +9,10 @@ module IRB
       def unwrap_string_literal(str)
         return if str.empty?
 
-        sexp = Ripper.sexp(str)
-        if sexp && sexp.size == 2 && sexp.last&.first&.first == :string_literal
-          @irb_context.workspace.binding.eval(str).to_s
+        result = Prism.parse(str)
+        body = result.value.statements.body
+        if result.success? && body.size == 1 && body.first.is_a?(Prism::StringNode)
+          body.first.unescaped
         else
           str
         end

data/lib/irb/command/ls.rb

@@ -55,11 +55,13 @@ module IRB
 
         o = Output.new(grep: grep)
 
-        klass  = (obj.class == Class || obj.class == Module ? obj : obj.class)
+        klass = Kernel.instance_method(:class).bind(obj).call
+        obj_is_class_or_module = Module === obj
+        klass = obj_is_class_or_module ? obj : klass
 
-        o.dump("constants", obj.constants) if obj.respond_to?(:constants)
+        o.dump("constants", obj.constants) if obj_is_class_or_module
         dump_methods(o, klass, obj)
-        o.dump("instance variables", obj.instance_variables)
+        o.dump("instance variables", Kernel.instance_method(:instance_variables).bind(obj).call)
         o.dump("class variables", klass.class_variables)
         o.dump("locals", locals) if locals
         o.print_result
@@ -67,7 +69,7 @@ module IRB
       end
 
       def dump_methods(o, klass, obj)
-        singleton_class = begin obj.singleton_class; rescue TypeError; nil end
+        singleton_class = begin Kernel.instance_method(:singleton_class).bind(obj).call; rescue TypeError; nil end
         dumped_mods = Array.new
         ancestors = klass.ancestors
         ancestors = ancestors.reject { |c| c >= Object } if klass < Object

data/lib/irb/completion.rb

@@ -8,6 +8,29 @@
 require_relative 'ruby-lex'
 
 module IRB
+  class DocumentTarget # :nodoc:
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+  end
+
+  class CommandDocument < DocumentTarget # :nodoc:
+  end
+
+  # Represents a method/class documentation target. May hold multiple names
+  # when the receiver is ambiguous (e.g. `{}.any?` could be Hash#any? or Proc#any?).
+  # The dialog popup uses only the first name; the full-screen display renders all.
+  class MethodDocument < DocumentTarget # :nodoc:
+    attr_reader :names
+
+    def initialize(*names)
+      super(names.first)
+      @names = names
+    end
+  end
+
   class BaseCompletor # :nodoc:
 
     # Set of reserved words used by Ruby, you should not use these for
@@ -76,6 +99,12 @@ module IRB
       end
     end
 
+    def command_document_target(preposing, matched)
+      if preposing.empty? && IRB::Command.command_names.include?(matched)
+        CommandDocument.new(matched)
+      end
+    end
+
     def retrieve_files_to_require_relative_from_current_dir
       @files_from_current_dir ||= Dir.glob("**/*.{rb,#{RbConfig::CONFIG['DLEXT']}}", base: '.').map { |path|
         path.sub(/\.(rb|#{RbConfig::CONFIG['DLEXT']})\z/, '')
@@ -118,8 +147,10 @@ module IRB
     end
 
     def doc_namespace(preposing, matched, _postposing, bind:)
-      result = ReplTypeCompletor.analyze(preposing + matched, binding: bind, filename: @context.irb_path)
-      result&.doc_namespace('')
+      command_document_target(preposing, matched) || begin
+        result = ReplTypeCompletor.analyze(preposing + matched, binding: bind, filename: @context.irb_path)
+        result&.doc_namespace('')
+      end
     end
   end
 
@@ -166,22 +197,13 @@ module IRB
       else
         return nil # It's not String literal
       end
-      tokens = RubyLex.ripper_lex_without_warning(preposing.rstrip)
-      tok = nil
-      tokens.reverse_each do |t|
-        unless [:on_lparen, :on_sp, :on_ignored_sp, :on_nl, :on_ignored_nl, :on_comment].include?(t.event)
-          tok = t
-          break
-        end
-      end
-      return unless tok&.event == :on_ident && tok.state == Ripper::EXPR_CMDARG
 
-      case tok.tok
-      when 'require'
+      case preposing
+      when /(^|[^\w])require\(? *\z/
         retrieve_files_to_require_from_load_path.filter_map { |path|
           quote + path if path.start_with?(actual_target)
         }
-      when 'require_relative'
+      when /(^|[^\w])require_relative\(? *\z/
         retrieve_files_to_require_relative_from_current_dir.filter_map { |path|
           quote + path if path.start_with?(actual_target)
         }
@@ -210,8 +232,8 @@ module IRB
       commands | completion_data
     end
 
-    def doc_namespace(_preposing, matched, _postposing, bind:)
-      retrieve_completion_data(matched, bind: bind, doc_namespace: true)
+    def doc_namespace(preposing, matched, _postposing, bind:)
+      command_document_target(preposing, matched) || retrieve_completion_data(matched, bind: bind, doc_namespace: true)
     end
 
     def retrieve_completion_data(input, bind:, doc_namespace:)

data/lib/irb/init.rb

@@ -87,6 +87,7 @@ module IRB # :nodoc:
     @CONF[:IGNORE_SIGINT] = true
     @CONF[:IGNORE_EOF] = false
     @CONF[:USE_PAGER] = true
+    @CONF[:SHOW_BANNER] = true
     @CONF[:EXTRA_DOC_DIRS] = []
     @CONF[:ECHO] = nil
     @CONF[:ECHO_ON_ASSIGNMENT] = nil
@@ -345,6 +346,8 @@ module IRB # :nodoc:
         opt = $1 || argv.shift
         prompt_mode = opt.upcase.tr("-", "_").intern
         @CONF[:PROMPT_MODE] = prompt_mode
+      when "--nobanner"
+        @CONF[:SHOW_BANNER] = false
       when "--noprompt"
         @CONF[:PROMPT_MODE] = :NULL
       when "--script"

data/lib/irb/input-method.rb

@@ -255,6 +255,16 @@ module IRB
 
   class RelineInputMethod < StdioInputMethod
     HISTORY = Reline::HISTORY
+    ALT_KEY_NAME = RUBY_PLATFORM.match?(/darwin/) ? "Option" : "Alt"
+    PRESS_ALT_D_TO_READ_FULL_DOC = "Press #{ALT_KEY_NAME}+d to read the full document".freeze
+    PRESS_ALT_D_TO_SEE_MORE = "Press #{ALT_KEY_NAME}+d to see more".freeze
+    ALT_D_SEQUENCES = [
+      [27, 100], # Normal Alt+d when convert-meta isn't used.
+      # When option/alt is not configured as a meta key in terminal emulator,
+      # option/alt + d will send a unicode character depend on OS keyboard setting.
+      [195, 164], # "ä" in somewhere (FIXME: environment information is unknown).
+      [226, 136, 130] # "∂" Alt+d on Mac keyboard.
+    ].freeze
     include HistorySavingAbility
     # Creates a new input method object using Reline
     def initialize(completor)
@@ -305,9 +315,17 @@ module IRB
       @auto_indent_proc = block
     end
 
-    def retrieve_doc_namespace(matched)
+    def retrieve_document_target(matched)
       preposing, _target, postposing, bind = @completion_params
-      @completor.doc_namespace(preposing, matched, postposing, bind: bind)
+      result = @completor.doc_namespace(preposing, matched, postposing, bind: bind)
+      case result
+      when DocumentTarget, nil
+        result
+      when Array
+        MethodDocument.new(*result)
+      when String
+        MethodDocument.new(result)
+      end
     end
 
     def rdoc_ri_driver
@@ -328,146 +346,158 @@ module IRB
       input_method = self # self is changed in the lambda below.
       ->() {
         dialog.trap_key = nil
-        alt_d = [
-          [27, 100], # Normal Alt+d when convert-meta isn't used.
-          # When option/alt is not configured as a meta key in terminal emulator,
-          # option/alt + d will send a unicode character depend on OS keyboard setting.
-          [195, 164], # "ä" in somewhere (FIXME: environment information is unknown).
-          [226, 136, 130] # "∂" Alt+d on Mac keyboard.
-        ]
-
-        if just_cursor_moving and completion_journey_data.nil?
+
+        if just_cursor_moving && completion_journey_data.nil?
           return nil
         end
         cursor_pos_to_render, result, pointer, autocomplete_dialog = context.pop(4)
-        return nil if result.nil? or pointer.nil? or pointer < 0
+        return nil if result.nil? || pointer.nil? || pointer < 0
 
-        name = input_method.retrieve_doc_namespace(result[pointer])
-        # Use first one because document dialog does not support multiple namespaces.
-        name = name.first if name.is_a?(Array)
+        matched_text = result[pointer]
+        show_easter_egg = matched_text&.match?(/\ARubyVM/) && !ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
+        target = show_easter_egg ? nil : input_method.retrieve_document_target(matched_text)
 
-        show_easter_egg = name&.match?(/\ARubyVM/) && !ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
+        x, width = input_method.dialog_doc_position(cursor_pos_to_render, autocomplete_dialog, screen_width)
+        return nil unless x
 
-        driver = input_method.rdoc_ri_driver
+        dialog.trap_key = ALT_D_SEQUENCES
 
         if key.match?(dialog.name)
-          if show_easter_egg
-            IRB.__send__(:easter_egg)
-          else
-            # RDoc::RI::Driver#display_names uses pager command internally.
-            # Some pager command like `more` doesn't use alternate screen
-            # so we need to turn on and off alternate screen manually.
-            begin
-              print "\e[?1049h"
-              driver.display_names([name])
-            rescue RDoc::RI::Driver::NotFoundError
-            ensure
-              print "\e[?1049l"
-            end
+          begin
+            print "\e[?1049h"
+            input_method.display_document(matched_text)
+          ensure
+            print "\e[?1049l"
           end
         end
 
-        begin
-          name = driver.expand_name(name)
-        rescue RDoc::RI::Driver::NotFoundError
-          return nil
-        rescue
-          return nil # unknown error
-        end
-        doc = nil
-        used_for_class = false
-        if not name =~ /#|\./
-          found, klasses, includes, extends = driver.classes_and_includes_and_extends_for(name)
-          if not found.empty?
-            doc = driver.class_document(name, found, klasses, includes, extends)
-            used_for_class = true
+        contents = case target
+        when CommandDocument
+          input_method.command_doc_dialog_contents(target.name, width)
+        when MethodDocument
+          input_method.rdoc_dialog_contents(target.name, width)
+        else
+          if show_easter_egg
+            input_method.easter_egg_dialog_contents
           end
         end
-        unless used_for_class
-          doc = RDoc::Markup::Document.new
-          begin
-            driver.add_method(doc, name)
-          rescue RDoc::RI::Driver::NotFoundError
-            doc = nil
-          rescue
-            return nil # unknown error
-          end
+        return nil unless contents
+
+        contents = contents.take(preferred_dialog_height)
+        y = cursor_pos_to_render.y
+        Reline::DialogRenderInfo.new(pos: Reline::CursorPos.new(x, y), contents: contents, width: width, bg_color: '49')
+      }
+    end
+
+    def command_doc_dialog_contents(command_name, width)
+      command_class = IRB::Command.load_command(command_name)
+      return unless command_class
+
+      [PRESS_ALT_D_TO_READ_FULL_DOC, ""] + command_class.doc_dialog_content(command_name, width)
+    end
+
+    def easter_egg_dialog_contents
+      type = STDOUT.external_encoding == Encoding::UTF_8 ? :unicode : :ascii
+      lines = IRB.send(:easter_egg_logo, type).split("\n")
+      lines[0][0, PRESS_ALT_D_TO_SEE_MORE.size] = PRESS_ALT_D_TO_SEE_MORE
+      lines
+    end
+
+    def rdoc_dialog_contents(name, width)
+      driver = rdoc_ri_driver
+      return unless driver
+
+      name = driver.expand_name(name)
+
+      doc = if name =~ /#|\./
+        d = RDoc::Markup::Document.new
+        driver.add_method(d, name)
+        d
+      else
+        found, klasses, includes, extends = driver.classes_and_includes_and_extends_for(name)
+        if found.empty?
+          d = RDoc::Markup::Document.new
+          driver.add_method(d, name)
+          d
+        else
+          driver.class_document(name, found, klasses, includes, extends)
         end
-        return nil if doc.nil?
-        width = 40
-
-        right_x = cursor_pos_to_render.x + autocomplete_dialog.width
-        if right_x + width > screen_width
-          right_width = screen_width - (right_x + 1)
-          left_x = autocomplete_dialog.column - width
-          left_x = 0 if left_x < 0
-          left_width = width > autocomplete_dialog.column ? autocomplete_dialog.column : width
-          if right_width.positive? and left_width.positive?
-            if right_width >= left_width
-              width = right_width
-              x = right_x
-            else
-              width = left_width
-              x = left_x
-            end
-          elsif right_width.positive? and left_width <= 0
+      end
+
+      formatter = RDoc::Markup::ToAnsi.new
+      formatter.width = width
+      [PRESS_ALT_D_TO_READ_FULL_DOC] + doc.accept(formatter).split("\n")
+    rescue RDoc::RI::Driver::NotFoundError
+    end
+
+    def dialog_doc_position(cursor_pos_to_render, autocomplete_dialog, screen_width)
+      width = 40
+      right_x = cursor_pos_to_render.x + autocomplete_dialog.width
+      if right_x + width > screen_width
+        right_width = screen_width - (right_x + 1)
+        left_x = autocomplete_dialog.column - width
+        left_x = 0 if left_x < 0
+        left_width = width > autocomplete_dialog.column ? autocomplete_dialog.column : width
+        if right_width.positive? && left_width.positive?
+          if right_width >= left_width
             width = right_width
             x = right_x
-          elsif right_width <= 0 and left_width.positive?
+          else
             width = left_width
             x = left_x
-          else # Both are negative width.
-            return nil
           end
-        else
+        elsif right_width.positive? && left_width <= 0
+          width = right_width
           x = right_x
-        end
-        formatter = RDoc::Markup::ToAnsi.new
-        formatter.width = width
-        dialog.trap_key = alt_d
-        mod_key = RUBY_PLATFORM.match?(/darwin/) ? "Option" : "Alt"
-        if show_easter_egg
-          type = STDOUT.external_encoding == Encoding::UTF_8 ? :unicode : :ascii
-          contents = IRB.send(:easter_egg_logo, type).split("\n")
-          message = "Press #{mod_key}+d to see more"
-          contents[0][0, message.size] = message
+        elsif right_width <= 0 && left_width.positive?
+          width = left_width
+          x = left_x
         else
-          message = "Press #{mod_key}+d to read the full document"
-          contents = [message] + doc.accept(formatter).split("\n")
+          return nil
         end
-        contents = contents.take(preferred_dialog_height)
-
-        y = cursor_pos_to_render.y
-        Reline::DialogRenderInfo.new(pos: Reline::CursorPos.new(x, y), contents: contents, width: width, bg_color: '49')
-      }
+      else
+        x = right_x
+      end
+      [x, width]
     end
 
     def display_document(matched)
-      driver = rdoc_ri_driver
-      return unless driver
-
-      if matched =~ /\A(?:::)?RubyVM/ and not ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
-        IRB.__send__(:easter_egg)
-        return
-      end
+      target = retrieve_document_target(matched)
+      return unless target
+
+      case target
+      when CommandDocument
+        command_class = IRB::Command.load_command(target.name)
+        if command_class
+          content = command_class.help_message || command_class.description
+          Pager.page(retain_content: true) do |io|
+            io.puts content
+          end
+        end
+      when MethodDocument
+        driver = rdoc_ri_driver
+        return unless driver
 
-      namespace = retrieve_doc_namespace(matched)
-      return unless namespace
+        if matched =~ /\A(?:::)?RubyVM/ && !ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
+          IRB.__send__(:easter_egg)
+          return
+        end
 
-      if namespace.is_a?(Array)
-        out = RDoc::Markup::Document.new
-        namespace.each do |m|
+        if target.names.length > 1
+          out = RDoc::Markup::Document.new
+          target.names.each do |m|
+            begin
+              driver.add_method(out, m)
+            rescue RDoc::RI::Driver::NotFoundError
+            end
+          end
+          driver.display(out)
+        else
           begin
-            driver.add_method(out, m)
+            driver.display_names([target.name])
           rescue RDoc::RI::Driver::NotFoundError
           end
         end
-        driver.display(out)
-      else
-        begin
-          driver.display_names([namespace])
-        rescue RDoc::RI::Driver::NotFoundError
-        end
       end
     end
 

data/lib/irb/nesting_parser.rb

@@ -222,6 +222,7 @@ module IRB
           # Heredoc closing contains trailing newline. We need to exclude it
           close_location_start(node.closing_loc) if node.closing_loc && !node.closing.empty?
         elsif node.opening
+          return if node.opening == '?' && node.closing.nil? # Character literal has no closing
           open_location(node.location, type, node.opening)
           if node.closing && node.closing != ''
             # Closing of `"#{\n` is "\n". We need to treat it as not-closed.