Move Checker into ParallelChecker

Author: josevalim

lib/elixir/lib/module/checker.ex

@@ -96,6 +96,116 @@ defmodule Module.ParallelChecker do
     |> Enum.sort()
   end
 
+  ## Module checking
+
+  defp check_module(module, cache) do
+    case extract_definitions(module) do
+      {:ok, module, file, definitions, no_warn_undefined} ->
+        Module.Types.warnings(module, file, definitions, no_warn_undefined, cache)
+        |> group_warnings()
+        |> emit_warnings()
+
+      :error ->
+        []
+    end
+  end
+
+  defp extract_definitions({module, module_map}) when is_map(module_map) do
+    no_warn_undefined =
+      module_map.compile_opts
+      |> extract_no_warn_undefined()
+      |> merge_compiler_no_warn_undefined()
+
+    {:ok, module, module_map.file, module_map.definitions, no_warn_undefined}
+  end
+
+  defp extract_definitions({module, binary}) when is_binary(binary) do
+    with {:ok, {_, [debug_info: chunk]}} <- :beam_lib.chunks(binary, [:debug_info]),
+         {:debug_info_v1, backend, data} <- chunk,
+         {:ok, module_map} <- backend.debug_info(:elixir_v1, module, data, []) do
+      extract_definitions({module, module_map})
+    else
+      _ -> :error
+    end
+  end
+
+  defp extract_no_warn_undefined(compile_opts) do
+    for(
+      {:no_warn_undefined, values} <- compile_opts,
+      value <- List.wrap(values),
+      do: value
+    )
+  end
+
+  defp merge_compiler_no_warn_undefined(no_warn_undefined) do
+    case Code.get_compiler_option(:no_warn_undefined) do
+      :all ->
+        :all
+
+      list when is_list(list) ->
+        no_warn_undefined ++ list
+    end
+  end
+
+  ## Warning helpers
+
+  def group_warnings(warnings) do
+    warnings
+    |> Enum.reduce(%{}, fn {module, warning, location}, acc ->
+      locations = MapSet.new([location])
+      Map.update(acc, {module, warning}, locations, &MapSet.put(&1, location))
+    end)
+    |> Enum.map(fn {{module, warning}, locations} -> {module, warning, Enum.sort(locations)} end)
+    |> Enum.sort()
+  end
+
+  def emit_warnings(warnings) do
+    Enum.flat_map(warnings, fn {module, warning, locations} ->
+      message = module.format_warning(warning)
+      print_warning([message, ?\n, format_locations(locations)])
+
+      Enum.map(locations, fn {file, line, _mfa} ->
+        {file, line, message}
+      end)
+    end)
+  end
+
+  defp format_locations([location]) do
+    format_location(location)
+  end
+
+  defp format_locations(locations) do
+    [
+      "Found at #{length(locations)} locations:\n",
+      Enum.map(locations, &format_location/1)
+    ]
+  end
+
+  defp format_location({file, line, {module, fun, arity}}) do
+    mfa = Exception.format_mfa(module, fun, arity)
+    [format_file_line(file, line), ": ", mfa, ?\n]
+  end
+
+  defp format_location({file, line, nil}) do
+    [format_file_line(file, line), ?\n]
+  end
+
+  defp format_location({file, line, module}) do
+    [format_file_line(file, line), ": ", inspect(module), ?\n]
+  end
+
+  defp format_file_line(file, line) do
+    file = Path.relative_to_cwd(file)
+    line = if line > 0, do: [?: | Integer.to_string(line)], else: []
+    ["  ", file, line]
+  end
+
+  defp print_warning(message) do
+    IO.puts(:stderr, [:elixir_errors.warning_prefix(), message])
+  end
+
+  ## Server callbacks
+
   def init([modules, send_results, schedulers]) do
     ets = :ets.new(:checker_cache, [:set, :public, {:read_concurrency, true}])
 
@@ -187,7 +297,7 @@ defmodule Module.ParallelChecker do
     send_results_pid = state.send_results
 
     spawn_link(fn ->
-      warnings = Module.Checker.verify(verify, {parent, ets})
+      warnings = check_module(verify, {parent, ets})
       send(send_results_pid, {__MODULE__, module, warnings})
       send(parent, {__MODULE__, :done})
     end)

