Provide Protocol.derive/3

Author: José Valim

lib/elixir/lib/kernel.ex

@@ -3094,7 +3094,7 @@ defmodule Kernel do
 
   For each protocol given to `@derive`, Elixir will assert there is an
   implementation of that protocol for maps and check if the map
-  implementation defines a `__deriving__/2` callback. If so, the callback
+  implementation defines a `__deriving__/3` callback. If so, the callback
   is invoked, otherwise an implementation that simply points to the map
   one is automatically derived.
 
@@ -3125,18 +3125,18 @@ defmodule Kernel do
           other -> raise ArgumentError, "struct field names must be atoms, got: #{inspect other}"
         end, fields)
 
+        @struct :maps.put(:__struct__, __MODULE__, :maps.from_list(fields))
+
         case Module.get_attribute(__MODULE__, :derive) do
-          nil ->
+          [] ->
             :ok
           derive ->
-            env = __ENV__
-            struct = :maps.put(:__struct__, __MODULE__, :maps.from_list(fields))
-            :lists.foreach(fn proto -> Protocol.__derive__(proto, struct, env) end, derive)
+            Protocol.__derive__(derive, __MODULE__, __ENV__)
         end
 
         @spec __struct__() :: t
         def __struct__() do
-          %{unquote_splicing(Macro.escape(fields)), __struct__: __MODULE__}
+          @struct
         end
       end
 

lib/elixir/lib/protocol.ex

@@ -111,6 +111,16 @@ defmodule Protocol do
     end
   end
 
