Do not perform completion on evaluated prompts, closes #12191

Author: josevalim

lib/iex/lib/iex.ex

@@ -858,8 +858,8 @@ defmodule IEx do
         _ -> :init.wait_until_started()
       end
 
+      :ok = :io.setopts(binary: true, encoding: :unicode)
       :ok = start_iex()
-      :ok = set_expand_fun()
       :ok = run_after_spawn()
       IEx.Server.run_from_shell(opts, mfa)
     end)
@@ -875,23 +875,6 @@ defmodule IEx do
     :ok
   end
 
-  defp set_expand_fun do
-    gl = Process.group_leader()
-
-    expand_fun =
-      if node(gl) != node() do
-        IEx.Autocomplete.remsh(node())
-      else
-        &IEx.Autocomplete.expand/1
-      end
-
-    # expand_fun is not supported by a shell variant
-    # on Windows, so we do two IO calls, not caring
-    # about the result of the expand_fun one.
-    _ = :io.setopts(gl, expand_fun: expand_fun)
-    :io.setopts(gl, binary: true, encoding: :unicode)
-  end
-
   defp run_after_spawn do
     _ = for fun <- Enum.reverse(after_spawn()), do: fun.()
     :ok

lib/iex/lib/iex/evaluator.ex

@@ -183,9 +183,9 @@ defmodule IEx.Evaluator do
 
   defp loop(%{server: server, ref: ref} = state) do
     receive do
-      {:eval, ^server, code, iex_state} ->
-        {result, status, state} = parse_eval_inspect(code, iex_state, state)
-        send(server, {:evaled, self(), status, result})
+      {:eval, ^server, code, counter, parser_state} ->
+        {status, parser_state, state} = parse_eval_inspect(code, counter, parser_state, state)
+        send(server, {:evaled, self(), status, parser_state})
         loop(state)
 
       {:fields_from_env, ^server, ref, receiver, fields} ->
@@ -285,30 +285,30 @@ defmodule IEx.Evaluator do
     end
   end
 
-  defp parse_eval_inspect(code, iex_state, state) do
+  defp parse_eval_inspect(code, counter, parser_state, state) do
     try do
       {parser_module, parser_fun, args} = IEx.Config.parser()
-      args = [code, [line: iex_state.counter, file: "iex"], iex_state.parser_state | args]
-      eval_and_inspect_parsed(apply(parser_module, parser_fun, args), iex_state, state)
+      args = [code, [line: counter, file: "iex"], parser_state | args]
+      eval_and_inspect_parsed(apply(parser_module, parser_fun, args), counter, state)
     catch
       kind, error ->
         print_error(kind, error, __STACKTRACE__)
-        {%{iex_state | parser_state: ""}, :ok, state}
+        {:error, "", state}
     end
   end
 
-  defp eval_and_inspect_parsed({:ok, forms, parser_state}, iex_state, state) do
+  defp eval_and_inspect_parsed({:ok, forms, parser_state}, counter, state) do
     put_history(state)
     put_whereami(state)
-    state = eval_and_inspect(forms, iex_state.counter, state)
-    {%{iex_state | parser_state: parser_state, counter: iex_state.counter + 1}, :ok, state}
+    state = eval_and_inspect(forms, counter, state)
+    {:ok, parser_state, state}
   after
     Process.delete(:iex_history)
     Process.delete(:iex_whereami)
   end
 
-  defp eval_and_inspect_parsed({:incomplete, parser_state}, iex_state, state) do
-    {%{iex_state | parser_state: parser_state}, :incomplete, state}
+  defp eval_and_inspect_parsed({:incomplete, parser_state}, _counter, state) do
+    {:incomplete, parser_state, state}
   end
 
   defp put_history(%{history: history}) do

lib/iex/lib/iex/server.ex