lib/elixir/lib/module/parallel_checker.ex

@@ -4,18 +4,16 @@ defmodule Module.Types do
   import Module.Types.Helpers
   alias Module.Types.{Expr, Pattern}
 
-  @doc """
-  Infer function definitions' types.
-  """
-  def infer_definitions(file, module, defs, no_warn_undefined, cache) do
+  @doc false
+  def warnings(module, file, defs, no_warn_undefined, cache) do
     stack = stack()
 
     Enum.flat_map(defs, fn {{fun, _arity} = function, kind, meta, clauses} ->
       context = context(with_file_meta(meta, file), module, function, no_warn_undefined, cache)
 
       Enum.flat_map(clauses, fn {_meta, args, guards, body} ->
         def_expr = {kind, meta, [guards_to_expr(guards, {fun, [], args})]}
-        infer_definition(args, guards, body, def_expr, stack, context)
+        warnings_from_clause(args, guards, body, def_expr, stack, context)
       end)
     end)
   end
@@ -27,7 +25,15 @@ defmodule Module.Types do
     end
   end
 
-  defp infer_definition(args, guards, body, def_expr, stack, context) do
+  defp guards_to_expr([], left) do
+    left
+  end
+
+  defp guards_to_expr([guard | guards], left) do
+    guards_to_expr(guards, {:when, [], [left, guard]})
+  end
+
+  defp warnings_from_clause(args, guards, body, def_expr, stack, context) do
     head_stack = push_expr_stack(def_expr, stack)
 
     with {:ok, _types, context} <- Pattern.of_head(args, guards, head_stack, context),
@@ -95,6 +101,8 @@ defmodule Module.Types do
     }
   end
 
+  ## VARIABLE LIFTING
+
   @doc """
   Lifts type variables to their infered types from the context.
   """
@@ -109,7 +117,9 @@ defmodule Module.Types do
     types
   end
 
-  @doc false
+  @doc """
+  Lifts a single type to its infered type from the context.
+  """
   def lift_type(type, context) do
     context = %{
       types: context.types,
@@ -121,18 +131,6 @@ defmodule Module.Types do
     type
   end
 
-  ## GUARDS
-
-  defp guards_to_expr([], left) do
-    left
-  end
-
-  defp guards_to_expr([guard | guards], left) do
-    guards_to_expr(guards, {:when, [], [left, guard]})
-  end
-
-  ## VARIABLE LIFTING
-
   # Lift type variable to its infered (hopefully concrete) types from the context
   defp do_lift_type({:var, var}, context) do
     case Map.fetch(context.lifted_types, var) do
@@ -249,7 +247,7 @@ defmodule Module.Types do
     end)
   end
 
-  ## ERROR FORMATTING
+  ## FORMAT WARNINGS
 
   def format_warning({:unable_unify, left, right, {location, expr, traces}}) do
     cond do

lib/elixir/lib/module/types.ex

@@ -163,7 +163,6 @@ bootstrap_files() ->
     ],
     [
      <<"lib/elixir/lib/list/chars.ex">>,
-     <<"lib/elixir/lib/module/checker.ex">>,
      <<"lib/elixir/lib/module/locals_tracker.ex">>,
      <<"lib/elixir/lib/module/parallel_checker.ex">>,
      <<"lib/elixir/lib/module/types/remote.ex">>,

lib/elixir/src/elixir_compiler.erl

@@ -1,6 +1,6 @@
 Code.require_file("../../test_helper.exs", __DIR__)
 
-defmodule Module.Checker.IntegrationTest do
+defmodule Module.Types.IntegrationTest do
   use ExUnit.Case
 
   import ExUnit.CaptureIO

lib/elixir/test/elixir/module/types/integration_test.exs

@@ -78,8 +78,8 @@ defmodule Mix.Compilers.ApplicationTracer do
       )
 
     warnings
-    |> Module.Checker.group_warnings()
-    |> Module.Checker.emit_warnings()
+    |> Module.ParallelChecker.group_warnings()
+    |> Module.ParallelChecker.emit_warnings()
   end
 
   # ../elixir/ebin/elixir.beam -> elixir