Add Macro.struct_info!

Author: josevalim

lib/elixir/lib/kernel.ex

@@ -5459,7 +5459,7 @@ defmodule Kernel do
   defmacro defstruct(fields) do
     header =
       quote bind_quoted: [fields: fields, bootstrapped?: bootstrapped?(Enum)] do
-        {struct, derive, kv, body} =
+        {struct, derive, escaped_struct, kv, body} =
           Kernel.Utils.defstruct(__MODULE__, fields, bootstrapped?, __ENV__)
 
         case derive do
@@ -5473,7 +5473,7 @@ defmodule Kernel do
     # especially since they are often expanded at compile-time.
     functions =
       quote line: 0, unquote: false do
-        def __struct__(), do: @__struct__
+        def __struct__(), do: unquote(escaped_struct)
         def __struct__(unquote(kv)), do: unquote(body)
       end
 

lib/elixir/lib/kernel/typespec.ex

@@ -567,27 +567,23 @@ defmodule Kernel.Typespec do
   defp typespec({:%, _, [name, {:%{}, meta, fields}]} = node, vars, caller, state) do
     case Macro.expand(name, %{caller | function: {:__info__, 1}}) do
       module when is_atom(module) ->
-        struct =
-          module
-          |> Macro.struct!(caller)
-          |> Map.delete(:__struct__)
-          |> Map.to_list()
+        struct_info = Macro.struct_info!(module, caller)
 
         if not Keyword.keyword?(fields) do
           compile_error(caller, "expected key-value pairs in struct #{Macro.to_string(name)}")
         end
 
         types =
           :lists.map(
-            fn
-              {:__exception__ = field, true} -> {field, Keyword.get(fields, field, true)}
-              {field, _} -> {field, Keyword.get(fields, field, quote(do: term()))}
+            fn %{field: field} ->
+              default_type = if field == :__exception__, do: true, else: quote(do: term())
+              {field, Keyword.get(fields, field, default_type)}
             end,
-            :lists.sort(struct)
+            struct_info
           )
 
         fun = fn {field, _} ->
