Respect struct field order when printing types

Author: josevalim

lib/elixir/lib/module/types/descr.ex

@@ -1822,36 +1822,30 @@ defmodule Module.Types.Descr do
     case tag do
       :closed ->
         with %{__struct__: struct_descr} <- fields,
-             {_, [struct]} <- atom_fetch(struct_descr) do
-          fields = Map.delete(fields, :__struct__)
+             {_, [struct]} <- atom_fetch(struct_descr),
+             [_ | _] = info <- maybe_struct(struct),
+             true <- map_size(fields) == length(info) + 1,
+             true <- Enum.all?(info, &is_map_key(fields, &1.field)) do
+          collapse? = Keyword.get(opts, :collapse_structs, false)
 
           fields =
-            with true <- Keyword.get(opts, :collapse_structs, false),
-                 [_ | _] = info <- maybe_struct(struct),
-                 true <- Enum.all?(info, &is_map_key(fields, &1.field)) do
-              Enum.reduce(info, fields, fn %{field: field}, acc ->
-                # TODO: This should consider the struct default value
-                if Map.fetch!(acc, field) == term() do
-                  Map.delete(acc, field)
-                else
-                  acc
-                end
-              end)
-            else
-              _ -> fields
-            end
+            for %{field: field} <- info,
+                type = Map.fetch!(fields, field),
+                # TODO: This should consider the struct default type
+                not collapse? or type != term(),
+                do: {field, type}
 
           {:%, [],
            [
              literal_to_quoted(struct),
              {:%{}, [], map_fields_to_quoted(tag, fields, opts)}
            ]}
         else
-          _ -> {:%{}, [], map_fields_to_quoted(tag, fields, opts)}
+          _ -> {:%{}, [], map_fields_to_quoted(tag, Enum.sort(fields), opts)}
         end
 
       :open ->
-        {:%{}, [], [{:..., [], nil} | map_fields_to_quoted(tag, fields, opts)]}
+        {:%{}, [], [{:..., [], nil} | map_fields_to_quoted(tag, Enum.sort(fields), opts)]}
     end
   end
 
@@ -1863,8 +1857,7 @@ defmodule Module.Types.Descr do
     end
   end
 
-  defp map_fields_to_quoted(tag, map, opts) do
-    sorted = Enum.sort(Map.to_list(map))
+  defp map_fields_to_quoted(tag, sorted, opts) do
     keyword? = Inspect.List.keyword?(sorted)
 
     for {key, type} <- sorted,

lib/elixir/test/elixir/module/types/descr_test.exs

@@ -1,5 +1,9 @@
 Code.require_file("type_helper.exs", __DIR__)
 
+defmodule Decimal do
+  defstruct [:sign, :coef, :exp]
+end
+
 defmodule Module.Types.DescrTest do
   use ExUnit.Case, async: true
 
@@ -1354,8 +1358,8 @@ defmodule Module.Types.DescrTest do
              |> to_quoted_string() ==
                """
                dynamic(
-                 :error or {%Decimal{coef: :NaN or :inf, exp: integer(), sign: integer()}, binary()} or
-                   {%Decimal{coef: :NaN or :inf or integer(), exp: integer(), sign: integer()}, term()}
+                 :error or {%Decimal{sign: integer(), coef: :NaN or :inf, exp: integer()}, binary()} or
+                   {%Decimal{sign: integer(), coef: :NaN or :inf or integer(), exp: integer()}, term()}
                )\
                """
     end
@@ -1470,16 +1474,26 @@ defmodule Module.Types.DescrTest do
     end
 
     test "structs" do
-      assert open_map(__struct__: atom([URI])) |> to_quoted_string() == "%{..., __struct__: URI}"
+      assert open_map(__struct__: atom([URI])) |> to_quoted_string() ==
+               "%{..., __struct__: URI}"
 
       assert closed_map(__struct__: atom([URI])) |> to_quoted_string() ==
-               "%URI{}"
-
-      assert closed_map(__struct__: atom([URI]), path: atom([nil])) |> to_quoted_string() ==
-               "%URI{path: nil}"
+               "%{__struct__: URI}"
 
       assert closed_map(__struct__: atom([URI, Another])) |> to_quoted_string() ==
                "%{__struct__: Another or URI}"
+
+      assert closed_map(__struct__: atom([Decimal]), coef: term(), exp: term(), sign: term())
+             |> to_quoted_string() ==
+               "%Decimal{sign: term(), coef: term(), exp: term()}"
+
+      assert closed_map(__struct__: atom([Decimal]), coef: term(), exp: term(), sign: term())
+             |> to_quoted_string(collapse_structs: true) ==
+               "%Decimal{}"
+
+      assert closed_map(__struct__: atom([Decimal]), coef: term(), exp: term(), sign: integer())
+             |> to_quoted_string(collapse_structs: true) ==
+               "%Decimal{sign: integer()}"
     end
   end
 

lib/elixir/test/elixir/module/types/expr_test.exs

@@ -801,14 +801,14 @@ defmodule Module.Types.ExprTest do
              the given type does not have the given key:
 
                  dynamic(%URI{
+                   scheme: term(),
                    authority: term(),
-                   fragment: term(),
+                   userinfo: term(),
                    host: term(),
-                   path: term(),
                    port: term(),
+                   path: term(),
                    query: term(),
-                   scheme: term(),
-                   userinfo: term()
+                   fragment: term()
                  })
 
              where "x" was given the type: