Always start IEx shell via -user

There is some uncertainty as to wether it will be possible
to start an IEx shell dynamically from a -noshell environment.

Therefore, this PR simplifies the shell booting to still
rely on -user, as it did earlier than Erlang/OTP 26.

Author: josevalim

Diff for: bin/elixir

@@ -218,6 +218,7 @@ SELF=$(readlink_f "$0")
 SCRIPT_PATH=$(dirname "$SELF")
 
 if [ "$OSTYPE" = "cygwin" ]; then SCRIPT_PATH=$(cygpath -m "$SCRIPT_PATH"); fi
+if [ "$MODE" != "iex" ]; then ERL="-noshell -s elixir start_cli $ERL"; fi
 
 if [ "$OS" != "Windows_NT" ] && [ -z "$NO_COLOR" ]; then
   if test -t 1 -a -t 2; then ERL="-elixir ansi_enabled true $ERL"; fi
@@ -228,7 +229,7 @@ fi
 ERTS_BIN=
 ERTS_BIN="$ERTS_BIN"
 
-set -- "$ERTS_BIN$ERL_EXEC" -noshell -elixir_root "$SCRIPT_PATH"/../lib -pa "$SCRIPT_PATH"/../lib/elixir/ebin $ELIXIR_ERL_OPTIONS -s elixir start_$MODE $ERL "$@"
+set -- "$ERTS_BIN$ERL_EXEC" -elixir_root "$SCRIPT_PATH"/../lib -pa "$SCRIPT_PATH"/../lib/elixir/ebin $ELIXIR_ERL_OPTIONS $ERL "$@"
 
 if [ -n "$RUN_ERL_PIPE" ]; then
   ESCAPED=""

Diff for: bin/elixir.bat

@@ -161,13 +161,11 @@ reg query HKCU\Console /v VirtualTerminalLevel 2>nul | findstr /e "0x1" >nul 2>n
 if %errorlevel% == 0 (
   set beforeExtra=-elixir ansi_enabled true !beforeExtra!
 )
