Merge branch 'sa/dialyzer-fix-guards' into dev

* sa/dialyzer-fix-guards:
  Fix warnings about guards containing not
  Fix errors in the handling of 'and'/'or' guards
  Cosmetic changes

OTP-9099

2 files changed, 75 insertions, 47 deletions

diff --git a/lib/dialyzer/src/dialyzer.erl b/lib/dialyzer/src/dialyzer.erl
index f4b3cff19c..dde0c17c39 100644
--- a/lib/dialyzer/src/dialyzer.erl
+++ b/lib/dialyzer/src/dialyzer.erl
@@ -336,6 +336,8 @@ message_to_string({guard_fail, [Arg1, Infix, Arg2]}) ->
   io_lib:format("Guard test ~s ~s ~s can never succeed\n", [Arg1, Infix, Arg2]);
 message_to_string({guard_fail, [Guard, Args]}) ->
   io_lib:format("Guard test ~w~s can never succeed\n", [Guard, Args]);
+message_to_string({neg_guard_fail, [Guard, Args]}) ->
+  io_lib:format("Guard test not(~w~s) can never succeed\n", [Guard, Args]);
 message_to_string({guard_fail_pat, [Pat, Type]}) ->
   io_lib:format("Clause guard cannot succeed. The ~s was matched"
 		" against the type ~s\n", [Pat, Type]);
