20 files changed, 506 insertions, 211 deletions
diff --git a/lib/compiler/src/beam_disasm.erl b/lib/compiler/src/beam_disasm.erl
index 4bdfe4e0c2..c45596f236 100644
--- a/lib/compiler/src/beam_disasm.erl
+++ b/lib/compiler/src/beam_disasm.erl
@@ -1030,6 +1030,7 @@ resolve_inst({gc_bif2,Args},Imports,_,_) ->
     [F,Live,Bif,A1,A2,Reg] = resolve_args(Args),
     {extfunc,_Mod,BifName,_Arity} = lookup(Bif+1,Imports),
     {gc_bif,BifName,F,Live,[A1,A2],Reg};
+
 %%
 %% New instruction in R14, gc_bif with 3 arguments
 %%
@@ -1146,21 +1147,17 @@ resolve_inst({put_map_assoc,Args},_,_,_) ->
     [FLbl,Src,Dst,{u,N},{{z,1},{u,_Len},List0}] = Args,
     List = resolve_args(List0),
     {put_map_assoc,FLbl,Src,Dst,N,{list,List}};
-
 resolve_inst({put_map_exact,Args},_,_,_) ->
     [FLbl,Src,Dst,{u,N},{{z,1},{u,_Len},List0}] = Args,
     List = resolve_args(List0),
     {put_map_exact,FLbl,Src,Dst,N,{list,List}};
-
-resolve_inst({is_map,Args0},_,_,_) ->
+resolve_inst({is_map=I,Args0},_,_,_) ->
     [FLbl|Args] = resolve_args(Args0),
-    {test, is_map, FLbl, Args};
-
+    {test,I,FLbl,Args};
 resolve_inst({has_map_fields,Args0},_,_,_) ->
     [FLbl,Src,{{z,1},{u,_Len},List0}] = Args0,
     List = resolve_args(List0),
     {test,has_map_fields,FLbl,Src,{list,List}};
-
 resolve_inst({get_map_elements,Args0},_,_,_) ->
     [FLbl,Src,{{z,1},{u,_Len},List0}] = Args0,
     List = resolve_args(List0),
diff --git a/lib/compiler/src/cerl.erl b/lib/compiler/src/cerl.erl
index 3c121f3b04..9d6768b157 100644
--- a/lib/compiler/src/cerl.erl
+++ b/lib/compiler/src/cerl.erl
@@ -124,21 +124,19 @@
 
 	 %% keep map exports here for now
 	 map_es/1,
-	 map_val/1,
+	 map_arg/1,
 	 update_c_map/3,
-	 ann_c_map/3,
+	 c_map/1, is_c_map_empty/1,
+	 ann_c_map/2, ann_c_map/3,
 	 map_pair_op/1,map_pair_key/1,map_pair_val/1,
 	 update_c_map_pair/4,
+	 c_map_pair/2,
 	 ann_c_map_pair/4
      ]).
 
--export_type([c_binary/0, c_call/0, c_clause/0, c_cons/0, c_fun/0, c_literal/0,
-              c_module/0, c_tuple/0, c_values/0, c_var/0, cerl/0, var_name/0]).
-
-%%
-%% needed by the include file below -- do not move
-%%
--type var_name() :: integer() | atom() | {atom(), integer()}.
+-export_type([c_binary/0, c_bitstr/0, c_call/0, c_clause/0, c_cons/0, c_fun/0,
+	      c_literal/0, c_map/0, c_map_pair/0, c_module/0, c_tuple/0,
+	      c_values/0, c_var/0, cerl/0, var_name/0]).
 
 -include("core_parse.hrl").
 
@@ -173,6 +171,8 @@
 	      | c_module() | c_primop() | c_receive() | c_seq()
               | c_try()    | c_tuple()  | c_values()  | c_var().
 
+-type var_name() :: integer() | atom() | {atom(), integer()}.
+
 %% =====================================================================
 %% Representation (general)
 %%
@@ -204,13 +204,15 @@
 %%    <td>call</td>
 %%    <td>case</td>
 %%    <td>catch</td>
-%%  </tr><tr>
 %%    <td>clause</td>
+%%  </tr><tr>
 %%    <td>cons</td>
 %%    <td>fun</td>
 %%    <td>let</td>
 %%    <td>letrec</td>
 %%    <td>literal</td>
+%%    <td>map</td>
+%%    <td>map_pair</td>
 %%    <td>module</td>
 %%  </tr><tr>
 %%    <td>primop</td>
@@ -261,10 +263,10 @@
 %% @see subtrees/1
 %% @see meta/1
 
--type ctype() :: 'alias'   | 'apply'  | 'binary' | 'bitrst'  | 'call'  | 'case'
-               | 'catch'   | 'clause' | 'cons'   | 'fun'     | 'let'  | 'letrec'
-               | 'literal' | 'map'    | 'module' | 'primop'  | 'receive' | 'seq'
-	       | 'try'     | 'tuple'  | 'values' |  'var'.
+-type ctype() :: 'alias'   | 'apply'  | 'binary' | 'bitrst' | 'call' | 'case'
+               | 'catch'   | 'clause' | 'cons'   | 'fun'    | 'let'  | 'letrec'
+               | 'literal' | 'map'  | 'map_pair' | 'module' | 'primop'
+               | 'receive' | 'seq'    | 'try'    | 'tuple'  | 'values' | 'var'.
 
 -spec type(cerl()) -> ctype().
 
@@ -1575,25 +1577,91 @@ ann_make_list(_, [], Node) ->
 %% ---------------------------------------------------------------------
 %% maps
 
