Add required field back to struct info

Closes elixir-lang#14616.
Closes elixir-lang#14617.
Closes elixir-lang#14500.

Author: josevalim

lib/elixir/lib/kernel/utils.ex

@@ -217,7 +217,7 @@ defmodule Kernel.Utils do
     case enforce_keys -- :maps.keys(struct) do
       [] ->
         mapper = fn {key, val} ->
-          %{field: key, default: val}
+          %{field: key, default: val, required: :lists.member(key, enforce_keys)}
         end
 
         :ets.insert(set, {{:elixir, :struct}, :lists.map(mapper, fields)})

lib/elixir/lib/macro.ex

@@ -861,21 +861,39 @@ defmodule Macro do
   end
 
   @doc """
-  Extracts the struct information (equivalent to calling
-  `module.__info__(:struct)`).
+  Extracts the struct information.
 
   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.
+  not have been compiled (including structs in the defined
+  under the module being compiled). For compiled modules,
+  it will invoke `module.__info__(:struct)`.
+
   Calling this function also adds an export dependency on the
   given struct.
 
   It will raise `ArgumentError` if the struct is not available.
+
+  ## Compatibility considerations
+
+  This function currently returns both `:required` and `:default`
+  entries for each field. While this naming is inconsistent
+  (a required field should not have a default), this is done for
+  backwards compatibility purposes.
+
+  In future releases, Elixir may introduce truly required struct
+  fields, and therefore only one of required or default will be
+  present. Your code should prepare for such scenario accordingly.
   """
   @doc since: "1.18.0"
   @spec struct_info!(module(), Macro.Env.t()) ::
-          [%{field: atom(), required: boolean(), default: term()}]
+          [
+            %{
+              required(:field) => atom(),
+              optional(:required) => boolean(),
+              optional(:default) => term()
+            }
+          ]
   def struct_info!(module, env) when is_atom(module) do
     case :elixir_map.maybe_load_struct_info([line: env.line], module, [], true, env) do
       {:ok, info} -> info

lib/elixir/lib/module.ex

@@ -681,7 +681,6 @@ defmodule Module do
   This function is generated for all modules. It's similar to `module_info/1` but
   includes some additional Elixir-specific information, such as struct and macro
   information. For documentation, see `c:Module.__info__/1`.
-
   '''
 
   @type definition :: {atom, arity}
@@ -721,7 +720,8 @@ defmodule Module do
 
     * `:module` - the module atom name
 
-    * `:struct` - (since v1.14.0) if the module defines a struct and if so each field in order
+    * `:struct` - (since v1.14.0) if the module defines a struct and if so each field in order.
+      See `Macro.struct_info!/2` for more information
 
   """
   @callback __info__(:attributes) :: keyword()
@@ -731,7 +731,14 @@ defmodule Module do
   @callback __info__(:md5) :: binary()
   @callback __info__(:module) :: module()
   @callback __info__(:struct) ::
-              list(%{required(:field) => atom(), optional(:default) => term()}) | nil
+              [
+                %{
+                  required(:field) => atom(),
+                  optional(:required) => boolean(),
+                  optional(:default) => term()
+                }
+              ]
+              | nil
 
   @doc """
   Returns information about module attributes used by Elixir.

lib/elixir/test/elixir/macro_test.exs

@@ -1645,31 +1645,32 @@ defmodule MacroTest do
 
   test "struct_info!/2 expands structs multiple levels deep" do
     defmodule StructBang do
+      @enforce_keys [:b]
       defstruct [:a, :b]
 
       assert Macro.struct_info!(StructBang, __ENV__) == [
-               %{field: :a, default: nil},
-               %{field: :b, default: nil}
+               %{field: :a, default: nil, required: false},
+               %{field: :b, default: nil, required: true}
              ]
 
       def within_function do
         assert Macro.struct_info!(StructBang, __ENV__) == [
-                 %{field: :a, default: nil},
-                 %{field: :b, default: nil}
+                 %{field: :a, default: nil, required: false},
+                 %{field: :b, default: nil, required: true}
                ]
       end
 
       defmodule Nested do
         assert Macro.struct_info!(StructBang, __ENV__) == [
-                 %{field: :a, default: nil},
-                 %{field: :b, default: nil}
+                 %{field: :a, default: nil, required: false},
+                 %{field: :b, default: nil, required: true}
                ]
       end
     end
 
     assert Macro.struct_info!(StructBang, __ENV__) == [
-             %{field: :a, default: nil},
-             %{field: :b, default: nil}
+             %{field: :a, default: nil, required: false},
+             %{field: :b, default: nil, required: true}
            ]
   end
 

lib/elixir/test/elixir/map_test.exs

@@ -401,7 +401,7 @@ defmodule MapTest do
     end
 
     info = Macro.struct_info!(WithBitstring, __ENV__)
-    assert info == [%{default: <<255, 127::7>>, field: :bitstring}]
+    assert info == [%{default: <<255, 127::7>>, field: :bitstring, required: false}]
   end
 
   test "defstruct can only be used once in a module" do