Remove boolean and number as builtin types (#10329)

Author: josevalim

lib/elixir/lib/module/types.ex

@@ -518,8 +518,8 @@ defmodule Module.Types do
   defp map_type?(_other), do: false
 
   defp atom_type?(:atom), do: true
-  defp atom_type?(:boolean), do: true
   defp atom_type?({:atom, _}), do: false
+  defp atom_type?({:union, union}), do: Enum.all?(union, &atom_type?/1)
   defp atom_type?(_other), do: false
 
   defp integer_type?(:integer), do: true

lib/elixir/lib/module/types/of.ex

@@ -173,7 +173,7 @@ defmodule Module.Types.Of do
     fun.(other)
   end
 
-  defp binary_type(:expr, {:float, _, _}), do: :number
+  defp binary_type(:expr, {:float, _, _}), do: {:union, [:integer, :float]}
   defp binary_type(:expr, {:utf8, _, _}), do: {:union, [:integer, :binary]}
   defp binary_type(:expr, {:utf16, _, _}), do: {:union, [:integer, :binary]}
   defp binary_type(:expr, {:utf32, _, _}), do: {:union, [:integer, :binary]}

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

@@ -217,43 +217,45 @@ defmodule Module.Types.Pattern do
   ## GUARDS
 
   # TODO: Some guards can be changed to intersection types or higher order types
+  @boolean {:union, [{:atom, true}, {:atom, false}]}
+  @number {:union, [:integer, :float]}
 
   @guard_functions %{
-    {:is_atom, 1} => {[:atom], :boolean},
-    {:is_binary, 1} => {[:binary], :boolean},
-    {:is_bitstring, 1} => {[:binary], :boolean},
-    {:is_boolean, 1} => {[:boolean], :boolean},
-    {:is_float, 1} => {[:float], :boolean},
-    {:is_function, 1} => {[:fun], :boolean},
-    {:is_function, 2} => {[:fun, :integer], :boolean},
-    {:is_integer, 1} => {[:integer], :boolean},
-    {:is_list, 1} => {[{:list, :dynamic}], :boolean},
-    {:is_map, 1} => {[{:map, [{:optional, :dynamic, :dynamic}]}], :boolean},
+    {:is_atom, 1} => {[:atom], @boolean},
+    {:is_binary, 1} => {[:binary], @boolean},
+    {:is_bitstring, 1} => {[:binary], @boolean},
+    {:is_boolean, 1} => {[@boolean], @boolean},
+    {:is_float, 1} => {[:float], @boolean},
+    {:is_function, 1} => {[:fun], @boolean},
+    {:is_function, 2} => {[:fun, :integer], @boolean},
+    {:is_integer, 1} => {[:integer], @boolean},
+    {:is_list, 1} => {[{:list, :dynamic}], @boolean},
+    {:is_map, 1} => {[{:map, [{:optional, :dynamic, :dynamic}]}], @boolean},
     {:is_map_key, 2} => {[:dynamic, {:map, [{:optional, :dynamic, :dynamic}]}], :dynamic},
-    {:is_number, 1} => {[:number], :boolean},
-    {:is_pid, 1} => {[:pid], :boolean},
-    {:is_port, 1} => {[:port], :boolean},
-    {:is_reference, 1} => {[:reference], :boolean},
-    {:is_tuple, 1} => {[:tuple], :boolean},
-    {:<, 2} => {[:dynamic, :dynamic], :boolean},
-    {:"=<", 2} => {[:dynamic, :dynamic], :boolean},
-    {:>, 2} => {[:dynamic, :dynamic], :boolean},
-    {:>=, 2} => {[:dynamic, :dynamic], :boolean},
-    {:"/=", 2} => {[:dynamic, :dynamic], :boolean},
-    {:"=/=", 2} => {[:dynamic, :dynamic], :boolean},
-    {:==, 2} => {[:dynamic, :dynamic], :boolean},
-    {:"=:=", 2} => {[:dynamic, :dynamic], :boolean},
-    {:*, 2} => {[:number, :number], :number},
-    {:+, 1} => {[:number], :number},
-    {:+, 2} => {[:number, :number], :number},
-    {:-, 1} => {[:number], :number},
-    {:-, 2} => {[:number, :number], :number},
-    {:/, 2} => {[:number, :number], :number},
-    {:abs, 1} => {[:number], :number},
-    {:ceil, 1} => {[:number], :integer},
-    {:floor, 1} => {[:number], :integer},
-    {:round, 1} => {[:number], :integer},
-    {:trunc, 1} => {[:number], :integer},
+    {:is_number, 1} => {[@number], @boolean},
+    {:is_pid, 1} => {[:pid], @boolean},
+    {:is_port, 1} => {[:port], @boolean},
+    {:is_reference, 1} => {[:reference], @boolean},
+    {:is_tuple, 1} => {[:tuple], @boolean},
+    {:<, 2} => {[:dynamic, :dynamic], @boolean},
+    {:"=<", 2} => {[:dynamic, :dynamic], @boolean},
+    {:>, 2} => {[:dynamic, :dynamic], @boolean},
+    {:>=, 2} => {[:dynamic, :dynamic], @boolean},
+    {:"/=", 2} => {[:dynamic, :dynamic], @boolean},
+    {:"=/=", 2} => {[:dynamic, :dynamic], @boolean},
+    {:==, 2} => {[:dynamic, :dynamic], @boolean},
+    {:"=:=", 2} => {[:dynamic, :dynamic], @boolean},
+    {:*, 2} => {[@number, @number], @number},
+    {:+, 1} => {[@number], @number},
+    {:+, 2} => {[@number, @number], @number},
+    {:-, 1} => {[@number], @number},
+    {:-, 2} => {[@number, @number], @number},
+    {:/, 2} => {[@number, @number], @number},
+    {:abs, 1} => {[@number], @number},
+    {:ceil, 1} => {[@number], :integer},
+    {:floor, 1} => {[@number], :integer},
+    {:round, 1} => {[@number], :integer},
+    {:trunc, 1} => {[@number], :integer},
     {:element, 2} => {[:integer, :tuple], :dynamic},
     {:hd, 1} => {[{:list, :dynamic}], :dynamic},
     {:length, 1} => {[{:list, :dynamic}], :integer},
@@ -265,7 +267,7 @@ defmodule Module.Types.Pattern do
     {:binary_part, 3} => {[:binary, :integer, :integer], :binary},
     {:bit_size, 1} => {[:binary], :integer},
     {:byte_size, 1} => {[:binary], :integer},
-    {:size, 1} => {[{:union, [:binary, :tuple]}], :boolean},
+    {:size, 1} => {[{:union, [:binary, :tuple]}], @boolean},
     {:div, 2} => {[:integer, :integer], :integer},
     {:rem, 2} => {[:integer, :integer], :integer},
     {:node, 0} => {[], :atom},
@@ -276,15 +278,15 @@ defmodule Module.Types.Pattern do
     {:bxor, 2} => {[:integer, :integer], :integer},
     {:bsl, 2} => {[:integer, :integer], :integer},
     {:bsr, 2} => {[:integer, :integer], :integer},
-    {:or, 2} => {[:boolean, :boolean], :boolean},
-    {:and, 2} => {[:boolean, :boolean], :boolean},
-    {:xor, 2} => {[:boolean, :boolean], :boolean},
-    {:not, 1} => {[:boolean], :boolean}
+    {:or, 2} => {[@boolean, @boolean], @boolean},
+    {:and, 2} => {[@boolean, @boolean], @boolean},
+    {:xor, 2} => {[@boolean, @boolean], @boolean},
+    {:not, 1} => {[@boolean], @boolean}
 
     # Following guards are matched explicitly to handle
     # type guard functions such as is_atom/1
-    # {:andalso, 2} => {[:boolean, :boolean], :boolean}
-    # {:orelse, 2} => {[:boolean, :boolean], :boolean}
+    # {:andalso, 2} => {[@boolean, @boolean], @boolean}
+    # {:orelse, 2} => {[@boolean, @boolean], @boolean}
   }
 
   @type_guards [
@@ -320,9 +322,9 @@ defmodule Module.Types.Pattern do
     with {:ok, left_type, left_context} <- of_guard(left, stack, fresh_context),
          {:ok, right_type, right_context} <- of_guard(right, stack, fresh_context),
          {:ok, context} <- merge_context_and(context, stack, left_context, right_context),
-         {:ok, _, context} <- unify(left_type, :boolean, stack, context),
-         {:ok, _, context} <- unify(right_type, :boolean, stack, context),
-         do: {:ok, :boolean, context}
+         {:ok, _, context} <- unify(left_type, @boolean, stack, context),
+         {:ok, _, context} <- unify(right_type, @boolean, stack, context),
+         do: {:ok, @boolean, context}
   end
 
   def of_guard({{:., _, [:erlang, :orelse]}, _, [left, right]} = expr, stack, context) do
@@ -332,8 +334,8 @@ defmodule Module.Types.Pattern do
     with {:ok, left_type, left_context} <- of_guard(left, stack, fresh_context),
          {:ok, _right_type, right_context} <- of_guard(right, stack, fresh_context),
          {:ok, context} <- merge_context_or(context, stack, left_context, right_context),
-         {:ok, _, context} <- unify(left_type, :boolean, stack, context),
-         do: {:ok, :boolean, context}
+         {:ok, _, context} <- unify(left_type, @boolean, stack, context),
+         do: {:ok, @boolean, context}
   end
 
   # The unary operators + and - are special cased to avoid common warnings until

lib/elixir/lib/module/types/unify.ex

@@ -21,11 +21,6 @@ defmodule Module.Types.Unify do
   #   {:union, [type]}
   #   {:map, [{:required | :optional, key_type, value_type}]}
   #
-  # TODO: Those types should be removed:
-  #
-  #   :boolean
-  #   :number
-  #
   # Once new types are added, they should be considered in:
   #
   #   * unify (all)
@@ -515,11 +510,6 @@ defmodule Module.Types.Unify do
   def subtype?(_, :dynamic, _context), do: true
   def subtype?({:atom, atom}, :atom, _context) when is_atom(atom), do: true
 
-  def subtype?({:atom, boolean}, :boolean, _context) when is_boolean(boolean), do: true
-  def subtype?(:boolean, :atom, _context), do: true
-  def subtype?(:float, :number, _context), do: true
-  def subtype?(:integer, :number, _context), do: true
-
   # Composite
 
   def subtype?({:tuple, _, _}, :tuple, _context), do: true

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

@@ -307,7 +307,8 @@ defmodule Module.Types.MapTest do
               {:map,
                [
                  {:required, {:atom, true}, {:atom, true}},
-                 {:required, :boolean, {:union, [{:atom, :bool}, {:atom, true}]}},
+                 {:required, {:union, [atom: true, atom: false]},
+                  {:union, [{:atom, :bool}, {:atom, true}]}},
                  {:required, :atom, {:union, [{:atom, :atom}, {:atom, :bool}, {:atom, true}]}}
                ]}}
 
@@ -320,7 +321,8 @@ defmodule Module.Types.MapTest do
               {:map,
                [
                  {:required, {:atom, true}, {:atom, true}},
-                 {:required, :boolean, {:union, [{:atom, :bool}, {:atom, true}]}},
+                 {:required, {:union, [atom: true, atom: false]},
+                  {:union, [{:atom, :bool}, {:atom, true}]}},
                  {:required, :atom, {:union, [{:atom, :atom}, {:atom, :bool}, {:atom, true}]}}
                ]}}
 
