More type checking

Author: josevalim

CHANGELOG.md

@@ -6,9 +6,9 @@ TODO.
 
 * Type checking and inference of patterns
 
-* [Support for tuples and lists as composite types](https://elixir-lang.org/blog/2024/08/28/typing-lists-and-tuples/).
+* [Support for tuples and lists as composite types](https://elixir-lang.org/blog/2024/08/28/typing-lists-and-tuples/) as well as type checking of its basic operations from Kernel
 
-* Type checking of `elem/2`, `hd/1`, and `tl/1` in `Kernel`
+* Type checking of all built-in conversion functions, such as `List.to_integer/1` and `Atom.to_string/1`
 
 * Type checking of all functions in the `Tuple` module
 

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

@@ -320,17 +320,36 @@ defmodule Module.Types.Of do
   # no overlaps.
 
   for {mod, fun, clauses} <- [
+        {:binary, :copy, [{[binary(), integer()], binary()}]},
+        {:erlang, :atom_to_binary, [{[atom()], binary()}]},
+        {:erlang, :atom_to_list, [{[atom()], list(integer())}]},
+        {:erlang, :binary_to_atom, [{[binary()], atom()}]},
+        {:erlang, :binary_to_existing_atom, [{[binary()], atom()}]},
         {:erlang, :binary_to_integer, [{[binary()], integer()}]},
+        {:erlang, :binary_to_integer, [{[binary(), integer()], integer()}]},
+        {:erlang, :binary_to_float, [{[binary()], float()}]},
         {:erlang, :integer_to_binary, [{[integer()], binary()}]},
+        {:erlang, :integer_to_binary, [{[integer(), integer()], binary()}]},
+        {:erlang, :integer_to_list, [{[integer()], non_empty_list(integer())}]},
+        {:erlang, :integer_to_list, [{[integer(), integer()], non_empty_list(integer())}]},
+        {:erlang, :list_to_atom, [{[list(integer())], atom()}]},
+        {:erlang, :list_to_existing_atom, [{[list(integer())], atom()}]},
+        {:erlang, :list_to_float, [{[non_empty_list(integer())], float()}]},
+        {:erlang, :list_to_integer, [{[non_empty_list(integer())], integer()}]},
+        {:erlang, :list_to_integer, [{[non_empty_list(integer()), integer()], integer()}]},
+        {:erlang, :list_to_tuple, [{[list(term())], dynamic(open_tuple([], term()))}]},
 
         # TODO: Replace term()/dynamic() by parametric types
-        {:erlang, :hd, [{[non_empty_list(term(), term())], dynamic()}]},
-        {:erlang, :tl, [{[non_empty_list(term(), term())], dynamic()}]},
         {:erlang, :delete_element,
          [{[integer(), open_tuple([], term())], dynamic(open_tuple([], term()))}]},
+        {:erlang, :hd, [{[non_empty_list(term(), term())], dynamic()}]},
         {:erlang, :element, [{[integer(), open_tuple([], term())], dynamic()}]},
         {:erlang, :insert_element,
-         [{[integer(), open_tuple([], term()), term()], dynamic(open_tuple([], term()))}]}
+         [{[integer(), open_tuple([], term()), term()], dynamic(open_tuple([], term()))}]},
+        {:erlang, :setelement,
+         [{[integer(), open_tuple([], term()), term()], dynamic(open_tuple([], term()))}]},
+        {:erlang, :tl, [{[non_empty_list(term(), term())], dynamic()}]},
+        {:erlang, :tuple_to_list, [{[open_tuple([], term())], dynamic(list(term()))}]}
       ] do
     [{args, _return} | _others] = clauses
 

lib/elixir/src/elixir_rewrite.erl

@@ -198,6 +198,8 @@ inline(Mod, Fun, Arity) -> inner_inline(ex_to_erl, Mod, Fun, Arity).
 ?inline(?process, unregister, 1, erlang, unregister);
 
 ?inline(?string, duplicate, 2, binary, copy);
+?inline(?string, to_atom, 1, erlang, binary_to_atom);
+?inline(?string, to_existing_atom, 1, erlang, binary_to_existing_atom);
 ?inline(?string, to_float, 1, erlang, binary_to_float);
 ?inline(?string, to_integer, 1, erlang, binary_to_integer);
 ?inline(?string, to_integer, 2, erlang, binary_to_integer);
@@ -208,8 +210,6 @@ inline(Mod, Fun, Arity) -> inner_inline(ex_to_erl, Mod, Fun, Arity).
 ?inline(?system, time_offset, 0, erlang, time_offset);
 ?inline(?system, unique_integer, 0, erlang, unique_integer);
 ?inline(?system, unique_integer, 1, erlang, unique_integer);
-
-?inline(?tuple, append, 2, erlang, append_element);
 ?inline(?tuple, to_list, 1, erlang, tuple_to_list);
 
 % Defined without macro to avoid conflict with Bitwise named operators
@@ -258,8 +258,6 @@ rewrite(Receiver, DotMeta, Right, Meta, Args) ->
 ?rewrite(?process, monitor, [Arg, Opts], erlang, monitor, [process, Arg, Opts]);
 ?rewrite(?process, send_after, [Dest, Msg, Time], erlang, send_after, [Time, Dest, Msg]);
 ?rewrite(?process, send_after, [Dest, Msg, Time, Opts], erlang, send_after, [Time, Dest, Msg, Opts]);
-?rewrite(?string, to_atom, [Arg], erlang, binary_to_atom, [Arg, utf8]);
-?rewrite(?string, to_existing_atom, [Arg], erlang, binary_to_existing_atom, [Arg, utf8]);
 ?rewrite(?tuple, duplicate, [Data, Size], erlang, make_tuple, [Size, Data]);
 
 inner_rewrite(ex_to_erl, Meta, ?tuple, delete_at, [Tuple, Index]) ->

lib/iex/lib/iex/autocomplete.ex

@@ -685,7 +685,7 @@ defmodule IEx.Autocomplete do
 
   defp hidden_fun?({name, arity}, docs) do
     case Enum.find(docs, &match?({{_, ^name, ^arity}, _, _, _, _}, &1)) do
-      nil -> hd(Atom.to_charlist(name)) == ?_
+      nil -> match?([?_ | _], Atom.to_charlist(name))
       {_, _, _, :hidden, _} -> true
       {_, _, _, _, _} -> false
     end