Added code generators for LSP data structures

Adding the LSP data structures by hand was growing tedious and there
were a couple bugs. Doing this programatically seems like it would be
safer and easier in the long run.
Right now, all of the data structures are mapped, which will likely make
compile times a bit longer, but mapping things as needed would add a lot
of complexity to something that only needs to be done occasionally.

Note: as of now, I haven't run this and checked in any artifacts. That
will happen in a subsequent PR.

Author: scohen

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

@@ -88,6 +88,31 @@ defmodule ElixirLS.LanguageServer.Experimental.Protocol.Proto.Field do
     end
   end
 
+  def extract({:tuple, tuple_types}, field_name, field_value) when is_list(field_value) do
+    result =
+      field_value
+      |> Enum.zip(tuple_types)
+      |> Enum.reduce_while([], fn {value, type}, acc ->
+        case extract(type, field_name, value) do
+          {:ok, value} -> {:cont, [value | acc]}
+          error -> {:halt, error}
+        end
+      end)
+
+    case result do
+      value when is_list(value) ->
+        value_as_tuple =
+          value
+          |> Enum.reverse()
+          |> List.to_tuple()
+
+        {:ok, value_as_tuple}
+
+      error ->
+        error
+    end
+  end
+
   def extract({:params, param_defs}, _field_name, field_value)
       when is_map(field_value) do
     result =
@@ -168,6 +193,10 @@ defmodule ElixirLS.LanguageServer.Experimental.Protocol.Proto.Field do
     {:ok, float_value}
   end
 
+  def encode(:float, field_value) when is_float(field_value) do
+    field_value
+  end
+
   def encode(:string, field_value) when is_binary(field_value) do
     {:ok, field_value}
   end
@@ -191,6 +220,13 @@ defmodule ElixirLS.LanguageServer.Experimental.Protocol.Proto.Field do
     end
   end
 