@@ -333,7 +335,8 @@ defmodule Module.Types.MapTest do
               {:map,
                [
                  {:required, {:atom, true}, {:atom, true}},
-                 {:required, :boolean, {:union, [{:atom, :bool}, {:atom, true}]}},
+                 {:required, {:union, [atom: true, atom: false]},
+                  {:union, [{:atom, :bool}, {:atom, true}]}},
                  {:required, :atom, {:union, [{:atom, :atom}, {:atom, :bool}, {:atom, true}]}}
                ]}}
   end

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

@@ -285,10 +285,10 @@ defmodule Module.Types.PatternTest do
                {:ok, [{:union, [:tuple, :atom]}]}
 
       assert quoted_head([x], [is_boolean(x) and is_atom(x)]) ==
-               {:ok, [:boolean]}
+               {:ok, [{:union, [atom: true, atom: false]}]}
 
       assert quoted_head([x], [is_atom(x) and is_boolean(x)]) ==
-               {:ok, [:boolean]}
+               {:ok, [{:union, [atom: true, atom: false]}]}
 
       assert quoted_head([x], [is_atom(x) > :foo]) == {:ok, [var: 0]}
 
@@ -307,7 +307,7 @@ defmodule Module.Types.PatternTest do
       assert {:error, {:unable_unify, {:tuple, :atom, _}}} =
                quoted_head([x], [is_tuple(x) and is_atom(x)])
 
