Inline some process and node calls, closes #1808

Author: José Valim

lib/elixir/lib/node.ex

@@ -1,6 +1,10 @@
 defmodule Node do
   @moduledoc """
-  Functions related to Erlang nodes.
+  Functions related to VM nodes.
+
+  Some of the functions in this module are inlined by the compiler,
+  similar to functions in the `Kernel` module. When such happens,
+  they are explicitly tagged as so.
   """
 
   @type t :: atom
@@ -97,6 +101,8 @@ defmodule Node do
 
   Check http://www.erlang.org/doc/man/erlang.html#spawn-2 for
   the list of available options.
+
+  Inlined by the compiler.
   """
   @spec spawn(t, (() -> any)) :: pid
   def spawn(node, fun) do
@@ -109,6 +115,8 @@ defmodule Node do
 
   Check http://www.erlang.org/doc/man/erlang.html#spawn_opt-3 for
   the list of available options.
+
+  Inlined by the compiler.
   """
   @spec spawn(t, (() -> any), Process.spawn_opts) :: pid | {pid, reference}
   def spawn(node, fun, opts) do
@@ -122,6 +130,8 @@ defmodule Node do
 
   Check http://www.erlang.org/doc/man/erlang.html#spawn-4 for
   the list of available options.
+
+  Inlined by the compiler.
   """
   @spec spawn(t, module, atom, [any]) :: pid
   def spawn(node, module, fun, args) do
@@ -135,6 +145,8 @@ defmodule Node do
 
   Check http://www.erlang.org/doc/man/erlang.html#spawn_opt-5 for
   the list of available options.
+
+  Inlined by the compiler.
   """
   @spec spawn(t, module, atom, [any], Process.spawn_opts) :: pid | {pid, reference}
   def spawn(node, module, fun, args, opts) do
@@ -147,6 +159,8 @@ defmodule Node do
   new process, atomically. If `node` does not exist, a useless pid is returned
   (and due to the link, an exit signal with exit reason `:noconnection` will be
   received).
+
+  Inlined by the compiler.
   """
   @spec spawn_link(t, (() -> any)) :: pid
   def spawn_link(node, fun) do
@@ -159,6 +173,8 @@ defmodule Node do
   process and the new process, atomically. If `node` does not exist, a useless
   pid is returned (and due to the link, an exit signal with exit reason
   `:noconnection` will be received).
+
+  Inlined by the compiler.
   """
   @spec spawn_link(t, module, atom, [any]) :: pid
   def spawn_link(node, module, fun, args) do

lib/elixir/lib/process.ex

@@ -1,11 +1,10 @@
 defmodule Process do
   @moduledoc """
-  This module provides convenience functions around processes and
-  the process dictionary. In Erlang, most of these functions are
-  auto-imported, but in Elixir they are grouped in a module for
-  convenience. Notice that these functions, different from Erlang's,
-  always return nil instead of undefined. You can use their Erlang
-  version if you want the undefined value.
+  Conveniences for working with processes and the process dictionary.
+
+  Some of the functions in this module are inlined by the compiler,
+  similar to functions in the `Kernel` module. When such happens,
+  they are explicitly tagged as so.
   """
 
   @doc """
@@ -81,16 +80,18 @@ defmodule Process do
   1) If pid is not trapping exits, pid will exit with the given reason;
 
   2) If pid is trapping exits, the exit signal is transformed into a message
-     {'EXIT', from, reason} and delivered to the message queue of pid;
+     {:EXIT, from, reason} and delivered to the message queue of pid;
 
   3) If reason is the atom `:normal`, pid will not exit. If it is trapping exits,
-     the exit signal is transformed into a message {'EXIT', from, :normal} and
+     the exit signal is transformed into a message {:EXIT, from, :normal} and
      delivered to its message queue;
 
   4) If reason is the atom `:kill`, that is if `exit(pid, :kill)` is called, an
      untrappable exit signal is sent to pid which will unconditionally exit with
      exit reason `:killed`.
 
+  Inlined by the compiler.
+
   ## Examples
 
       Process.exit(pid, :kill)
@@ -112,6 +113,8 @@ defmodule Process do
   @doc """
   Returns the pid of a new process started by the application of `fun`.
   It behaves exactly the same as `Kernel.spawn/1`.
