irb 1.14.3 → 1.18.0

data/lib/irb.rb

@@ -5,7 +5,7 @@
 #       by Keiju ISHITSUKA(keiju@ruby-lang.org)
 #
 
-require "ripper"
+require "prism"
 require "reline"
 
 require_relative "irb/init"
@@ -21,861 +21,10 @@ require_relative "irb/color"
 
 require_relative "irb/version"
 require_relative "irb/easter-egg"
+require_relative "irb/startup_message"
 require_relative "irb/debug"
 require_relative "irb/pager"
 
-# ## IRB
-#
-# Module IRB ("Interactive Ruby") provides a shell-like interface that supports
-# user interaction with the Ruby interpreter.
-#
-# It operates as a *read-eval-print loop*
-# ([REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop))
-# that:
-#
-# *   ***Reads*** each character as you type. You can modify the IRB context to
-#     change the way input works. See [Input](rdoc-ref:IRB@Input).
-# *   ***Evaluates*** the code each time it has read a syntactically complete
-#     passage.
-# *   ***Prints*** after evaluating. You can modify the IRB context to change
-#     the way output works. See [Output](rdoc-ref:IRB@Output).
-#
-#
-# Example:
-#
-#     $ irb
-#     irb(main):001> File.basename(Dir.pwd)
-#     => "irb"
-#     irb(main):002> Dir.entries('.').size
-#     => 25
-#     irb(main):003* Dir.entries('.').select do |entry|
-#     irb(main):004*   entry.start_with?('R')
-#     irb(main):005> end
-#     => ["README.md", "Rakefile"]
-#
-# The typed input may also include [\IRB-specific
-# commands](rdoc-ref:IRB@IRB-Specific+Commands).
-#
-# As seen above, you can start IRB by using the shell command `irb`.
-#
-# You can stop an IRB session by typing command `exit`:
-#
-#     irb(main):006> exit
-#     $
-#
-# At that point, IRB calls any hooks found in array `IRB.conf[:AT_EXIT]`, then
-# exits.
-#
-# ## Startup
-#
-# At startup, IRB:
-#
-# 1.  Interprets (as Ruby code) the content of the [configuration
-#     file](rdoc-ref:IRB@Configuration+File) (if given).
-# 2.  Constructs the initial session context from [hash
-#     IRB.conf](rdoc-ref:IRB@Hash+IRB.conf) and from default values; the hash
-#     content may have been affected by [command-line
-#     options](rdoc-ref:IRB@Command-Line+Options), and by direct assignments in
-#     the configuration file.
-# 3.  Assigns the context to variable `conf`.
-# 4.  Assigns command-line arguments to variable `ARGV`.
-# 5.  Prints the [prompt](rdoc-ref:IRB@Prompt+and+Return+Formats).
-# 6.  Puts the content of the [initialization
-#     script](rdoc-ref:IRB@Initialization+Script) onto the IRB shell, just as if
-#     it were user-typed commands.
-#
-#
-# ### The Command Line
-#
-# On the command line, all options precede all arguments; the first item that is
-# not recognized as an option is treated as an argument, as are all items that
-# follow.
-#
-# #### Command-Line Options
-#
-# Many command-line options affect entries in hash `IRB.conf`, which in turn
-# affect the initial configuration of the IRB session.
-#
-# Details of the options are described in the relevant subsections below.
-#
-# A cursory list of the IRB command-line options may be seen in the [help
-# message](https://raw.githubusercontent.com/ruby/irb/master/lib/irb/lc/help-message),
-# which is also displayed if you use command-line option `--help`.
-#
-# If you are interested in a specific option, consult the
-# [index](rdoc-ref:doc/irb/indexes.md@Index+of+Command-Line+Options).
-#
-# #### Command-Line Arguments
-#
-# Command-line arguments are passed to IRB in array `ARGV`:
-#
-#     $ irb --noscript Foo Bar Baz
-#     irb(main):001> ARGV
-#     => ["Foo", "Bar", "Baz"]
-#     irb(main):002> exit
-#     $
-#
-# Command-line option `--` causes everything that follows to be treated as
-# arguments, even those that look like options:
-#
-#     $ irb --noscript -- --noscript -- Foo Bar Baz
-#     irb(main):001> ARGV
-#     => ["--noscript", "--", "Foo", "Bar", "Baz"]
-#     irb(main):002> exit
-#     $
-#
-# ### Configuration File
-#
-# You can initialize IRB via a *configuration file*.
-#
-# If command-line option `-f` is given, no configuration file is looked for.
-#
-# Otherwise, IRB reads and interprets a configuration file if one is available.
-#
-# The configuration file can contain any Ruby code, and can usefully include
-# user code that:
-#
-# *   Can then be debugged in IRB.
-# *   Configures IRB itself.
-# *   Requires or loads files.
-#
-#
-# The path to the configuration file is the first found among:
-#
-# *   The value of variable `$IRBRC`, if defined.
-# *   The value of variable `$XDG_CONFIG_HOME/irb/irbrc`, if defined.
-# *   File `$HOME/.irbrc`, if it exists.
-# *   File `$HOME/.config/irb/irbrc`, if it exists.
-# *   File `.irbrc` in the current directory, if it exists.
-# *   File `irb.rc` in the current directory, if it exists.
-# *   File `_irbrc` in the current directory, if it exists.
-# *   File `$irbrc` in the current directory, if it exists.
-#
-#
-# If the search fails, there is no configuration file.
-#
-# If the search succeeds, the configuration file is read as Ruby code, and so
-# can contain any Ruby programming you like.
-#
-# Method `conf.rc?` returns `true` if a configuration file was read, `false`
-# otherwise. Hash entry `IRB.conf[:RC]` also contains that value.
-#
-# ### Hash `IRB.conf`
-#
-# The initial entries in hash `IRB.conf` are determined by:
-#
-# *   Default values.
-# *   Command-line options, which may override defaults.
-# *   Direct assignments in the configuration file.
-#
-#
-# You can see the hash by typing `IRB.conf`.
-#
-# Details of the entries' meanings are described in the relevant subsections
-# below.
-#
-# If you are interested in a specific entry, consult the
-# [index](rdoc-ref:doc/irb/indexes.md@Index+of+IRB.conf+Entries).
-#
-# ### Notes on Initialization Precedence
-#
-# *   Any conflict between an entry in hash `IRB.conf` and a command-line option
-#     is resolved in favor of the hash entry.
-# *   Hash `IRB.conf` affects the context only once, when the configuration file
-#     is interpreted; any subsequent changes to it do not affect the context and
-#     are therefore essentially meaningless.
-#
-#
-# ### Initialization Script
-#
-# By default, the first command-line argument (after any options) is the path to
-# a Ruby initialization script.
-#
-# IRB reads the initialization script and puts its content onto the IRB shell,
-# just as if it were user-typed commands.
-#
-# Command-line option `--noscript` causes the first command-line argument to be
-# treated as an ordinary argument (instead of an initialization script);
-# `--script` is the default.
-#
-# ## Input
-#
-# This section describes the features that allow you to change the way IRB input
-# works; see also [Input and Output](rdoc-ref:IRB@Input+and+Output).
-#
-# ### Input Command History
-#
-# By default, IRB stores a history of up to 1000 input commands in a file named
-# `.irb_history`. The history file will be in the same directory as the
-# [configuration file](rdoc-ref:IRB@Configuration+File) if one is found, or in
-# `~/` otherwise.
-#
-# A new IRB session creates the history file if it does not exist, and appends
-# to the file if it does exist.
-#
-# You can change the filepath by adding to your configuration file:
-# `IRB.conf[:HISTORY_FILE] = *filepath*`, where *filepath* is a string filepath.
-#
-# During the session, method `conf.history_file` returns the filepath, and
-# method `conf.history_file = *new_filepath*` copies the history to the file at
-# *new_filepath*, which becomes the history file for the session.
-#
-# You can change the number of commands saved by adding to your configuration
-# file: `IRB.conf[:SAVE_HISTORY] = *n*`, where *n* is one of:
-#
-# *   Positive integer: the number of commands to be saved.
-# *   Negative integer: all commands are to be saved.
-# *   Zero or `nil`: no commands are to be saved.
-#
-#
-# During the session, you can use methods `conf.save_history` or
-# `conf.save_history=` to retrieve or change the count.
-#
-# ### Command Aliases
-#
-# By default, IRB defines several command aliases:
-#
-#     irb(main):001> conf.command_aliases
-#     => {:"$"=>:show_source, :"@"=>:whereami}
-#
-# You can change the initial aliases in the configuration file with:
-#
-#     IRB.conf[:COMMAND_ALIASES] = {foo: :show_source, bar: :whereami}
-#
-# You can replace the current aliases at any time with configuration method
-# `conf.command_aliases=`; Because `conf.command_aliases` is a hash, you can
-# modify it.
-#
-# ### End-of-File
-#
-# By default, `IRB.conf[:IGNORE_EOF]` is `false`, which means that typing the
-# end-of-file character `Ctrl-D` causes the session to exit.
-#
-# You can reverse that behavior by adding `IRB.conf[:IGNORE_EOF] = true` to the
-# configuration file.
-#
-# During the session, method `conf.ignore_eof?` returns the setting, and method
-# `conf.ignore_eof = *boolean*` sets it.
-#
-# ### SIGINT
-#
-# By default, `IRB.conf[:IGNORE_SIGINT]` is `true`, which means that typing the
-# interrupt character `Ctrl-C` causes the session to exit.
-#
-# You can reverse that behavior by adding `IRB.conf[:IGNORE_SIGING] = false` to
-# the configuration file.
-#
-# During the session, method `conf.ignore_siging?` returns the setting, and
-# method `conf.ignore_sigint = *boolean*` sets it.
-#
-# ### Automatic Completion
-#
-# By default, IRB enables [automatic
-# completion](https://en.wikipedia.org/wiki/Autocomplete#In_command-line_interpr
-# eters):
-#
-# You can disable it by either of these:
-#
-# *   Adding `IRB.conf[:USE_AUTOCOMPLETE] = false` to the configuration file.
-# *   Giving command-line option `--noautocomplete` (`--autocomplete` is the
-#     default).
-#
-#
-# Method `conf.use_autocomplete?` returns `true` if automatic completion is
-# enabled, `false` otherwise.
-#
-# The setting may not be changed during the session.
-#
-# ### Automatic Indentation
-#
-# By default, IRB automatically indents lines of code to show structure (e.g.,
-# it indent the contents of a block).
-#
-# The current setting is returned by the configuration method
-# `conf.auto_indent_mode`.
-#
-# The default initial setting is `true`:
-#
-#     irb(main):001> conf.auto_indent_mode
-#     => true
-#     irb(main):002* Dir.entries('.').select do |entry|
-#     irb(main):003*   entry.start_with?('R')
-#     irb(main):004> end
-#     => ["README.md", "Rakefile"]
-#
-# You can change the initial setting in the configuration file with:
-#
-#     IRB.conf[:AUTO_INDENT] = false
-#
-# Note that the *current* setting *may not* be changed in the IRB session.
-#
-# ### Input Method
-#
-# The IRB input method determines how command input is to be read; by default,
-# the input method for a session is IRB::RelineInputMethod. Unless the
-# value of the TERM environment variable is 'dumb', in which case the
-# most simplistic input method is used.
-#
-# You can set the input method by:
-#
-# *   Adding to the configuration file:
-#
-#     *   `IRB.conf[:USE_SINGLELINE] = true` or `IRB.conf[:USE_MULTILINE]=
-#         false` sets the input method to IRB::ReadlineInputMethod.
-#     *   `IRB.conf[:USE_SINGLELINE] = false` or `IRB.conf[:USE_MULTILINE] =
-#         true` sets the input method to IRB::RelineInputMethod.
-#
-#
-# *   Giving command-line options:
-#
-#     *   `--singleline` or `--nomultiline` sets the input method to
-#         IRB::ReadlineInputMethod.
-#     *   `--nosingleline` or `--multiline` sets the input method to
-#         IRB::RelineInputMethod.
-#     *   `--nosingleline` together with `--nomultiline` sets the
-#         input to IRB::StdioInputMethod.
-#
-#
-# Method `conf.use_multiline?` and its synonym `conf.use_reline` return:
-#
-# *   `true` if option `--multiline` was given.
-# *   `false` if option `--nomultiline` was given.
-# *   `nil` if neither was given.
-#
-#
-# Method `conf.use_singleline?` and its synonym `conf.use_readline` return:
-#
-# *   `true` if option `--singleline` was given.
-# *   `false` if option `--nosingleline` was given.
-# *   `nil` if neither was given.
-#
-#
-# ## Output
-#
-# This section describes the features that allow you to change the way IRB
-# output works; see also [Input and Output](rdoc-ref:IRB@Input+and+Output).
-#
-# ### Return-Value Printing (Echoing)
-#
-# By default, IRB prints (echoes) the values returned by all input commands.
-#
-# You can change the initial behavior and suppress all echoing by:
-#
-# *   Adding to the configuration file: `IRB.conf[:ECHO] = false`. (The default
-#     value for this entry is `nil`, which means the same as `true`.)
-# *   Giving command-line option `--noecho`. (The default is `--echo`.)
-#
-#
-# During the session, you can change the current setting with configuration
-# method `conf.echo=` (set to `true` or `false`).
-#
-# As stated above, by default IRB prints the values returned by all input
-# commands; but IRB offers special treatment for values returned by assignment
-# statements, which may be:
-#
-# *   Printed with truncation (to fit on a single line of output), which is the
-#     default; an ellipsis (`...` is suffixed, to indicate the truncation):
-#
-#         irb(main):001> x = 'abc' * 100
-#
-#
-# > "abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc...
-#
-# *   Printed in full (regardless of the length).
-# *   Suppressed (not printed at all)
-#
-#
-# You can change the initial behavior by:
-#
-# *   Adding to the configuration file: `IRB.conf[:ECHO_ON_ASSIGNMENT] = false`.
-#     (The default value for this entry is `niL`, which means the same as
-#     `:truncate`.)
-# *   Giving command-line option `--noecho-on-assignment` or
-#     `--echo-on-assignment`. (The default is `--truncate-echo-on-assignment`.)
-#
-#
-# During the session, you can change the current setting with configuration
-# method `conf.echo_on_assignment=` (set to `true`, `false`, or `:truncate`).
-#
-# By default, IRB formats returned values by calling method `inspect`.
-#
-# You can change the initial behavior by:
-#
-# *   Adding to the configuration file: `IRB.conf[:INSPECT_MODE] = false`. (The
-#     default value for this entry is `true`.)
-# *   Giving command-line option `--noinspect`. (The default is `--inspect`.)
-#
-#
-# During the session, you can change the setting using method
-# `conf.inspect_mode=`.
-#
-# ### Multiline Output
-#
-# By default, IRB prefixes a newline to a multiline response.
-#
-# You can change the initial default value by adding to the configuration file:
-#
-#     IRB.conf[:NEWLINE_BEFORE_MULTILINE_OUTPUT] = false
-#
-# During a session, you can retrieve or set the value using methods
-# `conf.newline_before_multiline_output?` and
-# `conf.newline_before_multiline_output=`.
-#
-# Examples:
-#
-#     irb(main):001> conf.inspect_mode = false
-#     => false
-#     irb(main):002> "foo\nbar"
-#     =>
-#     foo
-#     bar
-#     irb(main):003> conf.newline_before_multiline_output = false
-#     => false
-#     irb(main):004> "foo\nbar"
-#     => foo
-#     bar
-#
-# ### Evaluation History
-#
-# By default, IRB saves no history of evaluations (returned values), and the
-# related methods `conf.eval_history`, `_`, and `__` are undefined.
-#
-# You can turn on that history, and set the maximum number of evaluations to be
-# stored:
-#
-# *   In the configuration file: add `IRB.conf[:EVAL_HISTORY] = *n*`. (Examples
-#     below assume that we've added `IRB.conf[:EVAL_HISTORY] = 5`.)
-# *   In the session (at any time): `conf.eval_history = *n*`.
-#
-#
-# If `n` is zero, all evaluation history is stored.
-#
-# Doing either of the above:
-#
-# *   Sets the maximum size of the evaluation history; defines method
-#     `conf.eval_history`, which returns the maximum size `n` of the evaluation
-#     history:
-#
-#         irb(main):001> conf.eval_history = 5
-#         => 5
-#         irb(main):002> conf.eval_history
-#         => 5
-#
-# *   Defines variable `_`, which contains the most recent evaluation, or `nil`
-#     if none; same as method `conf.last_value`:
-#
-#         irb(main):003> _
-#         => 5
-#         irb(main):004> :foo
-#         => :foo
-#         irb(main):005> :bar
-#         => :bar
-#         irb(main):006> _
-#         => :bar
-#         irb(main):007> _
-#         => :bar
-#
-# *   Defines variable `__`:
-#
-#     *   `__` unadorned: contains all evaluation history:
-#
-#             irb(main):008> :foo
-#             => :foo
-#             irb(main):009> :bar
-#             => :bar
-#             irb(main):010> :baz
-#             => :baz
-#             irb(main):011> :bat
-#             => :bat
-#             irb(main):012> :bam
-#             => :bam
-#             irb(main):013> __
-#             =>
-#             9 :bar
-#             10 :baz
-#             11 :bat
-#             12 :bam
-#             irb(main):014> __
-#             =>
-#             10 :baz
-#             11 :bat
-#             12 :bam
-#             13 ...self-history...
-#
-#         Note that when the evaluation is multiline, it is displayed
-#         differently.
-#
-#     *   `__[`*m*`]`:
-#
-#         *   Positive *m*:  contains the evaluation for the given line number,
-#             or `nil` if that line number is not in the evaluation history:
-#
-#                 irb(main):015> __[12]
-#                 => :bam
-#                 irb(main):016> __[1]
-#                 => nil
-#
-#         *   Negative *m*: contains the `mth`-from-end evaluation, or `nil` if
-#             that evaluation is not in the evaluation history:
-#
-#                 irb(main):017> __[-3]
-#                 => :bam
-#                 irb(main):018> __[-13]
-#                 => nil
-#
-#         *   Zero *m*: contains `nil`:
-#
-#                 irb(main):019> __[0]
-#                 => nil
-#
-#
-#
-#
-# ### Prompt and Return Formats
-#
-# By default, IRB uses the prompt and return value formats defined in its
-# `:DEFAULT` prompt mode.
-#
-# #### The Default Prompt and Return Format
-#
-# The default prompt and return values look like this:
-#
-#     irb(main):001> 1 + 1
-#     => 2
-#     irb(main):002> 2 + 2
-#     => 4
-#
-# The prompt includes:
-#
-# *   The name of the running program (`irb`); see [IRB
-#     Name](rdoc-ref:IRB@IRB+Name).
-# *   The name of the current session (`main`); See [IRB
-#     Sessions](rdoc-ref:IRB@IRB+Sessions).
-# *   A 3-digit line number (1-based).
-#
-#
-# The default prompt actually defines three formats:
-#
-# *   One for most situations (as above):
-#
-#         irb(main):003> Dir
-#         => Dir
-#
-# *   One for when the typed command is a statement continuation (adds trailing
-#     asterisk):
-#
-#         irb(main):004* Dir.
-#
-# *   One for when the typed command is a string continuation (adds trailing
-#     single-quote):
-#
-#         irb(main):005' Dir.entries('.
-#
-#
-# You can see the prompt change as you type the characters in the following:
-#
-#     irb(main):001* Dir.entries('.').select do |entry|
-#     irb(main):002*   entry.start_with?('R')
-#     irb(main):003> end
-#     => ["README.md", "Rakefile"]
-#
-# #### Pre-Defined Prompts
-#
-# IRB has several pre-defined prompts, stored in hash `IRB.conf[:PROMPT]`:
-#
-#     irb(main):001> IRB.conf[:PROMPT].keys
-#     => [:NULL, :DEFAULT, :CLASSIC, :SIMPLE, :INF_RUBY, :XMP]
-#
-# To see the full data for these, type `IRB.conf[:PROMPT]`.
-#
-# Most of these prompt definitions include specifiers that represent values like
-# the IRB name, session name, and line number; see [Prompt
-# Specifiers](rdoc-ref:IRB@Prompt+Specifiers).
-#
-# You can change the initial prompt and return format by:
-#
-# *   Adding to the configuration file: `IRB.conf[:PROMPT] = *mode*` where
-#     *mode* is the symbol name of a prompt mode.
-# *   Giving a command-line option:
-#
-#     *   `--prompt *mode*`: sets the prompt mode to *mode*. where *mode* is the
-#         symbol name of a prompt mode.
-#     *   `--simple-prompt` or `--sample-book-mode`: sets the prompt mode to
-#         `:SIMPLE`.
-#     *   `--inf-ruby-mode`: sets the prompt mode to `:INF_RUBY` and suppresses
-#         both `--multiline` and `--singleline`.
-#     *   `--noprompt`: suppresses prompting; does not affect echoing.
-#
-#
-#
-# You can retrieve or set the current prompt mode with methods
-#
-# `conf.prompt_mode` and `conf.prompt_mode=`.
-#
-# If you're interested in prompts and return formats other than the defaults,
-# you might experiment by trying some of the others.
-#
-# #### Custom Prompts
-#
-# You can also define custom prompts and return formats, which may be done
-# either in an IRB session or in the configuration file.
-#
-# A prompt in IRB actually defines three prompts, as seen above. For simple
-# custom data, we'll make all three the same:
-#
-#     irb(main):001* IRB.conf[:PROMPT][:MY_PROMPT] = {
-#     irb(main):002*   PROMPT_I: ': ',
-#     irb(main):003*   PROMPT_C: ': ',
-#     irb(main):004*   PROMPT_S: ': ',
-#     irb(main):005*   RETURN: '=> '
-#     irb(main):006> }
-#     => {:PROMPT_I=>": ", :PROMPT_C=>": ", :PROMPT_S=>": ", :RETURN=>"=> "}
-#
-# If you define the custom prompt in the configuration file, you can also make
-# it the current prompt by adding:
-#
-#     IRB.conf[:PROMPT_MODE] = :MY_PROMPT
-#
-# Regardless of where it's defined, you can make it the current prompt in a
-# session:
-#
-#     conf.prompt_mode = :MY_PROMPT
-#
-# You can view or modify the current prompt data with various configuration
-# methods:
-#
-# *   `conf.prompt_mode`, `conf.prompt_mode=`.
-# *   `conf.prompt_c`, `conf.c=`.
-# *   `conf.prompt_i`, `conf.i=`.
-# *   `conf.prompt_s`, `conf.s=`.
-# *   `conf.return_format`, `return_format=`.
-#
-#
-# #### Prompt Specifiers
-#
-# A prompt's definition can include specifiers for which certain values are
-# substituted:
-#
-# *   `%N`: the name of the running program.
-# *   `%m`: the value of `self.to_s`.
-# *   `%M`: the value of `self.inspect`.
-# *   `%l`: an indication of the type of string; one of `"`, `'`, `/`, `]`.
-# *   `%NNi`: Indentation level. NN is a 2-digit number that specifies the number
-#             of digits of the indentation level (03 will result in 001).
-# *   `%NNn`: Line number. NN is a 2-digit number that specifies the number
-#             of digits of the line number (03 will result in 001).
-# *   `%%`: Literal `%`.
-#
-#
-# ### Verbosity
-#
-# By default, IRB verbosity is disabled, which means that output is smaller
-# rather than larger.
-#
-# You can enable verbosity by:
-#
-# *   Adding to the configuration file: `IRB.conf[:VERBOSE] = true` (the default
-#     is `nil`).
-# *   Giving command-line options `--verbose` (the default is `--noverbose`).
-#
-#
-# During a session, you can retrieve or set verbosity with methods
-# `conf.verbose` and `conf.verbose=`.
-#
-# ### Help
-#
-# Command-line option `--version` causes IRB to print its help text and exit.
-#
-# ### Version
-#
-# Command-line option `--version` causes IRB to print its version text and exit.
-#
-# ## Input and Output
-#
-# ### Color Highlighting
-#
-# By default, IRB color highlighting is enabled, and is used for both:
-#
-# *   Input: As you type, IRB reads the typed characters and highlights elements
-#     that it recognizes; it also highlights errors such as mismatched
-#     parentheses.
-# *   Output: IRB highlights syntactical elements.
-#
-#
-# You can disable color highlighting by:
-#
-# *   Adding to the configuration file: `IRB.conf[:USE_COLORIZE] = false` (the
-#     default value is `true`).
-# *   Giving command-line option `--nocolorize`
-#
-#
-# ## Debugging
-#
-# Command-line option `-d` sets variables `$VERBOSE` and `$DEBUG` to `true`;
-# these have no effect on IRB output.
-#
-# ### Warnings
-#
-# Command-line option `-w` suppresses warnings.
-#
-# Command-line option `-W[*level*]` sets warning level;
-#
-# * 0=silence
-# * 1=medium
-# * 2=verbose
-#
-# ## Other Features
-#
-# ### Load Modules
-#
-# You can specify the names of modules that are to be required at startup.
-#
-# Array `conf.load_modules` determines the modules (if any) that are to be
-# required during session startup. The array is used only during session
-# startup, so the initial value is the only one that counts.
-#
-# The default initial value is `[]` (load no modules):
-#
-#     irb(main):001> conf.load_modules
-#     => []
-#
-# You can set the default initial value via:
-#
-# *   Command-line option `-r`
-#
-#          $ irb -r csv -r json
-#         irb(main):001> conf.load_modules
-#         => ["csv", "json"]
-#
-# *   Hash entry `IRB.conf[:LOAD_MODULES] = *array*`:
-#
-#         IRB.conf[:LOAD_MODULES] = %w[csv, json]
-#
-#
-# Note that the configuration file entry overrides the command-line options.
-#
-# ### RI Documentation Directories
-#
-# You can specify the paths to RI documentation directories that are to be
-# loaded (in addition to the default directories) at startup; see details about
-# RI by typing `ri --help`.
-#
-# Array `conf.extra_doc_dirs` determines the directories (if any) that are to be
-# loaded during session startup. The array is used only during session startup,
-# so the initial value is the only one that counts.
-#
-# The default initial value is `[]` (load no extra documentation):
-#
-#     irb(main):001> conf.extra_doc_dirs
-#     => []
-#
-# You can set the default initial value via:
-#
-# *   Command-line option `--extra_doc_dir`
-#
-#         $ irb --extra-doc-dir your_doc_dir --extra-doc-dir my_doc_dir
-#         irb(main):001> conf.extra_doc_dirs
-#         => ["your_doc_dir", "my_doc_dir"]
-#
-# *   Hash entry `IRB.conf[:EXTRA_DOC_DIRS] = *array*`:
-#
-#         IRB.conf[:EXTRA_DOC_DIRS] = %w[your_doc_dir my_doc_dir]
-#
-#
-# Note that the configuration file entry overrides the command-line options.
-#
-# ### IRB Name
-#
-# You can specify a name for IRB.
-#
-# The default initial value is `'irb'`:
-#
-#     irb(main):001> conf.irb_name
-#     => "irb"
-#
-# You can set the default initial value via hash entry `IRB.conf[:IRB_NAME] =
-# *string*`:
-#
-#     IRB.conf[:IRB_NAME] = 'foo'
-#
-# ### Application Name
-#
-# You can specify an application name for the IRB session.
-#
-# The default initial value is `'irb'`:
-#
-#     irb(main):001> conf.ap_name
-#     => "irb"
-#
-# You can set the default initial value via hash entry `IRB.conf[:AP_NAME] =
-# *string*`:
-#
-#     IRB.conf[:AP_NAME] = 'my_ap_name'
-#
-# ### Configuration Monitor
-#
-# You can monitor changes to the configuration by assigning a proc to
-# `IRB.conf[:IRB_RC]` in the configuration file:
-#
-#     IRB.conf[:IRB_RC] = proc {|conf| puts conf.class }
-#
-# Each time the configuration is changed, that proc is called with argument
-# `conf`:
-#
-# ### Encodings
-#
-# Command-line option `-E *ex*[:*in*]` sets initial external (ex) and internal
-# (in) encodings.
-#
-# Command-line option `-U` sets both to UTF-8.
-#
-# ### Commands
-#
-# Please use the `help` command to see the list of available commands.
-#
-# ### IRB Sessions
-#
-# IRB has a special feature, that allows you to manage many sessions at once.
-#
-# You can create new sessions with Irb.irb, and get a list of current sessions
-# with the `jobs` command in the prompt.
-#
-# #### Configuration
-#
-# The command line options, or IRB.conf, specify the default behavior of
-# Irb.irb.
-#
-# On the other hand, each conf in IRB@Command-Line+Options is used to
-# individually configure IRB.irb.
-#
-# If a proc is set for `IRB.conf[:IRB_RC]`, its will be invoked after execution
-# of that proc with the context of the current session as its argument. Each
-# session can be configured using this mechanism.
-#
-# #### Session variables
-#
-# There are a few variables in every Irb session that can come in handy:
-#
-# `_`
-# :   The value command executed, as a local variable
-# `__`
-# :   The history of evaluated commands. Available only if
-#     `IRB.conf[:EVAL_HISTORY]` is not `nil` (which is the default). See also
-#     IRB::Context#eval_history= and IRB::History.
-# `__[line_no]`
-# :   Returns the evaluation value at the given line number, `line_no`. If
-#     `line_no` is a negative, the return value `line_no` many lines before the
-#     most recent return value.
-#
-#
-# ## Restrictions
-#
-# Ruby code typed into IRB behaves the same as Ruby code in a file, except that:
-#
-# *   Because IRB evaluates input immediately after it is syntactically
-#     complete, some results may be slightly different.
-# *   Forking may not be well behaved.
-#
 module IRB
 
   # An exception raised by IRB.irb_abort
