is_function/2

Author: josevalim

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

@@ -119,6 +119,11 @@ defmodule Module.Types.Apply do
       |> union(tuple([fun(), args_or_arity]))
     )
 
+  not_signature =
+    for bool <- [true, false] do
+      {[atom([bool])], atom([not bool])}
+    end
+
   and_signature =
     for left <- [true, false], right <- [true, false] do
       {[atom([left]), atom([right])], atom([left and right])}
@@ -206,7 +211,7 @@ defmodule Module.Types.Apply do
         {:erlang, :map_size, [{[open_map()], integer()}]},
         {:erlang, :node, [{[], atom()}]},
         {:erlang, :node, [{[pid() |> union(reference()) |> union(port())], atom()}]},
-        {:erlang, :not, [{[atom([false])], atom([true])}, {[atom([true])], atom([false])}]},
+        {:erlang, :not, not_signature},
         {:erlang, :or, or_signature},
         {:erlang, :raise, [{[atom([:error, :exit, :throw]), term(), raise_stacktrace], none()}]},
         {:erlang, :rem, [{[integer(), integer()], integer()}]},
@@ -263,14 +268,14 @@ defmodule Module.Types.Apply do
          [{[term(), open_map()], tuple([atom([:ok]), term()]) |> union(atom([:error]))}]},
         {:maps, :get, [{[term(), open_map()], term()}]},
         {:maps, :is_key, [{[term(), open_map()], boolean()}]},
-        {:maps, :keys, [{[open_map()], dynamic(list(term()))}]},
+        {:maps, :keys, [{[open_map()], list(term())}]},
         {:maps, :put, [{[term(), term(), open_map()], open_map()}]},
         {:maps, :remove, [{[term(), open_map()], open_map()}]},
         {:maps, :take,
          [{[term(), open_map()], tuple([term(), open_map()]) |> union(atom([:error]))}]},
-        {:maps, :to_list, [{[open_map()], dynamic(list(tuple([term(), term()])))}]},
+        {:maps, :to_list, [{[open_map()], list(tuple([term(), term()]))}]},
         {:maps, :update, [{[term(), term(), open_map()], open_map()}]},
-        {:maps, :values, [{[open_map()], dynamic(list(term()))}]}
+        {:maps, :values, [{[open_map()], list(term())}]}
       ] do
     [arity] = Enum.map(clauses, fn {args, _return} -> length(args) end) |> Enum.uniq()
 
@@ -320,6 +325,20 @@ defmodule Module.Types.Apply do
     {:none, Enum.map(args, fn _ -> term() end), context}
   end
 
+  @is_function_info {:strong, nil, [{[term(), integer()], boolean()}]}
+
+  def remote_domain(:erlang, :is_function, [_, arity], expected, _meta, _stack, context)
+      when is_integer(arity) and arity >= 0 do
+    arg =
+      case booleaness(expected) do
+        :always_true -> fun(arity)
+        :always_false -> negation(fun(arity))
+        :undefined -> term()
+      end
+
+    {@is_function_info, [arg, integer()], context}
+  end
+
   def remote_domain(:erlang, :element, [index, _], expected, _meta, _stack, context)
       when is_integer(index) do
     tuple = open_tuple(List.duplicate(term(), max(index - 1, 0)) ++ [expected])

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

@@ -902,6 +902,40 @@ defmodule Module.Types.Descr do
     :sets.from_list([false], version: 2)
   ]
 
