Do not recompile if compilation fails due to --warnings-as-errors

Author: josevalim

lib/elixir/lib/code.ex

@@ -1717,7 +1717,7 @@ defmodule Code do
   def put_compiler_option(:warnings_as_errors, _value) do
     IO.warn(
       ":warnings_as_errors is deprecated as part of Code.put_compiler_option/2, " <>
-        "pass it as option to Kernel.ParallelCompiler instead or as a --warnings-as-errors flag. " <>
+        "instead you must pass it as a --warnings-as-errors flag. " <>
         "If you need to set it as a default in a mix task, you can also set it under aliases: " <>
         "[compile: \"compile --warnings-as-errors\"]"
     )

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -257,28 +257,13 @@ defmodule Kernel.ParallelCompiler do
 
     {status, modules_or_errors, info} =
       try do
-        outcome = spawn_workers(schedulers, cache, files, output, options)
-        {outcome, Keyword.get(options, :warnings_as_errors, false)}
+        spawn_workers(schedulers, cache, files, output, options)
       else
-        {{:ok, _, %{runtime_warnings: r_warnings, compile_warnings: c_warnings} = info}, true}
-        when r_warnings != [] or c_warnings != [] ->
-          message =
-            "Compilation failed due to warnings while using the --warnings-as-errors option"
-
-          IO.puts(:stderr, message)
-          errors = Enum.map(r_warnings ++ c_warnings, &Map.replace!(&1, :severity, :error))
-          {:error, errors, %{info | runtime_warnings: [], compile_warnings: []}}
-
-        {{:ok, outcome, info}, _} ->
+        {:ok, outcome, info} ->
           beam_timestamp = Keyword.get(options, :beam_timestamp)
           {:ok, write_module_binaries(outcome, output, beam_timestamp), info}
 
-        {{:error, errors, info}, true} ->
-          %{runtime_warnings: r_warnings, compile_warnings: c_warnings} = info
-          info = %{info | runtime_warnings: [], compile_warnings: []}
-          {:error, c_warnings ++ r_warnings ++ errors, info}
-
-        {{:error, errors, info}, _} ->
+        {:error, errors, info} ->
           {:error, errors, info}
       after
         Module.ParallelChecker.stop(cache)

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

@@ -454,40 +454,6 @@ defmodule Kernel.ParallelCompilerTest do
       end)
     end
 
-    test "supports warnings as errors" do
-      [fixture] =
-        write_tmp(
-          "warnings_as_errors",
-          warnings_as_errors: """
-          defmodule WarningsSample do
-            def hello(a), do: a
-            def hello(b), do: b
-          end
-          """
-        )
-
-      output = tmp_path("not_to_be_used")
-
-      try do
-        msg =
-          capture_io(:stderr, fn ->
-            assert {:error, [%{file: ^fixture, position: {3, 7}, message: "this clause " <> _}],
-                    @no_warnings} =
-                     Kernel.ParallelCompiler.compile_to_path([fixture], output,
-                       warnings_as_errors: true,
-                       return_diagnostics: true
-                     )
-          end)
-
-        assert msg =~
-                 "Compilation failed due to warnings while using the --warnings-as-errors option\n"
-      after
-        purge([WarningsSample])
-      end
-
-      refute File.exists?(output)
-    end
-
     test "does not use incorrect line number when error originates in another file" do
       File.mkdir_p!(tmp_path())
 
@@ -655,35 +621,5 @@ defmodule Kernel.ParallelCompilerTest do
                         "cannot compile module WithBehaviourAndStruct (errors have been logged)"
              end) =~ expected_msg
     end
-
-    test "supports warnings as errors" do
-      [fixture] =
-        write_tmp(
-          "warnings_as_errors",
-          warnings_as_errors: """
-          defmodule WarningsSample do
-            def hello(a), do: a
-            def hello(b), do: b
-          end
-          """
-        )
-
-      try do
-        msg =
-          capture_io(:stderr, fn ->
-            assert {:error, [%{file: ^fixture, position: {3, 7}, message: "this clause " <> _}],
-                    @no_warnings} =
-                     Kernel.ParallelCompiler.require([fixture],
-                       warnings_as_errors: true,
-                       return_diagnostics: true
-                     )
-          end)
-
-        assert msg =~
-                 "Compilation failed due to warnings while using the --warnings-as-errors option\n"
-      after
-        purge([WarningsSample])
-      end
-    end
   end
 end

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

@@ -208,14 +208,18 @@ defmodule Mix.Compilers.Elixir do
           end
 
           Mix.Task.Compiler.notify_modules_compiled(lazy_modules_diff)
-
-          unless_previous_warnings_as_errors(previous_warnings, opts, {:ok, all_warnings})
+          unless_warnings_as_errors(opts, {:ok, all_warnings})
 
         {:error, errors, %{runtime_warnings: r_warnings, compile_warnings: c_warnings}, state} ->
+          {errors, warnings} =
+            if opts[:warnings_as_errors],
+              do: {errors ++ r_warnings ++ c_warnings, []},
+              else: {errors, r_warnings ++ c_warnings}
+
           # In case of errors, we show all previous warnings and all new ones.
           {_, _, sources, _, _, _} = state
           errors = Enum.map(errors, &diagnostic/1)
-          warnings = Enum.map(r_warnings ++ c_warnings, &diagnostic/1)
+          warnings = Enum.map(warnings, &diagnostic/1)
           all_warnings = Keyword.get(opts, :all_warnings, errors == [])
           {:error, previous_warnings(sources, all_warnings) ++ warnings ++ errors}
       after
@@ -254,8 +258,7 @@ defmodule Mix.Compilers.Elixir do
 
       all_warnings = Keyword.get(opts, :all_warnings, true)
       previous_warnings = previous_warnings(sources, all_warnings)
-
-      unless_previous_warnings_as_errors(previous_warnings, opts, {status, previous_warnings})
+      unless_warnings_as_errors(opts, {status, previous_warnings})
     end
   end
 
@@ -1012,8 +1015,8 @@ defmodule Mix.Compilers.Elixir do
     File.rm(manifest <> ".checkpoint")
   end
 
-  defp unless_previous_warnings_as_errors(previous_warnings, opts, {status, all_warnings}) do
-    if previous_warnings != [] and opts[:warnings_as_errors] do
+  defp unless_warnings_as_errors(opts, {status, all_warnings}) do
+    if all_warnings != [] and opts[:warnings_as_errors] do
       message = "Compilation failed due to warnings while using the --warnings-as-errors option"
       IO.puts(:stderr, message)
       {:error, all_warnings}
@@ -1049,7 +1052,6 @@ defmodule Mix.Compilers.Elixir do
     threshold = opts[:long_compilation_threshold] || 10
     profile = opts[:profile]
     verbose = opts[:verbose] || false
-    warnings_as_errors = opts[:warnings_as_errors] || false
 
     pid =
       spawn_link(fn ->
@@ -1071,8 +1073,7 @@ defmodule Mix.Compilers.Elixir do
           long_compilation_threshold: threshold,
           profile: profile,
           beam_timestamp: timestamp,
-          return_diagnostics: true,
-          warnings_as_errors: warnings_as_errors
+          return_diagnostics: true
         ]
 
         response = Kernel.ParallelCompiler.compile_to_path(stale, dest, compile_opts)