Merge pull request #793 from scohen/scohen/generated-lsp-structures

Scohen/generated lsp structures

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 =
@@ -127,12 +152,18 @@ defmodule ElixirLS.LanguageServer.Experimental.Protocol.Proto.Field do
   end
 
   def encode({:one_of, types}, field_value) do
-    Enum.reduce_while(types, nil, fn type, _ ->
-      case encode(type, field_value) do
-        {:ok, _} = success -> {:halt, success}
-        error -> {:cont, error}
-      end
-    end)
+    encoded =
+      Enum.reduce_while(types, nil, fn type, _ ->
+        case encode(type, field_value) do
+          {:ok, _} = success -> {:halt, success}
+          error -> {:cont, error}
+        end
+      end)
+
+    case encoded do
+      encoded_list when is_list(encoded_list) -> {:ok, encoded_list}
+      error -> error
+    end
   end
 
   def encode({:list, list_type}, field_value) when is_list(field_value) do
@@ -168,6 +199,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 +226,24 @@ defmodule ElixirLS.LanguageServer.Experimental.Protocol.Proto.Field do
     end
   end
 
+  def encode({:tuple, types}, field_value) when is_tuple(field_value) do
+    encoded =
+      field_value
+      |> Tuple.to_list()
+      |> Enum.zip(types)
+      |> Enum.reduce_while([], fn {value, type}, acc ->
+        case encode(type, value) do
+          {:ok, encoded} -> {:cont, [encoded | acc]}
+          error -> {:halt, error}
+        end
+      end)
+
+    case encoded do
+      encoded_list when is_list(encoded_list) -> {:ok, Enum.reverse(encoded_list)}
+      error -> error
+    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,125 @@
+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
+    aliases = Map.values(data_model.type_aliases)
+    structures = Map.values(data_model.structures)
+    enumerations = Map.values(data_model.enumerations)
+
+    aliases ++ enumerations ++ structures
+  end
+
+  def fetch(%__MODULE__{} = data_model, name) do
+    field =
+      case kind(data_model, name) do
+        {:ok, :structure} -> :structures
+        {:ok, :type_alias} -> :type_aliases
+        {:ok, :enumeration} -> :enumerations
+        :error -> :error
+      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
+
+  def references(%__MODULE__{} = data_model, %{name: name}) do
+    references(data_model, name)
+  end
+
+  def references(%__MODULE__{} = data_model, roots) do
+    collect_references(data_model, List.wrap(roots), MapSet.new())
+  end
+
+  defp collect_references(%__MODULE__{}, [], %MapSet{} = references) do
+    MapSet.to_list(references)
+  end
+
+  defp collect_references(%__MODULE__{} = data_model, [first | rest], %MapSet{} = references) do
+    with false <- MapSet.member?(references, first),
+         {:ok, %referred_type{} = referred} <- fetch(data_model, first) do
+      new_refs = referred_type.references(referred)
+      collect_references(data_model, rest ++ new_refs, MapSet.put(references, first))
+    else
+      _ ->
+        collect_references(data_model, rest, references)
+    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,65 @@
+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
+    proto_module = Mappings.proto_module(mappings)
+
+    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 unquote(proto_module)
+            use Proto
+
+            defenum unquote(values)
+          end
+        end
+
+      {:ok, ast}
+    end
+  end
+
+  def references(%__MODULE__{}) do
+    []
+  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,37 @@
+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
+
+  def references(%__MODULE__{} = property) do
+    %type_module{} = property.type
+
+    property.type
+    |> type_module.references()
+    |> Enum.reject(fn name -> String.starts_with?(name, "LSP") 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