Print negations whenever most of the descr types are either top or negated

Author: josevalim

lib/elixir/lib/integer.ex

@@ -18,6 +18,45 @@ defmodule Integer do
 
   import Bitwise
 
+  @doc """
+  Counts the number of set bits (1) in the binary representation of a non-negative `integer`.
+
+  This operation is known as the Hamming weight or population count.
+
+  Raises an `ArithmeticError` if `integer` is negative.
+
+  ## Examples
+
+      iex> Integer.popcount(0)
+      0
+
+      iex> Integer.popcount(1)
+      1
+
+      iex> Integer.popcount(0b10110101)
+      5
+
+      iex> Integer.popcount(255)
+      8
+
+      iex> Integer.popcount(0b1111111111111111)
+      16
+
+      iex> Integer.popcount(-1)
+      ** (ArithmeticError) bad argument in arithmetic expression
+
+  """
+  @doc since: "1.20.0"
+  @spec popcount(non_neg_integer) :: non_neg_integer
+  def popcount(integer) when is_integer(integer) and integer < 0,
+    do: :erlang.error(:badarith, [integer])
+
+  def popcount(integer) when is_integer(integer),
+    do: popcount(integer, 0)
+
+  defp popcount(0, acc), do: acc
+  defp popcount(n, acc), do: popcount(n &&& n - 1, acc + 1)
+
   @doc """
   Determines if `integer` is odd.
 

lib/elixir/lib/module/types/descr.ex

@@ -721,18 +721,42 @@ defmodule Module.Types.Descr do
           {:term, static, []}
 
         {dynamic, static} ->
-          # Computing term_type?(difference(dynamic, static)) can be
-          # expensive, so we check for term type before hand and check
-          # for :term exclusively in dynamic_to_quoted/2.
-          if term_type?(dynamic) do
-            {:term, static, []}
-          else
-            # Denormalize functions before we do the difference
-            {static, dynamic, extra} = fun_denormalize(static, dynamic, opts)
-            {difference(dynamic, static), static, extra}
+          cond do
+            # Computing term_type?(difference(dynamic, static)) can be
+            # expensive, so we check for term type before hand and check
+            # for :term exclusively in dynamic_to_quoted/2.
+            term_type?(dynamic) ->
+              {:term, static, []}
+
+            # We need to check for quoted here before we compute the difference below
+            quoted = maybe_negated_term_type_to_quoted(static, opts) ->
+              {dynamic, %{}, [quoted]}
+
+            # Denormalize functions (only unions) before we do the difference
+            true ->
+              {static, dynamic, extra} = fun_denormalize(static, dynamic, opts)
+              {difference(dynamic, static), static, extra}
           end
       end
 
+    {static, extra} =
+      if quoted = maybe_negated_term_type_to_quoted(static, opts) do
+        {%{}, [quoted | extra]}
+      else
+        {static, extra}
+      end
+
+    # Dynamic always come first for visibility
+    unions =
+      to_quoted(:dynamic, dynamic, opts) ++ static_non_term_type_to_quoted(static, extra, opts)
+
+    case unions do
+      [] -> {:none, [], []}
+      unions -> Enum.reduce(unions, &{:or, [], [&2, &1]})
+    end
+  end
+
+  defp static_non_term_type_to_quoted(static, extra, opts) do
     # Merge empty list and list together if they both exist
     {extra, static} =
       case static do
@@ -748,17 +772,7 @@ defmodule Module.Types.Descr do
           {extra, static}
       end
 
-    # Dynamic always come first for visibility
-    unions =
-      to_quoted(:dynamic, dynamic, opts) ++
-        Enum.sort(
-          extra ++ Enum.flat_map(static, fn {key, value} -> to_quoted(key, value, opts) end)
-        )
-
-    case unions do
-      [] -> {:none, [], []}
-      unions -> Enum.reduce(unions, &{:or, [], [&2, &1]})
-    end
+    Enum.sort(extra ++ Enum.flat_map(static, fn {key, value} -> to_quoted(key, value, opts) end))
   end
 
   defp to_quoted(:atom, val, _opts), do: atom_to_quoted(val)
@@ -769,6 +783,54 @@ defmodule Module.Types.Descr do
   defp to_quoted(:tuple, bdd, opts), do: tuple_to_quoted(bdd, opts)
   defp to_quoted(:fun, bdd, opts), do: fun_to_quoted(bdd, opts)
 
+  defp maybe_negated_term_type_to_quoted(static, opts) do
+    if print_as_negated_type?(static) do
+      static
+      |> negation()
+      |> unfold()
+      |> static_non_term_type_to_quoted([], opts)
+      |> case do
+        [] ->
+          nil
+
+        [head | tail] ->
+          Enum.reduce(tail, {:not, [], [head]}, &{:and, [], [&2, {:not, [], [&1]}]})
+      end
+    end
+  end
+
+  # Unions would be printed as negations within negations
+  defp print_as_negated_type?(%{atom: {:union, _}}), do: false
+  defp print_as_negated_type?(%{fun: {:union, _}}), do: false
+
+  defp print_as_negated_type?(descr) do
+    # In here we compute the score of negations.
+    # If we have more than 6, we print it as a negated type.
+    result =
+      Enum.sum_by(Map.to_list(descr), fn
+        {:tuple, bdd} -> print_as_negated_bdd(bdd, @tuple_top)
+        {:map, bdd} -> print_as_negated_bdd(bdd, @map_top)
+        {:list, bdd} -> print_as_negated_bdd(bdd, @non_empty_list_top)
+        {:bitmap, bitmap} -> Integer.popcount(bitmap)
+        {:atom, {:union, _}} -> -100
+        {:fun, {:union, _}} -> -100
+        {_, _} -> 1
+      end)
+
+    result > 8
+  end
+
+  # A bdd leaf can be trivially printed in negated format
+  # but we don't count it towards the amount of negatives.
+  defp print_as_negated_bdd(top, top), do: 1
+  defp print_as_negated_bdd(bdd_leaf(_, _), _top), do: 0
+  defp print_as_negated_bdd(bdd, top), do: if(negated_bdd?(bdd, top), do: 1, else: -100)
+
+  defp negated_bdd?({_, :bdd_bot, :bdd_bot, bdd}, top),
+    do: bdd in [:bdd_top, top] or negated_bdd?(bdd, top)
+
+  defp negated_bdd?(_, _), do: false
+
   @doc """
   Converts a descr to its quoted string representation.
 
