Simplify handling of warnings as errors

Author: josevalim

lib/elixir/lib/code.ex

@@ -250,8 +250,7 @@ defmodule Code do
     :ignore_already_consolidated,
     :ignore_module_conflict,
     :infer_signatures,
-    :relative_paths,
-    :warnings_as_errors
+    :relative_paths
   ]
 
   @list_compiler_options [:no_warn_undefined, :tracers, :parser_options]
@@ -1563,8 +1562,8 @@ defmodule Code do
 
   ## Examples
 
-      Code.compiler_options(warnings_as_errors: true)
-      #=> %{warnings_as_errors: false}
+      Code.compiler_options(infer_signatures: false)
+      #=> %{infer_signatures: true}
 
   """
   @spec compiler_options(Enumerable.t({atom, term})) :: %{optional(atom) => term}
@@ -1593,6 +1592,12 @@ defmodule Code do
     :elixir_config.get(key)
   end
 
+  # TODO: Remove me in Elixir v2.0
+  def get_compiler_option(:warnings_as_errors) do
+    IO.warn(":warnings_as_errors is deprecated as part of Code.get_compiler_option/1")
+    :ok
+  end
+
   @doc """
   Returns a list with all available compiler options.
 
@@ -1647,9 +1652,6 @@ defmodule Code do
       warnings, and errors generated by the compiler. Note disabling this option
       won't affect runtime warnings and errors. Defaults to `true`.
 
-    * `:warnings_as_errors` - causes compilation to fail when warnings are
-      generated. Defaults to `false`.
-
     * `:no_warn_undefined` (since v1.10.0) - list of modules and `{Mod, fun, arity}`
       tuples that will not emit warnings that the module or function does not exist
       at compilation time. Pass atom `:all` to skip warning for all undefined
@@ -1695,6 +1697,16 @@ defmodule Code do
     :ok
   end
 
+  # TODO: Remove me in Elixir v2.0
+  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"
+    )
+
+    :ok
+  end
+
   def put_compiler_option(:no_warn_undefined, value) do
     if value != :all and not is_list(value) do
       raise "compiler option :no_warn_undefined should be a list or the atom :all, " <>

lib/elixir/lib/kernel/cli.ex

@@ -9,6 +9,7 @@ defmodule Kernel.CLI do
     compile: [],
     no_halt: false,
     compiler_options: [],
+    warnings_as_errors: false,
     errors: [],
     verbose_compile: false,
     profile: nil,
@@ -315,8 +316,7 @@ defmodule Kernel.CLI do
   end
 
   defp parse_argv([~c"--warnings-as-errors" | t], %{mode: :elixirc} = config) do
-    compiler_options = [{:warnings_as_errors, true} | config.compiler_options]
-    parse_argv(t, %{config | compiler_options: compiler_options})
+    parse_argv(t, %{config | warnings_as_errors: true})
   end
 
   defp parse_argv([~c"--verbose" | t], %{mode: :elixirc} = config) do
@@ -499,15 +499,11 @@ defmodule Kernel.CLI do
               ]
             end
 
-          profile_opts =
-            if config.profile do
-              [profile: config.profile]
-            else
-              []
-            end
-
           output = IO.chardata_to_string(config.output)
-          opts = verbose_opts ++ profile_opts
+
+          opts =
+            verbose_opts ++
+              [profile: config.profile, warnings_as_errors: config.warnings_as_errors]
 
           case Kernel.ParallelCompiler.compile_to_path(files, output, opts) do
             {:ok, _, _} -> :ok

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -258,7 +258,7 @@ defmodule Kernel.ParallelCompiler do
     {status, modules_or_errors, info} =
       try do
         outcome = spawn_workers(schedulers, checker, files, output, options)
