Features and bug fixes

  * Reworked literal numbering sequence so the first generated object
  literal is not given a sequence number and subsequent sequence
  numbers start at 0.
  * Added the `--only` option to the generator so it can import single
  types
  * Added the `--roots` option so the generator can import entire
  dependency chains. This is very helpful when adding a new request or
  notification.
  * Added command line switches to set the proto and types modules
  * Improved the source code formatting

Author: scohen

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

@@ -152,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
@@ -221,10 +227,21 @@ defmodule ElixirLS.LanguageServer.Experimental.Protocol.Proto.Field do
   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)
+    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

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

@@ -36,17 +36,20 @@ defmodule Mix.Tasks.Lsp.DataModel do
   end
 
   def all_types(%__MODULE__{} = data_model) do
-    data_model.type_aliases
-    |> Map.merge(data_model.enumerations)
-    |> Map.merge(data_model.structures)
+    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
-        :structure -> :structures
-        :type_alias -> :type_aliases
-        :enumeration -> :enumerations
+        {:ok, :structure} -> :structures
+        {:ok, :type_alias} -> :type_aliases
+        {:ok, :enumeration} -> :enumerations
+        :error -> :error
       end
 
     data_model
@@ -68,6 +71,29 @@ defmodule Mix.Tasks.Lsp.DataModel do
     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)
@@ -78,7 +104,7 @@ defmodule Mix.Tasks.Lsp.DataModel do
   end
 
   defp kind(%__MODULE__{} = data_model, name) do
-    Map.fetch!(data_model.names_to_types, name)
+    Map.fetch(data_model.names_to_types, name)
   end
 
   defp type_name("structures"), do: :structure

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

@@ -35,6 +35,8 @@ defmodule Mix.Tasks.Lsp.DataModel.Enumeration do
         %Mappings{} = mappings,
         %DataModel{}
       ) do
+    proto_module = Mappings.proto_module(mappings)
+
     with {:ok, destination_module} <-
            Mappings.fetch_destination_module(mappings, enumeration.name) do
       values =
@@ -46,7 +48,7 @@ defmodule Mix.Tasks.Lsp.DataModel.Enumeration do
       ast =
         quote do
           defmodule unquote(destination_module) do
-            alias ElixirLS.LanguageServer.Experimental.Protocol.Proto
+            alias unquote(proto_module)
             use Proto
 
             defenum unquote(values)
@@ -56,4 +58,8 @@ defmodule Mix.Tasks.Lsp.DataModel.Enumeration do
       {:ok, ast}
     end
   end
+
+  def references(%__MODULE__{}) do
+    []
+  end
 end

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

@@ -26,4 +26,12 @@ defmodule Mix.Tasks.Lsp.DataModel.Property do
       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/structure.ex

@@ -1,4 +1,5 @@
 defmodule Mix.Tasks.Lsp.DataModel.Structure do
+  alias Mix.Tasks.Lsp.Mappings.NumberingContext
   alias Mix.Tasks.Lsp.DataModel.Type.ObjectLiteral
   alias Mix.Tasks.Lsp.Mappings
   alias Mix.Tasks.Lsp.DataModel
@@ -8,6 +9,8 @@ defmodule Mix.Tasks.Lsp.DataModel.Structure do
   defstruct name: nil, documentation: nil, properties: nil, definition: nil, module: nil
 
   def new(%{"name" => name, "properties" => _} = definition) do
+    NumberingContext.new()
+
     %__MODULE__{
       name: name,
       documentation: definition[:documentation],
@@ -26,19 +29,32 @@ defmodule Mix.Tasks.Lsp.DataModel.Structure do
         %DataModel{} = data_model
       ) do
     with {:ok, destination_module} <- Mappings.fetch_destination_module(mappings, structure.name) do
+      NumberingContext.new()
+      types_module = Mappings.types_module(mappings)
+      proto_module = Mappings.proto_module(mappings)
       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))
+        structure.properties
+        |> Enum.sort_by(& &1.name)
+        |> Enum.map(&Property.to_protocol(&1, data_model, mappings))
+
+      type_module_alias =
+        case references(structure) do
+          [] -> []
+          _ -> [quote(do: alias(unquote(types_module)))]
+        end
 
       ast =
         quote do
           defmodule unquote(destination_module) do
-            alias ElixirLS.LanguageServer.Experimental.Protocol.Proto
+            alias unquote(proto_module)
+            unquote_splicing(type_module_alias)
+
             unquote_splicing(literal_definitions)
 
             use Proto
@@ -50,6 +66,10 @@ defmodule Mix.Tasks.Lsp.DataModel.Structure do
     end
   end
 
+  def references(%__MODULE__{} = structure) do
+    Enum.flat_map(structure.properties, &Property.references/1)
+  end
+
   def resolve(%__MODULE__{properties: properties} = structure) when is_list(properties) do
     structure
   end