Correct dializer errors in erlang.erl and others

New errors found when adding specs to erlang.erl and
removing them from erl_bif_types are examined and corrected.
Some errors was due to faulty specs, while others were actual
errors in the code using BIF's.

3 files changed, 3 insertions, 1410 deletions

diff --git a/lib/hipe/cerl/erl_bif_types.erl b/lib/hipe/cerl/erl_bif_types.erl
index 71c83d9359..190f14a474 100644
--- a/lib/hipe/cerl/erl_bif_types.erl
+++ b/lib/hipe/cerl/erl_bif_types.erl
@@ -45,7 +45,6 @@
 		    t_atom_vals/1,
 		    t_binary/0,
 		    t_bitstr/0,
-		    t_bitstrlist/0,
 		    t_boolean/0,
 		    t_byte/0,
 		    t_char/0,
@@ -64,7 +63,6 @@
 		    t_fun/2,
 		    t_fun_args/1,
 		    t_fun_range/1,
-		    t_identifier/0,
 		    t_inf/2,
 		    t_integer/0,
 		    t_integer/1,
@@ -72,8 +70,6 @@
 		    t_non_neg_integer/0,
 		    t_pos_integer/0,
 		    t_integers/1,
-		    t_iodata/0,
-		    t_iolist/0,
 		    t_is_any/1,
 		    t_is_atom/1,
 		    t_is_binary/1,
@@ -86,7 +82,6 @@
 		    t_is_fun/1,
 		    t_is_integer/1,
 		    t_is_integer/1,
-		    t_is_list/1,
 		    t_is_nil/1,
 		    t_is_none/1,
 		    t_is_none_or_unit/1,
@@ -123,8 +118,7 @@
 		    t_tuple/1,
 		    t_tuple_args/1,
 		    t_tuple_size/1,
-		    t_tuple_subtypes/1,
-		    t_unicode_string/0
+		    t_tuple_subtypes/1
 		   ]).
 
 -ifdef(DO_ERL_BIF_TYPES_TEST).
@@ -144,15 +138,6 @@ type(M, F, A) ->
 -spec type(atom(), atom(), arity(), [erl_types:erl_type()]) -> erl_types:erl_type().
 
 %%-- erlang -------------------------------------------------------------------
-type(erlang, halt, 0, _) -> t_none();
-type(erlang, halt, 1, _) -> t_none();
-type(erlang, exit, 1, _) -> t_none();
-%% Note that exit/2 sends an exit signal to another process.
-type(erlang, exit, 2, _) -> t_atom('true');
-type(erlang, error, 1, _) -> t_none();
-type(erlang, error, 2, _) -> t_none();
-type(erlang, throw, 1, _) -> t_none();
-type(erlang, hibernate, 3, _) -> t_none();
 type(erlang, '==', 2, Xs = [X1, X2]) ->
   case t_is_atom(X1) andalso t_is_atom(X2) of
     true -> type(erlang, '=:=', 2, Xs);
@@ -506,18 +491,7 @@ type(erlang, 'bnot', 1, Xs) ->
 	 end);
 %% This returns (-X)-1, so it often gives a negative result.
 %%  strict(arg_types(erlang, 'bnot', 1), Xs, fun (_) -> t_integer() end);
-type(erlang, abs, 1, Xs) ->
-  strict(arg_types(erlang, abs, 1), Xs, fun ([X]) -> X end);
-type(erlang, adler32, 1, Xs) ->
-  strict(arg_types(erlang, adler32, 1), Xs, fun (_) -> t_adler32() end);
-type(erlang, adler32, 2, Xs) ->
-  strict(arg_types(erlang, adler32, 2), Xs, fun (_) -> t_adler32() end);
-type(erlang, adler32_combine, 3, Xs) ->
-  strict(arg_types(erlang, adler32_combine, 3), Xs,
-	 fun (_) -> t_adler32() end);
 type(erlang, append, 2, Xs) -> type(erlang, '++', 2, Xs); % alias
-type(erlang, append_element, 2, Xs) ->
-  strict(arg_types(erlang, append_element, 2), Xs, fun (_) -> t_tuple() end);
 type(erlang, apply, 2, Xs) ->
   Fun = fun ([X, _Y]) -> 
 	    case t_is_fun(X) of
@@ -530,90 +504,8 @@ type(erlang, apply, 2, Xs) ->
   strict(arg_types(erlang, apply, 2), Xs, Fun);
 type(erlang, apply, 3, Xs) ->
   strict(arg_types(erlang, apply, 3), Xs, fun (_) -> t_any() end);
-type(erlang, atom_to_binary, 2, Xs) ->
-  strict(arg_types(erlang, atom_to_binary, 2), Xs, fun (_) -> t_binary() end);
-type(erlang, atom_to_list, 1, Xs) ->
-  strict(arg_types(erlang, atom_to_list, 1), Xs, fun (_) -> t_string() end);
-type(erlang, binary_part, 2, Xs) ->
-  strict(arg_types(erlang, binary_part, 2), Xs, fun (_) -> t_binary() end);
-type(erlang, binary_part, 3, Xs) ->
-  strict(arg_types(erlang, binary_part, 3), Xs, fun (_) -> t_binary() end);
-type(erlang, binary_to_atom, 2, Xs) ->
-  strict(arg_types(erlang, binary_to_atom, 2), Xs, fun (_) -> t_atom() end);
-type(erlang, binary_to_existing_atom, 2, Xs) ->
-  type(erlang, binary_to_atom, 2, Xs);
-type(erlang, binary_to_list, 1, Xs) ->
-  strict(arg_types(erlang, binary_to_list, 1), Xs,
-	 fun (_) -> t_list(t_byte()) end);
-type(erlang, binary_to_list, 3, Xs) ->
-  strict(arg_types(erlang, binary_to_list, 3), Xs,
-	 fun (_) -> t_list(t_byte()) end);
-type(erlang, binary_to_term, 1, Xs) ->
-  strict(arg_types(erlang, binary_to_term, 1), Xs, fun (_) -> t_any() end);
-type(erlang, binary_to_term, 2, Xs) ->
-  strict(arg_types(erlang, binary_to_term, 2), Xs, fun (_) -> t_any() end);
-type(erlang, bitsize, 1, Xs) ->	% XXX: TAKE OUT
-  type(erlang, bit_size, 1, Xs);
-type(erlang, bit_size, 1, Xs) ->
-  strict(arg_types(erlang, bit_size, 1), Xs,
-	 fun (_) -> t_non_neg_integer() end);
-type(erlang, bitstr_to_list, 1, Xs) ->	% XXX: TAKE OUT
-  type(erlang, bitstring_to_list, 1, Xs);
-type(erlang, bitstring_to_list, 1, Xs) ->
-  strict(arg_types(erlang, bitstring_to_list, 1), Xs,
-	 fun (_) -> t_list(t_sup(t_byte(), t_bitstr())) end);
-type(erlang, bump_reductions, 1, Xs) ->
-  strict(arg_types(erlang, bump_reductions, 1), Xs,
-	 fun (_) -> t_atom('true') end);
-type(erlang, byte_size, 1, Xs) ->
-  strict(arg_types(erlang, byte_size, 1), Xs,
-	 fun (_) -> t_non_neg_integer() end);
-type(erlang, call_on_load_function, 1, Xs) ->
-  %% Internal BIF used by on_load.
-  strict(arg_types(erlang, call_on_load_function, 1), Xs,
-	 fun (_) -> t_any() end);
-type(erlang, cancel_timer, 1, Xs) ->
-  strict(arg_types(erlang, cancel_timer, 1), Xs,
-	 fun (_) -> t_sup(t_integer(), t_atom('false')) end);
-type(erlang, check_old_code, 1, Xs) ->
-  strict(arg_types(erlang, check_old_code, 1), Xs,
-	 fun (_) -> t_boolean() end);
-type(erlang, check_process_code, 2, Xs) ->
-  strict(arg_types(erlang, check_process_code, 2), Xs,
-	 fun (_) -> t_boolean() end);
-type(erlang, crc32, 1, Xs) ->
-  strict(arg_types(erlang, crc32, 1), Xs, fun (_) -> t_crc32() end);
-type(erlang, crc32, 2, Xs) ->
-  strict(arg_types(erlang, crc32, 2), Xs, fun (_) -> t_crc32() end);
-type(erlang, crc32_combine, 3, Xs) ->
-  strict(arg_types(erlang, crc32_combine, 3), Xs, fun (_) -> t_crc32() end);
-type(erlang, date, 0, _) ->
-  t_date();
-type(erlang, decode_packet, 3, Xs) ->
-  strict(arg_types(erlang, decode_packet, 3), Xs,
-	 fun (_) ->
-	     t_sup([t_tuple([t_atom('ok'), t_packet(), t_binary()]),
-		    t_tuple([t_atom('more'), t_sup([t_non_neg_integer(),
-						    t_atom('undefined')])]),
-		    t_tuple([t_atom('error'), t_any()])])
-	 end);
-type(erlang, delete_module, 1, Xs) ->
-  strict(arg_types(erlang, delete_module, 1), Xs,
- 	 fun (_) -> t_sup(t_atom('true'), t_atom('undefined')) end);
-type(erlang, demonitor, 1, Xs) ->
-  strict(arg_types(erlang, demonitor, 1), Xs, fun (_) -> t_atom('true') end);
-%% TODO: overapproximation -- boolean only if 'info' is part of arg2 otherwise 'true'
-type(erlang, demonitor, 2, Xs) ->
-  strict(arg_types(erlang, demonitor, 2), Xs, fun (_) -> t_boolean() end);
 type(erlang, disconnect_node, 1, Xs) ->
   strict(arg_types(erlang, disconnect_node, 1), Xs, fun (_) -> t_sup([t_boolean(), t_atom('ignored')]) end);
-type(erlang, display, 1, _) -> t_atom('true');
-type(erlang, display_string, 1, Xs) ->
-  strict(arg_types(erlang, display_string, 1), Xs, fun(_) -> t_atom('true') end);
-type(erlang, display_nl, 0, _) ->
-  t_atom('true');
-type(erlang, dist_exit, 3, Xs) ->
-  strict(arg_types(erlang, dist_exit, 3), Xs, fun (_) -> t_atom('true') end);
 type(erlang, element, 2, Xs) ->
   strict(arg_types(erlang, element, 2), Xs,
 	 fun ([X1, X2]) ->
@@ -637,95 +529,16 @@ type(erlang, element, 2, Xs) ->
 		 t_sup([type(erlang, element, 2, [X1, Y]) || Y <- Ts])
 	     end
 	 end);
-type(erlang, erase, 0, _) -> t_any();
-type(erlang, erase, 1, _) -> t_any();
-type(erlang, external_size, 1, _) -> t_integer();
-type(erlang, external_size, 2, _) -> t_integer();
-type(erlang, finish_after_on_load, 2, Xs) ->
-  %% Internal BIF used by on_load.
-  strict(arg_types(erlang, finish_after_on_load, 2), Xs,
-	 fun (_) -> t_atom('true') end);
-type(erlang, float, 1, Xs) ->
-  strict(arg_types(erlang, float, 1), Xs, fun (_) -> t_float() end);
-type(erlang, float_to_list, 1, Xs) ->
-  strict(arg_types(erlang, float_to_list, 1), Xs, fun (_) -> t_string() end);
-type(erlang, function_exported, 3, Xs) ->
-  strict(arg_types(erlang, function_exported, 3), Xs,
-	 fun (_) -> t_boolean() end);
 type(erlang, fun_info, 1, Xs) ->
   strict(arg_types(erlang, fun_info, 1), Xs,
 	 fun (_) -> t_list(t_tuple([t_atom(), t_any()])) end);
