← Back to branch summary

~ubuntu-branches/debian/squeeze/erlang/squeeze

« back to all changes in this revision

Viewing changes to lib/hipe/cerl/erl_bif_types.erl

  • Committer: Bazaar Package Importer
  • Author(s): Sergei Golovan
  • Date: 2009-08-05 20:54:29 UTC
  • mfrom: (6.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20090805205429-pm4pnwew8axraosl
Tags: 1:13.b.1-dfsg-5
http://bugs.debian.org/536891
* Fixed parentheses in Emacs mode (closes: #536891).
* Removed unnecessary conflicts with erlang-manpages package.
* Added workaround for #475459: disabled threads on sparc architecture.
  This breaks wxErlang, so it's only a temporary solution.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/hipe/cerl/erl_bif_types.erl
45
45
                    t_atom_vals/1,
46
46
                    t_binary/0,
47
47
                    t_bitstr/0,
48
 
                    t_bool/0,
 
48
                    t_boolean/0,
49
49
                    t_byte/0,
50
50
                    t_char/0,
51
51
                    t_cons/0,
77
77
                    t_is_atom/1,
78
78
                    t_is_binary/1,
79
79
                    t_is_bitstr/1,
80
 
                    t_is_bool/1,
 
80
                    t_is_boolean/1,
81
81
                    t_is_cons/1,
82
82
                    t_is_constant/1,
83
83
                    t_is_float/1,
150
150
type(code, add_path, 1, Xs) ->
151
151
  strict(arg_types(code, add_path, 1), Xs,
152
152
         fun (_) ->
153
 
             t_sup(t_bool(),
 
153
             t_sup(t_boolean(),
154
154
                   t_tuple([t_atom('error'), t_atom('bad_directory')]))
155
155
         end);
156
156
type(code, add_patha, 1, Xs) ->
172
172
type(code, del_path, 1, Xs) ->
173
173
  strict(arg_types(code, del_path, 1), Xs,
174
174
         fun (_) ->
175
 
             t_sup(t_bool(),
 
175
             t_sup(t_boolean(),
176
176
                   t_tuple([t_atom('error'), t_atom('bad_name')]))
177
177
         end);
178
178
type(code, delete, 1, Xs) ->
179
 
  strict(arg_types(code, delete, 1), Xs, fun (_) -> t_bool() end);
 
179
  strict(arg_types(code, delete, 1), Xs, fun (_) -> t_boolean() end);
180
180
type(code, ensure_loaded, 1, Xs) ->
181
181
  type(code, load_file, 1, Xs);
182
182
type(code, get_chunk, 2, Xs) ->
199
199
                    t_atom('false')])
200
200
         end);
201
201
type(code, is_sticky, 1, Xs) ->
202
 
  strict(arg_types(code, is_sticky, 1), Xs, fun (_) -> t_bool() end);
 
202
  strict(arg_types(code, is_sticky, 1), Xs, fun (_) -> t_boolean() end);
203
203
type(code, is_module_native, 1, Xs) ->
204
204
  strict(arg_types(code, is_module_native, 1), Xs,
205
 
         fun (_) -> t_sup(t_bool(), t_atom('undefined')) end);
 
205
         fun (_) -> t_sup(t_boolean(), t_atom('undefined')) end);
206
206
type(code, lib_dir, 0, _) ->
207
207
  t_string();
208
208
type(code, lib_dir, 1, Xs) ->
326
326
    false ->
327
327
      case t_is_integer(X1) andalso t_is_integer(X2) of
328
328
        true -> type(erlang, '=:=', 2, Xs);
329
 
        false -> strict(Xs, t_bool())
 
329
        false -> strict(Xs, t_boolean())
330
330
      end
331
331
  end;
332
332
type(erlang, '/=', 2, Xs = [X1, X2]) -> 
335
335
    false ->
336
336
      case t_is_integer(X1) andalso t_is_integer(X2) of
337
337
        true -> type(erlang, '=/=', 2, Xs);
338
 
        false -> strict(Xs, t_bool())
 
338
        false -> strict(Xs, t_boolean())
339
339
      end
340
340
  end;
341
341
type(erlang, '=:=', 2, Xs = [Lhs, Rhs]) -> 
346
346
        case t_is_atom(Lhs) andalso t_is_atom(Rhs) of
347
347
          true ->
348
348
            case {t_atom_vals(Lhs), t_atom_vals(Rhs)} of
349
 
              {unknown, _} -> t_bool();
350
 
              {_, unknown} -> t_bool();
 
349
              {unknown, _} -> t_boolean();
 
350
              {_, unknown} -> t_boolean();
351
351
              {[X], [X]} -> t_atom('true');
352
352
              {LhsVals, RhsVals} ->
353
353
                case lists:all(fun({X, Y}) -> X =/= Y end, 
354
354
                               [{X, Y} || X <- LhsVals, Y <- RhsVals]) of
355
355
                  true -> t_atom('false');
356
 
                  false -> t_bool()
 
356
                  false -> t_boolean()
357
357
                end
358
358
            end;
359
359
          false ->
360
360
            case t_is_integer(Lhs) andalso t_is_integer(Rhs) of
361
 
              false -> t_bool();
 
361
              false -> t_boolean();
362
362
              true ->
363
363
                case {t_number_vals(Lhs), t_number_vals(Rhs)} of
364
364
                  {[X], [X]} when is_integer(X) -> t_atom('true');
375
375
                            andalso (RhsMin > LhsMax)),
376
376
                    case Ans1 orelse Ans2 of
377
377
                      true -> t_atom('false');
378
 
                      false -> t_bool()
 
378
                      false -> t_boolean()
379
379
                    end
380
380
                end
381
381
            end
390
390
        case t_is_atom(Lhs) andalso t_is_atom(Rhs) of
391
391
          true ->
392
392
            case {t_atom_vals(Lhs), t_atom_vals(Rhs)} of
393
 
              {unknown, _} -> t_bool();
394
 
              {_, unknown} -> t_bool();
 
393
              {unknown, _} -> t_boolean();
 
394
              {_, unknown} -> t_boolean();
395
395
              {[Val], [Val]} -> t_atom('false');
396
396
              {LhsVals, RhsVals} ->
397
397
                t_sup([t_from_term(X =/= Y) || X <- LhsVals, Y <- RhsVals])
398
398
            end;
399
399
          false ->
400
400
            case t_is_integer(Lhs) andalso t_is_integer(Rhs) of
401
 
              false -> t_bool();
 
401
              false -> t_boolean();
402
402
              true ->
403
403
                LhsMax = number_max(Lhs),
404
404
                LhsMin = number_min(Lhs),
414
414
                    if LhsMax =:= LhsMin, 
415
415
                       RhsMin =:= RhsMax, 
416
416
                       RhsMax =:= LhsMax -> t_atom('false');
417
 
                       true -> t_bool()
 
417
                       true -> t_boolean()
418
418
                    end
419
419
                end
420
420
            end
434
434
        if 
435
435
          is_integer(LhsMin), is_integer(RhsMax), LhsMin > RhsMax -> T;
436
436
          is_integer(LhsMax), is_integer(RhsMin), RhsMin >= LhsMax -> F;
437
 
          true -> t_bool()
 
437
          true -> t_boolean()
438
438
        end;