-if defined useIEx (
-  set beforeExtra=-s elixir start_iex !beforeExtra!
-) else (
-  set beforeExtra=-s elixir start_cli !beforeExtra!
+if not defined useIEx (
+  set beforeExtra=-noshell -s elixir start_cli !beforeExtra!
 )
 
-set beforeExtra=-noshell -elixir_root "!SCRIPT_PATH!..\lib" -pa "!SCRIPT_PATH!..\lib\elixir\ebin" !beforeExtra!
+set beforeExtra=-elixir_root "!SCRIPT_PATH!..\lib" -pa "!SCRIPT_PATH!..\lib\elixir\ebin" !beforeExtra!
 
 if defined ELIXIR_CLI_DRY_RUN (
    if defined useWerl (

Diff for: lib/elixir/lib/system.ex

@@ -305,22 +305,6 @@ defmodule System do
     :elixir_config.get(:no_halt)
   end
 
-  @doc """
-  Waits until the system boots.
-
-  Calling this function blocks until all of ARGV is processed.
-  Inside a release, this means the boot script and then ARGV
-  have been processed. This is only useful for those implementing
-  custom shells/consoles on top of Elixir.
-
-  However, be careful to not invoke this command from within
-  the process that is processing the command line arguments,
-  as doing so would lead to a deadlock.
-  """
-  @doc since: "1.15.0"
-  @spec wait_until_booted() :: :ok
-  defdelegate wait_until_booted(), to: :elixir_config
-
   @doc """
   Current working directory.
 

Diff for: lib/elixir/src/elixir.erl

@@ -2,7 +2,7 @@
 %% private to the Elixir compiler and reserved to be used by Elixir only.
 -module(elixir).
 -behaviour(application).
--export([start_cli/0, start/0, start_iex/0]).
+-export([start_cli/0, start/0]).
 -export([start/2, stop/1, config_change/3]).
 -export([
   string_to_tokens/5, tokens_to_quoted/3, 'string_to_quoted!'/5,
@@ -176,16 +176,12 @@ check_file_encoding(Encoding) ->
   end.
 
 %% Boot and process given options. Invoked by Elixir's script.
-
-%% TODO: Delete prim_tty branches and -user on Erlang/OTP 26.
-%% TODO: Remove IEx.CLI module
-%% TODO: Replace "-user elixir" and "-s elixir start_$MODE"
-%% by calls to "-s elixir cli" and "-e iex:cli()"
+%% TODO: Delete prim_tty branches on Erlang/OTP 26.
 
 start() ->
   case code:ensure_loaded(prim_tty) of
     {module, _} ->
-      user_drv:start(#{initial_shell => noshell});
+      user_drv:start(#{initial_shell => iex:shell()});
     {error, _} ->
       case init:get_argument(elixir_root) of
         {ok, [[Root]]} -> code:add_patha(Root ++ "/iex/ebin");
@@ -207,18 +203,7 @@ start_cli() ->
     {error, _}  -> ok
   end,
 
-  'Elixir.Kernel.CLI':main(init:get_plain_arguments()),
-  elixir_config:booted().
-
-start_iex() ->
-  case code:ensure_loaded(prim_tty) of
-    {module, _} ->
-      start_cli(),
-      iex:cli();
-
-    {error, _} ->
-      ok
-  end.
+  'Elixir.Kernel.CLI':main(init:get_plain_arguments()).
 
 %% EVAL HOOKS
 

Diff for: lib/elixir/src/elixir_config.erl

@@ -1,6 +1,6 @@
 -module(elixir_config).
 -compile({no_auto_import, [get/1]}).
--export([new/1, warn/2, serial/1, booted/0, wait_until_booted/0]).
+-export([new/1, warn/2, serial/1]).
 -export([static/1, is_bootstrap/0, identifier_tokenizer/0]).
 -export([delete/1, put/2, get/1, get/2, update/2, get_and_put/2]).
 -export([start_link/0, init/1, handle_call/3, handle_cast/2]).
@@ -48,11 +48,6 @@ delete(?MODULE) ->
 
 %% MISC
 
-booted() ->
-  gen_server:call(?MODULE, booted, infinity).
-wait_until_booted() ->
-  gen_server:call(?MODULE, wait_until_booted, infinity).
-
 serial(Fun) ->
   gen_server:call(?MODULE, {serial, Fun}, infinity).
 
@@ -75,27 +70,19 @@ start_link() ->
 init(?MODULE) ->
   {ok, []}.
 
-handle_call(booted, _From, Booted) when is_list(Booted) ->
-  [gen_server:reply(Caller, ok) || Caller <- Booted],
-  {reply, ok, done};
-handle_call(wait_until_booted, From, Booted) ->
-  if
-    is_list(Booted) -> {noreply, [From | Booted]};
-    Booted =:= done -> {reply, ok, Booted}
-  end;
-handle_call({serial, Fun}, _From, Booted) ->
-  {reply, Fun(), Booted};
-handle_call({put, Key, Value}, _From, Booted) ->
+handle_call({serial, Fun}, _From, State) ->
+  {reply, Fun(), State};
+  handle_call({put, Key, Value}, _From, State) ->
   ets:insert(?MODULE, {Key, Value}),
-  {reply, ok, Booted};
-handle_call({update, Key, Fun}, _From, Booted) ->
+  {reply, ok, State};
+handle_call({update, Key, Fun}, _From, State) ->
   Value = Fun(get(Key)),
   ets:insert(?MODULE, {Key, Value}),
-  {reply, Value, Booted};
-handle_call({get_and_put, Key, Value}, _From, Booted) ->
+  {reply, Value, State};
+handle_call({get_and_put, Key, Value}, _From, State) ->
   OldValue = get(Key),
   ets:insert(?MODULE, {Key, Value}),
-  {reply, OldValue, Booted}.
+  {reply, OldValue, State}.
 
 handle_cast(Cast, Tab) ->
   {stop, {bad_cast, Cast}, Tab}.

Diff for: lib/elixir/src/elixir_errors.erl

@@ -299,7 +299,9 @@ print_error(Meta, Env, Module, Desc) ->
 %% Compilation error.
 
 -spec compile_error(#{file := binary(), _ => _}) -> no_return().
-compile_error(#{module := Module, file := File}) when Module /= nil ->
+%% We check for the lexical tracker because pry() inside a module
+%% will have the environment but not a tracker.
+compile_error(#{module := Module, file := File, lexical_tracker := LT}) when Module /= nil, LT /= nil ->
   Inspected = elixir_aliases:inspect(Module),
   Message = io_lib:format("cannot compile module ~ts (errors have been logged)", [Inspected]),
   compile_error([], File, Message);

Diff for: lib/elixir/src/iex.erl

@@ -1,5 +1,5 @@
 -module(iex).
--export([cli/0]).
+-export([start/0, start/2, shell/0, sync_remote/2]).
 
 %% Manual tests for changing the CLI boot.
 %%
@@ -24,28 +24,57 @@
 %% 4. Finally, in some other circumstances, printing messages may become
 %%    borked. This can be verified with:
 %%
-%%      $ iex -e ":logger.info('foo~nbar', [])"
+%%      $ iex -e ":logger.info(~c'foo~nbar', [])"
 %%
 %% By the time those instructions have been written, all tests above pass.
-cli() ->
+
+start() ->
+  start([], {elixir_utils, noop, []}).
+
+start(Opts, MFA) ->
+  {ok, _} = application:ensure_all_started(elixir),
+  {ok, _} = application:ensure_all_started(iex),
+
   spawn(fun() ->
-    elixir_config:wait_until_booted(),
-    (shell:whereis() =:= undefined) andalso start_shell()
+    case init:notify_when_started(self()) of
+      started -> ok;
+      _ -> init:wait_until_started()
+    end,
+
+    ok = io:setopts([{binary, true}, {encoding, unicode}]),
+    'Elixir.IEx.Server':run_from_shell(Opts, MFA)
   end).
 
-start_shell() ->
+shell() ->
   Args = init:get_plain_arguments(),
-  Opts = [{remote, get_remsh(Args)}, {dot_iex_path, get_dot_iex(Args)}, {on_eof, halt}],
 
-  case 'Elixir.IEx':shell(Opts) of
-    {ok, _Shell} ->
-      ok;
+  case get_remsh(Args) of
+    nil ->
+      start_mfa(Args, {elixir, start_cli, []});
 
-    {error, Reason} ->
-      io:format(standard_error, "Could not start IEx CLI due to reason: ~tp", [Reason]),
-      erlang:halt(1)
+    Remote ->
+      Ref = make_ref(),
+
+      Parent =
+        spawn_link(fun() ->
+          receive
+            {'begin', Ref, Other} ->
+              elixir:start_cli(),
+              Other ! {done, Ref}
+          end
+        end),
+
+      {remote, Remote, start_mfa(Args, {?MODULE, sync_remote, [Parent, Ref]})}
   end.
 
+sync_remote(Parent, Ref) ->
+  Parent ! {'begin', Ref, self()},
+  receive {done, Ref} -> ok end.
+
+start_mfa(Args, MFA) ->
+  Opts = [{dot_iex_path, get_dot_iex(Args)}, {on_eof, halt}],
+  {?MODULE, start, [Opts, MFA]}.
+
 get_dot_iex(["--dot-iex", H | _]) -> elixir_utils:characters_to_binary(H);
 get_dot_iex([_ | T]) -> get_dot_iex(T);
 get_dot_iex([]) -> nil.

Diff for: lib/iex/lib/iex.ex

@@ -226,7 +226,7 @@ defmodule IEx do
   alternate between them. Let's give it a try:
 
       User switch command
-       --> s 'Elixir.IEx'
+       --> s iex
        --> c
 
   The command above will start a new shell and connect to it.
@@ -858,71 +858,10 @@ defmodule IEx do
 
   ## CLI
 
-  # This is a callback invoked by Erlang shell utilities
-  # when someone presses Ctrl+G and adds `s 'Elixir.IEx'`.
+  # TODO: Remove me on Elixir v1.20+
   @doc false
-  def start(opts \\ [], mfa \\ {IEx, :dont_display_result, []}) do
-    # TODO: Expose this as iex:start() instead on Erlang/OTP 26+
-    # TODO: Keep only this branch, delete optional args and mfa,
-    # and delete IEx.Server.run_from_shell/2 on Erlang/OTP 26+
-    if Code.ensure_loaded?(:prim_tty) do
-      spawn(fn ->
-        {:ok, _} = Application.ensure_all_started(:iex)
-        :ok = :io.setopts(binary: true, encoding: :unicode)
-        _ = for fun <- Enum.reverse(after_spawn()), do: fun.()
-        IEx.Server.run([register: false] ++ opts)
-      end)
-    else
-      spawn(fn ->
-        case :init.notify_when_started(self()) do
-          :started -> :ok
-          _ -> :init.wait_until_started()
-        end
-
-        {:ok, _} = Application.ensure_all_started(:iex)
-        :ok = :io.setopts(binary: true, encoding: :unicode)
-        _ = for fun <- Enum.reverse(after_spawn()), do: fun.()
-        IEx.Server.run_from_shell(opts, mfa)
-      end)
-    end
-  end
-
-  # TODO: The idea is to expose this as a public API once we require
-  # Erlang/OTP 26 but it may not be possible. In such cases, we may
-  # want to move this to another module.
-  # See https://github.com/erlang/otp/issues/8113#issuecomment-1941613281
-  @compile {:no_warn_undefined, {:shell, :start_interactive, 1}}
-
-  @doc false
-  def shell(opts) do
-    {remote, opts} = Keyword.pop(opts, :remote)
-    ref = make_ref()
-    mfa = {__MODULE__, :__shell__, [self(), ref, opts]}
-
-    shell =
-      if remote do
-        {:remote, to_charlist(remote), mfa}
-      else
-        mfa
-      end
-
-    case :shell.start_interactive(shell) do
-      :ok ->
-        receive do
-          {^ref, shell} -> {:ok, shell}
-        after
-          15_000 -> {:error, :timeout}
-        end
-
-      {:error, reason} ->
-        {:error, reason}
-    end
-  end
-
-  @doc false
-  def __shell__(parent, ref, opts) do
-    pid = start(opts)
-    send(parent, {ref, pid})
-    pid
+  def start do
+    IO.warn("Use \"s iex\" instead")
+    :iex.start()
   end
 end

Diff for: lib/iex/lib/iex/broker.ex

@@ -75,54 +75,13 @@ defmodule IEx.Broker do
     GenServer.call(broker_pid, {:refuse, take_ref})
   end
 
-  @doc """
-  Asks to IO if we want to take over.
-  """
-  def take_over?(location, whereami, opts) do
-    evaluator = opts[:evaluator] || self()
-    message = "Request to pry #{inspect(evaluator)} at #{location}#{whereami}"
-    interrupt = IEx.color(:eval_interrupt, "#{message}\nAllow? [Yn] ")
-    yes?(IO.gets(:stdio, interrupt))
-  end
-
-  defp yes?(string) when is_binary(string),
-    do: String.trim(string) in ["", "y", "Y", "yes", "YES", "Yes"]
-
-  defp yes?(charlist) when is_list(charlist),
-    do: yes?(List.to_string(charlist))
-
-  defp yes?(_), do: false
-
   @doc """
   Client requests a takeover.
   """
   @spec take_over(binary, iodata, keyword) ::
           {:ok, server :: pid, group_leader :: pid, counter :: integer}
           | {:error, :no_iex | :refused | atom()}
   def take_over(location, whereami, opts) do
-    case take_over_existing(location, whereami, opts) do
-      {:error, :no_iex} ->
-        cond do
-          # TODO: Remove this check on Erlang/OTP 26+ and {:error, :no_iex} return
-          not Code.ensure_loaded?(:prim_tty) ->
-            {:error, :no_iex}
-
-          take_over?(location, whereami, opts) ->
-            case IEx.shell(opts) do
-              {:ok, shell} -> {:ok, shell, Process.group_leader(), 1}
-              {:error, reason} -> {:error, reason}
-            end
-
-          true ->
-            {:error, :refused}
-        end
-
-      other ->
-        other
-    end
-  end
-
-  defp take_over_existing(location, whereami, opts) do
     case GenServer.whereis(@name) do
       nil -> {:error, :no_iex}
       _pid -> GenServer.call(@name, {:take_over, location, whereami, opts}, :infinity)