Deprecate usage around __struct__/0

Author: josevalim

lib/elixir/lib/kernel.ex

@@ -5565,27 +5565,8 @@ defmodule Kernel do
       # it is the bootstrapped version or not.
       Elixir.Kernel.@(impl(true))
 
-      # TODO: Change the implementation on v2.0 to simply call Kernel.struct!/2
       def exception(args) when Kernel.is_list(args) do
-        struct = __struct__()
-        {valid, invalid} = Enum.split_with(args, fn {k, _} -> Map.has_key?(struct, k) end)
-
-        case invalid do
-          [] ->
-            :ok
-
-          _ ->
-            IO.warn(
-              "the following fields are unknown when raising " <>
-                "#{Kernel.inspect(__MODULE__)}: #{Kernel.inspect(invalid)}. " <>
-                "Please make sure to only give known fields when raising " <>
-                "or redefine #{Kernel.inspect(__MODULE__)}.exception/1 to " <>
-                "discard unknown fields. Future Elixir versions will raise on " <>
-                "unknown fields given to raise/2"
-            )
-        end
-
-        Kernel.struct!(struct, valid)
+        struct!(__MODULE__, args)
       end
 
       defoverridable exception: 1

lib/elixir/lib/map.ex

@@ -1011,25 +1011,22 @@ defmodule Map do
   @doc """
   Converts a `struct` to map.
 
-  It accepts the struct module or a struct itself and
-  simply removes the `__struct__` field from the given struct
-  or from a new struct generated from the given module.
+  It accepts a struct and simply removes the `__struct__` field
+  from the given struct.
 
   ## Example
 
       defmodule User do
         defstruct [:name]
       end
 
-      Map.from_struct(User)
-      #=> %{name: nil}
-
       Map.from_struct(%User{name: "john"})
       #=> %{name: "john"}
 
   """
   @spec from_struct(atom | struct) :: map
   def from_struct(struct) when is_atom(struct) do
+    IO.warn("Map.from_struct/1 with a module is deprecated, please pass a struct instead")
     delete(struct.__struct__(), :__struct__)
   end
 

lib/ex_unit/lib/ex_unit/diff.ex

@@ -702,15 +702,13 @@ defmodule ExUnit.Diff do
   # Structs
 
   defp diff_quoted_struct(kw, right, env) do
-    struct1 = kw[:__struct__]
-    left = load_struct(kw[:__struct__])
-
-    if left && Enum.all?(kw, fn {k, _} -> Map.has_key?(left, k) end) do
+    if struct = struct_module(kw) do
       with true <- Macro.quoted_literal?(kw),
-           {eval_kw, []} <- safe_eval(kw) do
-        diff_quoted_struct(struct!(left, eval_kw), kw, right, struct1, env)
+           {eval_kw, []} <- safe_eval(kw),
+           {:ok, data} <- load_struct(struct, eval_kw) do
+        diff_quoted_struct(data, kw, right, struct, env)
       else
-        _ -> diff_map(kw, right, struct1, maybe_struct(right), env)
+        _ -> diff_map(kw, right, struct, maybe_struct(right), env)
       end
     else
       diff_map(kw, right, nil, maybe_struct(right), env)
@@ -746,13 +744,25 @@ defmodule ExUnit.Diff do
     end
   end
 
-  defp load_struct(struct) do
-    if is_atom(struct) and struct != nil and
-         Code.ensure_loaded?(struct) and function_exported?(struct, :__struct__, 0) do
-      struct.__struct__()
+  defp struct_module(kw) do
+    {struct, struct_kw} = Keyword.pop(kw, :__struct__)
+
+    info =
+      is_atom(struct) and struct != nil and
+        Code.ensure_loaded?(struct) and function_exported?(struct, :__info__, 1) and
+        struct.__info__(:struct)
+
+    if info && Enum.all?(struct_kw, fn {k, _} -> Enum.any?(info, &(&1.field == k)) end) do
+      struct
     end
   end
 
+  defp load_struct(struct, kw) do
+    {:ok, struct!(struct, kw)}
+  rescue
+    _ -> :error
+  end
+
   defp maybe_struct(%name{}), do: name
   defp maybe_struct(_), do: nil