439
 
      false -> t_bool()
 
439
      false -> t_boolean()
440
440
    end,
441
441
  strict(Xs, Ans);
442
442
type(erlang, '>=', 2, Xs = [Lhs, Rhs]) ->
452
452
        if 
453
453
          is_integer(LhsMin), is_integer(RhsMax), LhsMin >= RhsMax -> T;
454
454
          is_integer(LhsMax), is_integer(RhsMin), RhsMin > LhsMax -> F;
455
 
          true -> t_bool()
 
455
          true -> t_boolean()
456
456
        end;
457
 
      false -> t_bool()
 
457
      false -> t_boolean()
458
458
    end,
459
459
  strict(Xs, Ans);
460
460
type(erlang, '<', 2, Xs = [Lhs, Rhs]) ->
470
470
        if 
471
471
          is_integer(LhsMax), is_integer(RhsMin), LhsMax < RhsMin -> T;
472
472
          is_integer(LhsMin), is_integer(RhsMax), RhsMax =< LhsMin -> F;
473
 
          true -> t_bool()
 
473
          true -> t_boolean()
474
474
        end;
475
 
      false -> t_bool()
 
475
      false -> t_boolean()
476
476
    end,
477
477
  strict(Xs, Ans);
478
478
type(erlang, '=<', 2, Xs = [Lhs, Rhs]) ->
488
488
        if 
489
489
          is_integer(LhsMax), is_integer(RhsMin), LhsMax =< RhsMin -> T;
490
490
          is_integer(LhsMin), is_integer(RhsMax), RhsMax < LhsMin -> F;
491
 
          true -> t_bool()
 
491
          true -> t_boolean()
492
492
        end;
493
 
      false -> t_bool()
 
493
      false -> t_boolean()
494
494
    end,
495
495
  strict(Xs, Ans);
496
496
type(erlang, '+', 1, Xs) ->
597
597
             end
598
598
         end);
599
599
type(erlang, 'and', 2, Xs) ->
600
 
  strict(arg_types(erlang, 'and', 2), Xs, fun (_) -> t_bool() end);
 
600
  strict(arg_types(erlang, 'and', 2), Xs, fun (_) -> t_boolean() end);
601
601
type(erlang, 'or', 2, Xs) ->
602
 
  strict(arg_types(erlang, 'or', 2), Xs, fun (_) -> t_bool() end);
 
602
  strict(arg_types(erlang, 'or', 2), Xs, fun (_) -> t_boolean() end);
603
603
type(erlang, 'xor', 2, Xs) ->
604
 
  strict(arg_types(erlang, 'xor', 2), Xs, fun (_) -> t_bool() end);
 
604
  strict(arg_types(erlang, 'xor', 2), Xs, fun (_) -> t_boolean() end);
605
605
type(erlang, 'not', 1, Xs) ->
606
 
  strict(arg_types(erlang, 'not', 1), Xs, fun (_) -> t_bool() end);
 
606
  strict(arg_types(erlang, 'not', 1), Xs, fun (_) -> t_boolean() end);
607
607
type(erlang, 'band', 2, Xs) ->
608
608
  strict(arg_types(erlang, 'band', 2), Xs,
609
609
         fun ([X1, X2]) ->
726
726
         fun (_) -> t_sup(t_integer(), t_atom('false')) end);
727
727
type(erlang, check_process_code, 2, Xs) ->
728
728
  strict(arg_types(erlang, check_process_code, 2), Xs,
729
 
         fun (_) -> t_bool() end);
 
729
         fun (_) -> t_boolean() end);
730
730
type(erlang, concat_binary, 1, Xs) ->
731
731
  strict(arg_types(erlang, concat_binary, 1), Xs, fun (_) -> t_binary() end);
732
732
type(erlang, date, 0, _) ->
745
745
type(erlang, demonitor, 1, Xs) ->
746
746
  strict(arg_types(erlang, demonitor, 1), Xs, fun (_) -> t_atom('true') end);
747
747
type(erlang, disconnect_node, 1, Xs) ->
748
 
  strict(arg_types(erlang, disconnect_node, 1), Xs, fun (_) -> t_bool() end);
 
748
  strict(arg_types(erlang, disconnect_node, 1), Xs, fun (_) -> t_boolean() end);
749
749
type(erlang, display, 1, _) -> t_atom('true');
750
750
type(erlang, dist_exit, 3, Xs) ->
751
751
  strict(arg_types(erlang, dist_exit, 3), Xs, fun (_) -> t_atom('true') end);
780
780
type(erlang, float_to_list, 1, Xs) ->
781
781
  strict(arg_types(erlang, float_to_list, 1), Xs, fun (_) -> t_string() end);
782
782
type(erlang, function_exported, 3, Xs) ->
783
 
  strict(arg_types(erlang, function_exported, 3), Xs, fun (_) -> t_bool() end);
 
783
  strict(arg_types(erlang, function_exported, 3), Xs,
 
784
         fun (_) -> t_boolean() end);
784
785
type(erlang, fun_info, 1, Xs) ->
785
786
  strict(arg_types(erlang, fun_info, 1), Xs,
786
787
         fun (_) -> t_list(t_tuple([t_atom(), t_any()])) end);
791
792
  strict(arg_types(erlang, fun_to_list, 1), Xs, fun (_) -> t_string() end);
792
793
type(erlang, garbage_collect, 0, _) -> t_atom('true');
793
794
type(erlang, garbage_collect, 1, Xs) ->
794
 
  strict(arg_types(erlang, garbage_collect, 1), Xs, fun (_) -> t_bool() end);
 
795
  strict(arg_types(erlang, garbage_collect, 1), Xs, fun (_) -> t_boolean() end);
795
796
type(erlang, get, 0, _) -> t_list(t_tuple(2));
796
797
type(erlang, get, 1, _) -> t_any();          % | t_atom('undefined')
797
798
type(erlang, get_cookie, 0, _) -> t_atom();  % | t_atom('nocookie')
848
849
type(erlang, iolist_to_binary, 1, Xs) ->
849
850
  strict(arg_types(erlang, iolist_to_binary, 1), Xs,
850
851
         fun (_) -> t_binary() end);
851
 
type(erlang, is_alive, 0, _) -> t_bool();
 
852
type(erlang, is_alive, 0, _) -> t_boolean();
852
853
type(erlang, is_atom, 1, Xs) ->   
853
854
  Fun = fun (X) -> check_guard(X, fun (Y) -> t_is_atom(Y) end, t_atom()) end,
854
855
  strict(arg_types(erlang, is_atom, 1), Xs, Fun);
866
867
  strict(arg_types(erlang, is_bitstring, 1), Xs, Fun);
867
868
type(erlang, is_boolean, 1, Xs) ->
868
869
  Fun = fun (X) ->
869
 
            check_guard(X, fun (Y) -> t_is_bool(Y) end, t_bool())
 
870
            check_guard(X, fun (Y) -> t_is_boolean(Y) end, t_boolean())
870
871
        end,
871
872
  strict(arg_types(erlang, is_boolean, 1), Xs, Fun);
872
873
type(erlang, is_builtin, 3, Xs) ->
873
 
  strict(arg_types(erlang, is_builtin, 3), Xs, fun (_) -> t_bool() end);
 