+  @doc """
+  Compute the booleaness of an element.
+
+  It is either :undefined, :always_true, or :always_false.
+  """
+  def booleaness(:term), do: :undefined
+
+  def booleaness(%{} = descr) do
+    descr = Map.get(descr, :dynamic, descr)
+
+    case descr do
+      %{atom: {:union, %{true => _, false => _}}} ->
+        :undefined
+
+      %{atom: {:union, %{true => _}}} ->
+        :always_true
+
+      %{atom: {:union, %{false => _}}} ->
+        :always_false
+
+      %{atom: {:negation, %{true => _, false => _}}} ->
+        :undefined
+
+      %{atom: {:negation, %{true => _}}} ->
+        :always_false
+
+      %{atom: {:negation, %{false => _}}} ->
+        :always_true
+
+      _ ->
+        :undefined
+    end
+  end
+
   @doc """
   Compute the truthiness of an element.
 
@@ -1687,7 +1721,16 @@ defmodule Module.Types.Descr do
   defp pivot([], _acc, _fun), do: :error
 
   # Converts a function BDD (Binary Decision Diagram) to its quoted representation
-  defp fun_to_quoted({:negation, _bdds}, _opts), do: [{:fun, [], []}]
+  defp fun_to_quoted({:negation, bdds}, opts) do
+    case fun_to_quoted({:union, bdds}, opts) do
+      [] ->
+        [{:fun, [], []}]
+
+      parts ->
+        ors = Enum.reduce(parts, &{:or, [], [&2, &1]})
+        [{:and, [], [{:fun, [], []}, {:not, [], [ors]}]}]
+    end
+  end
 
   defp fun_to_quoted({:union, bdds}, opts) do
     for {arity, bdd} <- bdds,

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

@@ -34,7 +34,6 @@ defmodule Module.Types.Pattern do
 
   def of_head(patterns, guards, expected, tag, meta, stack, context) do
     stack = %{stack | meta: meta}
-
     {trees, context} = of_pattern_args(patterns, expected, tag, stack, context)
     {_, context} = of_guards(guards, stack, context)
     {trees, context}
@@ -762,6 +761,7 @@ defmodule Module.Types.Pattern do
   #    the environment vars.
 
   @guard atom([true, false, :fail])
+  @atom_true atom([true])
 
   defp of_guards([], _stack, context) do
     {[], context}
@@ -913,7 +913,16 @@ defmodule Module.Types.Pattern do
     Apply.remote_apply(info, :erlang, fun, args_types, call, stack, context)
   end
 
-  defp of_remote(fun, meta, args, call, {_root, expected}, stack, context) do
+  defp of_remote(fun, meta, args, call, {root, expected}, stack, context) do
+    # If we are the root, we are only interested in positive results,
+    # except for the operations that can return :fail.
+    expected =
+      if root and fun not in [:element, :hd, :map_get, :max, :min, :tl] do
+        @atom_true
+      else
+        expected
+      end
+
     {info, domain, context} =
       Apply.remote_domain(:erlang, fun, args, expected, meta, stack, context)
 

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

@@ -14,7 +14,7 @@ end
 defmodule Module.Types.DescrTest do
   use ExUnit.Case, async: true
 
-  import Module.Types.Descr, except: [fun: 1]
+  import Module.Types.Descr
   defmacro domain_key(arg) when is_atom(arg), do: [arg]
 
   defp number(), do: union(integer(), float())
@@ -1225,6 +1225,23 @@ defmodule Module.Types.DescrTest do
   end
 
   describe "projections" do
+    test "booleaness" do
+      for type <- [term(), none(), atom(), boolean(), integer()] do
+        assert booleaness(type) == :undefined
+        assert booleaness(dynamic(type)) == :undefined
+      end
+
+      for type <- [atom([false]), atom([:other, false]), negation(atom([true]))] do
+        assert booleaness(type) == :always_false
+        assert booleaness(dynamic(type)) == :always_false
+      end
+
+      for type <- [atom([true]), atom([:other, true]), negation(atom([false]))] do
+        assert booleaness(type) == :always_true
+        assert booleaness(dynamic(type)) == :always_true
+      end
+    end
+
     test "truthiness" do
       for type <- [term(), none(), atom(), boolean(), union(atom([false]), integer())] do
         assert truthiness(type) == :undefined
@@ -2710,6 +2727,13 @@ defmodule Module.Types.DescrTest do
              |> union(fun([pid()], pid()))
              |> to_quoted_string() ==
                "(integer() -> integer()) or (float() -> float()) or (pid() -> pid())"
+
+      assert fun(3) |> to_quoted_string() == "(none(), none(), none() -> term())"
+
+      assert intersection(fun(), negation(fun())) |> to_quoted_string() == "none()"
+
+      assert intersection(fun(), negation(fun(3))) |> to_quoted_string() ==
+               "fun() and not (none(), none(), none() -> term())"
     end
 
     test "function with optimized intersections" do

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

@@ -182,25 +182,6 @@ defmodule Module.Types.PatternTest do
                    m = 123
                """
     end
-
-    test "fields in guards" do
-      assert typeerror!([x = %Point{}], x.foo_bar, :ok) ==
-               ~l"""
-               unknown key .foo_bar in expression:
-
-                   x.foo_bar
-
-               the given type does not have the given key:
-
-                   dynamic(%Point{x: term(), y: term(), z: term()})
-
-               where "x" was given the type:
-
-                   # type: dynamic(%Point{})
-                   # from: types_test.ex:LINE-1
-                   x = %Point{}
-               """
-    end
   end
 
   describe "maps" do
@@ -241,11 +222,6 @@ defmodule Module.Types.PatternTest do
                )
     end
 
-    test "atom keys in guards" do
-      assert typecheck!([x = %{foo: :bar}], x.bar, x) ==
-               dynamic(open_map(foo: atom([:bar]), bar: atom([true, false, :fail])))
-    end
-
     test "domain keys in patterns" do
       assert typecheck!([x = %{123 => 456}], x) == dynamic(open_map())
       assert typecheck!([x = %{123 => 456, foo: :bar}], x) == dynamic(open_map(foo: atom([:bar])))
@@ -413,6 +389,71 @@ defmodule Module.Types.PatternTest do
   end
 
   describe "guards" do
+    test "not" do
+      assert typecheck!([x], not x, x) == dynamic(atom([false]))
+
+      assert typecheck!([x], not x.foo, x) == dynamic(open_map(foo: atom([false])))
+
+      assert typeerror!([x], not length(x), x) |> strip_ansi() == ~l"""
+             incompatible types given to Kernel.not/1:
+
+                 not length(x)
+
+             given types:
+
+                 integer()
+
+             but expected one of:
+
+                 #1
+                 true
+
+                 #2
+                 false
+
+             where "x" was given the type:
+
+                 # type: dynamic()
+                 # from: types_test.ex:LINE
+                 x
+             """
+    end
+
+    test "is_function/2" do
+      assert typecheck!([x], is_function(x, 3), x) == dynamic(fun(3))
+      assert typecheck!([x], not is_function(x, 3), x) == dynamic(negation(fun(3)))
+    end
+
+    test "elem" do
+      assert typecheck!([x], elem(x, 1), x) ==
+               dynamic(open_tuple([term(), atom([true, false, :fail])]))
+
+      assert typecheck!([x], not elem(x, 1), x) ==
+               dynamic(open_tuple([term(), atom([false])]))
+    end
+
+    test "map.field" do
+      assert typecheck!([x = %{foo: :bar}], x.bar, x) ==
+               dynamic(open_map(foo: atom([:bar]), bar: atom([true, false, :fail])))
+
+      assert typeerror!([x = %Point{}], x.foo_bar, :ok) ==
+               ~l"""
+               unknown key .foo_bar in expression:
+
+                   x.foo_bar
+
+               the given type does not have the given key:
+
+                   dynamic(%Point{x: term(), y: term(), z: term()})
+
+               where "x" was given the type:
+
+                   # type: dynamic(%Point{})
+                   # from: types_test.ex:LINE-1
+                   x = %Point{}
+               """
+    end
+
     test "domain checks propagate across all operations except 'orelse'" do
       assert typecheck!([x], [length(x) == 3], x) == dynamic(list(term()))