dialyzer: Unfold cerl patterns containing maps

Dialyzer relies heavily on the assumption that the type of a literal
that is used as a pattern is the type of any value that can match that
pattern. For maps, that is not true, and it was causing bad analysis
results. A new help function dialyzer_utils:refold_pattern/1 identifies
maps in literal patterns, and unfolds and labels them, allowing them to
be properly analysed.

1 files changed, 51 insertions, 0 deletions

diff --git a/lib/dialyzer/src/dialyzer_utils.erl b/lib/dialyzer/src/dialyzer_utils.erl
index 5fc1c0e691..b3505f5197 100644
--- a/lib/dialyzer/src/dialyzer_utils.erl
+++ b/lib/dialyzer/src/dialyzer_utils.erl
@@ -49,6 +49,7 @@
 	 process_record_remote_types/1,
          sets_filter/2,
 	 src_compiler_opts/0,
+	 refold_pattern/1,
 	 parallelism/0,
          family/1
 	]).
@@ -834,6 +835,56 @@ pp_atom(Atom) ->
 
 %%------------------------------------------------------------------------------
 
+-spec refold_pattern(cerl:cerl()) -> cerl:cerl().
+
+refold_pattern(Pat) ->
+  %% Avoid the churn of unfolding and refolding
+  case cerl:is_literal(Pat) andalso find_map(cerl:concrete(Pat)) of
+    true ->
+      Tree = refold_concrete_pat(cerl:concrete(Pat)),
+      [{label, Label}] = cerl:get_ann(Tree),
+      cerl:set_ann(Tree, [{label, Label}|cerl:get_ann(Pat)]);
+    false -> Pat
+  end.
+
+find_map(#{}) -> true;
+find_map(Tuple) when is_tuple(Tuple) -> find_map(tuple_to_list(Tuple));
+find_map([H|T]) -> find_map(H) orelse find_map(T);
+find_map(_) -> false.
+
+refold_concrete_pat(Val) ->
+  case Val of
+    _ when is_tuple(Val) ->
+      Els = lists:map(fun refold_concrete_pat/1, tuple_to_list(Val)),
+      case lists:all(fun cerl:is_literal/1, Els) of
+	true -> cerl:abstract(Val);
+	false -> label(cerl:c_tuple_skel(Els))
+      end;
+    [H|T] ->
+      case  cerl:is_literal(HP=refold_concrete_pat(H))
+	and cerl:is_literal(TP=refold_concrete_pat(T))
+      of
+	true -> cerl:abstract(Val);
+	false -> label(cerl:c_cons_skel(HP, TP))
+      end;
+    M when is_map(M) ->
+      %% Map patterns are not generated by the parser(!), but they have a
+      %% property we want, namely that they are never folded into literals.
+      %% N.B.: The key in a map pattern is an expression, *not* a pattern.
+      label(cerl:c_map_pattern([cerl:c_map_pair_exact(cerl:abstract(K),
+						      refold_concrete_pat(V))
+				|| {K, V} <- maps:to_list(M)]));
+    _ ->
+      cerl:abstract(Val)
+  end.
+
+label(Tree) ->
+      %% Sigh
+      Label = -erlang:unique_integer([positive]),
+      cerl:set_ann(Tree, [{label, Label}]).
+
+%%------------------------------------------------------------------------------
+
 -spec parallelism() -> integer().
 
 parallelism() ->