@@ -1738,7 +1800,7 @@ defmodule Module.Types.Descr do
   end
 
   # Converts the static and dynamic parts of descr to its quoted
-  # representation. The goal here is to the opposite of fun_descr
+  # representation. The goal here is to do the opposite of fun_descr
   # and put static and dynamic parts back together to improve
   # pretty printing.
   defp fun_denormalize(%{fun: {:union, static_repr}}, %{fun: {:union, dynamic_repr}}, opts) do
@@ -2173,6 +2235,12 @@ defmodule Module.Types.Descr do
     end
   end
 
+  defp list_difference(bdd_leaf(:term, :term), bdd_leaf(:term, :term)),
+    do: :bdd_bot
+
+  defp list_difference(bdd_leaf(:term, :term), bdd2),
+    do: bdd_negation(bdd2)
+
   # Computes the difference between two BDD (Binary Decision Diagram) list types.
   # It progressively subtracts each type in bdd2 from all types in bdd1.
   # The algorithm handles three cases:
@@ -2183,22 +2251,20 @@ defmodule Module.Types.Descr do
   # 3. Base case: adds bdd2 type to negations of bdd1 type
   # The result may be larger than the initial bdd1, which is maintained in the accumulator.
   defp list_difference(bdd_leaf(list1, last1) = bdd1, bdd_leaf(list2, last2) = bdd2) do
