Merge branch 'nox/compiler/beam_bool-not_boolean_expr'

* nox/compiler/beam_bool-not_boolean_expr:
  Compile BIF calls and operator expressions to Core the same way
  Do not try to optimize non-boolean guards

5 files changed, 109 insertions, 48 deletions

diff --git a/lib/compiler/src/beam_bool.erl b/lib/compiler/src/beam_bool.erl
index 81b6d78864..d01f9ee13d 100644
--- a/lib/compiler/src/beam_bool.erl
+++ b/lib/compiler/src/beam_bool.erl
@@ -531,7 +531,9 @@ bopt_cg({prot,Pre0,Tree}, Fail, Rs0, Acc, St0) ->
 bopt_cg({atom,true}, _Fail, _Rs, Acc, St) ->
     {Acc,St};
 bopt_cg({atom,false}, Fail, _Rs, Acc, St) ->
-    {[{jump,{f,Fail}}|Acc],St}.
+    {[{jump,{f,Fail}}|Acc],St};
+bopt_cg(_, _, _, _, _) ->
+    throw(not_boolean_expr).
 
 bopt_cg_not({'and',As0}) ->
     As = [bopt_cg_not(A) || A <- As0],
@@ -544,7 +546,9 @@ bopt_cg_not({'not',Arg}) ->
 bopt_cg_not({test,Test,Fail,As}) ->
     {inverted_test,Test,Fail,As};
 bopt_cg_not({atom,Bool}) when is_boolean(Bool) ->
-    {atom,not Bool}.
+    {atom,not Bool};
+bopt_cg_not(_) ->
+    throw(not_boolean_expr).
 
 bopt_cg_not_not({'and',As}) ->
     {'and',[bopt_cg_not_not(A) || A <- As]};
diff --git a/lib/compiler/src/v3_core.erl b/lib/compiler/src/v3_core.erl
index d3db395995..9c9941d039 100644
--- a/lib/compiler/src/v3_core.erl
+++ b/lib/compiler/src/v3_core.erl
@@ -274,51 +274,67 @@ gexpr({op,L,'orelse',E1,E2}, Bools, St0) ->
     True = {atom,L,true},
     E = make_bool_switch_guard(L, E1, V, True, E2),
     gexpr(E, Bools, St);
-gexpr({op,Line,Op,L,R}=Call, Bools0, St0) ->
+gexpr({op,Line,Op,L,R}=E, Bools, St) ->
     case erl_internal:bool_op(Op, 2) of
-	true ->
-	    {Le,Lps,Bools1,St1} = gexpr(L, Bools0, St0),
-	    {Ll,Llps,St2} = force_safe(Le, St1),
-	    {Re,Rps,Bools,St3} = gexpr(R, Bools1, St2),
-	    {Rl,Rlps,St4} = force_safe(Re, St3),
-	    Anno = lineno_anno(Line, St4),
-	    {#icall{anno=#a{anno=Anno},	%Must have an #a{}
-		    module=#c_literal{anno=Anno,val=erlang},
-		    name=#c_literal{anno=Anno,val=Op},
-		    args=[Ll,Rl]},Lps ++ Llps ++ Rps ++ Rlps,Bools,St4};
-	false ->
-	    gexpr_test(Call, Bools0, St0)
+        true ->
+            gexpr_bool(Op, L, R, Bools, St, Line);
+        false ->
+            gexpr_test(E, Bools, St)
     end;
