Add type checking of implementations

Author: josevalim

lib/elixir/lib/exception.ex

@@ -2547,61 +2547,3 @@ defmodule ErlangError do
   defp nth(3), do: "3rd"
   defp nth(n), do: "#{n}th"
 end
-
-defmodule Inspect.Error do
-  @moduledoc """
-  Raised when a struct cannot be inspected.
-  """
-  @enforce_keys [:exception_module, :exception_message, :stacktrace, :inspected_struct]
-  defexception @enforce_keys
-
-  @impl true
-  def exception(arguments) when is_list(arguments) do
-    exception = Keyword.fetch!(arguments, :exception)
-    exception_module = exception.__struct__
-    exception_message = Exception.message(exception) |> String.trim_trailing("\n")
-    stacktrace = Keyword.fetch!(arguments, :stacktrace)
-    inspected_struct = Keyword.fetch!(arguments, :inspected_struct)
-
-    %Inspect.Error{
-      exception_module: exception_module,
-      exception_message: exception_message,
-      stacktrace: stacktrace,
-      inspected_struct: inspected_struct
-    }
-  end
-
-  @impl true
-  def message(%__MODULE__{
-        exception_module: exception_module,
-        exception_message: exception_message,
-        inspected_struct: inspected_struct
-      }) do
-    ~s'''
-    got #{inspect(exception_module)} with message:
-
-        """
-    #{pad(exception_message, 4)}
-        """
-
-    while inspecting:
-
-    #{pad(inspected_struct, 4)}
-    '''
-  end
-
-  @doc false
-  def pad(message, padding_length)
-      when is_binary(message) and is_integer(padding_length) and padding_length >= 0 do
-    padding = String.duplicate(" ", padding_length)
-
-    message
-    |> String.split("\n")
-    |> Enum.map(fn
-      "" -> "\n"
-      line -> [padding, line, ?\n]
-    end)
-    |> IO.iodata_to_binary()
-    |> String.trim_trailing("\n")
-  end
-end

lib/elixir/lib/inspect.ex

@@ -577,36 +577,6 @@ defimpl Inspect, for: Function do
   end
 end
 
-defimpl Inspect, for: Inspect.Error do
-  @impl true
-  def inspect(%{stacktrace: stacktrace} = inspect_error, _opts) do
-    message = Exception.message(inspect_error)
-    format_output(message, stacktrace)
-  end
-
-  defp format_output(message, [_ | _] = stacktrace) do
-    stacktrace = Exception.format_stacktrace(stacktrace)
-
-    """
-    #Inspect.Error<
-    #{Inspect.Error.pad(message, 2)}
-
-      Stacktrace:
-
-    #{stacktrace}
-    >\
-    """
-  end
-
-  defp format_output(message, []) do
-    """
-    #Inspect.Error<
-      #{Inspect.Error.pad(message, 2)}
-    >\
-    """
-  end
-end
-
 defimpl Inspect, for: PID do
   def inspect(pid, _opts) do
     "#PID" <> IO.iodata_to_binary(:erlang.pid_to_list(pid))

lib/elixir/lib/inspect/error.ex

@@ -0,0 +1,87 @@
+defmodule Inspect.Error do
+  @moduledoc """
+  Raised when a struct cannot be inspected.
+  """
+  @enforce_keys [:exception_module, :exception_message, :stacktrace, :inspected_struct]
+  defexception @enforce_keys
+
+  @impl true
+  def exception(arguments) when is_list(arguments) do
+    exception = Keyword.fetch!(arguments, :exception)
+    exception_module = exception.__struct__
+    exception_message = Exception.message(exception) |> String.trim_trailing("\n")
+    stacktrace = Keyword.fetch!(arguments, :stacktrace)
+    inspected_struct = Keyword.fetch!(arguments, :inspected_struct)
+
+    %Inspect.Error{
+      exception_module: exception_module,
+      exception_message: exception_message,
+      stacktrace: stacktrace,
+      inspected_struct: inspected_struct
+    }
+  end
+
+  @impl true
+  def message(%__MODULE__{
+        exception_module: exception_module,
+        exception_message: exception_message,
+        inspected_struct: inspected_struct
+      }) do
+    ~s'''
+    got #{inspect(exception_module)} with message:
+
+        """
+    #{pad(exception_message, 4)}
+        """
+
+    while inspecting:
+
+    #{pad(inspected_struct, 4)}
+    '''
+  end
+
+  @doc false
+  def pad(message, padding_length)
+      when is_binary(message) and is_integer(padding_length) and padding_length >= 0 do
+    padding = String.duplicate(" ", padding_length)
+
+    message
+    |> String.split("\n")
+    |> Enum.map(fn
+      "" -> "\n"
+      line -> [padding, line, ?\n]
+    end)
+    |> IO.iodata_to_binary()
+    |> String.trim_trailing("\n")
+  end
+end
+
+defimpl Inspect, for: Inspect.Error do
+  @impl true
+  def inspect(%{stacktrace: stacktrace} = inspect_error, _opts) do
+    message = Exception.message(inspect_error)
+    format_output(message, stacktrace)
+  end
+
+  defp format_output(message, [_ | _] = stacktrace) do
+    stacktrace = Exception.format_stacktrace(stacktrace)
+
+    """
+    #Inspect.Error<
+    #{Inspect.Error.pad(message, 2)}
+
+      Stacktrace:
+
+    #{stacktrace}
+    >\
+    """
+  end
+
+  defp format_output(message, []) do
+    """
+    #Inspect.Error<
+      #{Inspect.Error.pad(message, 2)}
+    >\
+    """
+  end
+end