+  @doc """
+  Derive the `protocol` for `module` with the given options.
+  """
+  defmacro derive(protocol, module, options \\ []) do
+    quote do
+      module = unquote(module)
+      Protocol.__derive__([{unquote(protocol), unquote(options)}], module, __ENV__)
+    end
+  end
+
   ## Consolidation
 
   @doc """
@@ -527,17 +537,34 @@ defmodule Protocol do
   end
 
   @doc false
-  def __derive__(protocol, struct, %Macro.Env{} = env) do
-    for  = env.module
-    impl = Module.concat(protocol, Map)
+  def __derive__(derives, for, %Macro.Env{} = env) when is_atom(for) do
+    struct =
+      if for == env.module do
+        Module.get_attribute(for, :struct) ||
+          raise "struct is not defined for #{inspect for}"
+      else
+        for.__struct__
+      end
+
+    :lists.foreach(fn
+      proto when is_atom(proto) ->
+        derive(proto, for, struct, [], env)
+      {proto, opts} when is_atom(proto) ->
+        derive(proto, for, struct, opts, env)
+    end, :lists.flatten(derives))
 
-    extra = ", cannot derive #{inspect protocol} for #{inspect env.module}"
+    :ok
+  end
+
+  defp derive(protocol, for, struct, opts, env) do
+    impl  = Module.concat(protocol, Map)
+    extra = ", cannot derive #{inspect protocol} for #{inspect for}"
     assert_protocol!(protocol, extra)
     assert_impl!(protocol, impl, extra)
 
     # Clean up variables from eval context
-    env  = %{env | vars: []}
-    args = [env, struct]
+    env  = %{env | vars: [], export_vars: nil}
+    args = [for, struct, opts]
 
     :elixir_module.expand_callback(env.line, impl, :__deriving__, args, env, fn
       mod, fun, args ->
@@ -556,8 +583,6 @@ defmodule Protocol do
           end)
         end
     end)
-
-    :ok
   end
 
   @doc false

lib/elixir/src/elixir_exp.erl

@@ -243,7 +243,7 @@ expand({'try', Meta, [KV]}, E) ->
 
 %% Comprehensions
 
-expand({for, Meta, Args}, E) when is_list(Args) ->
+expand({for, Meta, [_|_] = Args}, E) ->
   elixir_for:expand(Meta, Args, E);
 
 %% Super

lib/elixir/src/elixir_module.erl

@@ -112,7 +112,7 @@ build(Line, File, Module, Lexical) ->
   end,
 
   Attributes = [behaviour, on_load, spec, type, export_type, opaque, callback, compile],
-  ets:insert(DataTable, {?acc_attr, [before_compile, after_compile, on_definition|Attributes]}),
+  ets:insert(DataTable, {?acc_attr, [before_compile, after_compile, on_definition, derive|Attributes]}),
   ets:insert(DataTable, {?persisted_attr, [vsn|Attributes]}),
   ets:insert(DataTable, {?docs_attr, ets:new(DataTable, [ordered_set, public])}),
   ets:insert(DataTable, {?lexical_attr, Lexical}),
@@ -128,7 +128,7 @@ build(Line, File, Module, Lexical) ->
 eval_form(Line, Module, Block, Vars, E) ->
   {Value, EE} = elixir_compiler:eval_forms(Block, Vars, E),
   elixir_def_overridable:store_pending(Module),
-  EV = elixir_env:linify({Line, EE#{vars := []}}),
+  EV = elixir_env:linify({Line, EE#{vars := [], export_vars := nil}}),
   EC = eval_callbacks(Line, Module, before_compile, [EV], EV),
   elixir_def_overridable:store_pending(Module),
   {Value, EC}.
@@ -137,7 +137,8 @@ eval_callbacks(Line, Module, Name, Args, E) ->
   Callbacks = lists:reverse(ets:lookup_element(data_table(Module), Name, 2)),
 
   lists:foldl(fun({M,F}, Acc) ->
-    expand_callback(Line, M, F, Args, Acc#{vars := []}, fun(AM, AF, AA) -> apply(AM, AF, AA) end)
+    expand_callback(Line, M, F, Args, Acc#{vars := [], export_vars := nil},
+                    fun(AM, AF, AA) -> apply(AM, AF, AA) end)
   end, E, Callbacks).
 
 %% Return the form with exports and function declarations.

lib/elixir/src/elixir_translator.erl

@@ -129,7 +129,7 @@ translate({'receive', Meta, [KV]}, #elixir_scope{return=Return} = RS) when is_li
 
 %% Comprehensions
 
-translate({for, Meta, Args}, S) when is_list(Args) ->
+translate({for, Meta, [_|_] = Args}, S) ->
   elixir_for:translate(Meta, Args, S);
 
 %% Super

lib/elixir/test/elixir/protocol_test.exs

@@ -21,11 +21,11 @@ defmodule ProtocolTest do
   end
 
   defimpl Derivable, for: Map do
-    defmacro __deriving__(_env, struct) do
+    defmacro __deriving__(module, struct, options) do
       quote do
-        defimpl Derivable do
+        defimpl Derivable, for: unquote(module) do
           def ok(arg) do
-            {:ok, arg, unquote(Macro.escape(struct))}
+            {:ok, arg, unquote(Macro.escape(struct)), unquote(options)}
           end
         end
       end
@@ -176,17 +176,42 @@ defmodule ProtocolTest do
 
   test "custom derive implementation" do
     struct = %ImplStruct{a: 1, b: 1}
-    assert Derivable.ok(struct) == {:ok, struct, %ImplStruct{}}
+    assert Derivable.ok(struct) == {:ok, struct, %ImplStruct{}, []}
 
     struct = %ImplStruct{a: 1, b: 1}
-    assert Derivable.ok(struct) == {:ok, struct, %ImplStruct{}}
+    assert Derivable.ok(struct) == {:ok, struct, %ImplStruct{}, []}
 
     assert_raise Protocol.UndefinedError, fn ->
       struct = %NoImplStruct{a: 1, b: 1}
       Derivable.ok(struct)
     end
   end
 
+  test "custom derive implementation with options" do
+    defmodule AnotherStruct do
+      @derive [{Derivable, :ok}]
+      @derive [WithAny]
+      defstruct a: 0, b: 0
+    end
+
+    struct = struct AnotherStruct, a: 1, b: 1
+    assert Derivable.ok(struct) ==
+           {:ok, struct, struct(AnotherStruct), :ok}
+  end
+
+  test "custom derive implementation via API" do
+    defmodule InlineStruct do
+      defstruct a: 0, b: 0
+    end
+
+    require Protocol
+    assert Protocol.derive(Derivable, InlineStruct, :oops) == :ok
+
+    struct = struct InlineStruct, a: 1, b: 1
+    assert Derivable.ok(struct) ==
+           {:ok, struct, struct(InlineStruct), :oops}
+  end
+
   test "cannot derive without a map implementation" do
     assert_raise ArgumentError,
         ~r"#{inspect Sample.Map} is not available, cannot derive #{inspect Sample}", fn ->