Typed protocols

.github/workflows/ci.yml

@@ -90,24 +90,34 @@ jobs:
         include:
           - elixir: 1.14.x
             otp: 23.x
+            tests_may_fail: false
           - elixir: 1.14.x
             otp: 24.x
+            tests_may_fail: false
           - elixir: 1.14.x
             otp: 25.x
+            tests_may_fail: false
           - elixir: 1.14.x
             otp: 26.x
+            tests_may_fail: false
           - elixir: 1.15.x
             otp: 24.x
+            tests_may_fail: false
           - elixir: 1.15.x
             otp: 25.x
+            tests_may_fail: false
           - elixir: 1.15.x
             otp: 26.x
+            tests_may_fail: false
           - elixir: 1.16.x
             otp: 24.x
+            tests_may_fail: false
           - elixir: 1.16.x
             otp: 25.x
+            tests_may_fail: false
           - elixir: 1.16.x
             otp: 26.x
+            tests_may_fail: false
           - elixir: 1.17.x
             otp: 25.x
             tests_may_fail: false

apps/debug_adapter/lib/debug_adapter/breakpoint_condition.ex

@@ -17,6 +17,7 @@ defmodule ElixirLS.DebugAdapter.BreakpointCondition do
           module,
           module,
           non_neg_integer,
+          Macro.Env.t(),
           String.t(),
           String.t() | nil,
           String.t()
@@ -29,7 +30,7 @@ defmodule ElixirLS.DebugAdapter.BreakpointCondition do
     )
   end
 
-  @spec unregister_condition(module, module, non_neg_integer) :: :ok
+  @spec unregister_condition(module, module, [non_neg_integer]) :: :ok
   def unregister_condition(name \\ __MODULE__, module, line) do
     GenServer.cast(name, {:unregister_condition, {module, line}})
   end
@@ -40,7 +41,7 @@ defmodule ElixirLS.DebugAdapter.BreakpointCondition do
   end
 
   @spec get_condition(module, non_neg_integer) ::
-          {String.t(), String.t(), non_neg_integer, non_neg_integer}
+          {Macro.Env.t(), String.t(), String.t(), String.t(), non_neg_integer}
   def get_condition(name \\ __MODULE__, number) do
     GenServer.call(name, {:get_condition, number})
   end

apps/debug_adapter/lib/debug_adapter/completions.ex

@@ -10,7 +10,7 @@ defmodule ElixirLS.DebugAdapter.Completions do
         snippet: snippet
       })
       when type in [:function, :macro] do
