Type check protocol dispatch

Author: josevalim

lib/elixir/lib/kernel.ex

@@ -3409,7 +3409,7 @@ defmodule Kernel do
 
   """
   defmacro to_charlist(term) do
-    quote(do: List.Chars.to_charlist(unquote(term)))
+    quote(do: :"Elixir.List.Chars".to_charlist(unquote(term)))
   end
 
   @doc """
@@ -4149,7 +4149,7 @@ defmodule Kernel do
   defp range(context, first, last, step)
        when is_integer(first) and is_integer(last) and is_integer(step)
        when context != nil do
-    {:%{}, [], [__struct__: Elixir.Range, first: first, last: last, step: step]}
+    {:%, [], [Elixir.Range, {:%{}, [], [first: first, last: last, step: step]}]}
   end
 
   defp range(nil, first, last, step) do

lib/elixir/lib/module/types.ex

@@ -145,7 +145,7 @@ defmodule Module.Types do
   defp default_domain({_, arity} = fun_arity, impl) do
     with {for, callbacks} <- impl,
          true <- fun_arity in callbacks do
-      [Module.Types.Of.impl(for) | List.duplicate(Descr.dynamic(), arity - 1)]
+      [Descr.dynamic(Module.Types.Of.impl(for)) | List.duplicate(Descr.dynamic(), arity - 1)]
     else
       _ -> List.duplicate(Descr.dynamic(), arity)
     end

lib/elixir/lib/module/types/apply.ex

@@ -566,11 +566,21 @@ defmodule Module.Types.Apply do
     is_map_key(builtin_modules(), module)
   end
 
+  @builtin_protocols [
+    Collectable,
+    Enumerable,
+    IEx.Info,
+    Inspect,
+    JSON.Encoder,
+    List.Chars,
+    String.Chars
+  ]
+
   defp builtin_modules do
     case :persistent_term.get(__MODULE__, nil) do
       nil ->
         {:ok, mods} = :application.get_key(:elixir, :modules)
-        mods = Map.from_keys(mods, [])
+        mods = Map.from_keys(mods -- @builtin_protocols, [])
         :persistent_term.put(__MODULE__, mods)
         mods
 
