Add support for the @optional_callbacks behaviour attribute (#4705)

Author: whatyouhide

lib/elixir/lib/kernel.ex

@@ -2381,13 +2381,14 @@ defmodule Kernel do
     raise ArgumentError, "expected 0 or 1 argument for @#{name}, got: #{length(args)}"
   end
 
-  defp typespec(:type),          do: :deftype
-  defp typespec(:typep),         do: :deftypep
-  defp typespec(:opaque),        do: :defopaque
-  defp typespec(:spec),          do: :defspec
-  defp typespec(:callback),      do: :defcallback
-  defp typespec(:macrocallback), do: :defmacrocallback
-  defp typespec(_),              do: false
+  defp typespec(:type),               do: :deftype
+  defp typespec(:typep),              do: :deftypep
+  defp typespec(:opaque),             do: :defopaque
+  defp typespec(:spec),               do: :defspec
+  defp typespec(:callback),           do: :defcallback
+  defp typespec(:macrocallback),      do: :defmacrocallback
+  defp typespec(:optional_callbacks), do: :defoptional_callbacks
+  defp typespec(_),                   do: false
 
   @doc """
   Returns the binding for the given context as a keyword list.

lib/elixir/lib/kernel/typespec.ex

@@ -92,6 +92,12 @@ defmodule Kernel.Typespec do
     end
   end
 
+  defmacro defoptional_callbacks(callbacks) do
+    quote do
+      Module.store_typespec(__ENV__.module, :optional_callbacks, {__ENV__.line, unquote(callbacks)})
+    end
+  end
+
   @doc """
   Defines a `type`, `typep` or `opaque` by receiving a typespec expression.
   """

lib/elixir/lib/module.ex

@@ -1105,8 +1105,8 @@ defmodule Module do
   defp preprocess_attribute(:on_definition, atom) when is_atom(atom),
     do: {atom, :__on_definition__}
 
-  defp preprocess_attribute(key, _value) when key in [:type, :typep, :export_type, :opaque, :callback, :macrocallback] do
-    raise ArgumentError, "attributes type, typep, export_type, opaque, callback and macrocallback " <>
+  defp preprocess_attribute(key, _value) when key in [:type, :typep, :export_type, :opaque, :callback, :macrocallback, :optional_callbacks] do
+    raise ArgumentError, "attributes type, typep, export_type, opaque, callback, macrocallback, and optional_callbacks " <>
       "must be set directly via the @ notation"
   end
 

lib/elixir/src/elixir_module.erl

@@ -159,7 +159,8 @@ build(Line, File, Module, Docs, Lexical) ->
 
   Attributes = [behaviour, on_load, compile, external_resource, dialyzer],
   ets:insert(Data, {?acc_attr, [before_compile, after_compile, on_definition, derive,
-                                spec, type, typep, opaque, callback, macrocallback | Attributes]}),
+                                spec, type, typep, opaque, callback, macrocallback,
+                                optional_callbacks | Attributes]}),
   ets:insert(Data, {?persisted_attr, [vsn | Attributes]}),
   ets:insert(Data, {?lexical_attr, Lexical}),
 
@@ -285,7 +286,8 @@ specs_form(Data, Defmacro, Defmacrop, Unreachable, Forms) ->
       Specs3 = lists:filter(fun({{_Kind, NameArity, _Spec}, _Line}) ->
                                 not lists:member(NameArity, Unreachable)
                             end, Specs2),
-      specs_attributes(Forms, Specs3);
+      optional_callbacks_attributes(get_typespec(Data, optional_callbacks), Specs3) ++
+        specs_attributes(Forms, Specs3);
     true ->
       Forms
   end.
@@ -322,6 +324,22 @@ spec_for_macro({type, Line, 'fun', [{type, _, product, Args} | T]}) ->
 
 spec_for_macro(Else) -> Else.
 
+optional_callbacks_attributes(OptionalCallbacksTypespec, Specs) ->
+  % We only take the specs of the callbacks (which are both callbacks and
+  % macrocallbacks).
+  Callbacks = [NameArity || {{callback, NameArity, _Spec}, _Line} <- Specs],
+  [{attribute, Line, optional_callbacks, macroify_callback_names(NamesArities, Callbacks)} ||
+    {Line, NamesArities} <- OptionalCallbacksTypespec].
+
+macroify_callback_names(NamesArities, Callbacks) ->
+  lists:map(fun({Name, Arity} = NameArity) ->
+                MacroNameArity = {elixir_utils:macro_name(Name), Arity + 1},
+                case lists:member(MacroNameArity, Callbacks) of
+                  true -> MacroNameArity;
+                  false -> NameArity
+                end
+            end, NamesArities).
+
 %% Loads the form into the code server.
 
 compile_opts(Module) ->

lib/elixir/test/elixir/kernel/typespec_test.exs

@@ -659,11 +659,18 @@ defmodule Kernel.TypespecTest do
     @callback orr(atom | integer) :: atom
     @callback literal(123, {atom}, :atom, [integer], true) :: atom
     @macrocallback last(integer) :: Macro.t
+    @macrocallback lastlast() :: atom
+    @optional_callbacks bar: 2, lastlast: 0
   end
 
   test "callbacks" do
     assert Sample.behaviour_info(:callbacks) ==
-           [first: 1, guarded: 1, "MACRO-last": 2, literal: 5, orr: 1, foo: 2, bar: 2]
+           ["MACRO-lastlast": 1, first: 1, guarded: 1, "MACRO-last": 2, literal: 5, orr: 1, foo: 2, bar: 2]
+  end
+
+  test "optional callbacks" do
+    assert Sample.behaviour_info(:optional_callbacks) ==
+           [bar: 2, "MACRO-lastlast": 1]
   end
 
   test "default is not supported" do