Simplify conditional handling

Author: josevalim

lib/elixir/lib/module/types/helpers.ex

@@ -223,11 +223,11 @@ defmodule Module.Types.Helpers do
     if Keyword.get(meta, :generated, false) do
       context
     else
-      effective_warn(module, warning, meta, stack, context)
+      effectively_warn(module, warning, meta, stack, context)
     end
   end
 
-  defp effective_warn(module, warning, meta, stack, context) do
+  defp effectively_warn(module, warning, meta, stack, context) do
     {fun, arity} = stack.function
     location = {stack.file, meta, {stack.module, fun, arity}}
     %{context | warnings: [{module, warning, location} | context.warnings]}
@@ -247,7 +247,7 @@ defmodule Module.Types.Helpers do
         if Keyword.get(meta, :generated, false) do
           context
         else
-          effective_warn(module, warning, meta, stack, %{context | failed: true})
+          effectively_warn(module, warning, meta, stack, %{context | failed: true})
         end
     end
   end

lib/elixir/src/elixir_erl_compiler.erl

@@ -119,8 +119,10 @@ format_warnings(Opts, Warnings) ->
 handle_file_warning(_, _File, {_Line, v3_core, {map_key_repeated, _}}) -> ok;
 handle_file_warning(_, _File, {_Line, sys_core_fold, {ignored, useless_building}}) -> ok;
 
-%% We skip all of no_clause, clause_type, guard, shadow.
+%% We skip all of no_match related to no_clause, clause_type, guard, shadow.
 %% Those have too little information and they overlap with the type system.
+%% We keep the remaining ones because the Erlang compiler performs analyses
+%% on literals (including numbers), which the type system does not do.
 handle_file_warning(_, _File, {_Line, sys_core_fold, {nomatch, Reason}}) when is_atom(Reason) -> ok;
 
 %% Ignore all linting errors (only come up on parse transforms)

lib/elixir/src/elixir_expand.erl

@@ -732,17 +732,7 @@ expand_case(Meta, Expr, Opts, S, E) ->
     end,
 
   {EOpts, SO, EO} = elixir_clauses:'case'(Meta, ROpts, SE, EE),
-
-  case prune_case_clauses(EExpr, EOpts) of
-    {ok, Pruned} -> {Pruned, SO, EO};
-    error -> {{'case', Meta, [EExpr, EOpts]}, SO, EO}
-  end.
-
-prune_case_clauses(false, [{do, [{'->', _, [[false], Body]}, {'->', _, [[true], _]}]}]) -> {ok, Body};
-prune_case_clauses(false, [{do, [{'->', _, [[true], _]}, {'->', _, [[false], Body]}]}]) -> {ok, Body};
-prune_case_clauses(true, [{do, [{'->', _, [[false], _]}, {'->', _, [[true], Body]}]}]) -> {ok, Body};
-prune_case_clauses(true, [{do, [{'->', _, [[true], Body]}, {'->', _, [[false], _]}]}]) -> {ok, Body};
-prune_case_clauses(_, _) -> error.
+  {{'case', Meta, [EExpr, EOpts]}, SO, EO}.
 
 rewrite_case_clauses([{do, [
   {'->', FalseMeta, [

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

@@ -1049,22 +1049,6 @@ defmodule Module.Types.ExprTest do
 
       assert type == atom([:ok, :error])
     end
-
-    test "does not report on literal booleans" do
-      assert typecheck!(
-               case true do
-                 true -> :ok
-                 false -> :error
-               end
-             ) == atom([:ok])
-
-      assert typecheck!(
-               case false do
-                 true -> :ok
-                 false -> :error
-               end
-             ) == atom([:error])
-    end
   end
 
   describe "conditionals" do
@@ -1073,7 +1057,7 @@ defmodule Module.Types.ExprTest do
                if true do
                  :ok
                end
-             ) == atom([:ok])
+             ) == atom([:ok, nil])
     end
   end