-type(erlang, fun_info, 2, Xs) ->
-  strict(arg_types(erlang, fun_info, 2), Xs,
-	 fun (_) -> t_tuple([t_atom(), t_any()]) end);
-type(erlang, fun_to_list, 1, Xs) ->
-  strict(arg_types(erlang, fun_to_list, 1), Xs, fun (_) -> t_string() end);
-type(erlang, garbage_collect, 0, _) -> t_atom('true');
-type(erlang, garbage_collect, 1, Xs) ->
-  strict(arg_types(erlang, garbage_collect, 1), Xs, fun (_) -> t_boolean() end);
-type(erlang, garbage_collect_message_area, 0, _) ->
-  t_boolean();
-type(erlang, get, 0, _) -> t_list(t_tuple(2));
-type(erlang, get, 1, _) -> t_any();          % | t_atom('undefined')
 type(erlang, get_cookie, 0, _) -> t_atom();  % | t_atom('nocookie')
-type(erlang, get_keys, 1, _) -> t_list();
-type(erlang, get_module_info, 1, Xs) ->
-  strict(arg_types(erlang, get_module_info, 1), Xs,
-	 fun (_) ->
-	     t_list(t_tuple([t_atom(), t_list(t_tuple([t_atom(), t_any()]))]))
-	 end);
-type(erlang, get_module_info, 2, Xs) ->
-  T_module_info_2_returns =
-    t_sup([t_atom(),
-	   t_list(t_tuple([t_atom(), t_any()])),
-	   t_list(t_tuple([t_atom(), t_arity(), t_integer()]))]),
-  strict(arg_types(erlang, get_module_info, 2), Xs,
-	 fun ([Module, Item]) ->
-	     case t_is_atom(Item) of
-	       true -> 
-		 case t_atom_vals(Item) of
-		   ['module'] -> t_inf(t_atom(), Module);
-		   ['imports'] -> t_nil();
-		   ['exports'] -> t_list(t_tuple([t_atom(), t_arity()]));
-		   ['functions'] -> t_list(t_tuple([t_atom(), t_arity()]));
-		   ['attributes'] -> t_list(t_tuple([t_atom(), t_any()]));
-		   ['compile'] -> t_list(t_tuple([t_atom(), t_any()]));
-		   ['native_addresses'] -> % [{FunName, Arity, Address}]
-		     t_list(t_tuple([t_atom(), t_arity(), t_integer()]));
-		   List when is_list(List) ->
-		     T_module_info_2_returns;
-		   unknown ->
-		     T_module_info_2_returns
-		 end;
-	       false ->
-		 T_module_info_2_returns
-	     end
-	 end);
-type(erlang, get_stacktrace, 0, _) ->
-  t_list(t_tuple([t_atom(), t_atom(), t_sup([t_arity(), t_list()]),
-		  t_list()]));
-type(erlang, group_leader, 0, _) -> t_pid();
-type(erlang, group_leader, 2, Xs) ->
-  strict(arg_types(erlang, group_leader, 2), Xs,
-	 fun (_) -> t_atom('true') end);
-type(erlang, hash, 2, Xs) ->
-  strict(arg_types(erlang, hash, 2), Xs, fun (_) -> t_integer() end);
 type(erlang, hd, 1, Xs) ->
   strict(arg_types(erlang, hd, 1), Xs, fun ([X]) -> t_cons_hd(X) end);
-type(erlang, integer_to_list, 1, Xs) ->
-  strict(arg_types(erlang, integer_to_list, 1), Xs,
-	 fun (_) -> t_string() end);
 type(erlang, integer_to_list, 2, Xs) ->
   strict(arg_types(erlang, integer_to_list, 2), Xs,
 	 fun (_) -> t_string() end);
 type(erlang, info, 1, Xs) -> type(erlang, system_info, 1, Xs); % alias
-type(erlang, iolist_size, 1, Xs) ->
-  strict(arg_types(erlang, iolist_size, 1), Xs,
-	 fun (_) -> t_non_neg_integer() end);
-type(erlang, iolist_to_binary, 1, Xs) ->
-  strict(arg_types(erlang, iolist_to_binary, 1), Xs,
-	 fun (_) -> t_binary() end);
-type(erlang, is_alive, 0, _) -> t_boolean();
 type(erlang, is_atom, 1, Xs) ->   
   Fun = fun (X) -> check_guard(X, fun (Y) -> t_is_atom(Y) end, t_atom()) end,
   strict(arg_types(erlang, is_atom, 1), Xs, Fun);
@@ -734,20 +547,11 @@ type(erlang, is_binary, 1, Xs) ->
 	    check_guard(X, fun (Y) -> t_is_binary(Y) end, t_binary())
 	end,
   strict(arg_types(erlang, is_binary, 1), Xs, Fun);
-type(erlang, is_bitstr, 1, Xs) ->	% XXX: TAKE OUT
-  type(erlang, is_bitstring, 1, Xs);
 type(erlang, is_bitstring, 1, Xs) ->
   Fun = fun (X) ->
 	    check_guard(X, fun (Y) -> t_is_bitstr(Y) end, t_bitstr())
 	end,
   strict(arg_types(erlang, is_bitstring, 1), Xs, Fun);
-type(erlang, is_boolean, 1, Xs) ->
-  Fun = fun (X) ->
-	    check_guard(X, fun (Y) -> t_is_boolean(Y) end, t_boolean())
-	end,
-  strict(arg_types(erlang, is_boolean, 1), Xs, Fun);
-type(erlang, is_builtin, 3, Xs) ->
-  strict(arg_types(erlang, is_builtin, 3), Xs, fun (_) -> t_boolean() end);
 type(erlang, is_constant, 1, Xs) ->
   Fun = fun (X) ->
 	    check_guard(X, fun (Y) -> t_is_constant(Y) end, t_constant())
@@ -797,9 +601,6 @@ type(erlang, is_pid, 1, Xs) ->
 type(erlang, is_port, 1, Xs) ->
   Fun = fun (X) -> check_guard(X, fun (Y) -> t_is_port(Y) end, t_port()) end,
   strict(arg_types(erlang, is_port, 1), Xs, Fun);
-type(erlang, is_process_alive, 1, Xs) ->
-  strict(arg_types(erlang, is_process_alive, 1), Xs,
-	 fun (_) -> t_boolean() end);
 type(erlang, is_record, 2, Xs) ->
   Fun = fun ([X, Y]) ->
 	    case t_is_tuple(X) of
@@ -901,68 +702,9 @@ type(erlang, is_tuple, 1, Xs) ->
 	    check_guard(X, fun (Y) -> t_is_tuple(Y) end, t_tuple())
 	end,
   strict(arg_types(erlang, is_tuple, 1), Xs, Fun);
-type(erlang, length, 1, Xs) ->
-  strict(arg_types(erlang, length, 1), Xs, fun (_) -> t_non_neg_fixnum() end);
-type(erlang, link, 1, Xs) ->
-  strict(arg_types(erlang, link, 1), Xs, fun (_) -> t_atom('true') end);
-type(erlang, list_to_atom, 1, Xs) ->
-  strict(arg_types(erlang, list_to_atom, 1), Xs, fun (_) -> t_atom() end);
-type(erlang, list_to_binary, 1, Xs) ->
-  strict(arg_types(erlang, list_to_binary, 1), Xs,
-	 fun (_) -> t_binary() end);
-type(erlang, list_to_bitstr, 1, Xs) ->
-  type(erlang, list_to_bitstring, 1, Xs);
-type(erlang, list_to_bitstring, 1, Xs) ->
-  strict(arg_types(erlang, list_to_bitstring, 1), Xs,
-	 fun (_) -> t_bitstr() end);
-type(erlang, list_to_existing_atom, 1, Xs) ->
-  strict(arg_types(erlang, list_to_existing_atom, 1), Xs,
-	 fun (_) -> t_atom() end);
-type(erlang, list_to_float, 1, Xs) ->
-  strict(arg_types(erlang, list_to_float, 1), Xs, fun (_) -> t_float() end);
-type(erlang, list_to_integer, 1, Xs) ->
-  strict(arg_types(erlang, list_to_integer, 1), Xs,
-	 fun (_) -> t_integer() end);
 type(erlang, list_to_integer, 2, Xs) ->
   strict(arg_types(erlang, list_to_integer, 2), Xs,
 	 fun (_) -> t_integer() end);
-type(erlang, list_to_pid, 1, Xs) ->
-  strict(arg_types(erlang, list_to_pid, 1), Xs, fun (_) -> t_pid() end);
-type(erlang, list_to_tuple, 1, Xs) ->
-  strict(arg_types(erlang, list_to_tuple, 1), Xs, fun (_) -> t_tuple() end);
-type(erlang, load_module, 2, Xs) ->
-  strict(arg_types(erlang, load_module, 2), Xs,
-	 fun ([Mod,_Bin]) -> t_code_load_return(Mod) end);
-type(erlang, load_nif, 2, Xs) ->
-  strict(arg_types(erlang, load_nif, 2), Xs,
-	 fun (_) ->
-	     Reason = t_atoms(['load_failed', 'bad_lib', 'load',
-			       'reload', 'upgrade', 'old_code']),
-	     RsnPair = t_tuple([Reason, t_string()]),
-	     t_sup(t_atom('ok'), t_tuple([t_atom('error'), RsnPair]))
-	 end);
-type(erlang, loaded, 0, _) ->
-  t_list(t_atom());
-type(erlang, localtime, 0, Xs) ->
-  type(erlang, universaltime, 0, Xs);    % same
-type(erlang, localtime_to_universaltime, 1, Xs) ->
-  type(erlang, universaltime_to_localtime, 1, Xs);    % same
-type(erlang, localtime_to_universaltime, 2, Xs) ->
-  strict(arg_types(erlang, localtime_to_universaltime, 2), Xs, % typecheck
-	 fun ([X,_]) -> type(erlang, localtime_to_universaltime, 1, [X]) end);
-type(erlang, make_fun, 3, Xs) ->
-  strict(arg_types(erlang, make_fun, 3), Xs, 
-	 fun ([_, _, Arity]) -> 
-	     case t_number_vals(Arity) of
-	       [N] ->
-		 case is_integer(N) andalso 0 =< N andalso N =< 255 of
-		   true -> t_fun(N, t_any());
-		   false -> t_none()
-		 end;
-	       _Other -> t_fun()
-	     end
-	 end);
-type(erlang, make_ref, 0, _) -> t_reference();
 type(erlang, make_tuple, 2, Xs) ->
   strict(arg_types(erlang, make_tuple, 2), Xs,
 	 fun ([Int, _]) ->
@@ -979,288 +721,17 @@ type(erlang, make_tuple, 3, Xs) ->
 	       _Other -> t_tuple()
 	     end
 	 end);
-type(erlang, match_spec_test, 3, Xs) ->
-  strict(arg_types(erlang, match_spec_test, 3), Xs,
-	 fun (_) -> t_sup(t_tuple([t_atom('ok'),
-				   t_any(), % it can be any term
-				   t_list(t_atom('return_trace')),
-				   t_match_spec_test_errors()]),
-			  t_tuple([t_atom('error'),
-				   t_match_spec_test_errors()])) end);
-type(erlang, md5, 1, Xs) ->
-  strict(arg_types(erlang, md5, 1), Xs, fun (_) -> t_binary() end);
-type(erlang, md5_final, 1, Xs) ->
-  strict(arg_types(erlang, md5_final, 1), Xs, fun (_) -> t_binary() end);
-type(erlang, md5_init, 0, _) -> t_binary();
-type(erlang, md5_update, 2, Xs) ->
-  strict(arg_types(erlang, md5_update, 2), Xs, fun (_) -> t_binary() end);
 type(erlang, memory, 0, _) -> t_list(t_tuple([t_atom(), t_non_neg_fixnum()]));