-        {outcome, Code.get_compiler_option(:warnings_as_errors)}
+        {outcome, Keyword.get(options, :warnings_as_errors, false)}
       else
         {{:ok, _, %{runtime_warnings: r_warnings, compile_warnings: c_warnings} = info}, true}
         when r_warnings != [] or c_warnings != [] ->

lib/elixir/src/elixir.erl

@@ -94,7 +94,6 @@ start(_Type, _Args) ->
     {on_undefined_variable, raise},
     {parser_options, [{columns, true}]},
     {debug_info, true},
-    {warnings_as_errors, false},
     {relative_paths, true},
     {no_warn_undefined, []},
     {tracers, []}

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

@@ -422,8 +422,6 @@ defmodule Kernel.ParallelCompilerTest do
     end
 
     test "supports warnings as errors" do
-      warnings_as_errors = Code.get_compiler_option(:warnings_as_errors)
-
       [fixture] =
         write_tmp(
           "warnings_as_errors",
@@ -438,20 +436,19 @@ defmodule Kernel.ParallelCompilerTest do
       output = tmp_path("not_to_be_used")
 
       try do
-        Code.compiler_options(warnings_as_errors: true)
-
         msg =
           capture_io(:stderr, fn ->
             assert {:error, [error], []} =
-                     Kernel.ParallelCompiler.compile_to_path([fixture], output)
+                     Kernel.ParallelCompiler.compile_to_path([fixture], output,
+                       warnings_as_errors: true
+                     )
 
             assert {^fixture, {3, 7}, "this clause " <> _} = error
           end)
 
         assert msg =~
                  "Compilation failed due to warnings while using the --warnings-as-errors option\n"
       after
-        Code.compiler_options(warnings_as_errors: warnings_as_errors)
         purge([WarningsSample])
       end
 
@@ -592,8 +589,6 @@ defmodule Kernel.ParallelCompilerTest do
     end
 
     test "supports warnings as errors" do
-      warnings_as_errors = Code.get_compiler_option(:warnings_as_errors)
-
       [fixture] =
         write_tmp(
           "warnings_as_errors",
@@ -606,19 +601,17 @@ defmodule Kernel.ParallelCompilerTest do
         )
 
       try do
-        Code.compiler_options(warnings_as_errors: true)
-
         msg =
           capture_io(:stderr, fn ->
-            assert {:error, [error], []} = Kernel.ParallelCompiler.require([fixture])
+            assert {:error, [error], []} =
+                     Kernel.ParallelCompiler.require([fixture], warnings_as_errors: true)
 
             assert {^fixture, {3, 7}, "this clause " <> _} = error
           end)
 
         assert msg =~
                  "Compilation failed due to warnings while using the --warnings-as-errors option\n"
       after
-        Code.compiler_options(warnings_as_errors: warnings_as_errors)
         purge([WarningsSample])
       end
     end

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

@@ -1042,6 +1042,7 @@ 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 ->
@@ -1063,7 +1064,8 @@ defmodule Mix.Compilers.Elixir do
           long_compilation_threshold: threshold,
           profile: profile,
           beam_timestamp: timestamp,
-          return_diagnostics: true
+          return_diagnostics: true,
+          warnings_as_errors: warnings_as_errors
         ]
 
         response = Kernel.ParallelCompiler.compile_to_path(stale, dest, compile_opts)

lib/mix/lib/mix/tasks/compile.elixir.ex

@@ -77,9 +77,9 @@ defmodule Mix.Tasks.Compile.Elixir do
       Defaults to `["lib"]`.
 
     * `:elixirc_options` - compilation options that apply to Elixir's compiler.
-      See `Code.put_compiler_option/2` for a complete list of options. These
-      options are often overridable from the command line using the switches
-      above.
+      It supports many of the options above  plus the options listed in
+      `Code.put_compiler_option/2`. In case conflicting options are given,
+      the ones given through the command line are used.
 
     * `[xref: [exclude: ...]]` - a list of `module` or `{module, function, arity}`
       that should not be warned on in case on undefined modules or undefined