Improve IEx autocomplete to support navigating map atom keys (#5488)

Signed-off-by: José Valim <jose.valim@plataformatec.com.br>

Author: myronmarston

lib/iex/lib/iex/autocomplete.ex

@@ -1,20 +1,22 @@
 defmodule IEx.Autocomplete do
   @moduledoc false
 
-  def expand('') do
+  def expand(expr, server \\ IEx.Server)
+
+  def expand('', _server) do
     expand_import("")
   end
 
-  def expand([h | t]=expr) do
+  def expand([h | t]=expr, server) do
     cond do
       h === ?. and t != [] ->
-        expand_dot(reduce(t))
+        expand_dot(reduce(t), server)
       h === ?: and t == [] ->
         expand_erlang_modules()
       identifier?(h) ->
-        expand_expr(reduce(expr))
+        expand_expr(reduce(expr), server)
       (h == ?/) and t != [] and identifier?(hd(t)) ->
-        expand_expr(reduce(t))
+        expand_expr(reduce(t), server)
       h in '([{' ->
         expand('')
       true ->
@@ -26,31 +28,33 @@ defmodule IEx.Autocomplete do
     (h in ?a..?z) or (h in ?A..?Z) or (h in ?0..?9) or h in [?_, ??, ?!]
   end
 
-  defp expand_dot(expr) do
+  defp expand_dot(expr, server) do
     case Code.string_to_quoted expr do
       {:ok, atom} when is_atom(atom) ->
-        expand_call(atom, "")
+        expand_call(atom, "", server)
       {:ok, {:__aliases__, _, list}} ->
-        expand_elixir_modules(list, "")
+        expand_elixir_modules(list, "", server)
+      {:ok, {_, _, _} = ast_node} ->
+        expand_call(ast_node, "", server)
       _ ->
         no()
     end
   end
 
-  defp expand_expr(expr) do
+  defp expand_expr(expr, server) do
     case Code.string_to_quoted expr do
       {:ok, atom} when is_atom(atom) ->
         expand_erlang_modules(Atom.to_string(atom))
       {:ok, {atom, _, nil}} when is_atom(atom) ->
         expand_import(Atom.to_string(atom))
       {:ok, {:__aliases__, _, [root]}} ->
-        expand_elixir_modules([], Atom.to_string(root))
+        expand_elixir_modules([], Atom.to_string(root), server)
       {:ok, {:__aliases__, _, [h | _] = list}} when is_atom(h) ->
         hint = Atom.to_string(List.last(list))
         list = Enum.take(list, length(list) - 1)
-        expand_elixir_modules(list, hint)
-      {:ok, {{:., _, [mod, fun]}, _, []}} when is_atom(fun) ->
-        expand_call(mod, Atom.to_string(fun))
+        expand_elixir_modules(list, hint, server)
+      {:ok, {{:., _, [ast_node, fun]}, _, []}} when is_atom(fun) ->
+        expand_call(ast_node, Atom.to_string(fun), server)
       _ ->
         no()
     end
@@ -105,21 +109,37 @@ defmodule IEx.Autocomplete do
   ## Expand calls
 
   # :atom.fun
-  defp expand_call(mod, hint) when is_atom(mod) do
+  defp expand_call(mod, hint, _server) when is_atom(mod) do
     expand_require(mod, hint)
   end
 
   # Elixir.fun
-  defp expand_call({:__aliases__, _, list}, hint) do
-    expand_alias(list)
+  defp expand_call({:__aliases__, _, list}, hint, server) do
+    expand_alias(list, server)
     |> normalize_module
     |> expand_require(hint)
   end
 
-  defp expand_call(_, _) do
+  # variable.fun_or_key
+  defp expand_call({_, _, _} = ast_node, hint, server) do
+    case value_from_binding(ast_node, server) do
+      {:ok, mod} when is_atom(mod) -> expand_call(mod, hint, server)
+      {:ok, map} when is_map(map) -> expand_map_field_access(map, hint)
+      _otherwise -> no()
+    end
+  end
+
+  defp expand_call(_, _, _) do
     no()
   end
 
+  defp expand_map_field_access(map, hint) do
+    case match_map_fields(map, hint) do
+      [%{kind: :map_key, name: name, value_is_map: false}] when name == hint -> no()
+      map_fields when is_list(map_fields) -> format_expansion(map_fields, hint)
+    end
+  end
+
   defp expand_require(mod, hint) do
     format_expansion match_module_funs(mod, hint), hint
   end
@@ -145,26 +165,27 @@ defmodule IEx.Autocomplete do
 
   ## Elixir modules
 
-  defp expand_elixir_modules([], hint) do
-    expand_elixir_modules(Elixir, hint, match_aliases(hint))
+  defp expand_elixir_modules([], hint, server) do
+    aliases = match_aliases(hint, server)
+    expand_elixir_modules_from_aliases(Elixir, hint, aliases)
   end
 
-  defp expand_elixir_modules(list, hint) do
-    expand_alias(list)
+  defp expand_elixir_modules(list, hint, server) do
+    expand_alias(list, server)
     |> normalize_module
-    |> expand_elixir_modules(hint, [])
+    |> expand_elixir_modules_from_aliases(hint, [])
   end
 
-  defp expand_elixir_modules(mod, hint, aliases) do
+  defp expand_elixir_modules_from_aliases(mod, hint, aliases) do
     aliases
     |> Kernel.++(match_elixir_modules(mod, hint))
     |> Kernel.++(match_module_funs(mod, hint))
     |> format_expansion(hint)
   end
 
-  defp expand_alias([name | rest] = list) do
+  defp expand_alias([name | rest] = list, server) do
     module = Module.concat(Elixir, name)
-    Enum.find_value env_aliases(), list, fn {alias, mod} ->
+    Enum.find_value env_aliases(server), list, fn {alias, mod} ->
       if alias === module do
         case Atom.to_string(mod) do
           "Elixir." <> mod ->
@@ -176,12 +197,12 @@ defmodule IEx.Autocomplete do
     end
   end
 
-  defp env_aliases do
-    Application.get_env(:iex, :autocomplete_server).current_env.aliases
-  end
+  defp env_aliases(server), do: server.current_env.aliases
+
+  defp get_evaluator(server), do: server.evaluator
 
-  defp match_aliases(hint) do
-    for {alias, _mod} <- env_aliases(),
+  defp match_aliases(hint, server) do
+    for {alias, _mod} <- env_aliases(server),
         [name] = Module.split(alias),
         starts_with?(name, hint) do
       %{kind: :module, type: :alias, name: name}
@@ -269,6 +290,14 @@ defmodule IEx.Autocomplete do
     end
   end
 
+  defp match_map_fields(map, hint) do
+    for {key, value} <- map,
+        is_atom(key),
+        key = to_string(key),
+        String.starts_with?(key, hint),
+        do: %{kind: :map_key, name: key, value_is_map: is_map(value)}
+  end
+
   defp get_module_funs(mod) do
     docs = Code.get_docs(mod, :docs) || []
     module_info_funs(mod) |> Enum.reject(&hidden_fun?(&1, docs))
@@ -316,6 +345,10 @@ defmodule IEx.Autocomplete do
     for a <- :lists.sort(arities), do: "#{name}/#{a}"
   end
 
+  defp to_entries(%{kind: :map_key, name: name}) do
+    [name]
+  end
+
   defp to_uniq_entries(%{kind: :module}) do
     []
   end
@@ -324,6 +357,10 @@ defmodule IEx.Autocomplete do
     to_entries(fun)
   end
 
+  defp to_uniq_entries(%{kind: :map_key}) do
+    []
+  end
+
   defp to_hint(%{kind: :module, name: name}, hint) when name == hint do
     format_hint(name, name) <> "."
   end
@@ -336,8 +373,41 @@ defmodule IEx.Autocomplete do
     format_hint(name, hint)
   end
 
+  defp to_hint(%{kind: :map_key, name: name, value_is_map: true}, hint) when name == hint do
+    format_hint(name, hint) <> "."
+  end
+
+  defp to_hint(%{kind: :map_key, name: name}, hint) do
+    format_hint(name, hint)
+  end
+
   defp format_hint(name, hint) do
     hint_size = byte_size(hint)
     :binary.part(name, hint_size, byte_size(name) - hint_size)
   end
+
+  defp value_from_binding(ast_node, server) do
+    with evaluator when is_pid(evaluator) <- get_evaluator(server),
+         {var, map_key_path} <- extract_from_ast(ast_node, []) do
+      IEx.Evaluator.value_from_binding(evaluator, var, map_key_path)
+    else
+      _ -> :error
+    end
+  end
+
+  defp extract_from_ast(var_name, acc) when is_atom(var_name) do
+    {var_name, acc}
+  end
+
+  defp extract_from_ast({var_name, _, nil}, acc) when is_atom(var_name) do
+    {var_name, acc}
+  end
+
+  defp extract_from_ast({{:., _, [ast_node, fun]}, _, []}, acc) when is_atom(fun) do
+    extract_from_ast(ast_node, [fun | acc])
+  end
+
+  defp extract_from_ast(_ast_node, _acc) do
+    :error
+  end
 end

lib/iex/lib/iex/evaluator.ex

@@ -24,6 +24,22 @@ defmodule IEx.Evaluator do
     end
   end
 
+  @doc """
+  Gets a value out of the binding, using the provided
+  variable name and map key path.
+  """
+  @spec value_from_binding(pid, atom, [atom]) :: {:ok, any} | :error
+  def value_from_binding(evaluator, var_name, map_key_path) do
+    ref = make_ref()
+    send evaluator, {:value_from_binding, ref, self(), var_name, map_key_path}
+
+    receive do
+      {^ref, result} -> result
+    after
+      5000 -> :error
+    end
+  end
+
   defp loop(server, history, state) do
     receive do
       {:eval, ^server, code, iex_state} ->
@@ -33,11 +49,24 @@ defmodule IEx.Evaluator do
       {:peek_env, receiver} ->
         send receiver, {:peek_env, state.env}
         loop(server, history, state)
+      {:value_from_binding, ref, receiver, var_name, map_key_path} ->
+        value = traverse_binding(state.binding, var_name, map_key_path)
+        send receiver, {ref, value}
+        loop(server, history, state)
       {:done, ^server} ->
         :ok
     end
   end
 
+  defp traverse_binding(binding, var_name, map_key_path) do
+    accumulator = Keyword.fetch(binding, var_name)
+
+    Enum.reduce map_key_path, accumulator, fn
+      key, {:ok, map} when is_map(map) -> Map.fetch(map, key)
+      _key, _acc -> :error
+    end
+  end
+
   defp loop_state(opts) do
     env =
       if env = opts[:env] do

lib/iex/lib/iex/server.ex

@@ -42,6 +42,19 @@ defmodule IEx.Server do
     end
   end
 
+  @doc """
+  Returns the PID of the IEx evaluator process if it exists.
+  """
+  @spec evaluator :: pid | nil
+  def evaluator() do
+    case IEx.Server.local do
+      nil -> nil
+      pid ->
+        {:dictionary, dictionary} = Process.info(pid, :dictionary)
+        dictionary[:evaluator]
+    end
+  end
+
   @doc """
   Returns the current session environment if a session exists.
   """
@@ -144,7 +157,11 @@ defmodule IEx.Server do
     loop(run_state(opts), evaluator, Process.monitor(evaluator))
   end
 
-  defp start_evaluator(opts) do
+  @doc """
+  Starst an evaluator using the provided options.
+  """
+  @spec start_evaluator(Keyword.t) :: pid
+  def start_evaluator(opts) do
     self_pid = self()
     self_leader = Process.group_leader
     evaluator = opts[:evaluator] ||

lib/iex/mix.exs

@@ -11,7 +11,6 @@ defmodule IEx.Mixfile do
     [registered: [IEx.Supervisor, IEx.Config],
      mod: {IEx.App, []},
      env: [
-      autocomplete_server: IEx.Server,
       colors: [],
       inspect: [pretty: true],
       history_size: 20,