Emit struct comparison warning only if the intersection has structs

This avoids the false negatives while still emitting
the warning when trying to compare two datetimes or similar.

Author: josevalim

lib/elixir/lib/module/types/apply.ex

@@ -436,11 +436,14 @@ defmodule Module.Types.Apply do
       number_type?(left) and number_type?(right) ->
         {:ok, result}
 
-      disjoint?(left, right) ->
-        {:error, :mismatched_comparison}
-
       true ->
-        {:ok, result}
+        common = intersection(left, right)
+
+        cond do
+          empty?(common) -> {:error, :mismatched_comparison}
+          match?({false, _}, map_fetch(common, :__struct__)) -> {:error, :struct_comparison}
+          true -> {:ok, result}
+        end
     end
   end
 
@@ -979,6 +982,35 @@ defmodule Module.Types.Apply do
     }
   end
 
+  def format_diagnostic({:struct_comparison, [left, right], mfac, expr, context}) do
+    {_, name, _, _} = mfac
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          comparison with structs found:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          given types:
+
+              #{type_comparison_to_string(name, left, right) |> indent(4)}
+          """,
+          format_traces(traces),
+          """
+
+          Comparison operators (>, <, >=, <=, min, and max) perform structural \
+          and not semantic comparison. Comparing with a struct won't give meaningful \
+          results. Structs that can be compared typically define a compare/2 function \
+          within their modules that can be used for semantic comparison.
+          """
+        ])
+    }
+  end
+
   def format_diagnostic({:undefined, :badmodule, module, fun, arity}) do
     top =
       if fun == :__struct__ and arity == 0 do

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

@@ -1067,6 +1067,55 @@ defmodule Module.Types.ExprTest do
                which are always disjoint, and the result is either always true or always false
                """
     end
+
+    test "warns on comparison with struct across dynamic call" do
+      assert typeerror!([x = %Point{}, y = %Point{}, mod = Kernel], mod.<=(x, y)) ==
+               ~l"""
+               comparison with structs found:
+
+                   mod.<=(x, y)
+
+               given types:
+
+                   dynamic(%Point{}) <= dynamic(%Point{})
+
+               where "mod" was given the type:
+
+                   # type: dynamic(Kernel)
+                   # from: types_test.ex:LINE-1
+                   mod = Kernel
+
+               where "x" was given the type:
+
+                   # type: dynamic(%Point{})
+                   # from: types_test.ex:LINE-1
+                   x = %Point{}
+
+               where "y" was given the type:
+
+                   # type: dynamic(%Point{})
+                   # from: types_test.ex:LINE-1
+                   y = %Point{}
+
+               Comparison operators (>, <, >=, <=, min, and max) perform structural and not semantic comparison. Comparing with a struct won't give meaningful results. Structs that can be compared typically define a compare/2 function within their modules that can be used for semantic comparison.
+               """
+
+      assert typeerror!(
+               [x = %Point{}, mod = Kernel, condition],
+               (
+                 y = if condition, do: 123, else: %Point{}
+                 mod.<=(x, y)
+               )
+             ) =~ "comparison with structs found:"
+
+      assert typecheck!(
+               [x = 456, mod = Kernel, condition],
+               (
+                 y = if condition, do: 123, else: %Point{}
+                 mod.<=(x, y)
+               )
+             ) == boolean()
+    end
   end
 
   describe ":erlang rewrites" do