Add CHANGELOG for function application and improve pretty printing

Author: josevalim

CHANGELOG.md

@@ -94,6 +94,44 @@ but expected a type that implements the Enumerable protocol, it must be one of:
     ) or fun() or list(term()) or non_struct_map()
 ```
 
+### Type checking and inference of anonymous functions
+
+Elixir v1.19 can now type infer and type check anonymous functions. Here is a trivial example:
+
+```elixir
+defmodule Example do
+  def run do
+    fun = fn %{} -> :map end
+    fun.("hello")
+  end
+end
+```
+
+The example above has an obvious typing violation, as the anonymous function expects a map but a string is given. With Elixir v1.19, the following warning is now printed:
+
+```
+    warning: incompatible types given on function application:
+
+        fun.("hello")
+
+    given types:
+
+        binary()
+
+    but function has type:
+
+        (dynamic(map()) -> :map)
+
+    typing violation found at:
+    │
+  6 │     fun.("hello")
+    │        ~
+    │
+    └─ mod.exs:6:8: Example.run/0
+```
+
+Function captures, such as `&String.to_integer/1`, will also propagate the type as of Elixir v1.19, arising more opportunity for Elixir's type system to catch bugs in our programs.
+
 ## Faster compile times in large projects
 
 This release includes two compiler improvements that can lead up to 4x faster builds in large codebases.

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

@@ -472,28 +472,33 @@ defmodule Module.Types.Apply do
   Returns the type of a remote capture.
   """
   def remote_capture(modules, fun, arity, meta, stack, context) do
-    if stack.mode == :traversal or modules == [] do
-      {dynamic(fun(arity)), context}
-    else
-      {type, fallback?, context} =
-        Enum.reduce(modules, {none(), false, context}, fn module, {type, fallback?, context} ->
-          case signature(module, fun, arity, meta, stack, context) do
-            {{:strong, _, clauses}, context} ->
-              {union(type, fun_from_non_overlapping_clauses(clauses)), fallback?, context}
+    cond do
+      stack.mode == :traversal ->
+        {dynamic(), context}
 
-            {{:infer, _, clauses}, context} when length(clauses) <= @max_clauses ->
-              {union(type, fun_from_overlapping_clauses(clauses)), fallback?, context}
+      modules == [] ->
+        {dynamic(fun(arity)), context}
 
-            {_, context} ->
-              {type, true, context}
-          end
-        end)
+      true ->
+        {type, fallback?, context} =
+          Enum.reduce(modules, {none(), false, context}, fn module, {type, fallback?, context} ->
+            case signature(module, fun, arity, meta, stack, context) do
+              {{:strong, _, clauses}, context} ->
+                {union(type, fun_from_non_overlapping_clauses(clauses)), fallback?, context}
 
-      if fallback? do
-        {dynamic(fun(arity)), context}
-      else
-        {type, context}
-      end
+              {{:infer, _, clauses}, context} when length(clauses) <= @max_clauses ->
+                {union(type, fun_from_overlapping_clauses(clauses)), fallback?, context}
+
+              {_, context} ->
+                {type, true, context}
+            end
+          end)
+
+        if fallback? do
+          {dynamic(fun(arity)), context}
+        else
+          {type, context}
+        end
     end
   end
 

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

@@ -111,13 +111,15 @@ defmodule Module.Types.Descr do
   Creates the top function type for the given arity,
   where all arguments are none() and return is term().
 
+  This function cannot be applied to, unless it is made dynamic.
+
   ## Examples
 
       fun(1)
       #=> (none -> term)
 
       fun(2)
-      #=> Creates (none, none) -> term
+      #=> Creates (none, none -> term)
   """
   def fun(arity) when is_integer(arity) and arity >= 0 do
     fun(List.duplicate(none(), arity), term())
@@ -1464,24 +1466,61 @@ defmodule Module.Types.Descr do
   defp fun_intersection(bdd1, bdd2) do
     case {bdd1, bdd2} do
       # Base cases
-      {_, :fun_bottom} -> :fun_bottom
-      {:fun_bottom, _} -> :fun_bottom
-      {:fun_top, bdd} -> bdd
-      {bdd, :fun_top} -> bdd
+      {_, :fun_bottom} ->
+        :fun_bottom
+
+      {:fun_bottom, _} ->
+        :fun_bottom
+
+      {:fun_top, bdd} ->
+        bdd
+
+      {bdd, :fun_top} ->
+        bdd
+
       # Optimizations
       # If intersecting with a single positive or negative function, we insert
       # it at the root instead of merging the trees (this avoids going down the
       # whole bdd).
-      {bdd, {fun, :fun_top, :fun_bottom}} -> {fun, bdd, :fun_bottom}
-      {bdd, {fun, :fun_bottom, :fun_top}} -> {fun, :fun_bottom, bdd}
-      {{fun, :fun_top, :fun_bottom}, bdd} -> {fun, bdd, :fun_bottom}
-      {{fun, :fun_bottom, :fun_top}, bdd} -> {fun, :fun_bottom, bdd}
+      {bdd, {{args, return} = fun, :fun_top, :fun_bottom}} ->
+        # If intersecting with the top type for that arity, no-op
+        if return == :term and Enum.all?(args, &(&1 == %{})) and
+             matching_arity?(bdd, length(args)) do
+          bdd
+        else
+          {fun, bdd, :fun_bottom}
+        end
+
+      {bdd, {fun, :fun_bottom, :fun_top}} ->
+        {fun, :fun_bottom, bdd}
+
+      {{{args, return} = fun, :fun_top, :fun_bottom}, bdd} ->
+        # If intersecting with the top type for that arity, no-op
+        if return == :term and Enum.all?(args, &(&1 == %{})) and
+             matching_arity?(bdd, length(args)) do
+          bdd
+        else
+          {fun, bdd, :fun_bottom}
+        end
+
+      {{fun, :fun_bottom, :fun_top}, bdd} ->
+        {fun, :fun_bottom, bdd}
+
       # General cases
-      {{fun, l1, r1}, {fun, l2, r2}} -> {fun, fun_intersection(l1, l2), fun_intersection(r1, r2)}
-      {{fun, l, r}, bdd} -> {fun, fun_intersection(l, bdd), fun_intersection(r, bdd)}
+      {{fun, l1, r1}, {fun, l2, r2}} ->
+        {fun, fun_intersection(l1, l2), fun_intersection(r1, r2)}
+
+      {{fun, l, r}, bdd} ->
+        {fun, fun_intersection(l, bdd), fun_intersection(r, bdd)}
     end
   end
 
+  defp matching_arity?({{args, _return}, l, r}, arity) do
+    length(args) == arity and matching_arity?(l, arity) and matching_arity?(r, arity)
+  end
+
+  defp matching_arity?(_, _arity), do: true
+
   defp fun_difference(bdd1, bdd2) do
     case {bdd1, bdd2} do
       {:fun_bottom, _} -> :fun_bottom

lib/elixir/lib/module/types/expr.ex

@@ -455,7 +455,7 @@ defmodule Module.Types.Expr do
   end
 
   def of_expr({{:., _, [fun]}, _, args} = call, _expected, _expr, stack, context) do
-    {fun_type, context} = of_expr(fun, fun(length(args)), call, stack, context)
+    {fun_type, context} = of_expr(fun, dynamic(fun(length(args))), call, stack, context)
 
     # TODO: Perform inference based on the strong domain of a function
     {args_types, context} =

lib/elixir/pages/references/gradual-set-theoretic-types.md

@@ -101,9 +101,9 @@ This function also has the type `(boolean() -> boolean())`, because it receives
 
 At this point, you may ask, why not a union? As a real-world example, take a t-shirt with green and yellow stripes. We can say the t-shirt belongs to the set of "t-shirts with green color". We can also say the t-shirt belongs to the set of "t-shirts with yellow color". Let's see the difference between unions and intersections:
 
-  * `(t_shirts_with_green() or t_shirts_with_yellow())` - contains t-shirts with either green or yellow, such as green, green and red, green and yellow, yellow, yellow and red, etc.
+  * `(t_shirts_with_green() or t_shirts_with_yellow())` - contains t-shirts with either green or yellow, such as green, green and red, green and yellow, but also only yellow, yellow and red, etc.
 
-  * `(t_shirts_with_green() and t_shirts_with_yellow())` - contains t-shirts with both green and yellow (and also other colors)
+  * `(t_shirts_with_green() and t_shirts_with_yellow())` - contains t-shirts with both green and yellow (and maybe other colors)
 
 Since the t-shirt has both colors, we say it belongs to the intersection of both sets. The same way that a function that goes from `(integer() -> integer())` and `(boolean() -> boolean())` is also an intersection. In practice, it does not make sense to define the union of two functions in Elixir, so the compiler will always point to the right direction.
 

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

@@ -1812,6 +1812,13 @@ defmodule Module.Types.DescrTest do
       assert fun() |> to_quoted_string() == "fun()"
       assert none_fun(1) |> to_quoted_string() == "(none() -> term())"
 
+      assert none_fun(1)
+             |> intersection(none_fun(2))
+             |> to_quoted_string() == "none()"
+
+      assert fun([integer()], atom()) |> intersection(none_fun(1)) |> to_quoted_string() ==
+               "(integer() -> atom())"
+
       assert fun([integer(), float()], boolean()) |> to_quoted_string() ==
                "(integer(), float() -> boolean())"
 

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

@@ -234,6 +234,28 @@ defmodule Module.Types.ExprTest do
              to said function are types that satisfy all sides of the union (which may be none)
              """
     end
+
+    test "bad arguments from inferred type" do
+      assert typeerror!(
+               (
+                 fun = fn %{} -> :map end
+                 fun.(:error)
+               )
+             )
+             |> strip_ansi() == """
+             incompatible types given on function application:
+
+                 fun.(:error)
+
+             given types:
+
+                 :error
+
+             but function has type:
+
+                 (dynamic(map()) -> :map)
+             """
+    end
   end
 
   describe "remotes" do