Avoid showing duplicate traces

Author: josevalim

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

@@ -147,25 +147,30 @@ defmodule Module.Types.Helpers do
 
   defp format_trace(%{type: :variable, name: name, context: context, traces: traces}) do
     traces =
-      for trace <- traces do
+      traces
+      |> Enum.map(fn trace ->
         location =
           trace.file
           |> Path.relative_to_cwd()
           |> Exception.format_file_line(trace.meta[:line])
           |> String.replace_suffix(":", "")
 
+        {trace.formatted_type, location, trace.formatted_expr, trace.formatted_hints}
+      end)
+      |> Enum.dedup()
+      |> Enum.map(fn {formatted_type, location, formatted_expr, formatted_hints} ->
         [
           """
 
-              # type: #{indent(trace.formatted_type, 4)}
+              # type: #{indent(formatted_type, 4)}
               # from: #{location}
               \
           """,
-          indent(trace.formatted_expr, 4),
+          indent(formatted_expr, 4),
           ?\n,
-          trace.formatted_hints
+          formatted_hints
         ]
-      end
+      end)
 
     type_or_types = pluralize(traces, "type", "types")
     ["\nwhere #{format_var(name, context)} was given the #{type_or_types}:\n" | traces]

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

@@ -25,6 +25,28 @@ defmodule Module.Types.PatternTest do
       assert typecheck!([%y{}, %x{}, x = y, x = Point], y) == dynamic(atom([Point]))
     end
 
+    test "repeated refinements are ignored on reporting" do
+      assert typeerror!([{name, arity}, arity = 123], hd(Atom.to_charlist(name))) == ~l"""
+             incompatible types given to Kernel.hd/1:
+
+                 hd(Atom.to_charlist(name))
+
+             expected types:
+
+                 non_empty_list(term(), term())
+
+             but got types:
+
+                 empty_list() or non_empty_list(integer())
+
+             where "name" was given the type:
+
+                 # type: dynamic()
+                 # from: types_test.ex
+                 {name, arity}
+             """
+    end
+
     test "errors on conflicting refinements" do
       assert typeerror!([a = b, a = :foo, b = :bar], {a, b}) ==
                ~l"""
@@ -35,13 +57,13 @@ defmodule Module.Types.PatternTest do
                where "a" was given the type:
 
                    # type: dynamic(:foo)
-                   # from: types_test.ex:29
+                   # from: types_test.ex:LINE-1
                    a = :foo
 
                where "b" was given the type:
 
                    # type: dynamic(:bar)
-                   # from: types_test.ex:29
+                   # from: types_test.ex:LINE-1
                    b = :bar
                """
     end