-    %{
+    %GenDAP.Structures.CompletionItem{
       type: "function",
       detail: Atom.to_string(type),
       label: "#{name}/#{arity}",
@@ -29,7 +29,7 @@ defmodule ElixirLS.DebugAdapter.Completions do
         other -> other
       end
 
-    %{
+    %GenDAP.Structures.CompletionItem{
       type: "module",
       detail: if(subtype != nil, do: Atom.to_string(subtype)),
       label: name,
@@ -41,7 +41,7 @@ defmodule ElixirLS.DebugAdapter.Completions do
         type: :variable,
         name: name
       }) do
-    %{
+    %GenDAP.Structures.CompletionItem{
       type: "variable",
       label: name
     }
@@ -58,7 +58,7 @@ defmodule ElixirLS.DebugAdapter.Completions do
         :map_key -> "map key"
       end
 
-    %{
+    %GenDAP.Structures.CompletionItem{
       type: "field",
       detail: detail,
       label: name

apps/debug_adapter/lib/debug_adapter/id_manager.ex

@@ -0,0 +1,59 @@
+defmodule ElixirLS.DebugAdapter.IdManager do
+  @moduledoc """
+  Global ID manager for Debug Adapter Protocol objects.
+
+  Uses ERTS :atomics module for thread-safe, shared mutable counters
+  that can be accessed from any process without blocking.
+  """
+
+  @counter_ref :dap_id_counter
+
+  @doc """
+  Initializes the global ID counter.
+  Should be called once during server startup.
+  """
+  def init do
+    # Create a single atomic counter starting at 1
+    counter = :atomics.new(1, [])
+    :atomics.put(counter, 1, 1)
+    :persistent_term.put(@counter_ref, counter)
+    :ok
+  end
+
+  @doc """
+  Gets the next unique ID atomically.
+  This is thread-safe and can be called from any process.
+  """
+  def next_id do
+    case :persistent_term.get(@counter_ref, nil) do
+      nil ->
+        raise "IdManager not initialized. Call IdManager.init/0 first."
+
+      counter ->
+        :atomics.add_get(counter, 1, 1)
+    end
+  end
+
+  @doc """
+  Cleans up the global ID counter.
+  Should be called during server shutdown.
+  """
+  def cleanup do
+    :persistent_term.erase(@counter_ref)
+    :ok
+  end
+
+  @doc """
+  Gets the current ID value without incrementing.
+  Mainly for testing/debugging purposes.
+  """
+  def current_id do
+    case :persistent_term.get(@counter_ref, nil) do
+      nil ->
+        raise "IdManager not initialized. Call IdManager.init/0 first."
+
+      counter ->
+        :atomics.get(counter, 1)
+    end
+  end
+end

apps/debug_adapter/lib/debug_adapter/output.ex

@@ -9,7 +9,7 @@ defmodule ElixirLS.DebugAdapter.Output do
   """
   alias ElixirLS.Utils.WireProtocol
   use GenServer
-  use ElixirLS.DebugAdapter.Protocol
+  import ElixirLS.DebugAdapter.Protocol.Basic
 
   ## Client API
 
@@ -38,31 +38,46 @@ defmodule ElixirLS.DebugAdapter.Output do
     )
   end
 
-  def send_event(server \\ __MODULE__, event, body) do
-    GenServer.call(server, {:send_event, event, body}, :infinity)
+  def send_event(server \\ __MODULE__, body) do
+    GenServer.call(server, {:send_event, body}, :infinity)
   end
 
   def debugger_console(server \\ __MODULE__, str) when is_binary(str) do
-    send_event(server, "output", %{"category" => "console", "output" => maybe_append_newline(str)})
+    send_event(server, %GenDAP.Events.OutputEvent{
+      seq: nil,
+      body: %{category: "console", output: maybe_append_newline(str)}
+    })
   end
 
   def debugger_important(server \\ __MODULE__, str) when is_binary(str) do
-    send_event(server, "output", %{
-      "category" => "important",
-      "output" => maybe_append_newline(str)
+    send_event(server, %GenDAP.Events.OutputEvent{
+      seq: nil,
+      body: %{
+        category: "important",
+        output: maybe_append_newline(str)
+      }
     })
   end
 
   def debuggee_out(server \\ __MODULE__, str) when is_binary(str) do
-    send_event(server, "output", %{"category" => "stdout", "output" => maybe_append_newline(str)})
+    send_event(server, %GenDAP.Events.OutputEvent{
+      seq: nil,
+      body: %{category: "stdout", output: maybe_append_newline(str)}
+    })
   end
 
   def debuggee_err(server \\ __MODULE__, str) when is_binary(str) do
-    send_event(server, "output", %{"category" => "stderr", "output" => maybe_append_newline(str)})
+    send_event(server, %GenDAP.Events.OutputEvent{
+      seq: nil,
+      body: %{category: "stderr", output: maybe_append_newline(str)}
+    })
   end
 
   def ex_unit_event(server \\ __MODULE__, data) when is_map(data) do
-    send_event(server, "output", %{"category" => "ex_unit", "output" => "", "data" => data})
+    send_event(server, %GenDAP.Events.OutputEvent{
+      seq: nil,
+      body: %{category: "ex_unit", output: "", data: data}
+    })
   end
 
   def telemetry(server \\ __MODULE__, event, properties, measurements)
@@ -82,13 +97,16 @@ defmodule ElixirLS.DebugAdapter.Output do
       "elixir_ls.mix_target" => Mix.target()
     }
 
-    send_event(server, "output", %{
-      "category" => "telemetry",
-      "output" => event,
-      "data" => %{
-        "name" => event,
-        "properties" => Map.merge(common_properties, properties),
-        "measurements" => measurements
+    send_event(server, %GenDAP.Events.OutputEvent{
+      seq: nil,
+      body: %{
+        category: "telemetry",
+        output: event,
+        data: %{
+          "name" => event,
+          "properties" => Map.merge(common_properties, properties),
+          "measurements" => measurements
+        }
       }
     })
   end
@@ -109,6 +127,15 @@ defmodule ElixirLS.DebugAdapter.Output do
   end
 
   @impl GenServer
+  def handle_call({:send_response, request_packet, body = %struct{}}, _from, seq) do
+    {:ok, dumped_body} =
+      SchematicV.dump(struct.schematic(), %{body | seq: seq, request_seq: request_packet["seq"]})
+
+    res = WireProtocol.send(dumped_body)
+
+    {:reply, res, seq + 1}
+  end
+
   def handle_call({:send_response, request_packet, body}, _from, seq) do
     res = WireProtocol.send(response(seq, request_packet["seq"], request_packet["command"], body))
     {:reply, res, seq + 1}
@@ -120,25 +147,39 @@ defmodule ElixirLS.DebugAdapter.Output do
         _from,
         seq
       ) do
-    res =
-      WireProtocol.send(
-        error_response(
-          seq,
-          request_packet["seq"],
-          request_packet["command"],
-          message,
-          format,
-          variables,
-          send_telemetry,
-          show_user
-        )
+    {:ok, dumped_error} =
+      SchematicV.dump(
+        GenDAP.Structures.ErrorResponse.schematic(),
+        %GenDAP.Structures.ErrorResponse{
+          seq: seq,
+          request_seq: request_packet["seq"],
+          command: request_packet["command"],
+          type: "response",
+          success: false,
+          message: message,
+          body: %{
+            error: %GenDAP.Structures.Message{
+              # TODO unique ids
+              id: 1,
+              format: format,
+              variables: variables,
+              send_telemetry: send_telemetry,
+              show_user: show_user
+            }
+          }
+        }
       )
 
+    res = WireProtocol.send(dumped_error)
+
     {:reply, res, seq + 1}
   end
 
-  def handle_call({:send_event, event, body}, _from, seq) do
-    res = WireProtocol.send(event(seq, event, body))
+  def handle_call({:send_event, body = %struct{seq: _}}, _from, seq) do
+    # IO.warn(inspect(%{body | seq: seq}))
+    {:ok, dumped_event} = SchematicV.dump(struct.schematic(), %{body | seq: seq})
+    # IO.warn(inspect(dumped_event))
+    res = WireProtocol.send(dumped_event)
     {:reply, res, seq + 1}
   end
 end

apps/debug_adapter/lib/debug_adapter/protocol.basic.ex

@@ -23,6 +23,18 @@ defmodule ElixirLS.DebugAdapter.Protocol.Basic do
     end
   end
 
+  defmacro response(seq, request_seq, command) do
+    quote do
+      %{
+        "type" => "response",
+        "command" => unquote(command),
+        "seq" => unquote(seq),
+        "request_seq" => unquote(request_seq),
+        "success" => true
+      }
+    end
+  end
+
   defmacro response(seq, request_seq, command, body) do
     quote do
       %{
@@ -77,4 +89,14 @@ defmodule ElixirLS.DebugAdapter.Protocol.Basic do
       }
     end
   end
+
+  defmacro event(seq, event) do
+    quote do
+      %{
+        "type" => "event",
+        "event" => unquote(event),
+        "seq" => unquote(seq)
+      }
+    end
+  end
 end