@@ -902,7 +51,13 @@ module IRB
         irb = Irb.new(nil, @CONF[:SCRIPT])
       else
         irb = Irb.new
+
+        # Only display the banner in the irb executable
+        if @CONF[:SHOW_BANNER] && ap_path&.end_with?("exe/irb")
+          StartupMessage.display
+        end
       end
+
       irb.run(@CONF)
     end
 
@@ -929,6 +84,15 @@ module IRB
     PROMPT_MAIN_TRUNCATE_OMISSION = '...'
     CONTROL_CHARACTERS_PATTERN = "\x00-\x1F"
 
+    # Track the nesting depth of run loops. This is used for history management
+    # only the outermost run loop should load/save history.
+    @run_nesting_depth = 0
+
+    class << self
+      # TODO: When refactoring to v2.0, find a better way to manage and track nesting sessions.
+      attr_accessor :run_nesting_depth
+    end
+
     # Returns the current context of this irb session
     attr_reader :context
     # The lexer used by this irb session
@@ -939,6 +103,7 @@ module IRB
     # Creates a new irb session
     def initialize(workspace = nil, input_method = nil, from_binding: false)
       @from_binding = from_binding
+      @prompt_part_cache = nil
       @context = Context.new(self, workspace, input_method)
       @context.workspace.load_helper_methods_to_main
       @signal_status = :IN_IRB