--spec map_es(c_map()) -> [cerl()].
+-spec map_es(c_map()) -> [c_map_pair()].
 
 map_es(#c_map{es = Es}) ->
     Es.
 
--spec map_val(c_map()) -> cerl().
-map_val(#c_map{var = M}) ->
+-spec map_arg(c_map()) -> c_map() | c_literal().
+
+map_arg(#c_map{arg=M}) ->
     M.
 
+-spec c_map([c_map_pair()]) -> c_map().
+
+c_map(Pairs) ->
+    #c_map{es=Pairs}.
+
+-spec is_c_map_empty(c_map() | c_literal()) -> boolean().
+
+is_c_map_empty(#c_map{ es=[] }) -> true;
+is_c_map_empty(#c_literal{val=M}) when is_map(M),map_size(M) =:= 0 -> true;
+is_c_map_empty(_) -> false.
+
+-spec ann_c_map([term()], [cerl()]) -> c_map() | c_literal().
+
+ann_c_map(As,Es) ->
+    ann_c_map(As, #c_literal{val=#{}}, Es).
+
+-spec ann_c_map([term()], c_map() | c_literal(), [c_map_pair()]) -> c_map() | c_literal().
+
+ann_c_map(As,#c_literal{val=Mval}=M,Es) when is_map(Mval), map_size(Mval) =:= 0 ->
+    Pairs = [[Ck,Cv]||#c_map_pair{key=Ck,val=Cv}<-Es],
+    IsLit = lists:foldl(fun(Pair,Res) ->
+		Res andalso is_lit_list(Pair)
+	end, true, Pairs),
+    Fun = fun(Pair) -> [K,V] = lit_list_vals(Pair), {K,V} end,
+    case IsLit of
+	false ->
+	    #c_map{arg=M, es=Es, anno=As };
+	true ->
+	    #c_literal{anno=As, val=maps:from_list(lists:map(Fun, Pairs))}
+	end;
+ann_c_map(As,#c_literal{val=M},Es) when is_map(M) ->
+    fold_map_pairs(As,Es,M);
 ann_c_map(As,M,Es) ->
-    #c_map{var=M,es = Es, anno = As }.
+    #c_map{arg=M, es=Es, anno=As }.
+
+fold_map_pairs(As,[],M) -> #c_literal{anno=As,val=M};
+%% M#{ K => V}
+fold_map_pairs(As,[#c_map_pair{op=#c_literal{val=assoc},key=Ck,val=Cv}=E|Es],M) ->
+    case is_lit_list([Ck,Cv]) of
+	true ->
+	    [K,V] = lit_list_vals([Ck,Cv]),
+	    fold_map_pairs(As,Es,maps:put(K,V,M));
+	false ->
+	    #c_map{arg=#c_literal{val=M,anno=As}, es=[E|Es], anno=As }
+    end;
+%% M#{ K := V}
+fold_map_pairs(As,[#c_map_pair{op=#c_literal{val=exact},key=Ck,val=Cv}=E|Es],M) ->
+    case is_lit_list([Ck,Cv]) of
+	true ->
+	    [K,V] = lit_list_vals([Ck,Cv]),
+	    case maps:is_key(K,M) of
+		true -> fold_map_pairs(As,Es,maps:put(K,V,M));
+		false ->
+		    #c_map{arg=#c_literal{val=M,anno=As}, es=[E|Es], anno=As }
+	    end;
+	false ->
+	    #c_map{arg=#c_literal{val=M,anno=As}, es=[E|Es], anno=As }
+    end;
+fold_map_pairs(As,Es,M) ->
+    #c_map{arg=#c_literal{val=M,anno=As}, es=Es, anno=As }.
+
+%-spec update_c_map(c_map() | c_literal(), [c_map_pair()]) -> c_map() | c_literal().
 
 update_c_map(Old,M,Es) ->
-    #c_map{var=M, es = Es, anno = get_ann(Old)}.
+    #c_map{arg=M, es = Es, anno = get_ann(Old)}.
 
 map_pair_key(#c_map_pair{key=K}) -> K.
 map_pair_val(#c_map_pair{val=V}) -> V.
 map_pair_op(#c_map_pair{op=Op}) -> Op.
 
+-spec c_map_pair(cerl(), cerl()) -> c_map_pair().
+
+c_map_pair(Key,Val) ->
+    #c_map_pair{op=#c_literal{val=assoc},key=Key,val=Val}.
+
 -spec ann_c_map_pair([term()], cerl(), cerl(), cerl()) ->
         c_map_pair().
 
@@ -4195,6 +4263,9 @@ ann_make_tree(As, bitstr, [[V],[S],[U],[T],[Fs]]) ->
     ann_c_bitstr(As, V, S, U, T, Fs);
 ann_make_tree(As, cons, [[H], [T]]) -> ann_c_cons(As, H, T);
 ann_make_tree(As, tuple, [Es]) -> ann_c_tuple(As, Es);
+ann_make_tree(As, map, [Es]) -> ann_c_map(As, Es);
+ann_make_tree(As, map, [[A], Es]) -> ann_c_map(As, A, Es);
+ann_make_tree(As, map_pair, [[Op], [K], [V]]) -> ann_c_map_pair(As, Op, K, V);
 ann_make_tree(As, 'let', [Vs, [A], [B]]) -> ann_c_let(As, Vs, A, B);
 ann_make_tree(As, seq, [[A], [B]]) -> ann_c_seq(As, A, B);
 ann_make_tree(As, apply, [[Op], Es]) -> ann_c_apply(As, Op, Es);
@@ -4324,12 +4395,8 @@ meta_1(cons, Node) ->
     %% we get exactly one element, we generate a 'c_cons' call
     %% instead of 'make_list' to reconstruct the node.
     case split_list(Node) of
-	{[H], none} ->
-	    meta_call(c_cons, [meta(H), meta(c_nil())]);
 	{[H], Node1} ->
 	    meta_call(c_cons, [meta(H), meta(Node1)]);
-	{L, none} ->
-	    meta_call(make_list, [make_list(meta_list(L))]);
 	{L, Node1} ->
 	    meta_call(make_list,
 		      [make_list(meta_list(L)), meta(Node1)])
@@ -4416,8 +4483,6 @@ split_list(Node, L) ->
     case type(Node) of
 	cons when A =:= [] ->
 	    split_list(cons_tl(Node), [cons_hd(Node) | L]);
-	nil when A =:= [] ->
-	    {lists:reverse(L), none};
 	_ ->
 	    {lists:reverse(L), Node}
     end.
diff --git a/lib/compiler/src/cerl_clauses.erl b/lib/compiler/src/cerl_clauses.erl
index 76d70dcabf..87bd47c08b 100644
--- a/lib/compiler/src/cerl_clauses.erl
+++ b/lib/compiler/src/cerl_clauses.erl
@@ -356,14 +356,19 @@ match(P, E, Bs) ->
 	    end;
     map ->
         %% The most we can do is to say "definitely no match" if a
-        %% binary pattern is matched against non-binary data.
+        %% map pattern is matched against non-map data.
         case E of
             any ->
                 {false, Bs};
             _ ->
                 case type(E) of
-                    literal ->
-                        none;
+		    literal ->
+			case is_map(concrete(E)) of
+			    false ->
+				none;
+			    true ->
+				{false, Bs}
+			end;
                     cons ->
                         none;
                     tuple ->
diff --git a/lib/compiler/src/cerl_inline.erl b/lib/compiler/src/cerl_inline.erl
index fa1d34cc9b..75740e8b9d 100644
--- a/lib/compiler/src/cerl_inline.erl
+++ b/lib/compiler/src/cerl_inline.erl
@@ -64,7 +64,7 @@
 	       seq_body/1, set_ann/2, try_arg/1, try_body/1, try_vars/1,
 	       try_evars/1, try_handler/1, tuple_es/1, tuple_arity/1,
 	       type/1, values_es/1, var_name/1,
-	       map_val/1, map_es/1, update_c_map/3,
+	       map_arg/1, map_es/1, update_c_map/3,
 	       update_c_map_pair/4,
 	       map_pair_op/1, map_pair_key/1, map_pair_val/1
 	   ]).
@@ -1343,7 +1343,7 @@ i_bitstr(E, Ren, Env, S) ->
 
 i_map(E, Ctx, Ren, Env, S) ->
     %% Visit the segments for value.
-    {M1, S1} = i(map_val(E), value, Ren, Env, S),
+    {M1, S1} = i(map_arg(E), value, Ren, Env, S),
     {Es, S2} = mapfoldl(fun (E, S) ->
 		i_map_pair(E, Ctx, Ren, Env, S)
 	end, S1, map_es(E)),
@@ -1420,8 +1420,8 @@ i_pattern(E, Ren, Env, Ren0, Env0, S) ->
 	    S2 = count_size(weight(binary), S1),
 	    {update_c_binary(E, Es), S2};
 	map ->
-	    %% map patterns should not have vals
-	    M = map_val(E),
+	    %% map patterns should not have args
+	    M = map_arg(E),
 
 	    {Es, S1} = mapfoldl(fun (E, S) ->
 			i_map_pair_pattern(E, Ren, Env, Ren0, Env0, S)
diff --git a/lib/compiler/src/cerl_trees.erl b/lib/compiler/src/cerl_trees.erl
index 2ebeab243f..e53bdd4efb 100644
--- a/lib/compiler/src/cerl_trees.erl
+++ b/lib/compiler/src/cerl_trees.erl
@@ -57,7 +57,7 @@
 	       update_c_try/6, update_c_tuple/2, update_c_tuple_skel/2,
 	       update_c_values/2, values_es/1, var_name/1,
 
-	       map_val/1, map_es/1,
+	       map_arg/1, map_es/1,
 	       ann_c_map/3,
 	       update_c_map/3,
 	       map_pair_key/1,map_pair_val/1,map_pair_op/1,
@@ -138,7 +138,7 @@ map_1(F, T) ->
  	tuple ->
 	    update_c_tuple_skel(T, map_list(F, tuple_es(T)));
  	map ->
-	    update_c_map(T, map(F,map_val(T)), map_list(F, map_es(T)));
+	    update_c_map(T, map(F, map_arg(T)), map_list(F, map_es(T)));
 	map_pair ->
 	    update_c_map_pair(T, map(F, map_pair_op(T)),
                                  map(F, map_pair_key(T)),
@@ -372,7 +372,7 @@ mapfold(F, S0, T) ->
 	    {Ts, S1} = mapfold_list(F, S0, tuple_es(T)),
 	    F(update_c_tuple_skel(T, Ts), S1);
 	map ->
-	    {M , S1} = mapfold(F, S0, map_val(T)),
+	    {M , S1} = mapfold(F, S0, map_arg(T)),
 	    {Ts, S2} = mapfold_list(F, S1, map_es(T)),
 	    F(update_c_map(T, M, Ts), S2);
 	map_pair ->
@@ -724,7 +724,7 @@ label(T, N, Env) ->
 	    {As, N2} = label_ann(T, N1),
 	    {ann_c_tuple_skel(As, Ts), N2};
  	map ->
-	    {M,  N1} = label(map_val(T), N, Env),
+	    {M,  N1} = label(map_arg(T), N, Env),
 	    {Ts, N2} = label_list(map_es(T), N1, Env),
 	    {As, N3} = label_ann(T, N2),
 	    {ann_c_map(As, M, Ts), N3};
diff --git a/lib/compiler/src/compile.erl b/lib/compiler/src/compile.erl
index 9030dd998b..c7d91070f6 100644
--- a/lib/compiler/src/compile.erl
+++ b/lib/compiler/src/compile.erl
@@ -234,7 +234,9 @@ format_error({crash,Pass,Reason}) ->
 format_error({bad_return,Pass,Reason}) ->
     io_lib:format("internal error in ~p;\nbad return value: ~ts", [Pass,format_error_reason(Reason)]);
 format_error({module_name,Mod,Filename}) ->
-    io_lib:format("Module name '~s' does not match file name '~ts'", [Mod,Filename]).
+    io_lib:format("Module name '~s' does not match file name '~ts'", [Mod,Filename]);
+format_error(reparsing_invalid_unicode) ->
+    "Non-UTF-8 character(s) detected, but no encoding declared. Encode the file in UTF-8 or add \"%% coding: latin-1\" at the beginning of the file. Retrying with latin-1 encoding.".
 
 format_error_reason({Reason, Stack}) when is_list(Stack) ->
     StackFun = fun
@@ -792,20 +794,59 @@ no_native_compilation(BeamFile, #compile{options=Opts0}) ->
 	_ -> false
     end.
 
-parse_module(St) ->
-    Opts = St#compile.options,
-    Cwd = ".",
-    IncludePath = [Cwd, St#compile.dir|inc_paths(Opts)],
-    R =  epp:parse_file(St#compile.ifile, IncludePath, pre_defs(Opts)),
+parse_module(St0) ->
+    case do_parse_module(utf8, St0) of
+	{ok,_}=Ret ->
+	    Ret;
+	{error,_}=Ret ->
+	    Ret;
+	{invalid_unicode,File,Line} ->
+	    case do_parse_module(latin1, St0) of
+		{ok,St} ->
+		    Es = [{File,[{Line,?MODULE,reparsing_invalid_unicode}]}],
+		    {ok,St#compile{warnings=Es++St#compile.warnings}};
+		{error,St} ->
+		    Es = [{File,[{Line,?MODULE,reparsing_invalid_unicode}]}],
+		    {error,St#compile{errors=Es++St#compile.errors}}
+	    end
+    end.
+
+do_parse_module(DefEncoding, #compile{ifile=File,options=Opts,dir=Dir}=St) ->
+    R = epp:parse_file(File,
+		       [{includes,[".",Dir|inc_paths(Opts)]},
+			{macros,pre_defs(Opts)},
+			{default_encoding,DefEncoding},
+			extra]),
     case R of
-	{ok,Forms} ->
-            Encoding = epp:read_encoding(St#compile.ifile),
-	    {ok,St#compile{code=Forms,encoding=Encoding}};
+	{ok,Forms,Extra} ->
+	    Encoding = proplists:get_value(encoding, Extra),
+	    case find_invalid_unicode(Forms, File) of
+		none ->
+		    {ok,St#compile{code=Forms,encoding=Encoding}};
+		{invalid_unicode,_,_}=Ret ->
+		    case Encoding of
+			none ->
+			    Ret;
+			_ ->
+			    {ok,St#compile{code=Forms,encoding=Encoding}}
+		    end
+	    end;
 	{error,E} ->
 	    Es = [{St#compile.ifile,[{none,?MODULE,{epp,E}}]}],
 	    {error,St#compile{errors=St#compile.errors ++ Es}}
     end.
 
+find_invalid_unicode([H|T], File0) ->
+    case H of
+	{attribute,_,file,{File,_}} ->
+	    find_invalid_unicode(T, File);
+	{error,{Line,file_io_server,invalid_unicode}} ->
+	    {invalid_unicode,File0,Line};
+	_Other ->
+	    find_invalid_unicode(T, File0)
+    end;
+find_invalid_unicode([], _) -> none.
+
 parse_core(St) ->
     case file:read_file(St#compile.ifile) of
 	{ok,Bin} ->
diff --git a/lib/compiler/src/compiler.app.src b/lib/compiler/src/compiler.app.src
index 8775c84698..8f68915f8e 100644
--- a/lib/compiler/src/compiler.app.src
+++ b/lib/compiler/src/compiler.app.src
@@ -67,4 +67,6 @@
 	    ]},
   {registered, []},
   {applications, [kernel, stdlib]},
-  {env, []}]}.
+  {env, []},
+  {runtime_dependencies, ["stdlib-2.0","kernel-3.0","hipe-3.10.3","erts-6.0",
+			  "crypto-3.3"]}]}.
diff --git a/lib/compiler/src/core_lib.erl b/lib/compiler/src/core_lib.erl
index ed181e3baa..2792fd8fa5 100644
--- a/lib/compiler/src/core_lib.erl
+++ b/lib/compiler/src/core_lib.erl
@@ -59,7 +59,7 @@ is_lit_bin(Es) ->
 
 %% Return the value of LitExpr.
 -spec literal_value(cerl:c_literal() | cerl:c_binary() |
-		    cerl:c_cons() | cerl:c_tuple()) -> term().
+		    cerl:c_map() | cerl:c_cons() | cerl:c_tuple()) -> term().
 
 literal_value(#c_literal{val=V}) -> V;
 literal_value(#c_binary{segments=Es}) ->
@@ -67,7 +67,14 @@ literal_value(#c_binary{segments=Es}) ->
 literal_value(#c_cons{hd=H,tl=T}) ->
     [literal_value(H)|literal_value(T)];
 literal_value(#c_tuple{es=Es}) ->
-    list_to_tuple(literal_value_list(Es)).
+    list_to_tuple(literal_value_list(Es));
+literal_value(#c_map{arg=Cm,es=Cmps}) ->
+    M = literal_value(Cm),
+    lists:foldl(fun(#c_map_pair{ key=Ck, val=Cv },Mi) ->
+		K = literal_value(Ck),
+		V = literal_value(Cv),
+		maps:put(K,V,Mi)
+	end, M, Cmps).
 
 literal_value_list(Vals) -> [literal_value(V) || V <- Vals].
 
@@ -105,7 +112,7 @@ vu_expr(V, #c_cons{hd=H,tl=T}) ->
     vu_expr(V, H) orelse vu_expr(V, T);
 vu_expr(V, #c_tuple{es=Es}) ->
     vu_expr_list(V, Es);
-vu_expr(V, #c_map{var=M,es=Es}) ->
+vu_expr(V, #c_map{arg=M,es=Es}) ->
     vu_expr(V, M) orelse vu_expr_list(V, Es);
 vu_expr(V, #c_map_pair{key=Key,val=Val}) ->
     vu_expr_list(V, [Key,Val]);
diff --git a/lib/compiler/src/core_lint.erl b/lib/compiler/src/core_lint.erl
index 25df33a287..c0e2bdaba0 100644
--- a/lib/compiler/src/core_lint.erl
+++ b/lib/compiler/src/core_lint.erl
@@ -33,9 +33,6 @@
 %% Values only as multiple values/variables/patterns.
 %% Return same number of values as requested
 %% Correct number of arguments
-%%
-%% Checks to add:
-%%
 %% Consistency of values/variables
 %% Consistency of function return values/calls.
 %%
@@ -211,7 +208,7 @@ functions(Fs, Def, St0) ->
 function({#c_var{name={_,_}},B}, Def, St) ->
     %% Body must be a fun!
     case B of
-	#c_fun{} -> expr(B, Def, any, St);
+	#c_fun{} -> expr(B, Def, 1, St);
 	_ -> add_error({illegal_expr,St#lint.func}, St)
     end.
 
@@ -247,40 +244,42 @@ gbody(E, Def, Rt, St0) ->
 	false -> St1
     end.
 
-gexpr(#c_var{name=N}, Def, _Rt, St) when is_atom(N); is_integer(N) ->
-    expr_var(N, Def, St);
-gexpr(#c_literal{}, _Def, _Rt, St) -> St;
-gexpr(#c_cons{hd=H,tl=T}, Def, _Rt, St) ->
-    gexpr_list([H,T], Def, St);
-gexpr(#c_tuple{es=Es}, Def, _Rt, St) ->
-    gexpr_list(Es, Def, St);
-gexpr(#c_map{es=Es}, Def, _Rt, St) ->
-    gexpr_list(Es, Def, St);
-gexpr(#c_map_pair{key=K,val=V}, Def, _Rt, St) ->
-    gexpr_list([K,V], Def, St);
-gexpr(#c_binary{segments=Ss}, Def, _Rt, St) ->
-    gbitstr_list(Ss, Def, St);
+gexpr(#c_var{name=N}, Def, Rt, St) when is_atom(N); is_integer(N) ->
+    return_match(Rt, 1, expr_var(N, Def, St));
+gexpr(#c_literal{}, _Def, Rt, St) ->
+    return_match(Rt, 1, St);
+gexpr(#c_cons{hd=H,tl=T}, Def, Rt, St) ->
+    return_match(Rt, 1, gexpr_list([H,T], Def, St));
+gexpr(#c_tuple{es=Es}, Def, Rt, St) ->
+    return_match(Rt, 1, gexpr_list(Es, Def, St));
+gexpr(#c_map{es=Es}, Def, Rt, St) ->
+    return_match(Rt, 1, gexpr_list(Es, Def, St));
+gexpr(#c_map_pair{key=K,val=V}, Def, Rt, St) ->
+    return_match(Rt, 1, gexpr_list([K,V], Def, St));
+gexpr(#c_binary{segments=Ss}, Def, Rt, St) ->
+    return_match(Rt, 1, gbitstr_list(Ss, Def, St));
 gexpr(#c_seq{arg=Arg,body=B}, Def, Rt, St0) ->
-    St1 = gexpr(Arg, Def, any, St0),		%Ignore values
-    gbody(B, Def, Rt, St1);
+    St1 = gexpr(Arg, Def, 1, St0),
+    return_match(Rt, 1, gbody(B, Def, Rt, St1));
 gexpr(#c_let{vars=Vs,arg=Arg,body=B}, Def, Rt, St0) ->
     St1 = gbody(Arg, Def, let_varcount(Vs), St0), %This is a guard body
     {Lvs,St2} = variable_list(Vs, St1),
     gbody(B, union(Lvs, Def), Rt, St2);
 gexpr(#c_call{module=#c_literal{val=erlang},name=#c_literal{val=is_record},
               args=[Arg,#c_literal{val=Tag},#c_literal{val=Size}]},
-      Def, 1, St) when is_atom(Tag), is_integer(Size) ->
-    gexpr(Arg, Def, 1, St);
+      Def, Rt, St) when is_atom(Tag), is_integer(Size) ->
+    return_match(Rt, 1, gexpr(Arg, Def, 1, St));
 gexpr(#c_call{module=#c_literal{val=erlang},name=#c_literal{val=is_record}},
-      _Def, 1, St) ->
-    add_error({illegal_guard,St#lint.func}, St);
+      _Def, Rt, St) ->
+    return_match(Rt, 1, add_error({illegal_guard,St#lint.func}, St));
 gexpr(#c_call{module=#c_literal{val=erlang},name=#c_literal{val=Name},args=As},
-      Def, 1, St) when is_atom(Name) ->
+      Def, Rt, St0) when is_atom(Name) ->
+    St1 = return_match(Rt, 1, St0),
     case is_guard_bif(Name, length(As)) of
         true ->
-            gexpr_list(As, Def, St);
+            gexpr_list(As, Def, St1);
         false ->
-            add_error({illegal_guard,St#lint.func}, St)
+            add_error({illegal_guard,St1#lint.func}, St1)
     end;
 gexpr(#c_primop{name=#c_literal{val=A},args=As}, Def, _Rt, St0) when is_atom(A) ->
     gexpr_list(As, Def, St0);
@@ -319,23 +318,25 @@ is_guard_bif(Name, Arity) ->
 
 %% expr(Expr, Defined, RetCount, State) -> State.
 
-expr(#c_var{name={_,_}=FA}, Def, _Rt, St) ->
-    expr_fname(FA, Def, St);
-expr(#c_var{name=N}, Def, _Rt, St) -> expr_var(N, Def, St);
-expr(#c_literal{}, _Def, _Rt, St) -> St;
-expr(#c_cons{hd=H,tl=T}, Def, _Rt, St) ->
-    expr_list([H,T], Def, St);
-expr(#c_tuple{es=Es}, Def, _Rt, St) ->
-    expr_list(Es, Def, St);
-expr(#c_map{es=Es}, Def, _Rt, St) ->
-    expr_list(Es, Def, St);
-expr(#c_map_pair{key=K,val=V},Def,_Rt,St) ->
-    expr_list([K,V],Def,St);
-expr(#c_binary{segments=Ss}, Def, _Rt, St) ->
-    bitstr_list(Ss, Def, St);
+expr(#c_var{name={_,_}=FA}, Def, Rt, St) ->
+    return_match(Rt, 1, expr_fname(FA, Def, St));
+expr(#c_var{name=N}, Def, Rt, St) ->
+    return_match(Rt, 1, expr_var(N, Def, St));
+expr(#c_literal{}, _Def, Rt, St) ->
+    return_match(Rt, 1, St);
+expr(#c_cons{hd=H,tl=T}, Def, Rt, St) ->
+    return_match(Rt, 1, expr_list([H,T], Def, St));
+expr(#c_tuple{es=Es}, Def, Rt, St) ->
+    return_match(Rt, 1, expr_list(Es, Def, St));
+expr(#c_map{es=Es}, Def, Rt, St) ->
+    return_match(Rt, 1, expr_list(Es, Def, St));
+expr(#c_map_pair{key=K,val=V}, Def, Rt, St) ->
+    return_match(Rt, 1, expr_list([K,V], Def, St));
+expr(#c_binary{segments=Ss}, Def, Rt, St) ->
+    return_match(Rt, 1, bitstr_list(Ss, Def, St));
 expr(#c_fun{vars=Vs,body=B}, Def, Rt, St0) ->
     {Vvs,St1} = variable_list(Vs, St0),
-    return_match(Rt, 1, body(B, union(Vvs, Def), any, St1));
+    return_match(Rt, 1, body(B, union(Vvs, Def), 1, St1));
 expr(#c_seq{arg=Arg,body=B}, Def, Rt, St0) ->
     St1 = expr(Arg, Def, 1, St0),
     body(B, Def, Rt, St1);
@@ -361,15 +362,26 @@ expr(#c_receive{clauses=Cs,timeout=T,action=A}, Def, Rt, St0) ->
     St1 = expr(T, Def, 1, St0),
     St2 = body(A, Def, Rt, St1),
     clauses(Cs, Def, 1, Rt, St2);
-expr(#c_apply{op=Op,args=As}, Def, _Rt, St0) ->
+expr(#c_apply{op=Op,args=As}, Def, Rt, St0) ->
     St1 = apply_op(Op, Def, length(As), St0),
-    expr_list(As, Def, St1);
+    return_match(Rt, 1, expr_list(As, Def, St1));
+expr(#c_call{module=#c_literal{val=erlang},name=#c_literal{val=Name},args=As},
+     Def, Rt, St0) when is_atom(Name) ->
+    St1 = expr_list(As, Def, St0),
+    case erl_bifs:is_exit_bif(erlang, Name, length(As)) of
+        true -> St1;
+        false -> return_match(Rt, 1, St1)
+    end;
 expr(#c_call{module=M,name=N,args=As}, Def, _Rt, St0) ->
     St1 = expr(M, Def, 1, St0),
     St2 = expr(N, Def, 1, St1),
     expr_list(As, Def, St2);
-expr(#c_primop{name=#c_literal{val=A},args=As}, Def, _Rt, St0) when is_atom(A) ->
-    expr_list(As, Def, St0);
+expr(#c_primop{name=#c_literal{val=A},args=As}, Def, Rt, St0) when is_atom(A) ->
+    St1 = expr_list(As, Def, St0),
+    case A of
+        match_fail -> St1;
+        _ -> return_match(Rt, 1, St1)
+    end;
 expr(#c_catch{body=B}, Def, Rt, St) ->
     return_match(Rt, 1, body(B, Def, 1, St));
 expr(#c_try{arg=A,vars=Vs,body=B,evars=Evs,handler=H}, Def, Rt, St0) ->
diff --git a/lib/compiler/src/core_parse.hrl b/lib/compiler/src/core_parse.hrl
index d54715ef59..4a00535360 100644
--- a/lib/compiler/src/core_parse.hrl
+++ b/lib/compiler/src/core_parse.hrl
@@ -34,7 +34,7 @@
 -record(c_apply, {anno=[], op,		% op :: Tree,
 		  args}).		% args :: [Tree]
 
--record(c_binary, {anno=[], segments}).	% segments :: [#c_bitstr{}]
+-record(c_binary, {anno=[], segments :: [cerl:c_bitstr()]}).
 
 -record(c_bitstr, {anno=[], val,        % val :: Tree,
 		   size,		% size :: Tree,
@@ -70,6 +70,15 @@
 
 -record(c_literal, {anno=[], val}).	% val :: literal()
 
+-record(c_map, {anno=[],
+		arg=#c_literal{val=#{}} :: cerl:c_var() | cerl:c_literal(),
+		es :: [cerl:c_map_pair()]}).
+
+-record(c_map_pair, {anno=[],
+	             op :: #c_literal{val::'assoc'} | #c_literal{val::'exact'},
+		     key,
+		     val}).
+
 -record(c_module, {anno=[], name,	% name :: Tree,
 		   exports,		% exports :: [Tree],
 		   attrs,		% attrs :: [#c_def{}],
@@ -96,12 +105,3 @@
 -record(c_values, {anno=[], es}).	% es :: [Tree]
 
 -record(c_var, {anno=[], name :: cerl:var_name()}).
-
--record(c_map_pair, {anno=[],
-	             op :: #c_literal{val::'assoc'} | #c_literal{val::'exact'},
-		     key,
-		     val}).
-
--record(c_map, {anno=[],
-		var=#c_literal{val=[]} :: #c_var{} | #c_literal{},
-		es :: [#c_map_pair{}]}).
diff --git a/lib/compiler/src/core_parse.yrl b/lib/compiler/src/core_parse.yrl
index b8db0f683a..a66ad4235f 100644
--- a/lib/compiler/src/core_parse.yrl
+++ b/lib/compiler/src/core_parse.yrl
@@ -21,7 +21,7 @@
 %% Have explicit productions for annotated phrases named anno_XXX.
 %% This just does an XXX and adds the annotation.
 
-Expect 1.
+Expect 0.
 
 Nonterminals
 
@@ -285,9 +285,9 @@ tuple -> '{' '}' : c_tuple([]).
 tuple -> '{' anno_expressions '}' : c_tuple('$2').
 
 map_expr -> '~' '{' '}' '~' : #c_map{es=[]}.
-map_expr -> '~' '{' map_pairs  '}' '~' : #c_map{es='$3'}.
-map_expr -> variable '~' '{' '}' '~' : #c_map{var='$1',es=[]}.
-map_expr -> variable '~' '{' map_pairs  '}' '~' : #c_map{var='$1',es='$4'}.
+map_expr -> '~' '{' map_pairs '}' '~' : #c_map{es='$3'}.
+map_expr -> '~' '{' map_pairs '|' variable '}' '~' : #c_map{arg='$5',es='$3'}.
+map_expr -> '~' '{' map_pairs '|' map_expr '}' '~' : #c_map{arg='$5',es='$3'}.
 
 map_pairs -> map_pair : ['$1'].
 map_pairs -> map_pair ',' map_pairs : ['$1' | '$3'].
diff --git a/lib/compiler/src/core_pp.erl b/lib/compiler/src/core_pp.erl
index faa26ec6df..83412ecdd7 100644
--- a/lib/compiler/src/core_pp.erl
+++ b/lib/compiler/src/core_pp.erl
@@ -118,6 +118,16 @@ format_1(#c_literal{val=Tuple}, Ctxt) when is_tuple(Tuple) ->
 format_1(#c_literal{anno=A,val=Bitstring}, Ctxt) when is_bitstring(Bitstring) ->
     Segs = segs_from_bitstring(Bitstring),
     format_1(#c_binary{anno=A,segments=Segs}, Ctxt);
+format_1(#c_literal{anno=A,val=M},Ctxt) when is_map(M) ->
+    Pairs = maps:to_list(M),
+    Op = case Ctxt of
+	#ctxt{ class = clause } -> exact;
+	_ -> assoc
+    end,
+    Cpairs = [#c_map_pair{op=#c_literal{val=Op},
+			  key=#c_literal{val=V},
+			  val=#c_literal{val=K}} || {K,V} <- Pairs],
+	format_1(#c_map{anno=A,arg=#c_literal{val=#{}},es=Cpairs},Ctxt);
 format_1(#c_var{name={I,A}}, _) ->
     [core_atom(I),$/,integer_to_list(A)];
 format_1(#c_var{name=V}, _) ->
@@ -161,15 +171,15 @@ format_1(#c_tuple{es=Es}, Ctxt) ->
      format_hseq(Es, ",", add_indent(Ctxt, 1), fun format/2),
      $}
     ];
-format_1(#c_map{var=#c_var{}=Var,es=Es}, Ctxt) ->
-    [format_1(Var, Ctxt),
-     "~{",
+format_1(#c_map{arg=#c_literal{val=M},es=Es}, Ctxt) when is_map(M),map_size(M)=:=0 ->
+    ["~{",
      format_hseq(Es, ",", add_indent(Ctxt, 1), fun format/2),
      "}~"
     ];
-format_1(#c_map{es=Es}, Ctxt) ->
+format_1(#c_map{arg=Var,es=Es}, Ctxt) ->
     ["~{",
      format_hseq(Es, ",", add_indent(Ctxt, 1), fun format/2),
+     "|",format(Var, add_indent(Ctxt, 1)),
      "}~"
     ];
 format_1(#c_map_pair{op=#c_literal{val=assoc},key=K,val=V}, Ctxt) ->
diff --git a/lib/compiler/src/erl_bifs.erl b/lib/compiler/src/erl_bifs.erl
index 3ad3c8c690..6c75538194 100644
--- a/lib/compiler/src/erl_bifs.erl
+++ b/lib/compiler/src/erl_bifs.erl
@@ -91,6 +91,7 @@ is_pure(erlang, is_float, 1) -> true;
 is_pure(erlang, is_function, 1) -> true;
 is_pure(erlang, is_integer, 1) -> true;
 is_pure(erlang, is_list, 1) -> true;
+is_pure(erlang, is_map, 1) -> true;
 is_pure(erlang, is_number, 1) -> true;
 is_pure(erlang, is_pid, 1) -> true;
 is_pure(erlang, is_port, 1) -> true;
diff --git a/lib/compiler/src/sys_core_fold.erl b/lib/compiler/src/sys_core_fold.erl
index 058abd3357..82817a987a 100644
--- a/lib/compiler/src/sys_core_fold.erl
+++ b/lib/compiler/src/sys_core_fold.erl
@@ -72,7 +72,7 @@
 -import(lists, [map/2,foldl/3,foldr/3,mapfoldl/3,all/2,any/2,
 		reverse/1,reverse/2,member/2,nth/2,flatten/1,unzip/1]).
 
--import(cerl, [ann_c_cons/3,ann_c_tuple/2]).
+-import(cerl, [ann_c_cons/3,ann_c_map/3,ann_c_tuple/2]).
 
 -include("core_parse.hrl").
 
@@ -246,7 +246,7 @@ expr(#c_tuple{anno=Anno,es=Es0}=Tuple, Ctxt, Sub) ->
 	value ->
 	    ann_c_tuple(Anno, Es)
     end;
-expr(#c_map{var=V0,es=Es0}=Map, Ctxt, Sub) ->
+expr(#c_map{anno=Anno,arg=V0,es=Es0}=Map, Ctxt, Sub) ->
     Es = pair_list(Es0, Ctxt, Sub),
     case Ctxt of
 	effect ->
@@ -254,7 +254,7 @@ expr(#c_map{var=V0,es=Es0}=Map, Ctxt, Sub) ->
 	    expr(make_effect_seq(Es, Sub), Ctxt, Sub);
 	value ->
 	    V = expr(V0, Ctxt, Sub),
-	    Map#c_map{var=V,es=Es}
+	    ann_c_map(Anno,V,Es)
     end;
 expr(#c_binary{segments=Ss}=Bin0, Ctxt, Sub) ->
     %% Warn for useless building, but always build the binary
@@ -1378,6 +1378,7 @@ eval_is_record(Call, _, _, _, _) -> Call.
 is_not_integer(#c_literal{val=Val}) when not is_integer(Val) -> true;
 is_not_integer(#c_tuple{}) -> true;
 is_not_integer(#c_cons{}) -> true;
+is_not_integer(#c_map{}) -> true;
 is_not_integer(_) -> false.
 
 %% is_not_tuple(Core) -> true | false.
@@ -1385,6 +1386,7 @@ is_not_integer(_) -> false.
 
 is_not_tuple(#c_literal{val=Val}) when not is_tuple(Val) -> true;
 is_not_tuple(#c_cons{}) -> true;
+is_not_tuple(#c_map{}) -> true;
 is_not_tuple(_) -> false.
 
 %% eval_setelement(Call, Pos, Tuple, NewVal) -> Core.
@@ -1554,16 +1556,8 @@ map_pair_pattern_list(Ps0, Isub, Osub0) ->
     {Ps,Osub}.
 
 map_pair_pattern(#c_map_pair{op=#c_literal{val=exact},key=K0,val=V0}=Pair,{Isub,Osub0}) ->
-    {K,Osub1} = case cerl:type(K0) of
-	binary ->
-	    K1 = eval_binary(K0),
-	    case cerl:type(K1) of
-		literal -> {K1,Osub0};
-		_ -> pattern(K0,Isub,Osub0)
-	    end;
-	_ -> pattern(K0,Isub,Osub0)
-    end,
-    {V,Osub} = pattern(V0,Isub,Osub1),
+    K = expr(K0, Isub),
+    {V,Osub} = pattern(V0,Isub,Osub0),
     {Pair#c_map_pair{key=K,val=V},{Isub,Osub}}.
 
 bin_pattern_list(Ps0, Isub, Osub0) ->
@@ -2029,9 +2023,9 @@ case_opt(Arg, Cs0, Sub) ->
 
 case_opt_args([A0|As0], Cs0, Sub, LitExpr, Acc) ->
     case case_opt_arg(A0, Sub, Cs0, LitExpr) of
-	error ->
+        {error,Cs1} ->
 	    %% Nothing to be done. Move on to the next argument.
-	    Cs = [{Ps,C,[P|PsAcc],Bs} || {[P|Ps],C,PsAcc,Bs} <- Cs0],
+            Cs = [{Ps,C,[P|PsAcc],Bs} || {[P|Ps],C,PsAcc,Bs} <- Cs1],
 	    case_opt_args(As0, Cs, Sub, LitExpr, [A0|Acc]);
 	{ok,As1,Cs} ->
 	    %% The argument was either expanded (from tuple/list) or
@@ -2050,7 +2044,7 @@ case_opt_arg(E0, Sub, Cs, LitExpr) ->
     E = maybe_replace_var(E0, Sub),
     case cerl:is_data(E) of
 	false ->
-	    error;
+            {error,Cs};
 	true ->
 	    case cerl:data_type(E) of
 		{atomic,_} ->
@@ -2100,35 +2094,44 @@ maybe_replace_var_1(E, #sub{t=Tdb}) ->
 %%  pattern matching is tricky, so we will give up in that case.
 
 case_opt_lit(Lit, Cs0, LitExpr) ->
-    try case_opt_lit_1(Cs0, Lit, LitExpr) of
+    Cs1 = case_opt_lit_1(Lit, Cs0, LitExpr),
+    try case_opt_lit_2(Lit, Cs1) of
 	Cs ->
 	    {ok,[],Cs}
     catch
 	throw:impossible ->
-	    error
+            {error,Cs1}
     end.
 
-case_opt_lit_1([{[P|Ps],C,PsAcc,Bs0}|Cs], E, LitExpr) ->
+case_opt_lit_1(E, [{[P|_],C,_,_}=Current|Cs], LitExpr) ->
+    case cerl_clauses:match(P, E) of
+        none ->
+            %% The pattern will not match the literal. Remove the clause.
+            %% Unless the entire case expression is a literal, also
+            %% emit a warning.
+            case LitExpr of
+                false -> add_warning(C, nomatch_clause_type);
+                true -> ok
+            end,
+            case_opt_lit_1(E, Cs, LitExpr);
+        _ ->
+            [Current|case_opt_lit_1(E, Cs, LitExpr)]
+    end;
+case_opt_lit_1(_, [], _) -> [].
+
+case_opt_lit_2(E, [{[P|Ps],C,PsAcc,Bs0}|Cs]) ->
+    %% Non-matching clauses have already been removed in case_opt_lit_1/3.
     case cerl_clauses:match(P, E) of
-	none ->
-	    %% The pattern will not match the literal. Remove the clause.
-	    %% Unless the entire case expression is a literal, also
-	    %% emit a warning.
-	    case LitExpr of
-		false -> add_warning(C, nomatch_clause_type);
-		true -> ok
-	    end,
-	    case_opt_lit_1(Cs, E, LitExpr);
 	{true,Bs} ->
 	    %% The pattern matches the literal. Remove the pattern
 	    %% and update the bindings.
-	    [{Ps,C,PsAcc,Bs++Bs0}|case_opt_lit_1(Cs, E, LitExpr)];
+            [{Ps,C,PsAcc,Bs++Bs0}|case_opt_lit_2(E, Cs)];
 	{false,_} ->
 	    %% Binary literal and pattern. We are not sure whether
 	    %% the pattern will match.
 	    throw(impossible)
     end;
-case_opt_lit_1([], _, _) -> [].
+case_opt_lit_2(_, []) -> [].
 
 %% case_opt_data(Expr, Clauses0, LitExpr) -> {ok,Exprs,Clauses}
 
@@ -2245,23 +2248,23 @@ letify(#c_var{name=Vname}=Var, Val, Body) ->
 
 %% opt_case_in_let(LetExpr) -> LetExpr'
 
-opt_case_in_let(#c_let{vars=Vs,arg=Arg,body=B}=Let) ->
-    opt_case_in_let_0(Vs, Arg, B, Let).
+opt_case_in_let(#c_let{vars=Vs,arg=Arg,body=B}=Let, Sub) ->
+    opt_case_in_let_0(Vs, Arg, B, Let, Sub).
 
 opt_case_in_let_0([#c_var{name=V}], Arg,
-		  #c_case{arg=#c_var{name=V},clauses=Cs}=Case, Let) ->
+		  #c_case{arg=#c_var{name=V},clauses=Cs}=Case, Let, Sub) ->
     case opt_case_in_let_1(V, Arg, Cs) of
 	impossible ->
 	    case is_simple_case_arg(Arg) andalso
 		not core_lib:is_var_used(V, Case#c_case{arg=#c_literal{val=nil}}) of
 		true ->
-		    expr(opt_bool_case(Case#c_case{arg=Arg,clauses=Cs}), sub_new());
+		    expr(opt_bool_case(Case#c_case{arg=Arg,clauses=Cs}), sub_new(Sub));
 		false ->
 		    Let
 	    end;
 	Expr -> Expr
     end;
-opt_case_in_let_0(_, _, _, Let) -> Let.
+opt_case_in_let_0(_, _, _, Let, _) -> Let.
 
 opt_case_in_let_1(V, Arg, Cs) ->
     try
@@ -2604,7 +2607,7 @@ opt_simple_let_2(Let0, Vs0, Arg0, Body0, effect, Sub) ->
 		    expr(#c_seq{arg=Arg,body=Body}, effect, sub_new_preserve_types(Sub));
 		true ->
 		    Let = Let0#c_let{vars=Vs,arg=Arg,body=Body},
-		    opt_case_in_let_arg(opt_case_in_let(Let), effect, Sub)
+		    opt_case_in_let_arg(opt_case_in_let(Let, Sub), effect, Sub)
 	    end
     end;
 opt_simple_let_2(Let, Vs0, Arg0, Body, value, Sub) ->
@@ -2627,7 +2630,7 @@ opt_simple_let_2(Let, Vs0, Arg0, Body, value, Sub) ->
 	    expr(#c_seq{arg=Arg,body=Body}, value, sub_new_preserve_types(Sub));
 	{Vs,Arg,Body} ->
 	    opt_case_in_let_arg(
-	      opt_case_in_let(Let#c_let{vars=Vs,arg=Arg,body=Body}),
+	      opt_case_in_let(Let#c_let{vars=Vs,arg=Arg,body=Body}, Sub),
 	      value, Sub)
     end.
 
diff --git a/lib/compiler/src/sys_pre_expand.erl b/lib/compiler/src/sys_pre_expand.erl
index 91a46a20fe..6410b73941 100644
--- a/lib/compiler/src/sys_pre_expand.erl
+++ b/lib/compiler/src/sys_pre_expand.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1996-2012. All Rights Reserved.
+%% Copyright Ericsson AB 1996-2014. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -33,12 +33,15 @@
 
 -include("../include/erl_bits.hrl").
 
+-type fa() :: {atom(), arity()}.
+
 -record(expand, {module=[],                     %Module name
                  exports=[],                    %Exports
                  imports=[],                    %Imports
                  compile=[],                    %Compile flags
                  attributes=[],                 %Attributes
                  callbacks=[],                  %Callbacks
+                 optional_callbacks=[] :: [fa()],  %Optional callbacks
                  defined,			%Defined functions (gb_set)
                  vcount=0,                      %Variable counter
                  func=[],                       %Current function
@@ -99,7 +102,21 @@ define_functions(Forms, #expand{defined=Predef}=St) ->
 module_attrs(#expand{attributes=Attributes}=St) ->
     Attrs = [{attribute,Line,Name,Val} || {Name,Line,Val} <- Attributes],
     Callbacks = [Callback || {_,_,callback,_}=Callback <- Attrs],
-    {Attrs,St#expand{callbacks=Callbacks}}.
+    OptionalCallbacks = get_optional_callbacks(Attrs),
+    {Attrs,St#expand{callbacks=Callbacks,
+                     optional_callbacks=OptionalCallbacks}}.
+
+get_optional_callbacks(Attrs) ->
+    L = [O ||
+            {attribute, _, optional_callbacks, O} <- Attrs,
+            is_fa_list(O)],
+    lists:append(L).
+
+is_fa_list([{FuncName, Arity}|L])
+  when is_atom(FuncName), is_integer(Arity), Arity >= 0 ->
+    is_fa_list(L);
+is_fa_list([]) -> true;
+is_fa_list(_) -> false.
 
 module_predef_funcs(St) ->
     {Mpf1,St1}=module_predef_func_beh_info(St),
@@ -108,19 +125,24 @@ module_predef_funcs(St) ->
 
 module_predef_func_beh_info(#expand{callbacks=[]}=St) ->
     {[], St};
-module_predef_func_beh_info(#expand{callbacks=Callbacks,defined=Defined,
+module_predef_func_beh_info(#expand{callbacks=Callbacks,
+                                    optional_callbacks=OptionalCallbacks,
+                                    defined=Defined,
 				    exports=Exports}=St) ->
     PreDef=[{behaviour_info,1}],
     PreExp=PreDef,
-    {[gen_beh_info(Callbacks)],
+    {[gen_beh_info(Callbacks, OptionalCallbacks)],
      St#expand{defined=gb_sets:union(gb_sets:from_list(PreDef), Defined),
 	       exports=union(from_list(PreExp), Exports)}}.
 
-gen_beh_info(Callbacks) ->
+gen_beh_info(Callbacks, OptionalCallbacks) ->
     List = make_list(Callbacks),
+    OptionalList = make_optional_list(OptionalCallbacks),
     {function,0,behaviour_info,1,
      [{clause,0,[{atom,0,callbacks}],[],
-       [List]}]}.
+       [List]},
+      {clause,0,[{atom,0,optional_callbacks}],[],
+       [OptionalList]}]}.
 
 make_list([]) -> {nil,0};
 make_list([{_,_,_,[{{Name,Arity},_}]}|Rest]) ->
@@ -130,6 +152,14 @@ make_list([{_,_,_,[{{Name,Arity},_}]}|Rest]) ->
        {integer,0,Arity}]},
      make_list(Rest)}.
 
+make_optional_list([]) -> {nil,0};
+make_optional_list([{Name,Arity}|Rest]) ->
+    {cons,0,
+     {tuple,0,
+      [{atom,0,Name},
+       {integer,0,Arity}]},
+     make_optional_list(Rest)}.
+
 module_predef_funcs_mod_info(St) ->
     PreDef = [{module_info,0},{module_info,1}],
     PreExp = PreDef,
@@ -232,7 +262,7 @@ pattern({map,Line,Ps}, St0) ->
     {TPs,St1} = pattern_list(Ps, St0),
     {{map,Line,TPs},St1};
 pattern({map_field_exact,Line,K0,V0}, St0) ->
-    {K,St1} = pattern(K0, St0),
+    {K,St1} = expr(K0, St0),
     {V,St2} = pattern(V0, St1),
     {{map_field_exact,Line,K,V},St2};
 %%pattern({struct,Line,Tag,Ps}, St0) ->
diff --git a/lib/compiler/src/v3_codegen.erl b/lib/compiler/src/v3_codegen.erl
index f1331d1fe7..47a357c23d 100644
--- a/lib/compiler/src/v3_codegen.erl
+++ b/lib/compiler/src/v3_codegen.erl
@@ -960,7 +960,6 @@ select_extract_map(Src, Vs, Fail, I, Vdb, Bef, St) ->
 	end, {{[],[]},Bef}, Vs),
 
     Code = case {HasKs,GetVs} of
-	{[],[]} -> {[],Aft,St};
 	{HasKs,[]} ->
 	    [{test,has_map_fields,{f,Fail},Rsrc,{list,HasKs}}];
 	{[],GetVs} ->
@@ -1553,8 +1552,7 @@ map_pair_strip_and_termsort(Es) ->
     Ls = [{K,V}||{_,K,V}<-Es],
     lists:sort(fun ({{_,A},_}, {{_,B},_}) -> erts_internal:cmp_term(A,B) =< 0;
                    ({nil,_},   {{_,B},_}) -> [] =< B;
-                   ({{_,A},_}, {nil,_})   -> A =< [];
-                   ({nil,_},   {nil,_})   -> true
+                   ({{_,A},_}, {nil,_})   -> A =< []
                end, Ls).
 
 %%%
diff --git a/lib/compiler/src/v3_core.erl b/lib/compiler/src/v3_core.erl
index 3d17557e01..83cf76f241 100644
--- a/lib/compiler/src/v3_core.erl
+++ b/lib/compiler/src/v3_core.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 1999-2013. All Rights Reserved.
+%% Copyright Ericsson AB 1999-2014. All Rights Reserved.
 %%
 %% The contents of this file are subject to the Erlang Public License,
 %% Version 1.1, (the "License"); you may not use this file except in
@@ -77,10 +77,13 @@
 		splitwith/2,keyfind/3,sort/1,foreach/2,droplast/1,last/1]).
 -import(ordsets, [add_element/2,del_element/2,is_element/2,
 		  union/1,union/2,intersection/2,subtract/2]).
--import(cerl, [ann_c_cons/3,ann_c_cons_skel/3,ann_c_tuple/2,c_tuple/1]).
+-import(cerl, [ann_c_cons/3,ann_c_cons_skel/3,ann_c_tuple/2,c_tuple/1,
+	       ann_c_map/2, ann_c_map/3]).
 
 -include("core_parse.hrl").
 
+-define(REC_OFFSET, 100000000). % Also in erl_expand_records.
+
 %% Internal core expressions and help functions.
 %% N.B. annotations fields in place as normal Core expressions.
 
@@ -500,7 +503,7 @@ expr({cons,L,H0,T0}, St0) ->
     {H1,Hps,St1} = safe(H0, St0),
     {T1,Tps,St2} = safe(T0, St1),
     A = lineno_anno(L, St2),
-    {ann_c_cons(A, H1, T1),Hps ++ Tps,St2};
+    {annotate_cons(A, H1, T1, St2),Hps ++ Tps,St2};
 expr({lc,L,E,Qs0}, St0) ->
     {Qs1,St1} = preprocess_quals(L, Qs0, St0),
     lc_tq(L, E, Qs1, #c_literal{anno=lineno_anno(L, St1),val=[]}, St1);
@@ -508,19 +511,38 @@ expr({bc,L,E,Qs}, St) ->
     bc_tq(L, E, Qs, {nil,L}, St);
 expr({tuple,L,Es0}, St0) ->
     {Es1,Eps,St1} = safe_list(Es0, St0),
-    A = lineno_anno(L, St1),
-    {ann_c_tuple(A, Es1),Eps,St1};
+    A = record_anno(L, St1),
+    {annotate_tuple(A, Es1, St1),Eps,St1};
 expr({map,L,Es0}, St0) ->
     % erl_lint should make sure only #{ K => V } are allowed
     % in map construction.
-    {Es1,Eps,St1} = map_pair_list(Es0, St0),
-    A = lineno_anno(L, St1),
-    {#c_map{anno=A,es=Es1},Eps,St1};
+    try map_pair_list(Es0, St0) of
+	{Es1,Eps,St1} ->
+	    A = lineno_anno(L, St1),
+	    {ann_c_map(A,Es1),Eps,St1}
+    catch
+	throw:{bad_map,Warning} ->
+	    St = add_warning(L, Warning, St0),
+	    LineAnno = lineno_anno(L, St),
+	    As = [#c_literal{anno=LineAnno,val=badarg}],
+	    {#icall{anno=#a{anno=LineAnno},	%Must have an #a{}
+		    module=#c_literal{anno=LineAnno,val=erlang},
+		    name=#c_literal{anno=LineAnno,val=error},
+		    args=As},[],St}
+    end;
 expr({map,L,M0,Es0}, St0) ->
-    {M1,Mps,St1} = safe(M0, St0),
-    {Es1,Eps,St2} = map_pair_list(Es0, St1),
-    A = lineno_anno(L, St2),
-    {#c_map{anno=A,var=M1,es=Es1},Mps++Eps,St2};
+    try expr_map(M0,Es0,lineno_anno(L, St0),St0) of
+	{_,_,_}=Res -> Res
+    catch
+	throw:{bad_map,Warning} ->
+	    St = add_warning(L, Warning, St0),
+	    LineAnno = lineno_anno(L, St),
+	    As = [#c_literal{anno=LineAnno,val=badarg}],
+	    {#icall{anno=#a{anno=LineAnno},	%Must have an #a{}
+		    module=#c_literal{anno=LineAnno,val=erlang},
+		    name=#c_literal{anno=LineAnno,val=error},
+		    args=As},[],St}
+    end;
 expr({bin,L,Es0}, St0) ->
     try expr_bin(Es0, lineno_anno(L, St0), St0) of
 	{_,_,_}=Res -> Res
@@ -730,22 +752,58 @@ make_bool_switch_guard(L, E, V, T, F) ->
       {clause,NegL,[V],[],[V]}
      ]}.
 
+expr_map(M0,Es0,A,St0) ->
+    {M1,Mps,St1} = safe(M0, St0),
+    case is_valid_map_src(M1) of
+	true ->
+	    case {M1,Es0} of
+		{#c_var{}, []} ->
+		    %% transform M#{} to is_map(M)
+		    {Vpat,St2} = new_var(St1),
+		    {Fpat,St3} = new_var(St2),
+		    Cs = [#iclause{
+			   anno=A,
+			   pats=[Vpat],
+			   guard=[#icall{anno=#a{anno=A},
+				   module=#c_literal{anno=A,val=erlang},
+			           name=#c_literal{anno=A,val=is_map},
+				   args=[Vpat]}],
+			   body=[Vpat]}],
+		    Fc = fail_clause([Fpat], A, #c_literal{val=badarg}),
+		    {#icase{anno=#a{anno=A},args=[M1],clauses=Cs,fc=Fc},Mps,St3};
+		{_,_} ->
+		    {Es1,Eps,St2} = map_pair_list(Es0, St1),
+		    {ann_c_map(A,M1,Es1),Mps++Eps,St2}
+	    end;
+	false -> throw({bad_map,bad_map})
+    end.
+
+is_valid_map_src(#c_literal{val = M}) when is_map(M) -> true;
+is_valid_map_src(#c_map{})  -> true;
+is_valid_map_src(#c_var{})  -> true;
+is_valid_map_src(_)         -> false.
+
 map_pair_list(Es, St) ->
     foldr(fun
 	    ({map_field_assoc,L,K0,V0}, {Ces,Esp,St0}) ->
 		{K,Ep0,St1} = safe(K0, St0),
+		ok = ensure_valid_map_key(K),
 		{V,Ep1,St2} = safe(V0, St1),
 		A = lineno_anno(L, St2),
 		Pair = #c_map_pair{op=#c_literal{val=assoc},anno=A,key=K,val=V},
 		{[Pair|Ces],Ep0 ++ Ep1 ++ Esp,St2};
 	    ({map_field_exact,L,K0,V0}, {Ces,Esp,St0}) ->
 		{K,Ep0,St1} = safe(K0, St0),
+		ok = ensure_valid_map_key(K),
 		{V,Ep1,St2} = safe(V0, St1),
 		A = lineno_anno(L, St2),
 		Pair = #c_map_pair{op=#c_literal{val=exact},anno=A,key=K,val=V},
 		{[Pair|Ces],Ep0 ++ Ep1 ++ Esp,St2}
 	end, {[],[],St}, Es).
 
+ensure_valid_map_key(#c_literal{}) -> ok;
+ensure_valid_map_key(_) -> throw({bad_map,bad_map_key}).
+
 %% try_exception([ExcpClause], St) -> {[ExcpVar],Handler,St}.
 
 try_exception(Ecs0, St0) ->
@@ -1501,9 +1559,9 @@ pattern({atom,L,A}, St) -> #c_literal{anno=lineno_anno(L, St),val=A};
 pattern({string,L,S}, St) -> #c_literal{anno=lineno_anno(L, St),val=S};
 pattern({nil,L}, St) -> #c_literal{anno=lineno_anno(L, St),val=[]};
 pattern({cons,L,H,T}, St) ->
-    ann_c_cons(lineno_anno(L, St), pattern(H, St), pattern(T, St));
+    annotate_cons(lineno_anno(L, St), pattern(H, St), pattern(T, St), St);
 pattern({tuple,L,Ps}, St) ->
-    ann_c_tuple(lineno_anno(L, St), pattern_list(Ps, St));
+    annotate_tuple(record_anno(L, St), pattern_list(Ps, St), St);
 pattern({map,L,Ps}, St) ->
     #c_map{anno=lineno_anno(L, St), es=pattern_map_pairs(Ps, St)};
 pattern({bin,L,Ps}, St) ->
@@ -1549,24 +1607,17 @@ pattern_alias_map_pair_patterns([Cv1,Cv2|Cvs]) ->
     pattern_alias_map_pair_patterns([pat_alias(Cv1,Cv2)|Cvs]).
 
 pattern_map_pair({map_field_exact,L,K,V}, St) ->
-    %% FIXME: Better way to construct literals? or missing case
-    %% {Key,_,_} = expr(K, St),
-    Key = case K of
-	{bin,L,Es0} ->
-	    case constant_bin(Es0) of
-		error ->
-		    throw(badmatch);
-		Bin ->
-		    #c_literal{anno=lineno_anno(L,St),val=Bin}
-	    end;
+    case expr(K,St) of
+	{#c_literal{}=Key,_,_} ->
+	    #c_map_pair{anno=lineno_anno(L, St),
+			op=#c_literal{val=exact},
+			key=Key,
+			val=pattern(V, St)};
 	_ ->
-	    pattern(K,St)
-    end,
-    #c_map_pair{anno=lineno_anno(L, St),
-                op=#c_literal{val=exact},
-		key=Key,
-		val=pattern(V, St)}.
-
+	    %% this will throw a cryptic error message
+	    %% but it is better than nothing
+	    throw(nomatch)
+    end.
 
 %% pat_bin([BinElement], State) -> [BinSeg].
 
@@ -1672,6 +1723,26 @@ fail_clause(Pats, Anno, Arg) ->
 	     body=[#iprimop{anno=#a{anno=Anno},name=#c_literal{val=match_fail},
 			    args=[Arg]}]}.
 
+annotate_tuple(A, Es, St) ->
+    case member(dialyzer, St#core.opts) of
+        true ->
+            %% Do not coalesce constant tuple elements. A Hack.
+            Node = cerl:ann_c_tuple(A, [cerl:c_var(any)]),
+            cerl:update_c_tuple_skel(Node, Es);
+        false ->
+            ann_c_tuple(A, Es)
+    end.
+
+annotate_cons(A, H, T, St) ->
+    case member(dialyzer, St#core.opts) of
+        true ->
+            %% Do not coalesce constant conses. A Hack.
+            Node= cerl:ann_c_cons(A, cerl:c_var(any), cerl:c_var(any)),
+            cerl:update_c_cons_skel(Node, H, T);
+        false ->
+            ann_c_cons(A, H, T)
+    end.
+
 ubody(B, St) -> uexpr(B, [], St).
 
 %% uclauses([Lclause], [KnownVar], State) -> {[Lclause],State}.
@@ -2166,6 +2237,8 @@ lit_vars(Lit) -> lit_vars(Lit, []).
 
 lit_vars(#c_cons{hd=H,tl=T}, Vs) -> lit_vars(H, lit_vars(T, Vs));
 lit_vars(#c_tuple{es=Es}, Vs) -> lit_list_vars(Es, Vs);
+lit_vars(#c_map{arg=V,es=Es}, Vs) -> lit_vars(V, lit_list_vars(Es, Vs));
+lit_vars(#c_map_pair{key=K,val=V}, Vs) -> lit_vars(K, lit_vars(V, Vs));
 lit_vars(#c_var{name=V}, Vs) -> add_element(V, Vs); 
 lit_vars(_, Vs) -> Vs.				%These are atomic
 
@@ -2187,6 +2260,23 @@ bitstr_vars(Segs, Vs) ->
  		  lit_vars(V, lit_vars(S, Vs0))
 	  end, Vs, Segs).
 
+record_anno(L, St) when L >= ?REC_OFFSET ->
+    case member(dialyzer, St#core.opts) of
+        true ->
+            [record | lineno_anno(L - ?REC_OFFSET, St)];
+        false ->
+            lineno_anno(L, St)
+    end;
+record_anno(L, St) when L < -?REC_OFFSET ->
+    case member(dialyzer, St#core.opts) of
+        true ->
+            [record | lineno_anno(L + ?REC_OFFSET, St)];
+        false ->
+            lineno_anno(L, St)
+    end;
+record_anno(L, St) ->
+    lineno_anno(L, St).
+
 lineno_anno(L, St) ->
     {line, Line} = erl_parse:get_attribute(L, line),
     if
@@ -2256,7 +2346,11 @@ is_simple_list(Es) -> lists:all(fun is_simple/1, Es).
 format_error(nomatch) ->
     "pattern cannot possibly match";
 format_error(bad_binary) ->
-    "binary construction will fail because of a type mismatch".
+    "binary construction will fail because of a type mismatch";
+format_error(bad_map_key) ->
+    "map construction will fail because of none literal key (large binaries are not literals)";
+format_error(bad_map) ->
+    "map construction will fail because of a type mismatch".
 
 add_warning(Line, Term, #core{ws=Ws,file=[{file,File}]}=St) when Line >= 0 ->
     St#core{ws=[{File,[{location(Line),?MODULE,Term}]}|Ws]};
diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl
index d00dd56f30..40d2f72b4c 100644
--- a/lib/compiler/src/v3_kernel.erl
+++ b/lib/compiler/src/v3_kernel.erl
@@ -272,9 +272,18 @@ expr(#c_cons{anno=A,hd=Ch,tl=Ct}, Sub, St0) ->
 expr(#c_tuple{anno=A,es=Ces}, Sub, St0) ->
     {Kes,Ep,St1} = atomic_list(Ces, Sub, St0),
     {#k_tuple{anno=A,es=Kes},Ep,St1};
-expr(#c_map{anno=A,var=Var0,es=Ces}, Sub, St0) ->
-    {Var,[],St1} = expr(Var0, Sub, St0),
-    map_split_pairs(A, Var, Ces, Sub, St1);
+expr(#c_map{anno=A,arg=Var,es=Ces}, Sub, St0) ->
+    try expr_map(A,Var,Ces,Sub,St0) of
+	{_,_,_}=Res -> Res
+    catch
+	throw:bad_map ->
+	    St1 = add_warning(get_line(A), bad_map, A, St0),
+	    Erl = #c_literal{val=erlang},
+	    Name = #c_literal{val=error},
+	    Args = [#c_literal{val=badarg}],
+	    Error = #c_call{anno=A,module=Erl,name=Name,args=Args},
+	    expr(Error, Sub, St1)
+    end;
 expr(#c_binary{anno=A,segments=Cv}, Sub, St0) ->
     try atomic_bin(Cv, Sub, St0) of
 	{Kv,Ep,St1} ->
@@ -496,6 +505,21 @@ translate_match_fail_1(Anno, As, Sub, #kern{ff=FF}) ->
 translate_fc(Args) ->
     [#c_literal{val=function_clause},make_list(Args)].
 
+expr_map(A,Var0,Ces,Sub,St0) ->
+    %% An extra pass of validation of Map src because of inlining
+    {Var,Mps,St1} = expr(Var0, Sub, St0),
+    case is_valid_map_src(Var) of
+	true ->
+	    {Km,Eps,St2} = map_split_pairs(A, Var, Ces, Sub, St1),
+	    {Km,Eps++Mps,St2};
+	false -> throw(bad_map)
+    end.
+
+is_valid_map_src(#k_map{}) -> true;
+is_valid_map_src(#k_literal{val=M}) when is_map(M) -> true;
+is_valid_map_src(#k_var{}) -> true;
+is_valid_map_src(_) -> false.
+
 map_split_pairs(A, Var, Ces, Sub, St0) ->
     %% two steps
     %% 1. force variables
@@ -557,8 +581,7 @@ map_key_clean(#k_literal{val=V}) -> {k_literal,V};
 map_key_clean(#k_int{val=V})     -> {k_int,V};
 map_key_clean(#k_float{val=V})   -> {k_float,V};
 map_key_clean(#k_atom{val=V})    -> {k_atom,V};
-map_key_clean(#k_nil{})          -> k_nil;
-map_key_clean(#k_var{name=V})    -> {k_var,V}.
+map_key_clean(#k_nil{})          -> k_nil.
 
 
 %% call_type(Module, Function, Arity) -> call | bif | apply | error.
@@ -1986,7 +2009,9 @@ format_error(nomatch_shadow) ->
 format_error(bad_call) ->
     "invalid module and/or function name; this call will always fail";
 format_error(bad_segment_size) ->
-    "binary construction will fail because of a type mismatch".
+    "binary construction will fail because of a type mismatch";
+format_error(bad_map) ->
+    "map construction will fail because of a type mismatch".
 
 add_warning(none, Term, Anno, #kern{ws=Ws}=St) ->
     File = get_file(Anno),
diff --git a/lib/compiler/src/v3_kernel_pp.erl b/lib/compiler/src/v3_kernel_pp.erl
index b4e486f97c..b33eba50eb 100644
--- a/lib/compiler/src/v3_kernel_pp.erl
+++ b/lib/compiler/src/v3_kernel_pp.erl
@@ -104,20 +104,26 @@ format_1(#k_tuple{es=Es}, Ctxt) ->
      format_hseq(Es, ",", ctxt_bump_indent(Ctxt, 1), fun format/2),
      $}
     ];
-format_1(#k_map{var=#k_var{}=Var,es=Es}, Ctxt) ->
-    [$~,${,
+format_1(#k_map{var=#k_literal{val=M},op=assoc,es=Es}, Ctxt) when is_map(M), map_size(M) =:= 0 ->
+    ["~{",
      format_hseq(Es, ",", ctxt_bump_indent(Ctxt, 1), fun format/2),
-     " | ",format_1(Var, Ctxt),
-     $},$~
+     "}~"
     ];
-format_1(#k_map{op=assoc,es=Es}, Ctxt) ->
+format_1(#k_map{var=#k_literal{val=M},op=exact,es=Es}, Ctxt) when is_map(M), map_size(M) =:= 0 ->
+    ["::{",
+     format_hseq(Es, ",", ctxt_bump_indent(Ctxt, 1), fun format/2),
+     "}::"
+    ];
+format_1(#k_map{var=Var,op=assoc,es=Es}, Ctxt) ->
     ["~{",
      format_hseq(Es, ",", ctxt_bump_indent(Ctxt, 1), fun format/2),
+     " | ",format_1(Var, Ctxt),
      "}~"
     ];
-format_1(#k_map{es=Es}, Ctxt) ->
+format_1(#k_map{var=Var,op=exact,es=Es}, Ctxt) ->
     ["::{",
      format_hseq(Es, ",", ctxt_bump_indent(Ctxt, 1), fun format/2),
+     " | ",format_1(Var, Ctxt),
      "}::"
     ];
 format_1(#k_map_pair{key=K,val=V}, Ctxt) ->
diff --git a/lib/compiler/src/v3_life.erl b/lib/compiler/src/v3_life.erl
index c4f54a7970..cd4b5fd674 100644
--- a/lib/compiler/src/v3_life.erl
+++ b/lib/compiler/src/v3_life.erl
@@ -324,8 +324,7 @@ type(k_binary) -> binary;
 type(k_bin_seg) -> bin_seg;
 type(k_bin_int) -> bin_int;
 type(k_bin_end) -> bin_end;
-type(k_map) -> map;
-type(k_map_pair) -> map_pair.
+type(k_map) -> map.
 
 %% variable(Klit) -> Lit.
 %% var_list([Klit]) -> [Lit].