-      assert {:error, {:unable_unify, {:boolean, :tuple, _}}} =
+      assert {:error, {:unable_unify, {{:union, [atom: true, atom: false]}, :tuple, _}}} =
                quoted_head([x], [is_tuple(is_atom(x))])
     end
 
@@ -322,13 +322,16 @@ defmodule Module.Types.PatternTest do
       assert {:error, {:unable_unify, {{:atom, :foo}, {:list, :dynamic}, _}}} =
                quoted_head([x], [length(:foo)])
 
-      assert {:error, {:unable_unify, {:boolean, {:list, :dynamic}, _}}} =
+      assert {:error,
+              {:unable_unify, {{:union, [atom: true, atom: false]}, {:list, :dynamic}, _}}} =
                quoted_head([x], [length(is_tuple(x))])
 
-      assert {:error, {:unable_unify, {:boolean, :tuple, _}}} =
+      assert {:error, {:unable_unify, {{:union, [atom: true, atom: false]}, :tuple, _}}} =
                quoted_head([x], [elem(is_tuple(x), 0)])
 
-      assert {:error, {:unable_unify, {:boolean, :number, _}}} =
+      assert {:error,
+              {:unable_unify,
+               {{:union, [atom: true, atom: false]}, {:union, [:integer, :float]}, _}}} =
                quoted_head([x], [elem({}, is_tuple(x))])
 
       assert quoted_head([x], [elem({}, 1)]) == {:ok, [var: 0]}