-type(erlang, memory, 1, Xs) ->
-  strict(arg_types(erlang, memory, 1), Xs,
-	 fun ([Type]) ->
-	     case t_is_atom(Type) of
-	       true -> t_non_neg_fixnum();
-	       false ->
-	         case t_is_list(Type) of
-		   true -> t_list(t_tuple([t_atom(), t_non_neg_fixnum()]));
-		   false ->
-		     t_sup(t_non_neg_fixnum(),
-		   	   t_list(t_tuple([t_atom(), t_non_neg_fixnum()])))
-		 end
-	     end
-	 end);
-type(erlang, module_loaded, 1, Xs) ->
-  strict(arg_types(erlang, module_loaded, 1), Xs, fun (_) -> t_boolean() end);
-type(erlang, monitor, 2, Xs) ->
-  strict(arg_types(erlang, monitor, 2), Xs, fun (_) -> t_reference() end);
-type(erlang, monitor_node, 2, Xs) ->
-  strict(arg_types(erlang, monitor_node, 2), Xs,
-	 fun (_) -> t_atom('true') end);
-type(erlang, monitor_node, 3, Xs) ->
-  strict(arg_types(erlang, monitor_node, 3), Xs,
-	 fun (_) -> t_atom('true') end);
 type(erlang, nif_error, 1, _) ->
   t_any();   % this BIF and the next one are stubs for NIFs and never return
 type(erlang, nif_error, 2, Xs) ->
   strict(arg_types(erlang, nif_error, 2), Xs, fun (_) -> t_any() end);
-type(erlang, node, 0, _) -> t_node();
-type(erlang, node, 1, Xs) ->
-  strict(arg_types(erlang, node, 1), Xs, fun (_) -> t_node() end);
 type(erlang, nodes, 0, _) -> t_list(t_node());
-type(erlang, nodes, 1, Xs) ->
-  strict(arg_types(erlang, nodes, 1), Xs, fun (_) -> t_list(t_node()) end);
-type(erlang, now, 0, _) ->
-  t_timestamp();
-type(erlang, open_port, 2, Xs) ->
-  strict(arg_types(erlang, open_port, 2), Xs, fun (_) -> t_port() end);
-type(erlang, phash, 2, Xs) ->
-  strict(arg_types(erlang, phash, 2), Xs, fun (_) -> t_pos_integer() end);
-type(erlang, phash2, 1, Xs) ->
-  strict(arg_types(erlang, phash2, 1), Xs, fun (_) -> t_non_neg_integer() end);
-type(erlang, phash2, 2, Xs) ->
-  strict(arg_types(erlang, phash2, 2), Xs, fun (_) -> t_non_neg_integer() end);
-type(erlang, pid_to_list, 1, Xs) ->
-  strict(arg_types(erlang, pid_to_list, 1), Xs, fun (_) -> t_string() end);
 type(erlang, port_call, Arity, Xs) when Arity =:= 2; Arity =:= 3 ->
   strict(arg_types(erlang, port_call, Arity), Xs, fun (_) -> t_any() end);
-type(erlang, port_close, 1, Xs) ->
-  strict(arg_types(erlang, port_close, 1), Xs,
-	 fun (_) -> t_atom('true') end);
-type(erlang, port_command, 2, Xs) ->
-  strict(arg_types(erlang, port_command, 2), Xs,
-	 fun (_) -> t_atom('true') end);
-type(erlang, port_command, 3, Xs) ->
-  strict(arg_types(erlang, port_command, 3), Xs,
-	 fun (_) -> t_boolean() end);
-type(erlang, port_connect, 2, Xs) ->
-  strict(arg_types(erlang, port_connect, 2), Xs,
-	 fun (_) -> t_atom('true') end);
-type(erlang, port_control, 3, Xs) ->
-  strict(arg_types(erlang, port_control, 3), Xs,
-	 fun (_) -> t_sup(t_string(), t_binary()) end);
-type(erlang, port_get_data, 1, Xs) ->
-  strict(arg_types(erlang, port_get_data, 1), Xs, fun (_) -> t_any() end);
 type(erlang, port_info, 1, Xs) ->
   strict(arg_types(erlang, port_info, 1), Xs,
 	 fun (_) -> t_sup(t_atom('undefined'), t_list()) end);
-type(erlang, port_info, 2, Xs) ->
-  strict(arg_types(erlang, port_info, 2), Xs,
-	 fun ([_Port, Item]) ->
-	     t_sup(t_atom('undefined'),
-		   case t_atom_vals(Item) of
-		     ['connected'] -> t_tuple([Item, t_pid()]);
-		     ['id'] -> t_tuple([Item, t_integer()]);
-		     ['input'] -> t_tuple([Item, t_integer()]);
-		     ['links'] -> t_tuple([Item, t_list(t_pid())]);
-		     ['name'] -> t_tuple([Item, t_string()]);
-		     ['output'] -> t_tuple([Item, t_integer()]);
-		     ['registered_name'] -> t_tuple([Item, t_atom()]);
-		     List when is_list(List) ->
-		       t_tuple([t_sup([t_atom(A) || A <- List]),
-				t_sup([t_atom(), t_integer(),
-				       t_pid(), t_list(t_pid()),
-				       t_string()])]);
-		     unknown ->
-		       [_, PosItem] = arg_types(erlang, port_info, 2),
-		       t_tuple([PosItem,
-				t_sup([t_atom(), t_integer(),
-				       t_pid(), t_list(t_pid()),
-				       t_string()])])		       
-		   end)
-	 end);
-type(erlang, port_to_list, 1, Xs) ->
-  strict(arg_types(erlang, port_to_list, 1), Xs, fun (_) -> t_string() end);
-type(erlang, ports, 0, _) -> t_list(t_port());
-type(erlang, port_set_data, 2, Xs) ->
-  strict(arg_types(erlang, port_set_data, 2), Xs,
-	 fun (_) -> t_atom('true') end);
-type(erlang, pre_loaded, 0, _) -> t_list(t_atom());
-type(erlang, process_display, 2, _) -> t_atom('true');
-type(erlang, process_flag, 2, Xs) ->
-  T_process_flag_returns = t_sup([t_boolean(), t_atom(), t_non_neg_integer()]),
-  strict(arg_types(erlang, process_flag, 2), Xs,
-	 fun ([Flag, _Option]) ->
-	     case t_is_atom(Flag) of
-	       true ->
-		 case t_atom_vals(Flag) of
-		   ['error_handler'] -> t_atom();
-		   ['min_heap_size'] -> t_non_neg_integer();
-		   ['scheduler'] -> t_non_neg_integer();
-		   ['monitor_nodes'] -> t_boolean();
-		   ['priority'] -> t_process_priority_level();
-		   ['save_calls'] -> t_non_neg_integer();
-		   ['trap_exit'] -> t_boolean();
-		   List when is_list(List) ->
-		     T_process_flag_returns;
-		   unknown ->
-		     T_process_flag_returns
-		 end;
-	       false -> % XXX: over-approximation if Flag is tuple
-		 T_process_flag_returns
-	     end
-	 end);
-type(erlang, process_flag, 3, Xs) ->
-  strict(arg_types(erlang, process_flag, 3), Xs,
-	 fun (_) -> t_non_neg_integer() end);
-type(erlang, process_info, 1, Xs) ->
-  strict(arg_types(erlang, process_info, 1), Xs,
-	 fun (_) ->
-	     t_sup(t_list(t_tuple([t_pinfo(), t_any()])),
-		   t_atom('undefined'))
-	 end);
-type(erlang, process_info, 2, Xs) ->
-  %% we define all normal return values: the return when the process exists
-  %% t_nil() is the return for 'registered_name'; perhaps for more
-  T_process_info_2_normal_returns =
-    t_sup([t_tuple([t_pinfo_item(), t_any()]), t_nil()]),
-  strict(arg_types(erlang, process_info, 2), Xs,
-	 fun ([_Pid, InfoItem]) ->
-	     Ret = case t_is_atom(InfoItem) of
-		     true ->
-		       case t_atom_vals(InfoItem) of
-			 ['backtrace'] -> t_tuple([InfoItem, t_binary()]);
-			 ['current_function'] -> t_tuple([InfoItem, t_mfa()]);
-			 ['dictionary'] -> t_tuple([InfoItem, t_list()]);
-			 ['error_handler'] -> t_tuple([InfoItem, t_atom()]);
-			 ['garbage_collection'] ->
-			   t_tuple([InfoItem, t_list()]);
-			 ['group_leader'] -> t_tuple([InfoItem, t_pid()]);
-			 ['heap_size'] ->
-			   t_tuple([InfoItem, t_non_neg_integer()]);
-			 ['initial_call'] -> t_tuple([InfoItem, t_mfa()]);
-			 ['last_calls'] ->
-			   t_tuple([InfoItem,
-				    t_sup(t_atom('false'), t_list())]);
-			 ['links'] -> t_tuple([InfoItem, t_list(t_pid())]);
-			 ['memory'] ->
-			   t_tuple([InfoItem, t_non_neg_integer()]);
-			 ['message_binary'] -> t_tuple([InfoItem,  t_list()]);
-			 ['message_queue_len'] ->
-			   t_tuple([InfoItem, t_non_neg_integer()]);
-			 ['messages'] -> t_tuple([InfoItem, t_list()]);
-			 ['monitored_by'] ->
-			   t_tuple([InfoItem,  t_list(t_pid())]);
-			 ['monitors'] ->
-			   t_tuple([InfoItem, 
-				    t_list(t_sup(t_tuple([t_atom('process'),
-							  t_pid()]),
-						 t_tuple([t_atom('process'),
-							  t_tuple([t_atom(),
-								   t_atom()])])))]);
-			 ['priority'] ->
-			   t_tuple([InfoItem, t_process_priority_level()]);
-			 ['reductions'] ->
-			   t_tuple([InfoItem, t_non_neg_integer()]);
-			 ['registered_name'] ->
-			   t_sup(t_tuple([InfoItem, t_atom()]), t_nil());
-			 ['sequential_trace_token'] ->
-			   t_tuple([InfoItem, t_any()]); %% Underspecified
-			 ['stack_size'] ->
-			   t_tuple([InfoItem, t_non_neg_integer()]);
-			 ['status'] ->
-			   t_tuple([InfoItem, t_process_status()]);
-			 ['suspending'] ->
-			   t_tuple([InfoItem,
-				    t_list(t_tuple([t_pid(),
-						    t_non_neg_integer(),
-						    t_non_neg_integer()]))]);
-			 ['total_heap_size'] ->
-			   t_tuple([InfoItem, t_non_neg_integer()]);
-			 ['trap_exit'] ->
-			   t_tuple([InfoItem, t_boolean()]);
-			 List when is_list(List) ->
-			   T_process_info_2_normal_returns;
-			 unknown ->
-			   T_process_info_2_normal_returns
-		       end;
-		     false ->
-		       case t_is_list(InfoItem) of
-			 true ->
-			   t_list(t_tuple([t_pinfo_item(), t_any()]));
-			 false ->
-			   t_sup(T_process_info_2_normal_returns,
-				 t_list(t_tuple([t_pinfo_item(), t_any()])))
-		       end
-		   end,
-	       t_sup([Ret, t_atom('undefined')])
-	 end);
-type(erlang, processes, 0, _) -> t_list(t_pid());
-type(erlang, purge_module, 1, Xs) ->
-  strict(arg_types(erlang, purge_module, 1), Xs,
-	 fun (_) -> t_atom('true') end);
-type(erlang, put, 2, Xs) ->
-  strict(arg_types(erlang, put, 2), Xs, fun (_) -> t_any() end);
-type(erlang, raise, 3, _) -> t_none();
-type(erlang, read_timer, 1, Xs) ->
-  strict(arg_types(erlang, read_timer, 1), Xs,
-	 fun (_) -> t_sup(t_non_neg_integer(), t_atom('false')) end);
-type(erlang, ref_to_list, 1, Xs) ->
-  strict(arg_types(erlang, ref_to_list, 1), Xs, fun (_) -> t_string() end);
-type(erlang, register, 2, Xs) ->
-  strict(arg_types(erlang, register, 2), Xs, fun (_) -> t_atom('true') end);
-type(erlang, registered, 0, _) -> t_list(t_atom());
-type(erlang, resume_process, 1, Xs) ->
-  strict(arg_types(erlang, resume_process, 1), Xs,
-	 fun (_) -> t_any() end); %% TODO: overapproximation -- fix this
-type(erlang, round, 1, Xs) ->
-  strict(arg_types(erlang, round, 1), Xs, fun (_) -> t_integer() end);
-type(erlang, posixtime_to_universaltime, 1, Xs) ->
-  strict(arg_types(erlang, posixtime_to_universaltime, 1), Xs, 
-	 fun(_) ->  t_tuple([t_date(), t_time()]) end);
-type(erlang, self, 0, _) -> t_pid();
-type(erlang, send, 2, Xs) -> type(erlang, '!', 2, Xs);  % alias
-type(erlang, send, 3, Xs) ->
-  strict(arg_types(erlang, send, 3), Xs,
-	 fun (_) -> t_sup(t_atom('ok'), t_sendoptions()) end);
-type(erlang, send_after, 3, Xs) ->
-  strict(arg_types(erlang, send_after, 3), Xs, fun (_) -> t_reference() end);
-type(erlang, seq_trace, 2, Xs) ->
-  strict(arg_types(erlang, seq_trace, 2), Xs,
-	 fun (_) -> t_sup(t_seq_trace_info_returns(), t_tuple(5)) end);
-type(erlang, seq_trace_info, 1, Xs) ->
-  strict(arg_types(erlang, seq_trace_info, 1), Xs,
-	 fun ([Item]) ->
-	     case t_atom_vals(Item) of
-	       ['label'] ->
-		 t_sup(t_tuple([Item, t_non_neg_integer()]), t_nil());
-	       ['serial'] -> 
-		 t_sup(t_tuple([Item, t_tuple([t_non_neg_integer(),
-					       t_non_neg_integer()])]),
-		       t_nil());
-	       ['send'] -> t_tuple([Item, t_boolean()]);
-	       ['receive'] -> t_tuple([Item, t_boolean()]);
-	       ['print'] -> t_tuple([Item, t_boolean()]);
-	       ['timestamp'] -> t_tuple([Item, t_boolean()]);
-	       List when is_list(List) ->
-		 t_seq_trace_info_returns();
-	       unknown ->
-		 t_seq_trace_info_returns()
-	     end
-	 end);
-type(erlang, seq_trace_print, 1, Xs) ->
-  strict(arg_types(erlang, seq_trace_print, 1), Xs, fun (_) -> t_boolean() end);
-type(erlang, seq_trace_print, 2, Xs) ->
-  strict(arg_types(erlang, seq_trace_print, 2), Xs, fun (_) -> t_boolean() end);
 type(erlang, set_cookie, 2, Xs) ->
   strict(arg_types(erlang, set_cookie, 2), Xs, fun (_) -> t_atom('true') end);
 type(erlang, setelement, 3, Xs) ->