@@ -999,7 +164,10 @@ module IRB
     end
 
     def run(conf = IRB.conf)
-      in_nested_session = !!conf[:MAIN_CONTEXT]
+      # Use run_nesting_depth to determine if we're in a nested session.
+      in_nested_session = Irb.run_nesting_depth > 0
+      Irb.run_nesting_depth += 1
+
       conf[:IRB_RC].call(context) if conf[:IRB_RC]
       prev_context = conf[:MAIN_CONTEXT]
       conf[:MAIN_CONTEXT] = context
@@ -1025,6 +193,8 @@ module IRB
           eval_input
         end
       ensure
+        Irb.run_nesting_depth -= 1
+
         # Do not restore to nil. It will cause IRB crash when used with threads.
         IRB.conf[:MAIN_CONTEXT] = prev_context if prev_context
 
@@ -1090,13 +260,7 @@ module IRB
       end
     end
 
-    def readmultiline
-      prompt = generate_prompt([], false, 0)
-
-      # multiline
-      return read_input(prompt) if @context.io.respond_to?(:check_termination)
-
-      # nomultiline
+    def read_input_nomultiline(prompt)
       code = +''
       line_offset = 0
       loop do
@@ -1108,42 +272,51 @@ module IRB
         code << line
         return code if command?(code)
 
