Typecheck cond

Author: josevalim

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

@@ -631,6 +631,48 @@ defmodule Module.Types.Descr do
   # an empty list of atoms. It is simplified to `0` in set operations, and the key
   # is removed from the map.
 
+  @false_or_nil_atoms [
+    :sets.from_list([false, nil], version: 2),
+    :sets.from_list([nil], version: 2),
+    :sets.from_list([false], version: 2)
+  ]
+
+  @doc """
+  Compute the truthness of an element.
+
+  It is either :undefined, :always_true, or :always_false.
+  """
+  def truthness(:term), do: :undefined
+
+  def truthness(%{} = descr) do
+    descr = Map.get(descr, :dynamic, descr)
+
+    case descr do
+      :term ->
+        :undefined
+
+      %{atom: {:union, set}}
+      when map_size(descr) == 1 and set in @false_or_nil_atoms ->
+        :always_false
+
+      %{atom: {:union, set}}
+      when map_size(descr) == 1 and not is_map_key(set, false) and not is_map_key(set, nil) ->
+        :always_true
+
+      %{atom: {:negation, %{nil => _, false => _}}} ->
+        :always_true
+
+      %{atom: _} ->
+        :undefined
+
+      _ when map_size(descr) == 0 ->
+        :undefined
+
+      _ ->
+        :always_true
+    end
+  end
+
   @doc """
   Optimized version of `not empty?(intersection(atom([atom]), type))`.
   """

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

@@ -178,16 +178,34 @@ defmodule Module.Types.Expr do
     of_expr(post, stack, context)
   end
 
-  # TODO: cond do pat -> expr end
   def of_expr({:cond, _meta, [[{:do, clauses}]]}, stack, context) do
-    context =
-      Enum.reduce(clauses, context, fn {:->, _meta, [head, body]}, context ->
-        {_, context} = of_expr(head, stack, context)
-        {_, context} = of_expr(body, stack, context)
-        context
-      end)
+    clauses
+    |> reduce_non_empty({none(), context}, fn
+      {:->, meta, [[head], body]}, {acc, context}, last? ->
+        {head_type, context} = of_expr(head, stack, context)
 
-    {dynamic(), context}
+        context =
+          if stack.mode == :infer do
+            context
+          else
+            case truthness(head_type) do
+              :always_true when not last? ->
+                warning = {:badcond, "always match", head_type, head, context}
+                warn(__MODULE__, warning, meta, stack, context)
+
+              :always_false ->
+                warning = {:badcond, "never match", head_type, head, context}
+                warn(__MODULE__, warning, meta, stack, context)
+
+              _ ->
+                context
+            end
+          end
+
+        {body_type, context} = of_expr(body, stack, context)
+        {union(body_type, acc), context}
+    end)
+    |> dynamic_unless_static(stack)
   end
 
   # TODO: case expr do pat -> expr end
@@ -459,6 +477,15 @@ defmodule Module.Types.Expr do
     {Enum.reduce(returns, &union/2), context}
   end
 
+  defp reduce_non_empty([last], acc, fun),
+    do: fun.(last, acc, true)
+
+  defp reduce_non_empty([head | tail], acc, fun),
+    do: reduce_non_empty(tail, fun.(head, acc, false), fun)
+
+  defp dynamic_unless_static({_, _} = output, %{mode: :static}), do: output
+  defp dynamic_unless_static({type, context}, %{mode: _}), do: {dynamic(type), context}
+
   defp of_clauses(clauses, stack, context) do
     Enum.reduce(clauses, context, fn {:->, meta, [head, body]}, context ->
       {patterns, guards} = extract_head(head)
@@ -480,13 +507,8 @@ defmodule Module.Types.Expr do
     {other, []}
   end
 
-  defp flatten_when({:when, _meta, [left, right]}) do
-    [left | flatten_when(right)]
-  end
-
-  defp flatten_when(other) do
-    [other]
-  end
+  defp flatten_when({:when, _meta, [left, right]}), do: [left | flatten_when(right)]
+  defp flatten_when(other), do: [other]
 
   defp of_expr_context(expr, stack, context) do
     {_type, context} = of_expr(expr, stack, context)
@@ -582,4 +604,25 @@ defmodule Module.Types.Expr do
         ])
     }
   end
