Change how requests and notfications are structured

There are a number of conversions related to document positions and
document realization that need to happen when a request is
serviced. Future request handlers would be made much simpler and more
correct if the system would handle these conversions for writers of
provider handlers. To wit, each request and notification module now
has an internal `lsp` field that contains the initial request, while
the surounding request represents the elixir side of the data. To
convert to elixir, all one has to do is use the `to_elixir` function.

The elixir struct that encloses the lsp struct has all of the same
fields, and if the enclosing struct has a text document, an additional
`source_file` field is added. All the fields on the elixir side are
initialized to nil until `to_elixir` is called.

When to_elixir is invoked, it scans the lsp document for
text_documents, which are fetched from the source file store. This
document is used to influence any ranges or positions and convert them
into their elixir-native data structures. Finally, all of the other
fields are copied into the elixir side.

Author: scohen

apps/language_server/lib/language_server/experimental/protocol/proto/convert.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

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

@@ -0,0 +1,56 @@
+defmodule ElixirLS.LanguageServer.Experimental.Protocol.Proto.Macros.Message do
+  alias ElixirLS.LanguageServer.Experimental.Protocol.Proto.Macros.{
+    Access,
+    Struct,
+    Parse,
+    Typespec,
+    Meta
+  }
+
+  alias ElixirLS.LanguageServer.Experimental.SourceFile
+
+  def build(meta_type, method, types, param_names, opts \\ []) do
+    parse_fn =
+      if Keyword.get(opts, :include_parse?, true) do
+        Parse.build(types)
+      end
+
+    quote do
+      unquote(Access.build())
+      unquote(Struct.build(types))
+      unquote(Typespec.build())
+      unquote(parse_fn)
+      unquote(Meta.build(types))
+
+      def __meta__(:method_name) do
+        unquote(method)
+      end
+
+      def __meta__(:type) do
+        unquote(meta_type)
+      end
+
+      def __meta__(:param_names) do
+        unquote(param_names)
+      end
+    end
+  end
+
+  def generate_elixir_types(caller_module, message_types) do
+    message_types
+    |> Enum.reduce(message_types, fn
+      {:text_document, _}, types ->
+        Keyword.put(types, :source_file, quote(do: SourceFile))
+
+      {:position, _}, types ->
+        Keyword.put(types, :position, quote(do: SourceFile.Position))
+
+      {:range, _}, types ->
+        Keyword.put(types, :range, quote(do: SourceFile.Range))
+
+      _, types ->
+        types
+    end)
+    |> Keyword.put(:lsp, quote(do: unquote(caller_module).LSP))
+  end
+end

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

@@ -1,13 +1,6 @@
 defmodule ElixirLS.LanguageServer.Experimental.Protocol.Proto.Notification do
   alias ElixirLS.LanguageServer.Experimental.Protocol.Proto.CompileMetadata
-
-  alias ElixirLS.LanguageServer.Experimental.Protocol.Proto.Macros.{
-    Access,
-    Meta,
-    Parse,
-    Struct,
-    Typespec
-  }
+  alias ElixirLS.LanguageServer.Experimental.Protocol.Proto.Macros.Message
 
   defmacro defnotification(method, types) do
     CompileMetadata.add_notification_module(__CALLER__.module)
@@ -17,43 +10,40 @@ defmodule ElixirLS.LanguageServer.Experimental.Protocol.Proto.Notification do
       method: quote(do: literal(unquote(method)))
     ]
 
-    all_types = Keyword.merge(jsonrpc_types, types)
+    param_names = Keyword.keys(types)
+    lsp_types = Keyword.merge(jsonrpc_types, types)
+    elixir_types = Message.generate_elixir_types(__CALLER__.module, lsp_types)
 
     quote location: :keep do
-      unquote(Access.build())
-      unquote(Struct.build(all_types))
-      unquote(Typespec.build())
-      unquote(build_notification_parse_function(method))
-      unquote(Parse.build(types))
-      unquote(Meta.build(all_types))
-
-      def __meta__(:method_name) do
-        unquote(method)
+      defmodule LSP do
+        unquote(Message.build(:notification, method, lsp_types, param_names))
       end
 
-      def __meta__(:type) do
-        :notification
-      end
+      alias ElixirLS.LanguageServer.Experimental.Protocol.Proto.Convert
 
-      def __meta__(:param_names) do
-        unquote(Keyword.keys(types))
+      unquote(
+        Message.build(:notification, method, elixir_types, param_names, include_parse?: false)
+      )
+
+      unquote(build_parse(method))
+
+      def to_elixir(%__MODULE__{} = request) do
+        Convert.to_elixir(request)
       end
     end
   end
 