-        tokens, opens, terminated = @scanner.check_code_state(code, local_variables: @context.local_variables)
+        continue, opens, terminated = @scanner.check_code_state(code, local_variables: @context.local_variables)
         return code if terminated
 
         line_offset += 1
-        continue = @scanner.should_continue?(tokens)
         prompt = generate_prompt(opens, continue, line_offset)
       end
     end
 
+    def readmultiline
+      with_prompt_part_cached do
+        prompt = generate_prompt([], false, 0)
+
+        if @context.io.respond_to?(:check_termination)
+          # multiline
+          read_input(prompt)
+        else
+          # nomultiline
+          read_input_nomultiline(prompt)
+        end
+      end
+    end
+
     def each_top_level_statement
       loop do
         code = readmultiline
         break unless code
-        yield build_statement(code), @line_no
+        yield parse_input(code), @line_no
         @line_no += code.count("\n")
       rescue RubyLex::TerminateLineInput
       end
     end
 
-    def build_statement(code)
+    def parse_input(code)
       if code.match?(/\A\n*\z/)
         return Statement::EmptyInput.new
       end
 
       code = code.dup.force_encoding(@context.io.encoding)
-      if (command, arg = @context.parse_command(code))
-        command_class = Command.load_command(command)
-        Statement::Command.new(code, command_class, arg)
-      else
-        is_assignment_expression = @scanner.assignment_expression?(code, local_variables: @context.local_variables)
-        Statement::Expression.new(code, is_assignment_expression)
-      end
+      is_assignment_expression = @scanner.assignment_expression?(code, local_variables: @context.local_variables)
+
+      @context.parse_input(code, is_assignment_expression)
     end
 
     def command?(code)