-gexpr({op,Line,Op,A}=Call, Bools0, St0) ->
-    case Op of
-	'not' ->
-	    {Ae0,Aps,Bools,St1} = gexpr(A, Bools0, St0),
-	    case Ae0 of
-		#icall{module=#c_literal{val=erlang},
-		       name=#c_literal{val='=:='},
-		       args=[E,#c_literal{val=true}]}=EqCall ->
-		    %%
-		    %% Doing the following transformation
-		    %%    not(Expr =:= true)  ==>  Expr =:= false
-		    %% will help eliminating redundant is_boolean/1 tests.
-		    %%
-		    Ae = EqCall#icall{args=[E,#c_literal{val=false}]},
-		    {Al,Alps,St2} = force_safe(Ae, St1),
-		    {Al,Aps ++ Alps,Bools,St2};
-		Ae ->
-		    {Al,Alps,St2} = force_safe(Ae, St1),
-		    Anno = lineno_anno(Line, St2),
-		    {#icall{anno=#a{anno=Anno},	%Must have an #a{}
-			    module=#c_literal{anno=Anno,val=erlang},
-			    name=#c_literal{anno=Anno,val=Op},
-			    args=[Al]},Aps ++ Alps,Bools,St2}
-	    end;
-	_ ->
-	    gexpr_test(Call, Bools0, St0)
+gexpr({call,Line,{remote,_,{atom,_,erlang},{atom,_,Op}},[L,R]}=E, Bools, St) ->
+    case erl_internal:bool_op(Op, 2) of
+        true ->
+            gexpr_bool(Op, L, R, Bools, St, Line);
+        false ->
+            gexpr_test(E, Bools, St)
     end;
+gexpr({op,Line,'not',A}, Bools, St) ->
+    gexpr_not(A, Bools, St, Line);
+gexpr({call,Line,{remote,_,{atom,_,erlang},{atom,_,'not'}},[A]}, Bools, St) ->
+    gexpr_not(A, Bools, St, Line);
 gexpr(E0, Bools, St0) ->
     gexpr_test(E0, Bools, St0).
 
+%% gexpr_not(L, R, Bools, State) -> {Cexpr,[PreExp],Bools,State}.
+%%  Generate a guard for boolean operators
+
+gexpr_bool(Op, L, R, Bools0, St0, Line) ->
+    {Le,Lps,Bools1,St1} = gexpr(L, Bools0, St0),
+    {Ll,Llps,St2} = force_safe(Le, St1),
+    {Re,Rps,Bools,St3} = gexpr(R, Bools1, St2),
+    {Rl,Rlps,St4} = force_safe(Re, St3),
+    Anno = lineno_anno(Line, St4),
+    {#icall{anno=#a{anno=Anno}, %Must have an #a{}
+            module=#c_literal{anno=Anno,val=erlang},
+            name=#c_literal{anno=Anno,val=Op},
+            args=[Ll,Rl]},Lps ++ Llps ++ Rps ++ Rlps,Bools,St4}.
+
+%% gexpr_not(Expr, Bools, State) -> {Cexpr,[PreExp],Bools,State}.
+%%  Generate an erlang:'not'/1 guard test.
+
+gexpr_not(A, Bools0, St0, Line) ->
+    {Ae0,Aps,Bools,St1} = gexpr(A, Bools0, St0),
+    case Ae0 of
+        #icall{module=#c_literal{val=erlang},
+               name=#c_literal{val='=:='},
+               args=[E,#c_literal{val=true}]}=EqCall ->
+            %%
+            %% Doing the following transformation
+            %%    not(Expr =:= true)  ==>  Expr =:= false
+            %% will help eliminating redundant is_boolean/1 tests.
+            %%
+            Ae = EqCall#icall{args=[E,#c_literal{val=false}]},
+            {Al,Alps,St2} = force_safe(Ae, St1),
+            {Al,Aps ++ Alps,Bools,St2};
+        Ae ->
+            {Al,Alps,St2} = force_safe(Ae, St1),
+            Anno = lineno_anno(Line, St2),
+            {#icall{anno=#a{anno=Anno}, %Must have an #a{}
+                    module=#c_literal{anno=Anno,val=erlang},
+                    name=#c_literal{anno=Anno,val='not'},
+                    args=[Al]},Aps ++ Alps,Bools,St2}
+    end.
+
 %% gexpr_test(Expr, Bools, State) -> {Cexpr,[PreExp],Bools,State}.
 %%  Generate a guard test.  At this stage we must be sure that we have
 %%  a proper boolean value here so wrap things with an true test if we
@@ -335,7 +351,8 @@ gexpr_test(E0, Bools0, St0) ->
 	#icall{anno=Anno,module=#c_literal{val=erlang},name=#c_literal{val=N},args=As} ->
 	    Ar = length(As),
 	    case erl_internal:type_test(N, Ar) orelse
-		erl_internal:comp_op(N, Ar) of
+                erl_internal:comp_op(N, Ar) orelse
+                erl_internal:bool_op(N, Ar) of
 		true -> {E1,Eps0,Bools0,St1};
 		false ->
 		    Lanno = Anno#a.anno,