@@ -1294,142 +765,19 @@ type(erlang, setelement, 3, Xs) ->
 		 t_sup([type(erlang, setelement, 3, [X1, Y, X3]) || Y <- Ts])
 	     end
 	 end);
-type(erlang, setnode, 2, Xs) ->
-  strict(arg_types(erlang, setnode, 2), Xs, fun (_) -> t_atom('true') end);
-type(erlang, setnode, 3, Xs) ->
-  strict(arg_types(erlang, setnode, 3), Xs, fun (_) -> t_atom('true') end);
-type(erlang, size, 1, Xs) ->
-  strict(arg_types(erlang, size, 1), Xs, fun (_) -> t_non_neg_integer() end);
 type(erlang, spawn, 1, Xs) ->
   strict(arg_types(erlang, spawn, 1), Xs, fun (_) -> t_pid() end);
 type(erlang, spawn, 2, Xs) ->
   strict(arg_types(erlang, spawn, 2), Xs, fun (_) -> t_pid() end);
-type(erlang, spawn, 3, Xs) ->
-  strict(arg_types(erlang, spawn, 3), Xs, fun (_) -> t_pid() end);
 type(erlang, spawn, 4, Xs) ->
   strict(arg_types(erlang, spawn, 4), Xs, fun (_) -> t_pid() end);
 type(erlang, spawn_link, 1, Xs) -> type(erlang, spawn, 1, Xs);  % same
 type(erlang, spawn_link, 2, Xs) -> type(erlang, spawn, 2, Xs);  % same
-type(erlang, spawn_link, 3, Xs) -> type(erlang, spawn, 3, Xs);  % same
 type(erlang, spawn_link, 4, Xs) -> type(erlang, spawn, 4, Xs);  % same
-type(erlang, spawn_opt, 1, Xs) ->
-  strict(arg_types(erlang, spawn_opt, 1), Xs, 
-	 fun ([Tuple]) ->
-	     Fun = fun (TS) ->
-		       [_, _, _, List] = t_tuple_args(TS),
-		       t_spawn_opt_return(List)
-		   end,
-	     t_sup([Fun(TS) || TS <- t_tuple_subtypes(Tuple)])
-	 end);
-type(erlang, spawn_opt, 2, Xs) -> 
-  strict(arg_types(erlang, spawn_opt, 2), Xs, 
-	 fun ([_, List]) -> t_spawn_opt_return(List) end);
-type(erlang, spawn_opt, 3, Xs) -> 
-  strict(arg_types(erlang, spawn_opt, 3), Xs, 
-	 fun ([_, _, List]) -> t_spawn_opt_return(List) end);
-type(erlang, spawn_opt, 4, Xs) -> 
-  strict(arg_types(erlang, spawn_opt, 4), Xs, 
-	 fun ([_, _, _, List]) -> t_spawn_opt_return(List) end);
-type(erlang, split_binary, 2, Xs) ->
-  strict(arg_types(erlang, split_binary, 2), Xs,
-	 fun (_) -> t_tuple([t_binary(), t_binary()]) end);
-type(erlang, start_timer, 3, Xs) ->
-  strict(arg_types(erlang, start_timer, 3), Xs, fun (_) -> t_reference() end);
-type(erlang, statistics, 1, Xs) ->
-  strict(arg_types(erlang, statistics, 1), Xs,
-	 fun ([Type]) ->
-	     T_statistics_1 = t_sup([t_non_neg_integer(),
-				     t_tuple([t_non_neg_integer(),
-					      t_non_neg_integer()]),
-				     %% When called with the argument 'io'.
-				     t_tuple([t_tuple([t_atom('input'),
-						       t_non_neg_integer()]),
-					      t_tuple([t_atom('output'),
-						       t_non_neg_integer()])]),
-				     t_tuple([t_non_neg_integer(),
-					      t_non_neg_integer(),
-					      t_non_neg_integer()])]),
-	     case t_atom_vals(Type) of
-	       ['context_switches'] ->
-		 t_tuple([t_non_neg_integer(), t_integer(0)]);
-	       ['exact_reductions'] ->
-		 t_tuple([t_non_neg_integer(), t_non_neg_integer()]);
-	       ['garbage_collection'] ->
-		 t_tuple([t_non_neg_integer(),
-			  t_non_neg_integer(),
-			  t_integer(0)]);
-	       ['io'] ->
-		 t_tuple([t_tuple([t_atom('input'),  t_non_neg_integer()]),
-			  t_tuple([t_atom('output'), t_non_neg_integer()])]);
-	       ['reductions'] ->
-		 t_tuple([t_non_neg_integer(), t_non_neg_integer()]);
-	       ['run_queue'] ->
-		 t_non_neg_integer();
-	       ['runtime'] ->
-		 t_tuple([t_non_neg_integer(), t_integer(0)]);
-	       ['wall_clock'] ->
-		 t_tuple([t_non_neg_integer(), t_integer(0)]);
-	       List when is_list(List) ->
-		 T_statistics_1;
-	       unknown ->
-		 T_statistics_1
-	     end
-	 end);
 type(erlang, subtract, 2, Xs) -> type(erlang, '--', 2, Xs); % alias
 type(erlang, suspend_process, 1, Xs) ->
   strict(arg_types(erlang, suspend_process, 1), Xs,
 	 fun (_) -> t_atom('true') end);
-type(erlang, suspend_process, 2, Xs) ->
-  strict(arg_types(erlang, suspend_process, 2), Xs,
-	 fun (_) -> t_boolean() end);
-type(erlang, system_flag, 2, Xs) ->
-  strict(arg_types(erlang, system_flag, 2), Xs,
-	 fun ([Flag,_Value]) ->
-	     %% this provides an overapproximation of all return values 
-	     T_system_flag_2 = t_sup([t_boolean(),
-				      t_integer(),
-				      t_sequential_tracer(),
-				      t_system_cpu_topology(),
-				      t_system_multi_scheduling()]),
-	     case t_is_atom(Flag) of
-	       true ->
-	         case t_atom_vals(Flag) of
-		   ['backtrace_depth'] ->
-		     t_non_neg_fixnum();
-		   ['cpu_topology'] ->
-		     t_system_cpu_topology();
-		   ['debug_flags'] ->
-		     t_atom('true');
-		   ['display_items'] ->
-		     t_non_neg_fixnum();
-		   ['fullsweep_after'] ->
-		     t_non_neg_fixnum();
-		   ['min_heap_size'] ->
-		     t_non_neg_fixnum();
-		   ['multi_scheduling'] ->
-		     t_system_multi_scheduling();
-		   ['schedulers_online'] ->
-		     t_pos_fixnum();
-		   ['scheduler_bind_type'] ->
-		     t_scheduler_bind_type_results();
-		   ['sequential_tracer'] ->
-		     t_sequential_tracer();
-		   ['trace_control_word'] ->
-		     t_integer();
-		   List when is_list(List) ->
-		     T_system_flag_2;
-		   unknown ->
-		     T_system_flag_2
-		 end;
-	       false ->
-	       	 case t_is_integer(Flag) of	% SHOULD BE: t_is_fixnum
-		   true ->
-		     t_atom('true');
-		   false ->
-		     T_system_flag_2
-		 end
-	     end
-	 end);
 type(erlang, system_info, 1, Xs) ->
   strict(arg_types(erlang, system_info, 1), Xs,
 	 fun ([Type]) ->
@@ -1546,58 +894,13 @@ type(erlang, system_info, 1, Xs) ->
 		 t_any() %% overapproximation as the return value might change
 	     end
 	 end);