-      !!@context.parse_command(code)
+      parse_input(code).is_a?(Statement::Command)
     end
 
     def configure_io
@@ -1163,23 +336,25 @@ module IRB
           else
             next true if command?(code)
 
-            _tokens, _opens, terminated = @scanner.check_code_state(code, local_variables: @context.local_variables)
+            _continue, _opens, terminated = @scanner.check_code_state(code, local_variables: @context.local_variables)
             terminated
           end
         end
       end
       if @context.io.respond_to?(:dynamic_prompt)
         @context.io.dynamic_prompt do |lines|
-          tokens = RubyLex.ripper_lex_without_warning(lines.map{ |l| l + "\n" }.join, local_variables: @context.local_variables)
-          line_results = IRB::NestingParser.parse_by_line(tokens)
+          code = lines.map{ |l| l + "\n" }.join
+          parse_lex_result = Prism.parse_lex(code, scopes: [@context.local_variables])
+          line_results = IRB::NestingParser.parse_by_line(parse_lex_result)
+
+          tokens = parse_lex_result.value[1].map(&:first)
+          tokens_by_line = tokens.group_by {|t| t.location.start_line - 1 }
+
           tokens_until_line = []
-          line_results.map.with_index do |(line_tokens, _prev_opens, next_opens, _min_depth), line_num_offset|
-            line_tokens.each do |token, _s|
-              # Avoid appending duplicated token. Tokens that include "n" like multiline
-              # tstring_content can exist in multiple lines.
-              tokens_until_line << token if token != tokens_until_line.last
-            end
-            continue = @scanner.should_continue?(tokens_until_line)
+          line_results.map.with_index do |(_prev_opens, next_opens, _min_depth), line_num_offset|
+            line = lines[line_num_offset]
+            tokens_until_line.concat(tokens_by_line[line_num_offset] || [])
+            continue = @scanner.should_continue?(tokens_until_line, line, line_num_offset + 1)
             generate_prompt(next_opens, continue, line_num_offset)
           end
         end
