Merge pull request #764 from scohen/scohen/experimental-protocol

Scohen/experimental protocol

Author: scohen

apps/language_server/.formatter.exs

@@ -3,7 +3,19 @@ impossible_to_format = [
   "test/fixtures/project_with_tests/test/error_test.exs"
 ]
 
+proto_dsl = [
+  defenum: 1,
+  defnotification: 2,
+  defrequest: 2,
+  defresponse: 1,
+  deftype: 1
+]
+
 [
+  export: [
+    locals_without_parens: proto_dsl
+  ],
+  locals_without_parens: proto_dsl,
   inputs:
     Enum.flat_map(
       [

apps/language_server/lib/language_server.ex

@@ -4,24 +4,31 @@ defmodule ElixirLS.LanguageServer do
   """
   use Application
 
+  alias ElixirLS.LanguageServer
+  alias ElixirLS.LanguageServer.Experimental
+
   @impl Application
   def start(_type, _args) do
     children = [
+      Experimental.SourceFile.Store,
       {ElixirLS.LanguageServer.Server, ElixirLS.LanguageServer.Server},
-      {ElixirLS.LanguageServer.JsonRpc, name: ElixirLS.LanguageServer.JsonRpc},
+      Experimental.Server,
+      {ElixirLS.LanguageServer.PacketRouter, [LanguageServer.Server, Experimental.Server]},
+      {ElixirLS.LanguageServer.JsonRpc,
+       name: ElixirLS.LanguageServer.JsonRpc, language_server: LanguageServer.PacketRouter},
       {ElixirLS.LanguageServer.Providers.WorkspaceSymbols, []},
       {ElixirLS.LanguageServer.Tracer, []},
       {ElixirLS.LanguageServer.ExUnitTestTracer, []}
     ]
 
-    opts = [strategy: :one_for_one, name: ElixirLS.LanguageServer.Supervisor, max_restarts: 0]
+    opts = [strategy: :one_for_one, name: LanguageServer.Supervisor, max_restarts: 0]
     Supervisor.start_link(children, opts)
   end
 
   @impl Application
   def stop(_state) do
     if ElixirLS.Utils.WireProtocol.io_intercepted?() do
-      ElixirLS.LanguageServer.JsonRpc.show_message(
+      LanguageServer.JsonRpc.show_message(
         :error,
         "ElixirLS has crashed. See Output panel."
       )

apps/language_server/lib/language_server/experimental/protocol.ex

@@ -0,0 +1,50 @@
+defmodule ElixirLS.LanguageServer.Experimental.Protocol.Notifications do
+  alias ElixirLS.LanguageServer.Experimental.Protocol.Proto
+  alias ElixirLS.LanguageServer.Experimental.Protocol.Types
+
+  defmodule Cancel do
+    use Proto
+
+    defnotification "$/cancelRequest", id: integer()
+  end
+
+  defmodule DidOpen do
+    use Proto
+
+    defnotification "textDocument/didOpen", text_document: Types.TextDocument
+  end
+
+  defmodule DidClose do
+    use Proto
+
+    defnotification "textDocument/didClose", text_document: Types.TextDocument.Identifier
+  end
+
+  defmodule DidChange do
+    use Proto
+
+    defnotification "textDocument/didChange",
+      text_document: Types.TextDocument.VersionedIdentifier,
+      content_changes: list_of(Types.TextDocument.ContentChangeEvent)
+  end
+
+  defmodule DidChangeConfiguration do
+    use Proto
+
+    defnotification "workspace/didChangeConfiguration", settings: map_of(any())
+  end
+
+  defmodule DidChangeWatchedFiles do
+    use Proto
+
+    defnotification "workspace/didChangeWatchedFiles", changes: list_of(Types.FileEvent)
+  end
+
+  defmodule DidSave do
+    use Proto
+
+    defnotification "textDocument/didSave", text_document: Types.TextDocument.Identifier
+  end
+
+  use Proto, decoders: :notifications
+end

apps/language_server/lib/language_server/experimental/protocol/notifications.ex

@@ -0,0 +1,47 @@
+defmodule ElixirLS.LanguageServer.Experimental.Protocol.Proto do
+  alias ElixirLS.LanguageServer.Experimental.Protocol.Proto.Decoders
+
+  defmacro __using__([]) do
+    quote location: :keep do
+      alias ElixirLS.LanguageServer.Experimental.Protocol.Proto
+      alias ElixirLS.LanguageServer.Experimental.Protocol.Proto.LspTypes
+      import ElixirLS.LanguageServer.Experimental.Protocol.Proto.TypeFunctions
+
+      import Proto.Enum, only: [defenum: 1]
+      import Proto.Notification, only: [defnotification: 2]
+      import Proto.Request, only: [defrequest: 2]
+      import Proto.Response, only: [defresponse: 1]
+      import Proto.Type, only: [deftype: 1]
+    end
+  end
+
+  defmacro __using__(opts) when is_list(opts) do
+    function_name =
+      case Keyword.get(opts, :decoders) do
+        :notifications ->
+          :for_notifications
+
+        :requests ->
+          :for_requests
+
+        _ ->
+          invalid_decoder!(__CALLER__)
+      end
+
+    quote do
+      @before_compile {Decoders, unquote(function_name)}
+    end
+  end
+
+  defmacro __using__(_) do
+    invalid_decoder!(__CALLER__)
+  end
+
+  defp invalid_decoder!(caller) do
+    raise CompileError.exception(
+            description: "Invalid decoder type. Must be either :notifications or :requests",
+            file: caller.file,
+            line: caller.line
+          )
+  end
+end

apps/language_server/lib/language_server/experimental/protocol/proto.ex

@@ -0,0 +1,53 @@
+defmodule ElixirLS.LanguageServer.Experimental.Protocol.Proto.CompileMetadata do
+  @moduledoc """
+  Compile-time storage of protocol metadata
+  """
+
+  @notification_modules_key {__MODULE__, :notification_modules}
+  @type_modules_key {__MODULE__, :type_modules}
+  @request_modules_key {__MODULE__, :request_modules}
+  @response_modules_key {__MODULE__, :response_modules}
+
+  def notification_modules do
+    :persistent_term.get(@notification_modules_key, [])
+  end
+
+  def request_modules do
+    :persistent_term.get(@request_modules_key, [])
+  end
+
+  def response_modules do
+    :persistent_term.get(@response_modules_key, [])
+  end
+
+  def type_modules do
+    :persistent_term.get(@type_modules_key)
+  end
+
+  def add_notification_module(module) do
+    add_module(@notification_modules_key, module)
+  end
+
+  def add_request_module(module) do
+    add_module(@request_modules_key, module)
+  end
+
+  def add_response_module(module) do
+    add_module(@response_modules_key, module)
+  end
+
+  def add_type_module(module) do
+    add_module(@type_modules_key, module)
+  end
+
+  defp update(key, initial_value, update_fn) do
+    case :persistent_term.get(key, :not_found) do
+      :not_found -> :persistent_term.put(key, initial_value)
+      found -> :persistent_term.put(key, update_fn.(found))
+    end
+  end
+
+  defp add_module(key, module) do
+    update(key, [module], fn old_list -> [module | old_list] end)
+  end
+end

apps/language_server/lib/language_server/experimental/protocol/proto/compile_metadata.ex

@@ -0,0 +1,51 @@
+defmodule ElixirLS.LanguageServer.Experimental.Protocol.Proto.Convert do
+  alias ElixirLS.LanguageServer.Experimental.SourceFile.Conversions
+  alias ElixirLS.LanguageServer.Experimental.Protocol.Types
+  alias ElixirLS.LanguageServer.Experimental.SourceFile
+
+  def to_elixir(%{text_document: _} = request) do
+    with {:ok, source_file} <- fetch_source_file(request.lsp),
+         {:ok, updates} <- convert(request.lsp, source_file) do
+      updated_request =
+        request
+        |> Map.put(:source_file, source_file)
+        |> Map.merge(updates)
+
+      {:ok, updated_request}
+    end
+  end
+
+  def to_elixir(request) do
+    request = Map.merge(request, Map.from_struct(request.lsp))
+
+    {:ok, request}
+  end
+
+  defp fetch_source_file(%{text_document: %Types.TextDocument{} = text_document}) do
+    with {:ok, source_file} <- SourceFile.Store.fetch(text_document.uri) do
+      {:ok, source_file}
+    end
+  end
+
+  defp fetch_source_file(%{source_file: %SourceFile{} = source_file}) do
+    {:ok, source_file}
+  end
+
+  defp fetch_source_file(_), do: :error
+
+  defp convert(%{range: range}, source_file) do
+    with {:ok, ex_range} <- Conversions.to_elixir(range, source_file) do
+      {:ok, %{range: ex_range}}
+    end
+  end
+
+  defp convert(%{position: position}, source_file) do
+    with {:ok, ex_pos} <- Conversions.to_elixir(position, source_file) do
+      {:ok, %{position: ex_pos}}
+    end
+  end
+
+  defp convert(_, _) do
+    {:ok, %{}}
+  end
+end