Initial implementation of new protocol / store / server state

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,156 @@
+defmodule ElixirLS.LanguageServer.Experimental.Protocol.Proto.Decoders do
+  alias ElixirLS.LanguageServer.Experimental.Protocol.Proto.CompileMetadata
+
+  defmacro for_notifications(_) do
+    notification_modules = CompileMetadata.notification_modules()
+    notification_matchers = Enum.map(notification_modules, &build_notification_matcher_macro/1)
+    notification_decoders = Enum.map(notification_modules, &build_notifications_decoder/1)
+
+    quote do
+      defmacro notification(method) do
+        quote do
+          %{"method" => unquote(method), "jsonrpc" => "2.0"}
+        end
+      end
+
+      defmacro notification(method, params) do
+        quote do
+          %{"method" => unquote(method), "params" => unquote(params), "jsonrpc" => "2.0"}
+        end
+      end
+
+      unquote(build_typespec(:notification, notification_modules))
+
+      unquote_splicing(notification_matchers)
+
+      @spec decode(String.t(), map()) :: {:ok, notification} | {:error, any}
+      unquote_splicing(notification_decoders)
+
+      def decode(method, _) do
+        {:error, {:unknown_notification, method}}
+      end
+
+      def __meta__(:events) do
+        unquote(notification_modules)
+      end
+
+      def __meta__(:notifications) do
+        unquote(notification_modules)
+      end
+    end
+  end
+
+  defmacro for_requests(_) do
+    request_modules = CompileMetadata.request_modules()
+    request_matchers = Enum.map(request_modules, &build_request_matcher_macro/1)
+    request_decoders = Enum.map(request_modules, &build_request_decoder/1)
+
+    quote do
+      def __meta__(:requests) do
+        unquote(request_modules)
+      end
+
+      defmacro request(id, method) do
+        quote do
+          %{"method" => unquote(method), "id" => unquote(id), "jsonrpc" => "2.0"}
+        end
+      end
+
+      defmacro request(id, method, params) do
+        quote do
+          %{"method" => unquote(method), "id" => unquote(id), "params" => unquote(params)}
+        end
+      end
+
+      unquote(build_typespec(:request, request_modules))
+
+      unquote_splicing(request_matchers)
+
+      @spec decode(String.t(), map()) :: {:ok, request} | {:error, any}
+      unquote_splicing(request_decoders)
+
+      def decode(method, _) do
+        {:error, {:unknown_request, method}}
+      end
+    end
+  end
+
+  defp build_notification_matcher_macro(notification_module) do
+    macro_name = module_to_macro_name(notification_module)
+    method_name = notification_module.__meta__(:method_name)
+
+    quote do
+      defmacro unquote(macro_name)() do
+        method_name = unquote(method_name)
+
+        quote do
+          %{"method" => unquote(method_name), "jsonrpc" => "2.0"}
+        end
+      end
+    end
+  end
+
+  defp build_notifications_decoder(notification_module) do
+    method_name = notification_module.__meta__(:method_name)
+
+    quote do
+      def decode(unquote(method_name), request) do
+        unquote(notification_module).parse(request)
+      end
+    end
+  end
+
+  defp build_request_matcher_macro(notification_module) do
+    macro_name = module_to_macro_name(notification_module)
+    method_name = notification_module.__meta__(:method_name)
+
+    quote do
+      defmacro unquote(macro_name)(id) do
+        method_name = unquote(method_name)
+
+        quote do
+          %{"method" => unquote(method_name), "id" => unquote(id), "jsonrpc" => "2.0"}
+        end
+      end
+    end
+  end
+
+  defp build_request_decoder(request_module) do
+    method_name = request_module.__meta__(:method_name)
+
+    quote do
+      def decode(unquote(method_name), request) do
+        unquote(request_module).parse(request)
+      end
+    end
+  end
+
+  def build_typespec(type_name, modules) do
+    spec_name = {type_name, [], nil}
+
+    spec =
+      Enum.reduce(modules, nil, fn
+        module, nil ->
+          quote do
+            unquote(module).t()
+          end
+
+        module, spec ->
+          quote do
+            unquote(module).t() | unquote(spec)
+          end
+      end)
+
+    quote do
+      @type unquote(spec_name) :: unquote(spec)
+    end
+  end
+
+  defp module_to_macro_name(module) do
+    module
+    |> Module.split()
+    |> List.last()
+    |> Macro.underscore()
+    |> String.to_atom()
+  end
+end