diff --git a/lib/dialyzer/src/dialyzer_dataflow.erl b/lib/dialyzer/src/dialyzer_dataflow.erl
index b80c7efc1a..2ffbcd3e82 100644
--- a/lib/dialyzer/src/dialyzer_dataflow.erl
+++ b/lib/dialyzer/src/dialyzer_dataflow.erl
@@ -1457,6 +1457,7 @@ do_clause(C, Arg, ArgType0, OrigArgType, Map,
 		  false ->
 		    WarnType = case Msg of
 				 {guard_fail, _} -> ?WARN_MATCHING;
+				 {neg_guard_fail, _} -> ?WARN_MATCHING;
 				 {opaque_guard, _} -> ?WARN_OPAQUE
 			       end,
 		    state__add_warning(State1, WarnType, FailGuard, Msg);
@@ -1748,7 +1749,7 @@ bind_opaque_pats(GenType, Type, Pat, Map, State, Rev) ->
 
 bind_guard(Guard, Map, State) ->
   try bind_guard(Guard, Map, dict:new(), pos, State) of
-      {Map1, _Type} -> Map1
+    {Map1, _Type} -> Map1
   catch
     throw:{fail, Warning} -> {error, Warning};
     throw:{fatal_fail, Warning} -> {error, Warning}
@@ -1869,8 +1870,8 @@ handle_guard_gen_fun({M, F, A}, Guard, Map, Env, Eval, State) ->
     true ->
       %% Is this an error-bif?
       case t_is_none(erl_bif_types:type(M, F, A)) of
-	true -> signal_guard_fail(Guard, As, State);
-	false -> signal_guard_fatal_fail(Guard, As, State)
+	true -> signal_guard_fail(Eval, Guard, As, State);
+	false -> signal_guard_fatal_fail(Eval, Guard, As, State)
       end;
     false ->
       BifArgs = case erl_bif_types:arg_types(M, F, A) of
@@ -1887,7 +1888,7 @@ handle_guard_gen_fun({M, F, A}, Guard, Map, Env, Eval, State) ->
       case t_is_none(Ret) of
 	true ->
 	  case Eval =:= pos of
-	    true -> signal_guard_fail(Guard, As, State);
+	    true -> signal_guard_fail(Eval, Guard, As, State);
 	    false -> throw({fail, none})
 	  end;
 	false -> {Map2, Ret}
@@ -1900,7 +1901,7 @@ handle_guard_type_test(Guard, F, Map, Env, Eval, State) ->
   case bind_type_test(Eval, F, ArgType, State) of
     error ->
       ?debug("Type test: ~w failed\n", [F]),
-      signal_guard_fail(Guard, [ArgType], State);
+      signal_guard_fail(Eval, Guard, [ArgType], State);
     {ok, NewArgType, Ret} ->
       ?debug("Type test: ~w succeeded, NewType: ~s, Ret: ~s\n",
 	     [F, t_to_string(NewArgType), t_to_string(Ret)]),
@@ -1963,18 +1964,19 @@ handle_guard_comp(Guard, Comp, Map, Env, Eval, State) ->
 	true  when Eval =:= pos ->       {Map, t_atom(true)};
 	true  when Eval =:= dont_know -> {Map, t_atom(true)};
 	true  when Eval =:= neg ->       {Map, t_atom(true)};
-	false when Eval =:= pos -> signal_guard_fail(Guard, ArgTypes, State);
+	false when Eval =:= pos ->
+	  signal_guard_fail(Eval, Guard, ArgTypes, State);
 	false when Eval =:= dont_know -> {Map, t_atom(false)};
 	false when Eval =:= neg ->       {Map, t_atom(false)}
       end;
     {literal, var} when IsInt1 andalso IsInt2 andalso (Eval =:= pos) ->
       case bind_comp_literal_var(Arg1, Arg2, Type2, Comp, Map1) of
-	error -> signal_guard_fail(Guard, ArgTypes, State);
+	error -> signal_guard_fail(Eval, Guard, ArgTypes, State);
 	{ok, NewMap} -> {NewMap, t_atom(true)}
       end;
     {var, literal} when IsInt1 andalso IsInt2 andalso (Eval =:= pos) ->
       case bind_comp_literal_var(Arg2, Arg1, Type1, invert_comp(Comp), Map1) of
-	error -> signal_guard_fail(Guard, ArgTypes, State);
+	error -> signal_guard_fail(Eval, Guard, ArgTypes, State);
 	{ok, NewMap} -> {NewMap, t_atom(true)}
       end;
     {_, _} ->
@@ -2014,7 +2016,7 @@ handle_guard_is_function(Guard, Map, Env, Eval, State) ->
   [FunType0, ArityType0] = ArgTypes0,
   ArityType = t_inf(ArityType0, t_integer()),
   case t_is_none(ArityType) of
-    true -> signal_guard_fail(Guard, ArgTypes0, State);
+    true -> signal_guard_fail(Eval, Guard, ArgTypes0, State);
     false ->
       FunTypeConstr =
 	case t_number_vals(ArityType) of
@@ -2026,7 +2028,7 @@ handle_guard_is_function(Guard, Map, Env, Eval, State) ->
       case t_is_none(FunType) of
 	true ->
 	  case Eval of
-	    pos -> signal_guard_fail(Guard, ArgTypes0, State);
+	    pos -> signal_guard_fail(Eval, Guard, ArgTypes0, State);
 	    neg -> {Map1, t_atom(false)};
 	    dont_know -> {Map1, t_atom(false)}
 	  end;
@@ -2062,7 +2064,7 @@ handle_guard_is_record(Guard, Map, Env, Eval, State) ->
   case t_is_none(Type) of
     true ->
       case Eval of
-	pos -> signal_guard_fail(Guard,
+	pos -> signal_guard_fail(Eval, Guard,
 				 [RecType, t_from_term(Tag),
 				  t_from_term(Arity)],
 				 State);
@@ -2095,7 +2097,7 @@ handle_guard_eq(Guard, Map, Env, Eval, State) ->
 	    Eval =:= pos ->
 	      ArgTypes = [t_from_term(cerl:concrete(Arg1)),
 			  t_from_term(cerl:concrete(Arg2))],
-	      signal_guard_fail(Guard, ArgTypes, State)
+	      signal_guard_fail(Eval, Guard, ArgTypes, State)
 	  end
       end;
     {literal, _} when Eval =:= pos ->
@@ -2150,7 +2152,7 @@ handle_guard_eqeq(Guard, Map, Env, Eval, State) ->
 	     Eval =:= pos ->
 	      ArgTypes = [t_from_term(cerl:concrete(Arg1)),
 			  t_from_term(cerl:concrete(Arg2))],
-	      signal_guard_fail(Guard, ArgTypes, State)
+	      signal_guard_fail(Eval, Guard, ArgTypes, State)
 	  end
       end;
     {literal, _} when Eval =:= pos ->
@@ -2172,7 +2174,7 @@ bind_eqeq_guard(Guard, Arg1, Arg2, Map, Env, Eval, State) ->
       case Eval of
 	neg -> {Map2, t_atom(false)};
 	dont_know -> {Map2, t_atom(false)};
-	pos -> signal_guard_fail(Guard, [Type1, Type2], State)
+	pos -> signal_guard_fail(Eval, Guard, [Type1, Type2], State)
       end;
     false ->
       case Eval of
@@ -2199,29 +2201,29 @@ bind_eqeq_guard(Guard, Arg1, Arg2, Map, Env, Eval, State) ->
   end.
 
 bind_eqeq_guard_lit_other(Guard, Arg1, Arg2, Map, Env, State) ->
-  %% Assumes positive evaluation
+  Eval = dont_know,
   case cerl:concrete(Arg1) of
     true ->
       {_, Type} = MT = bind_guard(Arg2, Map, Env, pos, State),
       case t_is_atom(true, Type) of
 	true -> MT;
 	false ->
-	  {_, Type0} = bind_guard(Arg2, Map, Env, dont_know, State),
-	  signal_guard_fail(Guard, [Type0, t_atom(true)], State)
+	  {_, Type0} = bind_guard(Arg2, Map, Env, Eval, State),
+	  signal_guard_fail(Eval, Guard, [Type0, t_atom(true)], State)
       end;
     false ->
       {Map1, Type} = bind_guard(Arg2, Map, Env, neg, State),
       case t_is_atom(false, Type) of
 	true -> {Map1, t_atom(true)};
 	false ->
-	  {_, Type0} = bind_guard(Arg2, Map, Env, dont_know, State),
-	  signal_guard_fail(Guard, [Type0, t_atom(true)], State)
+	  {_, Type0} = bind_guard(Arg2, Map, Env, Eval, State),
+	  signal_guard_fail(Eval, Guard, [Type0, t_atom(true)], State)
       end;
     Term ->
       LitType = t_from_term(Term),
-      {Map1, Type} = bind_guard(Arg2, Map, Env, dont_know, State),
+      {Map1, Type} = bind_guard(Arg2, Map, Env, Eval, State),
       case t_is_subtype(LitType, Type) of
-	false -> signal_guard_fail(Guard, [Type, LitType], State);
+	false -> signal_guard_fail(Eval, Guard, [Type, LitType], State);
 	true ->
 	  case cerl:is_c_var(Arg2) of
 	    true -> {enter_type(Arg2, LitType, Map1), t_atom(true)};
@@ -2250,31 +2252,37 @@ handle_guard_and(Guard, Map, Env, Eval, State) ->
 	catch throw:{fail, _} -> bind_guard(Arg2, Map, Env, pos, State)
 	end,
       {Map2, Type2} =
-	try bind_guard(Arg1, Map, Env, neg, State)
-	catch throw:{fail, _} -> bind_guard(Arg2, Map, Env, pos, State)
+	try bind_guard(Arg2, Map, Env, neg, State)
+	catch throw:{fail, _} -> bind_guard(Arg1, Map, Env, pos, State)
 	end,
       case t_is_atom(false, Type1) orelse t_is_atom(false, Type2) of
 	true -> {join_maps([Map1, Map2], Map), t_atom(false)};
 	false -> throw({fail, none})
       end;
     dont_know ->
-      True = t_atom(true),
       {Map1, Type1} = bind_guard(Arg1, Map, Env, dont_know, State),
-      case t_is_none(t_inf(Type1, t_boolean())) of
-	true -> throw({fail, none});
+      {Map2, Type2} = bind_guard(Arg2, Map, Env, dont_know, State),
+      Bool1 = t_inf(Type1, t_boolean()),
+      Bool2 = t_inf(Type2, t_boolean()),
+      case t_is_none(Bool1) orelse t_is_none(Bool2) of
+	true -> throw({fatal_fail, none});
 	false ->
-	  {Map2, Type2} = bind_guard(Arg2, Map1, Env, Eval, State),
-	  case t_is_none(t_inf(Type2, t_boolean())) of
-	    true -> throw({fail, none});
-	    false -> {Map2, True}
-	  end
+	  NewMap = join_maps([Map1, Map2], Map),
+	  NewType =
+	    case {t_atom_vals(Bool1), t_atom_vals(Bool2)} of
+	      {['true'] , ['true'] } -> t_atom(true);
+	      {['false'], _        } -> t_atom(false);
+	      {_        , ['false']} -> t_atom(false);
+	      {_        , _        } -> t_boolean()
+	    end,
+	  {NewMap, NewType}
       end
   end.
 
 handle_guard_or(Guard, Map, Env, Eval, State) ->
   [Arg1, Arg2] = cerl:call_args(Guard),
   case Eval of
-	pos ->
+    pos ->
       {Map1, Bool1} =
 	try bind_guard(Arg1, Map, Env, pos, State)
 	catch
@@ -2303,11 +2311,22 @@ handle_guard_or(Guard, Map, Env, Eval, State) ->
 	  end
       end;
     dont_know ->
-      {Map1, Bool1} = bind_guard(Arg1, Map, Env, dont_know, State),
-      {Map2, Bool2} = bind_guard(Arg2, Map, Env, dont_know, State),
-      case t_is_boolean(Bool1) andalso t_is_boolean(Bool2) of
-	true -> {join_maps([Map1, Map2], Map), t_sup(Bool1, Bool2)};
-	false -> throw({fail, none})
+      {Map1, Type1} = bind_guard(Arg1, Map, Env, dont_know, State),
+      {Map2, Type2} = bind_guard(Arg2, Map, Env, dont_know, State),
+      Bool1 = t_inf(Type1, t_boolean()),
+      Bool2 = t_inf(Type2, t_boolean()),
+      case t_is_none(Bool1) orelse t_is_none(Bool2) of
+	true -> throw({fatal_fail, none});
+	false ->
+	  NewMap = join_maps([Map1, Map2], Map),
+	  NewType =
+	    case {t_atom_vals(Bool1), t_atom_vals(Bool2)} of
+	      {['false'], ['false']} -> t_atom(false);
+	      {['true'] , _        } -> t_atom(true);
+	      {_        , ['true'] } -> t_atom(true);
+	      {_        , _        } -> t_boolean()
+	    end,
+	  {NewMap, NewType}
       end
   end.
 
@@ -2349,10 +2368,12 @@ bind_guard_list([G|Gs], Map, Env, Eval, State, Acc) ->
 bind_guard_list([], Map, _Env, _Eval, _State, Acc) ->
   {Map, lists:reverse(Acc)}.
 
--spec signal_guard_fail(cerl:c_call(), [erl_types:erl_type()], state()) ->
-        no_return().
+-type eval() :: 'pos' | 'neg' | 'dont_know'.
+
+-spec signal_guard_fail(eval(), cerl:c_call(), [erl_types:erl_type()],
+			state()) -> no_return().
 
-signal_guard_fail(Guard, ArgTypes, State) ->
+signal_guard_fail(Eval, Guard, ArgTypes, State) ->
   Args = cerl:call_args(Guard),
   F = cerl:atom_val(cerl:call_name(Guard)),
   MFA = {cerl:atom_val(cerl:call_module(Guard)), F, length(Args)},
@@ -2365,7 +2386,7 @@ signal_guard_fail(Guard, ArgTypes, State) ->
 		      atom_to_list(F),
 		      format_args_1([Arg2], [ArgType2], State)]};
       false ->