-type(erlang, system_monitor, 0, Xs) ->
-  strict(arg_types(erlang, system_monitor, 0), Xs,
-	 fun (_) -> t_system_monitor_settings() end);
-type(erlang, system_monitor, 1, Xs) ->
-  strict(arg_types(erlang, system_monitor, 1), Xs,
-	 fun (_) -> t_system_monitor_settings() end);
-type(erlang, system_monitor, 2, Xs) ->
-  strict(arg_types(erlang, system_monitor, 2), Xs,
-	 fun (_) -> t_system_monitor_settings() end);
-type(erlang, system_profile, 0, _) ->
-  t_system_profile_return();
-type(erlang, system_profile, 2, Xs) ->
-  strict(arg_types(erlang, system_profile, 2), Xs,
-	 fun (_) -> t_system_profile_return() end); 
 type(erlang, term_to_binary, 1, Xs) ->
   strict(arg_types(erlang, term_to_binary, 1), Xs, fun (_) -> t_binary() end);
-type(erlang, term_to_binary, 2, Xs) ->
-  strict(arg_types(erlang, term_to_binary, 2), Xs, fun (_) -> t_binary() end);
-type(erlang, time, 0, _) ->
-  t_tuple([t_non_neg_integer(), t_non_neg_integer(), t_non_neg_integer()]);
 type(erlang, tl, 1, Xs) ->
   strict(arg_types(erlang, tl, 1), Xs, fun ([X]) -> t_cons_tl(X) end);
-type(erlang, trace, 3, Xs) ->
-  strict(arg_types(erlang, trace, 3), Xs, fun (_) -> t_integer() end);
-type(erlang, trace_delivered, 1, Xs) ->
-  strict(arg_types(erlang, trace_delivered, 1), Xs,
-	 fun (_) -> t_reference() end);
-type(erlang, trace_info, 2, Xs) ->
-  strict(arg_types(erlang, trace_info, 2), Xs,
-	 fun (_) ->
-	     t_tuple([t_atom(),
-		      t_sup([%% the following is info about a PID
-			     t_list(t_atom()), t_pid(), t_port(),
-			     %% the following is info about a func
-			     t_atom('global'), t_atom('local'),
-			     t_atom('false'), t_atom('true'),
-			     t_list(), t_pid(), t_port(),
-			     t_integer(),
-			     t_list(t_tuple([t_atom(), t_any()])),
-			     %% and this is the 'not found' value
-			     t_atom('undefined')])])
-	 end);
 type(erlang, trace_pattern, 2, Xs) ->
   strict(arg_types(erlang, trace_pattern, 2), Xs,
 	 fun (_) -> t_non_neg_fixnum() end); %% num of MFAs that match pattern
-type(erlang, trace_pattern, 3, Xs) ->
-  strict(arg_types(erlang, trace_pattern, 3), Xs,
-	 fun (_) -> t_non_neg_fixnum() end); %% num of MFAs that match pattern
-type(erlang, trunc, 1, Xs) ->
-  strict(arg_types(erlang, trunc, 1), Xs, fun (_) -> t_integer() end);
-type(erlang, tuple_size, 1, Xs) ->
-  strict(arg_types(erlang, tuple_size, 1), Xs, fun (_) -> t_non_neg_integer() end);
 type(erlang, tuple_to_list, 1, Xs) ->
   strict(arg_types(erlang, tuple_to_list, 1), Xs,
 	 fun ([X]) ->
@@ -1618,21 +921,6 @@ type(erlang, tuple_to_list, 1, Xs) ->
 		 end
 	     end
 	 end);
-type(erlang, universaltime, 0, _) ->
-  t_tuple([t_date(), t_time()]);
-type(erlang, universaltime_to_localtime, 1, Xs) ->
-  strict(arg_types(erlang, universaltime_to_localtime, 1), Xs,
-	 fun ([T]) -> T end);
-type(erlang, universaltime_to_posixtime, 1, Xs) ->
-  strict(arg_types(erlang, universaltime_to_posixtime,1), Xs,
-	 fun(_) -> t_integer() end);
-type(erlang, unlink, 1, Xs) ->
-  strict(arg_types(erlang, unlink, 1), Xs, fun (_) -> t_atom('true') end);
-type(erlang, unregister, 1, Xs) ->
-  strict(arg_types(erlang, unregister, 1), Xs, fun (_) -> t_atom('true') end);
-type(erlang, whereis, 1, Xs) ->
-  strict(arg_types(erlang, whereis, 1), Xs,
-	 fun (_) -> t_sup([t_pid(), t_port(), t_atom('undefined')]) end);
 type(erlang, yield, 0, _) -> t_atom('true');
 %%-- ets ----------------------------------------------------------------------
 type(ets, rename, 2, Xs) ->
@@ -2128,8 +1416,6 @@ type(lists, merge, 2, Xs) ->
 		 end
 	     end
 	 end);
-%% type(lists, merge, 3, Xs) ->
-%% type(lists, merge3, 3, Xs) ->
 type(lists, min, 1, Xs) ->
   strict(arg_types(lists, min, 1), Xs, fun ([L]) -> t_list_elements(L) end);
 type(lists, nth, 2, Xs) ->
@@ -2806,18 +2092,8 @@ arg_types(erlang, 'bsl', 2) ->
   [t_integer(), t_integer()];
 arg_types(erlang, 'bnot', 1) ->
   [t_integer()];
-arg_types(erlang, abs, 1) ->
-  [t_number()];
-arg_types(erlang, adler32, 1) ->
-  [t_iodata()];
-arg_types(erlang, adler32, 2) ->
-  [t_adler32(), t_iodata()];
-arg_types(erlang, adler32_combine, 3) ->
-  [t_adler32(), t_adler32(), t_non_neg_integer()];
 arg_types(erlang, append, 2) ->
   arg_types(erlang, '++', 2);