-    cond do
-      disjoint?(list1, list2) or disjoint?(last1, last2) ->
-        bdd_leaf(list1, last1)
-
-      subtype?(list1, list2) ->
-        if subtype?(last1, last2),
-          do: :bdd_bot,
-          else: bdd_leaf(list1, difference(last1, last2))
-
-      true ->
-        bdd_difference(bdd1, bdd2)
+    if subtype?(list1, list2) do
+      if subtype?(last1, last2),
+        do: :bdd_bot,
+        else: bdd_leaf(list1, difference(last1, last2))
+    else
+      bdd_difference(bdd1, bdd2, &list_leaf_disjoint?/2)
     end
   end
 
   defp list_difference(bdd1, bdd2),
-    do: bdd_difference(bdd1, bdd2)
+    do: bdd_difference(bdd1, bdd2, &list_leaf_disjoint?/2)
+
+  defp list_leaf_disjoint?(bdd_leaf(list1, last1), bdd_leaf(list2, last2)),
+    do: disjoint?(list1, list2) or disjoint?(last1, last2)
 
   defp list_empty?(@non_empty_list_top), do: false
 

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

@@ -2602,6 +2602,11 @@ defmodule Module.Types.DescrTest do
   end
 
   describe "to_quoted" do
+    test "none" do
+      assert none() |> to_quoted_string() == "none()"
+      assert dynamic(none()) |> to_quoted_string() == "none()"
+    end
+
     test "bitmap" do
       assert union(pid(), bitstring()) |> to_quoted_string() ==
                "bitstring() or pid()"
@@ -2613,15 +2618,15 @@ defmodule Module.Types.DescrTest do
                "(bitstring() and not binary()) or integer()"
     end
 
-    test "none" do
-      assert none() |> to_quoted_string() == "none()"
-      assert dynamic(none()) |> to_quoted_string() == "none()"
-    end
+    test "bitmap (negation)" do
+      assert union(pid(), bitstring()) |> negation() |> to_quoted_string() ==
+               "not bitstring() and not pid()"
 
-    test "negation" do
-      assert negation(negation(integer())) |> to_quoted_string() == "integer()"
-      assert negation(negation(atom([:foo, :bar]))) |> to_quoted_string() == ":bar or :foo"
-      assert negation(negation(list(term()))) |> to_quoted_string() == "list(term())"
+      assert difference(bitstring(), binary())
+             |> union(integer())
+             |> negation()
+             |> to_quoted_string() ==
+               "not (bitstring() and not binary()) and not integer()"
     end
 
     test "atom" do
@@ -2641,6 +2646,15 @@ defmodule Module.Types.DescrTest do
       assert difference(atom(), boolean()) |> to_quoted_string() == "atom() and not boolean()"
     end
 
+    test "atom/boolean (negation)" do
+      assert atom() |> negation() |> to_quoted_string() == "not atom()"
+      assert atom([:a, :b]) |> negation() |> to_quoted_string() == "not :a and not :b"
+      assert boolean() |> negation() |> to_quoted_string() == "not boolean()"
+
+      assert atom([true, false, :a]) |> negation() |> to_quoted_string() ==
+               "not :a and not boolean()"
+    end
+
     test "dynamic" do
       assert dynamic() |> to_quoted_string() == "dynamic()"
 
@@ -2668,7 +2682,21 @@ defmodule Module.Types.DescrTest do
                "dynamic(%{a: integer()})"
     end
 
-    test "lists" do
+    test "dynamic (negation)" do
+      assert dynamic(negation(integer())) |> to_quoted_string() == "dynamic(not integer())"
+      assert negation(dynamic(integer())) |> to_quoted_string() == "dynamic() or not integer()"
+
+      assert union(atom(), dynamic(integer())) |> negation() |> to_quoted_string() ==
+               "dynamic(not atom()) or (not atom() and not integer())"
+
+      assert dynamic(union(atom(), integer()))
+             |> negation()
+             |> union(integer())
+             |> to_quoted_string() ==
+               "dynamic() or not atom()"
+    end
+
+    test "list" do
       assert list(term()) |> to_quoted_string() == "list(term())"
       assert list(integer()) |> to_quoted_string() == "list(integer())"
 