lib/elixir/lib/module/parallel_checker.ex

@@ -47,8 +47,17 @@ defmodule Module.ParallelChecker do
   @doc """
   Spawns a process that runs the parallel checker.
   """
-  def spawn({pid, {checker, table}}, module, module_map, log?) do
-    inner_spawn(pid, checker, table, module, cache_from_module_map(table, module_map), log?)
+  def spawn({pid, {checker, table}}, module, module_map, beam_location, log?) do
+    # Protocols may have been consolidated. So if we know their beam location,
+    # we discard their module map on purpose and start from file.
+    info =
+      if beam_location != [] and List.keymember?(module_map.attributes, :__protocol__, 0) do
+        List.to_string(beam_location)
+      else
+        cache_from_module_map(table, module_map)
+      end
+
+    inner_spawn(pid, checker, table, module, info, log?)
   end
 
   defp inner_spawn(pid, checker, table, module, info, log?) do
@@ -221,7 +230,7 @@ defmodule Module.ParallelChecker do
   ## Module checking
 
   defp check_module(module_tuple, cache, log?) do
-    {module, file, line, definitions, no_warn_undefined, behaviours, impls, after_verify} =
+    {module, file, line, definitions, no_warn_undefined, behaviours, impls, attrs, after_verify} =
       module_tuple
 
     behaviour_warnings =
@@ -236,7 +245,7 @@ defmodule Module.ParallelChecker do
 
     diagnostics =
       module
-      |> Module.Types.warnings(file, definitions, no_warn_undefined, cache)
+      |> Module.Types.warnings(file, attrs, definitions, no_warn_undefined, cache)
       |> Kernel.++(behaviour_warnings)
       |> group_warnings()
       |> emit_warnings(file, log?)
@@ -273,7 +282,10 @@ defmodule Module.ParallelChecker do
       |> extract_no_warn_undefined()
       |> merge_compiler_no_warn_undefined()
 
-    {module, file, line, definitions, no_warn_undefined, behaviours, impls, after_verify}
+    attributes = Keyword.take(attributes, [:__protocol__, :__impl__])
+
+    {module, file, line, definitions, no_warn_undefined, behaviours, impls, attributes,
+     after_verify}
   end
 
   defp extract_no_warn_undefined(compile_opts) do

lib/elixir/lib/module/types.ex

@@ -30,17 +30,26 @@ defmodule Module.Types do
   @modes [:static, :dynamic, :infer, :traversal]
 
   # These functions are not inferred because they are added/managed by the compiler
-  @no_infer [__protocol__: 1, behaviour_info: 1]
+  @no_infer [behaviour_info: 1]
 
   @doc false
-  def infer(module, file, defs, private, used_private, env, {_, cache}) do
-    infer_signatures? = :elixir_config.get(:infer_signatures) and cache != nil
+  def infer(module, file, attrs, defs, private, used_private, env, {_, cache}) do
+    # We don't care about inferring signatures for protocols,
+    # those will be replaced anyway. There is also nothing to
+    # infer if there is no cache system, we only do traversals.
+    infer_signatures? =
+      :elixir_config.get(:infer_signatures) and cache != nil and not protocol?(attrs)
+
+    impl = impl_for(attrs)
 
     finder =
       fn fun_arity ->
         case :lists.keyfind(fun_arity, 1, defs) do
-          {_, kind, _, _} = clause -> {infer_mode(kind, infer_signatures?), clause}
-          false -> false
+          {_, kind, _, _} = clause ->
+            {infer_mode(kind, infer_signatures?), clause, default_domain(fun_arity, impl)}
+
+          false ->
+            false
         end
       end
 