-arg_types(erlang, append_element, 2) ->
-  [t_tuple(), t_any()];
 arg_types(erlang, apply, 2) ->
   [t_sup(t_tuple([t_module(),
 		  t_atom()]),
@@ -2825,162 +2101,28 @@ arg_types(erlang, apply, 2) ->
    t_list()];
 arg_types(erlang, apply, 3) ->
   [t_sup(t_atom(), t_tuple()), t_atom(), t_list()];
-arg_types(erlang, atom_to_binary, 2) ->
-  [t_atom(), t_encoding_a2b()];
-arg_types(erlang, atom_to_list, 1) ->
-  [t_atom()];
-arg_types(erlang, binary_part, 2) ->
-  [t_binary(), t_tuple([t_non_neg_integer(), t_integer()])];
-arg_types(erlang, binary_part, 3) ->
-  [t_binary(), t_non_neg_integer(), t_integer()];
-arg_types(erlang, binary_to_atom, 2) ->
-  [t_binary(), t_encoding_a2b()];
-arg_types(erlang, binary_to_existing_atom, 2) ->
-  arg_types(erlang, binary_to_atom, 2);
-arg_types(erlang, binary_to_list, 1) ->
-  [t_binary()];
-arg_types(erlang, binary_to_list, 3) ->
-  [t_binary(), t_pos_integer(), t_pos_integer()]; % I want fixnum, but cannot
-arg_types(erlang, binary_to_term, 1) ->
-  [t_binary()];
-arg_types(erlang, binary_to_term, 2) ->
-  [t_binary(), t_list(t_atom('safe'))];
-arg_types(erlang, bitsize, 1) ->	% XXX: TAKE OUT
-  arg_types(erlang, bit_size, 1);
-arg_types(erlang, bit_size, 1) ->
-  [t_bitstr()];
-arg_types(erlang, bitstr_to_list, 1) ->	% XXX: TAKE OUT
-  arg_types(erlang, bitstring_to_list, 1);
-arg_types(erlang, bitstring_to_list, 1) ->
-  [t_bitstr()];
-arg_types(erlang, bump_reductions, 1) ->
-  [t_pos_fixnum()];
-arg_types(erlang, byte_size, 1) ->
-  [t_binary()];
-arg_types(erlang, call_on_load_function, 1) ->
-  [t_atom()];
-arg_types(erlang, cancel_timer, 1) ->
-  [t_reference()];
-arg_types(erlang, check_old_code, 1) ->
-  [t_atom()];
-arg_types(erlang, check_process_code, 2) ->
-  [t_pid(), t_atom()];
-arg_types(erlang, crc32, 1) ->
-  [t_iodata()];
-arg_types(erlang, crc32, 2) ->
-  [t_crc32(), t_iodata()];
-arg_types(erlang, crc32_combine, 3) ->
-  [t_crc32(), t_crc32(), t_non_neg_integer()];
-arg_types(erlang, date, 0) ->
-  [];
-arg_types(erlang, decode_packet, 3) ->
-  [t_decode_packet_type(), t_binary(), t_list(t_decode_packet_option())];
-arg_types(erlang, delete_module, 1) ->
-  [t_atom()];
-arg_types(erlang, demonitor, 1) ->
-  [t_reference()];
-arg_types(erlang, demonitor, 2) ->
-  [t_reference(), t_list(t_atoms(['flush', 'info']))];
 arg_types(erlang, disconnect_node, 1) ->
   [t_node()];
-arg_types(erlang, display, 1) ->
-  [t_any()];
-arg_types(erlang, display_nl, 0) ->
-  [];
-arg_types(erlang, display_string, 1) ->
-  [t_string()];
-arg_types(erlang, dist_exit, 3) ->
-  [t_pid(), t_dist_exit(), t_sup(t_pid(), t_port())];
 arg_types(erlang, element, 2) ->
   [t_pos_fixnum(), t_tuple()];
-arg_types(erlang, erase, 0) ->
-  [];
-arg_types(erlang, erase, 1) ->
-  [t_any()];
-arg_types(erlang, error, 1) ->
-  [t_any()];
-arg_types(erlang, error, 2) ->
-  [t_any(), t_list()];
-arg_types(erlang, exit, 1) ->
-  [t_any()];
-arg_types(erlang, exit, 2) ->
-  [t_sup(t_pid(), t_port()), t_any()];
-arg_types(erlang, external_size, 1) ->
-  [t_any()]; % takes any term as input
-arg_types(erlang, external_size, 2) ->
-  [t_any(), t_list()]; % takes any term as input and a list of options
-arg_types(erlang, finish_after_on_load, 2) ->
-  [t_atom(), t_boolean()];
-arg_types(erlang, float, 1) ->
-  [t_number()];
-arg_types(erlang, float_to_list, 1) ->
-  [t_float()];
-arg_types(erlang, function_exported, 3) ->
-  [t_atom(), t_atom(), t_arity()];
 arg_types(erlang, fun_info, 1) ->
   [t_fun()];
-arg_types(erlang, fun_info, 2) ->
-  [t_fun(), t_atom()];
-arg_types(erlang, fun_to_list, 1) ->
-  [t_fun()];
-arg_types(erlang, garbage_collect, 0) ->
-  [];
-arg_types(erlang, garbage_collect, 1) ->
-  [t_pid()];
-arg_types(erlang, garbage_collect_message_area, 0) ->
-  [];
-arg_types(erlang, get, 0) ->
-  [];
-arg_types(erlang, get, 1) ->
-  [t_any()];
 arg_types(erlang, get_cookie, 0) ->
   [];
-arg_types(erlang, get_keys, 1) ->
-  [t_any()];
-arg_types(erlang, get_stacktrace, 0) ->
-  [];
-arg_types(erlang, get_module_info, 1) ->
-  [t_atom()];
-arg_types(erlang, get_module_info, 2) ->
-  [t_atom(), t_module_info_2()];
-arg_types(erlang, group_leader, 0) ->
-  [];
-arg_types(erlang, group_leader, 2) ->
-  [t_pid(), t_pid()];
-arg_types(erlang, halt, 0) ->
-  [];
-arg_types(erlang, halt, 1) ->
-  [t_sup(t_non_neg_fixnum(), t_string())];
-arg_types(erlang, hash, 2) ->
-  [t_any(), t_integer()];
 arg_types(erlang, hd, 1) ->
   [t_cons()];
-arg_types(erlang, hibernate, 3) ->
-  [t_atom(), t_atom(), t_list()];
 arg_types(erlang, info, 1) ->
   arg_types(erlang, system_info, 1); % alias
-arg_types(erlang, iolist_to_binary, 1) ->
-  [t_sup(t_iolist(), t_binary())];
-arg_types(erlang, iolist_size, 1) ->
-  [t_sup(t_iolist(), t_binary())];
-arg_types(erlang, integer_to_list, 1) ->
-  [t_integer()];
 arg_types(erlang, integer_to_list, 2) ->
   [t_integer(), t_from_range(2, 36)];
-arg_types(erlang, is_alive, 0) ->
-  [];
 arg_types(erlang, is_atom, 1) ->
   [t_any()];
 arg_types(erlang, is_binary, 1) ->
   [t_any()];
-arg_types(erlang, is_bitstr, 1) ->	% XXX: TAKE OUT
-  arg_types(erlang, is_bitstring, 1);
 arg_types(erlang, is_bitstring, 1) ->
   [t_any()];
 arg_types(erlang, is_boolean, 1) ->
   [t_any()];
-arg_types(erlang, is_builtin, 3) ->
-  [t_atom(), t_atom(), t_arity()];
 arg_types(erlang, is_constant, 1) ->
   [t_any()];
 arg_types(erlang, is_float, 1) ->
@@ -2999,8 +2141,6 @@ arg_types(erlang, is_pid, 1) ->
   [t_any()];
 arg_types(erlang, is_port, 1) ->
   [t_any()];
-arg_types(erlang, is_process_alive, 1) ->
-  [t_pid()];
 arg_types(erlang, is_record, 2) ->
   [t_any(), t_atom()];
 arg_types(erlang, is_record, 3) ->
@@ -3009,369 +2149,61 @@ arg_types(erlang, is_reference, 1) ->
   [t_any()];
 arg_types(erlang, is_tuple, 1) ->
   [t_any()];
-arg_types(erlang, length, 1) ->
-  [t_list()];
-arg_types(erlang, link, 1) ->
-  [t_sup(t_pid(), t_port())];
-arg_types(erlang, list_to_atom, 1) ->
-  [t_string()];
-arg_types(erlang, list_to_binary, 1) ->
-  [t_iolist()];
-arg_types(erlang, list_to_bitstr, 1) ->	% XXX: TAKE OUT
-  arg_types(erlang, list_to_bitstring, 1);
-arg_types(erlang, list_to_bitstring, 1) ->
-  [t_bitstrlist()];
-arg_types(erlang, list_to_existing_atom, 1) ->
-  [t_string()];
-arg_types(erlang, list_to_float, 1) ->
-  [t_list(t_byte())];
-arg_types(erlang, list_to_integer, 1) ->
-  [t_list(t_byte())];
 arg_types(erlang, list_to_integer, 2) ->
   [t_list(t_byte()), t_from_range(2, 36)];
-arg_types(erlang, list_to_pid, 1) ->
-  [t_string()];
-arg_types(erlang, list_to_tuple, 1) ->
-  [t_list()];
-arg_types(erlang, load_module, 2) ->
-  [t_atom(), t_binary()];
-arg_types(erlang, load_nif, 2) ->
-  [t_string(), t_any()];
-arg_types(erlang, loaded, 0) ->
-  [];
-arg_types(erlang, localtime, 0) ->
-  [];
-arg_types(erlang, localtime_to_universaltime, 1) ->
-  [t_tuple([t_date(), t_time()])];
-arg_types(erlang, localtime_to_universaltime, 2) ->
-  arg_types(erlang, localtime_to_universaltime, 1) ++
-    [t_sup(t_boolean(), t_atom('undefined'))];
-arg_types(erlang, make_fun, 3) ->
-  [t_atom(), t_atom(), t_arity()];
-arg_types(erlang, make_ref, 0) ->
-  [];
 arg_types(erlang, make_tuple, 2) ->
   [t_non_neg_fixnum(), t_any()];  % the value 0 is OK as first argument
 arg_types(erlang, make_tuple, 3) ->
   [t_non_neg_fixnum(), t_any(), t_list(t_tuple([t_pos_integer(), t_any()]))];
-arg_types(erlang, match_spec_test, 3) ->
-  [t_sup(t_list(), t_tuple()),
-   t_any(),
-   t_sup(t_atom('table'), t_atom('trace'))];
-arg_types(erlang, md5, 1) ->
-  [t_sup(t_iolist(), t_binary())];
-arg_types(erlang, md5_final, 1) ->
-  [t_binary()];
-arg_types(erlang, md5_init, 0) ->
-  [];
-arg_types(erlang, md5_update, 2) ->
-  [t_binary(), t_sup(t_iolist(), t_binary())];
 arg_types(erlang, memory, 0) ->
   [];
-arg_types(erlang, memory, 1) ->
-  Arg = t_atoms(['total', 'processes', 'processes_used', 'system',
-		 'atom', 'atom_used', 'binary', 'code', 'ets',
-		 'maximum']),
-  [t_sup(Arg, t_list(Arg))];
-arg_types(erlang, module_loaded, 1) ->
-  [t_atom()];
-arg_types(erlang, monitor, 2) ->
-  [t_atom(), t_sup([t_pid(), t_atom(), t_tuple([t_atom(), t_node()])])];
-arg_types(erlang, monitor_node, 2) ->
-  [t_node(), t_boolean()];
-arg_types(erlang, monitor_node, 3) ->
-  [t_node(), t_boolean(), t_list(t_atom('allow_passive_connect'))];
 arg_types(erlang, nif_error, 1) ->
   [t_any()];
 arg_types(erlang, nif_error, 2) ->
   [t_any(), t_list()];
-arg_types(erlang, node, 0) ->
-  [];
-arg_types(erlang, node, 1) ->
-  [t_identifier()];
 arg_types(erlang, nodes, 0) ->
   [];
-arg_types(erlang, nodes, 1) ->
-  NodesArg = t_atoms(['visible', 'hidden', 'connected', 'this', 'known']),
-  [t_sup(NodesArg, t_list(NodesArg))];
-arg_types(erlang, now, 0) ->
-  [];
-arg_types(erlang, open_port, 2) ->
-  ArgT = t_sup(t_unicode_string(), t_binary()),
-  [t_sup(t_atom(), t_sup([t_tuple([t_atom('spawn'), t_string()]),
-			  t_tuple([t_atom('spawn_driver'), t_string()]),
-			  t_tuple([t_atom('spawn_executable'), ArgT]),
-			  t_tuple([t_atom('fd'), t_integer(), t_integer()])])),
-   t_list(t_sup(t_sup([t_atom('stream'),
-		       t_atom('exit_status'),
-		       t_atom('use_stdio'),
-		       t_atom('nouse_stdio'),
-		       t_atom('stderr_to_stdout'),
-		       t_atom('in'),
-		       t_atom('out'),
-		       t_atom('binary'),
-		       t_atom('eof'),
-		       t_atom('hide')]),
-		t_sup([t_tuple([t_atom('packet'), t_integer()]),
-		       t_tuple([t_atom('line'), t_integer()]),
-		       t_tuple([t_atom('cd'), t_string()]),
-		       t_tuple([t_atom('env'), t_list(t_tuple(2))]), % XXX: More
-		       t_tuple([t_atom('args'), t_list(ArgT)]),
-		       t_tuple([t_atom('arg0'), ArgT])])))];
-arg_types(erlang, phash, 2) ->
-  [t_any(), t_pos_integer()];
-arg_types(erlang, phash2, 1) ->
-  [t_any()];
-arg_types(erlang, phash2, 2) ->
-  [t_any(), t_pos_integer()];
-arg_types(erlang, pid_to_list, 1) ->
-  [t_pid()];
 arg_types(erlang, port_call, 2) ->
   [t_sup(t_port(), t_atom()), t_any()];
 arg_types(erlang, port_call, 3) ->
   [t_sup(t_port(), t_atom()), t_integer(), t_any()];
-arg_types(erlang, port_close, 1) ->
-  [t_sup(t_port(), t_atom())];
-arg_types(erlang, port_command, 2) ->
-  [t_sup(t_port(), t_atom()), t_sup(t_iolist(), t_binary())];
-arg_types(erlang, port_command, 3) ->
-  [t_sup(t_port(), t_atom()),
-   t_sup(t_iolist(), t_binary()),
-   t_list(t_atoms(['force', 'nosuspend']))];
-arg_types(erlang, port_connect, 2) ->
-  [t_sup(t_port(), t_atom()), t_pid()];
-arg_types(erlang, port_control, 3) ->
-  [t_sup(t_port(), t_atom()), t_integer(), t_sup(t_iolist(), t_binary())];
-arg_types(erlang, port_get_data, 1) ->
-  [t_sup(t_port(), t_atom())];
 arg_types(erlang, port_info, 1) ->
   [t_sup(t_port(), t_atom())];
-arg_types(erlang, port_info, 2) ->
-  [t_sup(t_port(), t_atom()),
-   t_atoms(['registered_name', 'id', 'connected',
-	    'links', 'name', 'input', 'output'])];
-arg_types(erlang, port_to_list, 1) ->
-  [t_port()];
-arg_types(erlang, ports, 0) ->
-  [];
-arg_types(erlang, port_set_data, 2) ->
-  [t_sup(t_port(), t_atom()), t_any()];
-arg_types(erlang, pre_loaded, 0) ->
-  [];
-arg_types(erlang, process_display, 2) ->
-  [t_pid(), t_atom('backtrace')];
-arg_types(erlang, process_flag, 2) ->
-  [t_sup([t_atom('trap_exit'), t_atom('error_handler'),
-	  t_atom('min_heap_size'), t_atom('priority'), t_atom('save_calls'),
-	  t_atom('scheduler'),                             % undocumented
-	  t_atom('monitor_nodes'), 			  % undocumented
-	  t_tuple([t_atom('monitor_nodes'), t_list()])]), % undocumented
-   t_sup([t_boolean(), t_atom(), t_non_neg_integer()])];
-arg_types(erlang, process_flag, 3) ->
-  [t_pid(), t_atom('save_calls'), t_non_neg_integer()];
-arg_types(erlang, process_info, 1) ->
-  [t_pid()];
-arg_types(erlang, process_info, 2) ->
-  [t_pid(), t_pinfo()];
-arg_types(erlang, processes, 0) ->
-  [];
-arg_types(erlang, purge_module, 1) ->
-  [t_atom()];
-arg_types(erlang, put, 2) ->
-  [t_any(), t_any()];
-arg_types(erlang, raise, 3) ->
-  OldStyleType = t_list(t_tuple([t_atom(), t_atom(),
-				 t_sup([t_arity(), t_list()])])),
-  NewStyleType = type(erlang, get_stacktrace, 0, []),
-  [t_raise_errorclass(), t_any(), t_sup(OldStyleType, NewStyleType)];
-arg_types(erlang, read_timer, 1) ->
-  [t_reference()];
-arg_types(erlang, ref_to_list, 1) ->
-  [t_reference()];
-arg_types(erlang, register, 2) ->
-  [t_atom(), t_sup(t_port(), t_pid())];
-arg_types(erlang, registered, 0) ->
-  [];
-arg_types(erlang, resume_process, 1) ->
-  [t_pid()]; % intended for debugging only
-arg_types(erlang, round, 1) ->
-  [t_number()];
-arg_types(erlang, posixtime_to_universaltime, 1) ->
-  [t_integer()];
-arg_types(erlang, self, 0) ->
-  [];
-arg_types(erlang, send, 2) ->
-  arg_types(erlang, '!', 2);  % alias
-arg_types(erlang, send, 3) ->
-  arg_types(erlang, send, 2) ++ [t_list(t_sendoptions())];
-arg_types(erlang, send_after, 3) ->
-  [t_non_neg_integer(), t_sup(t_pid(), t_atom()), t_any()];
-arg_types(erlang, seq_trace, 2) ->
-  [t_atom(), t_sup([t_boolean(), t_tuple([t_fixnum(), t_fixnum()]), t_fixnum(), t_nil()])];
-arg_types(erlang, seq_trace_info, 1) ->
-  [t_seq_trace_info()];
-arg_types(erlang, seq_trace_print, 1) ->
-  [t_any()];
-arg_types(erlang, seq_trace_print, 2) ->
-  [t_sup(t_atom(), t_fixnum()), t_any()];
 arg_types(erlang, set_cookie, 2) ->
   [t_node(), t_atom()];
 arg_types(erlang, setelement, 3) ->
   [t_pos_integer(), t_tuple(), t_any()];
-arg_types(erlang, setnode, 2) ->
-  [t_atom(), t_integer()];
-arg_types(erlang, setnode, 3) ->
-  [t_atom(), t_port(), t_tuple(4)];
-arg_types(erlang, size, 1) ->
-  [t_sup(t_tuple(), t_binary())];
 arg_types(erlang, spawn, 1) -> %% TODO: Tuple?
   [t_fun()];
 arg_types(erlang, spawn, 2) -> %% TODO: Tuple?
   [t_node(), t_fun()];
-arg_types(erlang, spawn, 3) -> %% TODO: Tuple?
-  [t_atom(), t_atom(), t_list()];
 arg_types(erlang, spawn, 4) -> %% TODO: Tuple?
   [t_node(), t_atom(), t_atom(), t_list()];
 arg_types(erlang, spawn_link, 1) ->
   arg_types(erlang, spawn, 1);  % same
 arg_types(erlang, spawn_link, 2) ->
   arg_types(erlang, spawn, 2);  % same
-arg_types(erlang, spawn_link, 3) ->
-  arg_types(erlang, spawn, 3);  % same
 arg_types(erlang, spawn_link, 4) ->
   arg_types(erlang, spawn, 4);  % same
-arg_types(erlang, spawn_opt, 1) ->
-  [t_tuple([t_atom(), t_atom(), t_list(), t_list(t_spawn_options())])];
-arg_types(erlang, spawn_opt, 2) ->
-  [t_fun(), t_list(t_spawn_options())];
-arg_types(erlang, spawn_opt, 3) ->
-  [t_atom(), t_fun(), t_list(t_spawn_options())];
-arg_types(erlang, spawn_opt, 4) ->
-  [t_node(), t_atom(), t_list(), t_list(t_spawn_options())];
-arg_types(erlang, split_binary, 2) ->
-  [t_binary(), t_non_neg_integer()];
-arg_types(erlang, start_timer, 3) ->
-  [t_non_neg_integer(), t_sup(t_pid(), t_atom()), t_any()];
-arg_types(erlang, statistics, 1) ->
-  [t_sup([t_atom('context_switches'),
-	  t_atom('exact_reductions'),
-	  t_atom('garbage_collection'),
-	  t_atom('io'),
-	  t_atom('reductions'),
-	  t_atom('run_queue'),
-	  t_atom('runtime'),
-	  t_atom('wall_clock')])];
 arg_types(erlang, subtract, 2) ->
   arg_types(erlang, '--', 2);
 arg_types(erlang, suspend_process, 1) ->
   [t_pid()];
-arg_types(erlang, suspend_process, 2) ->
-  [t_pid(), t_list(t_sup([t_atom('unless_suspending'),
-			  t_atom('asynchronous')]))];
-arg_types(erlang, system_flag, 2) ->
-  [t_sup([t_atom('backtrace_depth'),
-	  t_atom('cpu_topology'),
-	  t_atom('debug_flags'),	% undocumented
-	  t_atom('display_items'),	% undocumented
-	  t_atom('fullsweep_after'),
-	  t_atom('min_heap_size'),
-	  t_atom('multi_scheduling'),
-	  t_atom('schedulers_online'),
-	  t_atom('scheduler_bind_type'),
-	  %% Undocumented; used to implement (the documented) seq_trace module.
-	  t_atom('sequential_tracer'),
-	  t_atom('trace_control_word'),
-	  %% 'internal_cpu_topology' is an undocumented internal feature.
-	  t_atom('internal_cpu_topology'),
-	  t_integer()]),
-   t_sup([t_integer(),
-	  %% 'cpu_topology'
-	  t_system_cpu_topology(),
-	  %% 'scheduler_bind_type'
-	  t_scheduler_bind_type_args(),
-	  %% Undocumented: the following is for 'debug_flags' that
-	  %% takes any erlang term as flags and currently ignores it.
-	  %% t_any(),	% commented out since it destroys the type signature
-	  %%
-	  %% Again undocumented; the following are for 'sequential_tracer'
-	  t_sequential_tracer(),
-	  %% The following two are for 'multi_scheduling'
-	  t_atom('block'),
-	  t_atom('unblock'),
-	  %% The following is for 'internal_cpu_topology'
-	  t_internal_cpu_topology()])];
 arg_types(erlang, system_info, 1) ->
   [t_sup([t_atom(),                     % documented
 	  t_tuple([t_atom(), t_any()]), % documented
 	  t_tuple([t_atom(), t_atom(), t_any()]),
 	  t_tuple([t_atom(allocator_sizes), t_reference(), t_any()])])];
-arg_types(erlang, system_monitor, 0) ->
-  [];
-arg_types(erlang, system_monitor, 1) ->
-  [t_system_monitor_settings()];
-arg_types(erlang, system_monitor, 2) ->
-  [t_pid(), t_system_monitor_options()];
-arg_types(erlang, system_profile, 0) ->
-  [];
-arg_types(erlang, system_profile, 2) ->
-  [t_sup([t_pid(), t_port(), t_atom('undefined')]),
-   t_system_profile_options()];
 arg_types(erlang, term_to_binary, 1) ->
   [t_any()];
-arg_types(erlang, term_to_binary, 2) ->
-  [t_any(), t_list(t_sup([t_atom('compressed'),
-			  t_tuple([t_atom('compressed'), t_from_range(0, 9)]),
-			  t_tuple([t_atom('minor_version'), t_integers([0, 1])])]))];
-arg_types(erlang, throw, 1) ->
-  [t_any()];
-arg_types(erlang, time, 0) ->
-  [];
 arg_types(erlang, tl, 1) ->
   [t_cons()];
-arg_types(erlang, trace, 3) ->
-  [t_sup(t_pid(), t_sup([t_atom('existing'), t_atom('new'), t_atom('all')])),
-   t_boolean(),
-   t_list(t_sup(t_atom(), t_tuple(2)))];
-arg_types(erlang, trace_delivered, 1) ->
-  [t_sup(t_pid(), t_atom('all'))];
-arg_types(erlang, trace_info, 2) ->
-  [t_sup([%% the following two get info about a PID
-	  t_pid(), t_atom('new'),
-	  %% while the following two get info about a func
-	  t_mfa(), t_atom('on_load')]),
-   t_sup([%% the following are items about a PID
-	  t_atom('flags'), t_atom('tracer'),
-	  %% while the following are items about a func
-	  t_atom('traced'), t_atom('match_spec'), t_atom('meta'),
-	  t_atom('meta_match_spec'), t_atom('call_count'),
-	  t_atom('call_time'), t_atom('all')])];
 arg_types(erlang, trace_pattern, 2) ->
   [t_sup(t_tuple([t_atom(), t_atom(), t_sup(t_arity(), t_atom('_'))]),
 	 t_atom('on_load')),
    t_sup([t_boolean(), t_list(), t_atom('restart'), t_atom('pause')])];
-arg_types(erlang, trace_pattern, 3) ->
-  arg_types(erlang, trace_pattern, 2) ++
-    [t_list(t_sup([t_atom('global'), t_atom('local'),
-		   t_atom('meta'), t_tuple([t_atom('meta'), t_pid()]),
-		   t_atom('call_count'), t_atom('call_time')]))];
-arg_types(erlang, trunc, 1) ->
-  [t_number()];
-arg_types(erlang, tuple_size, 1) ->
-  [t_tuple()];
 arg_types(erlang, tuple_to_list, 1) ->
   [t_tuple()];
-arg_types(erlang, universaltime, 0) ->
-  [];
-arg_types(erlang, universaltime_to_localtime, 1) ->
-  [t_tuple([t_date(), t_time()])];
-arg_types(erlang, universaltime_to_posixtime, 1) ->
-  [t_tuple([t_date(), t_time()])];
-arg_types(erlang, unlink, 1) ->
-  [t_sup(t_pid(), t_port())];
-arg_types(erlang, unregister, 1) ->
-  [t_atom()];
-arg_types(erlang, whereis, 1) ->
-  [t_atom()];
 arg_types(erlang, yield, 0) ->
   [];
 %%------- ets -----------------------------------------------------------------
@@ -3641,208 +2473,19 @@ check_fun_application(Fun, Args) ->
 %% Some basic types used in various parts of the system
 %% =====================================================================
 
-t_date() ->
-  t_tuple([t_pos_fixnum(), t_pos_fixnum(), t_pos_fixnum()]).
-
-t_time() ->
-  t_tuple([t_non_neg_fixnum(), t_non_neg_fixnum(), t_non_neg_fixnum()]).
-
-t_timestamp() ->
-  t_tuple([t_non_neg_fixnum(), t_non_neg_fixnum(), t_non_neg_fixnum()]).
-
-t_packet() ->
-  t_sup([t_binary(), t_iolist(), t_httppacket()]).
-
-t_httppacket() ->
-  t_sup([t_HttpRequest(), t_HttpResponse(),
-	 t_HttpHeader(), t_atom('http_eoh'), t_HttpError()]).
-
 t_endian() ->
   t_sup(t_atom('big'), t_atom('little')).
 
 %% =====================================================================
-%% HTTP types documented in R12B-4
-%% =====================================================================
-
-t_HttpRequest() ->
-  t_tuple([t_atom('http_request'), t_HttpMethod(), t_HttpUri(), t_HttpVersion()]).
-
-t_HttpResponse() ->
-   t_tuple([t_atom('http_response'), t_HttpVersion(), t_integer(), t_HttpString()]).
-
-t_HttpHeader() ->
-  t_tuple([t_atom('http_header'), t_integer(), t_HttpField(), t_any(), t_HttpString()]).
-
-t_HttpError() ->
-  t_tuple([t_atom('http_error'), t_HttpString()]).
-
-t_HttpMethod() ->
-  t_sup(t_HttpMethodAtom(), t_HttpString()).
-
-t_HttpMethodAtom() ->
-  t_atoms(['OPTIONS', 'GET', 'HEAD', 'POST', 'PUT', 'DELETE', 'TRACE']).
-
-t_HttpUri() ->
-  t_sup([t_atom('*'),
-	 t_tuple([t_atom('absoluteURI'),
-		  t_sup(t_atom('http'), t_atom('https')),
-		  t_HttpString(),
-		  t_sup(t_non_neg_integer(), t_atom('undefined')),
-		  t_HttpString()]),
-	 t_tuple([t_atom('scheme'), t_HttpString(), t_HttpString()]),
-	 t_tuple([t_atom('abs_path'), t_HttpString()]),
-	 t_HttpString()]).
-
-t_HttpVersion() ->
-  t_tuple([t_non_neg_integer(), t_non_neg_integer()]).
-
-t_HttpField() ->
-  t_sup(t_HttpFieldAtom(), t_HttpString()).
-
-t_HttpFieldAtom() ->
-  t_atoms(['Cache-Control', 'Connection', 'Date', 'Pragma', 'Transfer-Encoding',
-	   'Upgrade', 'Via', 'Accept', 'Accept-Charset', 'Accept-Encoding',
-	   'Accept-Language', 'Authorization', 'From', 'Host',
-	   'If-Modified-Since', 'If-Match', 'If-None-Match', 'If-Range',
-	   'If-Unmodified-Since', 'Max-Forwards', 'Proxy-Authorization',
-	   'Range', 'Referer', 'User-Agent', 'Age', 'Location',
-	   'Proxy-Authenticate', 'Public', 'Retry-After', 'Server', 'Vary',
-	   'Warning', 'Www-Authenticate', 'Allow', 'Content-Base',
-	   'Content-Encoding', 'Content-Language', 'Content-Length',
-	   'Content-Location', 'Content-Md5', 'Content-Range', 'Content-Type',
-	   'Etag', 'Expires', 'Last-Modified', 'Accept-Ranges',
-	   'Set-Cookie', 'Set-Cookie2', 'X-Forwarded-For', 'Cookie',
-	   'Keep-Alive', 'Proxy-Connection']).
-
-t_HttpString() ->
-  t_sup(t_string(), t_binary()).
-
-%% =====================================================================
-%% These are used for the built-in functions of 'code'
-%% =====================================================================
-
-t_code_load_return(Mod) ->
-  t_sup(t_tuple([t_atom('module'), case t_is_atom(Mod) of
-				     true -> Mod;
-				     false -> t_atom()
-				   end]),
-	t_tuple([t_atom('error'), t_code_load_error_rsn()])).
-
-t_code_load_error_rsn() ->	% also used in erlang:load_module/2
-  t_sup([t_atom('badfile'),
-	 t_atom('nofile'),
-	 t_atom('not_purged'),
-	 t_atom('native_code'),
-	 t_atom('on_load'),
-	 t_atom('sticky_directory')]).	% only for the 'code' functions
-
-%% =====================================================================
 %% These are used for the built-in functions of 'erlang'
 %% =====================================================================
 
-t_adler32() ->
-  t_non_neg_integer().
-
 t_crc32() ->
   t_non_neg_integer().
 
-t_decode_packet_option() ->
-  t_sup([t_tuple([t_atom('packet_size'), t_non_neg_integer()]),
-	 t_tuple([t_atom('line_length'), t_non_neg_integer()])]).
-
-t_decode_packet_type() ->
-  t_sup([t_inet_setoption_packettype(), t_atom('httph'), t_atom('httph_bin')]).
-
-t_dist_exit() ->
-  t_sup([t_atom('kill'), t_atom('noconnection'), t_atom('normal')]).
-
-t_match_spec_test_errors() ->
-  t_list(t_sup(t_tuple([t_atom('error'), t_string()]),
-	       t_tuple([t_atom('warning'), t_string()]))).
-
-t_module_info_2() ->
- t_sup([t_atom('module'),
-	t_atom('imports'),
-	t_atom('exports'),
-	t_atom('functions'),
-	t_atom('attributes'),
-	t_atom('compile'),
-	t_atom('native_addresses')]).
-
-t_pinfo() ->
-  t_sup([t_pinfo_item(), t_list(t_pinfo_item())]).
-
-t_pinfo_item() ->
-  t_sup([t_atom('backtrace'),
-	 t_atom('current_function'),
-	 t_atom('dictionary'),
-	 t_atom('error_handler'),
-	 t_atom('garbage_collection'),
-	 t_atom('group_leader'),
-	 t_atom('heap_size'),
-	 t_atom('initial_call'),
-	 t_atom('last_calls'),
-	 t_atom('links'),
-	 t_atom('memory'),
-	 t_atom('message_binary'),     % for hybrid heap only
-	 t_atom('message_queue_len'),
-	 t_atom('messages'),
-	 t_atom('monitored_by'),
-	 t_atom('monitors'),
-	 t_atom('priority'),
-	 t_atom('reductions'),
-	 t_atom('registered_name'),
-	 t_atom('sequential_trace_token'),
-	 t_atom('stack_size'),
-	 t_atom('status'),
-	 t_atom('suspending'),
-	 t_atom('total_heap_size'),
-	 t_atom('trap_exit')]).
-
-t_process_priority_level() ->
-  t_sup([t_atom('max'), t_atom('high'), t_atom('normal'), t_atom('low')]).
-
-t_process_status() ->
-  t_sup([t_atom('exiting'), t_atom('garbage_collecting'),
-	 t_atom('runnable'), t_atom('running'),
-	 t_atom('suspended'), t_atom('waiting')]).
-
-t_raise_errorclass() ->
-  t_sup([t_atom('error'), t_atom('exit'), t_atom('throw')]).
-
-t_sendoptions() ->
-  t_sup(t_atom('noconnect'), t_atom('nosuspend')).
-
-t_seq_trace_info() ->
-  t_sup([t_atom('send'),
-	 t_atom('receive'),
-	 t_atom('print'),
-	 t_atom('timestamp'),
-	 t_atom('label'),
-	 t_atom('serial')]).
-
-%% XXX: Better if we also maintain correspondencies between infos and values
-t_seq_trace_info_returns() ->
-  Values = t_sup([t_non_neg_integer(), t_boolean(),
-		  t_tuple([t_non_neg_integer(), t_non_neg_integer()])]),
-  t_sup(t_tuple([t_seq_trace_info(), Values]), t_nil()).
-
 t_sequential_tracer() ->
   t_sup([t_atom('false'), t_pid(), t_port()]).
 
-t_spawn_options() ->
-  t_sup([t_atom('link'),
-	 t_atom('monitor'),
-	 t_tuple([t_atom('priority'), t_process_priority_level()]),
-	 t_tuple([t_atom('min_heap_size'), t_fixnum()]),
-	 t_tuple([t_atom('fullsweep_after'), t_fixnum()])]).
-
-t_spawn_opt_return(List) ->
-  case t_is_none(t_inf(t_list(t_atom('monitor')), List)) of
-    true -> t_pid();
-    false -> t_sup(t_pid(), t_tuple([t_pid(), t_reference()]))
-  end.
-
 t_system_cpu_topology() ->
   t_sup(t_atom('undefined'), t_system_cpu_topology_level_entry_list()).
 
@@ -3879,17 +2522,6 @@ t_internal_cpu_topology() -> %% Internal undocumented type
 			t_non_neg_fixnum()])),
 	t_atom('undefined')).
 
