Do not catch failures on tasks

Closes #2345

Author: José Valim

lib/elixir/lib/task.ex

@@ -2,10 +2,10 @@ defmodule Task do
   @moduledoc """
   Conveniences for spawning and awaiting for tasks.
 
-  Tasks are processes that meant to execute one particular
-  action throughout their life-cycle, often with little
-  explicit communication with other processes. The most common
-  use case for tasks is to compute a value asynchronously:
+  Tasks are processes meant to execute one particular
+  action throughout their life-cycle, often with little or no
+  communication with other processes. The most common use case
+  for tasks is to compute a value asynchronously:
 
       task = Task.async(fn -> do_some_work() end)
       res  = do_some_other_work()
@@ -16,28 +16,21 @@ defmodule Task do
   They are implemented by spawning a process that sends a message
   to the caller once the given computation is performed.
 
-  Besides `async/1` and `await/1`, tasks can also be used as part
-  of supervision trees and dynamically spawned in remote nodes.
-  We will explore all three scenarios next.
+  Besides `async/1` and `await/1`, tasks can also be used be
+  started as part of supervision trees and dynamically spawned
+  in remote nodes. We will explore all three scenarios next.
 
   ## async and await
 
   The most common way to spawn a task is with `Task.async/1`. A new
-  process will be created and this process is linked and monitored
-  by the caller. However, the processes are unlinked right before
-  the task finishes, allowing the proper error to be triggered only
-  on `await/1`.
+  process will be created, linked and monitored by the caller. Once
+  the task action finishes, a message will be sent to the caller
+  with its result.
 
-  This implies three things:
-
-  1) In case the caller crashes, the task will be killed and its
-     computation will abort;
-
-  2) In case the task crashes due to an error, the parent will
-     crash only on `await/1`;
-
-  3) In case the task crashes because a linked process caused
-     it to crash, the parent will crash immediately;
+  `Task.await/1` is used to read the message sent by the task. On
+  await, Elixir will also setup a monitor to verify if the process
+  exited with any abnormal reason (or in case exits are being
+  trapped by the caller).
 
   ## Supervised tasks
 
@@ -55,14 +48,9 @@ defmodule Task do
       ]
 
   Since such tasks are supervised and not directly linked to
-  the caller, they cannot be awaited on. For such reason,
-  differently from `async/1`, `start_link/1` returns `{:ok, pid}`
-  (which is the result expected by supervision trees).
-
-  Such tasks are useful as workers that run during your application
-  life-cycle and rarely communicate with other workers. For example,
-  a worker that pushes data to another server or a worker that consumes
-  events from an event manager and writes it to a log file.
+  the caller, they cannot be awaited on. Note `start_link/1`,
+  differently from `async/1`, returns `{:ok, pid}` (which is
+  the result expected by supervision trees).
 
   ## Supervision trees
 
@@ -78,7 +66,7 @@ defmodule Task do
       # In the remote node
       Task.Supervisor.start_link(name: :tasks_sup)
 
-      # On the client
+      # In the client
       Task.Supervisor.async({:tasks_sup, :remote@local}, fn -> do_work() end)
 
   `Task.Supervisor` is more often started in your supervision tree as:
@@ -118,7 +106,7 @@ defmodule Task do
   """
   @spec start_link(module, atom, [term]) :: {:ok, pid}
   def start_link(mod, fun, args) do
