Unit tests

Author: josevalim

lib/elixir/lib/protocol.ex

@@ -612,9 +612,9 @@ defmodule Protocol do
         protocol_def = change_protocol(protocol_def, types)
         impl_for = change_impl_for(impl_for, protocol, types)
         struct_impl_for = change_struct_impl_for(struct_impl_for, protocol, types, structs)
-        definitions = [protocol_def, impl_for, impl_for!, struct_impl_for] ++ definitions
+        new_signatures = new_signatures(definitions, protocol, types)
 
-        new_signatures = new_signatures(definitions, protocol, types, structs)
+        definitions = [protocol_def, impl_for, impl_for!, struct_impl_for] ++ definitions
         signatures = Enum.into(new_signatures, signatures)
         {:ok, definitions, signatures}
 
@@ -623,34 +623,41 @@ defmodule Protocol do
     end
   end
 
-  defp new_signatures(definitions, protocol, types, structs) do
+  defp new_signatures(definitions, protocol, types) do
     alias Module.Types.Descr
 
     clauses =
-      Enum.map(structs ++ List.delete(types, Any), fn impl ->
+      types
+      |> List.delete(Any)
+      |> Enum.map(fn impl ->
         {[Module.Types.Of.impl(impl)], Descr.atom([Module.concat(protocol, impl)])}
       end)
 
-    # TODO: Test a protocol with no implementation
-    domain =
+    {domain, impl_for, impl_for!} =
       case clauses do
         [] ->
-          Descr.none()
+          if Any in types do
+            clauses = [{[Descr.term()], Descr.atom([Module.concat(protocol, Any)])}]
+            {Descr.none(), clauses, clauses}
+          else
+            {Descr.none(), [{[Descr.term()], Descr.atom([nil])}],
+             [{[Descr.none()], Descr.none()}]}
+          end
 
         _ ->
-          clauses
-          |> Enum.map(fn {[domain], _} -> domain end)
-          |> Enum.reduce(&Descr.union/2)
-      end
-
-    not_domain = Descr.negation(domain)
-
-    {domain, impl_for, impl_for!} =
-      if Any in types do
-        clauses = clauses ++ [{[not_domain], Descr.atom([Module.concat(protocol, Any)])}]
-        {Descr.term(), clauses, clauses}
-      else
-        {domain, clauses ++ [{[not_domain], Descr.atom([nil])}], clauses}
+          domain =
+            clauses
+            |> Enum.map(fn {[domain], _} -> domain end)
+            |> Enum.reduce(&Descr.union/2)
+
+          not_domain = Descr.negation(domain)
+
+          if Any in types do
+            clauses = clauses ++ [{[not_domain], Descr.atom([Module.concat(protocol, Any)])}]
+            {Descr.term(), clauses, clauses}
+          else
+            {domain, clauses ++ [{[not_domain], Descr.atom([nil])}], clauses}
+          end
       end
 
     new_signatures =

lib/elixir/test/elixir/fixtures/consolidation/no_impl.ex

@@ -0,0 +1,3 @@
+defprotocol Protocol.ConsolidationTest.NoImpl do
+  def ok(term)
+end

lib/elixir/test/elixir/fixtures/consolidation/with_any.ex

@@ -1,5 +1,5 @@
 defprotocol Protocol.ConsolidationTest.WithAny do
   @fallback_to_any true
   @doc "Ok"
-  def ok(term)
+  def ok(term, opts)
 end

lib/elixir/test/elixir/protocol/consolidation_test.exs

@@ -8,16 +8,16 @@ Kernel.ParallelCompiler.compile_to_path(files, path, return_diagnostics: true)
 
 defmodule Protocol.ConsolidationTest do
   use ExUnit.Case, async: true
-  alias Protocol.ConsolidationTest.{Sample, WithAny}
+  alias Protocol.ConsolidationTest.{Sample, WithAny, NoImpl}
 
   defimpl WithAny, for: Map do
-    def ok(map) do
+    def ok(map, _opts) do
       {:ok, map}
     end
   end
 
   defimpl WithAny, for: Any do
-    def ok(any) do
+    def ok(any, _opts) do
       {:ok, any}
     end
   end
@@ -47,14 +47,24 @@ defmodule Protocol.ConsolidationTest do
   {:ok, binary} = Protocol.consolidate(Sample, [Any, ImplStruct])
   :code.load_binary(Sample, ~c"protocol_test.exs", binary)
 
-  @sample_binary binary
+  defp sample_binary, do: unquote(binary)
 
   # Any should be moved to the end
   :code.purge(WithAny)
   :code.delete(WithAny)
   {:ok, binary} = Protocol.consolidate(WithAny, [Any, ImplStruct, Map])
   :code.load_binary(WithAny, ~c"protocol_test.exs", binary)
 
+  defp with_any_binary, do: unquote(binary)
+
+  # No Any
+  :code.purge(NoImpl)
+  :code.delete(NoImpl)
+  {:ok, binary} = Protocol.consolidate(NoImpl, [])
+  :code.load_binary(NoImpl, ~c"protocol_test.exs", binary)
+
+  defp no_impl_binary, do: unquote(binary)
+
   test "consolidated?/1" do
     assert Protocol.consolidated?(WithAny)
     refute Protocol.consolidated?(Enumerable)
@@ -64,7 +74,7 @@ defmodule Protocol.ConsolidationTest do
     output =
       ExUnit.CaptureIO.capture_io(:stderr, fn ->
         defimpl WithAny, for: Integer do
-          def ok(_any), do: :ok
+          def ok(_any, _opts), do: :ok
         end
       end)
 
@@ -86,7 +96,7 @@ defmodule Protocol.ConsolidationTest do
     :code.delete(WithAny.Integer)
   end
 
-  test "consolidated implementations without any" do
+  test "consolidated implementations without fallback to any" do
     assert is_nil(Sample.impl_for(:foo))
     assert is_nil(Sample.impl_for(fn x -> x end))
     assert is_nil(Sample.impl_for(1))
@@ -106,8 +116,9 @@ defmodule Protocol.ConsolidationTest do
     assert Sample.impl_for(%NoImplStruct{}) == nil
   end
 
-  test "consolidated implementations with any and tuple fallback" do
+  test "consolidated implementations with fallback to any" do
     assert WithAny.impl_for(%NoImplStruct{}) == WithAny.Any
+
     # Derived
     assert WithAny.impl_for(%ImplStruct{}) ==
              Protocol.ConsolidationTest.WithAny.Protocol.ConsolidationTest.ImplStruct
@@ -118,66 +129,120 @@ defmodule Protocol.ConsolidationTest do
   end
 
   test "consolidation keeps docs" do
-    {:ok, {Sample, [{~c"Docs", docs_bin}]}} = :beam_lib.chunks(@sample_binary, [~c"Docs"])
+    {:ok, {Sample, [{~c"Docs", docs_bin}]}} = :beam_lib.chunks(sample_binary(), [~c"Docs"])
     {:docs_v1, _, _, _, _, _, docs} = :erlang.binary_to_term(docs_bin)
     ok_doc = List.keyfind(docs, {:function, :ok, 1}, 0)
 
     assert {{:function, :ok, 1}, _, ["ok(term)"], %{"en" => "Ok"}, _} = ok_doc
   end
 
-  test "consolidation keeps chunks" do
-    deprecated = [{{:ok, 1}, "Reason"}]
-    assert deprecated == Sample.__info__(:deprecated)
-
-    {:ok, {Sample, [{~c"ExCk", check_bin}]}} = :beam_lib.chunks(@sample_binary, [~c"ExCk"])
-    assert {:elixir_checker_v1, contents} = :erlang.binary_to_term(check_bin)
-    assert %{{:ok, 1} => %{deprecated: "Reason", sig: _}} = Map.new(contents.exports)
-  end
-
   @tag :requires_source
   test "consolidation keeps source" do
     assert Sample.__info__(:compile)[:source]
   end
 
   test "consolidated keeps callbacks" do
-    {:ok, callbacks} = Code.Typespec.fetch_callbacks(@sample_binary)
+    {:ok, callbacks} = Code.Typespec.fetch_callbacks(sample_binary())
     assert callbacks != []
   end
 
-  test "consolidation errors on missing BEAM files" do
-    defprotocol NoBeam do
-      def example(arg)
-    end
-
-    assert Protocol.consolidate(String, []) == {:error, :not_a_protocol}
-    assert Protocol.consolidate(NoBeam, []) == {:error, :no_beam_info}
-  end
-
   test "consolidation updates attributes" do
     assert Sample.__protocol__(:consolidated?)
     assert Sample.__protocol__(:impls) == {:consolidated, [ImplStruct]}
     assert WithAny.__protocol__(:consolidated?)
     assert WithAny.__protocol__(:impls) == {:consolidated, [Any, Map, ImplStruct]}
+    assert NoImpl.__protocol__(:consolidated?)
+    assert NoImpl.__protocol__(:impls) == {:consolidated, []}
   end
 
-  test "consolidation extracts protocols" do
-    protos = Protocol.extract_protocols([Application.app_dir(:elixir, "ebin")])
-    assert Enumerable in protos
-    assert Inspect in protos
-  end
+  describe "exports" do
+    import Module.Types.Descr
+    alias Module.Types.Of
+
+    defp exports(binary) do
+      {:ok, {_, [{~c"ExCk", check_bin}]}} = :beam_lib.chunks(binary, [~c"ExCk"])
+      assert {:elixir_checker_v1, contents} = :erlang.binary_to_term(check_bin)
+      Map.new(contents.exports)
+    end
+
+    test "keeps deprecations" do
+      deprecated = [{{:ok, 1}, "Reason"}]
+      assert deprecated == Sample.__info__(:deprecated)
+
+      assert %{{:ok, 1} => %{deprecated: "Reason", sig: _}} = exports(sample_binary())
+    end
+
+    test "defines signatures without fallback to any" do
+      exports = exports(sample_binary())
+
+      assert %{{:impl_for, 1} => %{sig: {:strong, domain, clauses}}} = exports
+      assert domain == [term()]
+
+      assert clauses == [
+               {[Of.impl(ImplStruct)], atom([Sample.Protocol.ConsolidationTest.ImplStruct])},
+               {[negation(Of.impl(ImplStruct))], atom([nil])}
+             ]
 
-  test "consolidation extracts implementations with charlist path" do
-    protos =
-      Protocol.extract_impls(Enumerable, [to_charlist(Application.app_dir(:elixir, "ebin"))])
+      assert %{{:impl_for!, 1} => %{sig: {:strong, domain, clauses}}} = exports
+      assert domain == [Of.impl(ImplStruct)]
 
-    assert List in protos
-    assert Function in protos
+      assert clauses == [
+               {[Of.impl(ImplStruct)], atom([Sample.Protocol.ConsolidationTest.ImplStruct])}
+             ]
+
+      assert %{{:ok, 1} => %{sig: {:strong, nil, clauses}}} = exports
+
+      assert clauses == [
+               {[Of.impl(ImplStruct)], dynamic()}
+             ]
+    end
+
+    test "defines signatures with fallback to any" do
+      exports = exports(with_any_binary())
+
+      assert %{
+               {:impl_for, 1} => %{sig: {:strong, domain, clauses}},
+               {:impl_for!, 1} => %{sig: {:strong, domain, clauses}}
+             } = exports
+
+      assert domain == [term()]
+
+      assert clauses == [
+               {[Of.impl(Map)], atom([WithAny.Map])},
+               {[Of.impl(ImplStruct)], atom([WithAny.Protocol.ConsolidationTest.ImplStruct])},
+               {[negation(union(Of.impl(ImplStruct), Of.impl(Map)))], atom([WithAny.Any])}
+             ]
+
+      assert %{{:ok, 2} => %{sig: {:strong, nil, clauses}}} = exports
+
+      assert clauses == [
+               {[term(), term()], dynamic()}
+             ]
+    end
+
+    test "defines signatures without implementation" do
+      exports = exports(no_impl_binary())
+
+      assert %{{:impl_for, 1} => %{sig: {:strong, domain, clauses}}} = exports
+      assert domain == [term()]
+      assert clauses == [{[term()], atom([nil])}]
+
+      assert %{{:impl_for!, 1} => %{sig: {:strong, domain, clauses}}} = exports
+      assert domain == [none()]
+      assert clauses == [{[none()], none()}]
+
+      assert %{{:ok, 1} => %{sig: {:strong, nil, clauses}}} = exports
+      assert clauses == [{[none()], dynamic()}]
+    end
   end
 
-  test "consolidation extracts implementations with binary path" do
-    protos = Protocol.extract_impls(Enumerable, [Application.app_dir(:elixir, "ebin")])
-    assert List in protos
-    assert Function in protos
+  test "consolidation errors on missing BEAM files" do
+    defprotocol NoBeam do
+      def example(arg)
+    end
+
+    assert Protocol.consolidate(String, []) == {:error, :not_a_protocol}
+    assert Protocol.consolidate(NoBeam, []) == {:error, :no_beam_info}
   end
 
   test "protocol not implemented" do
@@ -191,4 +256,26 @@ defmodule Protocol.ConsolidationTest do
       sample.ok(:foo)
     end
   end
+
+  describe "extraction" do
+    test "protocols" do
+      protos = Protocol.extract_protocols([Application.app_dir(:elixir, "ebin")])
+      assert Enumerable in protos
+      assert Inspect in protos
+    end
+
+    test "implementations with charlist path" do
+      protos =
+        Protocol.extract_impls(Enumerable, [to_charlist(Application.app_dir(:elixir, "ebin"))])
+
+      assert List in protos
+      assert Function in protos
+    end
+
+    test "implementations with binary path" do
+      protos = Protocol.extract_impls(Enumerable, [Application.app_dir(:elixir, "ebin")])
+      assert List in protos
+      assert Function in protos
+    end
+  end
 end