874
  strict(arg_types(erlang, is_builtin, 3), Xs, fun (_) -> t_boolean() end);
874
875
type(erlang, is_constant, 1, Xs) ->
875
876
  Fun = fun (X) ->
876
877
            check_guard(X, fun (Y) -> t_is_constant(Y) end, t_constant())
887
888
type(erlang, is_function, 2, Xs) ->
888
889
  Fun = fun ([FunType, ArityType]) -> 
889
890
            case t_number_vals(ArityType) of
890
 
              unknown -> t_bool();
 
891
              unknown -> t_boolean();
891
892
              [Val] -> 
892
893
                FunConstr = t_fun(any_list(Val), t_any()),
893
894
                Fun2 = fun (X) ->
894
895
                           t_is_subtype(X, FunConstr) andalso (not t_is_none(X))
895
896
                       end,
896
897
                check_guard_single(FunType, Fun2, FunConstr);
897
 
              IntList when is_list(IntList) -> t_bool() %% true?
 
898
              IntList when is_list(IntList) -> t_boolean() %% true?
898
899
            end
899
900
        end,
900
901
  strict(arg_types(erlang, is_function, 2), Xs, Fun);
922
923
  strict(arg_types(erlang, is_port, 1), Xs, Fun);
923
924
type(erlang, is_process_alive, 1, Xs) ->
924
925
  strict(arg_types(erlang, is_process_alive, 1), Xs,
925
 
         fun (_) -> t_bool() end);
 
926
         fun (_) -> t_boolean() end);
926
927
type(erlang, is_record, 2, Xs) ->
927
928
  Fun = fun ([X, Y]) ->
928
929
            case t_is_tuple(X) of
929
930
              false ->
930
931
                case t_is_none(t_inf(t_tuple(), X)) of
931
932
                  true -> t_atom('false');
932
 
                  false -> t_bool()
 
933
                  false -> t_boolean()
933
934
                end;
934
935
              true ->
935
936
                case t_tuple_subtypes(X) of
936
 
                  unknown -> t_bool();
 
937
                  unknown -> t_boolean();
937
938
                  [Tuple] ->
938
939
                    case t_tuple_args(Tuple) of
939
 
                      %% any -> t_bool();
 
940
                      %% any -> t_boolean();
940
941
                      [Tag|_] ->
941
942
                        case t_is_atom(Tag) of
942
943
                          false ->
943
944
                            TagAtom = t_inf(Tag, t_atom()),
944
945
                            case t_is_none(TagAtom) of
945
946
                              true -> t_atom('false');
946
 
                              false -> t_bool()
 
947
                              false -> t_boolean()
947
948
                            end;
948
949
                          true ->
949
950
                            case t_atom_vals(Tag) of
950
951
                              [RealTag] -> 
951
952
                                case t_atom_vals(Y) of
952
953
                                  [RealTag] -> t_atom('true');
953
 
                                  _ -> t_bool() 
 
954
                                  _ -> t_boolean() 
954
955
                                end;
955
 
                              _ -> t_bool()
 
956
                              _ -> t_boolean()
956
957
                            end
957
958
                        end
958
959
                    end;
970
971
                [RealArity] = Arity,
971
972
                case t_is_none(t_inf(t_tuple(RealArity), X)) of
972
973
                  true -> t_atom('false');
973
 
                  false -> t_bool()
 
974
                  false -> t_boolean()
974
975
                end;
975
976
              false ->
976
977
                case t_is_none(t_inf(t_tuple(), X)) of
977
978
                  true -> t_atom('false');
978
 
                  false -> t_bool()
 
979
                  false -> t_boolean()
979
980
                end;
980
981
              true when length(Arity) =:= 1 ->
981
982
                [RealArity] = Arity,
982
983
                case t_tuple_subtypes(X) of
983
 
                  unknown -> t_bool();
 
984
                  unknown -> t_boolean();
984
985
                  [Tuple] ->
985
986
                    case t_tuple_args(Tuple) of
986
 
                      %% any -> t_bool();
 
987
                      %% any -> t_boolean();
987
988
                      Args when length(Args) =:= RealArity ->
988
989
                        Tag = hd(Args),
989
990
                        case t_is_atom(Tag) of
991
992
                            TagAtom = t_inf(Tag, t_atom()),
992
993
                            case t_is_none(TagAtom) of
993
994
                              true -> t_atom('false');
994
 
                              false -> t_bool()
 
995
                              false -> t_boolean()
995
996
                            end;
996
997
                          true ->
997
998
                            case t_atom_vals(Tag) of
998
999
                              [RealTag] -> 
999
1000
                                case t_atom_vals(Y) of
1000
1001
                                  [RealTag] -> t_atom('true');
1001
 
                                  _ -> t_bool()
 
1002
                                  _ -> t_boolean()
1002
1003
                                end;
1003
 
                              _ -> t_bool()
 
1004
                              _ -> t_boolean()
1004
1005
                            end
1005
1006
                        end;
1006
1007
                      Args when length(Args) =/= RealArity ->
1007
1008
                        t_atom('false')
1008
1009
                    end;
1009
1010
                  [_, _|_] ->
1010
 
                    t_bool()
 
1011
                    t_boolean()
1011
1012
                end;
1012
1013
              true ->
1013
 
                t_bool()
 
1014
                t_boolean()
1014
1015
            end
1015
1016
        end,
1016
1017
  strict(arg_types(erlang, is_record, 3), Xs, Fun);
1077
1078
type(erlang, make_ref, 0, _) -> t_reference();
1078
1079
type(erlang, make_tuple, 2, Xs) ->
1079
1080
  strict(arg_types(erlang, make_tuple, 2), Xs,
1080
 
         fun ([Int,_]) ->
 
1081
         fun ([Int, _]) ->
 
1082
             case t_number_vals(Int) of
 
1083
               [N] when is_integer(N), N >= 0 -> t_tuple(N);
 
1084
               _Other -> t_tuple()
 
1085
             end
 
1086
         end);
 
1087
type(erlang, make_tuple, 3, Xs) ->
 
