Type Tuple.insert_at/3

Author: josevalim

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

@@ -1933,7 +1933,7 @@ defmodule Module.Types.Descr do
   @doc """
   Insert an element at the tuple.
 
-  It returns the same as `tuple_fetch/2` but with `:badrange` instead of `:badindex`.
+  It returns the same as `tuple_fetch/2`. Notice, however, the range for indexes is inclusive.
   """
   def tuple_insert_at(:term, _key, _type), do: :badtuple
 
@@ -1944,7 +1944,7 @@ defmodule Module.Types.Descr do
     end
   end
 
-  def tuple_insert_at(_, _, _), do: :badrange
+  def tuple_insert_at(_, _, _), do: :badindex
 
   defp tuple_insert_at_checked(descr, index, type) do
     case :maps.take(:dynamic, descr) do
@@ -1955,7 +1955,7 @@ defmodule Module.Types.Descr do
 
         cond do
           is_proper_tuple? and is_proper_size? -> tuple_insert_static(descr, index, type)
-          is_proper_tuple? -> :badrange
+          is_proper_tuple? -> :badindex
           true -> :badtuple
         end
 
@@ -1976,7 +1976,7 @@ defmodule Module.Types.Descr do
 
           # Highlight the case where the issue is an index out of range from the tuple
           is_proper_tuple? ->
-            :badrange
+            :badindex
 
           true ->
             :badtuple

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

@@ -296,17 +296,33 @@ 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)
+  def apply(:erlang, :element, [_, tuple], {_, meta, [index, _]} = expr, stack, context)
       when is_integer(index) do
-    case tuple_fetch(type, index - 1) do
+    case tuple_fetch(tuple, index - 1) do
       {_optional?, value_type} ->
         {value_type, context}
 
       reason ->
-        {error_type(), error({reason, expr, type, index - 1, context}, meta, stack, context)}
+        {error_type(), error({reason, expr, tuple, index - 1, context}, meta, stack, context)}
+    end
+  end
+
+  def apply(
+        :erlang,
+        :insert_element,
+        [_, tuple, value],
+        {_, meta, [index, _, _]} = expr,
+        stack,
+        context
+      )
+      when is_integer(index) do
+    case tuple_insert_at(tuple, index - 1, value) do
+      value_type when is_descr(value_type) ->
+        {value_type, context}
+
+      reason ->
+        {error_type(), error({reason, expr, tuple, index - 2, context}, meta, stack, context)}
     end
   end
 
@@ -571,15 +587,15 @@ defmodule Module.Types.Of do
     }
   end
 
-  def format_diagnostic({:badtuple, expr, type, index, context}) do
+  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:
+          expected a tuple in expression:
 
               #{expr_to_string(expr) |> indent(4)}
 
