Generate less code in defstruct

Author: josevalim

lib/elixir/lib/kernel.ex

@@ -5177,56 +5177,8 @@ defmodule Kernel do
   use `@type`.
   """
   defmacro defstruct(fields) do
-    builder =
-      case bootstrapped?(Enum) do
-        true ->
-          quote do
-            case @enforce_keys do
-              [] ->
-                def __struct__(kv) do
-                  Enum.reduce(kv, @__struct__, fn {key, val}, map ->
-                    Map.replace!(map, key, val)
-                  end)
-                end
-
-              _ ->
-                def __struct__(kv) do
-                  {map, keys} =
-                    Enum.reduce(kv, {@__struct__, @enforce_keys}, fn {key, val}, {map, keys} ->
-                      {Map.replace!(map, key, val), List.delete(keys, key)}
-                    end)
-
-                  case keys do
-                    [] ->
-                      map
-
-                    _ ->
-                      raise ArgumentError,
-                            "the following keys must also be given when building " <>
-                              "struct #{inspect(__MODULE__)}: #{inspect(keys)}"
-                  end
-                end
-            end
-          end
-
-        false ->
-          quote do
-            _ = @enforce_keys
-
-            def __struct__(kv) do
-              :lists.foldl(fn {key, val}, acc -> Map.replace!(acc, key, val) end, @__struct__, kv)
-            end
-          end
-      end
-
-    quote do
-      if Module.has_attribute?(__MODULE__, :__struct__) do
-        raise ArgumentError,
-              "defstruct has already been called for " <>
-                "#{Kernel.inspect(__MODULE__)}, defstruct can only be called once per module"
-      end
-
-      {struct, keys, derive} = Kernel.Utils.defstruct(__MODULE__, unquote(fields))
+    quote bind_quoted: [fields: fields, bootstrapped?: bootstrapped?(Enum)] do
+      {struct, keys, derive, body} = Kernel.Utils.defstruct(__MODULE__, fields, bootstrapped?)
       @__struct__ struct
       @enforce_keys keys
 
@@ -5235,11 +5187,9 @@ defmodule Kernel do
         _ -> Protocol.__derive__(derive, __MODULE__, __ENV__)
       end
 
-      def __struct__() do
-        @__struct__
-      end
+      def __struct__(), do: @__struct__
+      def __struct__(var!(kv)), do: unquote(body)
 
-      unquote(builder)
       Kernel.Utils.announce_struct(__MODULE__)
       struct
     end

lib/elixir/lib/kernel/utils.ex

@@ -100,7 +100,13 @@ defmodule Kernel.Utils do
   @doc """
   Callback for defstruct.
   """
-  def defstruct(module, fields) do
+  def defstruct(module, fields, bootstrapped?) do
+    if Module.has_attribute?(module, :__struct__) do
+      raise ArgumentError,
+            "defstruct has already been called for " <>
+              "#{Kernel.inspect(module)}, defstruct can only be called once per module"
+    end
+
     case fields do
       fs when is_list(fs) ->
         :ok
@@ -142,12 +148,54 @@ defmodule Kernel.Utils do
     end
 
     :lists.foreach(foreach, enforce_keys)
-
     struct = :maps.put(:__struct__, module, :maps.from_list(fields))
 
+    body =
+      case bootstrapped? do
+        true ->
+          case enforce_keys do
+            [] ->
+              quote do
+                Enum.reduce(var!(kv), @__struct__, fn {key, val}, map ->
+                  Map.replace!(map, key, val)
+                end)
+              end
+
+            _ ->
+              quote do
+                {map, keys} =
+                  Enum.reduce(var!(kv), {@__struct__, @enforce_keys}, fn {key, val},
+                                                                         {map, keys} ->
+                    {Map.replace!(map, key, val), List.delete(keys, key)}
+                  end)
+
+                case keys do
+                  [] ->
+                    map
+
+                  _ ->
+                    raise ArgumentError,
+                          "the following keys must also be given when building " <>
+                            "struct #{inspect(__MODULE__)}: #{inspect(keys)}"
+                end
+              end
+          end
+
+        false ->
+          quote do
+            _ = @enforce_keys
+
+            :lists.foldl(
+              fn {key, val}, acc -> Map.replace!(acc, key, val) end,
+              @__struct__,
+              var!(kv)
+            )
+          end
+      end
+
     case enforce_keys -- :maps.keys(struct) do
       [] ->
-        {struct, enforce_keys, Module.get_attribute(module, :derive)}
+        {struct, enforce_keys, Module.get_attribute(module, :derive), body}
 
       error_keys ->
         raise ArgumentError,

lib/elixir/lib/module.ex

@@ -929,6 +929,10 @@ defmodule Module do
     simplify_arg(Macro.expand_once(attr, env), counters, env)
   end
 
+  defp simplify_arg({:var!, _, [{var, _, atom} | _]}, counters, _env) when is_atom(atom) do
+    {simplify_var(var, Elixir), counters}
+  end
+
   defp simplify_arg(other, counters, _env) when is_integer(other),
     do: autogenerated_key(counters, :int)