1088
  strict(arg_types(erlang, make_tuple, 3), Xs,
 
1089
         fun ([Int, _, _]) ->
1081
1090
             case t_number_vals(Int) of
1082
1091
               [N] when is_integer(N), N >= 0 -> t_tuple(N);
1083
1092
               _Other -> t_tuple()
1099
1108
type(erlang, md5_update, 2, Xs) ->
1100
1109
  strict(arg_types(erlang, md5_update, 2), Xs, fun (_) -> t_binary() end);
1101
1110
type(erlang, module_loaded, 1, Xs) ->
1102
 
  strict(arg_types(erlang, module_loaded, 1), Xs, fun (_) -> t_bool() end);
 
1111
  strict(arg_types(erlang, module_loaded, 1), Xs, fun (_) -> t_boolean() end);
1103
1112
type(erlang, monitor, 2, Xs) ->
1104
1113
  strict(arg_types(erlang, monitor, 2), Xs, fun (_) -> t_reference() end);
1105
1114
type(erlang, monitor_node, 2, Xs) ->
1179
1188
type(erlang, pre_loaded, 0, _) -> t_list(t_atom());
1180
1189
type(erlang, process_display, 2, _) -> t_atom('true');
1181
1190
type(erlang, process_flag, 2, Xs) ->
1182
 
  T_process_flag_returns = t_sup([t_bool(), t_atom(), t_non_neg_integer()]),
 
1191
  T_process_flag_returns = t_sup([t_boolean(), t_atom(), t_non_neg_integer()]),
1183
1192
  strict(arg_types(erlang, process_flag, 2), Xs,
1184
1193
         fun ([Flag, _Option]) ->
1185
1194
             case t_is_atom(Flag) of
1187
1196
                 case t_atom_vals(Flag) of
1188
1197
                   ['error_handler'] -> t_atom();
1189
1198
                   ['min_heap_size'] -> t_non_neg_integer();
1190
 
                   ['monitor_nodes'] -> t_bool();
 
1199
                   ['monitor_nodes'] -> t_boolean();
1191
1200
                   ['priority'] -> t_process_priority_level();
1192
1201
                   ['save_calls'] -> t_non_neg_integer();
1193
 
                   ['trap_exit'] -> t_bool();
 
1202
                   ['trap_exit'] -> t_boolean();
1194
1203
                   List when is_list(List) ->
1195
1204
                     T_process_flag_returns;
1196
1205
                   unknown ->
1268
1277
                         ['total_heap_size'] ->
1269
1278
                           t_tuple([InfoItem, t_non_neg_integer()]);
1270
1279
                         ['trap_exit'] ->
1271
 
                           t_tuple([InfoItem, t_bool()]);
 
1280
                           t_tuple([InfoItem, t_boolean()]);
1272
1281
                         List when is_list(List) ->
1273
1282
                           T_process_info_2_normal_returns;
1274
1283
                         unknown ->
1320
1329
             case t_atom_vals(Item) of
1321
1330
               ['label'] -> t_sup(t_tuple([Item, t_any()]), t_nil());
1322
1331
               ['serial'] -> t_sup(t_tuple([Item, t_tuple(2)]), t_nil());
1323
 
               ['send'] -> t_tuple([Item, t_bool()]);
1324
 
               ['receive'] -> t_tuple([Item, t_bool()]);
1325
 
               ['print'] -> t_tuple([Item, t_bool()]);
1326
 
               ['timestamp'] -> t_tuple([Item, t_bool()]);
 
1332
               ['send'] -> t_tuple([Item, t_boolean()]);
 
1333
               ['receive'] -> t_tuple([Item, t_boolean()]);
 
1334
               ['print'] -> t_tuple([Item, t_boolean()]);
 
1335
               ['timestamp'] -> t_tuple([Item, t_boolean()]);
1327
1336
               List when is_list(List) ->
1328
1337
                 t_sup(t_tuple([t_seq_trace_info(), t_any()]), t_nil());
1329
1338
               unknown ->
1331
1340
             end
1332
1341
         end);
1333
1342
type(erlang, seq_trace_print, 1, Xs) ->
1334
 
  strict(arg_types(erlang, seq_trace_print, 1), Xs, fun (_) -> t_bool() end);
 
1343
  strict(arg_types(erlang, seq_trace_print, 1), Xs, fun (_) -> t_boolean() end);
1335
1344
type(erlang, seq_trace_print, 2, Xs) ->
1336
 
  strict(arg_types(erlang, seq_trace_print, 2), Xs, fun (_) -> t_bool() end);
 
1345
  strict(arg_types(erlang, seq_trace_print, 2), Xs, fun (_) -> t_boolean() end);
1337
1346
type(erlang, set_cookie, 2, Xs) ->
1338
1347
  strict(arg_types(erlang, set_cookie, 2), Xs, fun (_) -> t_atom('true') end);
1339
1348
type(erlang, setelement, 3, Xs) ->
1340
1349
  strict(arg_types(erlang, setelement, 3), Xs,
1341
1350
         fun ([X1, X2, X3]) ->
1342
 
             Ans =
1343
 
               case t_tuple_subtypes(X2) of
1344
 
                 unknown -> t_tuple();
1345
 
                 [_] ->
1346
 
                   Sz = t_tuple_size(X2),
1347
 
                   As = t_tuple_args(X2),
1348
 
                   case t_number_vals(X1) of
1349
 
                     unknown ->
1350
 
                       t_tuple([t_sup(X, X3) || X <- As]);
1351
 
                     [N] when is_integer(N), 1 =< N, N =< Sz ->
1352
 
                       t_tuple(list_replace(N, X3, As));
1353
 
                     [N] when is_integer(N), N < 1 ->
1354
 
                       t_none();
1355
 
                     [N] when is_integer(N), N > Sz ->
1356
 
                       t_none();
1357
 
                     Ns ->
1358
 
                       Fun = fun
1359
 
                               (N, Xs) when is_integer(N), 1 =< N, N =< Sz ->
1360
 
                                 X = lists:nth(N, Xs),
1361
 
                                 Y = t_sup(X, X3),
1362
 
                                 list_replace(N, Y, Xs);
 
1351
             case t_tuple_subtypes(X2) of
 
1352
               unknown -> t_tuple();
 
1353
               [_] ->
 
1354
                 Sz = t_tuple_size(X2),
 
1355
                 As = t_tuple_args(X2),
 
1356
                 case t_number_vals(X1) of
 
1357
                   unknown ->
 
1358
                     t_tuple([t_sup(X, X3) || X <- As]);
 
1359
                   [N] when is_integer(N), 1 =< N, N =< Sz ->
 
1360
                     t_tuple(list_replace(N, X3, As));
 
1361
                   [N] when is_integer(N), N < 1 ->
 
1362
                     t_none();
 
1363
                   [N] when is_integer(N), N > Sz ->
 
1364
                     t_none();
 
1365
                   Ns ->
 
1366
                     Fun = fun (N, Xs) when is_integer(N), 1 =< N, N =< Sz ->
 
1367
                               X = lists:nth(N, Xs),
 
1368
                               Y = t_sup(X, X3),
 
1369
                               list_replace(N, Y, Xs);
1363
1370
                               (_, Xs) ->
1364
 
                                 Xs
1365
 
                             end,
1366
 
                       t_tuple(lists:foldl(Fun, As, Ns))
1367
 
                   end;
1368
 
                 Ts when is_list(Ts) ->
1369
 
                   t_sup([type(erlang, setelement, 3, [X1, Y, X3]) || Y <- Ts])
1370
 
               end,
1371
 
             Ans
 
1371
                               Xs
 
1372
                           end,
 
1373
                     t_tuple(lists:foldl(Fun, As, Ns))
 
1374
                 end;
 
1375
               Ts when is_list(Ts) ->
 
1376
                 t_sup([type(erlang, setelement, 3, [X1, Y, X3]) || Y <- Ts])
 
1377
             end
1372
1378
         end);
1373
1379
type(erlang, setnode, 2, Xs) ->
1374
1380
  strict(arg_types(erlang, setnode, 2), Xs, fun (_) -> t_atom('true') end);
1456
1462
         fun (_) -> t_atom('true') end);
1457
1463
type(erlang, suspend_process, 2, Xs) ->
1458
1464
  strict(arg_types(erlang, suspend_process, 2), Xs,
1459
 
         fun (_) -> t_bool() end);
 
1465
         fun (_) -> t_boolean() end);