-	mk_guard_msg(F, Args, ArgTypes, State)
+	mk_guard_msg(Eval, F, Args, ArgTypes, State)
     end,
   throw({fail, {Guard, Msg}}).
 
@@ -2380,20 +2401,25 @@ is_infix_op({erlang, '>=', 2}) -> true;
 is_infix_op({M, F, A}) when is_atom(M), is_atom(F),
 			    is_integer(A), 0 =< A, A =< 255 -> false.
 
--spec signal_guard_fatal_fail(cerl:c_call(), [erl_types:erl_type()], state()) ->
-        no_return().
+-spec signal_guard_fatal_fail(eval(), cerl:c_call(), [erl_types:erl_type()],
+			      state()) -> no_return().
 
-signal_guard_fatal_fail(Guard, ArgTypes, State) ->
+signal_guard_fatal_fail(Eval, Guard, ArgTypes, State) ->
   Args = cerl:call_args(Guard),
   F = cerl:atom_val(cerl:call_name(Guard)),
-  Msg = mk_guard_msg(F, Args, ArgTypes, State),
+  Msg = mk_guard_msg(Eval, F, Args, ArgTypes, State),
   throw({fatal_fail, {Guard, Msg}}).
 
-mk_guard_msg(F, Args, ArgTypes, State) ->
+mk_guard_msg(Eval, F, Args, ArgTypes, State) ->
   FArgs = [F, format_args(Args, ArgTypes, State)],
   case any_has_opaque_subtype(ArgTypes) of
     true -> {opaque_guard, FArgs};
-    false -> {guard_fail, FArgs}
+    false ->
+      case Eval of
+	neg -> {neg_guard_fail, FArgs};
+	pos -> {guard_fail, FArgs};
+	dont_know -> {guard_fail, FArgs}
+      end
   end.
 
 bind_guard_case_clauses(Arg, Clauses, Map, Env, Eval, State) ->