Add protocol consolidation with mix compile.protocols

Author: José Valim

lib/elixir/lib/protocol.ex

@@ -211,6 +211,14 @@ defmodule Protocol do
     end
   end
 
+  @doc """
+  Returns true if the protocol was consolidated.
+  """
+  @spec consolidated?(module) :: boolean
+  def consolidated?(protocol) do
+    protocol.__info__(:attributes)[:protocol][:consolidated]
+  end
+
   @doc """
   Receives a protocol and a list of implementations and
   consolidates the given protocol.
@@ -225,7 +233,7 @@ defmodule Protocol do
   to be consolidated or not by analyzing the protocol
   attribute:
 
-      Enumerable.__info__(:attributes)[:protocol]
+      Protocol.consolidated?(Enumerable)
 
   If the first element of the tuple is true, it means
   the protocol was consolidated.

lib/elixir/test/elixir/protocol_test.exs

@@ -266,6 +266,11 @@ defmodule Protocol.ConsolidationTest do
   {:ok, binary} = Protocol.consolidate(WithAny, [Any, ImplStruct, Map])
   :code.load_binary(WithAny, 'protocol_test.exs', binary)
 
+  test "consolidated?/1" do
+    assert Protocol.consolidated?(WithAny)
+    refute Protocol.consolidated?(Enumerable)
+  end
+
   test "consolidated implementations without any" do
     assert nil? Sample.impl_for(:foo)
     assert nil? Sample.impl_for(fn(x) -> x end)

lib/mix/lib/mix/tasks/compile.protocols.ex

@@ -0,0 +1,66 @@
+defmodule Mix.Tasks.Compile.Protocols do
+  use Mix.Task
+
+  @recursive true
+
+  @moduledoc ~S"""
+  Consolidates all protocols in all paths.
+
+  This module consolidates all protocols in the code path
+  and output the new binary files to the given directory
+  (defaults to "consolidated").
+
+  A new directory will be created with the consolidated
+  protocol versions. Simply add it to your codepath to
+  make use of it:
+
+      mix run -pa consolidated
+
+  You can verify a protocol is consolidated by checking
+  its attributes:
+
+      elixir -pa consolidated -S \
+        mix run -e "IO.puts Protocol.consolidated?(Enumerable)"
+
+  """
+
+  def run(args) do
+    Mix.Task.run "compile", args
+    {opts, _, _} = OptionParser.parse(args, switches: [output: :string], aliases: [o: :output])
+
+    paths = filter_otp(:code.get_path, :code.lib_dir)
+    paths
+    |> Protocol.extract_protocols
+    |> consolidate(paths, opts[:output] || "consolidated")
+
+    :ok
+  end
+
+  defp filter_otp(paths, otp) do
+    Enum.filter(paths, &(not :lists.prefix(&1, otp)))
+  end
+
+  defp consolidate(protocols, paths, output) do
+    File.mkdir_p!(output)
+
+    for protocol <- protocols do
+      impls = Protocol.extract_impls(protocol, paths)
+      maybe_reload(protocol)
+      {:ok, binary} = Protocol.consolidate(protocol, impls)
+      File.write!(Path.join(output, "#{protocol}.beam"), binary)
+      Mix.shell.info "Consolidated #{inspect protocol}"
+    end
+  end
+
+  defp maybe_reload(module) do
+    case :code.which(module) do
+      :non_existing ->
+        module
+      file ->
+        unless Path.extname(file) == ".beam" do
+          :code.purge(module)
+          :code.delete(module)
+        end
+    end
+  end
+end

lib/mix/test/mix/tasks/compile.protocols_test.exs

@@ -0,0 +1,22 @@
+Code.require_file "../../test_helper.exs", __DIR__
+
+defmodule Mix.Tasks.Compile.ProtocolsTest do
+  use MixTest.Case
+
+  test "compiles and consolidates protocols" do
+    Mix.Project.push MixTest.Case.Sample
+
+    in_fixture "no_mixfile", fn ->
+      assert Mix.Tasks.Compile.Protocols.run([]) == :ok
+      assert_received {:mix_shell, :info, ["Consolidated Enumerable"]}
+
+      assert File.regular? "consolidated/Elixir.Enumerable.beam"
+      purge [Enumerable]
+
+      Code.prepend_path("consolidated")
+      assert Protocol.consolidated?(Enumerable)
+    end
+  after
+    purge [Enumerable]
+  end
+end