1460
1466
type(erlang, system_flag, 2, Xs) ->
1461
1467
  strict(arg_types(erlang, system_flag, 2), Xs,
1462
1468
         fun ([Flag,_Value]) ->
1463
1469
             %% this provides an overapproximation of all return values 
1464
1470
             T_system_flag_2 = t_sup([t_integer(),
1465
 
                                      t_bool(),
 
1471
                                      t_boolean(),
1466
1472
                                      t_system_cpu_topology(),
1467
1473
                                      t_system_multi_scheduling()]),
1468
1474
             case t_is_atom(Flag) of
1524
1530
                                              t_list(t_tuple([t_atom(),
1525
1531
                                                              t_any()]))]))]);
1526
1532
                   ['break_ignored'] ->
1527
 
                     t_bool();
 
1533
                     t_boolean();
1528
1534
                   ['cpu_topology'] ->
1529
1535
                     t_system_cpu_topology();
1530
1536
                   ['compat_rel'] ->
1532
1538
                   ['creation'] ->
1533
1539
                     t_fixnum();
1534
1540
                   ['debug_compiled'] ->
1535
 
                     t_bool();
 
1541
                     t_boolean();
1536
1542
                   ['dist'] ->
1537
1543
                     t_binary();
1538
1544
                   ['dist_ctrl'] ->
1595
1601
                   ['schedulers_online'] ->
1596
1602
                     t_pos_fixnum();
1597
1603
                   ['sequential_tracer'] ->
1598
 
                     t_tuple([t_atom('sequential_tracer'), t_bool()]);
 
1604
                     t_tuple([t_atom('sequential_tracer'), t_boolean()]);
1599
1605
                   ['smp_support'] ->
1600
 
                     t_bool();
 
1606
                     t_boolean();
1601
1607
                   ['system_architecture'] ->
1602
1608
                     t_string();
1603
1609
                   ['system_version'] ->
1604
1610
                     t_string();
1605
1611
                   ['threads'] ->
1606
 
                     t_bool();
 
1612
                     t_boolean();
1607
1613
                   ['thread_pool_size'] ->
1608
1614
                     t_non_neg_fixnum();
1609
1615
                   ['trace_control_word'] ->
1732
1738
type(erts_debug, flat_size, 1, Xs) ->
1733
1739
  strict(arg_types(erts_debug, flat_size, 1), Xs, fun (_) -> t_integer() end);
1734
1740
type(erts_debug, same, 2, Xs) ->
1735
 
  strict(arg_types(erts_debug, same, 2), Xs, fun (_) -> t_bool() end);
 
1741
  strict(arg_types(erts_debug, same, 2), Xs, fun (_) -> t_boolean() end);
1736
1742
%%-- ets ----------------------------------------------------------------------
1737
1743
type(ets, all, 0, _) ->
1738
1744
  t_list(t_tab());
1747
1753
  strict(arg_types(ets, delete_object, 2), Xs, fun (_) -> t_atom('true') end);
1748
1754
type(ets, first, 1, Xs) ->
1749
1755
  strict(arg_types(ets, first, 1), Xs, fun (_) -> t_any() end);
 
1756
type(ets, give_away, 3, Xs) ->
 
1757
  strict(arg_types(ets, give_away, 3), Xs, fun (_) -> t_atom('true') end);
