erl_bif_types: Add a selection of maps BIFs

 * maps:from_list/1
 * maps:get/2
 * maps:is_key/2
 * maps:merge/2
 * maps:put/3
 * maps:size/1
 * maps:to_list/1
 * maps:update/3

4 files changed, 208 insertions, 3 deletions

diff --git a/lib/dialyzer/test/small_SUITE_data/results/literals b/lib/dialyzer/test/small_SUITE_data/results/literals
index 222d2c0cdb..5d611f520b 100644
--- a/lib/dialyzer/test/small_SUITE_data/results/literals
+++ b/lib/dialyzer/test/small_SUITE_data/results/literals
@@ -5,6 +5,7 @@ literals.erl:14: Function t2/0 has no local return
 literals.erl:15: Record construction #r{id::'a'} violates the declared type of field id::'integer'
 literals.erl:17: Function t3/0 has no local return
 literals.erl:18: Record construction #r{id::'a'} violates the declared type of field id::'integer'
+literals.erl:20: Function t4/0 has no local return
 literals.erl:21: Record construction #r{id::'a'} violates the declared type of field id::'integer'
 literals.erl:23: Function m1/1 has no local return
 literals.erl:23: Matching of pattern {'r', 'a'} tagged with a record name violates the declared type of #r{id::'integer'}
diff --git a/lib/dialyzer/test/small_SUITE_data/src/literals.erl b/lib/dialyzer/test/small_SUITE_data/src/literals.erl
index abd7033712..3aefbf1a4e 100644
--- a/lib/dialyzer/test/small_SUITE_data/src/literals.erl
+++ b/lib/dialyzer/test/small_SUITE_data/src/literals.erl
@@ -18,7 +18,7 @@ t3() ->
     {#r{id = a}}. % violation
 
 t4() ->
-    #{a => #r{id = a}}. % violation found, but t4() returns... (bug)
+    #{a => #r{id = a}}. % violation
 
 m1(#r{id = a}) -> % violation
     ok.
diff --git a/lib/hipe/cerl/erl_bif_types.erl b/lib/hipe/cerl/erl_bif_types.erl
index 7684dc4a81..9453ca6c6f 100644
--- a/lib/hipe/cerl/erl_bif_types.erl
+++ b/lib/hipe/cerl/erl_bif_types.erl
@@ -115,7 +115,16 @@
 		    t_tuple_size/2,
 		    t_tuple_subtypes/2,
 		    t_is_map/2,
-		    t_map/0
+		    t_map/0,
+		    t_map/3,
+		    t_map_def_key/2,
+		    t_map_def_val/2,
+		    t_map_get/3,
+		    t_map_is_key/3,
+		    t_map_entries/2,
+		    t_map_put/3,
+		    t_map_update/3,
+		    map_pairwise_merge/3
 		   ]).
 
 -ifdef(DO_ERL_BIF_TYPES_TEST).
@@ -755,7 +764,7 @@ type(erlang, length, 1, Xs, Opaques) ->
   strict(erlang, length, 1, Xs, fun (_) -> t_non_neg_fixnum() end, Opaques);
 %% Guard bif, needs to be here.
 type(erlang, map_size, 1, Xs, Opaques) ->
-  strict(erlang, map_size, 1, Xs, fun (_) -> t_non_neg_integer() end, Opaques);
+  type(maps, size, 1, Xs, Opaques);
 type(erlang, make_fun, 3, Xs, Opaques) ->
   strict(erlang, make_fun, 3, Xs,
          fun ([_, _, Arity]) ->
@@ -1645,6 +1654,89 @@ type(lists, zipwith3, 4, Xs, Opaques) ->
 	 fun ([F,_As,_Bs,_Cs]) -> t_sup(t_list(t_fun_range(F, Opaques)),
                                         t_nil()) end, Opaques);
 
