Avoid compile warnings when implementing an empty protocol

Implementing a protocol creates a module that implements the
behaviour given by the protocol. A protocol that defines no
functions by extension defines no callbacks, and so won't be
recognized as a behaviour by the Erlang compiler. This means
that Elixir will log a warning when implementing such a protocol,
because behaviour_info/1 won't be defined on it, and so Elixir
also won't recognize it as a behaviour.

Erlang offers no mechanism to explicitly denote a module as
defining a behaviour, but in this case we know that every protocol
implementation must define an impl/1 function. By adding a callback
that describes this function to all protocols, the warning can be
avoided.

Author: QuinnWilton

lib/elixir/lib/protocol.ex

@@ -763,8 +763,8 @@ defmodule Protocol do
     IO.warn(message, stacktrace)
   end
 
-  # TODO: Convert the following warnings into errors in future Elixir versions
-  def __before_compile__(env) do
+  # TODO: Convert the following warnings into errors future in Elixir versions
+  defmacro __before_compile__(env) do
     # Callbacks
     callback_metas = callback_metas(env.module, :callback)
     callbacks = :maps.keys(callback_metas)
@@ -806,6 +806,16 @@ defmodule Protocol do
         nil
       )
     end
+
+    quote do
+      # Register the __impl__/1 callback to ensure the protocol is a behaviour
+      # Without this, a protocol that defines no functions won't be detected
+      # as a behaviour by the Erlang compiler, and any implementations of that
+      # protocol will log a warning.
+      @callback __impl__(:foo) :: module()
+      @callback __impl__(:target) :: module()
+      @callback __impl__(:protocol) :: module()
+    end
   end
 
   defp after_defprotocol do

lib/elixir/test/elixir/protocol_test.exs

@@ -3,6 +3,10 @@ Code.require_file("test_helper.exs", __DIR__)
 defmodule ProtocolTest do
   use ExUnit.Case, async: true
 
+  defp capture_err(fun) do
+    ExUnit.CaptureIO.capture_io(:stderr, fun)
+  end
+
   doctest Protocol
 
   {_, _, sample_binary, _} =
@@ -143,11 +147,23 @@ defmodule ProtocolTest do
   end
 
   test "protocol defines callbacks" do
-    assert [{:type, 13, :fun, args}] = get_callbacks(@sample_binary, :ok, 1)
-    assert args == [{:type, 13, :product, [{:user_type, 13, :t, []}]}, {:type, 13, :boolean, []}]
+    assert [{:type, 17, :fun, args}] = get_callbacks(@sample_binary, :ok, 1)
+    assert args == [{:type, 17, :product, [{:user_type, 17, :t, []}]}, {:type, 17, :boolean, []}]
+
+    assert [{:type, 27, :fun, args}] = get_callbacks(@with_any_binary, :ok, 1)
+    assert args == [{:type, 27, :product, [{:user_type, 27, :t, []}]}, {:type, 27, :term, []}]
+  end
+
+  test "protocol with no functions is a behaviour" do
+    refute capture_err(fn ->
+             Code.eval_string("""
+             defprotocol ProtoNoFunctions do
+             end
 
-    assert [{:type, 23, :fun, args}] = get_callbacks(@with_any_binary, :ok, 1)
-    assert args == [{:type, 23, :product, [{:user_type, 23, :t, []}]}, {:type, 23, :term, []}]
+             defimpl ProtoNoFunctions, for: Integer do
+             end
+             """)
+           end) =~ "module ProtoNoFunctions is not a behaviour"
   end
 
   test "protocol defines functions and attributes" do