Add source field to diagnostics

Author: josevalim

lib/elixir/lib/code.ex

@@ -197,15 +197,22 @@ defmodule Code do
   @typedoc """
   Diagnostics returned by the compiler and code evaluation.
 
+  The file and position relate to where the diagnostic should be shown.
   If there is a file and position, then the diagnostic is precise
   and you can use the given file and position for generating snippets,
   IDEs annotations, and so on. An optional span is available with
   the line and column the diagnostic ends.
 
   Otherwise, a stacktrace may be given, which you can place your own
   heuristics to provide better reporting.
+
+  The source field points to the source file the compiler tracked
+  the error to. For example, a file `lib/foo.ex` may embed `.eex`
+  templates from `lib/foo/bar.eex`. A syntax error on the EEx template
+  will point to file `lib/foo/bar.eex` but the source is `lib/foo.ex`.
   """
   @type diagnostic(severity) :: %{
+          required(:source) => Path.t() | nil,
           required(:file) => Path.t() | nil,
           required(:severity) => severity,
           required(:message) => String.t(),

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -859,9 +859,12 @@ defmodule Kernel.ParallelCompiler do
     )
 
     for {file, _, description, stacktrace} <- deadlock do
+      file = Path.absname(file)
+
       %{
         severity: :error,
-        file: Path.absname(file),
+        file: file,
+        source: file,
         position: nil,
         message: description,
         stacktrace: stacktrace,
@@ -889,13 +892,14 @@ defmodule Kernel.ParallelCompiler do
     ])
   end
 
-  defp to_error(file, kind, reason, stack) do
-    {line, span} = get_line_span(file, reason, stack)
-    file = Path.absname(file)
+  defp to_error(source, kind, reason, stack) do
+    {file, line, span} = get_snippet_info(source, reason, stack)
+    source = Path.absname(source)
     message = :unicode.characters_to_binary(Kernel.CLI.format_error(kind, reason, stack))
 
     %{
-      file: file,
+      file: file || source,
+      source: source,
       position: line || 0,
       message: message,
       severity: :error,
@@ -905,47 +909,47 @@ defmodule Kernel.ParallelCompiler do
     }
   end
 
-  defp get_line_span(
+  defp get_snippet_info(
          _file,
-         %{line: line, column: column, end_line: end_line, end_column: end_column},
+         %{file: file, line: line, column: column, end_line: end_line, end_column: end_column},
          _stack
        )
        when is_integer(line) and line > 0 and is_integer(column) and column >= 0 and
               is_integer(end_line) and end_line > 0 and is_integer(end_column) and end_column >= 0 do
-    {{line, column}, {end_line, end_column}}
+    {Path.absname(file), {line, column}, {end_line, end_column}}
   end
 
-  defp get_line_span(_file, %{line: line, column: column}, _stack)
+  defp get_snippet_info(_file, %{file: file, line: line, column: column}, _stack)
        when is_integer(line) and line > 0 and is_integer(column) and column >= 0 do
-    {{line, column}, nil}
+    {Path.absname(file), {line, column}, nil}
   end
 
-  defp get_line_span(_file, %{line: line}, _stack) when is_integer(line) and line > 0 do
-    {line, nil}
+  defp get_snippet_info(_file, %{line: line}, _stack) when is_integer(line) and line > 0 do
+    {nil, line, nil}
   end
 
-  defp get_line_span(file, :undef, [{_, _, _, []}, {_, _, _, info} | _]) do
-    get_line_span_from_stacktrace_info(info, file)
+  defp get_snippet_info(file, :undef, [{_, _, _, []}, {_, _, _, info} | _]) do
+    get_snippet_info_from_stacktrace_info(info, file)
   end
 
-  defp get_line_span(file, _reason, [{_, _, _, [file: expanding]}, {_, _, _, info} | _])
+  defp get_snippet_info(file, _reason, [{_, _, _, [file: expanding]}, {_, _, _, info} | _])
        when expanding in [~c"expanding macro", ~c"expanding struct"] do
-    get_line_span_from_stacktrace_info(info, file)
+    get_snippet_info_from_stacktrace_info(info, file)
   end
 
-  defp get_line_span(file, _reason, [{_, _, _, info} | _]) do
-    get_line_span_from_stacktrace_info(info, file)
+  defp get_snippet_info(file, _reason, [{_, _, _, info} | _]) do
+    get_snippet_info_from_stacktrace_info(info, file)
   end
 
-  defp get_line_span(_, _, _) do
-    {nil, nil}
+  defp get_snippet_info(_, _, _) do
+    {nil, nil, nil}
   end
 
-  defp get_line_span_from_stacktrace_info(info, file) do
+  defp get_snippet_info_from_stacktrace_info(info, file) do
     if Keyword.get(info, :file) == to_charlist(Path.relative_to_cwd(file)) do
-      {Keyword.get(info, :line), nil}
+      {nil, Keyword.get(info, :line), nil}
     else
-      {nil, nil}
+      {nil, nil, nil}
     end
   end
 end

lib/elixir/lib/module/parallel_checker.ex

@@ -324,6 +324,7 @@ defmodule Module.ParallelChecker do
   defp to_diagnostic(message, {file, position, mfa}) when is_list(position) do
     %{
       severity: :warning,
+      source: file,
       file: file,
       position: position_to_tuple(position),
       message: IO.iodata_to_binary(message),

lib/elixir/src/elixir_errors.erl

@@ -106,6 +106,7 @@ emit_diagnostic(Severity, Position, File, Message, Stacktrace, Options) ->
 
   Diagnostic = #{
     severity => Severity,
+    source => File,
     file => File,
     position => Position,
     message => unicode:characters_to_binary(Message),

lib/elixir/test/elixir/code_test.exs

@@ -252,6 +252,7 @@ defmodule CodeTest do
                  message: "undefined variable \"x\"",
                  position: 1,
                  file: "nofile",
+                 source: "nofile",
                  stacktrace: [],
                  severity: :error
                }

lib/elixir/test/elixir/kernel/parallel_compiler_test.exs

@@ -480,6 +480,24 @@ defmodule Kernel.ParallelCompilerTest do
       end)
     end
 