-t_scheduler_bind_type_args() ->
-  t_sup([t_atom('default_bind'),
-	 t_atom('no_node_processor_spread'),
-	 t_atom('no_node_thread_spread'),
-	 t_atom('no_spread'),
-	 t_atom('processor_spread'),
-	 t_atom('spread'),
-	 t_atom('thread_spread'),
-	 t_atom('thread_no_node_processor_spread'),
-	 t_atom('unbound')]).
-  
 t_scheduler_bind_type_results() ->
   t_sup([t_atom('no_node_processor_spread'),
 	 t_atom('no_node_thread_spread'),
@@ -3900,29 +2532,9 @@ t_scheduler_bind_type_results() ->
 	 t_atom('thread_no_node_processor_spread'),
 	 t_atom('unbound')]).
 
-t_system_monitor_settings() ->
-  t_sup([t_atom('undefined'),
-	 t_tuple([t_pid(), t_system_monitor_options()])]).
-
-t_system_monitor_options() ->
-  t_list(t_sup([t_atom('busy_port'),
-		t_atom('busy_dist_port'),
-		t_tuple([t_atom('long_gc'), t_integer()]),
-		t_tuple([t_atom('large_heap'), t_integer()])])).
-
 t_system_multi_scheduling() ->
   t_sup([t_atom('blocked'), t_atom('disabled'), t_atom('enabled')]).
 
