Use new Erlang :erpc instead of :rpc

Author: josevalim

lib/elixir/lib/kernel/cli.ex

@@ -400,23 +400,22 @@ defmodule Kernel.CLI do
     # Explicitly connect the node in case the rpc node was started with --sname/--name undefined.
     _ = :net_kernel.connect_node(node)
 
-    case :rpc.call(node, __MODULE__, :rpc_eval, [expr]) do
-      :ok ->
-        :ok
-
-      {:badrpc, {:EXIT, exit}} ->
-        Process.exit(self(), exit)
-
-      {:badrpc, reason} ->
-        if reason == :nodedown and :net_kernel.nodename() == :ignored do
+    try do
+      :erpc.call(node, __MODULE__, :rpc_eval, [expr])
+    catch
+      :error, {:erpc, reason} ->
+        if reason == :noconnection and :net_kernel.nodename() == :ignored do
           {:error,
            "--rpc-eval : Cannot run --rpc-eval if the node is not alive (set --name or --sname)"}
         else
           {:error, "--rpc-eval : RPC failed with reason #{inspect(reason)}"}
         end
 
-      {kind, error, stack} ->
-        :erlang.raise(kind, error, stack)
+      :exit, {kind, exit} when kind in [:exception, :signal] ->
+        Process.exit(self(), exit)
+    else
+      :ok -> :ok
+      {kind, reason, stack} -> :erlang.raise(kind, reason, stack)
     end
   end
 

lib/iex/lib/iex/autocomplete.ex

@@ -27,9 +27,10 @@ defmodule IEx.Autocomplete do
   """
   def remsh(node) do
     fn e ->
-      case :rpc.call(node, IEx.Autocomplete, :expand, [e, IEx.Broker.shell()]) do
-        {:badrpc, _} -> {:no, ~c"", []}
-        r -> r
+      try do
+        :erpc.call(node, IEx.Autocomplete, :expand, [e, IEx.Broker.shell()])
+      catch
+        _, _ -> {:no, ~c"", []}
       end
     end
   end

lib/iex/lib/iex/broker.ex

@@ -180,8 +180,11 @@ defmodule IEx.Broker do
 
   defp local_or_remote_shell() do
     Enum.find_value([node() | Node.list()], fn node ->
-      server = :rpc.call(node, IEx.Broker, :shell, [])
-      if is_pid(server), do: server
+      try do
+        :erpc.call(node, IEx.Broker, :shell, [])
+      catch
+        _, _ -> nil
+      end
     end)
   end
 end

lib/iex/lib/iex/helpers.ex

@@ -1458,15 +1458,14 @@ defmodule IEx.Helpers do
   def nl(nodes \\ Node.list(), module) when is_list(nodes) and is_atom(module) do
     case get_beam_and_path(module) do
       {bin, beam_path} ->
+        call = :erpc.multicall(nodes, :code, :load_binary, [module, beam_path, bin])
+
         results =
-          for node <- nodes do
-            case :rpc.call(node, :code, :load_binary, [module, beam_path, bin]) do
-              {:module, _} -> {node, :loaded, module}
-              {:badrpc, message} -> {node, :badrpc, message}
-              {:error, message} -> {node, :error, message}
-              unexpected -> {node, :error, unexpected}
-            end
-          end
+          Enum.zip_with(nodes, call, fn
+            node, {:ok, {:module, _}} -> {node, :loaded, module}
+            node, {:ok, {:error, reason}} -> {node, :error, reason}
+            node, {:error, {:erpc, reason}} -> {node, :badrpc, reason}
+          end)
 
         {:ok, results}
 

lib/iex/lib/iex/info.ex

@@ -346,7 +346,11 @@ defimpl IEx.Info, for: PID do
 
   def info(pid) do
     extra_info =
-      case :rpc.pinfo(pid, @keys) do
+      try do
+        :erpc.call(node(pid), :erlang, :process_info, [pid, @keys])
+      catch
+        _, _ -> [{"Alive", false}]
+      else
         [_ | _] = info ->
           [
             {"Alive", true},
@@ -382,11 +386,19 @@ end
 
 defimpl IEx.Info, for: Port do
   def info(port) do
-    connected = :rpc.call(node(port), :erlang, :port_info, [port, :connected])
+    open? =
+      try do
+        :erpc.call(node(port), :erlang, :port_info, [port, :connected])
+      catch
+        _, _ -> false
+      else
+        {:connected, _} -> true
+        _ -> false
+      end
 
     [
       {"Data type", "Port"},
-      {"Open", match?({:connected, _}, connected)},
+      {"Open", open?},
       {"Reference modules", "Port"}
     ]
   end

lib/iex/test/iex/helpers_test.exs

@@ -1294,9 +1294,12 @@ defmodule IEx.HelpersTest do
     @tag :capture_log
     test "loads a given module on the given nodes" do
       assert nl([node()], :lists) == {:ok, [{:nonode@nohost, :error, :sticky_directory}]}
-      assert nl(:nonexistent_module) == {:error, :nofile}
-      assert nl([:nosuchnode@badhost], Enum) == {:ok, [{:nosuchnode@badhost, :badrpc, :nodedown}]}
       assert nl([node()], Enum) == {:ok, [{:nonode@nohost, :loaded, Enum}]}
+
+      assert nl(:nonexistent_module) == {:error, :nofile}
+
+      assert nl([:nosuchnode@badhost], Enum) ==
+               {:ok, [{:nosuchnode@badhost, :badrpc, :noconnection}]}
     end
   end