@@ -1,25 +1,3 @@
-defmodule IEx.State do
-  @moduledoc false
-  # This state is exchanged between IEx.Server and
-  # IEx.Evaluator which is why it is a struct.
-  defstruct parser_state: "",
-            counter: 1,
-            prefix: "iex",
-            on_eof: :stop_evaluator,
-            evaluator_options: [],
-            previous_state: nil
-
-  @type t :: %{
-          __struct__: __MODULE__,
-          parser_state: binary(),
-          counter: pos_integer(),
-          prefix: binary(),
-          on_eof: :stop_evaluator | :halt,
-          evaluator_options: keyword(),
-          previous_state: nil | t()
-        }
-end
-
 defmodule IEx.Server do
   @moduledoc """
   The IEx.Server.
@@ -32,6 +10,15 @@ defmodule IEx.Server do
 
   """
 
+  @doc false
+  defstruct parser_state: "",
+            counter: 1,
+            prefix: "iex",
+            on_eof: :stop_evaluator,
+            evaluator_options: [],
+            expand_fun: nil,
+            previous_state: nil
+
   @doc """
   Starts a new IEx server session.
 
@@ -137,14 +124,16 @@ defmodule IEx.Server do
       write_prompt(:prompt, state.prefix, counter)
     end
 
+    :io.setopts(expand_fun: state.expand_fun)
     input = input || io_get()
     wait_input(state, evaluator, evaluator_ref, input)
   end
 
   defp wait_input(state, evaluator, evaluator_ref, input) do
     receive do
       {:io_reply, ^input, code} when is_binary(code) ->
-        send(evaluator, {:eval, self(), code, state})
+        :io.setopts(expand_fun: fn _ -> {:yes, [], []} end)
+        send(evaluator, {:eval, self(), code, state.counter, state.parser_state})
         wait_eval(state, evaluator, evaluator_ref)
 
       {:io_reply, ^input, :eof} ->
@@ -176,8 +165,10 @@ defmodule IEx.Server do
 
   defp wait_eval(state, evaluator, evaluator_ref) do
     receive do
-      {:evaled, ^evaluator, status, new_state} ->
-        loop(new_state, status, evaluator, evaluator_ref, nil)
+      {:evaled, ^evaluator, status, parser_state} ->
+        counter = if(status == :ok, do: state.counter + 1, else: state.counter)
+        state = %{state | counter: counter, parser_state: parser_state}
+        loop(state, status, evaluator, evaluator_ref, nil)
 
       msg ->
         handle_take_over(msg, state, evaluator, evaluator_ref, nil, fn state ->
@@ -358,9 +349,19 @@ defmodule IEx.Server do
     prefix = Keyword.get(opts, :prefix, "iex")
     on_eof = Keyword.get(opts, :on_eof, :stop_evaluator)
 
-    %IEx.State{
+    gl = Process.group_leader()
+
+    expand_fun =
+      if node(gl) != node() do
+        IEx.Autocomplete.remsh(node())
+      else
+        &IEx.Autocomplete.expand/1
+      end
+
+    %IEx.Server{
       prefix: prefix,
       on_eof: on_eof,
+      expand_fun: expand_fun,
       previous_state: Keyword.get(opts, :previous_state),
       evaluator_options: Keyword.take(opts, [:dot_iex_path])
     }

lib/iex/test/iex/autocomplete_test.exs

@@ -13,7 +13,7 @@ defmodule IEx.AutocompleteTest do
     ExUnit.CaptureIO.capture_io(fn ->
       evaluator = Process.get(:evaluator)
       Process.group_leader(evaluator, Process.group_leader())
-      send(evaluator, {:eval, self(), line <> "\n", %IEx.State{}})
+      send(evaluator, {:eval, self(), line <> "\n", 1, ""})
       assert_receive {:evaled, _, _, _}
     end)
   end
@@ -391,11 +391,11 @@ defmodule IEx.AutocompleteTest do
     assert {:yes, ~c"", entries} = expand(~c"%")
     assert ~c"URI" in entries
     assert ~c"IEx.History" in entries
-    assert ~c"IEx.State" in entries
+    assert ~c"IEx.Server" in entries
 
     assert {:yes, ~c"", entries} = expand(~c"%IEx.")
     assert ~c"IEx.History" in entries
-    assert ~c"IEx.State" in entries
+    assert ~c"IEx.Server" in entries
 
     assert expand(~c"%IEx.AutocompleteTe") == {:yes, ~c"st.MyStruct{", []}
     assert expand(~c"%IEx.AutocompleteTest.MyStr") == {:yes, ~c"uct{", []}