-t_system_profile_options() ->
-  t_list(t_sup([t_atom('exclusive'),
-		t_atom('runnable_ports'),
-		t_atom('runnable_procs'),
-		t_atom('scheduler')])).
-
-t_system_profile_return() ->
-  t_sup(t_atom('undefined'),
-	t_tuple([t_sup(t_pid(), t_port()), t_system_profile_options()])).
-
 %% =====================================================================
 %% These are used for the built-in functions of 'hipe_bifs'
 %% =====================================================================
@@ -3955,25 +2567,6 @@ t_insn_type() ->
 	 t_atom('closure')]).
 
 %% =====================================================================
-%% These are used for the built-in functions of 'inet'
-%% =====================================================================
-
-t_inet_setoption_packettype() ->
-  t_sup([t_atom('raw'),
-	 t_integers([0,1,2,4]),
-	 t_atom('asn1'), t_atom('cdr'), t_atom('sunrm'),
-	 t_atom('fcgi'), t_atom('tpkt'), t_atom('line'),
-	 t_atom('http'),
-	 t_atom('http_bin')]).	%% but t_atom('httph') is not needed
-
-%% =====================================================================
-%% These are used for the built-in functions of 'unicode'
-%% =====================================================================
-
-t_encoding_a2b() -> % for the 2nd arg of atom_to_binary/2 and binary_to_atom/2
-  t_atoms(['latin1', 'unicode', 'utf8']).
-
-%% =====================================================================
 %% Some testing code for ranges below
 %% =====================================================================
 
diff --git a/lib/kernel/src/disk_log_1.erl b/lib/kernel/src/disk_log_1.erl
index 266df84a03..0cb1ed579a 100644
--- a/lib/kernel/src/disk_log_1.erl
+++ b/lib/kernel/src/disk_log_1.erl
@@ -1495,7 +1495,7 @@ fwrite_close2(Fd, FileName, B) ->
 pwrite_close2(Fd, FileName, Position, B) ->
     case file:pwrite(Fd, Position, B) of
 	ok -> ok;
-	Error -> file_error(FileName, {error, Error})
+	{error,Error} -> file_error(FileName, {error, Error})
     end.
 
 position2(Fd, FileName, Pos) ->
diff --git a/lib/kernel/src/error_handler.erl b/lib/kernel/src/error_handler.erl
index a67b11a888..f8bc5f499c 100644
--- a/lib/kernel/src/error_handler.erl
+++ b/lib/kernel/src/error_handler.erl
@@ -90,7 +90,7 @@ int() -> int.
 crash(Fun, Args) ->
     crash({Fun,Args,[]}).
 
--spec crash(atom(), atom(), arity()) -> no_return().
+-spec crash(atom(), atom(), arity() | [term()]) -> no_return().
 
 crash(M, F, A) ->
     crash({M,F,A,[]}).