-  defp build_notification_parse_function(method) do
+  defp build_parse(method) do
     quote do
       def parse(%{"method" => unquote(method), "jsonrpc" => "2.0"} = request) do
         params = Map.get(request, "params", %{})
+        flattened_notificaiton = Map.merge(request, params)
 
-        case parse(params) do
-          {:ok, result} ->
-            result =
-              result
-              |> Map.put(:method, unquote(method))
-              |> Map.put(:jsonrpc, "2.0")
-
-            {:ok, result}
+        case LSP.parse(flattened_notificaiton) do
+          {:ok, raw_lsp} ->
+            struct_opts = [method: unquote(method), jsonrpc: "2.0", lsp: raw_lsp]
+            notification = struct(__MODULE__, struct_opts)
+            {:ok, notification}
 
           error ->
             error

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

@@ -1,20 +1,12 @@
 defmodule ElixirLS.LanguageServer.Experimental.Protocol.Proto.Request do
   alias ElixirLS.LanguageServer.Experimental.Protocol.Proto.CompileMetadata
+  alias ElixirLS.LanguageServer.Experimental.Protocol.Proto.Macros.Message
+  alias ElixirLS.LanguageServer.Experimental.Protocol.Proto.TypeFunctions
 
-  alias ElixirLS.LanguageServer.Experimental.Protocol.Proto.Macros.{
-    Access,
-    Struct,
-    Parse,
-    Typespec,
-    Meta
-  }
+  import TypeFunctions, only: [optional: 1, integer: 0, literal: 1]
 
   defmacro defrequest(method, types) do
-    alias ElixirLS.LanguageServer.Experimental.Protocol.Proto.TypeFunctions
-    import TypeFunctions, only: [optional: 1, integer: 0, literal: 1]
-
     CompileMetadata.add_request_module(__CALLER__.module)
-
     # id is optional so we can resuse the parse function. If it's required,
     # it will go in the pattern match for the params, which won't work.
 
@@ -24,43 +16,38 @@ defmodule ElixirLS.LanguageServer.Experimental.Protocol.Proto.Request do
       method: quote(do: literal(unquote(method)))
     ]
 
-    all_types = Keyword.merge(jsonrpc_types, types)
+    lsp_types = Keyword.merge(jsonrpc_types, types)
+    elixir_types = Message.generate_elixir_types(__CALLER__.module, lsp_types)
+    param_names = Keyword.keys(types)
 
     quote location: :keep do
-      unquote(Access.build())
-      unquote(Struct.build(all_types))
-      unquote(Typespec.build())
-      unquote(build_request_parse_function(method))
-      unquote(Parse.build(types))
-      unquote(Meta.build(all_types))
-
-      def __meta__(:method_name) do
-        unquote(method)
+      defmodule LSP do
+        unquote(Message.build(:request, method, lsp_types, param_names))
       end
 
-      def __meta__(:type) do
-        :request
-      end
+      alias ElixirLS.LanguageServer.Experimental.Protocol.Proto.Convert
+      alias ElixirLS.LanguageServer.Experimental.Protocol.Types
 
-      def __meta__(:param_names) do
-        unquote(Keyword.keys(types))
+      unquote(Message.build(:request, method, elixir_types, param_names, include_parse?: false))
+
+      unquote(build_parse(method))
+
+      def to_elixir(%__MODULE__{} = request) do
+        Convert.to_elixir(request)
       end
     end
   end
 
-  defp build_request_parse_function(method) do
+  defp build_parse(method) do
     quote do
       def parse(%{"method" => unquote(method), "id" => id, "jsonrpc" => "2.0"} = request) do
         params = Map.get(request, "params", %{})
+        flattened_request = Map.merge(request, params)
 
-        case parse(params) do
-          {:ok, request} ->
-            request =
-              request
-              |> Map.put(:id, id)
-              |> Map.put(:method, unquote(method))
-              |> Map.put(:jsonrpc, "2.0")
-
+        case LSP.parse(flattened_request) do
+          {:ok, raw_lsp} ->
+            struct_opts = [id: id, method: unquote(method), jsonrpc: "2.0", lsp: raw_lsp]
+            request = struct(__MODULE__, struct_opts)
             {:ok, request}
 
           error ->

apps/language_server/lib/language_server/experimental/source_file/conversions.ex

@@ -40,6 +40,10 @@ defmodule ElixirLS.LanguageServer.Experimental.SourceFile.Conversions do
     to_elixir(ls_range, source)
   end
 
+  def to_elixir(%LSPosition{} = position, %SourceFile{} = source_file) do
+    to_elixir(position, source_file.document)
+  end
+
   def to_elixir(%ElixirPosition{} = position, _) do
     position
   end