1750
1758
type(ets, info, 1, Xs) ->
1751
1759
  strict(arg_types(ets, info, 1), Xs,
1752
1760
         fun (_) ->
1758
1766
type(ets, insert, 2, Xs) ->
1759
1767
  strict(arg_types(ets, insert, 2), Xs, fun (_) -> t_atom('true') end);
1760
1768
type(ets, insert_new, 2, Xs) ->
1761
 
  strict(arg_types(ets, insert_new, 2), Xs, fun (_) -> t_bool() end);
 
1769
  strict(arg_types(ets, insert_new, 2), Xs, fun (_) -> t_boolean() end);
1762
1770
type(ets, is_compiled_ms, 1, Xs) ->
1763
 
  strict(arg_types(ets, is_compiled_ms, 1), Xs, fun (_) -> t_bool() end);
 
1771
  strict(arg_types(ets, is_compiled_ms, 1), Xs, fun (_) -> t_boolean() end);
1764
1772
type(ets, last, 1, Xs) ->
1765
1773
  type(ets, first, 1, Xs);
1766
1774
type(ets, lookup, 2, Xs) ->
1781
1789
type(ets, match_spec_run_r, 3, Xs) ->
1782
1790
  strict(arg_types(ets, match_spec_run_r, 3), Xs, fun (_) -> t_list() end);
1783
1791
type(ets, member, 2, Xs) ->
1784
 
  strict(arg_types(ets, member, 2), Xs, fun (_) -> t_bool() end);
 
1792
  strict(arg_types(ets, member, 2), Xs, fun (_) -> t_boolean() end);
1785
1793
type(ets, new, 2, Xs) ->
1786
1794
  strict(arg_types(ets, new, 2), Xs, fun (_) -> t_tab() end);
1787
1795
type(ets, next, 2, Xs) ->
1808
1816
type(ets, select_reverse, 1, Xs) -> type(ets, select, 1, Xs);
1809
1817
type(ets, select_reverse, 2, Xs) -> type(ets, select, 2, Xs);
1810
1818
type(ets, select_reverse, 3, Xs) -> type(ets, select, 3, Xs);
 
1819
type(ets, setopts, 2, Xs) ->
 
1820
  strict(arg_types(ets, setopts, 2), Xs, fun (_) -> t_atom('true') end);
1811
1821
type(ets, slot, 2, Xs) ->
1812
1822
  strict(arg_types(ets, slot, 2), Xs,
1813
1823
         fun (_) -> t_sup(t_list(t_tuple()), t_atom('$end_of_table')) end);
1814
1824
type(ets, update_counter, 3, Xs) ->
1815
1825
  strict(arg_types(ets, update_counter, 3), Xs, fun (_) -> t_integer() end);
1816
1826
type(ets, update_element, 3, Xs) ->
1817
 
  strict(arg_types(ets, update_element, 3), Xs, fun (_) -> t_bool() end);
 
1827
  strict(arg_types(ets, update_element, 3), Xs, fun (_) -> t_boolean() end);
1818
1828
%%-- file ---------------------------------------------------------------------
1819
1829
type(file, close, 1, Xs) ->
1820
1830
  strict(arg_types(file, close, 1), Xs, fun (_) -> t_file_return() end);
1934
1944
type(hipe_bifs, bitarray, 2, Xs) ->
1935
1945
  strict(arg_types(hipe_bifs, bitarray, 2), Xs, fun (_) -> t_bitarray() end);
1936
1946
type(hipe_bifs, bitarray_sub, 2, Xs) ->
1937
 
  strict(arg_types(hipe_bifs, bitarray_sub, 2), Xs, fun (_) -> t_bool() end);
 
1947
  strict(arg_types(hipe_bifs, bitarray_sub, 2), Xs, fun (_) -> t_boolean() end);
1938
1948
type(hipe_bifs, bitarray_update, 3, Xs) ->
1939
1949
  strict(arg_types(hipe_bifs, bitarray_update, 3), Xs,
1940
1950
         fun (_) -> t_bitarray() end);
1958
1968
  strict(arg_types(hipe_bifs, call_count_on, 1), Xs,
1959
1969
         fun (_) -> t_sup(t_atom('true'), t_nil()) end);
1960
1970
type(hipe_bifs, check_crc, 1, Xs) ->
1961
 
  strict(arg_types(hipe_bifs, check_crc, 1), Xs, fun (_) -> t_bool() end);
 
1971
  strict(arg_types(hipe_bifs, check_crc, 1), Xs, fun (_) -> t_boolean() end);
1962
1972
type(hipe_bifs, enter_code, 2, Xs) ->
1963
1973
  strict(arg_types(hipe_bifs, enter_code, 2), Xs,
1964
1974
         fun (_) -> t_tuple([t_integer(),
2287
2297
               true -> t_atom('false');
2288
2298
               false ->
2289
2299
                 case t_is_any(X) of
2290
 
                   true -> t_bool();
 
2300
                   true -> t_boolean();
2291
2301
                   false ->
2292
2302
                     case t_tuple_subtypes(Tuple) of
2293
 
                       unknown -> t_bool();
 
2303
                       unknown -> t_boolean();
2294
2304
                       List ->
2295
2305
                         Keys = [type(erlang, element, 2, [Y,S]) || S <- List],
2296
2306
                         Infs = [t_inf(Key, X) || Key <- Keys],
2297
2307
                         case all_is_none(Infs) of
2298
2308
                           true -> t_atom('false');
2299
 
                           false -> t_bool()
 
2309
                           false -> t_boolean()
2300
2310
                         end
2301
2311
                     end
2302
2312
                 end
2403
2413
             Y1 = t_list_elements(Y),
2404
2414
             case t_is_none(t_inf(Y1, X)) of
2405
2415
               true -> t_atom('false');
2406
 
               false -> t_bool()
 
2416
               false -> t_boolean()
2407
2417
             end
2408
2418
         end);
2409
2419
%% type(lists, merge, 1, Xs) ->
2467
2477
  strict(arg_types(lists, sort, 2), Xs,
2468
2478
         fun ([F, L]) ->
2469
2479
             R = t_fun_range(F),
2470
 
             case t_is_bool(R) of
 
2480
             case t_is_boolean(R) of
2471
2481
               true -> L;
2472
2482
               false ->
2473
2483
                 case t_is_nil(L) of
2612
2622
%%-- net_kernel ---------------------------------------------------------------
2613
2623
type(net_kernel, dflag_unicode_io, 1, Xs) ->
2614
2624
  strict(arg_types(net_kernel, dflag_unicode_io, 1), Xs, 
2615
 
         fun (_) -> t_bool() end); 
 
2625
         fun (_) -> t_boolean() end); 
2616
2626
%%-- ordsets ------------------------------------------------------------------
2617
2627
type(ordsets, filter, 2, Xs) ->
2618
2628
  type(lists, filter, 2, Xs);
2675
2685
type(string, concat, 2, Xs) -> % NOTE: added to avoid loss of information
2676
2686
  strict(arg_types(string, concat, 2), Xs, fun (_) -> t_string() end);
2677
2687
type(string, equal, 2, Xs) ->  % NOTE: added to avoid loss of information
2678
 
  strict(arg_types(string, equal, 2), Xs, fun (_) -> t_bool() end);
 
2688
  strict(arg_types(string, equal, 2), Xs, fun (_) -> t_boolean() end);
2679
2689
type(string, to_float, 1, Xs) ->
2680
2690
  strict(arg_types(string, to_float, 1), Xs,
2681
2691
         fun (_) -> t_sup(t_tuple([t_float(), t_string()]),
2706
2716
                    t_tuple([t_atom('incomplete'), t_string(), t_ML()])])
2707
2717
         end);
2708
2718
type(unicode, bin_is_7bit, 1, Xs) ->
2709
 
  strict(arg_types(unicode, bin_is_7bit, 1), Xs, fun (_) -> t_bool() end);
 
2719
  strict(arg_types(unicode, bin_is_7bit, 1), Xs, fun (_) -> t_boolean() end);
2710
2720
 
2711
2721
%%-----------------------------------------------------------------------------
2712
2722
type(M, F, A, Xs) when is_atom(M), is_atom(F),
2780
2790
        false ->
2781
2791
          case t_is_none(t_inf(Type, X)) of
2782
2792
            true -> t_atom('false');
2783
 
            false -> t_bool()
 
2793
            false -> t_boolean()
2784
2794
          end
2785
2795
      end
2786
2796
  end.
3278
3288
arg_types(erlang, 'rem', 2) ->
3279
3289
  [t_integer(), t_integer()];
3280
3290
arg_types(erlang, 'and', 2) ->
3281
 
  [t_bool(), t_bool()];
 
3291
  [t_boolean(), t_boolean()];
3282
3292
arg_types(erlang, 'or', 2) ->
3283
 
  [t_bool(), t_bool()];
 
3293
  [t_boolean(), t_boolean()];
3284
3294
arg_types(erlang, 'xor', 2) ->
3285
 
  [t_bool(), t_bool()];
 
3295
  [t_boolean(), t_boolean()];
3286
3296
arg_types(erlang, 'not', 1) ->
3287
 
  [t_bool()];
 
3297
  [t_boolean()];
3288
3298
arg_types(erlang, 'band', 2) ->
3289
3299
  [t_integer(), t_integer()];
3290
3300
arg_types(erlang, 'bor', 2) ->
3501
3511
  [t_tuple([t_date(), t_time()])];
3502
3512
arg_types(erlang, localtime_to_universaltime, 2) ->
3503
3513
  arg_types(erlang, localtime_to_universaltime, 1) ++
3504
 
    [t_sup(t_bool(), t_atom('undefined'))];
 
3514
    [t_sup(t_boolean(), t_atom('undefined'))];
3505
3515
arg_types(erlang, make_fun, 3) ->
3506
3516
  [t_atom(), t_atom(), t_arity()];
3507
3517
arg_types(erlang, make_ref, 0) ->
3508
3518
  [];
3509
3519
arg_types(erlang, make_tuple, 2) ->
3510
3520
  [t_non_neg_fixnum(), t_any()];  % the value 0 is OK as first argument
 
3521
arg_types(erlang, make_tuple, 3) ->
 
3522
  [t_non_neg_fixnum(), t_any(), t_list(t_tuple([t_pos_integer(), t_any()]))];
3511
3523
arg_types(erlang, match_spec_test, 3) ->
3512
3524
  [t_sup(t_list(), t_tuple()),
3513
3525
   t_any(),
3525
3537
arg_types(erlang, monitor, 2) ->
3526
3538
  [t_atom(), t_sup([t_pid(), t_atom(), t_tuple([t_atom(), t_node()])])];
3527
3539
arg_types(erlang, monitor_node, 2) ->
3528
 
  [t_node(), t_bool()];
 
3540
  [t_node(), t_boolean()];
3529
3541
arg_types(erlang, monitor_node, 3) ->
3530
 
  [t_node(), t_bool(), t_list(t_atom('allow_passive_connect'))];
 
3542
  [t_node(), t_boolean(), t_list(t_atom('allow_passive_connect'))];
3531
3543
arg_types(erlang, node, 0) ->
3532
3544
  [];
3533
3545
arg_types(erlang, node, 1) ->
3596
3608
          t_atom('min_heap_size'), t_atom('priority'), t_atom('save_calls'),
3597
3609
          t_atom('monitor_nodes'),                        % undocumented
3598
3610
          t_tuple([t_atom('monitor_nodes'), t_list()])]), % undocumented
3599
 
   t_sup([t_bool(), t_atom(), t_non_neg_integer()])];
 
