Initial support for tuples and in elem/2

Author: josevalim

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

@@ -59,12 +59,12 @@ defmodule Module.Types.Descr do
   def non_empty_list(), do: %{bitmap: @bit_non_empty_list}
   def open_map(), do: %{map: @map_top}
   def open_map(pairs), do: map_descr(:open, pairs)
+  def open_tuple(elements), do: tuple_descr(:open, elements)
   def pid(), do: %{bitmap: @bit_pid}
   def port(), do: %{bitmap: @bit_port}
   def reference(), do: %{bitmap: @bit_reference}
-  def open_tuple(elements), do: %{tuple: tuple_new(:open, elements)}
-  def tuple(elements), do: %{tuple: tuple_new(:closed, elements)}
   def tuple(), do: %{tuple: @tuple_top}
+  def tuple(elements), do: tuple_descr(:closed, elements)
 
   @boolset :sets.from_list([true, false], version: 2)
   def boolean(), do: %{atom: {:union, @boolset}}
@@ -727,9 +727,8 @@ defmodule Module.Types.Descr do
   with the assumption that the descr is exclusively a map (or dynamic).
 
   It returns a two element tuple or `:error`. The first element says
-  if the type is optional or not, the second element is the type.
-  In static mode, we likely want to raise if `map.field`
-  (or pattern matching?) is called on an optional key.
+  if the type is dynamically optional or not, the second element is
+  the type. In static mode, optional keys are not allowed.
   """
   def map_fetch(:term, _key), do: :badmap
 
@@ -1234,6 +1233,28 @@ defmodule Module.Types.Descr do
   # - {integer(), atom()} is encoded as {:closed, [integer(), atom()]}
   # - {atom(), boolean(), ...} is encoded as {:open, [atom(), boolean()]}
 
+  defp tuple_descr(tag, fields) do
+    case tuple_descr(fields, [], false) do
+      {fields, true} -> %{dynamic: %{tuple: tuple_new(tag, Enum.reverse(fields))}}
+      {_, false} -> %{tuple: tuple_new(tag, fields)}
+    end
+  end
+
+  defp tuple_descr([:term | rest], acc, dynamic?) do
+    tuple_descr(rest, [:term | acc], dynamic?)
+  end
+
+  defp tuple_descr([value | rest], acc, dynamic?) do
+    case :maps.take(:dynamic, value) do
+      :error -> tuple_descr(rest, [value | acc], dynamic?)
+      {dynamic, _static} -> tuple_descr(rest, [dynamic | acc], true)
+    end
+  end
+
+  defp tuple_descr([], acc, dynamic?) do
+    {acc, dynamic?}
+  end
+
   defp tuple_new(tag, elements), do: [{tag, elements, []}]
 
   defp tuple_intersection(dnf1, dnf2) do
@@ -1395,8 +1416,9 @@ defmodule Module.Types.Descr do
   with the assumption that the descr is exclusively a tuple (or dynamic).
 
   Returns one of:
+
   - `{false, type}` if the element is always accessible and has the given `type`.
-  - `{true, type}` if the element may exist and has the given `type`.
+  - `{true, type}` if the element is dynamically optional and has the given `type`.
   - `:badindex` if the index is never accessible in the tuple type.
   - `:badtuple` if the descr is not a tuple type.
 
@@ -1405,8 +1427,6 @@ defmodule Module.Types.Descr do
       iex> tuple_fetch(tuple([integer(), atom()]), 0)
       {false, integer()}
 
-      :badindex
-
       iex> tuple_fetch(union(tuple([integer()]), tuple([integer(), atom()])), 1)
       {true, atom()}
 
@@ -1420,7 +1440,7 @@ defmodule Module.Types.Descr do
   def tuple_fetch(_, index) when index < 0, do: :badindex
   def tuple_fetch(:term, _key), do: :badtuple
 
-  def tuple_fetch(%{} = descr, key) do
+  def tuple_fetch(%{} = descr, key) when is_integer(key) do
     case :maps.take(:dynamic, descr) do
       :error ->
         if descr_key?(descr, :tuple) and tuple_only?(descr) do

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

@@ -266,6 +266,21 @@ defmodule Module.Types.Of do
 
   ## Apply
 
+  # TODO: Implement element without a literal index
+  # TODO: Add a test for an open tuple (inferred from a guard)
+  # TODO: Implement set_element
+
+  def apply(:erlang, :element, [_, type], {_, meta, [index, _]} = expr, stack, context)
+      when is_integer(index) do
+    case tuple_fetch(type, index - 1) do
+      {_optional?, value_type} ->
+        {:ok, value_type, context}
+
+      reason ->
+        {:ok, dynamic(), warn({reason, expr, type, index - 1, context}, meta, stack, context)}
+    end
+  end
+
   def apply(:erlang, name, [left, right], expr, stack, context)
       when name in [:>=, :"=<", :>, :<, :min, :max] do
     result = if name in [:min, :max], do: union(left, right), else: boolean()
@@ -619,6 +634,48 @@ defmodule Module.Types.Of do
     }
   end
 
+  def format_diagnostic({:badtuple, expr, type, index, context}) do
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          expected a tuple when accessing element at index #{index} in expression:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          but got type:
+
+              #{to_quoted_string(type) |> indent(4)}
+          """,
+          format_traces(traces)
+        ])
+    }
+  end
+
+  def format_diagnostic({:badindex, expr, type, index, context}) do
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          out of range index #{index} in expression:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          the given type does not have the given index:
+
+              #{to_quoted_string(type) |> indent(4)}
+          """,
+          format_traces(traces)
+        ])
+    }
+  end
+
   def format_diagnostic({:badmodule, expr, type, fun, arity, hints, context}) do
     traces = collect_traces(expr, context)
 

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

@@ -299,7 +299,7 @@ defmodule Module.Types.Pattern do
   # {...}
   defp of_shared({:{}, _meta, exprs}, _expected_expr, stack, context, fun) do
     case map_reduce_ok(exprs, context, &fun.(&1, {dynamic(), &1}, stack, &2)) do
-      {:ok, _, context} -> {:ok, tuple(), context}
+      {:ok, types, context} -> {:ok, tuple(types), context}
       {:error, reason} -> {:error, reason}
     end
   end

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

@@ -719,6 +719,10 @@ defmodule Module.Types.DescrTest do
 
     test "tuples" do
       assert tuple([integer(), atom()]) |> to_quoted_string() == "{integer(), atom()}"
+
+      assert tuple([integer(), dynamic(atom())]) |> to_quoted_string() ==
+               "dynamic({integer(), atom()})"
+
       assert open_tuple([integer(), atom()]) |> to_quoted_string() == "{integer(), atom(), ...}"
 
       assert union(tuple([integer(), atom()]), open_tuple([atom()])) |> to_quoted_string() ==

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

@@ -204,6 +204,48 @@ defmodule Module.Types.ExprTest do
   describe "tuples" do
     test "creating tuples" do
       assert typecheck!({:ok, 123}) == tuple([atom([:ok]), integer()])
+      assert typecheck!([x], {:ok, x}) == dynamic(tuple([atom([:ok]), term()]))
+    end
+
+    test "accessing tuples" do
+      assert typecheck!(elem({:ok, 123}, 0)) == atom([:ok])
+      assert typecheck!(elem({:ok, 123}, 1)) == integer()
+      assert typecheck!([x], elem({:ok, x}, 0)) == dynamic(atom([:ok]))
+      assert typecheck!([x], elem({:ok, x}, 1)) == dynamic(term())
+    end
+
+    test "accessing an index on not a map" do
+      assert typewarn!([<<x::integer>>], elem(x, 0)) ==
+               {dynamic(),
+                ~l"""
+                expected a tuple when accessing element at index 0 in expression:
+
+                    elem(x, 0)
+
+                but got type:
+
+                    integer()
+
+                where "x" was given the type:
+
+                    # type: integer()
+                    # from: types_test.ex:LINE-2
+                    <<x::integer>>
+                """}
+    end
+
+    test "accessing an out of range index" do
+      assert typewarn!(elem({:ok, 123}, 2)) ==
+               {dynamic(),
+                ~l"""
+                out of range index 2 in expression:
+
+                    elem({:ok, 123}, 2)
+
+                the given type does not have the given index:
+
+                    {:ok, integer()}
+                """}
     end
   end
 
@@ -212,6 +254,7 @@ defmodule Module.Types.ExprTest do
       assert typecheck!(%{foo: :bar}) == closed_map(foo: atom([:bar]))
       assert typecheck!(%{123 => 456}) == open_map()
       assert typecheck!(%{123 => 456, foo: :bar}) == open_map(foo: atom([:bar]))
+      assert typecheck!([x], %{key: x}) == dynamic(closed_map(key: term()))
 
       assert typecheck!(
                (

lib/mix/test/test_helper.exs

@@ -132,7 +132,13 @@ defmodule MixTest.Case do
 
   defmacro in_fixture(which, block) do
     module = inspect(__CALLER__.module)
-    function = Atom.to_string(elem(__CALLER__.function, 0))
+
+    function =
+      case __CALLER__.function do
+        {name, _arity} -> Atom.to_string(name)
+        nil -> raise "expected in_fixture/2 to be called from a function"
+      end
+
     tmp = Path.join(module, function)
 
     quote do