@@ -371,7 +374,11 @@ defmodule Module.Types.PatternTest do
       assert quoted_head([%{true: bool}], [is_boolean(bool)]) ==
                {:ok,
                 [
-                  {:map, [{:required, {:atom, true}, :boolean}, {:optional, :dynamic, :dynamic}]}
+                  {:map,
+                   [
+                     {:required, {:atom, true}, {:union, [atom: true, atom: false]}},
+                     {:optional, :dynamic, :dynamic}
+                   ]}
                 ]}
 
       assert quoted_head([%{true: true} = foo, %{false: false} = foo]) ==

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

@@ -53,27 +53,17 @@ defmodule Module.Types.UnifyTest do
       assert unify_lift(:integer, :integer) == {:ok, :integer}
       assert unify_lift(:binary, :binary) == {:ok, :binary}
       assert unify_lift(:atom, :atom) == {:ok, :atom}
-      assert unify_lift(:boolean, :boolean) == {:ok, :boolean}
 
-      assert {:error, {:unable_unify, {:integer, :boolean, _}}} = unify_lift(:integer, :boolean)
+      assert {:error, {:unable_unify, {:integer, :atom, _}}} = unify_lift(:integer, :atom)
     end
 
     test "subtype undirected" do
-      assert unify_lift(:boolean, :atom) == {:ok, :boolean}
-      assert unify_lift(:atom, :boolean) == {:ok, :boolean}
-      assert unify_lift(:boolean, {:atom, true}) == {:ok, {:atom, true}}
-      assert unify_lift({:atom, true}, :boolean) == {:ok, {:atom, true}}
       assert unify_lift(:atom, {:atom, true}) == {:ok, {:atom, true}}
       assert unify_lift({:atom, true}, :atom) == {:ok, {:atom, true}}
     end
 
     test "subtype directed" do
-      assert unify_directed_lift(:boolean, :atom) == {:ok, :boolean}
-      assert unify_directed_lift({:atom, true}, :boolean) == {:ok, {:atom, true}}
       assert unify_directed_lift({:atom, true}, :atom) == {:ok, {:atom, true}}
-
-      assert {:error, _} = unify_directed_lift(:atom, :boolean)
-      assert {:error, _} = unify_directed_lift(:boolean, {:atom, true})
       assert {:error, _} = unify_directed_lift(:atom, {:atom, true})
     end
 
@@ -83,8 +73,8 @@ defmodule Module.Types.UnifyTest do
       assert unify_lift({:tuple, 1, [:integer]}, {:tuple, 1, [:integer]}) ==
                {:ok, {:tuple, 1, [:integer]}}
 
-      assert unify_lift({:tuple, 1, [:boolean]}, {:tuple, 1, [:atom]}) ==
-               {:ok, {:tuple, 1, [:boolean]}}
+      assert unify_lift({:tuple, 1, [{:atom, :foo}]}, {:tuple, 1, [:atom]}) ==
+               {:ok, {:tuple, 1, [{:atom, :foo}]}}
 
       assert {:error, {:unable_unify, {{:tuple, 1, [:integer]}, {:tuple, 0, []}, _}}} =
                unify_lift({:tuple, 1, [:integer]}, {:tuple, 0, []})
@@ -134,10 +124,10 @@ defmodule Module.Types.UnifyTest do
                {:ok, {:map, [{:required, :integer, :atom}]}}
 
       assert unify_lift(
-               {:map, [{:required, {:atom, :foo}, :boolean}]},
+               {:map, [{:required, {:atom, :foo}, {:atom, :bar}}]},
                {:map, [{:required, {:atom, :foo}, :atom}]}
              ) ==