@@ -67,7 +76,11 @@ defmodule Module.Types do
           kind in [:def, :defmacro],
           reduce: {[], context()} do
         {types, context} ->
-          finder = fn _ -> {infer_mode(kind, infer_signatures?), def} end
+          # Optimized version of finder, since we already the definition
+          finder = fn _ ->
+            {infer_mode(kind, infer_signatures?), def, default_domain(fun_arity, impl)}
+          end
+
           {_kind, inferred, context} = local_handler(meta, fun_arity, stack, context, finder)
 
           if infer_signatures? and kind == :def and fun_arity not in @no_infer do
@@ -111,6 +124,25 @@ defmodule Module.Types do
     if infer_signatures? and kind in [:def, :defp], do: :infer, else: :traversal
   end
 
+  defp protocol?(attrs) do
+    List.keymember?(attrs, :__protocol__, 0)
+  end
+
+  defp impl_for(attrs) do
+    case List.keyfind(attrs, :__impl__, 0) do
+      {:__impl__, [protocol: _, for: for]} -> for
+      _ -> nil
+    end
+  end
+
+  defp default_domain({fun, arity}, impl) when impl != nil and fun != :__impl__ and arity >= 1 do
+    [Module.Types.Of.impl(impl) | List.duplicate(Descr.dynamic(), arity - 1)]
+  end
+
+  defp default_domain({_, arity}, _) do
+    List.duplicate(Descr.dynamic(), arity)
+  end
+
   defp undefined_function!(reason, meta, {fun, arity}, stack, env) do
     env = %{env | function: stack.function, file: stack.file}
     tuple = {reason, {fun, arity}, stack.module}
@@ -159,10 +191,12 @@ defmodule Module.Types do
   end
 
   @doc false
-  def warnings(module, file, defs, no_warn_undefined, cache) do
+  def warnings(module, file, attrs, defs, no_warn_undefined, cache) do
+    impl = impl_for(attrs)
+
     finder = fn fun_arity ->
       case :lists.keyfind(fun_arity, 1, defs) do
-        {_, _, _, _} = clause -> {:dynamic, clause}
+        {_, _, _, _} = clause -> {:dynamic, clause, default_domain(fun_arity, impl)}
         false -> false
       end
     end
@@ -172,7 +206,8 @@ defmodule Module.Types do
 
     context =
       Enum.reduce(defs, context(), fn {fun_arity, _kind, meta, _clauses} = def, context ->
-        finder = fn _ -> {:dynamic, def} end
+        # Optimized version of finder, since we already the definition
+        finder = fn _ -> {:dynamic, def, default_domain(fun_arity, impl)} end
         {_kind, _inferred, context} = local_handler(meta, fun_arity, stack, context, finder)
         context
       end)
@@ -211,11 +246,11 @@ defmodule Module.Types do
 
       local_sigs ->
         case finder.(fun_arity) do
-          {mode, {fun_arity, kind, meta, clauses}} ->
+          {mode, {fun_arity, kind, meta, clauses}, expected} ->
             context = put_in(context.local_sigs, Map.put(local_sigs, fun_arity, kind))
 
             {inferred, mapping, context} =
-              local_handler(fun_arity, kind, meta, clauses, mode, stack, context)
+              local_handler(fun_arity, kind, meta, clauses, expected, mode, stack, context)
 
             context =
               update_in(context.local_sigs, &Map.put(&1, fun_arity, {kind, inferred, mapping}))
@@ -228,8 +263,8 @@ defmodule Module.Types do
     end
   end
 
-  defp local_handler({fun, arity} = fun_arity, kind, meta, clauses, mode, stack, context) do
-    expected = List.duplicate(Descr.dynamic(), arity)
+  defp local_handler(fun_arity, kind, meta, clauses, expected, mode, stack, context) do
+    {fun, _arity} = fun_arity
     stack = stack |> fresh_stack(mode, fun_arity) |> with_file_meta(meta)
 
     {_, _, mapping, clauses_types, clauses_context} =

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

@@ -87,6 +87,40 @@ defmodule Module.Types.Of do
   defp new_trace(expr, type, formatter, stack, traces),
     do: [{expr, stack.file, type, formatter} | traces]
 
+  ## 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()},
+    {Port, port()},
+    {PID, pid()},
+    {Reference, reference()},
+    {Tuple, tuple()},
+    {Any, term()}
+  ]
+
+  for {for, type} <- impls do
+    def impl(unquote(for)), do: unquote(Macro.escape(dynamic(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))
+    else
+      dynamic(open_map(__struct__: atom([struct])))
+    end
+  end
+
   ## Map/structs
 
   @doc """