Conditional breakpoints (#661)

* extract and test erlang binding processing

fix some isses when var is usend more than 10 times
add explicite ordering by variable instance
discard underscored variables

* breakpoint conditions support added

do not warn when setting already set breakpoint

* update readme

# Conflicts:
#	README.md

* log when expression crashes

* add support for conditional function breakpoints

* update readme

Author: lukaszsamson

README.md

@@ -101,6 +101,8 @@ ElixirLS includes debugger support adhering to the [Debug Adapter Protocol](http
 
 When debugging in Elixir or Erlang, only modules that have been "interpreted" (using `:int.ni/1` or `:int.i/1`) will accept breakpoints or show up in stack traces. The debugger in ElixirLS automatically interprets all modules in the Mix project and dependencies prior to launching the Mix task, so you can set breakpoints anywhere in your project or dependency modules.
 
+### Debuging tests and `.exs` files
+
 In order to debug modules in `.exs` files (such as tests), they must be specified under `requireFiles` in your launch configuration so they can be loaded and interpreted prior to running the task. For example, the default launch configuration for "mix test" in the VS Code plugin looks like this:
 
 ```
@@ -155,6 +157,7 @@ Use the following launch config to debug phoenix apps
 
 Please make sure that `startApps` is not set to `true` as it prevents phoenix from starting correctly. On the other hand phoenix tests expects that the apps are already started so in that case set it to `true`.
 
+### NIF modules limitation
 
 Please note that due to `:int` limitation NIF modules cannot be interpreted and need to be excluded via `excludeModules` option. This option can be also used to disable interpreting for some modules when it is not desirable e.g. when performance is not satisfactory.
 
@@ -177,7 +180,27 @@ Please note that due to `:int` limitation NIF modules cannot be interpreted and
 }
 ```
 
-Function breakpoints will break on the first line of every clause of the specified function. The function needs to be specified as MFA (module, function, arity) in the standard elixir format, e.g. `:some_module.function/1` or `Some.Module.some_function/2`.
+### Function breakpoints
+
+Function breakpoints will break on the first line of every clause of the specified function. The function needs to be specified as MFA (module, function, arity) in the standard elixir format, e.g. `:some_module.function/1` or `Some.Module.some_function/2`. Breaking on private functions is not supported via function breakpoints.
+
+### Conditional breakpoints
+
+Break conditions are supported and evaluate elixir expressions within the context set of breakpoints. There is currently a limit of 100 breakpoint conditions. Due to limitations in `:int` breakpoint conditions cannot be unset. See also limitations on Expression evaluator for further details.
+
+### Expression evaluator
+
+An expression evaluator is included in the debbuger. It evaluates elixir expressions in the context of a process stopped on a breakpoint. All bound variables are accessible (no support for attributes as those are compile time). Please note that there are limitations due to `:int` operating on beam instruction level. The binding returns multiple versions of variables in Static Singe Assignment with no indication which one is valid in the current elixir scope. A heuristic is used that selects the highest versions but it does not behave correctly in all cases, e.g. in
+
+```elixir
+a = 4
+if true do
+  a = 5
+end
+some
+```
+
+when a breakpoint is reached on line with `some`, the last bound value for `a` seen by expression breakpoint evaluator is 5 (should be 4).
 
 ## Automatic builds and error reporting
 

apps/elixir_ls_debugger/lib/debugger/binding.ex

@@ -0,0 +1,38 @@
+defmodule ElixirLS.Debugger.Binding do
+  def to_elixir_variable_names(bindings) do
+    bindings
+    |> Enum.group_by(fn {key, _} -> get_elixir_variable(key) end)
+    # filter out underscore binding as those are invalid in elixir
+    |> Enum.reject(fn {classic_key, _} ->
+      classic_key |> Atom.to_string() |> String.starts_with?("_")
+    end)
+    |> Enum.map(fn {classic_key, list} ->
+      # assume binding with highest number is the current one
+      # this may not be allways true, e.g. in
+      # a = 5
+      # if true do
+      #   a = 4
+      # end
+      # results in _a@1 = 5 and _a@2 = 4
+      # but we have no way of telling which one is current
+      {_, last_value} = list |> Enum.max_by(fn {key, _} -> key end)
+      {classic_key, last_value}
+    end)
+  end
+
+  def get_elixir_variable(key) do
+    # binding is present with prefix _ and postfix @
+    # for example _key@1 and _value@1 are representations of current function variables
+    key
+    |> Atom.to_string()
+    |> String.replace(~r/_(.*)@\d+/, "\\1")
+    |> String.to_atom()
+  end
+
+  def get_number(key) do
+    key
+    |> Atom.to_string()
+    |> String.replace(~r/_.*@(\d+)/, "\\1")
+    |> String.to_integer()
+  end
+end

apps/elixir_ls_debugger/lib/debugger/breakpoint_condition.ex

@@ -0,0 +1,114 @@
+defmodule ElixirLS.Debugger.BreakpointCondition do
+  @moduledoc """
+  Server that tracks breakpoint conditions
+  """
+
+  use GenServer
+  @range 0..99
+
+  def start_link(args) do
+    GenServer.start_link(__MODULE__, Keyword.delete(args, :name),
+      name: Keyword.get(args, :name, __MODULE__)
+    )
+  end
+
+  def register_condition(name \\ __MODULE__, module, lines, condition) do
+    GenServer.call(name, {:register_condition, {module, lines}, condition})
+  end
+
+  def unregister_condition(name \\ __MODULE__, module, lines) do
+    GenServer.cast(name, {:unregister_condition, {module, lines}})
+  end
+
+  def has_condition?(name \\ __MODULE__, module, lines) do
+    GenServer.call(name, {:has_condition?, {module, lines}})
+  end
+
+  def get_condition(name \\ __MODULE__, number) do
+    GenServer.call(name, {:get_condition, number})
+  end
+
+  @impl GenServer
+  def init(_args) do
+    {:ok,
+     %{
+       free: @range |> Enum.map(& &1),
+       conditions: %{}
+     }}
+  end
+
+  @impl GenServer
+  def handle_call(
+        {:register_condition, key, condition},
+        _from,
+        %{free: free, conditions: conditions} = state
+      ) do
+    case conditions[key] do
+      nil ->
+        case free do
+          [] ->
+            {:reply, {:error, :limit_reached}, state}
+
+          [number | rest] ->
+            state = %{
+              state
+              | free: rest,
+                conditions: conditions |> Map.put(key, {number, condition})
+            }
+
+            {:reply, {:ok, {__MODULE__, :"check_#{number}"}}, state}
+        end
+
+      {number, _old_condition} ->
+        state = %{state | conditions: conditions |> Map.put(key, {number, condition})}
+        {:reply, {:ok, {__MODULE__, :"check_#{number}"}}, state}
+    end
+  end
+
+  def handle_call({:has_condition?, key}, _from, %{conditions: conditions} = state) do
+    {:reply, Map.has_key?(conditions, key), state}
+  end
+
+  def handle_call({:get_condition, number}, _from, %{conditions: conditions} = state) do
+    condition = conditions |> Map.values() |> Enum.find(fn {n, _c} -> n == number end) |> elem(1)
+    {:reply, condition, state}
+  end
+
+  @impl GenServer
+  def handle_cast({:unregister_condition, key}, %{free: free, conditions: conditions} = state) do
+    state =
+      case Map.pop(conditions, key) do
+        {{number, _}, conditions} ->
+          %{state | free: [number | free], conditions: conditions}
+
+        {nil, _} ->
+          state
+      end
+
+    {:noreply, state}
+  end
+
+  # `:int` module supports setting breakpoint conditions in the form `{module, function}`
+  # we need a way of dynamically generating such pairs and assigning conditions that they will evaluate
+  # an arbitrary limit of 100 conditions was chosen
+  for i <- @range do
+    @spec unquote(:"check_#{i}")(term) :: boolean
+    def unquote(:"check_#{i}")(binding) do
+      condition = get_condition(unquote(i))
+      eval_condition(condition, binding)
+    end
+  end
+
+  def eval_condition(condition, binding) do
+    elixir_binding = binding |> ElixirLS.Debugger.Binding.to_elixir_variable_names()
+
+    try do
+      {term, _bindings} = Code.eval_string(condition, elixir_binding)
+      if term, do: true, else: false
+    catch
+      kind, error ->
+        IO.warn("Error in conditional breakpoint: " <> Exception.format_banner(kind, error))
+        false
+    end
+  end
+end