-          if not Keyword.has_key?(struct, field) do
+          if not Enum.any?(struct_info, &(&1.field == field)) do
             compile_error(
               caller,
               "undefined field #{inspect(field)} on struct #{inspect(module)}"
@@ -596,7 +592,7 @@ defmodule Kernel.Typespec do
         end
 
         :lists.foreach(fun, fields)
-        typespec({:%{}, meta, [__struct__: module] ++ types}, vars, caller, state)
+        typespec({:%{}, meta, [__struct__: module] ++ :lists.usort(types)}, vars, caller, state)
 
       _ ->
         compile_error(

lib/elixir/lib/kernel/utils.ex

@@ -103,7 +103,7 @@ defmodule Kernel.Utils do
   def defstruct(module, fields, bootstrapped?, env) do
     {set, bag} = :elixir_module.data_tables(module)
 
-    if :ets.member(set, :__struct__) do
+    if :ets.member(set, {:elixir, :struct}) do
       raise ArgumentError,
             "defstruct has already been called for " <>
               "#{Kernel.inspect(module)}, defstruct can only be called once per module"
@@ -119,6 +119,8 @@ defmodule Kernel.Utils do
 
     mapper = fn
       {key, val} when is_atom(key) ->
+        key == :__struct__ and raise(ArgumentError, "cannot set :__struct__ in struct definition")
+
         try do
           :elixir_quote.escape(val, :none, false)
         rescue
@@ -129,6 +131,7 @@ defmodule Kernel.Utils do
         end
 
       key when is_atom(key) ->
+        key == :__struct__ and raise(ArgumentError, "cannot set :__struct__ in struct definition")
         {key, nil}
 
       other ->
@@ -163,23 +166,24 @@ defmodule Kernel.Utils do
     end
 
     :lists.foreach(foreach, enforce_keys)
-    struct = :maps.put(:__struct__, module, :maps.from_list(fields))
+    struct = :maps.from_list([__struct__: module] ++ fields)
+    escaped_struct = :elixir_quote.escape(struct, :none, false)
 
     body =
       case bootstrapped? do
         true ->
           case enforce_keys do
             [] ->
               quote do
-                Enum.reduce(kv, @__struct__, fn {key, val}, map ->
+                Enum.reduce(kv, unquote(escaped_struct), fn {key, val}, map ->
                   %{map | key => val}
                 end)
               end
 
             _ ->
               quote do
                 {map, keys} =
-                  Enum.reduce(kv, {@__struct__, unquote(enforce_keys)}, fn
+                  Enum.reduce(kv, {unquote(escaped_struct), unquote(enforce_keys)}, fn
                     {key, val}, {map, keys} ->
                       {%{map | key => val}, List.delete(keys, key)}
                   end)
@@ -200,25 +204,21 @@ defmodule Kernel.Utils do
           quote do
             :lists.foldl(
               fn {key, val}, acc -> %{acc | key => val} end,
-              @__struct__,
+              unquote(escaped_struct),
               kv
             )
           end
       end
 
     case enforce_keys -- :maps.keys(struct) do
       [] ->
-        # The __struct__ attribute is during expansion and for loading remote structs
-        :ets.insert(set, {:__struct__, struct, nil, []})
-
-        # The complete metadata goes into __info__(:struct)
         mapper = fn {key, val} ->
           %{field: key, default: val, required: :lists.member(key, enforce_keys)}
         end
 
         :ets.insert(set, {{:elixir, :struct}, :lists.map(mapper, fields)})
         derive = :lists.map(fn {_, value} -> value end, :ets.take(bag, {:accumulate, :derive}))
-        {struct, :lists.reverse(derive), quote(do: kv), body}
+        {struct, :lists.reverse(derive), escaped_struct, quote(do: kv), body}
 
       error_keys ->
         raise ArgumentError,

lib/elixir/lib/macro.ex

@@ -827,30 +827,36 @@ defmodule Macro do
     :elixir_quote.escape(expr, kind, unquote)
   end
 
+  # TODO: Deprecate me on Elixir v1.22
+  @doc false
+  def struct!(module, env) when is_atom(module) do
+    pairs =
+      for %{field: field, default: default} <- struct_info!(module, env), do: {field, default}
+
+    :maps.from_list([__struct__: module] ++ pairs)
+  end
+
   @doc """
-  Expands the struct given by `module` in the given `env`.
+  Extracts the struct information (equivalent to calling
+  `module.__info__(:struct)`).
 
   This is useful when a struct needs to be expanded at
   compilation time and the struct being expanded may or may
   not have been compiled. This function is also capable of
   expanding structs defined under the module being compiled.
+  Calling this function also adds an export dependency on the
+  given struct.
 
-  It will raise `CompileError` if the struct is not available.
-  From Elixir v1.12, calling this function also adds an export
-  dependency on the given struct.
+  It will raise `ArgumentError` if the struct is not available.
   """
-  @doc since: "1.8.0"
-  @spec struct!(module, Macro.Env.t()) ::
-          %{required(:__struct__) => module, optional(atom) => any}
-        when module: module()
-  def struct!(module, env) when is_atom(module) do
-    if module == env.module do
-      Module.get_attribute(module, :__struct__)
-    end ||
-      case :elixir_map.maybe_load_struct([line: env.line], module, [], [], env) do
-        {:ok, struct} -> struct
-        {:error, desc} -> raise ArgumentError, List.to_string(:elixir_map.format_error(desc))
-      end
+  @doc since: "1.18.0"
+  @spec struct_info!(module(), Macro.Env.t()) ::
+          [%{field: atom(), required: boolean(), default: term()}]
+  def struct_info!(module, env) when is_atom(module) do
+    case :elixir_map.maybe_load_struct_info([line: env.line], module, [], env) do
+      {:ok, info} -> info
+      {:error, desc} -> raise ArgumentError, List.to_string(:elixir_map.format_error(desc))
+    end
   end
 
   @doc """

lib/elixir/lib/macro/env.ex

@@ -102,8 +102,10 @@ defmodule Macro.Env do
   ]
 
   # Define the __struct__ callbacks by hand for bootstrap reasons.
-  {struct, [], kv, body} = Kernel.Utils.defstruct(__MODULE__, fields, false, __ENV__)
-  def __struct__(), do: unquote(:elixir_quote.escape(struct, :none, false))
+  {_struct, [], escaped_struct, kv, body} =
+    Kernel.Utils.defstruct(__MODULE__, fields, false, __ENV__)
+
+  def __struct__(), do: unquote(escaped_struct)
   def __struct__(unquote(kv)), do: unquote(body)
 
   @doc """

lib/elixir/lib/module.ex

@@ -1944,7 +1944,7 @@ defmodule Module do
 
       _ ->
         message =
-          case :ets.lookup(set, :__struct__) do
+          case :ets.lookup(set, {:elixir, :struct}) do
             [] ->
               "warning: module attribute @derive was set but never used (it must come before defstruct)"
 

lib/elixir/src/elixir.hrl

@@ -1,4 +1,4 @@
--define(key(M, K), maps:get(K, M)).
+-define(key(M, K), map_get(K, M)).
 -define(ann(Meta), elixir_erl:get_ann(Meta)).
 -define(line(Meta), elixir_utils:get_line(Meta)).
 -define(generated(Meta), elixir_utils:generated(Meta)).

lib/elixir/src/elixir_erl.erl

@@ -90,10 +90,21 @@ elixir_to_erl(Tree, Ann) when is_binary(Tree) ->
   %% considers a string in a binary to be encoded in latin1, so the bytes
   %% are not changed in any fashion.
   {bin, Ann, [{bin_element, Ann, {string, Ann, binary_to_list(Tree)}, default, default}]};
-elixir_to_erl(Pid, Ann) when is_pid(Pid) ->
-  ?remote(Ann, erlang, binary_to_term, [elixir_to_erl(term_to_binary(Pid), Ann)]);
-elixir_to_erl(_Other, _Ann) ->
-  error(badarg).
+elixir_to_erl(Tree, Ann) when is_function(Tree) ->
+  case (erlang:fun_info(Tree, type) == {type, external}) andalso
+       (erlang:fun_info(Tree, env) == {env, []}) of
+    true ->
+      {module, Module} = erlang:fun_info(Tree, module),
+      {name, Name} = erlang:fun_info(Tree, name),
+      {arity, Arity} = erlang:fun_info(Tree, arity),
+      {'fun', Ann, {function, {atom, Ann, Module}, {atom, Ann, Name}, {integer, Ann, Arity}}};
+    false ->
+      error(badarg, [Tree, Ann])
+  end;
+elixir_to_erl(Tree, Ann) when is_pid(Tree); is_port(Tree); is_reference(Tree) ->
+  ?remote(Ann, erlang, binary_to_term, [elixir_to_erl(term_to_binary(Tree), Ann)]);
+elixir_to_erl(Tree, Ann) ->
+  error(badarg, [Tree, Ann]).
 
 elixir_to_erl_cons([H | T], Ann) -> {cons, Ann, elixir_to_erl(H, Ann), elixir_to_erl_cons(T, Ann)};
 elixir_to_erl_cons(T, Ann) -> elixir_to_erl(T, Ann).
@@ -296,8 +307,7 @@ macros_info(Defmacro) ->
 struct_info(nil) ->
   {clause, 0, [{atom, 0, struct}], [], [{atom, 0, nil}]};
 struct_info(Fields) ->
-  FieldsWithoutDefault = [maps:remove(default, FieldInfo) || FieldInfo <- Fields],
-  {clause, 0, [{atom, 0, struct}], [], [elixir_to_erl(FieldsWithoutDefault)]}.
+  {clause, 0, [{atom, 0, struct}], [], [elixir_to_erl(Fields)]}.
 
 get_module_info(Module, Key) ->
   Call = ?remote(0, erlang, get_module_info, [{atom, 0, Module}, {var, 0, 'Key'}]),

lib/elixir/src/elixir_expand.erl

@@ -485,9 +485,16 @@ expand(List, S, E) when is_list(List) ->
 
   {EArgs, elixir_env:close_write(SE, S), EE};
 
+expand(Zero, S, #{context := match} = E) when is_float(Zero), Zero == 0.0 ->
+  elixir_errors:file_warn([], E, ?MODULE, invalid_match_on_zero_float),
+  {Zero, S, E};
+
+expand(Other, S, E) when is_number(Other); is_atom(Other); is_binary(Other) ->
+  {Other, S, E};
+
 expand(Function, S, E) when is_function(Function) ->
   case (erlang:fun_info(Function, type) == {type, external}) andalso
-       (erlang:fun_info(Function, env) == {env, []}) of
+        (erlang:fun_info(Function, env) == {env, []}) of
     true ->
       {elixir_quote:fun_to_quoted(Function), S, E};
     false ->
@@ -504,13 +511,6 @@ expand(Pid, S, E) when is_pid(Pid) ->
       {Pid, S, E}
   end;
 
-expand(Zero, S, #{context := match} = E) when is_float(Zero), Zero == 0.0 ->
-  elixir_errors:file_warn([], E, ?MODULE, invalid_match_on_zero_float),
-  {Zero, S, E};
-
-expand(Other, S, E) when is_number(Other); is_atom(Other); is_binary(Other) ->
-  {Other, S, E};
-
 expand(Other, _S, E) ->
   file_error([{line, 0}], ?key(E, file), ?MODULE, {invalid_quoted_expr, Other}).