+
+  Inlined by the compiler.
   """
   @spec spawn((() -> any)) :: pid
   def spawn(fun) do
@@ -129,6 +132,8 @@ defmodule Process do
 
   It also accepts extra options, for the list of available options
   check http://www.erlang.org/doc/man/erlang.html#spawn_opt-2
+
+  Inlined by the compiler.
   """
   @spec spawn((() -> any), spawn_opts) :: pid | {pid, reference}
   def spawn(fun, opts) do
@@ -141,6 +146,8 @@ defmodule Process do
   scheduler queue and be run some time later.
 
   It behaves exactly the same as the `Kernel.spawn/3` function.
+
+  Inlined by the compiler.
   """
   @spec spawn(module, atom, [any]) :: pid
   def spawn(mod, fun, args) do
@@ -155,6 +162,7 @@ defmodule Process do
   It also accepts extra options, for the list of available options
   check http://www.erlang.org/doc/man/erlang.html#spawn_opt-4
 
+  Inlined by the compiler.
   """
   @spec spawn(module, atom, [any], spawn_opts) :: pid | {pid, reference}
   def spawn(mod, fun, args, opts) do
@@ -165,6 +173,8 @@ defmodule Process do
   Returns the pid of a new process started by the application of `fun`.
   A link is created between the calling process and the new
   process, atomically.
+
+  Inlined by the compiler.
   """
   @spec spawn_link((() -> any)) :: pid
   def spawn_link(fun) do
@@ -175,6 +185,8 @@ defmodule Process do
   Returns the pid of a new process started by the application of
   `module.function(args)`. A link is created between the calling process
   and the new process, atomically. Otherwise works like spawn/3.
+
+  Inlined by the compiler.
   """
   @spec spawn_link(module, atom, [any]) :: pid
   def spawn_link(mod, fun, args) do
@@ -184,6 +196,8 @@ defmodule Process do
   @doc """
   Returns the pid of a new process started by the application of `fun`
   and reference for a monitor created to the new process.
+
+  Inlined by the compiler.
   """
   @spec spawn_monitor((() -> any)) :: {pid, reference}
   def spawn_monitor(fun) do
@@ -194,6 +208,8 @@ defmodule Process do
   A new process is started by the application of `module.function(args)`
   and the process is monitored at the same time. Returns the pid and a
   reference for the monitor. Otherwise works like spawn/3.
+
+  Inlined by the compiler.
   """
   @spec spawn_monitor(module, atom, [any]) :: {pid, reference}
   def spawn_monitor(mod, fun, args) do
@@ -205,6 +221,8 @@ defmodule Process do
   It returns the monitor reference.
 
   See http://www.erlang.org/doc/man/erlang.html#monitor-2 for more info.
+
+  Inlined by the compiler.
   """
   @spec monitor(pid | {reg_name :: atom, node :: atom} | reg_name :: atom) :: reference
   def monitor(item) do
@@ -217,6 +235,8 @@ defmodule Process do
   If the monitoring is already turned off, nothing happens.
 
   See http://www.erlang.org/doc/man/erlang.html#demonitor-2 for more info.
+
+  Inlined by the compiler.
   """
   @spec demonitor(reference) :: true
   @spec demonitor(reference, options :: [:flush | :info]) :: boolean
@@ -244,6 +264,8 @@ defmodule Process do
   (or port) `pid`, if there is not such a link already.
 
   See http://www.erlang.org/doc/man/erlang.html#link-1 for more info.
+
+  Inlined by the compiler.
   """
   @spec link(pid | port) :: true
   def link(pid) do
@@ -256,6 +278,8 @@ defmodule Process do
   fail, even if there is no link or `id` does not exist
 
   See http://www.erlang.org/doc/man/erlang.html#unlink-1 for more info.
