Inline functions in the Tuple module, closes #2261

Author: José Valim

lib/elixir/lib/tuple.ex

@@ -9,6 +9,8 @@ defmodule Tuple do
   Creates a tuple of size `size` containing the
   given `data` at every position.
 
+  Inlined by the compiler.
+
   ## Examples
 
       iex> Tuple.duplicate(:hello, 3)
@@ -27,6 +29,8 @@ defmodule Tuple do
   Raises an `ArgumentError` if `index` is greater than the
   length of `tuple`.
 
+  Inlined by the compiler.
+
   ## Examples
 
       iex> tuple = {:bar, :baz}
@@ -46,6 +50,8 @@ defmodule Tuple do
   Raises an `ArgumentError` if `index` is greater than
   or equal to the length of `tuple`.
 
+  Inlined by the compiler.
+
   ## Examples
 
       iex> tuple = {:foo, :bar, :baz}

lib/elixir/src/elixir_dispatch.erl

@@ -10,12 +10,12 @@
 -include("elixir.hrl").
 -import(ordsets, [is_element/2]).
 
-%% Module macros
 -define(kernel, 'Elixir.Kernel').
+-define(map, 'Elixir.Map').
 -define(node, 'Elixir.Node').
 -define(process, 'Elixir.Process').
 -define(system, 'Elixir.System').
--define(map, 'Elixir.Map').
+-define(tuple, 'Elixir.Tuple').
 
 default_functions() ->
   [ {?kernel, elixir_imported_functions()} ].
@@ -341,8 +341,17 @@ rewrite(?kernel, elem, [Tuple, Index], _) ->
   {ok, erlang, element, [increment(Index), Tuple]};
 rewrite(?kernel, set_elem, [Tuple, Index, Value], _) ->
   {ok, erlang, setelement, [increment(Index), Tuple, Value]};
+
 rewrite(?process, monitor, [Arg], _) ->
   {ok, erlang, monitor, [process, Arg]};
+
+rewrite(?tuple, insert_at, [Tuple, Index, Term], _) ->
+  {ok, erlang, insert_element, [increment(Index), Tuple, Term]};
+rewrite(?tuple, delete_at, [Tuple, Index], _) ->
+  {ok, erlang, delete_element, [increment(Index), Tuple]};
+rewrite(?tuple, duplicate, [Data, Size], _) ->
+  {ok, erlang, make_tuple, [Size, Data]};
+
 rewrite(?map, 'has_key?', [Map, Key], _) ->
   {ok, maps, is_key, [Key, Map]};
 rewrite(?map, fetch, [Map, Key], _) ->

lib/elixir/test/elixir/tuple_test.exs

@@ -28,17 +28,28 @@ defmodule TupleTest do
   end
 
   # Tuple module
+  # We check two variants due to inlining.
 
   test :duplicate do
     assert Tuple.duplicate(:foo, 0) == {}
     assert Tuple.duplicate(:foo, 3) == {:foo, :foo, :foo}
+
+    mod = Tuple
+    assert mod.duplicate(:foo, 0) == {}
+    assert mod.duplicate(:foo, 3) == {:foo, :foo, :foo}
   end
 
   test :insert_at do
     assert Tuple.insert_at({:bar, :baz}, 0, :foo) == {:foo, :bar, :baz}
+
+    mod = Tuple
+    assert mod.insert_at({:bar, :baz}, 0, :foo) == {:foo, :bar, :baz}
   end
 
   test :delete_at do
     assert Tuple.delete_at({:foo, :bar, :baz}, 0) == {:bar, :baz}
+
+    mod = Tuple
+    assert mod.delete_at({:foo, :bar, :baz}, 0) == {:bar, :baz}
   end
 end