@@ -791,7 +801,7 @@ defmodule Module.Types.Apply do
       empty_arg_reason(args_types) ||
         """
         but expected one of:
-        #{clauses_args_to_quoted_string(clauses, converter)}
+        #{clauses_args_to_quoted_string(clauses, converter, [])}
         """
 
     %{
@@ -817,23 +827,37 @@ defmodule Module.Types.Apply do
   def format_diagnostic({:badremote, mfac, expr, args_types, domain, clauses, context}) do
     traces = collect_traces(expr, context)
     {mod, fun, arity, converter} = mfac
+    meta = elem(expr, 1)
+
+    mfa_or_fa = if mod, do: Exception.format_mfa(mod, fun, arity), else: "#{fun}/#{arity}"
+
+    # Protocol errors can be very verbose, so we collapse structs
+    {caller, hints, opts} =
+      cond do
+        meta[:from_interpolation] ->
+          {"string interpolation", [:interpolation], [collapse_structs: true]}
+
+        Code.ensure_loaded?(mod) and
+            Keyword.has_key?(mod.module_info(:attributes), :__protocol__) ->
+          {mfa_or_fa, [{:protocol, mod}], [collapse_structs: true]}
+
+        true ->
+          {mfa_or_fa, [], []}
+      end
 
     explanation =
       empty_arg_reason(converter.(args_types)) ||
         """
         but expected one of:
-        #{clauses_args_to_quoted_string(clauses, converter)}
+        #{clauses_args_to_quoted_string(clauses, converter, opts)}
         """
 
-    mfa_or_fa =
-      if mod, do: Exception.format_mfa(mod, fun, arity), else: "#{fun}/#{arity}"
-
     %{
       details: %{typing_traces: traces},
       message:
         IO.iodata_to_binary([
           """
-          incompatible types given to #{mfa_or_fa}:
+          incompatible types given to #{caller}:
 
               #{expr_to_string(expr) |> indent(4)}
 
@@ -843,7 +867,8 @@ defmodule Module.Types.Apply do
 
           """,
           explanation,
-          format_traces(traces)
+          format_traces(traces),
+          format_hints(hints)
         ])
     }
   end
@@ -998,25 +1023,25 @@ defmodule Module.Types.Apply do
     |> IO.iodata_to_binary()
   end
 
-  defp clauses_args_to_quoted_string([{args, _return}], converter) do
-    "\n    " <> (clause_args_to_quoted_string(args, converter) |> indent(4))
+  defp clauses_args_to_quoted_string([{args, _return}], converter, opts) do
+    "\n    " <> (clause_args_to_quoted_string(args, converter, opts) |> indent(4))
   end
 
-  defp clauses_args_to_quoted_string(clauses, converter) do
+  defp clauses_args_to_quoted_string(clauses, converter, opts) do
     clauses
     |> Enum.with_index(fn {args, _return}, index ->
       """
 
       ##{index + 1}
-      #{clause_args_to_quoted_string(args, converter)}\
+      #{clause_args_to_quoted_string(args, converter, opts)}\
       """
       |> indent(4)
     end)
     |> Enum.join("\n")
   end
 
-  defp clause_args_to_quoted_string(args, converter) do
-    docs = Enum.map(args, &(&1 |> to_quoted() |> Code.Formatter.to_algebra()))
+  defp clause_args_to_quoted_string(args, converter, opts) do
+    docs = Enum.map(args, &(&1 |> to_quoted(opts) |> Code.Formatter.to_algebra()))
     args_docs_to_quoted_string(converter.(docs))
   end
 

lib/elixir/lib/module/types/helpers.ex

@@ -70,6 +70,21 @@ defmodule Module.Types.Helpers do
         "var.fun()" (with parentheses) means "var" is an atom()
         """
 
+      :interpolation ->
+        """
+
+        #{hint()} string interpolation in Elixir use the String.Chars protocol to \
+        convert a data structure into a string. Either convert the data type into a \
+        string upfront or implement the protocol accordingly
+        """
+
+      {:protocol, protocol} ->
+        """
+
+        #{hint()} #{inspect(protocol)} is a protocol in Elixir. Either make sure you \
+        give valid data types as argument or implement the protocol accordingly
+        """
+
       :anonymous_rescue ->
         """
 

lib/elixir/lib/module/types/of.ex

@@ -89,17 +89,14 @@ defmodule Module.Types.Of do
 
   ## Implementations
 
-  # Right now we are still defaulting all implementations to their dynamic variations.
-  # TODO: What should the default types be once we have typed protocols?
-
   impls = [
     {Atom, atom()},
     {BitString, binary()},
     {Float, float()},
     {Function, fun()},
     {Integer, integer()},
     {List, list(term())},
-    {Map, open_map()},
+    {Map, open_map(__struct__: not_set())},
     {Port, port()},
     {PID, pid()},
     {Reference, reference()},
@@ -108,16 +105,16 @@ defmodule Module.Types.Of do
   ]
 
   for {for, type} <- impls do
-    def impl(unquote(for)), do: unquote(Macro.escape(dynamic(type)))
+    def impl(unquote(for)), do: unquote(Macro.escape(type))
   end
 
   def impl(struct) do
     # Elixir did not strictly require the implementation to be available, so we need a fallback.
     # TODO: Assume implementation is available on Elixir v2.0.
     if info = Code.ensure_loaded?(struct) && struct.__info__(:struct) do
-      dynamic(struct_type(struct, info))
+      struct_type(struct, info)
     else
-      dynamic(open_map(__struct__: atom([struct])))
+      open_map(__struct__: atom([struct]))
     end
   end
 
@@ -330,13 +327,25 @@ defmodule Module.Types.Of do
           Module.Types.Pattern.of_guard(left, type, expr, stack, context)
 
         :expr ->
+          left = annotate_interpolation(left, right)
           {actual, context} = Module.Types.Expr.of_expr(left, stack, context)
           intersect(actual, type, expr, stack, context)
       end
 
     specifier_size(kind, right, stack, context)
   end
 
+  defp annotate_interpolation(
+         {{:., _, [String.Chars, :to_string]} = dot, meta, [arg]},
+         {:binary, _, nil}
+       ) do
+    {dot, [from_interpolation: true] ++ meta, [arg]}
+  end
+
+  defp annotate_interpolation(left, _right) do
+    left
+  end
+
   defp specifier_type(kind, {:-, _, [left, _right]}), do: specifier_type(kind, left)
   defp specifier_type(:match, {:utf8, _, _}), do: @integer
   defp specifier_type(:match, {:utf16, _, _}), do: @integer

lib/elixir/lib/protocol.ex

@@ -560,25 +560,26 @@ defmodule Protocol do
     # Ensure the types are sorted so the compiled beam is deterministic
     types = Enum.sort(types)
 
-    with {:ok, ast_info, specs, compile_info} <- beam_protocol(protocol),
-         {:ok, definitions} <- change_debug_info(protocol, ast_info, types),
-         do: compile(definitions, specs, compile_info)
+    with {:ok, any, definitions, signatures, compile_info} <- beam_protocol(protocol),
+         {:ok, definitions, signatures} <-
+           consolidate(protocol, any, definitions, signatures, types),
+         do: compile(definitions, signatures, compile_info)
   end
 
   defp beam_protocol(protocol) do
-    chunk_ids = [:debug_info, [?D, ?o, ?c, ?s], [?E, ?x, ?C, ?k]]
+    chunk_ids = [:debug_info, [?D, ?o, ?c, ?s]]
     opts = [:allow_missing_chunks]
 
     case :beam_lib.chunks(beam_file(protocol), chunk_ids, opts) do
       {:ok, {^protocol, [{:debug_info, debug_info} | chunks]}} ->
-        {:debug_info_v1, _backend, {:elixir_v1, info, specs}} = debug_info
-        %{attributes: attributes, definitions: definitions} = info
+        {:debug_info_v1, _backend, {:elixir_v1, module_map, specs}} = debug_info
+        %{attributes: attributes, definitions: definitions, signatures: signatures} = module_map
         chunks = :lists.filter(fn {_name, value} -> value != :missing_chunk end, chunks)
         chunks = :lists.map(fn {name, value} -> {List.to_string(name), value} end, chunks)
 
         case attributes[:__protocol__] do
           [fallback_to_any: any] ->
-            {:ok, {any, definitions}, specs, {info, chunks}}
+            {:ok, any, definitions, signatures, {module_map, specs, chunks}}
 
           _ ->
             {:error, :not_a_protocol}
@@ -596,29 +597,67 @@ defmodule Protocol do
     end
   end
 
-  # Change the debug information to the optimized
-  # impl_for/1 dispatch version.
-  defp change_debug_info(protocol, {any, definitions}, types) do
-    types = if any, do: types, else: List.delete(types, Any)
-    all = [Any] ++ for {mod, _guard} <- built_in(), do: mod
-    structs = types -- all
-
+  # Consolidate the protocol for faster implementations and fine-grained type information.
+  defp consolidate(protocol, fallback_to_any?, definitions, signatures, types) do
     case List.keytake(definitions, {:__protocol__, 1}, 0) do
       {protocol_def, definitions} ->
+        types = if fallback_to_any?, do: types, else: List.delete(types, Any)
+        built_in_plus_any = [Any] ++ for {mod, _guard} <- built_in(), do: mod
+        structs = types -- built_in_plus_any
+
         {impl_for, definitions} = List.keytake(definitions, {:impl_for, 1}, 0)
+        {impl_for!, definitions} = List.keytake(definitions, {:impl_for!, 1}, 0)
         {struct_impl_for, definitions} = List.keytake(definitions, {:struct_impl_for, 1}, 0)
 
         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
 
-        {:ok, [protocol_def, impl_for, struct_impl_for] ++ definitions}
+        new_signatures = new_signatures(definitions, protocol, types, structs)
+        signatures = Enum.into(new_signatures, signatures)
+        {:ok, definitions, signatures}
 
       nil ->
         {:error, :not_a_protocol}
     end
   end
 
+  defp new_signatures(definitions, protocol, types, structs) do
+    alias Module.Types.Descr
+
+    clauses =
+      Enum.map(structs ++ List.delete(types, Any), fn impl ->
+        {[Module.Types.Of.impl(impl)], Descr.atom([Module.concat(protocol, impl)])}
+      end)
+
+    domain =
+      clauses
+      |> Enum.map(fn {[domain], _} -> domain end)
+      |> Enum.reduce(&Descr.union/2)
+
+    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}
+      end
+
+    new_signatures =
+      for {{fun, arity}, :def, _, _} <- definitions do
+        rest = List.duplicate(Descr.term(), arity - 1)
+        {{fun, arity}, {:strong, nil, [{[domain | rest], Descr.dynamic()}]}}
+      end
+
+    [
+      {{:impl_for, 1}, {:strong, [Descr.term()], impl_for}},
+      {{:impl_for!, 1}, {:strong, [domain], impl_for!}}
+    ] ++ new_signatures
+  end
+
   defp change_protocol({_name, _kind, meta, clauses}, types) do
     clauses =
       Enum.map(clauses, fn
@@ -682,9 +721,9 @@ defmodule Protocol do
   end
 
   # Finally compile the module and emit its bytecode.
-  defp compile(definitions, specs, {info, chunks}) do
-    info = %{info | definitions: definitions}
-    {:ok, :elixir_erl.consolidate(info, specs, chunks)}
+  defp compile(definitions, signatures, {module_map, specs, docs_chunk}) do
+    module_map = %{module_map | definitions: definitions, signatures: signatures}
+    {:ok, :elixir_erl.consolidate(module_map, specs, docs_chunk)}
   end
 
   ## Definition callbacks

lib/elixir/src/elixir_erl.erl

@@ -118,9 +118,10 @@ scope(_Meta, ExpandCaptures) ->
 
 %% Static compilation hook, used in protocol consolidation
 
-consolidate(Map, TypeSpecs, Chunks) ->
-  {Prefix, Forms, _Def, _Defmacro, _Macros} = dynamic_form(Map),
-  load_form(Map, Prefix, Forms, TypeSpecs, Chunks).
+consolidate(Map, TypeSpecs, DocsChunk) ->
+  {Prefix, Forms, Def, _Defmacro, _Macros} = dynamic_form(Map),
+  CheckerChunk = checker_chunk(Map, Def, chunk_opts(Map)),
+  load_form(Map, Prefix, Forms, TypeSpecs, DocsChunk ++ CheckerChunk).
 
 %% Dynamic compilation hook, used in regular compiler
 
@@ -143,16 +144,17 @@ compile(#{module := Module, anno := Anno} = BaseMap) ->
   {Prefix, Forms, Def, Defmacro, Macros} = dynamic_form(Map),
   {Types, Callbacks, TypeSpecs} = typespecs_form(Map, TranslatedTypespecs, Macros),
 
-  ChunkOpts =
-    case lists:member(deterministic, ?key(Map, compile_opts)) of
-      true -> [deterministic];
-      false -> []
-    end,
-
+  ChunkOpts = chunk_opts(Map),
   DocsChunk = docs_chunk(Map, Set, Module, Anno, Def, Defmacro, Types, Callbacks, ChunkOpts),
   CheckerChunk = checker_chunk(Map, Def, ChunkOpts),
   load_form(Map, Prefix, Forms, TypeSpecs, DocsChunk ++ CheckerChunk).
 
+chunk_opts(Map) ->
+  case lists:member(deterministic, ?key(Map, compile_opts)) of
+    true -> [deterministic];
+    false -> []
+  end.
+
 dynamic_form(#{module := Module, relative_file := RelativeFile,
                attributes := Attributes, definitions := Definitions, unreachable := Unreachable,
                deprecated := Deprecated, compile_opts := Opts} = Map) ->