Remove struct comparison specific warning

Now that we have added inference, there are too many false
positives. However, note we still have a disjoint check warning,
which will still warn about several cases of structs.

Closes #13227.
Closes #14359.

Author: josevalim

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

@@ -433,10 +433,6 @@ defmodule Module.Types.Apply do
       not check? ->
         {:ok, result}
 
-      match?({false, _}, map_fetch(left, :__struct__)) or
-          match?({false, _}, map_fetch(right, :__struct__)) ->
-        {:error, :struct_comparison}
-
       number_type?(left) and number_type?(right) ->
         {:ok, result}
 
@@ -983,35 +979,6 @@ 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,39 +1067,6 @@ 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 = :foo, y = %Point{}, mod = Kernel], mod.<=(x, y)) ==
-               ~l"""
-               comparison with structs found:
-
-                   mod.<=(x, y)
-
-               given types:
-
-                   dynamic(:foo) <= 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(:foo)
-                   # from: types_test.ex:LINE-1
-                   x = :foo
-
-               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.
-               """
-    end
   end
 
   describe ":erlang rewrites" do