+
+  def format_diagnostic({:badcond, explain, type, expr, context}) do
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          this clause in cond will #{explain}:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          since it has type:
+
+              #{to_quoted_string(type) |> indent(4)}
+          """,
+          format_traces(traces)
+        ])
+    }
+  end
 end

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

@@ -582,6 +582,9 @@ defmodule Module.Types.Of do
       when name in [:>=, :"=<", :>, :<, :min, :max] do
     context =
       cond do
+        stack.mode == :infer ->
+          context
+
         match?({false, _}, map_fetch(left, :__struct__)) or
             match?({false, _}, map_fetch(right, :__struct__)) ->
           warning = {:struct_comparison, expr, context}
@@ -609,6 +612,9 @@ defmodule Module.Types.Of do
       when name in [:==, :"/=", :"=:=", :"=/="] do
     context =
       cond do
+        stack.mode == :infer ->
+          context
+
         name in [:==, :"/="] and number_type?(left) and number_type?(right) ->
           context
 

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

@@ -594,6 +594,24 @@ defmodule Module.Types.DescrTest do
       assert fun_fetch(dynamic(), 1) == :ok
     end
 
+    test "truthness" do
+      for type <- [term(), none(), atom(), boolean(), union(atom([false]), integer())] do
+        assert truthness(type) == :undefined
+        assert truthness(dynamic(type)) == :undefined
+      end
+
+      for type <- [atom([false]), atom([nil]), atom([nil, false]), atom([false, nil])] do
+        assert truthness(type) == :always_false
+        assert truthness(dynamic(type)) == :always_false
+      end
+
+      for type <-
+            [negation(atom()), atom([true]), negation(atom([false, nil])), atom([:ok]), integer()] do
+        assert truthness(type) == :always_true
+        assert truthness(dynamic(type)) == :always_true
+      end
+    end
+
     test "atom_fetch" do
       assert atom_fetch(term()) == :error
       assert atom_fetch(union(term(), dynamic(atom([:foo, :bar])))) == :error

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

@@ -888,6 +888,82 @@ defmodule Module.Types.ExprTest do
     end
   end
 
+  describe "cond" do
+    test "always true" do
+      assert typecheck!(
+               cond do
+                 true -> :ok
+               end
+             ) == atom([:ok])
+
+      assert typecheck!(
+               [x, y],
+               cond do
+                 y -> :y
+                 x -> :x
+               end
+             ) == atom([:x, :y])
+
+      assert typedyn!(
+               [x, y],
+               cond do
+                 y -> :y
+                 x -> :x
+               end
+             ) == dynamic(atom([:x, :y]))
+
+      assert typewarn!(
+               [x, y = {:foo, :bar}],
+               cond do
+                 y -> :y
+                 x -> :x
+               end
+             ) ==
+               {atom([:x, :y]),
+                ~l"""
+                this clause in cond will always match:
+
+                    y
+
+                since it has type:
+
+                    dynamic({:foo, :bar})
+
+                where "y" was given the type:
+
+                    # type: dynamic({:foo, :bar})
+                    # from: types_test.ex:LINE-7
+                    y = {:foo, :bar}
+                """}
+    end
+
+    test "always false" do
+      assert typewarn!(
+               [x, y = false],
+               cond do
+                 y -> :y
+                 x -> :x
+               end
+             ) ==
+               {atom([:x, :y]),
+                ~l"""
+                this clause in cond will never match:
+
+                    y
+
+                since it has type:
+
+                    dynamic(false)
+
+                where "y" was given the type:
+
+                    # type: dynamic(false)
+                    # from: types_test.ex:LINE-7
+                    y = false
+                """}
+    end
+  end
+
   describe "comprehensions" do
     test "binary generators" do
       assert typeerror!([<<x>>], for(<<y <- x>>, do: y)) ==