3611
   t_sup([t_boolean(), t_atom(), t_non_neg_integer()])];
3600
3612
arg_types(erlang, process_flag, 3) ->
3601
3613
  [t_pid(), t_atom('save_calls'), t_non_neg_integer()];
3602
3614
arg_types(erlang, process_info, 1) ->
3632
3644
arg_types(erlang, send_after, 3) ->
3633
3645
  [t_non_neg_integer(), t_sup(t_pid(), t_atom()), t_any()];
3634
3646
arg_types(erlang, seq_trace, 2) ->
3635
 
  [t_atom(), t_sup([t_bool(), t_tuple([t_fixnum(), t_fixnum()]), t_nil()])];
 
3647
  [t_atom(), t_sup([t_boolean(), t_tuple([t_fixnum(), t_fixnum()]), t_nil()])];
3636
3648
arg_types(erlang, seq_trace_info, 1) ->
3637
3649
  [t_seq_trace_info()];
3638
3650
arg_types(erlang, seq_trace_print, 1) ->
3734
3746
  [t_any()];
3735
3747
arg_types(erlang, term_to_binary, 2) ->
3736
3748
  [t_any(), t_list(t_sup([t_atom('compressed'),
3737
 
                          t_tuple([t_atom('minor_version'), t_integer()])]))];
 
3749
                          t_tuple([t_atom('compressed'), t_from_range(0, 9)]),
 
3750
                          t_tuple([t_atom('minor_version'), t_integers([0, 1])])]))];
3738
3751
arg_types(erlang, throw, 1) ->
3739
3752
  [t_any()];
3740
3753
arg_types(erlang, time, 0) ->
3743
3756
  [t_cons()];
3744
3757
arg_types(erlang, trace, 3) ->
3745
3758
  [t_sup(t_pid(), t_sup([t_atom('existing'), t_atom('new'), t_atom('all')])),
3746
 
   t_bool(),
 
3759
   t_boolean(),
3747
3760
   t_list(t_sup(t_atom(), t_tuple(2)))];
3748
3761
arg_types(erlang, trace_delivered, 1) ->
3749
3762
  [t_sup(t_pid(), t_atom('all'))];
3760
3773
arg_types(erlang, trace_pattern, 2) ->
3761
3774
  [t_sup(t_tuple([t_atom(), t_atom(), t_sup(t_arity(), t_atom('_'))]),
3762
3775
         t_atom('on_load')),
3763
 
   t_sup([t_bool(), t_list(), t_atom('restart'), t_atom('pause')])];
 
3776
   t_sup([t_boolean(), t_list(), t_atom('restart'), t_atom('pause')])];
3764
3777
arg_types(erlang, trace_pattern, 3) ->
3765
3778
  arg_types(erlang, trace_pattern, 2) ++