-    Task.Supervised.start_link(:undefined, {mod, fun, args})
+    Task.Supervised.start_link({mod, fun, args})
   end
 
   @doc """

lib/elixir/lib/task/supervised.ex

@@ -1,15 +1,23 @@
 defmodule Task.Supervised do
   @moduledoc false
 
-  def start_link(:undefined, fun) do
+  def start_link(fun) do
     :proc_lib.start_link(__MODULE__, :noreply, [fun])
   end
 
   def start_link(caller, fun) do
     :proc_lib.start_link(__MODULE__, :reply, [caller, fun])
   end
 
-  def async(caller, {module, fun, args}) do
+  def async(caller, mfa) do
+    ref = receive do: ({^caller, ref} -> ref)
+    send caller, {ref, apply(mfa)}
+  end
+
+  def reply(caller, mfa) do
+    :erlang.link(caller)
+    :proc_lib.init_ack({:ok, self()})
+
     ref =
       # There is a race condition on this operation when working accross
       # node that manifests if a `Task.Supervisor.async/1` call is made
@@ -33,29 +41,15 @@ defmodule Task.Supervised do
         5000 -> exit(:timeout)
       end
 
-    try do
-      apply(module, fun, args)
-    else
-      result ->
-        send caller, {ref, result}
-    catch
-      :error, reason ->
-        exit({reason, System.stacktrace()})
-      :throw, value ->
-        exit({{:nocatch, value}, System.stacktrace()})
-    after
-      :erlang.unlink(caller)
-    end
+    send caller, {ref, apply(mfa)}
   end
 
-  def reply(caller, mfa) do
-    :erlang.link(caller)
+  def noreply(mfa) do
     :proc_lib.init_ack({:ok, self()})
-    async(caller, mfa)
+    apply(mfa)
   end
 
-  def noreply({module, fun, args}) do
-    :proc_lib.init_ack({:ok, self()})
+  def apply({module, fun, args}) do
     try do
       apply(module, fun, args)
     catch

lib/elixir/lib/task/supervisor.ex

@@ -98,6 +98,6 @@ defmodule Task.Supervisor do
   """
   @spec start_child(Supervisor.supervisor, module, atom, [term]) :: {:ok, pid}
   def start_child(supervisor, module, fun, args) do
-    Supervisor.start_child(supervisor, [:undefined, {module, fun, args}])
+    Supervisor.start_child(supervisor, [{module, fun, args}])
   end
 end

lib/elixir/test/elixir/task/supervisor_test.exs

@@ -85,18 +85,21 @@ defmodule Task.SupervisorTest do
   end
 
   test "await/1 exits on task throw", config do
+    Process.flag(:trap_exit, true)
     task = Task.Supervisor.async(config[:supervisor], fn -> throw :unknown end)
     assert {{{:nocatch, :unknown}, _}, {Task, :await, [^task, 5000]}} =
            catch_exit(Task.await(task))
   end
 
   test "await/1 exits on task error", config do
+    Process.flag(:trap_exit, true)
     task = Task.Supervisor.async(config[:supervisor], fn -> raise "oops" end)
     assert {{%RuntimeError{}, _}, {Task, :await, [^task, 5000]}} =
            catch_exit(Task.await(task))
   end
 
   test "await/1 exits on task exit", config do
+    Process.flag(:trap_exit, true)
     task = Task.Supervisor.async(config[:supervisor], fn -> exit :unknown end)
     assert {:unknown, {Task, :await, [^task, 5000]}} =
            catch_exit(Task.await(task))

lib/elixir/test/elixir/task_test.exs

@@ -70,18 +70,21 @@ defmodule TaskTest do
   end
 
   test "await/1 exits on task throw" do
+    Process.flag(:trap_exit, true)
     task = Task.async(fn -> throw :unknown end)
     assert {{{:nocatch, :unknown}, _}, {Task, :await, [^task, 5000]}} =
            catch_exit(Task.await(task))
   end
 
   test "await/1 exits on task error" do
+    Process.flag(:trap_exit, true)
     task = Task.async(fn -> raise "oops" end)
     assert {{%RuntimeError{}, _}, {Task, :await, [^task, 5000]}} =
            catch_exit(Task.await(task))
   end
 
   test "await/1 exits on task exit" do
+    Process.flag(:trap_exit, true)
     task = Task.async(fn -> exit :unknown end)
     assert {:unknown, {Task, :await, [^task, 5000]}} =
            catch_exit(Task.await(task))