@@ -600,7 +616,7 @@ defmodule Module.Types.Of do
       message:
         IO.iodata_to_binary([
           """
-          out of range tuple access at index #{index} in expression:
+          expected a tuple with at least #{pluralize(index + 1, "element", "elements")} in expression:
 
               #{expr_to_string(expr) |> indent(4)}
 
@@ -749,6 +765,9 @@ defmodule Module.Types.Of do
     }
   end
 
+  defp pluralize(1, singular, _), do: "1 #{singular}"
+  defp pluralize(i, _, plural), do: "#{i} #{plural}"
+
   defp dot_var?(expr) do
     match?({{:., _, [var, _fun]}, _, _args} when is_var(var), expr)
   end

lib/elixir/lib/tuple.ex

@@ -87,22 +87,8 @@ defmodule Tuple do
     :erlang.insert_element(index + 1, tuple, value)
   end
 
-  @doc """
-  Inserts an element at the end of a tuple.
-
-  Returns a new tuple with the element appended at the end, and contains
-  the elements in `tuple` followed by `value` as the last element.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> tuple = {:foo, :bar}
-      iex> Tuple.append(tuple, :baz)
-      {:foo, :bar, :baz}
-
-  """
-  @spec append(tuple, term) :: tuple
+  @doc false
+  @deprecated "Use insert_at instead"
   def append(tuple, value) do
     :erlang.append_element(tuple, value)
   end

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

@@ -641,13 +641,21 @@ defmodule Module.Types.DescrTest do
     test "tuple_fetch" do
       assert tuple_fetch(term(), 0) == :badtuple
       assert tuple_fetch(integer(), 0) == :badtuple
+
       assert tuple_fetch(tuple([integer(), atom()]), 0) == {false, integer()}
       assert tuple_fetch(tuple([integer(), atom()]), 1) == {false, atom()}
       assert tuple_fetch(tuple([integer(), atom()]), 2) == :badindex
+
+      assert tuple_fetch(open_tuple([integer(), atom()]), 0) == {false, integer()}
+      assert tuple_fetch(open_tuple([integer(), atom()]), 1) == {false, atom()}
+      assert tuple_fetch(open_tuple([integer(), atom()]), 2) == :badindex
+
       assert tuple_fetch(tuple([integer(), atom()]), -1) == :badindex
       assert tuple_fetch(empty_tuple(), 0) == :badindex
       assert difference(tuple(), tuple()) |> tuple_fetch(0) == :badindex
-      assert tuple([atom()]) |> difference(empty_tuple()) |> tuple_fetch(0) == {false, atom()}
+
+      assert tuple([atom()]) |> difference(empty_tuple()) |> tuple_fetch(0) ==
+               {false, atom()}
 
       assert difference(tuple([union(integer(), atom())]), open_tuple([atom()]))
              |> tuple_fetch(0) == {false, integer()}
@@ -742,14 +750,14 @@ defmodule Module.Types.DescrTest do
     end
 
     test "tuple_insert_at" do
-      assert tuple_insert_at(tuple([integer(), atom()]), 3, boolean()) == :badrange
-      assert tuple_insert_at(tuple([integer(), atom()]), -1, boolean()) == :badrange
+      assert tuple_insert_at(tuple([integer(), atom()]), 3, boolean()) == :badindex
+      assert tuple_insert_at(tuple([integer(), atom()]), -1, boolean()) == :badindex
       assert tuple_insert_at(integer(), 0, boolean()) == :badtuple
       assert tuple_insert_at(term(), 0, boolean()) == :badtuple
 
       # Out-of-bounds in a union
       assert union(tuple([integer(), atom()]), tuple([float()]))
-             |> tuple_insert_at(2, boolean()) == :badrange
+             |> tuple_insert_at(2, boolean()) == :badindex
 
       # Test inserting into a closed tuple
       assert tuple_insert_at(tuple([integer(), atom()]), 1, boolean()) ==

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

@@ -248,18 +248,16 @@ defmodule Module.Types.ExprTest do
       assert typecheck!([x], {:ok, x}) == dynamic(tuple([atom([:ok]), term()]))
     end
 
-    test "accessing tuples" do
+    test "elem/2" 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:
+                expected a tuple in expression:
 
                     elem(x, 0)
 
@@ -273,13 +271,11 @@ defmodule Module.Types.ExprTest do
                     # 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 tuple access at index 2 in expression:
+                expected a tuple with at least 3 elements in expression:
 
                     elem({:ok, 123}, 2)
 
@@ -288,6 +284,49 @@ defmodule Module.Types.ExprTest do
                     {:ok, integer()}
                 """}
     end
+
+    test "Tuple.insert_at/3" do
+      assert typecheck!(Tuple.insert_at({}, 0, "foo")) == tuple([binary()])
+
+      assert typecheck!(Tuple.insert_at({:ok, 123}, 0, "foo")) ==
+               tuple([binary(), atom([:ok]), integer()])
+
+      assert typecheck!(Tuple.insert_at({:ok, 123}, 1, "foo")) ==
+               tuple([atom([:ok]), binary(), integer()])
+
+      assert typecheck!(Tuple.insert_at({:ok, 123}, 2, "foo")) ==
+               tuple([atom([:ok]), integer(), binary()])
+
+      assert typewarn!([<<x::integer>>], Tuple.insert_at(x, 0, "foo")) ==
+               {dynamic(),
+                ~l"""
+                expected a tuple in expression:
+
+                    Tuple.insert_at(x, 0, "foo")
+
+                but got type:
+
+                    integer()
+
+                where "x" was given the type:
+
+                    # type: integer()
+                    # from: types_test.ex:LINE-2
+                    <<x::integer>>
+                """}
+
+      assert typewarn!(Tuple.insert_at({:ok, 123}, 3, "foo")) ==
+               {dynamic(),
+                ~l"""
+                expected a tuple with at least 3 elements in expression:
+
+                    Tuple.insert_at({:ok, 123}, 3, "foo")
+
+                the given type does not have the given index:
+
+                    {:ok, integer()}
+                """}
+    end
   end
 
   describe "maps/structs" do