%% -*- erlang-indent-level: 2 -*- %% %% %CopyrightBegin% %% %% Copyright Ericsson AB 2003-2012. All Rights Reserved. %% %% The contents of this file are subject to the Erlang Public License, %% Version 1.1, (the "License"); you may not use this file except in %% compliance with the License. You should have received a copy of the %% Erlang Public License along with this software. If not, it can be %% retrieved online at http://www.erlang.org/. %% %% Software distributed under the License is distributed on an "AS IS" %% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See %% the License for the specific language governing rights and limitations %% under the License. %% %% %CopyrightEnd% %% %% ===================================================================== %% Type information for Erlang Built-in functions (implemented in C) %% %% Copyright (C) 2002 Richard Carlsson %% Copyright (C) 2006 Richard Carlsson, Tobias Lindahl and Kostis Sagonas %% %% Author contact: richardc@it.uu.se, tobiasl@it.uu.se, kostis@it.uu.se %% ===================================================================== -module(erl_bif_types). %-define(BITS, (hipe_rtl_arch:word_size() * 8) - ?TAG_IMMED1_SIZE). -define(BITS, 128). %This is only in bsl to convert answer to pos_inf/neg_inf. -define(TAG_IMMED1_SIZE, 4). -export([type/3, type/4, arg_types/3, is_known/3, structure_inspecting_args/3, infinity_add/2]). -import(erl_types, [number_max/1, number_min/1, t_any/0, t_arity/0, t_atom/0, t_atom/1, t_atoms/1, t_atom_vals/1, t_binary/0, t_bitstr/0, t_boolean/0, t_byte/0, t_char/0, t_cons/0, t_cons/2, t_cons_hd/1, t_cons_tl/1, t_fixnum/0, t_non_neg_fixnum/0, t_pos_fixnum/0, t_float/0, t_from_range/2, t_from_term/1, t_fun/0, t_fun/2, t_fun_args/1, t_fun_range/1, t_identifier/0, t_inf/2, t_integer/0, t_integer/1, t_non_neg_fixnum/0, t_non_neg_integer/0, t_pos_integer/0, t_integers/1, t_is_any/1, t_is_atom/1, t_is_binary/1, t_is_bitstr/1, t_is_boolean/1, t_is_cons/1, t_is_float/1, t_is_float/1, t_is_fun/1, t_is_integer/1, t_is_integer/1, t_is_nil/1, t_is_none/1, t_is_none_or_unit/1, t_is_number/1, t_is_pid/1, t_is_port/1, t_is_maybe_improper_list/1, t_is_reference/1, t_is_string/1, t_is_subtype/2, t_is_tuple/1, t_list/0, t_list/1, t_list_elements/1, t_list_termination/1, t_mfa/0, t_module/0, t_nil/0, t_node/0, t_none/0, t_nonempty_list/0, t_nonempty_list/1, t_number/0, t_number_vals/1, t_pid/0, t_port/0, t_maybe_improper_list/0, t_reference/0, t_string/0, t_subtract/2, t_sup/1, t_sup/2, t_tuple/0, t_tuple/1, t_tuple_args/1, t_tuple_size/1, t_tuple_subtypes/1 ]). -ifdef(DO_ERL_BIF_TYPES_TEST). -export([test/0]). -endif. %%============================================================================= -spec type(atom(), atom(), arity()) -> erl_types:erl_type(). type(M, F, A) -> type(M, F, A, any_list(A)). %% Arguments should be checked for undefinedness, so we do not make %% unnecessary overapproximations. -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(); type(erlang, error, 1, _) -> t_none(); type(erlang, error, 2, _) -> t_none(); type(erlang, throw, 1, _) -> t_none(); type(erlang, '==', 2, Xs = [X1, X2]) -> case t_is_atom(X1) andalso t_is_atom(X2) of true -> type(erlang, '=:=', 2, Xs); false -> case t_is_integer(X1) andalso t_is_integer(X2) of true -> type(erlang, '=:=', 2, Xs); false -> strict(Xs, t_boolean()) end end; type(erlang, '/=', 2, Xs = [X1, X2]) -> case t_is_atom(X1) andalso t_is_atom(X2) of true -> type(erlang, '=/=', 2, Xs); false -> case t_is_integer(X1) andalso t_is_integer(X2) of true -> type(erlang, '=/=', 2, Xs); false -> strict(Xs, t_boolean()) end end; type(erlang, '=:=', 2, Xs = [Lhs, Rhs]) -> Ans = case t_is_none(t_inf(Lhs, Rhs)) of true -> t_atom('false'); false -> case t_is_atom(Lhs) andalso t_is_atom(Rhs) of true -> case {t_atom_vals(Lhs), t_atom_vals(Rhs)} of {unknown, _} -> t_boolean(); {_, unknown} -> t_boolean(); {[X], [X]} -> t_atom('true'); {LhsVals, RhsVals} -> case lists:all(fun({X, Y}) -> X =/= Y end, [{X, Y} || X <- LhsVals, Y <- RhsVals]) of true -> t_atom('false'); false -> t_boolean() end end; false -> case t_is_integer(Lhs) andalso t_is_integer(Rhs) of false -> t_boolean(); true -> case {t_number_vals(Lhs), t_number_vals(Rhs)} of {[X], [X]} when is_integer(X) -> t_atom('true'); _ -> LhsMax = number_max(Lhs), LhsMin = number_min(Lhs), RhsMax = number_max(Rhs), RhsMin = number_min(Rhs), Ans1 = (is_integer(LhsMin) andalso is_integer(RhsMax) andalso (LhsMin > RhsMax)), Ans2 = (is_integer(LhsMax) andalso is_integer(RhsMin) andalso (RhsMin > LhsMax)), case Ans1 orelse Ans2 of true -> t_atom('false'); false -> t_boolean() end end end end end, strict(Xs, Ans); type(erlang, '=/=', 2, Xs = [Lhs, Rhs]) -> Ans = case t_is_none(t_inf(Lhs, Rhs)) of true -> t_atom('true'); false -> case t_is_atom(Lhs) andalso t_is_atom(Rhs) of true -> case {t_atom_vals(Lhs), t_atom_vals(Rhs)} of {unknown, _} -> t_boolean(); {_, unknown} -> t_boolean(); {[Val], [Val]} -> t_atom('false'); {LhsVals, RhsVals} -> t_sup([t_from_term(X =/= Y) || X <- LhsVals, Y <- RhsVals]) end; false -> case t_is_integer(Lhs) andalso t_is_integer(Rhs) of false -> t_boolean(); true -> LhsMax = number_max(Lhs), LhsMin = number_min(Lhs), RhsMax = number_max(Rhs), RhsMin = number_min(Rhs), Ans1 = (is_integer(LhsMin) andalso is_integer(RhsMax) andalso (LhsMin > RhsMax)), Ans2 = (is_integer(LhsMax) andalso is_integer(RhsMin) andalso (RhsMin > LhsMax)), case Ans1 orelse Ans2 of true -> t_atom('true'); false -> if LhsMax =:= LhsMin, RhsMin =:= RhsMax, RhsMax =:= LhsMax -> t_atom('false'); true -> t_boolean() end end end end end, strict(Xs, Ans); type(erlang, '>', 2, Xs = [Lhs, Rhs]) -> Ans = case t_is_integer(Lhs) andalso t_is_integer(Rhs) of true -> LhsMax = number_max(Lhs), LhsMin = number_min(Lhs), RhsMax = number_max(Rhs), RhsMin = number_min(Rhs), T = t_atom('true'), F = t_atom('false'), if is_integer(LhsMin), is_integer(RhsMax), LhsMin > RhsMax -> T; is_integer(LhsMax), is_integer(RhsMin), RhsMin >= LhsMax -> F; true -> t_boolean() end; false -> compare('>', Lhs, Rhs) end, strict(Xs, Ans); type(erlang, '>=', 2, Xs = [Lhs, Rhs]) -> Ans = case t_is_integer(Lhs) andalso t_is_integer(Rhs) of true -> LhsMax = number_max(Lhs), LhsMin = number_min(Lhs), RhsMax = number_max(Rhs), RhsMin = number_min(Rhs), T = t_atom('true'), F = t_atom('false'), if is_integer(LhsMin), is_integer(RhsMax), LhsMin >= RhsMax -> T; is_integer(LhsMax), is_integer(RhsMin), RhsMin > LhsMax -> F; true -> t_boolean() end; false -> compare('>=', Lhs, Rhs) end, strict(Xs, Ans); type(erlang, '<', 2, Xs = [Lhs, Rhs]) -> Ans = case t_is_integer(Lhs) andalso t_is_integer(Rhs) of true -> LhsMax = number_max(Lhs), LhsMin = number_min(Lhs), RhsMax = number_max(Rhs), RhsMin = number_min(Rhs), T = t_atom('true'), F = t_atom('false'), if is_integer(LhsMax), is_integer(RhsMin), LhsMax < RhsMin -> T; is_integer(LhsMin), is_integer(RhsMax), RhsMax =< LhsMin -> F; true -> t_boolean() end; false -> compare('<', Lhs, Rhs) end, strict(Xs, Ans); type(erlang, '=<', 2, Xs = [Lhs, Rhs]) -> Ans = case t_is_integer(Lhs) andalso t_is_integer(Rhs) of true -> LhsMax = number_max(Lhs), LhsMin = number_min(Lhs), RhsMax = number_max(Rhs), RhsMin = number_min(Rhs), T = t_atom('true'), F = t_atom('false'), if is_integer(LhsMax), is_integer(RhsMin), LhsMax =< RhsMin -> T; is_integer(LhsMin), is_integer(RhsMax), RhsMax < LhsMin -> F; true -> t_boolean() end; false -> compare('=<', Lhs, Rhs) end, strict(Xs, Ans); type(erlang, '+', 1, Xs) -> strict(arg_types(erlang, '+', 1), Xs, fun ([X]) -> X end); type(erlang, '-', 1, Xs) -> strict(arg_types(erlang, '-', 1), Xs, fun ([X]) -> case t_is_integer(X) of true -> type(erlang, '-', 2, [t_integer(0), X]); false -> X end end); type(erlang, '!', 2, Xs) -> strict(arg_types(erlang, '!', 2), Xs, fun ([_, X2]) -> X2 end); type(erlang, '+', 2, Xs) -> strict(arg_types(erlang, '+', 2), Xs, fun ([X1, X2]) -> case arith('+', X1, X2) of {ok, T} -> T; error -> case t_is_float(X1) orelse t_is_float(X2) of true -> t_float(); false -> t_number() end end end); type(erlang, '-', 2, Xs) -> strict(arg_types(erlang, '-', 2), Xs, fun ([X1, X2]) -> case arith('-', X1, X2) of {ok, T} -> T; error -> case t_is_float(X1) orelse t_is_float(X2) of true -> t_float(); false -> t_number() end end end); type(erlang, '*', 2, Xs) -> strict(arg_types(erlang, '*', 2), Xs, fun ([X1, X2]) -> case arith('*', X1, X2) of {ok, T} -> T; error -> case t_is_float(X1) orelse t_is_float(X2) of true -> t_float(); false -> t_number() end end end); type(erlang, '/', 2, Xs) -> strict(arg_types(erlang, '/', 2), Xs, fun (_) -> t_float() end); type(erlang, 'div', 2, Xs) -> strict(arg_types(erlang, 'div', 2), Xs, fun ([X1, X2]) -> case arith('div', X1, X2) of error -> t_integer(); {ok, T} -> T end end); type(erlang, 'rem', 2, Xs) -> strict(arg_types(erlang, 'rem', 2), Xs, fun ([X1, X2]) -> case arith('rem', X1, X2) of error -> t_non_neg_integer(); {ok, T} -> T end end); type(erlang, '++', 2, Xs) -> strict(arg_types(erlang, '++', 2), Xs, fun ([X1, X2]) -> case t_is_nil(X1) of true -> X2; % even if X2 is not a list false -> case t_is_nil(X2) of true -> X1; false -> E1 = t_list_elements(X1), case t_is_cons(X1) of true -> t_cons(E1, X2); false -> t_sup(X2, t_cons(E1, X2)) end end end end); type(erlang, '--', 2, Xs) -> %% We don't know which elements (if any) in X2 will be found and %% removed from X1, even if they would have the same type. Thus, we %% must assume that X1 can remain unchanged. However, if we succeed, %% we know that X1 must be a proper list, but the result could %% possibly be empty even if X1 is nonempty. strict(arg_types(erlang, '--', 2), Xs, fun ([X1, X2]) -> case t_is_nil(X1) of true -> t_nil(); false -> case t_is_nil(X2) of true -> X1; false -> t_list(t_list_elements(X1)) end end end); type(erlang, 'and', 2, Xs) -> strict(arg_types(erlang, 'and', 2), Xs, fun (_) -> t_boolean() end); type(erlang, 'or', 2, Xs) -> strict(arg_types(erlang, 'or', 2), Xs, fun (_) -> t_boolean() end); type(erlang, 'xor', 2, Xs) -> strict(arg_types(erlang, 'xor', 2), Xs, fun (_) -> t_boolean() end); type(erlang, 'not', 1, Xs) -> strict(arg_types(erlang, 'not', 1), Xs, fun (_) -> t_boolean() end); type(erlang, 'band', 2, Xs) -> strict(arg_types(erlang, 'band', 2), Xs, fun ([X1, X2]) -> case arith('band', X1, X2) of error -> t_integer(); {ok, T} -> T end end); %% The result is not wider than the smallest argument. We need to %% kill any value-sets in the result. %% strict(arg_types(erlang, 'band', 2), Xs, %% fun ([X1, X2]) -> t_sup(t_inf(X1, X2), t_byte()) end); type(erlang, 'bor', 2, Xs) -> strict(arg_types(erlang, 'bor', 2), Xs, fun ([X1, X2]) -> case arith('bor', X1, X2) of error -> t_integer(); {ok, T} -> T end end); %% The result is not wider than the largest argument. We need to %% kill any value-sets in the result. %% strict(arg_types(erlang, 'bor', 2), Xs, %% fun ([X1, X2]) -> t_sup(t_sup(X1, X2), t_byte()) end); type(erlang, 'bxor', 2, Xs) -> strict(arg_types(erlang, 'bxor', 2), Xs, fun ([X1, X2]) -> case arith('bxor', X1, X2) of error -> t_integer(); {ok, T} -> T end end); %% The result is not wider than the largest argument. We need to %% kill any value-sets in the result. %% strict(arg_types(erlang, 'bxor', 2), Xs, %% fun ([X1, X2]) -> t_sup(t_sup(X1, X2), t_byte()) end); type(erlang, 'bsr', 2, Xs) -> strict(arg_types(erlang, 'bsr', 2), Xs, fun ([X1, X2]) -> case arith('bsr', X1, X2) of error -> t_integer(); {ok, T} -> T end end); %% If the first argument is unsigned (which is the case for %% characters and bytes), the result is never wider. We need to kill %% any value-sets in the result. %% strict(arg_types(erlang, 'bsr', 2), Xs, %% fun ([X, _]) -> t_sup(X, t_byte()) end); type(erlang, 'bsl', 2, Xs) -> strict(arg_types(erlang, 'bsl', 2), Xs, fun ([X1, X2]) -> case arith('bsl', X1, X2) of error -> t_integer(); {ok, T} -> T end end); %% Not worth doing anything special here. %% strict(arg_types(erlang, 'bsl', 2), Xs, fun (_) -> t_integer() end); type(erlang, 'bnot', 1, Xs) -> strict(arg_types(erlang, 'bnot', 1), Xs, fun ([X1]) -> case arith('bnot', X1) of error -> t_integer(); {ok, T} -> T end end); %% Guard bif, needs to be here. type(erlang, abs, 1, Xs) -> strict(arg_types(erlang, abs, 1), Xs, fun ([X]) -> X 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, append, 2, Xs) -> type(erlang, '++', 2, Xs); % alias type(erlang, apply, 2, Xs) -> Fun = fun ([X, _Y]) -> case t_is_fun(X) of true -> t_fun_range(X); false -> t_any() end end, strict(arg_types(erlang, apply, 2), Xs, Fun); type(erlang, apply, 3, Xs) -> strict(arg_types(erlang, apply, 3), Xs, fun (_) -> t_any() end); %% Guard bif, needs to be here. type(erlang, binary_part, 2, Xs) -> strict(arg_types(erlang, binary_part, 2), Xs, fun (_) -> t_binary() end); %% Guard bif, needs to be here. type(erlang, binary_part, 3, Xs) -> strict(arg_types(erlang, binary_part, 3), Xs, fun (_) -> t_binary() end); %% Guard bif, needs to be here. type(erlang, bit_size, 1, Xs) -> strict(arg_types(erlang, bit_size, 1), Xs, fun (_) -> t_non_neg_integer() end); %% Guard bif, needs to be here. type(erlang, byte_size, 1, Xs) -> strict(arg_types(erlang, byte_size, 1), Xs, fun (_) -> t_non_neg_integer() end); type(erlang, disconnect_node, 1, Xs) -> strict(arg_types(erlang, disconnect_node, 1), Xs, fun (_) -> t_sup([t_boolean(), t_atom('ignored')]) end); %% Guard bif, needs to be here. %% Also much more expressive than anything you could write in a spec... type(erlang, element, 2, Xs) -> strict(arg_types(erlang, element, 2), Xs, fun ([X1, X2]) -> case t_tuple_subtypes(X2) of unknown -> t_any(); [_] -> Sz = t_tuple_size(X2), As = t_tuple_args(X2), case t_number_vals(X1) of unknown -> t_sup(As); Ns when is_list(Ns) -> Fun = fun (N, X) when is_integer(N), 1 =< N, N =< Sz -> t_sup(X, lists:nth(N, As)); (_, X) -> X end, lists:foldl(Fun, t_none(), Ns) end; Ts when is_list(Ts) -> t_sup([type(erlang, element, 2, [X1, Y]) || Y <- Ts]) end end); %% Guard bif, needs to be here. type(erlang, float, 1, Xs) -> strict(arg_types(erlang, float, 1), Xs, fun (_) -> t_float() 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, get_cookie, 0, _) -> t_atom(); % | t_atom('nocookie') %% Guard bif, needs to be here. type(erlang, hd, 1, Xs) -> strict(arg_types(erlang, hd, 1), Xs, fun ([X]) -> t_cons_hd(X) 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 %% All type tests are guard BIF's and may be implemented in ways that %% cannot be expressed in a type spec, why they are kept in erl_bif_types. 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); type(erlang, is_binary, 1, Xs) -> Fun = fun (X) -> 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_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_float, 1, Xs) -> Fun = fun (X) -> check_guard(X, fun (Y) -> t_is_float(Y) end, t_float()) end, strict(arg_types(erlang, is_float, 1), Xs, Fun); type(erlang, is_function, 1, Xs) -> Fun = fun (X) -> check_guard(X, fun (Y) -> t_is_fun(Y) end, t_fun()) end, strict(arg_types(erlang, is_function, 1), Xs, Fun); type(erlang, is_function, 2, Xs) -> Fun = fun ([FunType, ArityType]) -> case t_number_vals(ArityType) of unknown -> t_boolean(); [Val] -> FunConstr = t_fun(any_list(Val), t_any()), Fun2 = fun (X) -> t_is_subtype(X, FunConstr) andalso (not t_is_none(X)) end, check_guard_single(FunType, Fun2, FunConstr); IntList when is_list(IntList) -> t_boolean() %% true? end end, strict(arg_types(erlang, is_function, 2), Xs, Fun); type(erlang, is_integer, 1, Xs) -> Fun = fun (X) -> check_guard(X, fun (Y) -> t_is_integer(Y) end, t_integer()) end, strict(arg_types(erlang, is_integer, 1), Xs, Fun); type(erlang, is_list, 1, Xs) -> Fun = fun (X) -> Fun2 = fun (Y) -> t_is_maybe_improper_list(Y) end, check_guard(X, Fun2, t_maybe_improper_list()) end, strict(arg_types(erlang, is_list, 1), Xs, Fun); type(erlang, is_number, 1, Xs) -> Fun = fun (X) -> check_guard(X, fun (Y) -> t_is_number(Y) end, t_number()) end, strict(arg_types(erlang, is_number, 1), Xs, Fun); type(erlang, is_pid, 1, Xs) -> Fun = fun (X) -> check_guard(X, fun (Y) -> t_is_pid(Y) end, t_pid()) end, strict(arg_types(erlang, is_pid, 1), Xs, Fun); 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_record, 2, Xs) -> Fun = fun ([X, Y]) -> case t_is_tuple(X) of false -> case t_is_none(t_inf(t_tuple(), X)) of true -> t_atom('false'); false -> t_boolean() end; true -> case t_tuple_subtypes(X) of unknown -> t_boolean(); [Tuple] -> case t_tuple_args(Tuple) of %% any -> t_boolean(); [Tag|_] -> case t_is_atom(Tag) of false -> TagAtom = t_inf(Tag, t_atom()), case t_is_none(TagAtom) of true -> t_atom('false'); false -> t_boolean() end; true -> case t_atom_vals(Tag) of [RealTag] -> case t_atom_vals(Y) of [RealTag] -> t_atom('true'); _ -> t_boolean() end; _ -> t_boolean() end end end; List when length(List) >= 2 -> t_sup([type(erlang, is_record, 2, [T, Y]) || T <- List]) end end end, strict(arg_types(erlang, is_record, 2), Xs, Fun); type(erlang, is_record, 3, Xs) -> Fun = fun ([X, Y, Z]) -> Arity = t_number_vals(Z), case t_is_tuple(X) of false when length(Arity) =:= 1 -> [RealArity] = Arity, case t_is_none(t_inf(t_tuple(RealArity), X)) of true -> t_atom('false'); false -> t_boolean() end; false -> case t_is_none(t_inf(t_tuple(), X)) of true -> t_atom('false'); false -> t_boolean() end; true when length(Arity) =:= 1 -> [RealArity] = Arity, case t_tuple_subtypes(X) of unknown -> t_boolean(); [Tuple] -> case t_tuple_args(Tuple) of %% any -> t_boolean(); Args when length(Args) =:= RealArity -> Tag = hd(Args), case t_is_atom(Tag) of false -> TagAtom = t_inf(Tag, t_atom()), case t_is_none(TagAtom) of true -> t_atom('false'); false -> t_boolean() end; true -> case t_atom_vals(Tag) of [RealTag] -> case t_atom_vals(Y) of [RealTag] -> t_atom('true'); _ -> t_boolean() end; _ -> t_boolean() end end; Args when length(Args) =/= RealArity -> t_atom('false') end; [_, _|_] -> t_boolean() end; true -> t_boolean() end end, strict(arg_types(erlang, is_record, 3), Xs, Fun); type(erlang, is_reference, 1, Xs) -> Fun = fun (X) -> check_guard(X, fun (Y) -> t_is_reference(Y) end, t_reference()) end, strict(arg_types(erlang, is_reference, 1), Xs, Fun); type(erlang, is_tuple, 1, Xs) -> Fun = fun (X) -> check_guard(X, fun (Y) -> t_is_tuple(Y) end, t_tuple()) end, strict(arg_types(erlang, is_tuple, 1), Xs, Fun); %% Guard bif, needs to be here. type(erlang, length, 1, Xs) -> strict(arg_types(erlang, length, 1), Xs, fun (_) -> t_non_neg_fixnum() end); type(erlang, list_to_integer, 2, Xs) -> strict(arg_types(erlang, list_to_integer, 2), Xs, fun (_) -> t_integer() end); type(erlang, make_tuple, 2, Xs) -> strict(arg_types(erlang, make_tuple, 2), Xs, fun ([Int, _]) -> case t_number_vals(Int) of [N] when is_integer(N), N >= 0 -> t_tuple(N); _Other -> t_tuple() end end); type(erlang, make_tuple, 3, Xs) -> strict(arg_types(erlang, make_tuple, 3), Xs, fun ([Int, _, _]) -> case t_number_vals(Int) of [N] when is_integer(N), N >= 0 -> t_tuple(N); _Other -> t_tuple() end end); type(erlang, memory, 0, _) -> t_list(t_tuple([t_atom(), t_non_neg_fixnum()])); 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); %% Guard bif, needs to be here. type(erlang, node, 0, _) -> t_node(); %% Guard bif, needs to be here. 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, port_call, Arity, Xs) when Arity =:= 2; Arity =:= 3 -> strict(arg_types(erlang, port_call, Arity), 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); %% Guard bif, needs to be here. type(erlang, round, 1, Xs) -> strict(arg_types(erlang, round, 1), Xs, fun (_) -> t_integer() end); %% Guard bif, needs to be here. type(erlang, self, 0, _) -> t_pid(); type(erlang, set_cookie, 2, Xs) -> strict(arg_types(erlang, set_cookie, 2), Xs, fun (_) -> t_atom('true') end); type(erlang, setelement, 3, Xs) -> strict(arg_types(erlang, setelement, 3), Xs, fun ([X1, X2, X3]) -> case t_tuple_subtypes(X2) of unknown -> t_tuple(); [_] -> Sz = t_tuple_size(X2), As = t_tuple_args(X2), case t_number_vals(X1) of unknown -> t_tuple([t_sup(X, X3) || X <- As]); [N] when is_integer(N), 1 =< N, N =< Sz -> t_tuple(list_replace(N, X3, As)); [N] when is_integer(N), N < 1 -> t_none(); [N] when is_integer(N), N > Sz -> t_none(); Ns -> Fun = fun (N, XL) when is_integer(N), 1 =< N, N =< Sz -> X = lists:nth(N, XL), Y = t_sup(X, X3), list_replace(N, Y, XL); (_, XL) -> XL end, t_tuple(lists:foldl(Fun, As, Ns)) end; Ts when is_list(Ts) -> t_sup([type(erlang, setelement, 3, [X1, Y, X3]) || Y <- Ts]) end end); %% Guard bif, needs to be here. 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, 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, 4, Xs) -> type(erlang, spawn, 4, Xs); % same 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, system_info, 1, Xs) -> strict(arg_types(erlang, system_info, 1), Xs, fun ([Type]) -> case t_is_atom(Type) of true -> case t_atom_vals(Type) of ['allocated_areas'] -> t_list(t_sup([t_tuple([t_atom(),t_non_neg_integer()]), t_tuple([t_atom(), t_non_neg_integer(), t_non_neg_integer()])])); ['allocator'] -> t_tuple([t_sup([t_atom('undefined'), t_atom('glibc')]), t_list(t_integer()), t_list(t_atom()), t_list(t_tuple([t_atom(), t_list(t_tuple([t_atom(), t_any()]))]))]); ['break_ignored'] -> t_boolean(); ['cpu_topology'] -> t_system_cpu_topology(); ['compat_rel'] -> t_non_neg_fixnum(); ['creation'] -> t_fixnum(); ['debug_compiled'] -> t_boolean(); ['dist'] -> t_binary(); ['dist_ctrl'] -> t_list(t_tuple([t_atom(), t_sup([t_pid(), t_port])])); %% elib_malloc is intentionally not included, %% because it scheduled for removal in R15. ['endian'] -> t_endian(); ['fullsweep_after'] -> t_tuple([t_atom('fullsweep_after'), t_non_neg_integer()]); ['garbage_collection'] -> t_list(); ['global_heaps_size'] -> t_non_neg_integer(); ['heap_sizes'] -> t_list(t_integer()); ['heap_type'] -> t_sup([t_atom('private'), t_atom('hybrid')]); ['hipe_architecture'] -> t_atoms(['amd64', 'arm', 'powerpc', 'ppc64', 'undefined', 'ultrasparc', 'x86']); ['info'] -> t_binary(); ['internal_cpu_topology'] -> %% Undocumented internal feature t_internal_cpu_topology(); ['loaded'] -> t_binary(); ['logical_processors'] -> t_non_neg_fixnum(); ['machine'] -> t_string(); ['multi_scheduling'] -> t_system_multi_scheduling(); ['multi_scheduling_blockers'] -> t_list(t_pid()); ['os_type'] -> t_tuple([t_sup([t_atom('unix'), t_atom('vxworks'), t_atom('win32')]), t_atom()]); ['os_version'] -> t_sup(t_tuple([t_non_neg_fixnum(), t_non_neg_fixnum(), t_non_neg_fixnum()]), t_string()); ['process_count'] -> t_non_neg_fixnum(); ['process_limit'] -> t_non_neg_fixnum(); ['procs'] -> t_binary(); ['scheduler_bindings'] -> t_tuple(); ['scheduler_bind_type'] -> t_scheduler_bind_type_results(); ['schedulers'] -> t_pos_fixnum(); ['schedulers_online'] -> t_pos_fixnum(); ['sequential_tracer'] -> t_tuple([t_atom('sequential_tracer'), t_sequential_tracer()]); ['smp_support'] -> t_boolean(); ['system_architecture'] -> t_string(); ['system_version'] -> t_string(); ['threads'] -> t_boolean(); ['thread_pool_size'] -> t_non_neg_fixnum(); ['trace_control_word'] -> t_integer(); ['version'] -> t_string(); ['wordsize'] -> t_integers([4,8]); List when is_list(List) -> t_any(); %% gross overapproximation unknown -> t_any() end; false -> %% This currently handles only {allocator, Alloc} t_any() %% overapproximation as the return value might change end end); %% Guard bif, needs to be here. type(erlang, tl, 1, Xs) -> strict(arg_types(erlang, tl, 1), Xs, fun ([X]) -> t_cons_tl(X) end); %% Guard bif, needs to be here. type(erlang, trunc, 1, Xs) -> strict(arg_types(erlang, trunc, 1), Xs, fun (_) -> t_integer() end); %% Guard bif, needs to be here. 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]) -> case t_tuple_subtypes(X) of unknown -> t_list(); SubTypes -> Args = lists:flatten([t_tuple_args(ST) || ST <- SubTypes]), %% Can be nil if the tuple can be {} case lists:any(fun (T) -> t_tuple_size(T) =:= 0 end, SubTypes) of true -> %% Be careful here. If we had only {} we need to %% keep the nil. t_sup(t_nonempty_list(t_sup(Args)), t_nil()); false -> t_nonempty_list(t_sup(Args)) end end end); type(erlang, yield, 0, _) -> t_atom('true'); %%-- ets ---------------------------------------------------------------------- type(ets, rename, 2, Xs) -> strict(arg_types(ets, rename, 2), Xs, fun ([_, Name]) -> Name end); %%-- hipe_bifs ---------------------------------------------------------------- type(hipe_bifs, add_ref, 2, Xs) -> strict(arg_types(hipe_bifs, add_ref, 2), Xs, fun (_) -> t_nil() end); type(hipe_bifs, alloc_data, 2, Xs) -> strict(arg_types(hipe_bifs, alloc_data, 2), Xs, fun (_) -> t_integer() end); % address type(hipe_bifs, array, 2, Xs) -> strict(arg_types(hipe_bifs, array, 2), Xs, fun (_) -> t_immarray() end); type(hipe_bifs, array_length, 1, Xs) -> strict(arg_types(hipe_bifs, array_length, 1), Xs, fun (_) -> t_non_neg_fixnum() end); type(hipe_bifs, array_sub, 2, Xs) -> strict(arg_types(hipe_bifs, array_sub, 2), Xs, fun (_) -> t_immediate() end); type(hipe_bifs, array_update, 3, Xs) -> strict(arg_types(hipe_bifs, array_update, 3), Xs, fun (_) -> t_immarray() end); type(hipe_bifs, atom_to_word, 1, Xs) -> strict(arg_types(hipe_bifs, atom_to_word, 1), Xs, fun (_) -> t_integer() end); type(hipe_bifs, bif_address, 3, Xs) -> strict(arg_types(hipe_bifs, bif_address, 3), Xs, fun (_) -> t_sup(t_integer(), t_atom('false')) end); type(hipe_bifs, bitarray, 2, Xs) -> strict(arg_types(hipe_bifs, bitarray, 2), Xs, fun (_) -> t_bitarray() end); type(hipe_bifs, bitarray_sub, 2, Xs) -> strict(arg_types(hipe_bifs, bitarray_sub, 2), Xs, fun (_) -> t_boolean() end); type(hipe_bifs, bitarray_update, 3, Xs) -> strict(arg_types(hipe_bifs, bitarray_update, 3), Xs, fun (_) -> t_bitarray() end); type(hipe_bifs, bytearray, 2, Xs) -> strict(arg_types(hipe_bifs, bytearray, 2), Xs, fun (_) -> t_bytearray() end); type(hipe_bifs, bytearray_sub, 2, Xs) -> strict(arg_types(hipe_bifs, bytearray_sub, 2), Xs, fun (_) -> t_byte() end); type(hipe_bifs, bytearray_update, 3, Xs) -> strict(arg_types(hipe_bifs, bytearray_update, 3), Xs, fun (_) -> t_bytearray() end); type(hipe_bifs, call_count_clear, 1, Xs) -> strict(arg_types(hipe_bifs, call_count_clear, 1), Xs, fun (_) -> t_sup(t_non_neg_integer(), t_atom('false')) end); type(hipe_bifs, call_count_get, 1, Xs) -> strict(arg_types(hipe_bifs, call_count_get, 1), Xs, fun (_) -> t_sup(t_non_neg_integer(), t_atom('false')) end); type(hipe_bifs, call_count_off, 1, Xs) -> strict(arg_types(hipe_bifs, call_count_off, 1), Xs, fun (_) -> t_sup(t_non_neg_integer(), t_atom('false')) end); type(hipe_bifs, call_count_on, 1, Xs) -> strict(arg_types(hipe_bifs, call_count_on, 1), Xs, fun (_) -> t_sup(t_atom('true'), t_nil()) end); type(hipe_bifs, check_crc, 1, Xs) -> strict(arg_types(hipe_bifs, check_crc, 1), Xs, fun (_) -> t_boolean() end); type(hipe_bifs, enter_code, 2, Xs) -> strict(arg_types(hipe_bifs, enter_code, 2), Xs, fun (_) -> t_tuple([t_integer(), %% XXX: The tuple below contains integers and %% is of size same as the length of the MFA list t_sup(t_nil(), t_binary())]) end); type(hipe_bifs, enter_sdesc, 1, Xs) -> strict(arg_types(hipe_bifs, enter_sdesc, 1), Xs, fun (_) -> t_nil() end); type(hipe_bifs, find_na_or_make_stub, 2, Xs) -> strict(arg_types(hipe_bifs, find_na_or_make_stub, 2), Xs, fun (_) -> t_integer() end); % address type(hipe_bifs, fun_to_address, 1, Xs) -> strict(arg_types(hipe_bifs, fun_to_address, 1), Xs, fun (_) -> t_integer() end); %% type(hipe_bifs, get_emu_address, 1, Xs) -> %% strict(arg_types(hipe_bifs, get_emu_address, 1), Xs, %% fun (_) -> t_integer() end); % address type(hipe_bifs, get_rts_param, 1, Xs) -> strict(arg_types(hipe_bifs, get_rts_param, 1), Xs, fun (_) -> t_sup(t_integer(), t_nil()) end); type(hipe_bifs, invalidate_funinfo_native_addresses, 1, Xs) -> strict(arg_types(hipe_bifs, invalidate_funinfo_native_addresses, 1), Xs, fun (_) -> t_nil() end); type(hipe_bifs, make_fe, 3, Xs) -> strict(arg_types(hipe_bifs, make_fe, 3), Xs, fun (_) -> t_integer() end); %% type(hipe_bifs, make_native_stub, 2, Xs) -> %% strict(arg_types(hipe_bifs, make_native_stub, 2), Xs, %% fun (_) -> t_integer() end); % address type(hipe_bifs, mark_referred_from, 1, Xs) -> strict(arg_types(hipe_bifs, mark_referred_from, 1), Xs, fun (_) -> t_nil() end); type(hipe_bifs, merge_term, 1, Xs) -> strict(arg_types(hipe_bifs, merge_term, 1), Xs, fun ([X]) -> X end); type(hipe_bifs, patch_call, 3, Xs) -> strict(arg_types(hipe_bifs, patch_call, 3), Xs, fun (_) -> t_nil() end); type(hipe_bifs, patch_insn, 3, Xs) -> strict(arg_types(hipe_bifs, patch_insn, 3), Xs, fun (_) -> t_nil() end); type(hipe_bifs, primop_address, 1, Xs) -> strict(arg_types(hipe_bifs, primop_address, 1), Xs, fun (_) -> t_sup(t_integer(), t_atom('false')) end); type(hipe_bifs, redirect_referred_from, 1, Xs) -> strict(arg_types(hipe_bifs, redirect_referred_from, 1), Xs, fun (_) -> t_nil() end); type(hipe_bifs, ref, 1, Xs) -> strict(arg_types(hipe_bifs, ref, 1), Xs, fun (_) -> t_immarray() end); type(hipe_bifs, ref_get, 1, Xs) -> strict(arg_types(hipe_bifs, ref_get, 1), Xs, fun (_) -> t_immediate() end); type(hipe_bifs, ref_set, 2, Xs) -> strict(arg_types(hipe_bifs, ref_set, 2), Xs, fun (_) -> t_nil() end); type(hipe_bifs, remove_refs_from, 1, Xs) -> strict(arg_types(hipe_bifs, remove_refs_from, 1), Xs, fun (_) -> t_nil() end); type(hipe_bifs, set_funinfo_native_address, 3, Xs) -> strict(arg_types(hipe_bifs, set_funinfo_native_address, 3), Xs, fun (_) -> t_nil() end); type(hipe_bifs, set_native_address, 3, Xs) -> strict(arg_types(hipe_bifs, set_native_address, 3), Xs, fun (_) -> t_nil() end); type(hipe_bifs, system_crc, 1, Xs) -> strict(arg_types(hipe_bifs, system_crc, 1), Xs, fun (_) -> t_crc32() end); type(hipe_bifs, term_to_word, 1, Xs) -> strict(arg_types(hipe_bifs, term_to_word, 1), Xs, fun (_) -> t_integer() end); type(hipe_bifs, update_code_size, 3, Xs) -> strict(arg_types(hipe_bifs, update_code_size, 3), Xs, fun (_) -> t_nil() end); type(hipe_bifs, write_u8, 2, Xs) -> strict(arg_types(hipe_bifs, write_u8, 2), Xs, fun (_) -> t_nil() end); type(hipe_bifs, write_u32, 2, Xs) -> strict(arg_types(hipe_bifs, write_u32, 2), Xs, fun (_) -> t_nil() end); type(hipe_bifs, write_u64, 2, Xs) -> strict(arg_types(hipe_bifs, write_u64, 2), Xs, fun (_) -> t_nil() end); %%-- lists -------------------------------------------------------------------- type(lists, all, 2, Xs) -> strict(arg_types(lists, all, 2), Xs, fun ([F, L]) -> case t_is_nil(L) of true -> t_atom('true'); false -> El = t_list_elements(L), case check_fun_application(F, [El]) of ok -> case t_is_cons(L) of true -> t_fun_range(F); false -> %% The list can be empty. t_sup(t_atom('true'), t_fun_range(F)) end; error -> case t_is_cons(L) of true -> t_none(); false -> t_fun_range(F) end end end end); type(lists, any, 2, Xs) -> strict(arg_types(lists, any, 2), Xs, fun ([F, L]) -> case t_is_nil(L) of true -> t_atom('false'); false -> El = t_list_elements(L), case check_fun_application(F, [El]) of ok -> case t_is_cons(L) of true -> t_fun_range(F); false -> %% The list can be empty t_sup(t_atom('false'), t_fun_range(F)) end; error -> case t_is_cons(L) of true -> t_none(); false -> t_fun_range(F) end end end end); type(lists, append, 2, Xs) -> type(erlang, '++', 2, Xs); % alias type(lists, delete, 2, Xs) -> strict(arg_types(lists, delete, 2), Xs, fun ([_, List]) -> case t_is_cons(List) of true -> t_cons_tl(List); false -> List end end); type(lists, dropwhile, 2, Xs) -> strict(arg_types(lists, dropwhile, 2), Xs, fun ([F, X]) -> case t_is_nil(X) of true -> t_nil(); false -> X1 = t_list_elements(X), case check_fun_application(F, [X1]) of ok -> case t_atom_vals(t_fun_range(F)) of ['true'] -> case t_is_none(t_inf(t_list(), X)) of true -> t_none(); false -> t_nil() end; ['false'] -> case t_is_none(t_inf(t_list(), X)) of true -> t_none(); false -> X end; _ -> t_inf(t_cons_tl(t_inf(X, t_cons())), t_maybe_improper_list()) end; error -> case t_is_cons(X) of true -> t_none(); false -> t_nil() end end end end); type(lists, filter, 2, Xs) -> strict(arg_types(lists, filter, 2), Xs, fun ([F, L]) -> case t_is_nil(L) of true -> t_nil(); false -> T = t_list_elements(L), case check_fun_application(F, [T]) of ok -> case t_atom_vals(t_fun_range(F)) =:= ['false'] of true -> t_nil(); false -> case t_atom_vals(t_fun_range(F)) =:= ['true'] of true -> L; false -> t_list(T) end end; error -> case t_is_cons(L) of true -> t_none(); false -> t_nil() end end end end); type(lists, flatten, 1, Xs) -> strict(arg_types(lists, flatten, 1), Xs, fun ([L]) -> case t_is_nil(L) of true -> L; % (nil has undefined elements) false -> %% Avoiding infinite recursion is tricky X1 = t_list_elements(L), case t_is_any(X1) of true -> t_list(); false -> X2 = type(lists, flatten, 1, [t_inf(X1, t_list())]), t_sup(t_list(t_subtract(X1, t_list())), X2) end end end); type(lists, flatmap, 2, Xs) -> strict(arg_types(lists, flatmap, 2), Xs, fun ([F, List]) -> case t_is_nil(List) of true -> t_nil(); false -> case check_fun_application(F, [t_list_elements(List)]) of ok -> R = t_fun_range(F), case t_is_nil(R) of true -> t_nil(); false -> Elems = t_list_elements(R), case t_is_cons(List) of true -> case t_is_subtype(t_nil(), R) of true -> t_list(Elems); false -> t_nonempty_list(Elems) end; false -> t_list(Elems) end end; error -> case t_is_cons(List) of true -> t_none(); false -> t_nil() end end end end); type(lists, foreach, 2, Xs) -> strict(arg_types(lists, foreach, 2), Xs, fun ([F, List]) -> case t_is_cons(List) of true -> case check_fun_application(F, [t_list_elements(List)]) of ok -> t_atom('ok'); error -> t_none() end; false -> t_atom('ok') end end); type(lists, foldl, 3, Xs) -> strict(arg_types(lists, foldl, 3), Xs, fun ([F, Acc, List]) -> case t_is_nil(List) of true -> Acc; false -> case check_fun_application(F, [t_list_elements(List), Acc]) of ok -> case t_is_cons(List) of true -> t_fun_range(F); false -> t_sup(t_fun_range(F), Acc) end; error -> case t_is_cons(List) of true -> t_none(); false -> Acc end end end end); type(lists, foldr, 3, Xs) -> type(lists, foldl, 3, Xs); % same type(lists, keydelete, 3, Xs) -> strict(arg_types(lists, keydelete, 3), Xs, fun ([_, _, L]) -> Term = t_list_termination(L), t_sup(Term, erl_types:lift_list_to_pos_empty(L)) end); type(lists, keyfind, 3, Xs) -> strict(arg_types(lists, keyfind, 3), Xs, fun ([X, Y, Z]) -> ListEs = t_list_elements(Z), Tuple = t_inf(t_tuple(), ListEs), case t_is_none(Tuple) of true -> t_atom('false'); false -> %% this BIF, contrary to lists:keysearch/3 does not %% wrap its result in a 'value'-tagged tuple Ret = t_sup(Tuple, t_atom('false')), case t_is_any(X) of true -> Ret; false -> case t_tuple_subtypes(Tuple) of unknown -> Ret; List -> case key_comparisons_fail(X, Y, List) of true -> t_atom('false'); false -> Ret end end end end end); type(lists, keymap, 3, Xs) -> strict(arg_types(lists, keymap, 3), Xs, fun ([F, _I, L]) -> case t_is_nil(L) of true -> L; false -> t_list(t_sup(t_fun_range(F), t_list_elements(L))) end end); type(lists, keymember, 3, Xs) -> strict(arg_types(lists, keymember, 3), Xs, fun ([X, Y, Z]) -> ListEs = t_list_elements(Z), Tuple = t_inf(t_tuple(), ListEs), case t_is_none(Tuple) of true -> t_atom('false'); false -> case t_is_any(X) of true -> t_boolean(); false -> case t_tuple_subtypes(Tuple) of unknown -> t_boolean(); List -> case key_comparisons_fail(X, Y, List) of true -> t_atom('false'); false -> t_boolean() end end end end end); type(lists, keymerge, 3, Xs) -> strict(arg_types(lists, keymerge, 3), Xs, fun ([_I, L1, L2]) -> type(lists, merge, 2, [L1, L2]) end); type(lists, keyreplace, 4, Xs) -> strict(arg_types(lists, keyreplace, 4), Xs, fun ([_K, _I, L, T]) -> t_list(t_sup(t_list_elements(L), T)) end); type(lists, keysearch, 3, Xs) -> strict(arg_types(lists, keysearch, 3), Xs, fun ([X, Y, Z]) -> ListEs = t_list_elements(Z), Tuple = t_inf(t_tuple(), ListEs), case t_is_none(Tuple) of true -> t_atom('false'); false -> Ret = t_sup(t_tuple([t_atom('value'), Tuple]), t_atom('false')), case t_is_any(X) of true -> Ret; false -> case t_tuple_subtypes(Tuple) of unknown -> Ret; List -> case key_comparisons_fail(X, Y, List) of true -> t_atom('false'); false -> Ret end end end end end); type(lists, keysort, 2, Xs) -> strict(arg_types(lists, keysort, 2), Xs, fun ([_, L]) -> L end); type(lists, last, 1, Xs) -> strict(arg_types(lists, last, 1), Xs, fun ([L]) -> t_list_elements(L) end); type(lists, map, 2, Xs) -> strict(arg_types(lists, map, 2), Xs, fun ([F, L]) -> case t_is_nil(L) of true -> L; false -> El = t_list_elements(L), case t_is_cons(L) of true -> case check_fun_application(F, [El]) of ok -> t_nonempty_list(t_fun_range(F)); error -> t_none() end; false -> case check_fun_application(F, [El]) of ok -> t_list(t_fun_range(F)); error -> t_nil() end end end end); type(lists, mapfoldl, 3, Xs) -> strict(arg_types(lists, mapfoldl, 3), Xs, fun ([F, Acc, List]) -> case t_is_nil(List) of true -> t_tuple([List, Acc]); false -> El = t_list_elements(List), R = t_fun_range(F), case t_is_cons(List) of true -> case check_fun_application(F, [El, Acc]) of ok -> Fun = fun (RangeTuple) -> [T1, T2] = t_tuple_args(RangeTuple), t_tuple([t_nonempty_list(T1), T2]) end, t_sup([Fun(ST) || ST <- t_tuple_subtypes(R)]); error -> t_none() end; false -> case check_fun_application(F, [El, Acc]) of ok -> Fun = fun (RangeTuple) -> [T1, T2] = t_tuple_args(RangeTuple), t_tuple([t_list(T1), t_sup(Acc, T2)]) end, t_sup([Fun(ST) || ST <- t_tuple_subtypes(R)]); error -> t_tuple([t_nil(), Acc]) end end end end); type(lists, mapfoldr, 3, Xs) -> type(lists, mapfoldl, 3, Xs); % same type(lists, max, 1, Xs) -> strict(arg_types(lists, max, 1), Xs, fun ([L]) -> t_list_elements(L) end); type(lists, member, 2, Xs) -> strict(arg_types(lists, member, 2), Xs, fun ([X, Y]) -> Y1 = t_list_elements(Y), case t_is_none(t_inf(Y1, X)) of true -> t_atom('false'); false -> t_boolean() end end); %% type(lists, merge, 1, Xs) -> type(lists, merge, 2, Xs) -> strict(arg_types(lists, merge, 2), Xs, fun ([L1, L2]) -> case t_is_none(L1) of true -> L2; false -> case t_is_none(L2) of true -> L1; false -> t_sup(L1, L2) end end end); type(lists, min, 1, Xs) -> strict(arg_types(lists, min, 1), Xs, fun ([L]) -> t_list_elements(L) end); type(lists, nth, 2, Xs) -> strict(arg_types(lists, nth, 2), Xs, fun ([_, Y]) -> t_list_elements(Y) end); type(lists, nthtail, 2, Xs) -> strict(arg_types(lists, nthtail, 2), Xs, fun ([_, Y]) -> t_sup(Y, t_list()) end); type(lists, partition, 2, Xs) -> strict(arg_types(lists, partition, 2), Xs, fun ([F, L]) -> case t_is_nil(L) of true -> t_tuple([L,L]); false -> El = t_list_elements(L), case check_fun_application(F, [El]) of error -> case t_is_cons(L) of true -> t_none(); false -> t_tuple([t_nil(), t_nil()]) end; ok -> case t_atom_vals(t_fun_range(F)) of ['true'] -> t_tuple([L, t_nil()]); ['false'] -> t_tuple([t_nil(), L]); [_, _] -> L2 = t_list(El), t_tuple([L2, L2]) end end end end); type(lists, reverse, 1, Xs) -> strict(arg_types(lists, reverse, 1), Xs, fun ([X]) -> X end); type(lists, reverse, 2, Xs) -> type(erlang, '++', 2, Xs); % reverse-onto is just like append type(lists, sort, 1, Xs) -> strict(arg_types(lists, sort, 1), Xs, fun ([X]) -> X end); type(lists, sort, 2, Xs) -> strict(arg_types(lists, sort, 2), Xs, fun ([F, L]) -> R = t_fun_range(F), case t_is_boolean(R) of true -> L; false -> case t_is_nil(L) of true -> t_nil(); false -> t_none() end end end); type(lists, split, 2, Xs) -> strict(arg_types(lists, split, 2), Xs, fun ([_, L]) -> case t_is_nil(L) of true -> t_tuple([L, L]); false -> T = t_list_elements(L), t_tuple([t_list(T), t_list(T)]) end end); type(lists, splitwith, 2, Xs) -> T1 = type(lists, takewhile, 2, Xs), T2 = type(lists, dropwhile, 2, Xs), case t_is_none(T1) orelse t_is_none(T2) of true -> t_none(); false -> t_tuple([T1, T2]) end; type(lists, subtract, 2, Xs) -> type(erlang, '--', 2, Xs); % alias type(lists, takewhile, 2, Xs) -> strict(arg_types(lists, takewhile, 2), Xs, fun([F, L]) -> case t_is_none(t_inf(t_list(), L)) of false -> type(lists, filter, 2, Xs); true -> %% This works for non-proper lists as well. El = t_list_elements(L), type(lists, filter, 2, [F, t_list(El)]) end end); type(lists, usort, 1, Xs) -> type(lists, sort, 1, Xs); % same type(lists, usort, 2, Xs) -> type(lists, sort, 2, Xs); % same type(lists, unzip, 1, Xs) -> strict(arg_types(lists, unzip, 1), Xs, fun ([Ps]) -> case t_is_nil(Ps) of true -> t_tuple([t_nil(), t_nil()]); false -> % Ps is a proper list of pairs TupleTypes = t_tuple_subtypes(t_list_elements(Ps)), lists:foldl(fun(Tuple, Acc) -> [A, B] = t_tuple_args(Tuple), t_sup(t_tuple([t_list(A), t_list(B)]), Acc) end, t_none(), TupleTypes) end end); type(lists, unzip3, 1, Xs) -> strict(arg_types(lists, unzip3, 1), Xs, fun ([Ts]) -> case t_is_nil(Ts) of true -> t_tuple([t_nil(), t_nil(), t_nil()]); false -> % Ps is a proper list of triples TupleTypes = t_tuple_subtypes(t_list_elements(Ts)), lists:foldl(fun(T, Acc) -> [A, B, C] = t_tuple_args(T), t_sup(t_tuple([t_list(A), t_list(B), t_list(C)]), Acc) end, t_none(), TupleTypes) end end); type(lists, zip, 2, Xs) -> strict(arg_types(lists, zip, 2), Xs, fun ([As, Bs]) -> case (t_is_nil(As) orelse t_is_nil(Bs)) of true -> t_nil(); false -> A = t_list_elements(As), B = t_list_elements(Bs), t_list(t_tuple([A, B])) end end); type(lists, zip3, 3, Xs) -> strict(arg_types(lists, zip3, 3), Xs, fun ([As, Bs, Cs]) -> case (t_is_nil(As) orelse t_is_nil(Bs) orelse t_is_nil(Cs)) of true -> t_nil(); false -> A = t_list_elements(As), B = t_list_elements(Bs), C = t_list_elements(Cs), t_list(t_tuple([A, B, C])) end end); type(lists, zipwith, 3, Xs) -> strict(arg_types(lists, zipwith, 3), Xs, fun ([F, _As, _Bs]) -> t_sup(t_list(t_fun_range(F)), t_nil()) end); type(lists, zipwith3, 4, Xs) -> strict(arg_types(lists, zipwith3, 4), Xs, fun ([F,_As,_Bs,_Cs]) -> t_sup(t_list(t_fun_range(F)), t_nil()) end); %%-- string ------------------------------------------------------------------- type(string, chars, 2, Xs) -> % NOTE: added to avoid loss of information strict(arg_types(string, chars, 2), Xs, fun (_) -> t_string() end); type(string, chars, 3, Xs) -> % NOTE: added to avoid loss of information strict(arg_types(string, chars, 3), Xs, fun ([Char, N, Tail]) -> case t_is_nil(Tail) of true -> type(string, chars, 2, [Char, N]); false -> case t_is_string(Tail) of true -> t_string(); false -> t_sup(t_sup(t_string(), Tail), t_cons(Char, Tail)) end end end); %%----------------------------------------------------------------------------- type(M, F, A, Xs) when is_atom(M), is_atom(F), is_integer(A), 0 =< A, A =< 255 -> strict(Xs, t_any()). % safe approximation for all functions. %%----------------------------------------------------------------------------- %% Auxiliary functions %%----------------------------------------------------------------------------- strict(Xs, Ts, F) -> %% io:format("inf lists arg~n1:~p~n2:~p ~n", [Xs, Ts]), Xs1 = inf_lists(Xs, Ts), %% io:format("inf lists return ~p ~n", [Xs1]), case any_is_none_or_unit(Xs1) of true -> t_none(); false -> F(Xs1) end. strict(Xs, X) -> case any_is_none_or_unit(Xs) of true -> t_none(); false -> X end. inf_lists([X | Xs], [T | Ts]) -> [t_inf(X, T) | inf_lists(Xs, Ts)]; inf_lists([], []) -> []. any_list(N) -> any_list(N, t_any()). any_list(N, A) when N > 0 -> [A | any_list(N - 1, A)]; any_list(0, _) -> []. list_replace(N, E, [X | Xs]) when N > 1 -> [X | list_replace(N - 1, E, Xs)]; list_replace(1, E, [_X | Xs]) -> [E | Xs]. any_is_none_or_unit(Ts) -> lists:any(fun erl_types:t_is_none_or_unit/1, Ts). check_guard([X], Test, Type) -> check_guard_single(X, Test, Type). check_guard_single(X, Test, Type) -> case Test(X) of true -> t_atom('true'); false -> case erl_types:t_is_opaque(X) of true -> t_none(); false -> case t_is_none(t_inf(Type, X)) of true -> t_atom('false'); false -> t_boolean() end end end. %%----------------------------------------------------------------------------- %% Functions for range analysis %%----------------------------------------------------------------------------- infinity_max([]) -> empty; infinity_max([H|T]) -> if H =:= empty -> infinity_max(T); true -> lists:foldl( fun (Elem, Max) -> Geq = infinity_geq(Elem, Max), if not Geq orelse (Elem =:= empty) -> Max; true -> Elem end end, H, T) end. infinity_min([]) -> empty; infinity_min([H|T]) -> if H =:= empty -> infinity_min(T); true -> lists:foldl(fun (Elem, Min) -> Geq = infinity_geq(Elem, Min), if Geq orelse (Elem =:= empty) -> Min; true -> Elem end end, H, T) end. -type inf_integer() :: 'neg_inf' | 'pos_inf' | integer(). -spec infinity_abs('pos_inf' | 'neg_inf') -> 'pos_inf' ; (integer()) -> non_neg_integer(). infinity_abs(pos_inf) -> pos_inf; infinity_abs(neg_inf) -> pos_inf; infinity_abs(Number) when is_integer(Number) -> abs(Number). %% span_zero(Range) -> %% infinity_geq(0, number_min(Range)) and infinity_geq(number_max(Range), 0). infinity_inv(pos_inf) -> neg_inf; infinity_inv(neg_inf) -> pos_inf; infinity_inv(Number) when is_integer(Number) -> -Number. infinity_band(neg_inf, Type2) -> Type2; %% infinity_band(Type1, neg_inf) -> Type1; infinity_band(pos_inf, Type2) -> Type2; %% infinity_band(Type1, pos_inf) -> Type1; infinity_band(Type1, Type2) when is_integer(Type1), is_integer(Type2) -> Type1 band Type2. infinity_bor(neg_inf, _Type2) -> neg_inf; %% infinity_bor(_Type1, neg_inf) -> neg_inf; infinity_bor(pos_inf, _Type2) -> pos_inf; %% infinity_bor(_Type1, pos_inf) -> pos_inf; infinity_bor(Type1, Type2) when is_integer(Type1), is_integer(Type2) -> Type1 bor Type2. infinity_div(pos_inf, pos_inf) -> [0, pos_inf]; infinity_div(pos_inf, neg_inf) -> [neg_inf, 0]; infinity_div(neg_inf, neg_inf) -> [0, pos_inf]; infinity_div(neg_inf, pos_inf) -> [neg_inf, 0]; infinity_div(pos_inf, Number) when is_integer(Number), Number > 0 -> pos_inf; infinity_div(pos_inf, Number) when is_integer(Number), Number < 0 -> neg_inf; infinity_div(neg_inf, Number) when is_integer(Number), Number > 0 -> neg_inf; infinity_div(neg_inf, Number) when is_integer(Number), Number < 0 -> pos_inf; infinity_div(Number, pos_inf) when is_integer(Number), Number >= 0 -> pos_inf; infinity_div(Number, pos_inf) when is_integer(Number), Number < 0 -> neg_inf; infinity_div(Number, neg_inf) when is_integer(Number), Number >= 0 -> neg_inf; infinity_div(Number, neg_inf) when is_integer(Number), Number < 0 -> pos_inf; infinity_div(Number1, Number2) when is_integer(Number1), is_integer(Number2) -> Number1 div Number2. infinity_bsl(pos_inf, _) -> pos_inf; infinity_bsl(neg_inf, _) -> neg_inf; infinity_bsl(Number, pos_inf) when is_integer(Number), Number >= 0 -> pos_inf; infinity_bsl(Number, pos_inf) when is_integer(Number) -> neg_inf; infinity_bsl(Number, neg_inf) when is_integer(Number), Number >= 0 -> 0; infinity_bsl(Number, neg_inf) when is_integer(Number) -> -1; infinity_bsl(Number1, Number2) when is_integer(Number1), is_integer(Number2) -> Bits = ?BITS, if Number2 > (Bits * 2) -> infinity_bsl(Number1, pos_inf); Number2 < (-Bits * 2) -> infinity_bsl(Number1, neg_inf); true -> Number1 bsl Number2 end. infinity_geq(pos_inf, _) -> true; infinity_geq(_, pos_inf) -> false; infinity_geq(_, neg_inf) -> true; infinity_geq(neg_inf, _) -> false; infinity_geq(A, B) when is_integer(A), is_integer(B) -> A >= B. -spec infinity_add(inf_integer(), inf_integer()) -> inf_integer(). infinity_add(pos_inf, _Number) -> pos_inf; infinity_add(neg_inf, _Number) -> neg_inf; infinity_add(_Number, pos_inf) -> pos_inf; infinity_add(_Number, neg_inf) -> neg_inf; infinity_add(Number1, Number2) when is_integer(Number1), is_integer(Number2) -> Number1 + Number2. infinity_mult(neg_inf, Number) -> Greater = infinity_geq(Number, 0), if Greater -> neg_inf; true -> pos_inf end; infinity_mult(pos_inf, Number) -> infinity_inv(infinity_mult(neg_inf, Number)); infinity_mult(Number, pos_inf) -> infinity_inv(infinity_mult(neg_inf, Number)); infinity_mult(Number, neg_inf) -> infinity_mult(neg_inf, Number); infinity_mult(Number1, Number2) when is_integer(Number1), is_integer(Number2)-> Number1 * Number2. width({Min, Max}) -> infinity_max([width(Min), width(Max)]); width(pos_inf) -> pos_inf; width(neg_inf) -> pos_inf; width(X) when is_integer(X), X >= 0 -> poswidth(X, 0); width(X) when is_integer(X), X < 0 -> negwidth(X, 0). poswidth(X, N) -> case X < (1 bsl N) of true -> N; false -> poswidth(X, N+1) end. negwidth(X, N) -> case X >= (-1 bsl N) of true -> N; false -> negwidth(X, N+1) end. arith('bnot', X1) -> case t_is_integer(X1) of false -> error; true -> Min1 = number_min(X1), Max1 = number_max(X1), {ok, t_from_range(infinity_add(infinity_inv(Max1), -1), infinity_add(infinity_inv(Min1), -1))} end. arith_mult(Min1, Max1, Min2, Max2) -> Tmp_list = [infinity_mult(Min1, Min2), infinity_mult(Min1, Max2), infinity_mult(Max1, Min2), infinity_mult(Max1, Max2)], {infinity_min(Tmp_list), infinity_max(Tmp_list)}. arith_div(_Min1, _Max1, 0, 0) -> %% Signal failure. {pos_inf, neg_inf}; arith_div(Min1, Max1, Min2, Max2) -> %% 0 is not an accepted divisor. NewMin2 = if Min2 =:= 0 -> 1; true -> Min2 end, NewMax2 = if Max2 =:= 0 -> -1; true -> Max2 end, Tmp_list = lists:flatten([infinity_div(Min1, NewMin2), infinity_div(Min1, NewMax2), infinity_div(Max1, NewMin2), infinity_div(Max1, NewMax2)]), {infinity_min(Tmp_list), infinity_max(Tmp_list)}. arith_rem(Min1, Max1, Min2, Max2) -> Min1_geq_zero = infinity_geq(Min1, 0), Max1_leq_zero = infinity_geq(0, Max1), Max_range2 = infinity_max([infinity_abs(Min2), infinity_abs(Max2)]), Max_range2_leq_zero = infinity_geq(0, Max_range2), New_min = if Min1_geq_zero -> 0; Max_range2 =:= 0 -> 0; Max_range2_leq_zero -> infinity_add(Max_range2, 1); true -> infinity_add(infinity_inv(Max_range2), 1) end, New_max = if Max1_leq_zero -> 0; Max_range2 =:= 0 -> 0; Max_range2_leq_zero -> infinity_add(infinity_inv(Max_range2), -1); true -> infinity_add(Max_range2, -1) end, {New_min, New_max}. arith_bsl(Min1, Max1, Min2, Max2) -> case infinity_geq(Min1, 0) of true -> {infinity_bsl(Min1, Min2), infinity_bsl(Max1, Max2)}; false -> case infinity_geq(Max1, 0) of true -> {infinity_bsl(Min1, Max2), infinity_bsl(Max1, Max2)}; false -> {infinity_bsl(Min1, Max2), infinity_bsl(Max2, Min2)} end end. arith_band_range_set({Min, Max}, [Int|IntList]) -> SafeAnd = lists:foldl( fun (IntFromSet, SafeAndAcc) -> IntFromSet bor SafeAndAcc end, Int, IntList), {infinity_band(Min, SafeAnd), infinity_band(Max, SafeAnd)}. arith_bor_range_set({Min, Max}, [Int|IntList]) -> SafeAnd = lists:foldl( fun (IntFromSet, SafeAndAcc) -> IntFromSet band SafeAndAcc end, Int, IntList), {infinity_bor(Min, SafeAnd), infinity_bor(Max, SafeAnd)}. arith_band(X1, X2) -> L1 = t_number_vals(X1), L2 = t_number_vals(X2), Min1 = number_min(X1), Max1 = number_max(X1), Min2 = number_min(X2), Max2 = number_max(X2), case {L1 =:= unknown, L2 =:= unknown} of {true, false} -> arith_band_range_set(arith_band_ranges(Min1, Max1, Min2, Max2), L2); {false, true} -> arith_band_range_set(arith_band_ranges(Min1, Max1, Min2, Max2), L1); {true, true} -> arith_band_ranges(Min1, Max1, Min2, Max2) end. arith_bor(X1, X2) -> L1 = t_number_vals(X1), L2 = t_number_vals(X2), Min1 = number_min(X1), Max1 = number_max(X1), Min2 = number_min(X2), Max2 = number_max(X2), case {L1 =:= unknown, L2 =:= unknown} of {true, false} -> arith_bor_range_set(arith_bor_ranges(Min1, Max1, Min2, Max2), L2); {false, true} -> arith_bor_range_set(arith_bor_ranges(Min1, Max1, Min2, Max2), L1); {true, true} -> arith_bor_ranges(Min1, Max1, Min2, Max2) end. arith_band_ranges(Min1, Max1, Min2, Max2) -> Width = infinity_min([width({Min1, Max1}), width({Min2, Max2})]), Min = case infinity_geq(Min1, 0) orelse infinity_geq(Min2, 0) of true -> 0; false -> infinity_bsl(-1, Width) end, Max = case infinity_geq(Max1, 0) orelse infinity_geq(Max2, 0) of true -> infinity_add(infinity_bsl(1, Width), -1); false -> 0 end, {Min, Max}. arith_bor_ranges(Min1, Max1, Min2, Max2) -> Width = infinity_max([width({Min1, Max1}), width({Min2, Max2})]), Min = case infinity_geq(Min1, 0) andalso infinity_geq(Min2, 0) of true -> 0; false -> infinity_bsl(-1, Width) end, Max = case infinity_geq(Max1, 0) andalso infinity_geq(Max2, 0) of true -> infinity_add(infinity_bsl(1, Width), -1); false -> -1 end, {Min, Max}. arith(Op, X1, X2) -> %% io:format("arith ~p ~p ~p~n", [Op, X1, X2]), case t_is_integer(X1) andalso t_is_integer(X2) of false -> error; true -> L1 = t_number_vals(X1), L2 = t_number_vals(X2), case (L1 =:= unknown) orelse (L2 =:= unknown) of true -> Min1 = number_min(X1), Max1 = number_max(X1), Min2 = number_min(X2), Max2 = number_max(X2), {NewMin, NewMax} = case Op of '+' -> {infinity_add(Min1, Min2), infinity_add(Max1, Max2)}; '-' -> {infinity_add(Min1, infinity_inv(Max2)), infinity_add(Max1, infinity_inv(Min2))}; '*' -> arith_mult(Min1, Max1, Min2, Max2); 'div' -> arith_div(Min1, Max1, Min2, Max2); 'rem' -> arith_rem(Min1, Max1, Min2, Max2); 'bsl' -> arith_bsl(Min1, Max1, Min2, Max2); 'bsr' -> NewMin2 = infinity_inv(Max2), NewMax2 = infinity_inv(Min2), arith_bsl(Min1, Max1, NewMin2, NewMax2); 'band' -> arith_band(X1, X2); 'bor' -> arith_bor(X1, X2); 'bxor' -> arith_bor_ranges(Min1, Max1, Min2, Max2) %% overaprox. end, %% io:format("done arith ~p = ~p~n", [Op, {NewMin, NewMax}]), {ok, t_from_range(NewMin, NewMax)}; false -> %% Some of these arithmetic operations might throw a system_limit %% exception; for example, when trying to evaluate 1 bsl 100000000. try case Op of '+' -> [X + Y || X <- L1, Y <- L2]; '-' -> [X - Y || X <- L1, Y <- L2]; '*' -> [X * Y || X <- L1, Y <- L2]; 'div' -> [X div Y || X <- L1, Y <- L2, Y =/= 0]; 'rem' -> [X rem Y || X <- L1, Y <- L2, Y =/= 0]; 'bsl' -> [X bsl Y || X <- L1, Y <- L2]; 'bsr' -> [X bsr Y || X <- L1, Y <- L2]; 'band' -> [X band Y || X <- L1, Y <- L2]; 'bor' -> [X bor Y || X <- L1, Y <- L2]; 'bxor' -> [X bxor Y || X <- L1, Y <- L2] end of AllVals -> {ok, t_integers(ordsets:from_list(AllVals))} catch error:system_limit -> error end end end. %%============================================================================= %% Comparison of terms %%============================================================================= compare(Op, Lhs, Rhs) -> case t_is_none(t_inf(Lhs, Rhs)) of false -> t_boolean(); true -> case Op of '<' -> always_smaller(Lhs, Rhs); '>' -> always_smaller(Rhs, Lhs); '=<' -> always_smaller(Lhs, Rhs); '>=' -> always_smaller(Rhs, Lhs) end end. always_smaller(Type1, Type2) -> {Min1, Max1} = type_ranks(Type1), {Min2, Max2} = type_ranks(Type2), if Max1 < Min2 -> t_atom('true'); Min1 > Max2 -> t_atom('false'); true -> t_boolean() end. type_ranks(Type) -> type_ranks(Type, 1, 0, 0, type_order()). type_ranks(_Type, _I, Min, Max, []) -> {Min, Max}; type_ranks(Type, I, Min, Max, [TypeClass|Rest]) -> {NewMin, NewMax} = case t_is_none(t_inf(Type, TypeClass)) of true -> {Min, Max}; false -> case Min of 0 -> {I, I}; _ -> {Min, I} end end, type_ranks(Type, I+1, NewMin, NewMax, Rest). type_order() -> [t_number(), t_atom(), t_reference(), t_fun(), t_port(), t_pid(), t_tuple(), t_list(), t_binary()]. key_comparisons_fail(X0, KeyPos, TupleList) -> X = case t_is_number(t_inf(X0, t_number())) of false -> X0; true -> t_number() end, lists:all(fun(Tuple) -> Key = type(erlang, element, 2, [KeyPos, Tuple]), t_is_none(t_inf(Key, X)) end, TupleList). %%============================================================================= -spec arg_types(atom(), atom(), arity()) -> [erl_types:erl_type()] | 'unknown'. %%------- erlang -------------------------------------------------------------- arg_types(erlang, '!', 2) -> Pid = t_sup([t_pid(), t_port(), t_atom(), t_tuple([t_atom(), t_node()])]), [Pid, t_any()]; arg_types(erlang, '==', 2) -> [t_any(), t_any()]; arg_types(erlang, '/=', 2) -> [t_any(), t_any()]; arg_types(erlang, '=:=', 2) -> [t_any(), t_any()]; arg_types(erlang, '=/=', 2) -> [t_any(), t_any()]; arg_types(erlang, '>', 2) -> [t_any(), t_any()]; arg_types(erlang, '>=', 2) -> [t_any(), t_any()]; arg_types(erlang, '<', 2) -> [t_any(), t_any()]; arg_types(erlang, '=<', 2) -> [t_any(), t_any()]; arg_types(erlang, '+', 1) -> [t_number()]; arg_types(erlang, '+', 2) -> [t_number(), t_number()]; arg_types(erlang, '++', 2) -> [t_list(), t_any()]; arg_types(erlang, '-', 1) -> [t_number()]; arg_types(erlang, '-', 2) -> [t_number(), t_number()]; arg_types(erlang, '--', 2) -> [t_list(), t_list()]; arg_types(erlang, '*', 2) -> [t_number(), t_number()]; arg_types(erlang, '/', 2) -> [t_number(), t_number()]; arg_types(erlang, 'div', 2) -> [t_integer(), t_integer()]; arg_types(erlang, 'rem', 2) -> [t_integer(), t_integer()]; arg_types(erlang, 'and', 2) -> [t_boolean(), t_boolean()]; arg_types(erlang, 'or', 2) -> [t_boolean(), t_boolean()]; arg_types(erlang, 'xor', 2) -> [t_boolean(), t_boolean()]; arg_types(erlang, 'not', 1) -> [t_boolean()]; arg_types(erlang, 'band', 2) -> [t_integer(), t_integer()]; arg_types(erlang, 'bor', 2) -> [t_integer(), t_integer()]; arg_types(erlang, 'bxor', 2) -> [t_integer(), t_integer()]; arg_types(erlang, 'bsr', 2) -> [t_integer(), t_integer()]; arg_types(erlang, 'bsl', 2) -> [t_integer(), t_integer()]; arg_types(erlang, 'bnot', 1) -> [t_integer()]; %% Guard bif, needs to be here. arg_types(erlang, abs, 1) -> [t_number()]; arg_types(erlang, append, 2) -> arg_types(erlang, '++', 2); arg_types(erlang, apply, 2) -> [t_sup(t_tuple([t_module(), t_atom()]), t_fun()), t_list()]; arg_types(erlang, apply, 3) -> [t_sup(t_atom(), t_tuple()), t_atom(), t_list()]; %% Guard bif, needs to be here. arg_types(erlang, binary_part, 2) -> [t_binary(), t_tuple([t_non_neg_integer(), t_integer()])]; %% Guard bif, needs to be here. arg_types(erlang, binary_part, 3) -> [t_binary(), t_non_neg_integer(), t_integer()]; %% Guard bif, needs to be here. arg_types(erlang, bit_size, 1) -> [t_bitstr()]; %% Guard bif, needs to be here. arg_types(erlang, byte_size, 1) -> [t_binary()]; arg_types(erlang, disconnect_node, 1) -> [t_node()]; arg_types(erlang, halt, 0) -> []; arg_types(erlang, halt, 1) -> [t_sup(t_non_neg_fixnum(), t_string())]; arg_types(erlang, error, 1) -> [t_any()]; arg_types(erlang, error, 2) -> [t_any(), t_list()]; arg_types(erlang, exit, 1) -> [t_any()]; %% Guard bif, needs to be here. arg_types(erlang, element, 2) -> [t_pos_fixnum(), t_tuple()]; %% Guard bif, needs to be here. arg_types(erlang, float, 1) -> [t_number()]; arg_types(erlang, fun_info, 1) -> [t_fun()]; arg_types(erlang, get_cookie, 0) -> []; %% Guard bif, needs to be here. arg_types(erlang, hd, 1) -> [t_cons()]; arg_types(erlang, info, 1) -> arg_types(erlang, system_info, 1); % alias arg_types(erlang, integer_to_list, 2) -> [t_integer(), t_from_range(2, 36)]; arg_types(erlang, is_atom, 1) -> [t_any()]; arg_types(erlang, is_binary, 1) -> [t_any()]; arg_types(erlang, is_bitstring, 1) -> [t_any()]; arg_types(erlang, is_boolean, 1) -> [t_any()]; arg_types(erlang, is_float, 1) -> [t_any()]; arg_types(erlang, is_function, 1) -> [t_any()]; arg_types(erlang, is_function, 2) -> [t_any(), t_arity()]; arg_types(erlang, is_integer, 1) -> [t_any()]; arg_types(erlang, is_list, 1) -> [t_any()]; arg_types(erlang, is_number, 1) -> [t_any()]; arg_types(erlang, is_pid, 1) -> [t_any()]; arg_types(erlang, is_port, 1) -> [t_any()]; arg_types(erlang, is_record, 2) -> [t_any(), t_atom()]; arg_types(erlang, is_record, 3) -> [t_any(), t_atom(), t_pos_fixnum()]; arg_types(erlang, is_reference, 1) -> [t_any()]; arg_types(erlang, is_tuple, 1) -> [t_any()]; %% Guard bif, needs to be here. arg_types(erlang, length, 1) -> [t_list()]; arg_types(erlang, list_to_integer, 2) -> [t_list(t_byte()), t_from_range(2, 36)]; 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, memory, 0) -> []; arg_types(erlang, nif_error, 1) -> [t_any()]; arg_types(erlang, nif_error, 2) -> [t_any(), t_list()]; %% Guard bif, needs to be here. arg_types(erlang, node, 0) -> []; %% Guard bif, needs to be here. arg_types(erlang, node, 1) -> [t_identifier()]; arg_types(erlang, nodes, 0) -> []; 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_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'])]; %% Guard bif, needs to be here. arg_types(erlang, round, 1) -> [t_number()]; %% Guard bif, needs to be here. arg_types(erlang, self, 0) -> []; arg_types(erlang, set_cookie, 2) -> [t_node(), t_atom()]; arg_types(erlang, setelement, 3) -> [t_pos_integer(), t_tuple(), t_any()]; %% Guard bif, needs to be here. 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, 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, 4) -> arg_types(erlang, spawn, 4); % same arg_types(erlang, subtract, 2) -> arg_types(erlang, '--', 2); arg_types(erlang, suspend_process, 1) -> [t_pid()]; 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, throw, 1) -> [t_any()]; %% Guard bif, needs to be here. arg_types(erlang, tl, 1) -> [t_cons()]; %% Guard bif, needs to be here. arg_types(erlang, trunc, 1) -> [t_number()]; %% Guard bif, needs to be here. arg_types(erlang, tuple_size, 1) -> [t_tuple()]; arg_types(erlang, tuple_to_list, 1) -> [t_tuple()]; arg_types(erlang, yield, 0) -> []; %%------- ets ----------------------------------------------------------------- arg_types(ets, rename, 2) -> [t_atom(), t_atom()]; %%------- hipe_bifs ----------------------------------------------------------- arg_types(hipe_bifs, add_ref, 2) -> [t_mfa(), t_tuple([t_mfa(), t_integer(), t_sup(t_atom('call'), t_atom('load_mfa')), t_trampoline(), t_sup(t_atom('remote'), t_atom('local'))])]; arg_types(hipe_bifs, alloc_data, 2) -> [t_integer(), t_integer()]; arg_types(hipe_bifs, array, 2) -> [t_non_neg_fixnum(), t_immediate()]; arg_types(hipe_bifs, array_length, 1) -> [t_immarray()]; arg_types(hipe_bifs, array_sub, 2) -> [t_immarray(), t_non_neg_fixnum()]; arg_types(hipe_bifs, array_update, 3) -> [t_immarray(), t_non_neg_fixnum(), t_immediate()]; arg_types(hipe_bifs, atom_to_word, 1) -> [t_atom()]; arg_types(hipe_bifs, bif_address, 3) -> [t_atom(), t_atom(), t_arity()]; arg_types(hipe_bifs, bitarray, 2) -> [t_non_neg_fixnum(), t_boolean()]; arg_types(hipe_bifs, bitarray_sub, 2) -> [t_bitarray(), t_non_neg_fixnum()]; arg_types(hipe_bifs, bitarray_update, 3) -> [t_bytearray(), t_non_neg_fixnum(), t_boolean()]; arg_types(hipe_bifs, bytearray, 2) -> [t_non_neg_fixnum(), t_byte()]; arg_types(hipe_bifs, bytearray_sub, 2) -> [t_bytearray(), t_non_neg_fixnum()]; arg_types(hipe_bifs, bytearray_update, 3) -> [t_bytearray(), t_non_neg_fixnum(), t_byte()]; arg_types(hipe_bifs, call_count_clear, 1) -> [t_mfa()]; arg_types(hipe_bifs, call_count_get, 1) -> [t_mfa()]; arg_types(hipe_bifs, call_count_off, 1) -> [t_mfa()]; arg_types(hipe_bifs, call_count_on, 1) -> [t_mfa()]; arg_types(hipe_bifs, check_crc, 1) -> [t_crc32()]; arg_types(hipe_bifs, enter_code, 2) -> [t_binary(), t_sup(t_nil(), t_tuple())]; arg_types(hipe_bifs, enter_sdesc, 1) -> [t_tuple([t_integer(), t_integer(), t_integer(), t_integer(), t_integer(), t_mfa()])]; arg_types(hipe_bifs, find_na_or_make_stub, 2) -> [t_mfa(), t_boolean()]; arg_types(hipe_bifs, fun_to_address, 1) -> [t_mfa()]; %% arg_types(hipe_bifs, get_emu_address, 1) -> %% [t_mfa()]; arg_types(hipe_bifs, get_rts_param, 1) -> [t_fixnum()]; arg_types(hipe_bifs, invalidate_funinfo_native_addresses, 1) -> [t_list(t_mfa())]; arg_types(hipe_bifs, make_fe, 3) -> [t_integer(), t_atom(), t_tuple([t_integer(), t_integer(), t_integer()])]; %% arg_types(hipe_bifs, make_native_stub, 2) -> %% [t_integer(), t_arity()]; arg_types(hipe_bifs, mark_referred_from, 1) -> [t_mfa()]; arg_types(hipe_bifs, merge_term, 1) -> [t_any()]; arg_types(hipe_bifs, patch_call, 3) -> [t_integer(), t_integer(), t_trampoline()]; arg_types(hipe_bifs, patch_insn, 3) -> [t_integer(), t_integer(), t_insn_type()]; arg_types(hipe_bifs, primop_address, 1) -> [t_atom()]; arg_types(hipe_bifs, redirect_referred_from, 1) -> [t_mfa()]; arg_types(hipe_bifs, ref, 1) -> [t_immediate()]; arg_types(hipe_bifs, ref_get, 1) -> [t_hiperef()]; arg_types(hipe_bifs, ref_set, 2) -> [t_hiperef(), t_immediate()]; arg_types(hipe_bifs, remove_refs_from, 1) -> [t_mfa()]; arg_types(hipe_bifs, set_funinfo_native_address, 3) -> arg_types(hipe_bifs, set_native_address, 3); arg_types(hipe_bifs, set_native_address, 3) -> [t_mfa(), t_integer(), t_boolean()]; arg_types(hipe_bifs, system_crc, 1) -> [t_crc32()]; arg_types(hipe_bifs, term_to_word, 1) -> [t_any()]; arg_types(hipe_bifs, update_code_size, 3) -> [t_atom(), t_sup(t_nil(), t_binary()), t_integer()]; arg_types(hipe_bifs, write_u8, 2) -> [t_integer(), t_byte()]; arg_types(hipe_bifs, write_u32, 2) -> [t_integer(), t_integer()]; arg_types(hipe_bifs, write_u64, 2) -> [t_integer(), t_integer()]; %%------- lists --------------------------------------------------------------- arg_types(lists, all, 2) -> [t_fun([t_any()], t_boolean()), t_list()]; arg_types(lists, any, 2) -> [t_fun([t_any()], t_boolean()), t_list()]; arg_types(lists, append, 2) -> arg_types(erlang, '++', 2); % alias arg_types(lists, delete, 2) -> [t_any(), t_maybe_improper_list()]; arg_types(lists, dropwhile, 2) -> [t_fun([t_any()], t_boolean()), t_maybe_improper_list()]; arg_types(lists, filter, 2) -> [t_fun([t_any()], t_boolean()), t_list()]; arg_types(lists, flatten, 1) -> [t_list()]; arg_types(lists, flatmap, 2) -> [t_fun([t_any()], t_list()), t_list()]; arg_types(lists, foreach, 2) -> [t_fun([t_any()], t_any()), t_list()]; arg_types(lists, foldl, 3) -> [t_fun([t_any(), t_any()], t_any()), t_any(), t_list()]; arg_types(lists, foldr, 3) -> arg_types(lists, foldl, 3); % same arg_types(lists, keydelete, 3) -> [t_any(), t_pos_fixnum(), t_maybe_improper_list()]; % t_list(t_tuple())]; arg_types(lists, keyfind, 3) -> arg_types(lists, keysearch, 3); arg_types(lists, keymap, 3) -> [t_fun([t_any()], t_any()), t_pos_fixnum(), t_list(t_tuple())]; arg_types(lists, keymember, 3) -> [t_any(), t_pos_fixnum(), t_maybe_improper_list()]; % t_list(t_tuple()); arg_types(lists, keymerge, 3) -> [t_pos_fixnum(), t_list(t_tuple()), t_list(t_tuple())]; arg_types(lists, keyreplace, 4) -> [t_any(), t_pos_fixnum(), t_maybe_improper_list(), t_tuple()]; % t_list(t_tuple())]; arg_types(lists, keysearch, 3) -> [t_any(), t_pos_fixnum(), t_maybe_improper_list()]; % t_list(t_tuple())]; arg_types(lists, keysort, 2) -> [t_pos_fixnum(), t_list(t_tuple())]; arg_types(lists, last, 1) -> [t_nonempty_list()]; arg_types(lists, map, 2) -> [t_fun([t_any()], t_any()), t_list()]; arg_types(lists, mapfoldl, 3) -> [t_fun([t_any(), t_any()], t_tuple([t_any(), t_any()])), t_any(), t_list()]; arg_types(lists, mapfoldr, 3) -> arg_types(lists, mapfoldl, 3); % same arg_types(lists, max, 1) -> [t_nonempty_list()]; arg_types(lists, member, 2) -> [t_any(), t_list()]; %% arg_types(lists, merge, 1) -> %% [t_list(t_list())]; arg_types(lists, merge, 2) -> [t_list(), t_list()]; %% arg_types(lists, merge, 3) -> %% [t_fun([t_any(), t_any()], t_boolean()), t_list(), t_list()]; %% arg_types(lists, merge3, 3) -> %% [t_list(), t_list(), t_list()]; arg_types(lists, min, 1) -> [t_nonempty_list()]; arg_types(lists, nth, 2) -> [t_pos_fixnum(), t_nonempty_list()]; arg_types(lists, nthtail, 2) -> [t_non_neg_fixnum(), t_nonempty_list()]; arg_types(lists, partition, 2) -> arg_types(lists, filter, 2); % same arg_types(lists, reverse, 1) -> [t_list()]; arg_types(lists, reverse, 2) -> [t_list(), t_any()]; arg_types(lists, sort, 1) -> [t_list()]; arg_types(lists, sort, 2) -> [t_fun([t_any(), t_any()], t_boolean()), t_list()]; arg_types(lists, split, 2) -> [t_non_neg_fixnum(), t_maybe_improper_list()]; % do not lie in 2nd arg arg_types(lists, splitwith, 2) -> [t_fun([t_any()], t_boolean()), t_maybe_improper_list()]; arg_types(lists, subtract, 2) -> arg_types(erlang, '--', 2); % alias arg_types(lists, takewhile, 2) -> [t_fun([t_any()], t_boolean()), t_maybe_improper_list()]; arg_types(lists, usort, 1) -> arg_types(lists, sort, 1); % same arg_types(lists, usort, 2) -> arg_types(lists, sort, 2); arg_types(lists, unzip, 1) -> [t_list(t_tuple(2))]; arg_types(lists, unzip3, 1) -> [t_list(t_tuple(3))]; arg_types(lists, zip, 2) -> [t_list(), t_list()]; arg_types(lists, zip3, 3) -> [t_list(), t_list(), t_list()]; arg_types(lists, zipwith, 3) -> [t_fun([t_any(), t_any()], t_any()), t_list(), t_list()]; arg_types(lists, zipwith3, 4) -> [t_fun([t_any(), t_any(), t_any()], t_any()), t_list(), t_list(), t_list()]; %%------- string -------------------------------------------------------------- arg_types(string, chars, 2) -> [t_char(), t_non_neg_integer()]; arg_types(string, chars, 3) -> [t_char(), t_non_neg_integer(), t_any()]; %%----------------------------------------------------------------------------- arg_types(M, F, A) when is_atom(M), is_atom(F), is_integer(A), 0 =< A, A =< 255 -> unknown. % safe approximation for all functions. -spec is_known(atom(), atom(), arity()) -> boolean(). is_known(M, F, A) -> arg_types(M, F, A) =/= unknown. -spec structure_inspecting_args(atom(), atom(), arity()) -> [1..255]. structure_inspecting_args(erlang, element, 2) -> [2]; structure_inspecting_args(erlang, is_atom, 1) -> [1]; structure_inspecting_args(erlang, is_boolean, 1) -> [1]; structure_inspecting_args(erlang, is_binary, 1) -> [1]; structure_inspecting_args(erlang, is_bitstring, 1) -> [1]; structure_inspecting_args(erlang, is_float, 1) -> [1]; structure_inspecting_args(erlang, is_function, 1) -> [1]; structure_inspecting_args(erlang, is_integer, 1) -> [1]; structure_inspecting_args(erlang, is_list, 1) -> [1]; structure_inspecting_args(erlang, is_number, 1) -> [1]; structure_inspecting_args(erlang, is_pid, 1) -> [1]; structure_inspecting_args(erlang, is_port, 1) -> [1]; structure_inspecting_args(erlang, is_reference, 1) -> [1]; structure_inspecting_args(erlang, is_tuple, 1) -> [1]; structure_inspecting_args(erlang, length, 1) -> [1]; %%structure_inspecting_args(erlang, setelement, 3) -> [2]. structure_inspecting_args(_, _, _) -> []. % XXX: assume no arg needs inspection check_fun_application(Fun, Args) -> case t_is_fun(Fun) of true -> case t_fun_args(Fun) of unknown -> case t_is_none_or_unit(t_fun_range(Fun)) of true -> error; false -> ok end; FunDom when length(FunDom) =:= length(Args) -> case any_is_none_or_unit(inf_lists(FunDom, Args)) of true -> error; false -> case t_is_none_or_unit(t_fun_range(Fun)) of true -> error; false -> ok end end; _ -> error end; false -> error end. %% ===================================================================== %% Some basic types used in various parts of the system %% ===================================================================== t_endian() -> t_sup(t_atom('big'), t_atom('little')). %% ===================================================================== %% These are used for the built-in functions of 'erlang' %% ===================================================================== t_crc32() -> t_non_neg_integer(). t_sequential_tracer() -> t_sup([t_atom('false'), t_pid(), t_port()]). t_system_cpu_topology() -> t_sup(t_atom('undefined'), t_system_cpu_topology_level_entry_list()). t_system_cpu_topology_level_entry_list() -> t_list(t_system_cpu_topology_level_entry()). t_system_cpu_topology_level_entry() -> t_sup(t_tuple([t_system_cpu_topology_level_tag(), t_system_cpu_topology_sublevel_entry()]), t_tuple([t_system_cpu_topology_level_tag(), t_system_cpu_topology_info_list(), t_system_cpu_topology_sublevel_entry()])). t_system_cpu_topology_sublevel_entry() -> t_sup(t_system_cpu_topology_logical_cpu_id(), t_list(t_tuple())). % approximation t_system_cpu_topology_level_tag() -> t_atoms(['core', 'node', 'processor', 'thread']). t_system_cpu_topology_logical_cpu_id() -> t_tuple([t_atom('logical'), t_non_neg_fixnum()]). t_system_cpu_topology_info_list() -> t_nil(). % it may be extended in the future t_internal_cpu_topology() -> %% Internal undocumented type t_sup(t_list(t_tuple([t_atom('cpu'), t_non_neg_fixnum(), t_non_neg_fixnum(), t_non_neg_fixnum(), t_non_neg_fixnum(), t_non_neg_fixnum(), t_non_neg_fixnum()])), t_atom('undefined')). t_scheduler_bind_type_results() -> t_sup([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_system_multi_scheduling() -> t_sup([t_atom('blocked'), t_atom('disabled'), t_atom('enabled')]). %% ===================================================================== %% These are used for the built-in functions of 'hipe_bifs' %% ===================================================================== t_trampoline() -> t_sup(t_nil(), t_integer()). t_immediate() -> t_sup([t_nil(), t_atom(), t_fixnum()]). t_immarray() -> t_integer(). %% abstract data type t_hiperef() -> t_immarray(). t_bitarray() -> t_bitstr(). t_bytearray() -> t_binary(). t_insn_type() -> t_sup([% t_atom('call'), t_atom('load_mfa'), t_atom('x86_abs_pcrel'), t_atom('atom'), t_atom('constant'), t_atom('c_const'), t_atom('closure')]). %% ===================================================================== %% Some testing code for ranges below %% ===================================================================== -ifdef(DO_ERL_BIF_TYPES_TEST). test() -> put(hipe_target_arch, amd64), Bsl1 = type(erlang, 'bsl', 2, [t_from_range(1, 299), t_from_range(-4, 22)]), Bsl2 = type(erlang, 'bsl', 2), Bsl3 = type(erlang, 'bsl', 2, [t_from_range(1, 299), t_atom('pelle')]), io:format("Bsl ~p ~p ~p~n", [Bsl1, Bsl2, Bsl3]), Add1 = type(erlang, '+', 2, [t_from_range(1, 299), t_from_range(-4, 22)]), Add2 = type(erlang, '+', 2), Add3 = type(erlang, '+', 2, [t_from_range(1, 299), t_atom('pelle')]), io:format("Add ~p ~p ~p~n", [Add1, Add2, Add3]), Band1 = type(erlang, 'band', 2, [t_from_range(1, 29), t_from_range(34, 36)]), Band2 = type(erlang, 'band', 2), Band3 = type(erlang, 'band', 2, [t_from_range(1, 299), t_atom('pelle')]), io:format("band ~p ~p ~p~n", [Band1, Band2, Band3]), Bor1 = type(erlang, 'bor', 2, [t_from_range(1, 29), t_from_range(8, 11)]), Bor2 = type(erlang, 'bor', 2), Bor3 = type(erlang, 'bor', 2, [t_from_range(1, 299), t_atom('pelle')]), io:format("bor ~p ~p ~p~n", [Bor1, Bor2, Bor3]), io:format("inf_?"), pos_inf = infinity_max([1, 4, 51, pos_inf]), -12 = infinity_min([1, 142, -4, -12]), neg_inf = infinity_max([neg_inf]), io:format("width"), 4 = width({7, 9}), pos_inf = width({neg_inf, 100}), pos_inf = width({1, pos_inf}), 3 = width({-8, 7}), 0 = width({-1, 0}), io:format("arith * "), Mult1 = t_from_range(0, 12), Mult2 = t_from_range(-21, 7), Mult1 = type(erlang, '*', 2, [t_from_range(2,3), t_from_range(0,4)]), Mult2 = type(erlang, '*', 2, [t_from_range(-7,-1), t_from_range(-1,3)]), ok. -endif.