3766
3779
    [t_list(t_sup([t_atom('global'), t_atom('local'),
3796
3809
  [];
3797
3810
%%------- erts_debug ----------------------------------------------------------
3798
3811
arg_types(erts_debug, breakpoint, 2) ->
3799
 
  [t_tuple([t_atom(), t_atom(), t_sup(t_integer(), t_atom('_'))]), t_bool()];
 
3812
  [t_tuple([t_atom(), t_atom(), t_sup(t_integer(), t_atom('_'))]), t_boolean()];
3800
3813
arg_types(erts_debug, disassemble, 1) ->
3801
3814
  [t_sup(t_mfa(), t_integer())];
3802
3815
arg_types(erts_debug, flat_size, 1) ->
3816
3829
  [t_tab(), t_tuple()];
3817
3830
arg_types(ets, first, 1) ->
3818
3831
  [t_tab()];
 
3832
arg_types(ets, give_away, 3) ->
 
3833
  [t_tab(), t_pid(), t_any()];
3819
3834
arg_types(ets, info, 1) ->
3820
3835
  [t_tab()];
3821
3836
arg_types(ets, info, 2) ->
3859
3874
arg_types(ets, rename, 2) ->
3860
3875
  [t_atom(), t_atom()];
3861
3876
arg_types(ets, safe_fixtable, 2) ->
3862
 
  [t_tab(), t_bool()];
 
3877
  [t_tab(), t_boolean()];
3863
3878
arg_types(ets, select, 1) ->
3864
3879
  [t_any()];
3865
3880
arg_types(ets, select, 2) ->
3878
3893
  arg_types(ets, select, 3);
3879
3894
arg_types(ets, slot, 2) ->
3880
3895
  [t_tab(), t_non_neg_fixnum()]; % 2nd arg can be 0
 
3896
arg_types(ets, setopts, 2) ->
 
3897
  Opt = t_sup(t_tuple([t_atom('heir'), t_pid(), t_any()]),
 
3898
              t_tuple([t_atom('heir'), t_atom('none')])),
 
3899
  [t_tab(), t_sup(Opt, t_list(Opt))];
3881
3900
arg_types(ets, update_counter, 3) ->
3882
3901
  [t_tab(), t_any(), t_sup(t_integer(),
3883
3902
                           t_sup(t_tuple([t_integer(), t_integer()]),
3957
3976
arg_types(hipe_bifs, bif_address, 3) ->
3958
3977
  [t_atom(), t_atom(), t_arity()];
3959
3978
arg_types(hipe_bifs, bitarray, 2) ->
3960
 
  [t_non_neg_fixnum(), t_bool()];
 
3979
  [t_non_neg_fixnum(), t_boolean()];
3961
3980
arg_types(hipe_bifs, bitarray_sub, 2) ->
3962
3981
  [t_bitarray(), t_non_neg_fixnum()];
3963
3982
arg_types(hipe_bifs, bitarray_update, 3) ->
3964
 
  [t_bytearray(), t_non_neg_fixnum(), t_bool()];
 
3983
  [t_bytearray(), t_non_neg_fixnum(), t_boolean()];
3965
3984
arg_types(hipe_bifs, bytearray, 2) ->
3966
3985
  [t_non_neg_fixnum(), t_byte()];
3967
3986
arg_types(hipe_bifs, bytearray_sub, 2) ->
3983
4002
arg_types(hipe_bifs, enter_sdesc, 1) ->
3984
4003
  [t_tuple([t_integer(), t_integer(), t_integer(), t_integer(), t_integer()])];
3985
4004
arg_types(hipe_bifs, find_na_or_make_stub, 2) ->
3986
 
  [t_mfa(), t_bool()];
 
4005
  [t_mfa(), t_boolean()];
3987
4006
arg_types(hipe_bifs, fun_to_address, 1) ->
3988
4007
  [t_mfa()];
3989
4008
%% arg_types(hipe_bifs, get_emu_address, 1) ->
4019
4038
arg_types(hipe_bifs, set_funinfo_native_address, 3) ->
4020
4039
  arg_types(hipe_bifs, set_native_address, 3);
4021
4040
arg_types(hipe_bifs, set_native_address, 3) ->
4022
 
  [t_mfa(), t_integer(), t_bool()];
 
4041
  [t_mfa(), t_integer(), t_boolean()];
4023
4042
arg_types(hipe_bifs, system_crc, 1) ->
4024
4043
  [t_integer()];
4025
4044
arg_types(hipe_bifs, term_to_word, 1) ->
4056
4075
  arg_types(io_lib, format, 2);
4057
4076
%%------- lists ---------------------------------------------------------------
4058
4077
arg_types(lists, all, 2) ->
4059
 
  [t_fun([t_any()], t_bool()), t_list()];
 
4078
  [t_fun([t_any()], t_boolean()), t_list()];
4060
4079
arg_types(lists, any, 2) ->
4061
 
  [t_fun([t_any()], t_bool()), t_list()];
 
4080
  [t_fun([t_any()], t_boolean()), t_list()];
4062
4081
arg_types(lists, append, 2) -> 
4063
4082
  arg_types(erlang, '++', 2);  % alias
4064
4083
arg_types(lists, delete, 2) ->
4065
4084
  [t_any(), t_maybe_improper_list()];
4066
4085
arg_types(lists, dropwhile, 2) ->
4067
 
  [t_fun([t_any()], t_bool()), t_maybe_improper_list()];
 
4086
  [t_fun([t_any()], t_boolean()), t_maybe_improper_list()];
4068
4087
arg_types(lists, filter, 2) ->
4069
 
  [t_fun([t_any()], t_bool()), t_list()];
 
4088
  [t_fun([t_any()], t_boolean()), t_list()];
4070
4089
arg_types(lists, flatten, 1) ->
4071
4090
  [t_list()];
4072
4091
arg_types(lists, flatmap, 2) ->
4110
4129
arg_types(lists, merge, 2) ->
4111
4130
  [t_list(), t_list()];
4112
4131
%% arg_types(lists, merge, 3) ->
4113
 
%%   [t_fun([t_any(), t_any()], t_bool()), t_list(), t_list()];
 
4132
%%   [t_fun([t_any(), t_any()], t_boolean()), t_list(), t_list()];
4114
4133
%% arg_types(lists, merge3, 3) ->
4115
4134
%%   [t_list(), t_list(), t_list()];
4116
4135
arg_types(lists, min, 1) ->
4132
4151
arg_types(lists, sort, 1) ->
4133
4152
  [t_list()];
4134
4153
arg_types(lists, sort, 2) ->
4135
 
  [t_fun([t_any(), t_any()], t_bool()), t_list()];
 
4154
  [t_fun([t_any(), t_any()], t_boolean()), t_list()];
4136
4155
arg_types(lists, split, 2) ->
4137
4156
  [t_non_neg_fixnum(), t_maybe_improper_list()]; % do not lie in 2nd arg
4138
4157
arg_types(lists, splitwith, 2) ->
4139
 
  [t_fun([t_any()], t_bool()), t_maybe_improper_list()];
 
4158
  [t_fun([t_any()], t_boolean()), t_maybe_improper_list()];
4140
4159
arg_types(lists, subtract, 2) ->
4141
4160
  arg_types(erlang, '--', 2);  % alias
4142
4161
arg_types(lists, takewhile, 2) ->
4143
 
  [t_fun([t_any()], t_bool()), t_maybe_improper_list()];
 
4162
  [t_fun([t_any()], t_boolean()), t_maybe_improper_list()];
4144
4163
arg_types(lists, usort, 1) ->
4145
4164
  arg_types(lists, sort, 1);   % same
4146
4165
arg_types(lists, usort, 2) ->
4562
4581
 
4563
4582
%% From the 'ets' documentation
4564
4583
%%-----------------------------
4565
 
%% Option = Type | Access | named_table | {keypos,Pos}
4566
 
%%   Type = set | ordered_set | bag | duplicate_bag
4567
 
%% Access = public | protected | private
4568
 
%%    Pos = integer()
 
4584
%%   Option = Type | Access | named_table | {keypos,Pos}
 
4585
%%          | {heir,pid(),HeirData} | {heir,none} | {write_concurrency,bool()}
 
4586
%%     Type = set | ordered_set | bag | duplicate_bag
 
4587
%%   Access = public | protected | private
 
4588
%%      Pos = integer()
 
4589
%% HeirData = term()
4569
4590
t_ets_new_options() ->
4570
4591
  t_list(t_sup([t_atom('set'),
4571
4592
                t_atom('ordered_set'),
4575
4596
                t_atom('protected'),
4576
4597
                t_atom('private'),
4577
4598
                t_atom('named_table'),
4578
 
                t_tuple([t_atom('keypos'), t_integer()])])).
 
4599
                t_tuple([t_atom('heir'), t_pid(), t_any()]),
 
4600
                t_tuple([t_atom('heir'), t_atom('none')]),
 
4601
                t_tuple([t_atom('keypos'), t_integer()]),
 
4602
                t_tuple([t_atom('write_concurrency'), t_boolean()])])).
4579
4603
 
4580
4604
t_ets_info_items() ->
4581
4605
  t_sup([t_atom('fixed'),
4753
4777
 
4754
4778
t_inet_setoption() ->
4755
4779
  t_sup([%% first the 2-tuple options
4756
 
         t_tuple([t_atom('active'), t_sup(t_bool(), t_atom('once'))]),
4757
 
         t_tuple([t_atom('broadcast'), t_bool()]),
4758
 
         t_tuple([t_atom('delay_send'), t_bool()]),
4759
 
         t_tuple([t_atom('dontroute'), t_bool()]),
4760
 
         t_tuple([t_atom('exit_on_close'), t_bool()]),
 
4780
         t_tuple([t_atom('active'), t_sup(t_boolean(), t_atom('once'))]),
 
4781
         t_tuple([t_atom('broadcast'), t_boolean()]),
 
4782
         t_tuple([t_atom('delay_send'), t_boolean()]),
 
4783
         t_tuple([t_atom('dontroute'), t_boolean()]),
 
4784
         t_tuple([t_atom('exit_on_close'), t_boolean()]),
4761
4785
         t_tuple([t_atom('header'), t_non_neg_integer()]),
4762
 
         t_tuple([t_atom('keepalive'), t_bool()]),
4763
 
         t_tuple([t_atom('nodelay'), t_bool()]),
 
4786
         t_tuple([t_atom('keepalive'), t_boolean()]),
 
4787
         t_tuple([t_atom('nodelay'), t_boolean()]),
4764
4788
         t_tuple([t_atom('packet'), t_inet_setoption_packettype()]),
4765
4789
         t_tuple([t_atom('packet_size'), t_non_neg_integer()]),
4766
4790
         t_tuple([t_atom('read_packets'), t_non_neg_integer()]),
4767
4791
         t_tuple([t_atom('recbuf'), t_non_neg_integer()]),
4768
 
         t_tuple([t_atom('reuseaddr'), t_bool()]),
 
4792
         t_tuple([t_atom('reuseaddr'), t_boolean()]),
4769
4793
         t_tuple([t_atom('send_timeout'), t_non_neg_integer()]),
4770
4794
         t_tuple([t_atom('sndbuf'), t_non_neg_integer()]),
4771
4795
         t_tuple([t_atom('priority'), t_non_neg_integer()]),