Let the type system and erlang compiler decide on the meaning optimize_boolean

Author: josevalim

lib/elixir/lib/module/types/expr.ex

@@ -246,7 +246,13 @@ defmodule Module.Types.Expr do
   def of_expr({:case, meta, [case_expr, [{:do, clauses}]]}, stack, context) do
     {case_type, context} = of_expr(case_expr, stack, context)
 
-    clauses
+    # If we are only type checking the expression and the expression is a literal,
+    # let's mark it as generated, as it is most likely a macro code.
+    if is_atom(case_expr) and {:type_check, :expr} in meta do
+      for {:->, meta, args} <- clauses, do: {:->, [generated: true] ++ meta, args}
+    else
+      clauses
+    end
     |> of_clauses([case_type], {:case, meta, case_type, case_expr}, stack, {none(), context})
     |> dynamic_unless_static(stack)
   end

lib/elixir/src/elixir_erl_pass.erl

@@ -302,9 +302,16 @@ translate(Other, Ann, S) ->
 
 translate_case(Meta, Expr, Opts, S) ->
   Ann = ?ann(Meta),
-  Clauses = elixir_erl_clauses:get_clauses(do, Opts, match),
   {TExpr, SE} = translate(Expr, Ann, S),
-  {TClauses, SC} = elixir_erl_clauses:clauses(Clauses, SE),
+  Clauses = elixir_erl_clauses:get_clauses(do, Opts, match),
+  RClauses =
+    %% For constructs that optimize booleans, we mark them as generated
+    %% to avoid reports from the Erlang compiler but specially Dialyzer.
+    case lists:member({optimize_boolean, true}, Meta) of
+      true -> [{N, ?generated(M), H, B} || {N, M, H, B} <- Clauses];
+      false -> Clauses
+    end,
+  {TClauses, SC} = elixir_erl_clauses:clauses(RClauses, SE),
   {{'case', Ann, TExpr, TClauses}, SC}.
 
 translate_list([{'|', _, [Left, Right]}], Ann, List, Acc) ->

lib/elixir/src/elixir_expand.erl

@@ -720,15 +720,9 @@ expand_case(Meta, Expr, Opts, S, E) ->
   {EExpr, SE, EE} = expand(Expr, S, E),
 
   ROpts =
-    case proplists:get_value(optimize_boolean, Meta, false) of
-      true ->
-        case elixir_utils:returns_boolean(EExpr) of
-          true -> rewrite_case_clauses(Opts);
-          false -> generated_case_clauses(Opts)
-        end;
-
-      false ->
-        Opts
+    case lists:member({optimize_boolean, true}, Meta) andalso elixir_utils:returns_boolean(EExpr) of
+      true -> rewrite_case_clauses(Opts);
+      false -> Opts
     end,
 
   {EOpts, SO, EO} = elixir_clauses:'case'(Meta, ROpts, SE, EE),
@@ -752,19 +746,15 @@ rewrite_case_clauses([{do, [
 ]}]) ->
   rewrite_case_clauses(FalseMeta, FalseExpr, TrueMeta, TrueExpr);
 
-rewrite_case_clauses(Other) ->
-  generated_case_clauses(Other).
+rewrite_case_clauses(Opts) ->
+  Opts.
 
 rewrite_case_clauses(FalseMeta, FalseExpr, TrueMeta, TrueExpr) ->
   [{do, [
-    {'->', ?generated(FalseMeta), [[false], FalseExpr]},
-    {'->', ?generated(TrueMeta), [[true], TrueExpr]}
+    {'->', FalseMeta, [[false], FalseExpr]},
+    {'->', TrueMeta, [[true], TrueExpr]}
   ]}].
 
-generated_case_clauses([{do, Clauses}]) ->
-  RClauses = [{'->', ?generated(Meta), Args} || {'->', Meta, Args} <- Clauses],
-  [{do, RClauses}].
-
 %% Comprehensions
 
 expand_for({for, Meta, [_ | _] = Args}, S, E, Return) ->

lib/elixir/test/elixir/kernel/import_test.exs

@@ -219,7 +219,7 @@ defmodule Kernel.ImportTest do
   end
 
   test "import lexical on case" do
-    case true do
+    case Process.get(:unused, true) do
       false ->
         import List
         flatten([1, [2], 3])

lib/elixir/test/elixir/kernel_test.exs

@@ -301,8 +301,8 @@ defmodule KernelTest do
     assert (false and true) == false
     assert (false and 0) == false
     assert (false and raise("oops")) == false
-    assert ((x = true) and not x) == false
-    assert_raise BadBooleanError, fn -> 0 and 1 end
+    assert ((x = Process.get(:unused, true)) and not x) == false
+    assert_raise BadBooleanError, fn -> Process.get(:unused, 0) and 1 end
   end
 
   test "or/2" do
@@ -313,8 +313,8 @@ defmodule KernelTest do
     assert (false or false) == false
     assert (false or true) == true
     assert (false or 0) == 0
-    assert ((x = false) or not x) == true
-    assert_raise BadBooleanError, fn -> 0 or 1 end
+    assert ((x = Process.get(:unused, false)) or not x) == true
+    assert_raise BadBooleanError, fn -> Process.get(:unused, 0) or 1 end
   end
 
   defp delegate_is_struct(arg), do: is_struct(arg)