Include a hint for defimpl type checking

Author: josevalim

lib/elixir/lib/module/types.ex

@@ -49,8 +49,8 @@ defmodule Module.Types do
     finder =
       fn fun_arity ->
         case :lists.keyfind(fun_arity, 1, defs) do
-          {_, kind, _, _} = clause ->
-            {infer_mode(kind, infer_signatures?), clause, default_domain(fun_arity, impl)}
+          {_, kind, _, _} = def ->
+            default_domain(infer_mode(kind, infer_signatures?), def, fun_arity, impl)
 
           false ->
             false
@@ -82,7 +82,7 @@ defmodule Module.Types do
         {types, context} ->
           # Optimized version of finder, since we already the definition
           finder = fn _ ->
-            {infer_mode(kind, infer_signatures?), def, default_domain(fun_arity, impl)}
+            default_domain(infer_mode(kind, infer_signatures?), def, fun_arity, impl)
           end
 
           {_kind, inferred, context} = local_handler(meta, fun_arity, stack, context, finder)
@@ -146,12 +146,24 @@ defmodule Module.Types do
     end
   end
 
-  defp default_domain({_, arity} = fun_arity, impl) do
+  defp default_domain(mode, def, {_, arity} = fun_arity, impl) do
     with {for, callbacks} <- impl,
          true <- fun_arity in callbacks do
-      [Descr.dynamic(Module.Types.Of.impl(for)) | List.duplicate(Descr.dynamic(), arity - 1)]
+      args = [
+        Descr.dynamic(Module.Types.Of.impl(for))
+        | List.duplicate(Descr.dynamic(), arity - 1)
+      ]
+
+      {fun_arity, kind, meta, clauses} = def
+
+      clauses =
+        for {meta, args, guards, body} <- clauses do
+          {[type_check: {:impl, for}] ++ meta, args, guards, body}
+        end
+
+      {mode, {fun_arity, kind, meta, clauses}, args}
     else
-      _ -> List.duplicate(Descr.dynamic(), arity)
+      _ -> {mode, def, List.duplicate(Descr.dynamic(), arity)}
     end
   end
 
@@ -208,7 +220,7 @@ defmodule Module.Types do
 
     finder = fn fun_arity ->
       case :lists.keyfind(fun_arity, 1, defs) do
-        {_, _, _, _} = clause -> {:dynamic, clause, default_domain(fun_arity, impl)}
+        {_, _, _, _} = def -> default_domain(:dynamic, def, fun_arity, impl)
         false -> false
       end
     end
@@ -219,7 +231,7 @@ defmodule Module.Types do
     context =
       Enum.reduce(defs, context(), fn {fun_arity, _kind, meta, _clauses} = def, context ->
         # Optimized version of finder, since we already the definition
-        finder = fn _ -> {:dynamic, def, default_domain(fun_arity, impl)} end
+        finder = fn _ -> default_domain(:dynamic, def, fun_arity, impl) end
         {_kind, _inferred, context} = local_handler(meta, fun_arity, stack, context, finder)
         context
       end)

lib/elixir/lib/module/types/helpers.ex

@@ -132,6 +132,20 @@ defmodule Module.Types.Helpers do
         the union (which may be none)
         """
 
+      {:impl, for} ->
+        # Get the type without dynamic for better pretty printing
+        type =
+          for
+          |> Module.Types.Of.impl()
+          |> Module.Types.Descr.dynamic()
+          |> Map.fetch!(:dynamic)
+          |> Module.Types.Descr.to_quoted_string(collapse_structs: true)
+
+        """
+
+        #{hint()} defimpl for #{inspect(for)} requires its callbacks to match exclusively on #{type}
+        """
+
       :empty_domain ->
         """
 

lib/elixir/lib/module/types/pattern.ex

@@ -259,12 +259,12 @@ defmodule Module.Types.Pattern do
   defp badpattern_error(expr, index, tag, stack, context) do
     meta =
       if meta = get_meta(expr) do
-        meta ++ Keyword.take(stack.meta, [:generated, :line])
+        meta ++ Keyword.take(stack.meta, [:generated, :line, :type_check])
       else
         stack.meta
       end
 
-    error(__MODULE__, {:badpattern, expr, index, tag, context}, meta, stack, context)
+    error(__MODULE__, {:badpattern, meta, expr, index, tag, context}, meta, stack, context)
   end
 
   defp of_pattern_intersect(tree, expected, expr, index, tag, stack, context) do
@@ -802,13 +802,19 @@ defmodule Module.Types.Pattern do
   #
   # The match pattern ones have the whole expression instead
   # of a single pattern.
-  def format_diagnostic({:badpattern, pattern_or_expr, index, tag, context}) do
+  def format_diagnostic({:badpattern, meta, pattern_or_expr, index, tag, context}) do
     {to_trace, message} = badpattern(tag, pattern_or_expr, index)
     traces = collect_traces(to_trace, context)
 
+    hints =
+      case Keyword.get(meta, :type_check) do
+        {:impl, _} = impl -> [impl]
+        _ -> []
+      end
+
     %{
       details: %{typing_traces: traces},
-      message: IO.iodata_to_binary([message, format_traces(traces)])
+      message: IO.iodata_to_binary([message, format_traces(traces), format_hints(hints)])
     }
   end
 

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

@@ -408,6 +408,8 @@ defmodule Module.Types.IntegrationTest do
 
                 dynamic(%Range{})
 
+            hint: defimpl for Range requires its callbacks to match exclusively on %Range{}
+
             typing violation found at:
             │
           6 │   def itself(nil), do: nil