+%%-- maps ---------------------------------------------------------------------
+type(maps, from_list, 1, Xs, Opaques) ->
+  strict(maps, from_list, 1, Xs,
+	 fun ([List]) ->
+	     case t_is_nil(List, Opaques) of
+	       true -> t_from_term(#{});
+	       false ->
+		 T = t_list_elements(List, Opaques),
+		 case t_tuple_subtypes(T, Opaques) of
+		   unknown -> t_map();
+		   Stypes when length(Stypes) >= 1 ->
+		     t_sup([begin
+			      [K, V] = t_tuple_args(Args, Opaques),
+			      t_map([], K, V)
+			    end || Args <- Stypes])
+		 end
+	     end
+	 end, Opaques);
+type(maps, get, 2, Xs, Opaques) ->
+  strict(maps, get, 2, Xs,
+	 fun ([Key, Map]) ->
+	     t_map_get(Key, Map, Opaques)
+	 end, Opaques);
+type(maps, is_key, 2, Xs, Opaques) ->
+  strict(maps, is_key, 2, Xs,
+	 fun ([Key, Map]) ->
+	     t_map_is_key(Key, Map, Opaques)
+	 end, Opaques);
+type(maps, merge, 2, Xs, Opaques) ->
+  strict(maps, merge, 2, Xs,
+	 fun ([MapA, MapB]) ->
+	     ADefK = t_map_def_key(MapA, Opaques),
+	     BDefK = t_map_def_key(MapB, Opaques),
+	     ADefV = t_map_def_val(MapA, Opaques),
+	     BDefV = t_map_def_val(MapB, Opaques),
+	     t_map(map_pairwise_merge(
+		     fun(K, _,     _,  mandatory, V) -> {K, mandatory, V};
+			(K, MNess, VA, optional, VB) -> {K, MNess, t_sup(VA,VB)}
+		     end, MapA, MapB),
+		   t_sup(ADefK, BDefK), t_sup(ADefV, BDefV))
+	 end, Opaques);
+type(maps, put, 3, Xs, Opaques) ->
+  strict(maps, put, 3, Xs,
+	 fun ([Key, Value, Map]) ->
+	     t_map_put({Key, Value}, Map, Opaques)
+	 end, Opaques);
+type(maps, size, 1, Xs, Opaques) ->
+  strict(maps, size, 1, Xs,
+	 fun ([Map]) ->
+	     Mand = [E || E={_,mandatory,_} <- t_map_entries(Map, Opaques)],
+	     LowerBound = length(Mand),
+	     case t_is_none(t_map_def_key(Map, Opaques)) of
+	       false -> t_from_range(LowerBound, pos_inf);
+	       true ->
+		 Opt = [E || E={_,optional,_} <- t_map_entries(Map, Opaques)],
+		 UpperBound = LowerBound + length(Opt),
+		 t_from_range(LowerBound, UpperBound)
+	     end
+	 end, Opaques);
+type(maps, to_list, 1, Xs, Opaques) ->
+  strict(maps, to_list, 1, Xs,
+	 fun ([Map]) ->
+	     DefK = t_map_def_key(Map, Opaques),
+	     DefV = t_map_def_val(Map, Opaques),
+	     Pairs = t_map_entries(Map, Opaques),
+	     EType = lists:foldl(
+		       fun({K,_,V},EType0) ->
+			   case t_is_none(V) of
+			     true -> t_subtract(EType0, t_tuple([K,t_any()]));
+			     false -> t_sup(EType0, t_tuple([K,V]))
+			   end
+		       end, t_tuple([DefK, DefV]), Pairs),
+	     case t_is_none(EType) of
+	       true -> t_nil();
+	       false -> t_list(EType)
+	     end
+	 end, Opaques);
+type(maps, update, 3, Xs, Opaques) ->
+  strict(maps, update, 3, Xs,
+	 fun ([Key, Value, Map]) ->
+	     t_map_update({Key, Value}, Map, Opaques)
+	 end, Opaques);
+
 %%-----------------------------------------------------------------------------
 type(M, F, A, Xs, _O) when is_atom(M), is_atom(F),
 		       is_integer(A), 0 =< A, A =< 255 ->
@@ -2556,6 +2648,23 @@ arg_types(lists, zipwith, 3) ->
   [t_fun([t_any(), t_any()], t_any()), t_list(), t_list()];
 arg_types(lists, zipwith3, 4) ->
   [t_fun([t_any(), t_any(), t_any()], t_any()), t_list(), t_list(), t_list()];
+%%------- maps ----------------------------------------------------------------
+arg_types(maps, from_list, 1) ->
+  [t_list(t_tuple(2))];
+arg_types(maps, get, 2) ->
+  [t_any(), t_map()];
+arg_types(maps, is_key, 2) ->
+  [t_any(), t_map()];
+arg_types(maps, merge, 2) ->
+  [t_map(), t_map()];
+arg_types(maps, put, 3) ->
+  [t_any(), t_any(), t_map()];
+arg_types(maps, size, 1) ->
+  [t_map()];
+arg_types(maps, to_list, 1) ->
+  [t_map()];
+arg_types(maps, update, 3) ->
+  [t_any(), t_any(), t_map()];
 arg_types(M, F, A) when is_atom(M), is_atom(F),
 			is_integer(A), 0 =< A, A =< 255 ->
   unknown.                     % safe approximation for all functions.
diff --git a/lib/hipe/cerl/erl_types.erl b/lib/hipe/cerl/erl_types.erl
index 6c4386892d..ea69e54c83 100644
--- a/lib/hipe/cerl/erl_types.erl
+++ b/lib/hipe/cerl/erl_types.erl
@@ -158,6 +158,9 @@
 	 t_map_entries/2, t_map_entries/1,
 	 t_map_def_key/2, t_map_def_key/1,
 	 t_map_def_val/2, t_map_def_val/1,
+	 t_map_get/2, t_map_get/3,
+	 t_map_is_key/2, t_map_is_key/3,
+	 t_map_update/2, t_map_update/3,
 	 t_map_put/2, t_map_put/3,
 	 t_matchstate/0,
 	 t_matchstate/2,
@@ -1851,6 +1854,93 @@ map_put({Key, Value}, ?map(Pairs,DefK,DefV), Opaques) ->
       end
   end.
 
+-spec t_map_update({erl_type(), erl_type()}, erl_type()) -> erl_type().
+
+t_map_update(KV, Map) ->
+  t_map_update(KV, Map, 'universe').
+
+-spec t_map_update({erl_type(), erl_type()}, erl_type(), opaques()) -> erl_type().
+
+t_map_update(_, ?none, _) -> ?none;
+t_map_update(KV={Key, _}, M, Opaques) ->
+  case t_is_subtype(t_atom('true'), t_map_is_key(Key, M, Opaques)) of
+    false -> ?none;
+    true -> t_map_put(KV, M, Opaques)
+  end.
+
+-spec t_map_get(erl_type(), erl_type()) -> erl_type().
+
+t_map_get(Key, Map) ->
+  t_map_get(Key, Map, 'universe').
+
+-spec t_map_get(erl_type(), erl_type(), opaques()) -> erl_type().
+
+t_map_get(Key, Map, Opaques) ->
+  do_opaque(Map, Opaques,
+	    fun(UM) ->
+		do_opaque(Key, Opaques, fun(UK) -> map_get(UK, UM) end)
+	    end).
+
+map_get(_, ?none) -> ?none;
+map_get(Key, ?map(Pairs, DefK, DefV)) ->
+  DefRes =
+    case t_do_overlap(DefK, Key) of
+      false -> t_none();
+      true -> DefV
+    end,
+  case t_is_singleton(Key) of
+    false ->
+      lists:foldl(fun({K, _, V}, Res) ->
+		      case t_do_overlap(K, Key) of
+			false -> Res;
+			true -> t_sup(Res, V)
+		      end
+		  end, DefRes, Pairs);
+    true ->
+      case lists:keyfind(Key, 1, Pairs) of
+	false -> DefRes;
+	{_, _, ValType} -> ValType
+      end
+  end.
+
+-spec t_map_is_key(erl_type(), erl_type()) -> erl_type().
+
+t_map_is_key(Key, Map) ->
+  t_map_is_key(Key, Map, 'universe').
+
+-spec t_map_is_key(erl_type(), erl_type(), opaques()) -> erl_type().
+
+t_map_is_key(Key, Map, Opaques) ->
+  do_opaque(Map, Opaques,
+	    fun(UM) ->
+		do_opaque(Key, Opaques, fun(UK) -> map_is_key(UK, UM) end)
+	    end).
+
+map_is_key(_, ?none) -> ?none;
+map_is_key(Key, ?map(Pairs, DefK, _DefV)) ->
+  case t_is_singleton(Key) of
+    true ->
+      case lists:keyfind(Key, 1, Pairs) of
+	{Key, ?mand, _}     -> t_atom(true);
+	{Key, ?opt,  ?none} -> t_atom(false);
+	{Key, ?opt,  _}     -> t_boolean();
+	false ->
+	  case t_do_overlap(DefK, Key) of
+	    false -> t_atom(false);
+	    true -> t_boolean()
+	  end
+      end;
+    false ->
+      case t_do_overlap(DefK, Key)
+	orelse lists:any(fun({_,_,?none}) -> false;
+			    ({K,_,_}) -> t_do_overlap(K, Key)
+			 end, Pairs)
+      of
+	true -> t_boolean();
+	false -> t_atom(false)
+      end
+  end.
+
 %%-----------------------------------------------------------------------------
 %% Tuples
 %%
@@ -3931,6 +4021,11 @@ subtype_is_equal(T1, T2) ->
 t_is_instance(ConcreteType, Type) ->
   t_is_subtype(ConcreteType, t_unopaque(Type)).
 
+-spec t_do_overlap(erl_type(), erl_type()) -> boolean().
+
+t_do_overlap(TypeA, TypeB) ->
+  not (t_is_none_or_unit(t_inf(TypeA, TypeB))).
+
 -spec t_unopaque(erl_type()) -> erl_type().
 
 t_unopaque(T) ->