diff --git a/lib/compiler/test/andor_SUITE.erl b/lib/compiler/test/andor_SUITE.erl
index 7bef0aa27c..d79696df38 100644
--- a/lib/compiler/test/andor_SUITE.erl
+++ b/lib/compiler/test/andor_SUITE.erl
@@ -129,6 +129,10 @@ t_case_y(X, Y, Z) ->
 	    Y =:= 100
     end.
 
+-define(GUARD(E), if E -> true;
+             true -> false
+          end).
+
 t_and_or(Config) when is_list(Config) ->
     ?line true = true and true,
     ?line false = true and false,
@@ -160,11 +164,14 @@ t_and_or(Config) when is_list(Config) ->
     ?line true = false or id(true),
     ?line false = false or id(false),
 
-   ok.
+    True = id(true),
 
--define(GUARD(E), if E -> true;
-		     true -> false
-		  end).
+    false = ?GUARD(erlang:'and'(bar, True)),
+    false = ?GUARD(erlang:'or'(bar, True)),
+    false = ?GUARD(erlang:'not'(erlang:'and'(bar, True))),
+    false = ?GUARD(erlang:'not'(erlang:'not'(erlang:'and'(bar, True)))),
+
+   ok.
 
 t_andalso(Config) when is_list(Config) ->
     Bs = [true,false],
diff --git a/lib/compiler/test/core_SUITE.erl b/lib/compiler/test/core_SUITE.erl
index aa222c48de..428ad65364 100644
--- a/lib/compiler/test/core_SUITE.erl
+++ b/lib/compiler/test/core_SUITE.erl
@@ -24,7 +24,7 @@
 	 dehydrated_itracer/1,nested_tries/1,
 	 seq_in_guard/1,make_effect_seq/1,eval_is_boolean/1,
 	 unsafe_case/1,nomatch_shadow/1,reversed_annos/1,
-	 map_core_test/1,eval_case/1]).
+	 map_core_test/1,eval_case/1,bad_boolean_guard/1]).
 
 -include_lib("test_server/include/test_server.hrl").
 
@@ -50,7 +50,7 @@ groups() ->
     [{p,test_lib:parallel(),
       [dehydrated_itracer,nested_tries,seq_in_guard,make_effect_seq,
        eval_is_boolean,unsafe_case,nomatch_shadow,reversed_annos,
-       map_core_test,eval_case
+       map_core_test,eval_case,bad_boolean_guard
    ]}].
 
 
@@ -77,6 +77,7 @@ end_per_group(_GroupName, Config) ->
 ?comp(reversed_annos).
 ?comp(map_core_test).
 ?comp(eval_case).
+?comp(bad_boolean_guard).
 
 try_it(Mod, Conf) ->
     Src = filename:join(?config(data_dir, Conf), atom_to_list(Mod)),
diff --git a/lib/compiler/test/core_SUITE_data/bad_boolean_guard.core b/lib/compiler/test/core_SUITE_data/bad_boolean_guard.core
new file mode 100644
index 0000000000..318f8e3dc7
--- /dev/null
+++ b/lib/compiler/test/core_SUITE_data/bad_boolean_guard.core
@@ -0,0 +1,32 @@
+module 'bad_boolean_guard' ['bad_boolean_guard'/0,
+			    'module_info'/0,
+			    'module_info'/1]
+    attributes []
+'bad_boolean_guard'/0 =
+    fun () ->
+	apply 'f'/1
+	    ('true')
+'f'/1 =
+    fun (_X_cor0) ->
+	case _X_cor0 of
+	  <X>
+	      when try
+		    call 'erlang':'and'
+			('bad', _X_cor0)
+		of <Try> ->
+		    Try
+		catch <T,R> ->
+		    'false' ->
+	      'not_ok'
+	  <_X_cor3> when 'true' ->
+	      'ok'
+	end
+'module_info'/0 =
+    fun () ->
+	call 'erlang':'get_module_info'
+	    ('bad_boolean_guard')
+'module_info'/1 =
+    fun (_X_cor0) ->
+	call 'erlang':'get_module_info'
+	    ('bad_boolean_guard', _X_cor0)
+end
\ No newline at end of file