@@ -1191,8 +366,8 @@ module IRB
           next nil if !is_newline && lines[line_index]&.byteslice(0, byte_pointer)&.match?(/\A\s*\z/)
 
           code = lines[0..line_index].map { |l| "#{l}\n" }.join
-          tokens = RubyLex.ripper_lex_without_warning(code, local_variables: @context.local_variables)
-          @scanner.process_indent_level(tokens, lines, line_index, is_newline)
+          parse_lex_result = Prism.parse_lex(code, scopes: [@context.local_variables])
+          @scanner.process_indent_level(parse_lex_result, lines, line_index, is_newline)
         end
       end
     end
@@ -1282,7 +457,10 @@ module IRB
       # The "<top (required)>" in "(irb)" may be the top level of IRB so imitate the main object.
       message = message.gsub(/\(irb\):(?<num>\d+):in (?<open_quote>[`'])<(?<frame>top \(required\))>'/) { "(irb):#{$~[:num]}:in #{$~[:open_quote]}<main>'" }
       puts message
-      puts 'Maybe IRB bug!' if irb_bug
+
+      if irb_bug
+        puts "This may be an issue with IRB. If you believe this is an unexpected behavior, please report it to https://github.com/ruby/irb/issues"
+      end
     rescue Exception => handler_exc
       begin
         puts exc.inspect
@@ -1369,40 +547,36 @@ module IRB
     end
 
     def output_value(omit = false) # :nodoc:
-      str = @context.inspect_last_value
-      multiline_p = str.include?("\n")
-      if omit
-        winwidth = @context.io.winsize.last
-        if multiline_p
-          first_line = str.split("\n").first
-          result = @context.newline_before_multiline_output? ? (@context.return_format % first_line) : first_line
-          output_width = Reline::Unicode.calculate_width(result, true)
-          diff_size = output_width - Reline::Unicode.calculate_width(first_line, true)
-          if diff_size.positive? and output_width > winwidth
-            lines, _ = Reline::Unicode.split_by_width(first_line, winwidth - diff_size - 3)
-            str = "%s..." % lines.first
-            str += "\e[0m" if Color.colorable?
-            multiline_p = false
-          else
-            str = str.gsub(/(\A.*?\n).*/m, "\\1...")
-            str += "\e[0m" if Color.colorable?
-          end
-        else
-          output_width = Reline::Unicode.calculate_width(@context.return_format % str, true)
-          diff_size = output_width - Reline::Unicode.calculate_width(str, true)
-          if diff_size.positive? and output_width > winwidth
-            lines, _ = Reline::Unicode.split_by_width(str, winwidth - diff_size - 3)
-            str = "%s..." % lines.first
-            str += "\e[0m" if Color.colorable?
-          end
-        end
+      unless @context.return_format.include?('%')
+        puts @context.return_format
+        return
       end
 
-      if multiline_p && @context.newline_before_multiline_output?
-        str = "\n" + str
+      winheight, winwidth = @context.io.winsize
+      if omit
+        content, overflow = Pager.take_first_page(winwidth, 1) do |out|
+          @context.inspect_last_value(out)
+        end
+        if overflow
+          content = "\n#{content}" if @context.newline_before_multiline_output?
+          content = "#{content}..."
+          content = "#{content}\e[0m" if Color.colorable?
+        end
+        puts format(@context.return_format, content.chomp)
+      elsif Pager.should_page? && @context.inspector_support_stream_output?
+        formatter_proc = ->(content, multipage) do
+          content = content.chomp
+          content = "\n#{content}" if @context.newline_before_multiline_output? && (multipage || content.include?("\n"))
+          format(@context.return_format, content)
+        end
+        Pager.page_with_preview(winwidth, winheight, formatter_proc) do |out|
+          @context.inspect_last_value(out)
+        end
+      else
+        content = @context.inspect_last_value.chomp
+        content = "\n#{content}" if @context.newline_before_multiline_output? && content.include?("\n")
+        Pager.page_content(format(@context.return_format, content), retain_content: true)
       end
-
-      Pager.page_content(format(@context.return_format, str), retain_content: true)
     end
 
     # Outputs the local variables to this current session, including #signal_status
@@ -1424,8 +598,15 @@ module IRB
 
     private
 
+    def with_prompt_part_cached
+      @prompt_part_cache = {}
+      yield
+    ensure
+      @prompt_part_cache = nil
+    end
+
     def generate_prompt(opens, continue, line_offset)
-      ltype = @scanner.ltype_from_open_tokens(opens)
+      ltype = @scanner.ltype_from_open_nestings(opens)
       indent = @scanner.calc_indent_level(opens)
       continue = opens.any? || continue
       line_no = @line_no + line_offset
@@ -1455,25 +636,29 @@ module IRB
     end
 
     def truncate_prompt_main(str) # :nodoc:
-      str = str.tr(CONTROL_CHARACTERS_PATTERN, ' ')
-      if str.size <= PROMPT_MAIN_TRUNCATE_LENGTH
-        str
-      else
-        str[0, PROMPT_MAIN_TRUNCATE_LENGTH - PROMPT_MAIN_TRUNCATE_OMISSION.size] + PROMPT_MAIN_TRUNCATE_OMISSION
+      if str.size > PROMPT_MAIN_TRUNCATE_LENGTH
+        str = str[0, PROMPT_MAIN_TRUNCATE_LENGTH - PROMPT_MAIN_TRUNCATE_OMISSION.size] + PROMPT_MAIN_TRUNCATE_OMISSION
       end
+      str.tr(CONTROL_CHARACTERS_PATTERN, ' ')
     end
 
     def format_prompt(format, ltype, indent, line_no) # :nodoc:
+      # @prompt_part_cache could be nil in unit tests
+      part_cache = @prompt_part_cache || {}
       format.gsub(/%([0-9]+)?([a-zA-Z%])/) do
         case $2
         when "N"
           @context.irb_name
         when "m"
-          main_str = @context.safe_method_call_on_main(:to_s) rescue "!#{$!.class}"
-          truncate_prompt_main(main_str)
+          part_cache[:m] ||= (
+            main_str = "#{@context.safe_method_call_on_main(:to_s)}" rescue "!#{$!.class}"
+            truncate_prompt_main(main_str)
+          )
         when "M"
-          main_str = @context.safe_method_call_on_main(:inspect) rescue "!#{$!.class}"
-          truncate_prompt_main(main_str)
+          part_cache[:M] ||= (
+            main_str = "#{@context.safe_method_call_on_main(:inspect)}" rescue "!#{$!.class}"
+            truncate_prompt_main(main_str)
+          )
         when "l"
           ltype
         when "i"