-               {:ok, {:map, [{:required, {:atom, :foo}, :boolean}]}}
+               {:ok, {:map, [{:required, {:atom, :foo}, {:atom, :bar}}]}}
 
       assert {:error,
               {:unable_unify,
@@ -166,28 +156,28 @@ defmodule Module.Types.UnifyTest do
 
     test "map required/optional key" do
       assert unify_lift(
-               {:map, [{:required, {:atom, :foo}, :boolean}]},
+               {:map, [{:required, {:atom, :foo}, {:atom, :bar}}]},
                {:map, [{:required, {:atom, :foo}, :atom}]}
              ) ==
-               {:ok, {:map, [{:required, {:atom, :foo}, :boolean}]}}
+               {:ok, {:map, [{:required, {:atom, :foo}, {:atom, :bar}}]}}
 
       assert unify_lift(
-               {:map, [{:optional, {:atom, :foo}, :boolean}]},
+               {:map, [{:optional, {:atom, :foo}, {:atom, :bar}}]},
                {:map, [{:required, {:atom, :foo}, :atom}]}
              ) ==
-               {:ok, {:map, [{:required, {:atom, :foo}, :boolean}]}}
+               {:ok, {:map, [{:required, {:atom, :foo}, {:atom, :bar}}]}}
 
       assert unify_lift(
-               {:map, [{:required, {:atom, :foo}, :boolean}]},
+               {:map, [{:required, {:atom, :foo}, {:atom, :bar}}]},
                {:map, [{:optional, {:atom, :foo}, :atom}]}
              ) ==
-               {:ok, {:map, [{:required, {:atom, :foo}, :boolean}]}}
+               {:ok, {:map, [{:required, {:atom, :foo}, {:atom, :bar}}]}}
 
       assert unify_lift(
-               {:map, [{:optional, {:atom, :foo}, :boolean}]},
+               {:map, [{:optional, {:atom, :foo}, {:atom, :bar}}]},
                {:map, [{:optional, {:atom, :foo}, :atom}]}
              ) ==
-               {:ok, {:map, [{:optional, {:atom, :foo}, :boolean}]}}
+               {:ok, {:map, [{:optional, {:atom, :foo}, {:atom, :bar}}]}}
     end
 
     test "map with subtyped keys" do
@@ -277,8 +267,8 @@ defmodule Module.Types.UnifyTest do
       assert unify_lift({:union, [:integer, :atom]}, {:union, [:atom, :integer]}) ==
                {:ok, {:union, [:integer, :atom]}}
 
-      assert unify_lift({:union, [:atom]}, {:union, [:boolean]}) == {:ok, {:union, [:boolean]}}
-      assert unify_lift({:union, [:boolean]}, {:union, [:atom]}) == {:ok, {:union, [:boolean]}}
+      assert unify_lift({:union, [:atom]}, {:union, [{:atom, :bar}]}) ==
+               {:ok, {:union, [{:atom, :bar}]}}
 
       assert {:error, {:unable_unify, {{:union, [:integer]}, {:union, [:atom]}, _}}} =
                unify_lift({:union, [:integer]}, {:union, [:atom]})
@@ -425,15 +415,11 @@ defmodule Module.Types.UnifyTest do
   describe "subtype?/3" do
     test "with simple types" do
       assert subtype?({:atom, :foo}, :atom, new_context())
-      assert subtype?({:atom, true}, :boolean, new_context())
       assert subtype?({:atom, true}, :atom, new_context())
-      assert subtype?(:boolean, :atom, new_context())
 
       refute subtype?(:integer, :binary, new_context())
       refute subtype?(:atom, {:atom, :foo}, new_context())
-      refute subtype?(:boolean, {:atom, true}, new_context())
       refute subtype?(:atom, {:atom, true}, new_context())
-      refute subtype?(:atom, :boolean, new_context())
     end
 
     test "with composite types" do
@@ -503,8 +489,7 @@ defmodule Module.Types.UnifyTest do
   test "to_union/2" do
     assert to_union([:atom], new_context()) == :atom
     assert to_union([:integer, :integer], new_context()) == :integer
-    assert to_union([:boolean, :atom], new_context()) == :atom
-    assert to_union([{:atom, :foo}, :boolean, :atom], new_context()) == :atom
+    assert to_union([{:atom, :foo}, {:atom, :bar}, :atom], new_context()) == :atom
 
     assert to_union([:binary, :atom], new_context()) == {:union, [:binary, :atom]}
     assert to_union([:atom, :binary, :atom], new_context()) == {:union, [:atom, :binary]}