+    test "gets correct file+line+column number for SyntaxError" do
+      File.mkdir_p!(tmp_path())
+
+      [fixture] =
+        write_tmp("error",
+          error: """
+          raise SyntaxError, file: "foo/bar.ex", line: 3, column: 10
+          """
+        )
+
+      file = Path.absname("foo/bar.ex")
+
+      capture_io(:stderr, fn ->
+        assert {:error, [%{file: ^file, source: ^fixture, position: {3, 10}}], _} =
+                 Kernel.ParallelCompiler.compile([fixture], return_diagnostics: true)
+      end)
+    end
+
     test "gets proper beam destinations from dynamic modules" do
       fixtures =
         write_tmp(

lib/mix/lib/mix/compilers/elixir.ex

@@ -724,9 +724,11 @@ defmodule Mix.Compilers.Elixir do
          )} <- sources,
         file = Path.absname(source),
         {position, message, span} <- compile_warnings ++ runtime_warnings do
+      # TODO: Store the whole diagnostic
       diagnostic = %Mix.Task.Compiler.Diagnostic{
         severity: :warning,
         file: file,
+        source: file,
         position: position,
         message: message,
         compiler_name: "Elixir",
@@ -774,11 +776,13 @@ defmodule Mix.Compilers.Elixir do
            message: message,
            severity: severity,
            stacktrace: stacktrace,
-           span: span
+           span: span,
+           source: source
          } = diagnostic
        ) do
     %Mix.Task.Compiler.Diagnostic{
       file: file,
+      source: source,
       position: position,
       message: message,
       severity: severity,

lib/mix/lib/mix/compilers/erlang.ex

@@ -288,8 +288,11 @@ defmodule Mix.Compilers.Erlang do
   defp to_diagnostics(warnings_or_errors, severity) do
     for {file, issues} <- warnings_or_errors,
         {location, module, data} <- issues do
+      file = Path.absname(file)
+
       %Mix.Task.Compiler.Diagnostic{
-        file: Path.absname(file),
+        file: file,
+        source: file,
         position: location_normalize(location),
         message: to_string(module.format_error(data)),
         severity: severity,

lib/mix/lib/mix/task.compiler.ex

@@ -32,17 +32,24 @@ defmodule Mix.Task.Compiler do
     @moduledoc """
     Diagnostic information such as a warning or compilation error.
 
+    The file and position relate to where the diagnostic should be shown.
     If there is a file and position, then the diagnostic is precise
     and you can use the given file and position for generating snippets,
     IDEs annotations, and so on. An optional span is available with
     the line and column the diagnostic ends.
 
     Otherwise, a stacktrace may be given, which you can place your own
     heuristics to provide better reporting.
+
+    The source field points to the source file the compiler tracked
+    the error to. For example, a file `lib/foo.ex` may embed `.eex`
+    templates from `lib/foo/bar.eex`. A syntax error on the EEx template
+    will point to file `lib/foo/bar.eex` but the source is `lib/foo.ex`.
     """
 
     @type t :: %__MODULE__{
             file: Path.t() | nil,
+            source: Path.t() | nil,
             severity: severity,
             message: IO.chardata(),
             position: Code.position(),
@@ -72,6 +79,7 @@ defmodule Mix.Task.Compiler do
     @enforce_keys [:file, :severity, :message, :position, :compiler_name]
     defstruct [
       :file,
+      :source,
       :severity,
       :message,
       :position,

lib/mix/test/mix/tasks/compile.elixir_test.exs

@@ -1443,6 +1443,7 @@ defmodule Mix.Tasks.Compile.ElixirTest do
 
         assert %Diagnostic{
                  file: ^file,
+                 source: ^file,
                  severity: :warning,
                  position: {2, 13},
                  compiler_name: "Elixir",
@@ -1457,6 +1458,7 @@ defmodule Mix.Tasks.Compile.ElixirTest do
 
         assert %Diagnostic{
                  file: ^file,
+                 source: ^file,
                  severity: :warning,
                  position: {2, 13},
                  compiler_name: "Elixir",
@@ -1518,6 +1520,7 @@ defmodule Mix.Tasks.Compile.ElixirTest do
 
                assert %Diagnostic{
                         file: ^file,
+                        source: ^file,
                         severity: :error,
                         position: {2, 20},
                         message: "** (SyntaxError) invalid syntax found on lib/a.ex:2:" <> _,
@@ -1552,6 +1555,7 @@ defmodule Mix.Tasks.Compile.ElixirTest do
 
         assert %Diagnostic{
                  file: ^file,
+                 source: ^file,
                  severity: :error,
                  position: 2,
                  message: "** (KeyError) key :invalid_key not found" <> _,