+  def encode({:tuple, types}, field_value) when is_tuple(field_value) do
+    field_value
+    |> Tuple.to_list()
+    |> Enum.zip(types)
+    |> Enum.map(fn {value, type} -> encode(type, value) end)
+  end
+
   def encode({:params, param_defs}, field_value) when is_map(field_value) do
     param_fields =
       Enum.reduce_while(param_defs, [], fn {param_name, param_type}, acc ->

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

@@ -31,6 +31,10 @@ defmodule ElixirLS.LanguageServer.Experimental.Protocol.Proto.TypeFunctions do
     {:list, type}
   end
 
+  def tuple_of(types) when is_list(types) do
+    {:tuple, types}
+  end
+
   def map_of(type, opts \\ []) do
     field_name = Keyword.get(opts, :as)
     {:map, type, field_name}

apps/language_server/lib/mix/tasks/lsp/data_model.ex

@@ -0,0 +1,99 @@
+defmodule Mix.Tasks.Lsp.DataModel do
+  alias Mix.Tasks.Lsp.DataModel.Enumeration
+  alias Mix.Tasks.Lsp.DataModel.Structure
+  alias Mix.Tasks.Lsp.DataModel.TypeAlias
+
+  defstruct names_to_types: %{},
+            notifications: %{},
+            requests: %{},
+            structures: %{},
+            type_aliases: %{},
+            enumerations: %{}
+
+  def new do
+    with {:ok, root_meta} <- load_meta_model() do
+      names_to_types =
+        root_meta
+        |> Map.take(~w(structures enumerations typeAliases))
+        |> Enum.flat_map(fn {type, list_of_things} ->
+          Enum.map(list_of_things, fn %{"name" => name} -> {name, type_name(type)} end)
+        end)
+        |> Map.new()
+
+      type_aliases = load_from_meta(root_meta, "typeAliases", &TypeAlias.new/1)
+      enumerations = load_from_meta(root_meta, "enumerations", &Enumeration.new/1)
+      structures = load_from_meta(root_meta, "structures", &Structure.new/1)
+
+      data_model = %__MODULE__{
+        names_to_types: names_to_types,
+        enumerations: enumerations,
+        type_aliases: type_aliases,
+        structures: structures
+      }
+
+      {:ok, data_model}
+    end
+  end
+
+  def all_types(%__MODULE__{} = data_model) do
+    data_model.type_aliases
+    |> Map.merge(data_model.enumerations)
+    |> Map.merge(data_model.structures)
+  end
+
+  def fetch(%__MODULE__{} = data_model, name) do
+    field =
+      case kind(data_model, name) do
+        :structure -> :structures
+        :type_alias -> :type_aliases
+        :enumeration -> :enumerations
+      end
+
+    data_model
+    |> Map.get(field, %{})
+    |> Map.fetch(name)
+    |> case do
+      {:ok, %element_module{} = element} ->
+        {:ok, element_module.resolve(element, data_model)}
+
+      :error ->
+        :error
+    end
+  end
+
+  def fetch!(%__MODULE__{} = data_model, name) do
+    case fetch(data_model, name) do
+      {:ok, thing} -> thing
+      :error -> raise "Could not find type #{name}"
+    end
+  end
+
+  defp load_from_meta(root_meta, name, new_fn) do
+    root_meta
+    |> Map.get(name)
+    |> Map.new(fn definition ->
+      loaded = new_fn.(definition)
+      {loaded.name, loaded}
+    end)
+  end
+
+  defp kind(%__MODULE__{} = data_model, name) do
+    Map.fetch!(data_model.names_to_types, name)
+  end
+
+  defp type_name("structures"), do: :structure
+  defp type_name("enumerations"), do: :enumeration
+  defp type_name("typeAliases"), do: :type_alias
+
+  @meta_model_file_name "metamodel.3.17.json"
+  defp load_meta_model do
+    file_name =
+      __ENV__.file
+      |> Path.dirname()
+      |> Path.join([@meta_model_file_name])
+
+    with {:ok, file_contents} <- File.read(file_name) do
+      JasonVendored.decode(file_contents)
+    end
+  end
+end

apps/language_server/lib/mix/tasks/lsp/data_model/enumeration.ex

@@ -0,0 +1,59 @@
+defmodule Mix.Tasks.Lsp.DataModel.Enumeration do
+  defmodule Value do
+    defstruct [:name, :value, :documentation]
+
+    def new(%{"name" => name, "value" => value} = value_meta) do
+      docs = value_meta["documentation"]
+      %__MODULE__{name: name, value: value, documentation: docs}
+    end
+  end
+
+  alias Mix.Tasks.Lsp.Mappings
+  alias Mix.Tasks.Lsp.DataModel
+  alias Mix.Tasks.Lsp.DataModel.Type
+  defstruct [:name, :values, :type]
+
+  def new(%{"name" => name, "type" => type, "values" => values}) do
+    %__MODULE__{
+      name: name,
+      type: Type.new(name, type),
+      values: Enum.map(values, &Value.new/1)
+    }
+  end
+
+  def to_protocol(%__MODULE__{} = enumeration, _, _) do
+    module_name = Module.concat([enumeration.name])
+    quote(do: unquote(module_name))
+  end
+
+  def resolve(%__MODULE__{} = enumeration, %DataModel{} = data_model) do
+    %__MODULE__{enumeration | type: Type.resolve(enumeration.type, data_model)}
+  end
+
+  def build_definition(
+        %__MODULE__{} = enumeration,
+        %Mappings{} = mappings,
+        %DataModel{}
+      ) do
+    with {:ok, destination_module} <-
+           Mappings.fetch_destination_module(mappings, enumeration.name) do
+      values =
+        Enum.map(enumeration.values, fn value ->
+          name = value.name |> Macro.underscore() |> String.to_atom()
+          quote(do: {unquote(name), unquote(value.value)})
+        end)
+
+      ast =
+        quote do
+          defmodule unquote(destination_module) do
+            alias ElixirLS.LanguageServer.Experimental.Protocol.Proto
+            use Proto
+
+            defenum unquote(values)
+          end
+        end
+
+      {:ok, ast}
+    end
+  end
+end

apps/language_server/lib/mix/tasks/lsp/data_model/notification.ex

@@ -0,0 +1,3 @@
+defmodule Mix.Tasks.Lsp.DataModel.Notification do
+  defstruct [:method, :direction, :params, :documentation]
+end

apps/language_server/lib/mix/tasks/lsp/data_model/property.ex

@@ -0,0 +1,29 @@
+defmodule Mix.Tasks.Lsp.DataModel.Property do
+  alias Mix.Tasks.Lsp.DataModel
+  alias Mix.Tasks.Lsp.Mappings
+  alias Mix.Tasks.Lsp.DataModel.Type
+
+  defstruct [:name, :type, :required?, :references, :documentation]
+
+  def new(%{"name" => name, "type" => type} = property_meta) do
+    required? = !Map.get(property_meta, "optional", false)
+
+    keys = Keyword.merge([name: name, required?: required?], type: Type.new(name, type))
+    struct(__MODULE__, keys)
+  end
+
+  def resolve(%__MODULE__{} = property, %DataModel{} = data_model) do
+    %__MODULE__{property | type: Type.resolve(property.type, data_model)}
+  end
+
+  def to_protocol(%__MODULE__{} = property, %DataModel{} = data_model, %Mappings{} = mappings) do
+    underscored = property.name |> Macro.underscore() |> String.to_atom()
+    type_call = Type.to_protocol(property.type, data_model, mappings)
+
+    if property.required? do
+      quote(do: {unquote(underscored), unquote(type_call)})
+    else
+      quote(do: {unquote(underscored), optional(unquote(type_call))})
+    end
+  end
+end

apps/language_server/lib/mix/tasks/lsp/data_model/request.ex

@@ -0,0 +1,3 @@
+defmodule Mix.Tasks.Lsp.DataModel.Request do
+  defstruct [:method, :result, :direction, :params]
+end

apps/language_server/lib/mix/tasks/lsp/data_model/structure.ex

@@ -0,0 +1,111 @@
+defmodule Mix.Tasks.Lsp.DataModel.Structure do
+  alias Mix.Tasks.Lsp.DataModel.Type.ObjectLiteral
+  alias Mix.Tasks.Lsp.Mappings
+  alias Mix.Tasks.Lsp.DataModel
+  alias Mix.Tasks.Lsp.DataModel.Type
+  alias Mix.Tasks.Lsp.DataModel.Property
+
+  defstruct name: nil, documentation: nil, properties: nil, definition: nil, module: nil
+
+  def new(%{"name" => name, "properties" => _} = definition) do
+    %__MODULE__{
+      name: name,
+      documentation: definition[:documentation],
+      definition: definition,
+      module: Module.concat([name])
+    }
+  end
+
+  def to_protocol(%__MODULE__{} = structure, _, %Mappings{} = _mappings) do
+    quote(do: unquote(structure.module))
+  end
+
+  def build_definition(
+        %__MODULE__{} = structure,
+        %Mappings{} = mappings,
+        %DataModel{} = data_model
+      ) do
+    with {:ok, destination_module} <- Mappings.fetch_destination_module(mappings, structure.name) do
+      structure = resolve(structure, data_model)
+      object_literals = Type.collect_object_literals(structure, data_model)
+
+      literal_definitions =
+        Enum.map(object_literals, &ObjectLiteral.build_definition(&1, data_model, mappings))
+
+      protocol_properties =
+        Enum.map(structure.properties, &Property.to_protocol(&1, data_model, mappings))
+
+      ast =
+        quote do
+          defmodule unquote(destination_module) do
+            alias ElixirLS.LanguageServer.Experimental.Protocol.Proto
+            unquote_splicing(literal_definitions)
+
+            use Proto
+            deftype unquote(protocol_properties)
+          end
+        end
+
+      {:ok, ast}
+    end
+  end
+
+  def resolve(%__MODULE__{properties: properties} = structure) when is_list(properties) do
+    structure
+  end
+
+  def resolve(%__MODULE__{} = structure, %DataModel{} = data_model) do
+    %__MODULE__{structure | properties: properties(structure, data_model)}
+  end
+
+  def properties(%__MODULE__{properties: properties}) when is_list(properties) do
+    properties
+  end
+
+  def properties(%__MODULE__{} = structure, %DataModel{} = data_model) do
+    property_list(structure, data_model)
+  end
+
+  defp resolve_remote_properties(%__MODULE__{} = structure, %DataModel{} = data_model) do
+    []
+    |> add_extends(structure.definition)
+    |> add_mixins(structure.definition)
+    |> Enum.flat_map(fn %{"kind" => "reference", "name" => type_name} ->
+      data_model
+      |> DataModel.fetch!(type_name)
+      |> property_list(data_model)
+    end)
+  end
+
+  defp property_list(%__MODULE__{} = structure, %DataModel{} = data_model) do
+    base_properties =
+      structure.definition
+      |> Map.get("properties")
+      |> Enum.map(&Property.new/1)
+
+    base_property_names = MapSet.new(base_properties, & &1.name)
+
+    # Note: The reject here is so that properties defined in the
+    # current structure override those defined in mixins and extends
+    resolved_remote_properties =
+      structure
+      |> resolve_remote_properties(data_model)
+      |> Enum.reject(&(&1.name in base_property_names))
+
+    base_properties
+    |> Enum.concat(resolved_remote_properties)
+    |> Enum.sort_by(& &1.name)
+  end
+
+  defp add_extends(queue, %{"extends" => extends}) do
+    extends ++ queue
+  end
+
+  defp add_extends(queue, _), do: queue
+
+  defp add_mixins(queue, %{"mixins" => mixins}) do
+    mixins ++ queue
+  end
+
+  defp add_mixins(queue, _), do: queue
+end