+
+  Inlined by the compiler.
   """
   @spec unlink(pid | port) :: true
   def unlink(pid) do

lib/elixir/src/elixir_dispatch.erl

@@ -9,7 +9,11 @@
   find_import/4, format_error/1]).
 -include("elixir.hrl").
 -import(ordsets, [is_element/2]).
+
+%% Module macros
 -define(kernel, 'Elixir.Kernel').
+-define(node, 'Elixir.Node').
+-define(process, 'Elixir.Process').
 
 default_functions() ->
   [ { ?kernel, elixir_imported_functions() } ].
@@ -328,6 +332,8 @@ rewrite(?kernel, elem, [Tuple, Index], 2) ->
   { ok, erlang, element, [increment(Index), Tuple] };
 rewrite(?kernel, set_elem, [Tuple, Index, Value], 2) ->
   { ok, erlang, setelement, [increment(Index), Tuple, Value] };
+rewrite(?process, monitor, [Arg], 1) ->
+  { ok, erlang, monitor, [process, Arg] };
 rewrite(Receiver, Name, Args, Arity) ->
   case inline(Receiver, Name, Arity) of
     { AR, AN } -> { ok, AR, AN, Args };
@@ -421,4 +427,28 @@ inline(?kernel, tl, 1) -> { erlang, tl };
 inline(?kernel, trunc, 1) -> { erlang, trunc };
 inline(?kernel, tuple_size, 1) -> { erlang, tuple_size };
 inline(?kernel, tuple_to_list, 1) -> { erlang, tuple_to_list };
+
+inline(?process, exit, 2) -> { erlang, exit };
+inline(?process, spawn, 1) -> { erlang, spawn };
+inline(?process, spawn, 2) -> { erlang, spawn_opt };
+inline(?process, spawn, 3) -> { erlang, spawn };
+inline(?process, spawn, 4) -> { erlang, spawn_opt };
+inline(?process, spawn_link, 1) -> { erlang, spawn_link };
+inline(?process, spawn_link, 3) -> { erlang, spawn_link };
+inline(?process, spawn_monitor, 1) -> { erlang, spawn_monitor };
+inline(?process, spawn_monitor, 3) -> { erlang, spawn_monitor };
+inline(?process, demonitor, 1) -> { erlang, demonitor };
+inline(?process, demonitor, 2) -> { erlang, demonitor };
+inline(?process, link, 1) -> { erlang, link };
+inline(?process, unlink, 1) -> { erlang, unlink };
+
+inline(?node, spawn, 2) -> { erlang, spawn };
+inline(?node, spawn, 3) -> { erlang, spawn_opt };
+inline(?node, spawn, 4) -> { erlang, spawn };
+inline(?node, spawn, 5) -> { erlang, spawn_opt };
+inline(?node, spawn_link, 2) -> { erlang, spawn_link };
+inline(?node, spawn_link, 4) -> { erlang, spawn_link };
+inline(?node, spawn_monitor, 2) -> { erlang, spawn_monitor };
+inline(?node, spawn_monitor, 4) -> { erlang, spawn_monitor };
+
 inline(_, _, _) -> false.

lib/elixir/test/elixir/process_test.exs

@@ -3,13 +3,26 @@ Code.require_file "test_helper.exs", __DIR__
 defmodule ProcessTest do
   use ExUnit.Case, async: true
 
-  test :self do
+  test "self/0" do
     assert is_pid(Process.self)
   end
 
-  test :group_leader do
+  test "group_leader/2 and group_leader/0" do
     another = spawn_link(fn -> :timer.sleep(1000) end)
     assert Process.group_leader(self, another)
     assert Process.group_leader == another
   end
+
+  test "monitoring functions are inlined by the compiler" do
+    assert expand(quote(do: Process.monitor(pid())), __ENV__) ==
+           quote(do: :erlang.monitor(:process, pid()))
+
+    assert &Process.spawn_monitor/1 == &:erlang.spawn_monitor/1
+    assert &Process.spawn_monitor/3 == &:erlang.spawn_monitor/3
+  end
+
+  defp expand(expr, env) do
+    { expr, _env } = :elixir_exp.expand(expr, :elixir_env.ex_to_env(env))
+    expr
+  end
 end