@@ -2720,7 +2748,18 @@ defmodule Module.Types.DescrTest do
       assert to_quoted_string(list_with_tail) == "non_empty_list(atom())"
     end
 
-    test "tuples" do
+    test "list (negation)" do
+      assert list(term()) |> negation() |> to_quoted_string() == "not list(term())"
+      assert list(negation(integer())) |> to_quoted_string() == "list(not integer())"
+
+      assert list(term()) |> difference(empty_list()) |> negation() |> to_quoted_string() ==
+               "not non_empty_list(term())"
+
+      assert non_empty_list(integer(), integer()) |> negation() |> to_quoted_string() ==
+               "not non_empty_list(integer(), integer())"
+    end
+
+    test "tuple" do
       assert tuple([integer(), atom()]) |> to_quoted_string() == "{integer(), atom()}"
 
       assert tuple([integer(), dynamic(atom())]) |> to_quoted_string() ==
@@ -2832,7 +2871,12 @@ defmodule Module.Types.DescrTest do
                """
     end
 
-    test "function" do
+    test "tuple (negation)" do
+      assert tuple([integer()]) |> negation() |> to_quoted_string() == "not {integer()}"
+      assert tuple([negation(integer())]) |> to_quoted_string() == "{not integer()}"
+    end
+
+    test "fun" do
       assert fun() |> to_quoted_string() == "fun()"
       assert none_fun(1) |> to_quoted_string() == "(none() -> term())"
 
@@ -2868,7 +2912,7 @@ defmodule Module.Types.DescrTest do
                "fun() and not (none(), none(), none() -> term())"
     end
 
-    test "function with optimized intersections" do
+    test "fun with optimized intersections" do
       assert fun([integer()], atom()) |> intersection(none_fun(1)) |> to_quoted_string() ==
                "(integer() -> atom())"
 
@@ -2879,7 +2923,7 @@ defmodule Module.Types.DescrTest do
                "(integer() -> atom())"
     end
 
-    test "function with dynamic signatures" do
+    test "fun with dynamic signatures" do
       assert fun([dynamic(integer())], float()) |> to_quoted_string() ==
                "(dynamic(integer()) -> float())"
 
@@ -2912,6 +2956,11 @@ defmodule Module.Types.DescrTest do
                """
     end
 
+    test "fun (negation)" do
+      assert fun([integer()], atom()) |> negation() |> to_quoted_string() ==
+               "not (integer() -> atom())"
+    end
+
     test "map as records" do
       assert empty_map() |> to_quoted_string() == "empty_map()"
       assert open_map() |> to_quoted_string() == "map()"
@@ -3035,14 +3084,28 @@ defmodule Module.Types.DescrTest do
              |> to_quoted_string() == "%{..., a: float(), b: atom(), c: port()}"
     end
 
-    test "maps as dictionaries" do
+    test "map as dictionaries" do
       assert closed_map([{domain_key(:integer), integer()}])
              |> to_quoted_string() == "%{integer() => integer()}"
 
       assert closed_map([{domain_key(:integer), not_set()}, {:float, float()}])
              |> to_quoted_string() == "%{integer() => not_set(), float: float()}"
     end
 
+    test "map (negation)" do
+      assert open_map(a: integer()) |> negation() |> to_quoted_string() ==
+               "not %{..., a: integer()}"
+
+      assert open_map(a: negation(integer())) |> to_quoted_string() ==
+               "%{..., a: not integer()}"
+
+      assert closed_map(a: integer()) |> negation() |> to_quoted_string() ==
+               "not %{a: integer()}"
+
+      assert closed_map(a: negation(integer())) |> to_quoted_string() ==
+               "%{a: not integer()}"
+    end
+
     test "structs" do
       assert open_map(__struct__: term()) |> to_quoted_string() ==
                "%{..., __struct__: term()}"