aboutsummaryrefslogtreecommitdiffstats
path: root/lib/dialyzer/src
diff options
context:
space:
mode:
authorErlang/OTP <[email protected]>2009-11-20 14:54:40 +0000
committerErlang/OTP <[email protected]>2009-11-20 14:54:40 +0000
commit84adefa331c4159d432d22840663c38f155cd4c1 (patch)
treebff9a9c66adda4df2106dfd0e5c053ab182a12bd /lib/dialyzer/src
downloadotp-84adefa331c4159d432d22840663c38f155cd4c1.tar.gz
otp-84adefa331c4159d432d22840663c38f155cd4c1.tar.bz2
otp-84adefa331c4159d432d22840663c38f155cd4c1.zip
The R13B03 release.OTP_R13B03
Diffstat (limited to 'lib/dialyzer/src')
-rw-r--r--lib/dialyzer/src/Makefile159
-rw-r--r--lib/dialyzer/src/dialyzer.app.src42
-rw-r--r--lib/dialyzer/src/dialyzer.appup.src20
-rw-r--r--lib/dialyzer/src/dialyzer.erl480
-rw-r--r--lib/dialyzer/src/dialyzer.hrl146
-rw-r--r--lib/dialyzer/src/dialyzer_analysis_callgraph.erl530
-rw-r--r--lib/dialyzer/src/dialyzer_callgraph.erl697
-rw-r--r--lib/dialyzer/src/dialyzer_cl.erl717
-rw-r--r--lib/dialyzer/src/dialyzer_cl_parse.erl448
-rw-r--r--lib/dialyzer/src/dialyzer_codeserver.erl282
-rw-r--r--lib/dialyzer/src/dialyzer_contracts.erl492
-rw-r--r--lib/dialyzer/src/dialyzer_dataflow.erl3468
-rw-r--r--lib/dialyzer/src/dialyzer_dep.erl580
-rw-r--r--lib/dialyzer/src/dialyzer_explanation.erl52
-rw-r--r--lib/dialyzer/src/dialyzer_gui.erl1349
-rw-r--r--lib/dialyzer/src/dialyzer_gui_wx.erl1243
-rw-r--r--lib/dialyzer/src/dialyzer_gui_wx.hrl112
-rw-r--r--lib/dialyzer/src/dialyzer_options.erl269
-rw-r--r--lib/dialyzer/src/dialyzer_plt.erl576
-rw-r--r--lib/dialyzer/src/dialyzer_races.erl2426
-rw-r--r--lib/dialyzer/src/dialyzer_succ_typings.erl540
-rw-r--r--lib/dialyzer/src/dialyzer_typesig.erl2756
-rw-r--r--lib/dialyzer/src/dialyzer_utils.erl458
23 files changed, 17842 insertions, 0 deletions
diff --git a/lib/dialyzer/src/Makefile b/lib/dialyzer/src/Makefile
new file mode 100644
index 0000000000..ffdc0c6dcd
--- /dev/null
+++ b/lib/dialyzer/src/Makefile
@@ -0,0 +1,159 @@
+#
+# %CopyrightBegin%
+#
+# Copyright Ericsson AB 2006-2009. 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%
+#
+#=============================================================================
+#
+# File: lib/dialyzer/src/Makefile
+# Authors: Kostis Sagonas and Tobias Lindahl
+#
+#=============================================================================
+
+include $(ERL_TOP)/make/target.mk
+include $(ERL_TOP)/make/$(TARGET)/otp.mk
+
+# ----------------------------------------------------
+# Application version
+# ----------------------------------------------------
+include ../vsn.mk
+VSN=$(DIALYZER_VSN)
+
+# ----------------------------------------------------
+# Release directory specification
+# ----------------------------------------------------
+RELSYSDIR = $(RELEASE_PATH)/lib/dialyzer-$(VSN)
+
+# ----------------------------------------------------
+# Orientation information
+# ----------------------------------------------------
+DIALYZER_DIR = $(ERL_TOP)/lib/dialyzer
+
+# ----------------------------------------------------
+# Target Specs
+# ----------------------------------------------------
+MODULES = \
+ dialyzer \
+ dialyzer_analysis_callgraph \
+ dialyzer_callgraph \
+ dialyzer_cl \
+ dialyzer_cl_parse \
+ dialyzer_codeserver \
+ dialyzer_contracts \
+ dialyzer_dataflow \
+ dialyzer_dep \
+ dialyzer_explanation \
+ dialyzer_gui \
+ dialyzer_gui_wx \
+ dialyzer_options \
+ dialyzer_plt \
+ dialyzer_races \
+ dialyzer_succ_typings \
+ dialyzer_typesig \
+ dialyzer_utils
+
+HRL_FILES= dialyzer.hrl dialyzer_gui_wx.hrl
+ERL_FILES= $(MODULES:%=%.erl)
+INSTALL_FILES= $(MODULES:%=$(EBIN)/%.$(EMULATOR)) $(APP_TARGET) $(APPUP_TARGET)
+TARGET_FILES= $(INSTALL_FILES)
+
+APP_FILE= dialyzer.app
+APP_SRC= $(APP_FILE).src
+APP_TARGET= $(EBIN)/$(APP_FILE)
+
+APPUP_FILE= dialyzer.appup
+APPUP_SRC= $(APPUP_FILE).src
+APPUP_TARGET= $(EBIN)/$(APPUP_FILE)
+
+# ----------------------------------------------------
+# FLAGS
+# ----------------------------------------------------
+
+ifeq ($(NATIVE_LIBS_ENABLED),yes)
+ERL_COMPILE_FLAGS += +native
+endif
+ERL_COMPILE_FLAGS += +warn_exported_vars +warn_unused_import +warn_untyped_record +warn_missing_spec
+
+# ----------------------------------------------------
+# Targets
+# ----------------------------------------------------
+
+debug opt: $(TARGET_FILES)
+
+docs:
+
+clean:
+ rm -f $(TARGET_FILES)
+ rm -f core
+
+# ----------------------------------------------------
+# Special Build Targets
+# ----------------------------------------------------
+
+$(EBIN)/dialyzer_cl_parse.$(EMULATOR): dialyzer_cl_parse.erl ../vsn.mk
+ erlc -W $(ERL_COMPILE_FLAGS) -DVSN="\"v$(VSN)\"" -o$(EBIN) dialyzer_cl_parse.erl
+
+$(EBIN)/dialyzer_plt.$(EMULATOR): dialyzer_plt.erl ../vsn.mk
+ erlc -W $(ERL_COMPILE_FLAGS) -DVSN="\"v$(VSN)\"" -o$(EBIN) dialyzer_plt.erl
+
+$(EBIN)/dialyzer_gui.$(EMULATOR): dialyzer_gui.erl ../vsn.mk
+ erlc -W $(ERL_COMPILE_FLAGS) -DVSN="\"v$(VSN)\"" -o$(EBIN) dialyzer_gui.erl
+
+$(EBIN)/dialyzer_gui_wx.$(EMULATOR): dialyzer_gui_wx.erl ../vsn.mk
+ erlc -W $(ERL_COMPILE_FLAGS) -DVSN="\"v$(VSN)\"" -o$(EBIN) dialyzer_gui_wx.erl
+
+$(APP_TARGET): $(APP_SRC) ../vsn.mk
+ sed -e 's;%VSN%;$(VSN);' $< > $@
+
+$(APPUP_TARGET): $(APPUP_SRC) ../vsn.mk
+ sed -e 's;%VSN%;$(VSN);' $< > $@
+
+# ---------------------------------------------------------------------
+# dependencies -- I wish they were somehow automatically generated
+# ---------------------------------------------------------------------
+
+$(EBIN)/dialyzer.beam: dialyzer.hrl
+$(EBIN)/dialyzer_analysis_callgraph.beam: dialyzer.hrl
+$(EBIN)/dialyzer_callgraph.beam: dialyzer.hrl
+$(EBIN)/dialyzer_cl.beam: dialyzer.hrl ../../kernel/include/file.hrl
+$(EBIN)/dialyzer_cl_parse.beam: dialyzer.hrl
+$(EBIN)/dialyzer_codeserver.beam: dialyzer.hrl
+$(EBIN)/dialyzer_contracts.beam: dialyzer.hrl
+$(EBIN)/dialyzer_dataflow.beam: dialyzer.hrl
+$(EBIN)/dialyzer_dep.beam: dialyzer.hrl
+$(EBIN)/dialyzer_explanation.beam: dialyzer.hrl
+$(EBIN)/dialyzer_gui.beam: dialyzer.hrl
+$(EBIN)/dialyzer_gui_wx.beam: dialyzer.hrl dialyzer_gui_wx.hrl
+$(EBIN)/dialyzer_options.beam: dialyzer.hrl
+$(EBIN)/dialyzer_plt.beam: dialyzer.hrl
+$(EBIN)/dialyzer_races.beam: dialyzer.hrl
+$(EBIN)/dialyzer_succ_typings.beam: dialyzer.hrl
+$(EBIN)/dialyzer_typesig.beam: dialyzer.hrl
+$(EBIN)/dialyzer_utils.beam: dialyzer.hrl
+
+# ----------------------------------------------------
+# Release Target
+# ----------------------------------------------------
+include $(ERL_TOP)/make/otp_release_targets.mk
+
+release_spec: opt
+ $(INSTALL_DIR) $(RELSYSDIR)/src
+ $(INSTALL_DATA) $(ERL_FILES) $(HRL_FILES) $(EXTRA_FILES) \
+ $(RELSYSDIR)/src
+ $(INSTALL_DIR) $(RELSYSDIR)/ebin
+ $(INSTALL_DATA) $(INSTALL_FILES) $(RELSYSDIR)/ebin
+
+release_docs_spec:
diff --git a/lib/dialyzer/src/dialyzer.app.src b/lib/dialyzer/src/dialyzer.app.src
new file mode 100644
index 0000000000..c1d109812c
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer.app.src
@@ -0,0 +1,42 @@
+%% This is an -*- erlang -*- file.
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2006-2009. 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%
+%%
+
+{application, dialyzer,
+ [{description, "DIscrepancy AnaLYZer of ERlang programs, version %VSN%"},
+ {vsn, "%VSN%"},
+ {modules, [dialyzer,
+ dialyzer_analysis_callgraph,
+ dialyzer_callgraph,
+ dialyzer_cl,
+ dialyzer_cl_parse,
+ dialyzer_codeserver,
+ dialyzer_contracts,
+ dialyzer_dataflow,
+ dialyzer_dep,
+ dialyzer_gui,
+ dialyzer_options,
+ dialyzer_plt,
+ dialyzer_races,
+ dialyzer_succ_typings,
+ dialyzer_typesig,
+ dialyzer_utils]},
+ {registered, []},
+ {applications, [compiler, gs, hipe, kernel, stdlib]},
+ {env, []}]}.
diff --git a/lib/dialyzer/src/dialyzer.appup.src b/lib/dialyzer/src/dialyzer.appup.src
new file mode 100644
index 0000000000..26d14ee8f4
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer.appup.src
@@ -0,0 +1,20 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2006-2009. 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%
+%%
+
+{"%VSN%",[],[]}.
diff --git a/lib/dialyzer/src/dialyzer.erl b/lib/dialyzer/src/dialyzer.erl
new file mode 100644
index 0000000000..c1897ed892
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer.erl
@@ -0,0 +1,480 @@
+%% -*- erlang-indent-level: 2 -*-
+%%-----------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2006-2009. 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%
+%%
+
+%%%-------------------------------------------------------------------
+%%% File : dialyzer.erl
+%%% Authors : Tobias Lindahl <[email protected]>
+%%% Kostis Sagonas <[email protected]>
+%%% Description : This is the interface for the Dialyzer tool.
+%%%
+%%% Created : 27 Apr 2004 by Tobias Lindahl <[email protected]>
+%%%-------------------------------------------------------------------
+
+-module(dialyzer).
+
+%%--------------------------------------------------------------------
+%% NOTE: Only functions exported by this module are available to
+%% other applications.
+%%--------------------------------------------------------------------
+-export([plain_cl/0,
+ run/1,
+ gui/0,
+ gui/1,
+ plt_info/1,
+ format_warning/1]).
+
+-include("dialyzer.hrl").
+
+%%--------------------------------------------------------------------
+%% Interfaces:
+%% - plain_cl/0 : to be used ONLY by the dialyzer C program.
+%% - run/1: Erlang interface for a command line-like analysis
+%% - gui/0/1: Erlang interface for the gui.
+%% - format_warning/1: Get the string representation of a warning.
+%% - plt_info/1: Get information of the specified plt.
+%%--------------------------------------------------------------------
+
+-spec plain_cl() -> no_return().
+
+plain_cl() ->
+ case dialyzer_cl_parse:start() of
+ {check_init, Opts} ->
+ cl_halt(cl_check_init(Opts), Opts);
+ {plt_info, Opts} ->
+ cl_halt(cl_print_plt_info(Opts), Opts);
+ {{gui, Type}, Opts} ->
+ try check_gui_options(Opts)
+ catch throw:{dialyzer_error, Msg} -> cl_error(Msg)
+ end,
+ case Opts#options.check_plt of
+ true ->
+ case cl_check_init(Opts#options{get_warnings = false}) of
+ {ok, _} -> gui_halt(internal_gui(Type, Opts), Opts);
+ {error, _} = Error -> cl_halt(Error, Opts)
+ end;
+ false ->
+ gui_halt(internal_gui(Type, Opts), Opts)
+ end;
+ {cl, Opts} ->
+ case Opts#options.check_plt of
+ true ->
+ case cl_check_init(Opts#options{get_warnings = false}) of
+ {error, _} = Error -> cl_halt(Error, Opts);
+ {ok, _} -> cl_halt(cl(Opts), Opts)
+ end;
+ false ->
+ cl_halt(cl(Opts), Opts)
+ end;
+ {error, Msg} ->
+ cl_error(Msg)
+ end.
+
+cl_check_init(#options{analysis_type = AnalType} = Opts) ->
+ case AnalType of
+ plt_build -> {ok, ?RET_NOTHING_SUSPICIOUS};
+ plt_add -> {ok, ?RET_NOTHING_SUSPICIOUS};
+ plt_remove -> {ok, ?RET_NOTHING_SUSPICIOUS};
+ Other when Other =:= succ_typings; Other =:= plt_check ->
+ F = fun() ->
+ NewOpts = Opts#options{analysis_type = plt_check},
+ {Ret, _Warnings} = dialyzer_cl:start(NewOpts),
+ Ret
+ end,
+ doit(F)
+ end.
+
+cl_print_plt_info(Opts) ->
+ F = fun() ->
+ print_plt_info(Opts)
+ end,
+ doit(F).
+
+print_plt_info(#options{init_plt = PLT, output_file = OutputFile}) ->
+ String =
+ case dialyzer_plt:included_files(PLT) of
+ {ok, Files} ->
+ io_lib:format("The PLT ~s includes the following files:\n~p\n",
+ [PLT, Files]);
+ {error, read_error} ->
+ Msg = io_lib:format("Could not read the PLT file ~p\n", [PLT]),
+ throw({dialyzer_error, Msg});
+ {error, no_such_file} ->
+ Msg = io_lib:format("The PLT file ~p does not exist\n", [PLT]),
+ throw({dialyzer_error, Msg})
+ end,
+ case OutputFile =:= none of
+ true ->
+ io:format("~s", [String]),
+ ?RET_NOTHING_SUSPICIOUS;
+ false ->
+ case file:open(OutputFile, [write]) of
+ {ok, FileDesc} ->
+ io:format(FileDesc, "~s", [String]),
+ ok = file:close(FileDesc),
+ ?RET_NOTHING_SUSPICIOUS;
+ {error, Reason} ->
+ Msg1 = io_lib:format("Could not open output file ~p, Reason: ~p\n",
+ [OutputFile, Reason]),
+ throw({dialyzer_error, Msg1})
+ end
+ end.
+
+cl(Opts) ->
+ F = fun() ->
+ {Ret, _Warnings} = dialyzer_cl:start(Opts),
+ Ret
+ end,
+ doit(F).
+
+-spec run(dial_options()) -> [dial_warning()].
+
+run(Opts) ->
+ try dialyzer_options:build([{report_mode, quiet},
+ {erlang_mode, true}|Opts]) of
+ {error, Msg} ->
+ throw({dialyzer_error, Msg});
+ OptsRecord ->
+ case cl_check_init(OptsRecord) of
+ {ok, ?RET_NOTHING_SUSPICIOUS} ->
+ case dialyzer_cl:start(OptsRecord) of
+ {?RET_DISCREPANCIES, Warnings} -> Warnings;
+ {?RET_NOTHING_SUSPICIOUS, []} -> []
+ end;
+ {error, ErrorMsg1} ->
+ throw({dialyzer_error, ErrorMsg1})
+ end
+ catch
+ throw:{dialyzer_error, ErrorMsg} ->
+ erlang:error({dialyzer_error, lists:flatten(ErrorMsg)})
+ end.
+
+internal_gui(Type, OptsRecord) ->
+ F = fun() ->
+ case Type of
+ gs -> dialyzer_gui:start(OptsRecord);
+ wx -> dialyzer_gui_wx:start(OptsRecord)
+ end,
+ ?RET_NOTHING_SUSPICIOUS
+ end,
+ doit(F).
+
+-spec gui() -> 'ok'.
+
+gui() ->
+ gui([]).
+
+-spec gui(dial_options()) -> 'ok'.
+
+gui(Opts) ->
+ try dialyzer_options:build([{report_mode, quiet}|Opts]) of
+ {error, Msg} ->
+ throw({dialyzer_error, Msg});
+ OptsRecord ->
+ ok = check_gui_options(OptsRecord),
+ case cl_check_init(OptsRecord) of
+ {ok, ?RET_NOTHING_SUSPICIOUS} ->
+ F = fun() ->
+ dialyzer_gui:start(OptsRecord)
+ end,
+ case doit(F) of
+ {ok, _} -> ok;
+ {error, Msg} -> throw({dialyzer_error, Msg})
+ end;
+ {error, ErrorMsg1} ->
+ throw({dialyzer_error, ErrorMsg1})
+ end
+ catch
+ throw:{dialyzer_error, ErrorMsg} ->
+ erlang:error({dialyzer_error, lists:flatten(ErrorMsg)})
+ end.
+
+check_gui_options(#options{analysis_type = succ_typings}) ->
+ ok;
+check_gui_options(#options{analysis_type = Mode}) ->
+ Msg = io_lib:format("Analysis mode ~w is illegal in GUI mode", [Mode]),
+ throw({dialyzer_error, Msg}).
+
+-spec plt_info(file:filename()) ->
+ {'ok', [{'files', [file:filename()]}]} | {'error', atom()}.
+
+plt_info(Plt) ->
+ case dialyzer_plt:included_files(Plt) of
+ {ok, Files} -> {ok, [{files, Files}]};
+ Error -> Error
+ end.
+
+
+%%-----------
+%% Machinery
+%%-----------
+
+doit(F) ->
+ try
+ {ok, F()}
+ catch
+ throw:{dialyzer_error, Msg} ->
+ {error, lists:flatten(Msg)}
+ end.
+
+cl_error(Msg) ->
+ cl_halt({error, Msg}, #options{}).
+
+gui_halt(R, Opts) ->
+ cl_halt(R, Opts#options{report_mode = quiet}).
+
+-spec cl_halt({'ok',dial_ret()} | {'error',string()}, #options{}) -> no_return().
+
+cl_halt({ok, R = ?RET_NOTHING_SUSPICIOUS}, #options{report_mode = quiet}) ->
+ halt(R);
+cl_halt({ok, R = ?RET_DISCREPANCIES}, #options{report_mode = quiet}) ->
+ halt(R);
+cl_halt({ok, R = ?RET_NOTHING_SUSPICIOUS}, #options{}) ->
+ io:put_chars("done (passed successfully)\n"),
+ halt(R);
+cl_halt({ok, R = ?RET_DISCREPANCIES}, #options{output_file = Output}) ->
+ io:put_chars("done (warnings were emitted)\n"),
+ cl_check_log(Output),
+ halt(R);
+cl_halt({error, Msg1}, #options{output_file = Output}) ->
+ %% Msg2 = "dialyzer: Internal problems were encountered in the analysis",
+ io:format("\ndialyzer: ~s\n", [Msg1]),
+ cl_check_log(Output),
+ halt(?RET_INTERNAL_ERROR).
+
+-spec cl_check_log('none' | file:filename()) -> 'ok'.
+
+cl_check_log(none) ->
+ ok;
+cl_check_log(Output) ->
+ io:format(" Check output file `~s' for details\n", [Output]).
+
+-spec format_warning(dial_warning()) -> string().
+
+format_warning({_Tag, {File, Line}, Msg}) when is_list(File),
+ is_integer(Line) ->
+ BaseName = filename:basename(File),
+ String = lists:flatten(message_to_string(Msg)),
+ lists:flatten(io_lib:format("~s:~w: ~s", [BaseName, Line, String])).
+
+
+%%-----------------------------------------------------------------------------
+%% Message classification and pretty-printing below. Messages appear in
+%% categories and in more or less alphabetical ordering within each category.
+%%-----------------------------------------------------------------------------
+
+%%----- Warnings for general discrepancies ----------------
+message_to_string({apply, [Args, ArgNs, FailReason,
+ SigArgs, SigRet, Contract]}) ->
+ io_lib:format("Fun application with arguments ~s ", [Args]) ++
+ call_or_apply_to_string(ArgNs, FailReason, SigArgs, SigRet, Contract);
+message_to_string({app_call, [M, F, Args, Culprit, ExpectedType, FoundType]}) ->
+ io_lib:format("The call ~s:~s~s requires that ~s is of type ~s not ~s\n",
+ [M, F, Args, Culprit, ExpectedType, FoundType]);
+message_to_string({bin_construction, [Culprit, Size, Seg, Type]}) ->
+ io_lib:format("Binary construction will fail since the ~s field ~s in"
+ " segment ~s has type ~s\n", [Culprit, Size, Seg, Type]);
+message_to_string({call, [M, F, Args, ArgNs, FailReason,
+ SigArgs, SigRet, Contract]}) ->
+ io_lib:format("The call ~w:~w~s ", [M, F, Args]) ++
+ call_or_apply_to_string(ArgNs, FailReason, SigArgs, SigRet, Contract);
+message_to_string({call_to_missing, [M, F, A]}) ->
+ io_lib:format("Call to missing or unexported function ~w:~w/~w\n", [M, F, A]);
+message_to_string({exact_eq, [Type1, Op, Type2]}) ->
+ io_lib:format("The test ~s ~s ~s can never evaluate to 'true'\n",
+ [Type1, Op, Type2]);
+message_to_string({fun_app_args, [Args, Type]}) ->
+ io_lib:format("Fun application with arguments ~s will fail"
+ " since the function has type ~s\n", [Args, Type]);
+message_to_string({fun_app_no_fun, [Op, Type, Arity]}) ->
+ io_lib:format("Fun application will fail since ~s :: ~s"
+ " is not a function of arity ~w\n", [Op, Type, Arity]);
+message_to_string({guard_fail, []}) ->
+ "Clause guard cannot succeed.\n";
+message_to_string({guard_fail, [Arg1, Infix, Arg2]}) ->
+ io_lib:format("Guard test ~s ~s ~s can never succeed\n", [Arg1, Infix, Arg2]);
+message_to_string({guard_fail, [Guard, Args]}) ->
+ io_lib:format("Guard test ~w~s can never succeed\n", [Guard, Args]);
+message_to_string({guard_fail_pat, [Pat, Type]}) ->
+ io_lib:format("Clause guard cannot succeed. The ~s was matched"
+ " against the type ~s\n", [Pat, Type]);
+message_to_string({improper_list_constr, [TlType]}) ->
+ io_lib:format("Cons will produce an improper list"
+ " since its 2nd argument is ~s\n", [TlType]);
+message_to_string({no_return, [Type|Name]}) ->
+ NameString =
+ case Name of
+ [] -> "The created fun ";
+ [F, A] -> io_lib:format("Function ~w/~w ", [F, A])
+ end,
+ case Type of
+ no_match -> NameString ++ "has no clauses that will ever match\n";
+ only_explicit -> NameString ++ "only terminates with explicit exception\n";
+ only_normal -> NameString ++ "has no local return\n";
+ both -> NameString ++ "has no local return\n"
+ end;
+message_to_string({record_constr, [Types, Name]}) ->
+ io_lib:format("Record construction ~s violates the"
+ " declared type for #~w{}\n", [Types, Name]);
+message_to_string({record_constr, [Name, Field, Type]}) ->
+ io_lib:format("Record construction violates the declared type for #~w{}"
+ " since ~s cannot be of type ~s\n", [Name, Field, Type]);
+message_to_string({record_matching, [String, Name]}) ->
+ io_lib:format("The ~s violates the"
+ " declared type for #~w{}\n", [String, Name]);
+message_to_string({pattern_match, [Pat, Type]}) ->
+ io_lib:format("The ~s can never match the type ~s\n", [Pat, Type]);
+message_to_string({pattern_match_cov, [Pat, Type]}) ->
+ io_lib:format("The ~s can never match since previous"
+ " clauses completely covered the type ~s\n",
+ [Pat, Type]);
+message_to_string({unmatched_return, [Type]}) ->
+ io_lib:format("Expression produces a value of type ~s,"
+ " but this value is unmatched\n", [Type]);
+message_to_string({unused_fun, []}) ->
+ io_lib:format("Function will never be called\n", []);
+message_to_string({unused_fun, [F, A]}) ->
+ io_lib:format("Function ~w/~w will never be called\n", [F, A]);
+%%----- Warnings for specs and contracts -------------------
+message_to_string({contract_diff, [M, F, _A, Contract, Sig]}) ->
+ io_lib:format("Type specification ~w:~w~s"
+ " is not equal to the success typing: ~w:~w~s\n",
+ [M, F, Contract, M, F, Sig]);
+message_to_string({contract_subtype, [M, F, _A, Contract, Sig]}) ->
+ io_lib:format("Type specification ~w:~w~s"
+ " is a subtype of the success typing: ~w:~w~s\n",
+ [M, F, Contract, M, F, Sig]);
+message_to_string({contract_supertype, [M, F, _A, Contract, Sig]}) ->
+ io_lib:format("Type specification ~w:~w~s"
+ " is a supertype of the success typing: ~w:~w~s\n",
+ [M, F, Contract, M, F, Sig]);
+message_to_string({invalid_contract, [M, F, A, Sig]}) ->
+ io_lib:format("Invalid type specification for function ~w:~w/~w."
+ " The success typing is ~s\n", [M, F, A, Sig]);
+message_to_string({extra_range, [M, F, A, ExtraRanges, SigRange]}) ->
+ io_lib:format("The specification for ~w:~w/~w states that the function"
+ " might also return ~s but the inferred return is ~s\n",
+ [M, F, A, ExtraRanges, SigRange]);
+message_to_string({overlapping_contract, []}) ->
+ "Overloaded contract has overlapping domains;"
+ " such contracts are currently unsupported and are simply ignored\n";
+message_to_string({spec_missing_fun, [M, F, A]}) ->
+ io_lib:format("Contract for function that does not exist: ~w:~w/~w\n",
+ [M, F, A]);
+%%----- Warnings for opaque type violations -------------------
+message_to_string({call_with_opaque, [M, F, Args, ArgNs, ExpArgs]}) ->
+ io_lib:format("The call ~w:~w~s contains ~s when ~s\n",
+ [M, F, Args, form_positions(ArgNs), form_expected(ExpArgs)]);
+message_to_string({call_without_opaque, [M, F, Args, ExpectedTriples]}) ->
+ io_lib:format("The call ~w:~w~s does not have ~s\n",
+ [M, F, Args, form_expected_without_opaque(ExpectedTriples)]);
+message_to_string({opaque_eq, [Type, _Op, OpaqueType]}) ->
+ io_lib:format("Attempt to test for equality between a term of type ~s"
+ " and a term of opaque type ~s\n", [Type, OpaqueType]);
+message_to_string({opaque_guard, [Guard, Args]}) ->
+ io_lib:format("Guard test ~w~s breaks the opaqueness of its argument\n",
+ [Guard, Args]);
+message_to_string({opaque_match, [Pat, OpaqueType, OpaqueTerm]}) ->
+ Term = if OpaqueType =:= OpaqueTerm -> "the term";
+ true -> OpaqueTerm
+ end,
+ io_lib:format("The attempt to match a term of type ~s against the ~s"
+ " breaks the opaqueness of ~s\n", [OpaqueType, Pat, Term]);
+message_to_string({opaque_neq, [Type, _Op, OpaqueType]}) ->
+ io_lib:format("Attempt to test for inequality between a term of type ~s"
+ " and a term of opaque type ~s\n", [Type, OpaqueType]);
+message_to_string({opaque_type_test, [Fun, Opaque]}) ->
+ io_lib:format("The type test ~s(~s) breaks the opaqueness of the term ~s\n", [Fun, Opaque, Opaque]);
+%%----- Warnings for concurrency errors --------------------
+message_to_string({race_condition, [M, F, Args, Reason]}) ->
+ io_lib:format("The call ~w:~w~s ~s\n", [M, F, Args, Reason]).
+
+
+%%-----------------------------------------------------------------------------
+%% Auxiliary functions below
+%%-----------------------------------------------------------------------------
+
+call_or_apply_to_string(ArgNs, FailReason, SigArgs, SigRet,
+ {IsOverloaded, Contract}) ->
+ PositionString = form_position_string(ArgNs),
+ case FailReason of
+ only_sig ->
+ case ArgNs =:= [] of
+ true ->
+ %% We do not know which argument(s) caused the failure
+ io_lib:format("will never return since the success typing arguments"
+ " are ~s\n", [SigArgs]);
+ false ->
+ io_lib:format("will never return since it differs in argument"
+ " ~s from the success typing arguments: ~s\n",
+ [PositionString, SigArgs])
+ end;
+ only_contract ->
+ case (ArgNs =:= []) orelse IsOverloaded of
+ true ->
+ %% We do not know which arguments caused the failure
+ io_lib:format("breaks the contract ~s\n", [Contract]);
+ false ->
+ io_lib:format("breaks the contract ~s in argument ~s\n",
+ [Contract, PositionString])
+ end;
+ both ->
+ io_lib:format("will never return since the success typing is ~s -> ~s"
+ " and the contract is ~s\n", [SigArgs, SigRet, Contract])
+ end.
+
+form_positions(ArgNs) ->
+ case ArgNs of
+ [_] -> "an opaque term in ";
+ [_,_|_] -> "opaque terms in "
+ end ++ form_position_string(ArgNs).
+
+%% We know which positions N are to blame;
+%% the list of triples will never be empty.
+form_expected_without_opaque([{N, T, TStr}]) ->
+ case erl_types:t_is_opaque(T) of
+ true ->
+ io_lib:format("an opaque term of type ~s in ", [TStr]);
+ false ->
+ io_lib:format("a term of type ~s (with opaque subterms) in ", [TStr])
+ end ++ form_position_string([N]);
+form_expected_without_opaque(ExpectedTriples) -> %% TODO: can do much better here
+ {ArgNs, _Ts, _TStrs} = lists:unzip3(ExpectedTriples),
+ "opaque terms in " ++ form_position_string(ArgNs).
+
+form_expected(ExpectedArgs) ->
+ case ExpectedArgs of
+ [T] ->
+ TS = erl_types:t_to_string(T),
+ case erl_types:t_is_opaque(T) of
+ true -> io_lib:format("an opaque term of type ~s is expected", [TS]);
+ false -> io_lib:format("a structured term of type ~s is expected", [TS])
+ end;
+ [_,_|_] -> "terms of different types are expected in these positions"
+ end.
+
+form_position_string(ArgNs) ->
+ case ArgNs of
+ [] -> "";
+ [N1] -> io_lib:format("position ~w", [N1]);
+ [_,_|_] ->
+ " and"++ArgString = lists:flatten([io_lib:format(" and ~w", [N])
+ || N <- ArgNs]),
+ "positions" ++ ArgString
+ end.
diff --git a/lib/dialyzer/src/dialyzer.hrl b/lib/dialyzer/src/dialyzer.hrl
new file mode 100644
index 0000000000..f0f9bd25d7
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer.hrl
@@ -0,0 +1,146 @@
+%%% This is an -*- Erlang -*- file.
+%%%
+%%% %CopyrightBegin%
+%%%
+%%% Copyright Ericsson AB 2006-2009. 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%
+%%%
+%%%-------------------------------------------------------------------
+%%% File : dialyzer.hrl
+%%% Author : Tobias Lindahl <[email protected]>
+%%% Kostis Sagonas <[email protected]>
+%%% Description : Header file for Dialyzer.
+%%%
+%%% Created : 1 Oct 2004 by Kostis Sagonas <[email protected]>
+%%%-------------------------------------------------------------------
+
+-define(RET_NOTHING_SUSPICIOUS, 0).
+-define(RET_INTERNAL_ERROR, 1).
+-define(RET_DISCREPANCIES, 2).
+
+-type dial_ret() :: ?RET_NOTHING_SUSPICIOUS
+ | ?RET_INTERNAL_ERROR
+ | ?RET_DISCREPANCIES.
+
+%%--------------------------------------------------------------------
+%% Warning classification
+%%--------------------------------------------------------------------
+
+-define(WARN_RETURN_NO_RETURN, warn_return_no_exit).
+-define(WARN_RETURN_ONLY_EXIT, warn_return_only_exit).
+-define(WARN_NOT_CALLED, warn_not_called).
+-define(WARN_NON_PROPER_LIST, warn_non_proper_list).
+-define(WARN_FUN_APP, warn_fun_app).
+-define(WARN_MATCHING, warn_matching).
+-define(WARN_OPAQUE, warn_opaque).
+-define(WARN_FAILING_CALL, warn_failing_call).
+-define(WARN_BIN_CONSTRUCTION, warn_bin_construction).
+-define(WARN_CONTRACT_TYPES, warn_contract_types).
+-define(WARN_CONTRACT_SYNTAX, warn_contract_syntax).
+-define(WARN_CONTRACT_NOT_EQUAL, warn_contract_not_equal).
+-define(WARN_CONTRACT_SUBTYPE, warn_contract_subtype).
+-define(WARN_CONTRACT_SUPERTYPE, warn_contract_supertype).
+-define(WARN_CALLGRAPH, warn_callgraph).
+-define(WARN_UNMATCHED_RETURN, warn_umatched_return).
+-define(WARN_RACE_CONDITION, warn_race_condition).
+
+%%
+%% The following type has double role:
+%% 1. It is the set of warnings that will be collected.
+%% 2. It is also the set of tags for warnings that will be returned.
+%%
+-type dial_warn_tag() :: ?WARN_RETURN_NO_RETURN | ?WARN_RETURN_ONLY_EXIT
+ | ?WARN_NOT_CALLED | ?WARN_NON_PROPER_LIST
+ | ?WARN_MATCHING | ?WARN_OPAQUE | ?WARN_FUN_APP
+ | ?WARN_FAILING_CALL | ?WARN_BIN_CONSTRUCTION
+ | ?WARN_CONTRACT_TYPES | ?WARN_CONTRACT_SYNTAX
+ | ?WARN_CONTRACT_NOT_EQUAL | ?WARN_CONTRACT_SUBTYPE
+ | ?WARN_CONTRACT_SUPERTYPE | ?WARN_CALLGRAPH
+ | ?WARN_UNMATCHED_RETURN | ?WARN_RACE_CONDITION.
+
+%%
+%% This is the representation of each warning as they will be returned
+%% to dialyzer's callers
+%%
+-type file_line() :: {file:filename(), non_neg_integer()}.
+-type dial_warning() :: {dial_warn_tag(), file_line(), {atom(), [term()]}}.
+
+%%
+%% This is the representation of dialyzer's internal errors
+%%
+-type dial_error() :: any(). %% XXX: underspecified
+
+%%--------------------------------------------------------------------
+%% THIS TYPE SHOULD ONE DAY DISAPPEAR -- IT DOES NOT BELONG HERE
+%%--------------------------------------------------------------------
+
+-type ordset(T) :: [T] . %% XXX: temporarily
+
+%%--------------------------------------------------------------------
+%% Basic types used either in the record definitions below or in other
+%% parts of the application
+%%--------------------------------------------------------------------
+
+-type anal_type() :: 'succ_typings' | 'plt_build'.
+-type anal_type1() :: anal_type() | 'plt_add' | 'plt_check' | 'plt_remove'.
+-type contr_constr() :: {'subtype', erl_types:erl_type(), erl_types:erl_type()}.
+-type contract_pair() :: {erl_types:erl_type(), [contr_constr()]}.
+-type dial_define() :: {atom(), term()}.
+-type dial_option() :: {atom(), term()}.
+-type dial_options() :: [dial_option()].
+-type label() :: non_neg_integer().
+-type rep_mode() :: 'quiet' | 'normal' | 'verbose'.
+-type start_from() :: 'byte_code' | 'src_code'.
+
+%%--------------------------------------------------------------------
+%% Record declarations used by various files
+%%--------------------------------------------------------------------
+
+-record(analysis, {analysis_pid :: pid(),
+ type = succ_typings :: anal_type(),
+ defines = [] :: [dial_define()],
+ doc_plt :: dialyzer_plt:plt(),
+ files = [] :: [file:filename()],
+ include_dirs = [] :: [file:filename()],
+ start_from = byte_code :: start_from(),
+ plt :: dialyzer_plt:plt(),
+ use_contracts = true :: boolean(),
+ race_detection = false :: boolean(),
+ callgraph_file = "" :: file:filename()}).
+
+-record(options, {files = [] :: [file:filename()],
+ files_rec = [] :: [file:filename()],
+ analysis_type = succ_typings :: anal_type1(),
+ defines = [] :: [dial_define()],
+ from = byte_code :: start_from(),
+ get_warnings = maybe :: boolean() | 'maybe',
+ init_plt = none :: 'none' | file:filename(),
+ include_dirs = [] :: [file:filename()],
+ output_plt = none :: 'none' | file:filename(),
+ legal_warnings = ordsets:new() :: ordset(dial_warn_tag()),
+ report_mode = normal :: rep_mode(),
+ erlang_mode = false :: boolean(),
+ use_contracts = true :: boolean(),
+ output_file = none :: 'none' | file:filename(),
+ output_format = formatted :: 'raw' | 'formatted',
+ callgraph_file = "" :: file:filename(),
+ check_plt = true :: boolean()
+ }).
+
+-record(contract, {contracts = [] :: [contract_pair()],
+ args = [] :: [erl_types:erl_type()],
+ forms = [] :: [{_, _}]}).
+
+%%--------------------------------------------------------------------
diff --git a/lib/dialyzer/src/dialyzer_analysis_callgraph.erl b/lib/dialyzer/src/dialyzer_analysis_callgraph.erl
new file mode 100644
index 0000000000..97d63a1f14
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_analysis_callgraph.erl
@@ -0,0 +1,530 @@
+%% -*- erlang-indent-level: 2 -*-
+%%--------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2006-2009. 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%
+%%
+
+%%%-------------------------------------------------------------------
+%%% File : dialyzer_analysis_callgraph.erl
+%%% Author : Tobias Lindahl <[email protected]>
+%%% Description :
+%%%
+%%% Created : 5 Apr 2005 by Tobias Lindahl <[email protected]>
+%%%-------------------------------------------------------------------
+
+-module(dialyzer_analysis_callgraph).
+
+-export([start/3]).
+
+-include("dialyzer.hrl").
+
+-record(analysis_state,
+ {
+ codeserver :: dialyzer_codeserver:codeserver(),
+ analysis_type = succ_typings :: anal_type(),
+ defines = [] :: [dial_define()],
+ doc_plt :: dialyzer_plt:plt(),
+ include_dirs = [] :: [file:filename()],
+ no_warn_unused :: set(),
+ parent :: pid(),
+ plt :: dialyzer_plt:plt(),
+ start_from = byte_code :: start_from(),
+ use_contracts = true :: boolean()
+ }).
+
+-record(server_state, {parent :: pid(), legal_warnings :: [dial_warn_tag()]}).
+
+%%--------------------------------------------------------------------
+%% Main
+%%--------------------------------------------------------------------
+
+-spec start(pid(), [dial_warn_tag()], #analysis{}) -> 'ok'.
+
+start(Parent, LegalWarnings, Analysis) ->
+ RacesOn = ordsets:is_element(?WARN_RACE_CONDITION, LegalWarnings),
+ Analysis0 = Analysis#analysis{race_detection = RacesOn},
+ Analysis1 = expand_files(Analysis0),
+ Analysis2 = run_analysis(Analysis1),
+ State = #server_state{parent = Parent, legal_warnings = LegalWarnings},
+ loop(State, Analysis2, none).
+
+run_analysis(Analysis) ->
+ Self = self(),
+ Fun = fun() -> analysis_start(Self, Analysis) end,
+ Analysis#analysis{analysis_pid = spawn_link(Fun)}.
+
+loop(#server_state{parent = Parent, legal_warnings = LegalWarnings} = State,
+ #analysis{analysis_pid = AnalPid} = Analysis, ExtCalls) ->
+ receive
+ {AnalPid, log, LogMsg} ->
+ send_log(Parent, LogMsg),
+ loop(State, Analysis, ExtCalls);
+ {AnalPid, warnings, Warnings} ->
+ case filter_warnings(LegalWarnings, Warnings) of
+ [] -> ok;
+ SendWarnings ->
+ send_warnings(Parent, SendWarnings)
+ end,
+ loop(State, Analysis, ExtCalls);
+ {AnalPid, cserver, CServer, Plt} ->
+ send_codeserver_plt(Parent, CServer, Plt),
+ loop(State, Analysis, ExtCalls);
+ {AnalPid, done, Plt, DocPlt} ->
+ case ExtCalls =:= none of
+ true ->
+ send_analysis_done(Parent, Plt, DocPlt);
+ false ->
+ send_ext_calls(Parent, ExtCalls),
+ send_analysis_done(Parent, Plt, DocPlt)
+ end;
+ {AnalPid, ext_calls, NewExtCalls} ->
+ loop(State, Analysis, NewExtCalls);
+ {AnalPid, mod_deps, ModDeps} ->
+ send_mod_deps(Parent, ModDeps),
+ loop(State, Analysis, ExtCalls);
+ {Parent, stop} ->
+ exit(AnalPid, kill),
+ ok
+ end.
+
+%%--------------------------------------------------------------------
+%% The Analysis
+%%--------------------------------------------------------------------
+
+analysis_start(Parent, Analysis) ->
+ CServer = dialyzer_codeserver:new(),
+ Plt = Analysis#analysis.plt,
+ State = #analysis_state{codeserver = CServer,
+ analysis_type = Analysis#analysis.type,
+ defines = Analysis#analysis.defines,
+ doc_plt = Analysis#analysis.doc_plt,
+ include_dirs = Analysis#analysis.include_dirs,
+ plt = Plt,
+ parent = Parent,
+ start_from = Analysis#analysis.start_from,
+ use_contracts = Analysis#analysis.use_contracts
+ },
+ Files = ordsets:from_list(Analysis#analysis.files),
+ {Callgraph, NoWarn, TmpCServer0} = compile_and_store(Files, State),
+ %% Remote type postprocessing
+ NewCServer =
+ try
+ NewRecords = dialyzer_codeserver:get_temp_records(TmpCServer0),
+ OldRecords = dialyzer_plt:get_types(State#analysis_state.plt),
+ MergedRecords = dialyzer_utils:merge_records(NewRecords, OldRecords),
+ TmpCServer1 = dialyzer_codeserver:set_temp_records(MergedRecords, TmpCServer0),
+ TmpCServer2 = dialyzer_utils:process_record_remote_types(TmpCServer1),
+ dialyzer_contracts:process_contract_remote_types(TmpCServer2)
+ catch
+ throw:{error, _ErrorMsg} = Error -> exit(Error)
+ end,
+ NewPlt = dialyzer_plt:insert_types(Plt, dialyzer_codeserver:get_records(NewCServer)),
+ State0 = State#analysis_state{plt = NewPlt},
+ dump_callgraph(Callgraph, State0, Analysis),
+ State1 = State0#analysis_state{codeserver = NewCServer},
+ State2 = State1#analysis_state{no_warn_unused = NoWarn},
+ %% Remove all old versions of the files being analyzed
+ AllNodes = dialyzer_callgraph:all_nodes(Callgraph),
+ Plt1 = dialyzer_plt:delete_list(NewPlt, AllNodes),
+ Exports = dialyzer_codeserver:get_exports(NewCServer),
+ NewCallgraph =
+ case Analysis#analysis.race_detection of
+ true -> dialyzer_callgraph:put_race_detection(true, Callgraph);
+ false -> Callgraph
+ end,
+ State3 = analyze_callgraph(NewCallgraph, State2#analysis_state{plt = Plt1}),
+ NonExports = sets:subtract(sets:from_list(AllNodes), Exports),
+ NonExportsList = sets:to_list(NonExports),
+ Plt3 = dialyzer_plt:delete_list(State3#analysis_state.plt, NonExportsList),
+ Plt4 = dialyzer_plt:delete_contract_list(Plt3, NonExportsList),
+ send_codeserver_plt(Parent, CServer, State3#analysis_state.plt),
+ send_analysis_done(Parent, Plt4, State3#analysis_state.doc_plt).
+
+analyze_callgraph(Callgraph, State) ->
+ Plt = State#analysis_state.plt,
+ Codeserver = State#analysis_state.codeserver,
+ Parent = State#analysis_state.parent,
+ case State#analysis_state.analysis_type of
+ plt_build ->
+ Callgraph1 = dialyzer_callgraph:finalize(Callgraph),
+ NewPlt = dialyzer_succ_typings:analyze_callgraph(Callgraph1, Plt,
+ Codeserver, Parent),
+ dialyzer_callgraph:delete(Callgraph1),
+ State#analysis_state{plt = NewPlt};
+ succ_typings ->
+ NoWarn = State#analysis_state.no_warn_unused,
+ DocPlt = State#analysis_state.doc_plt,
+ Callgraph1 = dialyzer_callgraph:finalize(Callgraph),
+ {Warnings, NewPlt, NewDocPlt} =
+ dialyzer_succ_typings:get_warnings(Callgraph1, Plt, DocPlt,
+ Codeserver, NoWarn, Parent),
+ dialyzer_callgraph:delete(Callgraph1),
+ send_warnings(State#analysis_state.parent, Warnings),
+ State#analysis_state{plt = NewPlt, doc_plt = NewDocPlt}
+ end.
+
+%%--------------------------------------------------------------------
+%% Build the callgraph and fill the codeserver.
+%%--------------------------------------------------------------------
+
+compile_and_store(Files, #analysis_state{codeserver = CServer,
+ defines = Defs,
+ include_dirs = Dirs,
+ parent = Parent,
+ use_contracts = UseContracts,
+ start_from = StartFrom} = State) ->
+ send_log(Parent, "Reading files and computing callgraph... "),
+ {T1, _} = statistics(runtime),
+ Includes = [{i, D} || D <- Dirs],
+ Defines = [{d, Macro, Val} || {Macro, Val} <- Defs],
+ Callgraph = dialyzer_callgraph:new(),
+ Fun = case StartFrom of
+ src_code ->
+ fun(File, {TmpCG, TmpCServer, TmpFailed, TmpNoWarn, TmpMods}) ->
+ case compile_src(File, Includes, Defines, TmpCG,
+ TmpCServer, UseContracts) of
+ {error, Reason} ->
+ {TmpCG, TmpCServer, [{File, Reason}|TmpFailed], TmpNoWarn,
+ TmpMods};
+ {ok, NewCG, NoWarn, NewCServer, Mod} ->
+ {NewCG, NewCServer, TmpFailed, NoWarn++TmpNoWarn,
+ [Mod|TmpMods]}
+ end
+ end;
+ byte_code ->
+ fun(File, {TmpCG, TmpCServer, TmpFailed, TmpNoWarn, TmpMods}) ->
+ case compile_byte(File, TmpCG, TmpCServer, UseContracts) of
+ {error, Reason} ->
+ {TmpCG, TmpCServer, [{File, Reason}|TmpFailed], TmpNoWarn,
+ TmpMods};
+ {ok, NewCG, NoWarn, NewCServer, Mod} ->
+ {NewCG, NewCServer, TmpFailed, NoWarn++TmpNoWarn,
+ [Mod|TmpMods]}
+ end
+ end
+ end,
+ {NewCallgraph1, NewCServer, Failed, NoWarn, Modules} =
+ lists:foldl(Fun, {Callgraph, CServer, [], [], []}, Files),
+ case Failed =:= [] of
+ true ->
+ NewFiles = lists:zip(lists:reverse(Modules), Files),
+ ModDict =
+ lists:foldl(fun({Mod, F}, Dict) -> dict:append(Mod, F, Dict) end,
+ dict:new(), NewFiles),
+ check_for_duplicate_modules(ModDict);
+ false ->
+ Msg = io_lib:format("Could not scan the following file(s): ~p",
+ [lists:flatten(Failed)]),
+ exit({error, Msg})
+ end,
+ {T2, _} = statistics(runtime),
+ Msg1 = io_lib:format("done in ~.2f secs\nRemoving edges... ", [(T2-T1)/1000]),
+ send_log(Parent, Msg1),
+ NewCallgraph2 = cleanup_callgraph(State, NewCServer, NewCallgraph1, Modules),
+ {T3, _} = statistics(runtime),
+ Msg2 = io_lib:format("done in ~.2f secs\n", [(T3-T2)/1000]),
+ send_log(Parent, Msg2),
+ {NewCallgraph2, sets:from_list(NoWarn), NewCServer}.
+
+cleanup_callgraph(#analysis_state{plt = InitPlt, parent = Parent,
+ codeserver = CodeServer},
+ CServer, Callgraph, Modules) ->
+ ModuleDeps = dialyzer_callgraph:module_deps(Callgraph),
+ send_mod_deps(Parent, ModuleDeps),
+ {Callgraph1, ExtCalls} = dialyzer_callgraph:remove_external(Callgraph),
+ ExtCalls1 = [Call || Call = {_From, To} <- ExtCalls,
+ not dialyzer_plt:contains_mfa(InitPlt, To)],
+ {BadCalls1, RealExtCalls} =
+ if ExtCalls1 =:= [] -> {[], []};
+ true ->
+ ModuleSet = sets:from_list(Modules),
+ lists:partition(fun({_From, {M, _F, _A}}) ->
+ sets:is_element(M, ModuleSet) orelse
+ dialyzer_plt:contains_module(InitPlt, M)
+ end, ExtCalls1)
+ end,
+ NonLocalCalls = dialyzer_callgraph:non_local_calls(Callgraph1),
+ BadCalls2 = [Call || Call = {_From, To} <- NonLocalCalls,
+ not dialyzer_codeserver:is_exported(To, CServer)],
+ case BadCalls1 ++ BadCalls2 of
+ [] -> ok;
+ BadCalls -> send_bad_calls(Parent, BadCalls, CodeServer)
+ end,
+ if RealExtCalls =:= [] -> ok;
+ true ->
+ send_ext_calls(Parent, lists:usort([To || {_From, To} <- RealExtCalls]))
+ end,
+ Callgraph1.
+
+compile_src(File, Includes, Defines, Callgraph, CServer, UseContracts) ->
+ DefaultIncludes = default_includes(filename:dirname(File)),
+ SrcCompOpts = dialyzer_utils:src_compiler_opts(),
+ CompOpts = SrcCompOpts ++ Includes ++ Defines ++ DefaultIncludes,
+ case dialyzer_utils:get_abstract_code_from_src(File, CompOpts) of
+ {error, _Msg} = Error -> Error;
+ {ok, AbstrCode} ->
+ case dialyzer_utils:get_core_from_abstract_code(AbstrCode, CompOpts) of
+ error -> {error, " Could not find abstract code for: " ++ File};
+ {ok, Core} ->
+ Mod = cerl:concrete(cerl:module_name(Core)),
+ NoWarn = abs_get_nowarn(AbstrCode, Mod),
+ case dialyzer_utils:get_record_and_type_info(AbstrCode) of
+ {error, _} = Error -> Error;
+ {ok, RecInfo} ->
+ CServer2 =
+ dialyzer_codeserver:store_temp_records(Mod, RecInfo, CServer),
+ case UseContracts of
+ true ->
+ case dialyzer_utils:get_spec_info(Mod, AbstrCode, RecInfo) of
+ {error, _} = Error -> Error;
+ {ok, SpecInfo} ->
+ CServer3 =
+ dialyzer_codeserver:store_temp_contracts(Mod,
+ SpecInfo,
+ CServer2),
+ store_core(Mod, Core, NoWarn, Callgraph, CServer3)
+ end;
+ false ->
+ store_core(Mod, Core, NoWarn, Callgraph, CServer2)
+ end
+ end
+ end
+ end.
+
+compile_byte(File, Callgraph, CServer, UseContracts) ->
+ case dialyzer_utils:get_abstract_code_from_beam(File) of
+ error ->
+ {error, " Could not get abstract code for: " ++ File ++ "\n" ++
+ " Recompile with +debug_info or analyze starting from source code"};
+ {ok, AbstrCode} ->
+ case dialyzer_utils:get_core_from_abstract_code(AbstrCode) of
+ error -> {error, " Could not get core for: "++File};
+ {ok, Core} ->
+ Mod = cerl:concrete(cerl:module_name(Core)),
+ NoWarn = abs_get_nowarn(AbstrCode, Mod),
+ case dialyzer_utils:get_record_and_type_info(AbstrCode) of
+ {error, _} = Error -> Error;
+ {ok, RecInfo} ->
+ CServer1 =
+ dialyzer_codeserver:store_temp_records(Mod, RecInfo, CServer),
+ case UseContracts of
+ true ->
+ case dialyzer_utils:get_spec_info(Mod, AbstrCode, RecInfo) of
+ {error, _} = Error -> Error;
+ {ok, SpecInfo} ->
+ CServer2 =
+ dialyzer_codeserver:store_temp_contracts(Mod, SpecInfo,
+ CServer1),
+ store_core(Mod, Core, NoWarn, Callgraph, CServer2)
+ end;
+ false ->
+ store_core(Mod, Core, NoWarn, Callgraph, CServer1)
+ end
+ end
+ end
+ end.
+
+store_core(Mod, Core, NoWarn, Callgraph, CServer) ->
+ Exp = get_exports_from_core(Core),
+ CServer1 = dialyzer_codeserver:insert_exports(Exp, CServer),
+ {LabeledCore, CServer2} = label_core(Core, CServer1),
+ store_code_and_build_callgraph(Mod, LabeledCore, Callgraph, CServer2, NoWarn).
+
+abs_get_nowarn(Abs, M) ->
+ [{M, F, A}
+ || {attribute, _, compile, {nowarn_unused_function, {F, A}}} <- Abs].
+
+get_exports_from_core(Core) ->
+ Tree = cerl:from_records(Core),
+ Exports1 = cerl:module_exports(Tree),
+ Exports2 = [cerl:var_name(V) || V <- Exports1],
+ M = cerl:atom_val(cerl:module_name(Tree)),
+ [{M, F, A} || {F, A} <- Exports2].
+
+label_core(Core, CServer) ->
+ NextLabel = dialyzer_codeserver:get_next_core_label(CServer),
+ CoreTree = cerl:from_records(Core),
+ {LabeledTree, NewNextLabel} = cerl_trees:label(CoreTree, NextLabel),
+ {cerl:to_records(LabeledTree),
+ dialyzer_codeserver:set_next_core_label(NewNextLabel, CServer)}.
+
+store_code_and_build_callgraph(Mod, Core, Callgraph, CServer, NoWarn) ->
+ CoreTree = cerl:from_records(Core),
+ NewCallgraph = dialyzer_callgraph:scan_core_tree(CoreTree, Callgraph),
+ CServer2 = dialyzer_codeserver:insert(Mod, CoreTree, CServer),
+ {ok, NewCallgraph, NoWarn, CServer2, Mod}.
+
+%%--------------------------------------------------------------------
+%% Utilities
+%%--------------------------------------------------------------------
+
+expand_files(Analysis = #analysis{files = Files, start_from = StartFrom}) ->
+ Ext = case StartFrom of
+ byte_code -> ".beam";
+ src_code -> ".erl"
+ end,
+ case expand_files(Files, Ext, []) of
+ [] ->
+ Msg = "No " ++ Ext ++ " files to analyze" ++
+ case StartFrom of
+ byte_code -> " (no --src specified?)";
+ src_code -> ""
+ end,
+ exit({error, Msg});
+ NewFiles ->
+ Analysis#analysis{files = NewFiles}
+ end.
+
+expand_files([File|Left], Ext, FileAcc) ->
+ case filelib:is_dir(File) of
+ true ->
+ {ok, List} = file:list_dir(File),
+ NewFiles =
+ [filename:join(File, X) || X <- List, filename:extension(X) =:= Ext],
+ expand_files(Left, Ext, NewFiles);
+ false ->
+ expand_files(Left, Ext, [File|FileAcc])
+ end;
+expand_files([], _Ext, FileAcc) ->
+ FileAcc.
+
+check_for_duplicate_modules(ModDict) ->
+ Duplicates = dict:filter(fun(_, [_]) -> false;
+ (_, _Files) -> true
+ end, ModDict),
+ case dict:size(Duplicates) =:= 0 of
+ true ->
+ ok;
+ false ->
+ Mods = [X || {_, X} <- dict:to_list(Duplicates)],
+ Msg = io_lib:format("Duplicate modules: ~p", [Mods]),
+ exit({error, Msg})
+ end.
+
+default_includes(Dir) ->
+ L1 = ["..", "../incl", "../inc", "../include"],
+ [{i, filename:join(Dir, X)} || X <- L1].
+
+%%-------------------------------------------------------------------
+%% Handle Messages
+%%-------------------------------------------------------------------
+
+send_log(Parent, Msg) ->
+ Parent ! {self(), log, Msg},
+ ok.
+
+send_warnings(_Parent, []) ->
+ ok;
+send_warnings(Parent, Warnings) ->
+ Parent ! {self(), warnings, Warnings},
+ ok.
+
+filter_warnings(LegalWarnings, Warnings) ->
+ [TIW || {Tag, _Id, _Warning} = TIW <- Warnings,
+ ordsets:is_element(Tag, LegalWarnings)].
+
+send_analysis_done(Parent, Plt, DocPlt) ->
+ Parent ! {self(), done, Plt, DocPlt},
+ ok.
+
+send_ext_calls(Parent, ExtCalls) ->
+ Parent ! {self(), ext_calls, ExtCalls},
+ ok.
+
+send_codeserver_plt(Parent, CServer, Plt ) ->
+ Parent ! {self(), cserver, CServer, Plt},
+ ok.
+
+send_bad_calls(Parent, BadCalls, CodeServer) ->
+ send_warnings(Parent, format_bad_calls(BadCalls, CodeServer, [])).
+
+send_mod_deps(Parent, ModuleDeps) ->
+ Parent ! {self(), mod_deps, ModuleDeps},
+ ok.
+
+format_bad_calls([{{_, _, _}, {_, module_info, A}}|Left], CodeServer, Acc)
+ when A =:= 0; A =:= 1 ->
+ format_bad_calls(Left, CodeServer, Acc);
+format_bad_calls([{FromMFA, {M, F, A} = To}|Left], CodeServer, Acc) ->
+ {_Var, FunCode} = dialyzer_codeserver:lookup_mfa_code(FromMFA, CodeServer),
+ Msg = {call_to_missing, [M, F, A]},
+ FileLine = find_call_file_and_line(FunCode, To),
+ NewAcc = [{?WARN_CALLGRAPH, FileLine, Msg}|Acc],
+ format_bad_calls(Left, CodeServer, NewAcc);
+format_bad_calls([], _CodeServer, Acc) ->
+ Acc.
+
+find_call_file_and_line(Tree, MFA) ->
+ Fun =
+ fun(SubTree, Acc) ->
+ case cerl:is_c_call(SubTree) of
+ true ->
+ M = cerl:call_module(SubTree),
+ F = cerl:call_name(SubTree),
+ A = cerl:call_arity(SubTree),
+ case cerl:is_c_atom(M) andalso cerl:is_c_atom(F) of
+ true ->
+ case {cerl:concrete(M), cerl:concrete(F), A} of
+ MFA ->
+ Ann = cerl:get_ann(SubTree),
+ [{get_file(Ann), get_line(Ann)}|Acc];
+ _ -> Acc
+ end;
+ false -> Acc
+ end;
+ false -> Acc
+ end
+ end,
+ hd(cerl_trees:fold(Fun, [], Tree)).
+
+get_line([Line|_]) when is_integer(Line) -> Line;
+get_line([_|Tail]) -> get_line(Tail);
+get_line([]) -> -1.
+
+get_file([{file, File}|_]) -> File;
+get_file([_|Tail]) -> get_file(Tail).
+
+-spec dump_callgraph(dialyzer_callgraph:callgraph(), #analysis_state{}, #analysis{}) ->
+ 'ok'.
+
+dump_callgraph(_CallGraph, _State, #analysis{callgraph_file = ""}) -> ok;
+dump_callgraph(CallGraph, State, #analysis{callgraph_file = File} = Analysis) ->
+ Extension = filename:extension(File),
+ Start_Msg = io_lib:format("Dumping the callgraph... ", []),
+ send_log(State#analysis_state.parent, Start_Msg),
+ {T1, _} = statistics(runtime),
+ dump_callgraph(CallGraph, State, Analysis, Extension),
+ {T2, _} = statistics(runtime),
+ Finish_Msg = io_lib:format("done in ~2f secs\n", [(T2-T1)/1000]),
+ send_log(State#analysis_state.parent, Finish_Msg),
+ ok.
+
+dump_callgraph(CallGraph, _State, #analysis{callgraph_file = File}, ".dot") ->
+ dialyzer_callgraph:to_dot(CallGraph, File);
+dump_callgraph(CallGraph, _State, #analysis{callgraph_file = File}, ".ps") ->
+ Args = "-Gratio=compress -Gsize=\"100,100\"",
+ dialyzer_callgraph:to_ps(CallGraph, File, Args);
+dump_callgraph(CallGraph, State, #analysis{callgraph_file = File}, _Ext) ->
+ case file:open(File, [write]) of
+ {ok, Fd} ->
+ io:format(Fd, "~p", [CallGraph]),
+ ok = file:close(Fd);
+ {error, Reason} ->
+ Msg = io_lib:format("Could not open output file ~p, Reason: ~p\n",
+ [File, Reason]),
+ send_log(State#analysis_state.parent, Msg)
+ end.
diff --git a/lib/dialyzer/src/dialyzer_callgraph.erl b/lib/dialyzer/src/dialyzer_callgraph.erl
new file mode 100644
index 0000000000..21d31df71c
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_callgraph.erl
@@ -0,0 +1,697 @@
+%% -*- erlang-indent-level: 2 -*-
+%%-----------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2006-2009. 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%
+%%
+
+%%%-------------------------------------------------------------------
+%%% File : dialyzer_callgraph.erl
+%%% Author : Tobias Lindahl <[email protected]>
+%%% Description :
+%%%
+%%% Created : 30 Mar 2005 by Tobias Lindahl <[email protected]>
+%%%-------------------------------------------------------------------
+-module(dialyzer_callgraph).
+
+-export([all_nodes/1,
+ delete/1,
+ finalize/1,
+ is_escaping/2,
+ is_self_rec/2,
+ non_local_calls/1,
+ lookup_rec_var/2,
+ lookup_call_site/2,
+ lookup_label/2,
+ lookup_name/2,
+ modules/1,
+ module_deps/1,
+ %% module_postorder/1,
+ module_postorder_from_funs/2,
+ new/0,
+ in_neighbours/2,
+ renew_race_info/4,
+ reset_from_funs/2,
+ scan_core_tree/2,
+ strip_module_deps/2,
+ take_scc/1,
+ remove_external/1,
+ to_dot/2,
+ to_ps/3]).
+
+-export([cleanup/1, get_digraph/1, get_named_tables/1, get_public_tables/1,
+ get_race_code/1, get_race_detection/1, race_code_new/1,
+ put_race_code/2, put_race_detection/2, put_named_tables/2,
+ put_public_tables/2]).
+
+-include("dialyzer.hrl").
+
+%%----------------------------------------------------------------------
+
+-type mfa_or_funlbl() :: label() | mfa().
+-type scc() :: [mfa_or_funlbl()].
+-type mfa_calls() :: [{mfa_or_funlbl(), mfa_or_funlbl()}].
+
+%%-----------------------------------------------------------------------------
+%% A callgraph is a directed graph where the nodes are functions and a
+%% call between two functions is an edge from the caller to the callee.
+%%
+%% calls - A mapping from call site (and apply site) labels
+%% to the possible functions that can be called.
+%% digraph - A digraph representing the callgraph.
+%% Nodes are represented as MFAs or labels.
+%% esc - A set of all escaping functions as reported by dialyzer_dep.
+%% postorder - A list of strongly connected components of the callgraph
+%% sorted in a topological bottom-up order.
+%% This is produced by calling finalize/1.
+%% name_map - A mapping from label to MFA.
+%% rev_name_map - A reverse mapping of the name_map.
+%% rec_var_map - A dict mapping from letrec bound labels to function names.
+%% Only for top level functions (from module defs).
+%% self_rec - A set containing all self recursive functions.
+%% Note that this contains MFAs for named functions and labels
+%% whenever applicable.
+%%-----------------------------------------------------------------------------
+
+-record(callgraph, {digraph = digraph:new() :: digraph(),
+ esc = sets:new() :: set(),
+ name_map = dict:new() :: dict(),
+ rev_name_map = dict:new() :: dict(),
+ postorder = [] :: [scc()],
+ rec_var_map = dict:new() :: dict(),
+ self_rec = sets:new() :: set(),
+ calls = dict:new() :: dict(),
+ race_code = dict:new() :: dict(),
+ public_tables = [] :: [label()],
+ named_tables = [] :: [string()],
+ race_detection = false :: boolean()}).
+
+%% Exported Types
+
+-type callgraph() :: #callgraph{}.
+
+%%----------------------------------------------------------------------
+
+-spec new() -> callgraph().
+
+new() ->
+ #callgraph{}.
+
+-spec delete(callgraph()) -> 'true'.
+
+delete(#callgraph{digraph = Digraph}) ->
+ digraph_delete(Digraph).
+
+-spec all_nodes(callgraph()) -> [mfa()].
+
+all_nodes(#callgraph{digraph = DG}) ->
+ digraph_vertices(DG).
+
+-spec lookup_rec_var(label(), callgraph()) -> 'error' | {'ok', mfa()}.
+
+lookup_rec_var(Label, #callgraph{rec_var_map = RecVarMap})
+ when is_integer(Label) ->
+ dict:find(Label, RecVarMap).
+
+-spec lookup_call_site(label(), callgraph()) -> 'error' | {'ok', [_]}. % XXX: refine
+
+lookup_call_site(Label, #callgraph{calls = Calls})
+ when is_integer(Label) ->
+ dict:find(Label, Calls).
+
+-spec lookup_name(label(), callgraph()) -> 'error' | {'ok', mfa()}.
+
+lookup_name(Label, #callgraph{name_map = NameMap})
+ when is_integer(Label) ->
+ dict:find(Label, NameMap).
+
+-spec lookup_label(mfa_or_funlbl(), callgraph()) -> 'error' | {'ok', integer()}.
+
+lookup_label({_,_,_} = MFA, #callgraph{rev_name_map = RevNameMap}) ->
+ dict:find(MFA, RevNameMap);
+lookup_label(Label, #callgraph{}) when is_integer(Label) ->
+ {ok, Label}.
+
+-spec in_neighbours(mfa_or_funlbl(), callgraph()) -> 'none' | [mfa_or_funlbl(),...].
+
+in_neighbours(Label, #callgraph{digraph = Digraph, name_map = NameMap})
+ when is_integer(Label) ->
+ Name = case dict:find(Label, NameMap) of
+ {ok, Val} -> Val;
+ error -> Label
+ end,
+ digraph_in_neighbours(Name, Digraph);
+in_neighbours({_, _, _} = MFA, #callgraph{digraph = Digraph}) ->
+ digraph_in_neighbours(MFA, Digraph).
+
+-spec is_self_rec(mfa_or_funlbl(), callgraph()) -> boolean().
+
+is_self_rec(MfaOrLabel, #callgraph{self_rec = SelfRecs}) ->
+ sets:is_element(MfaOrLabel, SelfRecs).
+
+-spec is_escaping(label(), callgraph()) -> boolean().
+
+is_escaping(Label, #callgraph{esc = Esc}) when is_integer(Label) ->
+ sets:is_element(Label, Esc).
+
+-type callgraph_edge() :: {mfa_or_funlbl(),mfa_or_funlbl()}.
+-spec add_edges([callgraph_edge()], callgraph()) -> callgraph().
+
+add_edges([], CG) ->
+ CG;
+add_edges(Edges, #callgraph{digraph = Callgraph} = CG) ->
+ CG#callgraph{digraph = digraph_add_edges(Edges, Callgraph)}.
+
+-spec add_edges([callgraph_edge()], [mfa_or_funlbl()], callgraph()) -> callgraph().
+
+add_edges(Edges, MFAs, #callgraph{digraph = DG} = CG) ->
+ DG1 = digraph_confirm_vertices(MFAs, DG),
+ add_edges(Edges, CG#callgraph{digraph = DG1}).
+
+-spec take_scc(callgraph()) -> 'none' | {'ok', scc(), callgraph()}.
+
+take_scc(#callgraph{postorder = [SCC|SCCs]} = CG) ->
+ {ok, SCC, CG#callgraph{postorder = SCCs}};
+take_scc(#callgraph{postorder = []}) ->
+ none.
+
+-spec remove_external(callgraph()) -> {callgraph(), [tuple()]}.
+
+remove_external(#callgraph{digraph = DG} = CG) ->
+ {NewDG, External} = digraph_remove_external(DG),
+ {CG#callgraph{digraph = NewDG}, External}.
+
+-spec non_local_calls(callgraph()) -> mfa_calls().
+
+non_local_calls(#callgraph{digraph = DG}) ->
+ Edges = digraph_edges(DG),
+ find_non_local_calls(Edges, sets:new()).
+
+-spec find_non_local_calls([{mfa_or_funlbl(), mfa_or_funlbl()}], set()) -> mfa_calls().
+
+find_non_local_calls([{{M,_,_}, {M,_,_}}|Left], Set) ->
+ find_non_local_calls(Left, Set);
+find_non_local_calls([{{M1,_,_}, {M2,_,_}} = Edge|Left], Set) when M1 =/= M2 ->
+ find_non_local_calls(Left, sets:add_element(Edge, Set));
+find_non_local_calls([{{_,_,_}, Label}|Left], Set) when is_integer(Label) ->
+ find_non_local_calls(Left, Set);
+find_non_local_calls([{Label, {_,_,_}}|Left], Set) when is_integer(Label) ->
+ find_non_local_calls(Left, Set);
+find_non_local_calls([{Label1, Label2}|Left], Set) when is_integer(Label1),
+ is_integer(Label2) ->
+ find_non_local_calls(Left, Set);
+find_non_local_calls([], Set) ->
+ sets:to_list(Set).
+
+-spec renew_race_info(callgraph(), dict(), [label()], [string()]) ->
+ callgraph().
+
+renew_race_info(CG, RaceCode, PublicTables, NamedTables) ->
+ CG#callgraph{race_code = RaceCode,
+ public_tables = PublicTables,
+ named_tables = NamedTables}.
+
+%%----------------------------------------------------------------------
+%% Handling of modules & SCCs
+%%----------------------------------------------------------------------
+
+-spec modules(callgraph()) -> [module()].
+
+modules(#callgraph{digraph = DG}) ->
+ ordsets:from_list([M || {M,_F,_A} <- digraph_vertices(DG)]).
+
+-spec module_postorder(callgraph()) -> [[module()]].
+
+module_postorder(#callgraph{digraph = DG}) ->
+ Edges = digraph_edges(DG),
+ Nodes = ordsets:from_list([M || {M,_F,_A} <- digraph_vertices(DG)]),
+ MDG = digraph:new(),
+ MDG1 = digraph_confirm_vertices(Nodes, MDG),
+ MDG2 = create_module_digraph(Edges, MDG1),
+ MDG3 = digraph_utils:condensation(MDG2),
+ PostOrder = digraph_utils:postorder(MDG3),
+ PostOrder1 = sort_sccs_internally(PostOrder, MDG2),
+ digraph:delete(MDG2),
+ digraph_delete(MDG3),
+ PostOrder1.
+
+%% The module deps of a module are modules that depend on the module
+-spec module_deps(callgraph()) -> dict().
+
+module_deps(#callgraph{digraph = DG}) ->
+ Edges = digraph_edges(DG),
+ Nodes = ordsets:from_list([M || {M,_F,_A} <- digraph_vertices(DG)]),
+ MDG = digraph:new(),
+ MDG1 = digraph_confirm_vertices(Nodes, MDG),
+ MDG2 = create_module_digraph(Edges, MDG1),
+ Deps = [{N, ordsets:from_list(digraph:in_neighbours(MDG2, N))}
+ || N <- Nodes],
+ digraph_delete(MDG2),
+ dict:from_list(Deps).
+
+-spec strip_module_deps(dict(), set()) -> dict().
+
+strip_module_deps(ModDeps, StripSet) ->
+ FilterFun1 = fun(Val) -> not sets:is_element(Val, StripSet) end,
+ MapFun = fun(_Key, ValSet) -> ordsets:filter(FilterFun1, ValSet) end,
+ ModDeps1 = dict:map(MapFun, ModDeps),
+ FilterFun2 = fun(_Key, ValSet) -> ValSet =/= [] end,
+ dict:filter(FilterFun2, ModDeps1).
+
+sort_sccs_internally(PO, MDG) ->
+ sort_sccs_internally(PO, MDG, []).
+
+sort_sccs_internally([SCC|SCCs], MDG, Acc) ->
+ case SCC of
+ [_, _, _ | _] -> % length(SCC) >= 3
+ TmpDG = digraph_utils:subgraph(MDG, SCC),
+ NewSCC = digraph_utils:postorder(TmpDG),
+ digraph_delete(TmpDG),
+ sort_sccs_internally(SCCs, MDG, [NewSCC|Acc]);
+ _ ->
+ sort_sccs_internally(SCCs, MDG, [SCC|Acc])
+ end;
+sort_sccs_internally([], _MDG, Acc) ->
+ lists:reverse(Acc).
+
+create_module_digraph([{{M, _, _}, {M, _, _}}|Left], MDG) ->
+ create_module_digraph(Left, MDG);
+create_module_digraph([{{M1, _, _}, {M2, _, _}}|Left], MDG) ->
+ create_module_digraph(Left, digraph_add_edge(M1, M2, MDG));
+create_module_digraph([{_, _}|Left], MDG) ->
+ create_module_digraph(Left, MDG);
+create_module_digraph([], MDG) ->
+ MDG.
+
+-spec finalize(callgraph()) -> callgraph().
+
+finalize(#callgraph{digraph = DG} = CG) ->
+ CG#callgraph{postorder = digraph_finalize(DG)}.
+
+-spec reset_from_funs([mfa_or_funlbl()], callgraph()) -> callgraph().
+
+reset_from_funs(Funs, #callgraph{digraph = DG} = CG) ->
+ SubGraph = digraph_reaching_subgraph(Funs, DG),
+ Postorder = digraph_finalize(SubGraph),
+ digraph_delete(SubGraph),
+ CG#callgraph{postorder = Postorder}.
+
+-spec module_postorder_from_funs([mfa_or_funlbl()], callgraph()) -> [[module()]].
+
+module_postorder_from_funs(Funs, #callgraph{digraph = DG} = CG) ->
+ SubGraph = digraph_reaching_subgraph(Funs, DG),
+ PO = module_postorder(CG#callgraph{digraph = SubGraph}),
+ digraph_delete(SubGraph),
+ PO.
+
+%%----------------------------------------------------------------------
+%% Core code
+%%----------------------------------------------------------------------
+
+%% The core tree must be labeled as by cerl_trees:label/1 (or /2).
+%% The set of labels in the tree must be disjoint from the set of
+%% labels already occuring in the callgraph.
+
+-spec scan_core_tree(cerl:c_module(), callgraph()) -> callgraph().
+
+scan_core_tree(Tree, #callgraph{calls = OldCalls,
+ esc = OldEsc,
+ name_map = OldNameMap,
+ rec_var_map = OldRecVarMap,
+ rev_name_map = OldRevNameMap,
+ self_rec = OldSelfRec} = CG) ->
+ %% Build name map and recursion variable maps.
+ {NewNameMap, NewRevNameMap, NewRecVarMap} =
+ build_maps(Tree, OldRecVarMap, OldNameMap, OldRevNameMap),
+
+ %% First find the module-local dependencies.
+ {Deps0, EscapingFuns, Calls} = dialyzer_dep:analyze(Tree),
+ NewCalls = dict:merge(fun(_Key, Val, Val) -> Val end, OldCalls, Calls),
+ NewEsc = sets:union(sets:from_list(EscapingFuns), OldEsc),
+ LabelEdges = get_edges_from_deps(Deps0),
+
+ %% Find the self recursive functions. Named functions get both the
+ %% key and their name for convenience.
+ SelfRecs0 = lists:foldl(fun({Key, Key}, Acc) ->
+ case dict:find(Key, NewNameMap) of
+ error -> [Key|Acc];
+ {ok, Name} -> [Key, Name|Acc]
+ end;
+ (_, Acc) -> Acc
+ end, [], LabelEdges),
+ SelfRecs = sets:union(sets:from_list(SelfRecs0), OldSelfRec),
+
+ NamedEdges1 = name_edges(LabelEdges, NewNameMap),
+
+ %% We need to scan for inter-module calls since these are not tracked
+ %% by dialyzer_dep. Note that the caller is always recorded as the
+ %% top level function. This is OK since the included functions are
+ %% stored as scc with the parent.
+ NamedEdges2 = scan_core_funs(Tree),
+
+ %% Confirm all nodes in the tree.
+ Names1 = lists:append([[X, Y] || {X, Y} <- NamedEdges1]),
+ Names2 = ordsets:from_list(Names1),
+
+ %% Get rid of the 'top' function from nodes and edges.
+ Names3 = ordsets:del_element(top, Names2),
+ NewNamedEdges2 =
+ [E || {From, To} = E <- NamedEdges2, From =/= top, To =/= top],
+ NewNamedEdges1 =
+ [E || {From, To} = E <- NamedEdges1, From =/= top, To =/= top],
+ NamedEdges3 = NewNamedEdges1 ++ NewNamedEdges2,
+ CG1 = add_edges(NamedEdges3, Names3, CG),
+ CG1#callgraph{calls = NewCalls,
+ esc = NewEsc,
+ name_map = NewNameMap,
+ rec_var_map = NewRecVarMap,
+ rev_name_map = NewRevNameMap,
+ self_rec = SelfRecs}.
+
+build_maps(Tree, RecVarMap, NameMap, RevNameMap) ->
+ %% We only care about the named (top level) functions. The anonymous
+ %% functions will be analysed together with their parents.
+ Defs = cerl:module_defs(Tree),
+ Mod = cerl:atom_val(cerl:module_name(Tree)),
+ lists:foldl(fun({Var, Function}, {AccNameMap, AccRevNameMap, AccRecVarMap}) ->
+ FunName = cerl:fname_id(Var),
+ Arity = cerl:fname_arity(Var),
+ MFA = {Mod, FunName, Arity},
+ {dict:store(get_label(Function), MFA, AccNameMap),
+ dict:store(MFA, get_label(Function), AccRevNameMap),
+ dict:store(get_label(Var), MFA, AccRecVarMap)}
+ end, {NameMap, RevNameMap, RecVarMap}, Defs).
+
+get_edges_from_deps(Deps) ->
+ %% Convert the dependencies as produced by dialyzer_dep to a list of
+ %% edges. Also, remove 'external' since we are not interested in
+ %% this information.
+ Edges = dict:fold(fun(external, _Set, Acc) -> Acc;
+ (Caller, Set, Acc) ->
+ [[{Caller, Callee} || Callee <- Set,
+ Callee =/= external]|Acc]
+ end, [], Deps),
+ lists:flatten(Edges).
+
+name_edges(Edges, NameMap) ->
+ %% If a label is present in the name map it is renamed. Otherwise
+ %% keep the label as the identity.
+ MapFun = fun(X) ->
+ case dict:find(X, NameMap) of
+ error -> X;
+ {ok, MFA} -> MFA
+ end
+ end,
+ name_edges(Edges, MapFun, NameMap, []).
+
+name_edges([{From, To}|Left], MapFun, NameMap, Acc) ->
+ NewFrom = MapFun(From),
+ NewTo = MapFun(To),
+ name_edges(Left, MapFun, NameMap, [{NewFrom, NewTo}|Acc]);
+name_edges([], _MapFun, _NameMap, Acc) ->
+ Acc.
+
+scan_core_funs(Tree) ->
+ Defs = cerl:module_defs(Tree),
+ Mod = cerl:atom_val(cerl:module_name(Tree)),
+ DeepEdges = lists:foldl(fun({Var, Function}, Edges) ->
+ FunName = cerl:fname_id(Var),
+ Arity = cerl:fname_arity(Var),
+ MFA = {Mod, FunName, Arity},
+ [scan_one_core_fun(Function, MFA)|Edges]
+ end, [], Defs),
+ lists:flatten(DeepEdges).
+
+scan_one_core_fun(TopTree, FunName) ->
+ FoldFun = fun(Tree, Acc) ->
+ case cerl:type(Tree) of
+ call ->
+ CalleeM = cerl:call_module(Tree),
+ CalleeF = cerl:call_name(Tree),
+ A = length(cerl:call_args(Tree)),
+ case (cerl:is_c_atom(CalleeM) andalso
+ cerl:is_c_atom(CalleeF)) of
+ true ->
+ M = cerl:atom_val(CalleeM),
+ F = cerl:atom_val(CalleeF),
+ case erl_bif_types:is_known(M, F, A) of
+ true -> Acc;
+ false -> [{FunName, {M, F, A}}|Acc]
+ end;
+ false ->
+ %% We cannot handle run-time bindings
+ Acc
+ end;
+ _ ->
+ %% Nothing that can introduce new edges in the callgraph.
+ Acc
+ end
+ end,
+ cerl_trees:fold(FoldFun, [], TopTree).
+
+get_label(T) ->
+ case cerl:get_ann(T) of
+ [{label, L} | _] when is_integer(L) -> L;
+ _ -> erlang:error({missing_label, T})
+ end.
+
+%%----------------------------------------------------------------------
+%% Digraph
+%%----------------------------------------------------------------------
+
+digraph_add_edges([{From, To}|Left], DG) ->
+ digraph_add_edges(Left, digraph_add_edge(From, To, DG));
+digraph_add_edges([], DG) ->
+ DG.
+
+digraph_add_edge(From, To, DG) ->
+ case digraph:vertex(DG, From) of
+ false -> digraph:add_vertex(DG, From);
+ {From, _} -> ok
+ end,
+ case digraph:vertex(DG, To) of
+ false -> digraph:add_vertex(DG, To);
+ {To, _} -> ok
+ end,
+ digraph:add_edge(DG, {From, To}, From, To, []),
+ DG.
+
+digraph_confirm_vertices([MFA|Left], DG) ->
+ digraph:add_vertex(DG, MFA, confirmed),
+ digraph_confirm_vertices(Left, DG);
+digraph_confirm_vertices([], DG) ->
+ DG.
+
+digraph_remove_external(DG) ->
+ Vertices = digraph:vertices(DG),
+ Unconfirmed = remove_unconfirmed(Vertices, DG),
+ {DG, Unconfirmed}.
+
+remove_unconfirmed(Vertexes, DG) ->
+ remove_unconfirmed(Vertexes, DG, []).
+
+remove_unconfirmed([V|Left], DG, Unconfirmed) ->
+ case digraph:vertex(DG, V) of
+ {V, confirmed} -> remove_unconfirmed(Left, DG, Unconfirmed);
+ {V, []} -> remove_unconfirmed(Left, DG, [V|Unconfirmed])
+ end;
+remove_unconfirmed([], DG, Unconfirmed) ->
+ BadCalls = lists:append([digraph:in_edges(DG, V) || V <- Unconfirmed]),
+ BadCallsSorted = lists:keysort(1, BadCalls),
+ digraph:del_vertices(DG, Unconfirmed),
+ BadCallsSorted.
+
+digraph_delete(DG) ->
+ digraph:delete(DG).
+
+digraph_edges(DG) ->
+ digraph:edges(DG).
+
+digraph_vertices(DG) ->
+ digraph:vertices(DG).
+
+digraph_in_neighbours(V, DG) ->
+ case digraph:in_neighbours(DG, V) of
+ [] -> none;
+ List -> List
+ end.
+
+%% Pick all the independent nodes (leaves) from one module. Then try
+%% to stay within the module until no more independent nodes can be
+%% chosen. Then pick a new module and so on.
+%%
+%% Note that an SCC that ranges over more than one module is
+%% considered to belong to all modules to make sure that we do not
+%% lose any nodes.
+
+digraph_postorder(Digraph) ->
+ %% Remove all self-edges for SCCs.
+ Edges = [digraph:edge(Digraph, E) || E <- digraph:edges(Digraph)],
+ SelfEdges = [E || {E, V, V, _} <- Edges],
+ true = digraph:del_edges(Digraph, SelfEdges),
+ %% Determine the first module outside of the loop.
+ Leaves = digraph_leaves(Digraph),
+ case Leaves =:= [] of
+ true -> [];
+ false ->
+ {Module, Taken} = take_sccs_from_fresh_module(Leaves),
+ true = digraph:del_vertices(Digraph, Taken),
+ digraph_postorder(Digraph, Module, [Taken])
+ end.
+
+digraph_postorder(Digraph, LastModule, Acc) ->
+ Leaves = digraph_leaves(Digraph),
+ case Leaves =:= [] of
+ true -> lists:append(lists:reverse(Acc));
+ false ->
+ case [SCC || SCC <- Leaves, scc_belongs_to_module(SCC, LastModule)] of
+ [] ->
+ {NewModule, NewTaken} = take_sccs_from_fresh_module(Leaves),
+ true = digraph:del_vertices(Digraph, NewTaken),
+ digraph_postorder(Digraph, NewModule, [NewTaken|Acc]);
+ NewTaken ->
+ true = digraph:del_vertices(Digraph, NewTaken),
+ digraph_postorder(Digraph, LastModule, [NewTaken|Acc])
+ end
+ end.
+
+digraph_leaves(Digraph) ->
+ [V || V <- digraph:vertices(Digraph), digraph:out_degree(Digraph, V) =:= 0].
+
+take_sccs_from_fresh_module(Leaves) ->
+ NewModule = find_module(hd(Leaves)),
+ {NewModule,
+ [SCC || SCC <- Leaves, scc_belongs_to_module(SCC, NewModule)]}.
+
+-spec scc_belongs_to_module(scc(), module()) -> boolean().
+
+scc_belongs_to_module([Label|Left], Module) when is_integer(Label) ->
+ scc_belongs_to_module(Left, Module);
+scc_belongs_to_module([{M, _, _}|Left], Module) ->
+ if M =:= Module -> true;
+ true -> scc_belongs_to_module(Left, Module)
+ end;
+scc_belongs_to_module([], _Module) ->
+ false.
+
+-spec find_module(scc()) -> module().
+
+find_module([{M, _, _}|_]) -> M;
+find_module([Label|Left]) when is_integer(Label) -> find_module(Left).
+
+digraph_finalize(DG) ->
+ DG1 = digraph_utils:condensation(DG),
+ Postorder = digraph_postorder(DG1),
+ digraph:delete(DG1),
+ Postorder.
+
+digraph_reaching_subgraph(Funs, DG) ->
+ Vertices = digraph_utils:reaching(Funs, DG),
+ digraph_utils:subgraph(DG, Vertices).
+
+%%----------------------------------------------------------------------
+%% Races
+%%----------------------------------------------------------------------
+
+-spec cleanup(callgraph()) -> callgraph().
+
+cleanup(#callgraph{name_map = NameMap,
+ rev_name_map = RevNameMap,
+ public_tables = PublicTables,
+ named_tables = NamedTables,
+ race_code = RaceCode}) ->
+ #callgraph{name_map = NameMap,
+ rev_name_map = RevNameMap,
+ public_tables = PublicTables,
+ named_tables = NamedTables,
+ race_code = RaceCode}.
+
+-spec get_digraph(callgraph()) -> digraph().
+
+get_digraph(#callgraph{digraph = Digraph}) ->
+ Digraph.
+
+-spec get_named_tables(callgraph()) -> [string()].
+
+get_named_tables(#callgraph{named_tables = NamedTables}) ->
+ NamedTables.
+
+-spec get_public_tables(callgraph()) -> [label()].
+
+get_public_tables(#callgraph{public_tables = PT}) ->
+ PT.
+
+-spec get_race_code(callgraph()) -> dict().
+
+get_race_code(#callgraph{race_code = RaceCode}) ->
+ RaceCode.
+
+-spec get_race_detection(callgraph()) -> boolean().
+
+get_race_detection(#callgraph{race_detection = RD}) ->
+ RD.
+
+-spec race_code_new(callgraph()) -> callgraph().
+
+race_code_new(Callgraph) ->
+ Callgraph#callgraph{race_code = dict:new()}.
+
+-spec put_race_code(dict(), callgraph()) -> callgraph().
+
+put_race_code(RaceCode, Callgraph) ->
+ Callgraph#callgraph{race_code = RaceCode}.
+
+-spec put_race_detection(boolean(), callgraph()) -> callgraph().
+
+put_race_detection(RaceDetection, Callgraph) ->
+ Callgraph#callgraph{race_detection = RaceDetection}.
+
+-spec put_named_tables([string()], callgraph()) -> callgraph().
+
+put_named_tables(NamedTables, Callgraph) ->
+ Callgraph#callgraph{named_tables = NamedTables}.
+
+-spec put_public_tables([label()], callgraph()) -> callgraph().
+
+put_public_tables(PublicTables, Callgraph) ->
+ Callgraph#callgraph{public_tables = PublicTables}.
+
+%%=============================================================================
+%% Utilities for 'dot'
+%%=============================================================================
+
+-spec to_dot(callgraph(), file:filename()) -> 'ok'.
+
+to_dot(#callgraph{digraph = DG, esc = Esc} = CG, File) ->
+ Fun = fun(L) ->
+ case lookup_name(L, CG) of
+ error -> L;
+ {ok, Name} -> Name
+ end
+ end,
+ Escaping = [{Fun(L), {color, red}}
+ || L <- sets:to_list(Esc), L =/= external],
+ Vertices = digraph_edges(DG),
+ hipe_dot:translate_list(Vertices, File, "CG", Escaping).
+
+-spec to_ps(callgraph(), file:filename(), string()) -> 'ok'.
+
+to_ps(#callgraph{} = CG, File, Args) ->
+ Dot_File = filename:rootname(File) ++ ".dot",
+ to_dot(CG, Dot_File),
+ Command = io_lib:format("dot -Tps ~s -o ~s ~s", [Args, File, Dot_File]),
+ _ = os:cmd(Command),
+ ok.
diff --git a/lib/dialyzer/src/dialyzer_cl.erl b/lib/dialyzer/src/dialyzer_cl.erl
new file mode 100644
index 0000000000..ab56a4e6d3
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_cl.erl
@@ -0,0 +1,717 @@
+%% -*- erlang-indent-level: 2 -*-
+%%-------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2006-2009. 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%
+%%
+
+%%%-------------------------------------------------------------------
+%%% File : dialyzer_cl.erl
+%%% Authors : Tobias Lindahl <[email protected]>
+%%% Kostis Sagonas <[email protected]>
+%%% Description : The command line interface for the Dialyzer tool.
+%%%
+%%% Created : 27 Apr 2004 by Tobias Lindahl <[email protected]>
+%%%-------------------------------------------------------------------
+
+-module(dialyzer_cl).
+
+-export([start/1]).
+
+-include("dialyzer.hrl").
+-include_lib("kernel/include/file.hrl"). % needed for #file_info{}
+
+-record(cl_state,
+ {backend_pid :: pid(),
+ erlang_mode = false :: boolean(),
+ external_calls = [] :: [mfa()],
+ legal_warnings = ordsets:new() :: [dial_warn_tag()],
+ mod_deps = dict:new() :: dict(),
+ output = standard_io :: io:device(),
+ output_format = formatted :: 'raw' | 'formatted',
+ output_plt = none :: 'none' | file:filename(),
+ plt_info = none :: 'none' | dialyzer_plt:plt_info(),
+ report_mode = normal :: rep_mode(),
+ return_status= ?RET_NOTHING_SUSPICIOUS :: dial_ret(),
+ stored_warnings = [] :: [dial_warning()]
+ }).
+
+%%--------------------------------------------------------------------
+
+-spec start(#options{}) -> {dial_ret(), [dial_warning()]}.
+
+start(#options{analysis_type = AnalysisType} = Options) ->
+ process_flag(trap_exit, true),
+ case AnalysisType of
+ plt_check -> check_plt(Options);
+ plt_build -> build_plt(Options);
+ plt_add -> add_to_plt(Options);
+ plt_remove -> remove_from_plt(Options);
+ succ_typings -> do_analysis(Options)
+ end.
+
+%%--------------------------------------------------------------------
+
+build_plt(Opts) ->
+ Opts1 = init_opts_for_build(Opts),
+ Files = get_files_from_opts(Opts1),
+ Md5 = dialyzer_plt:compute_md5_from_files(Files),
+ PltInfo = {Md5, dict:new()},
+ do_analysis(Files, Opts1, dialyzer_plt:new(), PltInfo).
+
+init_opts_for_build(Opts) ->
+ case Opts#options.output_plt =:= none of
+ true ->
+ case Opts#options.init_plt of
+ none -> Opts#options{init_plt = none, output_plt = get_default_plt()};
+ Plt -> Opts#options{init_plt = none, output_plt = Plt}
+ end;
+ false -> Opts#options{init_plt = none}
+ end.
+
+%%--------------------------------------------------------------------
+
+add_to_plt(Opts) ->
+ Opts1 = init_opts_for_add(Opts),
+ AddFiles = get_files_from_opts(Opts1),
+ plt_common(Opts1, [], AddFiles).
+
+init_opts_for_add(Opts) ->
+ case Opts#options.output_plt =:= none of
+ true ->
+ case Opts#options.init_plt of
+ none -> Opts#options{output_plt = get_default_plt(),
+ init_plt = get_default_plt()};
+ Plt -> Opts#options{output_plt = Plt}
+ end;
+ false ->
+ case Opts#options.init_plt =:= none of
+ true -> Opts#options{init_plt = get_default_plt()};
+ false -> Opts
+ end
+ end.
+
+%%--------------------------------------------------------------------
+
+check_plt(Opts) ->
+ Opts1 = init_opts_for_check(Opts),
+ report_check(Opts),
+ plt_common(Opts1, [], []).
+
+init_opts_for_check(Opts) ->
+ Plt =
+ case Opts#options.init_plt of
+ none -> get_default_plt();
+ Plt0 -> Plt0
+ end,
+ Opts#options{files = [],
+ files_rec = [],
+ analysis_type = plt_check,
+ defines = [],
+ from = byte_code,
+ init_plt = Plt,
+ include_dirs = [],
+ output_plt = Plt,
+ use_contracts = true
+ }.
+
+%%--------------------------------------------------------------------
+
+remove_from_plt(Opts) ->
+ Opts1 = init_opts_for_remove(Opts),
+ Files = get_files_from_opts(Opts1),
+ plt_common(Opts1, Files, []).
+
+init_opts_for_remove(Opts) ->
+ case Opts#options.output_plt =:= none of
+ true ->
+ case Opts#options.init_plt of
+ none -> Opts#options{output_plt = get_default_plt(),
+ init_plt = get_default_plt()};
+ Plt -> Opts#options{output_plt = Plt}
+ end;
+ false ->
+ case Opts#options.init_plt =:= none of
+ true -> Opts#options{init_plt = get_default_plt()};
+ false -> Opts
+ end
+ end.
+
+%%--------------------------------------------------------------------
+
+plt_common(Opts, RemoveFiles, AddFiles) ->
+ case check_plt(Opts, RemoveFiles, AddFiles) of
+ ok ->
+ case Opts#options.report_mode of
+ quiet -> ok;
+ _ -> io:put_chars(" yes\n")
+ end,
+ {?RET_NOTHING_SUSPICIOUS, []};
+ {old_version, Md5} ->
+ PltInfo = {Md5, dict:new()},
+ Files = [F || {F, _} <- Md5],
+ do_analysis(Files, Opts, dialyzer_plt:new(), PltInfo);
+ {differ, Md5, DiffMd5, ModDeps} ->
+ report_failed_plt_check(Opts, DiffMd5),
+ {AnalFiles, RemovedMods, ModDeps1} =
+ expand_dependent_modules(Md5, DiffMd5, ModDeps),
+ Plt = clean_plt(Opts#options.init_plt, RemovedMods),
+ case AnalFiles =:= [] of
+ true ->
+ %% Only removed stuff. Just write the PLT.
+ dialyzer_plt:to_file(Opts#options.output_plt, Plt, ModDeps,
+ {Md5, ModDeps}),
+ {?RET_NOTHING_SUSPICIOUS, []};
+ false ->
+ do_analysis(AnalFiles, Opts, Plt, {Md5, ModDeps1})
+ end;
+ {error, no_such_file} ->
+ Msg = io_lib:format("Could not find the PLT: ~s\n~s",
+ [Opts#options.init_plt, default_plt_error_msg()]),
+ error(Msg);
+ {error, not_valid} ->
+ Msg = io_lib:format("The file: ~s is not a valid PLT file\n~s",
+ [Opts#options.init_plt, default_plt_error_msg()]),
+ error(Msg);
+ {error, read_error} ->
+ Msg = io_lib:format("Could not read the PLT: ~s\n~s",
+ [Opts#options.init_plt, default_plt_error_msg()]),
+ error(Msg);
+ {error, {no_file_to_remove, F}} ->
+ Msg = io_lib:format("Could not remove the file ~s from the PLT: ~s\n",
+ [F, Opts#options.init_plt]),
+ error(Msg)
+ end.
+
+default_plt_error_msg() ->
+ "Use the options:\n"
+ " --build_plt to build a new PLT; or\n"
+ " --add_to_plt to add to an existing PLT\n"
+ "\n"
+ "For example, use a command like the following:\n"
+ " dialyzer --build_plt --apps erts kernel stdlib mnesia\n"
+ "Note that building a PLT such as the above may take 20 mins or so\n"
+ "\n"
+ "If you later need information about other applications, say crypto,\n"
+ "you can extend the PLT by the command:\n"
+ " dialyzer --add_to_plt --apps crypto\n"
+ "For applications that are not in Erlang/OTP use an absolute file name.\n".
+
+%%--------------------------------------------------------------------
+
+check_plt(Opts, RemoveFiles, AddFiles) ->
+ Plt = Opts#options.init_plt,
+ case dialyzer_plt:check_plt(Plt, RemoveFiles, AddFiles) of
+ {old_version, _MD5} = OldVersion ->
+ report_old_version(Opts),
+ OldVersion;
+ {differ, _MD5, _DiffMd5, _ModDeps} = Differ ->
+ Differ;
+ ok ->
+ ok;
+ {error, _Reason} = Error ->
+ Error
+ end.
+
+%%--------------------------------------------------------------------
+
+report_check(#options{report_mode = ReportMode, init_plt = InitPlt}) ->
+ case ReportMode of
+ quiet -> ok;
+ _ ->
+ io:format(" Checking whether the PLT ~s is up-to-date...", [InitPlt])
+ end.
+
+report_old_version(#options{report_mode = ReportMode, init_plt = InitPlt}) ->
+ case ReportMode of
+ quiet -> ok;
+ _ ->
+ io:put_chars(" no\n"),
+ io:format(" (the PLT ~s was built with an old version of Dialyzer)\n",
+ [InitPlt])
+ end.
+
+report_failed_plt_check(#options{analysis_type = AnalType,
+ report_mode = ReportMode}, DiffMd5) ->
+ case AnalType =:= plt_check of
+ true ->
+ case ReportMode of
+ quiet -> ok;
+ normal -> io:format(" no\n", []);
+ verbose -> report_md5_diff(DiffMd5)
+ end;
+ false -> ok
+ end.
+
+report_analysis_start(#options{analysis_type = Type,
+ report_mode = ReportMode,
+ init_plt = InitPlt,
+ output_plt = OutputPlt}) ->
+ case ReportMode of
+ quiet -> ok;
+ _ ->
+ io:format(" "),
+ case Type of
+ plt_add ->
+ case InitPlt =:= OutputPlt of
+ true -> io:format("Adding information to ~s...", [OutputPlt]);
+ false -> io:format("Adding information from ~s to ~s...",
+ [InitPlt, OutputPlt])
+ end;
+ plt_build ->
+ io:format("Creating PLT ~s ...", [OutputPlt]);
+ plt_check ->
+ io:format("Rebuilding the information in ~s...", [OutputPlt]);
+ plt_remove ->
+ case InitPlt =:= OutputPlt of
+ true -> io:format("Removing information from ~s...", [OutputPlt]);
+ false -> io:format("Removing information from ~s to ~s...",
+ [InitPlt, OutputPlt])
+ end;
+ succ_typings -> io:format("Proceeding with analysis...")
+ end
+ end.
+
+report_native_comp(#options{report_mode = ReportMode}) ->
+ case ReportMode of
+ quiet -> ok;
+ _ -> io:format(" Compiling some key modules to native code...")
+ end.
+
+report_elapsed_time(T1, T2, #options{report_mode = ReportMode}) ->
+ case ReportMode of
+ quiet -> ok;
+ _ ->
+ ElapsedTime = T2 - T1,
+ Mins = ElapsedTime div 60000,
+ Secs = (ElapsedTime rem 60000) / 1000,
+ io:format(" done in ~wm~.2fs\n", [Mins, Secs])
+ end.
+
+report_md5_diff(List) ->
+ io:format(" The PLT information is not up to date:\n", []),
+ case [Mod || {removed, Mod} <- List] of
+ [] -> ok;
+ RemovedMods -> io:format(" Removed modules: ~p\n", [RemovedMods])
+ end,
+ case [Mod || {differ, Mod} <- List] of
+ [] -> ok;
+ ChangedMods -> io:format(" Changed modules: ~p\n", [ChangedMods])
+ end.
+
+%%--------------------------------------------------------------------
+
+get_default_plt() ->
+ dialyzer_plt:get_default_plt().
+
+%%--------------------------------------------------------------------
+
+do_analysis(Options) ->
+ Files = get_files_from_opts(Options),
+ case Options#options.init_plt of
+ none -> do_analysis(Files, Options, dialyzer_plt:new(), none);
+ File -> do_analysis(Files, Options, dialyzer_plt:from_file(File), none)
+ end.
+
+do_analysis(Files, Options, Plt, PltInfo) ->
+ assert_writable(Options#options.output_plt),
+ hipe_compile(Files, Options),
+ report_analysis_start(Options),
+ State0 = new_state(),
+ State1 = init_output(State0, Options),
+ State2 = State1#cl_state{legal_warnings = Options#options.legal_warnings,
+ output_plt = Options#options.output_plt,
+ plt_info = PltInfo,
+ erlang_mode = Options#options.erlang_mode,
+ report_mode = Options#options.report_mode},
+ AnalysisType = convert_analysis_type(Options#options.analysis_type,
+ Options#options.get_warnings),
+ InitAnalysis = #analysis{type = AnalysisType,
+ defines = Options#options.defines,
+ include_dirs = Options#options.include_dirs,
+ files = Files,
+ start_from = Options#options.from,
+ plt = Plt,
+ use_contracts = Options#options.use_contracts,
+ callgraph_file = Options#options.callgraph_file},
+ State3 = start_analysis(State2, InitAnalysis),
+ {T1, _} = statistics(wall_clock),
+ Return = cl_loop(State3),
+ {T2, _} = statistics(wall_clock),
+ report_elapsed_time(T1, T2, Options),
+ Return.
+
+convert_analysis_type(plt_check, true) -> succ_typings;
+convert_analysis_type(plt_check, false) -> plt_build;
+convert_analysis_type(plt_add, true) -> succ_typings;
+convert_analysis_type(plt_add, false) -> plt_build;
+convert_analysis_type(plt_build, true) -> succ_typings;
+convert_analysis_type(plt_build, false) -> plt_build;
+convert_analysis_type(plt_remove, true) -> succ_typings;
+convert_analysis_type(plt_remove, false) -> plt_build;
+convert_analysis_type(succ_typings, _) -> succ_typings.
+
+%%--------------------------------------------------------------------
+
+assert_writable(none) ->
+ ok;
+assert_writable(PltFile) ->
+ case check_if_writable(PltFile) of
+ true -> ok;
+ false ->
+ Msg = io_lib:format(" The PLT file ~s is not writable", [PltFile]),
+ error(Msg)
+ end.
+
+check_if_writable(PltFile) ->
+ case filelib:is_regular(PltFile) of
+ true -> is_writable_file_or_dir(PltFile);
+ false ->
+ case filelib:is_dir(PltFile) of
+ true -> false;
+ false ->
+ DirName = filename:dirname(PltFile),
+ filelib:is_dir(DirName) andalso is_writable_file_or_dir(DirName)
+ end
+ end.
+
+is_writable_file_or_dir(PltFile) ->
+ case file:read_file_info(PltFile) of
+ {ok, #file_info{access = A}} ->
+ (A =:= write) orelse (A =:= read_write);
+ {error, _} ->
+ false
+ end.
+
+%%--------------------------------------------------------------------
+
+clean_plt(PltFile, RemovedMods) ->
+ %% Clean the plt from the removed modules.
+ Plt = dialyzer_plt:from_file(PltFile),
+ sets:fold(fun(M, AccPlt) -> dialyzer_plt:delete_module(AccPlt, M) end,
+ Plt, RemovedMods).
+
+expand_dependent_modules(Md5, DiffMd5, ModDeps) ->
+ ChangedMods = sets:from_list([M || {differ, M} <- DiffMd5]),
+ RemovedMods = sets:from_list([M || {removed, M} <- DiffMd5]),
+ BigSet = sets:union(ChangedMods, RemovedMods),
+ BigList = sets:to_list(BigSet),
+ ExpandedSet = expand_dependent_modules_1(BigList, BigSet, ModDeps),
+ NewModDeps = dialyzer_callgraph:strip_module_deps(ModDeps, BigSet),
+ AnalyzeMods = sets:subtract(ExpandedSet, RemovedMods),
+ FilterFun = fun(File) ->
+ Mod = list_to_atom(filename:basename(File, ".beam")),
+ sets:is_element(Mod, AnalyzeMods)
+ end,
+ {[F || {F, _} <- Md5, FilterFun(F)], RemovedMods, NewModDeps}.
+
+expand_dependent_modules_1([Mod|Mods], Included, ModDeps) ->
+ case dict:find(Mod, ModDeps) of
+ {ok, Deps} ->
+ NewDeps = sets:subtract(sets:from_list(Deps), Included),
+ case sets:size(NewDeps) =:= 0 of
+ true -> expand_dependent_modules_1(Mods, Included, ModDeps);
+ false ->
+ NewIncluded = sets:union(Included, NewDeps),
+ expand_dependent_modules_1(sets:to_list(NewDeps) ++ Mods,
+ NewIncluded, ModDeps)
+ end;
+ error ->
+ expand_dependent_modules_1(Mods, Included, ModDeps)
+ end;
+expand_dependent_modules_1([], Included, _ModDeps) ->
+ Included.
+
+-define(MIN_FILES_FOR_NATIVE_COMPILE, 20).
+
+-spec hipe_compile([file:filename()], #options{}) -> 'ok'.
+
+hipe_compile(Files, #options{erlang_mode = ErlangMode} = Options) ->
+ case (length(Files) < ?MIN_FILES_FOR_NATIVE_COMPILE) orelse ErlangMode of
+ true -> ok;
+ false ->
+ case erlang:system_info(hipe_architecture) of
+ undefined -> ok;
+ _ ->
+ Mods = [lists, dict, gb_sets, gb_trees, ordsets, sets,
+ cerl, cerl_trees, erl_types, erl_bif_types,
+ dialyzer_analysis_callgraph, dialyzer_codeserver,
+ dialyzer_dataflow, dialyzer_dep, dialyzer_plt,
+ dialyzer_succ_typings, dialyzer_typesig],
+ report_native_comp(Options),
+ {T1, _} = statistics(wall_clock),
+ native_compile(Mods),
+ {T2, _} = statistics(wall_clock),
+ report_elapsed_time(T1, T2, Options)
+ end
+ end.
+
+native_compile(Mods) ->
+ case erlang:system_info(schedulers) of
+ %% N when N > 1 ->
+ %% Parent = self(),
+ %% Pids = [spawn(fun () -> Parent ! {self(), hc(M)} end) || M <- Mods],
+ %% lists:foreach(fun (Pid) -> receive {Pid, Res} -> Res end end, Pids);
+ _ -> % 1 ->
+ lists:foreach(fun (Mod) -> hc(Mod) end, Mods)
+ end.
+
+hc(Mod) ->
+ case code:ensure_loaded(Mod) of
+ {module, Mod} -> ok;
+ {error, sticky_directory} -> ok
+ end,
+ case code:is_module_native(Mod) of
+ true -> ok;
+ false ->
+ {ok, Mod} = hipe:c(Mod),
+ ok
+ end.
+
+new_state() ->
+ #cl_state{}.
+
+init_output(State0, #options{output_file = OutFile, output_format = OutFormat}) ->
+ State = State0#cl_state{output_format = OutFormat},
+ case OutFile =:= none of
+ true ->
+ State;
+ false ->
+ case file:open(OutFile, [write]) of
+ {ok, File} ->
+ State#cl_state{output = File};
+ {error, Reason} ->
+ Msg = io_lib:format("Could not open output file ~p, Reason: ~p\n",
+ [OutFile, Reason]),
+ error(State, lists:flatten(Msg))
+ end
+ end.
+
+-spec maybe_close_output_file(#cl_state{}) -> 'ok'.
+
+maybe_close_output_file(State) ->
+ case State#cl_state.output of
+ standard_io -> ok;
+ File -> ok = file:close(File)
+ end.
+
+%% ----------------------------------------------------------------
+%%
+%% Main Loop
+%%
+
+-define(LOG_CACHE_SIZE, 10).
+
+%%-spec cl_loop(#cl_state{}) ->
+cl_loop(State) ->
+ cl_loop(State, []).
+
+cl_loop(State, LogCache) ->
+ BackendPid = State#cl_state.backend_pid,
+ receive
+ {BackendPid, log, LogMsg} ->
+ %%io:format(State#cl_state.output ,"Log: ~s\n", [LogMsg]),
+ cl_loop(State, lists:sublist([LogMsg|LogCache], ?LOG_CACHE_SIZE));
+ {BackendPid, warnings, Warnings} ->
+ NewState = store_warnings(State, Warnings),
+ cl_loop(NewState, LogCache);
+ {BackendPid, done, NewPlt, _NewDocPlt} ->
+ return_value(State, NewPlt);
+ {BackendPid, ext_calls, ExtCalls} ->
+ cl_loop(State#cl_state{external_calls = ExtCalls}, LogCache);
+ {BackendPid, mod_deps, ModDeps} ->
+ NewState = State#cl_state{mod_deps = ModDeps},
+ cl_loop(NewState, LogCache);
+ {'EXIT', BackendPid, {error, Reason}} ->
+ Msg = failed_anal_msg(Reason, LogCache),
+ error(State, Msg);
+ {'EXIT', BackendPid, Reason} when Reason =/= 'normal' ->
+ Msg = failed_anal_msg(io_lib:format("~P", [Reason, 12]), LogCache),
+ error(State, Msg);
+ _Other ->
+ %% io:format("Received ~p\n", [_Other]),
+ cl_loop(State, LogCache)
+ end.
+
+-spec failed_anal_msg(string(), [_]) -> string().
+
+failed_anal_msg(Reason, LogCache) ->
+ Msg = "Analysis failed with error: " ++ Reason ++ "\n",
+ case LogCache =:= [] of
+ true -> Msg;
+ false ->
+ Msg ++ "Last messages in the log cache:\n " ++ format_log_cache(LogCache)
+ end.
+
+%%
+%% formats the log cache (treating it as a string) for pretty-printing
+%%
+format_log_cache(LogCache) ->
+ Str = lists:append(lists:reverse(LogCache)),
+ string:join(string:tokens(Str, "\n"), "\n ").
+
+-spec store_warnings(#cl_state{}, [dial_warning()]) -> #cl_state{}.
+
+store_warnings(#cl_state{stored_warnings = StoredWarnings} = St, Warnings) ->
+ St#cl_state{stored_warnings = StoredWarnings ++ Warnings}.
+
+-spec error(string()) -> no_return().
+
+error(Msg) ->
+ throw({dialyzer_error, Msg}).
+
+-spec error(#cl_state{}, string()) -> no_return().
+
+error(State, Msg) ->
+ case State#cl_state.output of
+ standard_io -> ok;
+ Outfile -> io:format(Outfile, "\n~s\n", [Msg])
+ end,
+ maybe_close_output_file(State),
+ throw({dialyzer_error, Msg}).
+
+return_value(State = #cl_state{erlang_mode = ErlangMode,
+ mod_deps = ModDeps,
+ output_plt = OutputPlt,
+ plt_info = PltInfo,
+ stored_warnings = StoredWarnings},
+ Plt) ->
+ case OutputPlt =:= none of
+ true -> ok;
+ false -> dialyzer_plt:to_file(OutputPlt, Plt, ModDeps, PltInfo)
+ end,
+ RetValue =
+ case StoredWarnings =:= [] of
+ true -> ?RET_NOTHING_SUSPICIOUS;
+ false -> ?RET_DISCREPANCIES
+ end,
+ case ErlangMode of
+ false ->
+ print_warnings(State),
+ print_ext_calls(State),
+ maybe_close_output_file(State),
+ {RetValue, []};
+ true ->
+ {RetValue, process_warnings(StoredWarnings)}
+ end.
+
+print_ext_calls(#cl_state{report_mode = quiet}) ->
+ ok;
+print_ext_calls(#cl_state{output = Output,
+ external_calls = Calls,
+ stored_warnings = Warnings,
+ output_format = Format}) ->
+ case Calls =:= [] of
+ true -> ok;
+ false ->
+ case Warnings =:= [] of
+ true -> io:nl(Output); %% Need to do a newline first
+ false -> ok
+ end,
+ case Format of
+ formatted ->
+ io:put_chars(Output, "Unknown functions:\n"),
+ do_print_ext_calls(Output, Calls, " ");
+ raw ->
+ io:put_chars(Output, "%% Unknown functions:\n"),
+ do_print_ext_calls(Output, Calls, "%% ")
+ end
+ end.
+
+do_print_ext_calls(Output, [{M,F,A}|T], Before) ->
+ io:format(Output, "~s~p:~p/~p\n", [Before,M,F,A]),
+ do_print_ext_calls(Output, T, Before);
+do_print_ext_calls(_, [], _) ->
+ ok.
+
+print_warnings(#cl_state{stored_warnings = []}) ->
+ ok;
+print_warnings(#cl_state{output = Output,
+ output_format = Format,
+ stored_warnings = Warnings}) ->
+ PrWarnings = process_warnings(Warnings),
+ case PrWarnings of
+ [] -> ok;
+ [_|_] ->
+ S = case Format of
+ formatted ->
+ [dialyzer:format_warning(W) || W <- PrWarnings];
+ raw ->
+ [io_lib:format("~p. \n", [W]) || W <- PrWarnings]
+ end,
+ io:format(Output, "\n~s", [S])
+ end.
+
+-spec process_warnings([dial_warning()]) -> [dial_warning()].
+
+process_warnings(Warnings) ->
+ Warnings1 = lists:keysort(2, Warnings), %% Sort on file/line
+ remove_duplicate_warnings(Warnings1, []).
+
+remove_duplicate_warnings([Duplicate, Duplicate|Left], Acc) ->
+ remove_duplicate_warnings([Duplicate|Left], Acc);
+remove_duplicate_warnings([NotDuplicate|Left], Acc) ->
+ remove_duplicate_warnings(Left, [NotDuplicate|Acc]);
+remove_duplicate_warnings([], Acc) ->
+ lists:reverse(Acc).
+
+get_files_from_opts(Options) ->
+ From = Options#options.from,
+ Files1 = add_files(Options#options.files, From),
+ Files2 = add_files_rec(Options#options.files_rec, From),
+ ordsets:union(Files1, Files2).
+
+add_files_rec(Files, From) ->
+ add_files(Files, From, true).
+
+add_files(Files, From) ->
+ add_files(Files, From, false).
+
+add_files(Files, From, Rec) ->
+ Files1 = [filename:absname(F) || F <- Files],
+ Files2 = ordsets:from_list(Files1),
+ Dirs = ordsets:filter(fun(X) -> filelib:is_dir(X) end, Files2),
+ Files3 = ordsets:subtract(Files2, Dirs),
+ Extension = case From of
+ byte_code -> ".beam";
+ src_code -> ".erl"
+ end,
+ Fun = add_file_fun(Extension),
+ lists:foldl(fun(Dir, Acc) ->
+ filelib:fold_files(Dir, Extension, Rec, Fun, Acc)
+ end, Files3, Dirs).
+
+add_file_fun(Extension) ->
+ fun(File, AccFiles) ->
+ case filename:extension(File) =:= Extension of
+ true ->
+ AbsName = filename:absname(File),
+ ordsets:add_element(AbsName, AccFiles);
+ false -> AccFiles
+ end
+ end.
+
+-spec start_analysis(#cl_state{}, #analysis{}) -> #cl_state{}.
+
+start_analysis(State, Analysis) ->
+ Self = self(),
+ LegalWarnings = State#cl_state.legal_warnings,
+ Fun = fun() ->
+ dialyzer_analysis_callgraph:start(Self, LegalWarnings, Analysis)
+ end,
+ BackendPid = spawn_link(Fun),
+ State#cl_state{backend_pid = BackendPid}.
+
diff --git a/lib/dialyzer/src/dialyzer_cl_parse.erl b/lib/dialyzer/src/dialyzer_cl_parse.erl
new file mode 100644
index 0000000000..ae466e5c01
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_cl_parse.erl
@@ -0,0 +1,448 @@
+%% -*- erlang-indent-level: 2 -*-
+%%-----------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2006-2009. 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%
+%%
+
+-module(dialyzer_cl_parse).
+
+-export([start/0]).
+-export([collect_args/1]). % used also by typer_options.erl
+
+-include("dialyzer.hrl").
+
+%%-----------------------------------------------------------------------
+
+-type dial_cl_parse_ret() :: {'check_init', #options{}}
+ | {'plt_info', #options{}}
+ | {'cl', #options{}}
+ | {{'gui', 'gs' | 'wx'}, #options{}}
+ | {'error', string()}.
+
+%%-----------------------------------------------------------------------
+
+-spec start() -> dial_cl_parse_ret().
+
+start() ->
+ init(),
+ Args = init:get_plain_arguments(),
+ try
+ cl(Args)
+ catch
+ throw:{dialyzer_cl_parse_error, Msg} -> {error, Msg};
+ _:R ->
+ Msg = io_lib:format("~p\n~p\n", [R, erlang:get_stacktrace()]),
+ {error, lists:flatten(Msg)}
+ end.
+
+cl(["--add_to_plt"|T]) ->
+ put(dialyzer_options_analysis_type, plt_add),
+ cl(T);
+cl(["--apps"|T]) ->
+ T1 = get_lib_dir(T, []),
+ {Args, T2} = collect_args(T1),
+ append_var(dialyzer_options_files_rec, Args),
+ cl(T2);
+cl(["--build_plt"|T]) ->
+ put(dialyzer_options_analysis_type, plt_build),
+ cl(T);
+cl(["--check_plt"|T]) ->
+ put(dialyzer_options_analysis_type, plt_check),
+ cl(T);
+cl(["-n"|T]) ->
+ cl(["--no_check_plt"|T]);
+cl(["--no_check_plt"|T]) ->
+ put(dialyzer_options_check_plt, false),
+ cl(T);
+cl(["--plt_info"|T]) ->
+ put(dialyzer_options_analysis_type, plt_info),
+ cl(T);
+cl(["--get_warnings"|T]) ->
+ put(dialyzer_options_get_warnings, true),
+ cl(T);
+cl(["-D"|_]) ->
+ error("No defines specified after -D");
+cl(["-D"++Define|T]) ->
+ Def = re:split(Define, "=", [{return, list}]),
+ append_defines(Def),
+ cl(T);
+cl(["-h"|_]) ->
+ help_message();
+cl(["--help"|_]) ->
+ help_message();
+cl(["-I"]) ->
+ error("no include directory specified after -I");
+cl(["-I", Dir|T]) ->
+ append_include(Dir),
+ cl(T);
+cl(["-I"++Dir|T]) ->
+ append_include(Dir),
+ cl(T);
+cl(["-c"++_|T]) ->
+ NewTail = command_line(T),
+ cl(NewTail);
+cl(["-r"++_|T0]) ->
+ {Args, T} = collect_args(T0),
+ append_var(dialyzer_options_files_rec, Args),
+ cl(T);
+cl(["--remove_from_plt"|T]) ->
+ put(dialyzer_options_analysis_type, plt_remove),
+ cl(T);
+cl(["--com"++_|T]) ->
+ NewTail = command_line(T),
+ cl(NewTail);
+cl(["--output"]) ->
+ error("No outfile specified");
+cl(["-o"]) ->
+ error("No outfile specified");
+cl(["--output",Output|T]) ->
+ put(dialyzer_output, Output),
+ cl(T);
+cl(["--output_plt"]) ->
+ error("No outfile specified for --output_plt");
+cl(["--output_plt",Output|T]) ->
+ put(dialyzer_output_plt, Output),
+ cl(T);
+cl(["-o", Output|T]) ->
+ put(dialyzer_output, Output),
+ cl(T);
+cl(["-o"++Output|T]) ->
+ put(dialyzer_output, Output),
+ cl(T);
+cl(["--raw"|T]) ->
+ put(dialyzer_output_format, raw),
+ cl(T);
+cl(["-pa", Path|T]) ->
+ case code:add_patha(Path) of
+ true -> cl(T);
+ {error, _} -> error("Bad directory for -pa: "++Path)
+ end;
+cl(["--plt", PLT|T]) ->
+ put(dialyzer_init_plt, PLT),
+ cl(T);
+cl(["--plt"]) ->
+ error("No plt specified for --plt");
+cl(["-q"|T]) ->
+ put(dialyzer_options_report_mode, quiet),
+ cl(T);
+cl(["--quiet"|T]) ->
+ put(dialyzer_options_report_mode, quiet),
+ cl(T);
+cl(["--src"|T]) ->
+ put(dialyzer_options_from, src_code),
+ cl(T);
+cl(["--no_spec"|T]) ->
+ put(dialyzer_options_use_contracts, false),
+ cl(T);
+cl(["-v"|_]) ->
+ io:format("Dialyzer version "++?VSN++"\n"),
+ erlang:halt(?RET_NOTHING_SUSPICIOUS);
+cl(["--version"|_]) ->
+ io:format("Dialyzer version "++?VSN++"\n"),
+ erlang:halt(?RET_NOTHING_SUSPICIOUS);
+cl(["--verbose"|T]) ->
+ put(dialyzer_options_report_mode, verbose),
+ cl(T);
+cl(["-W"|_]) ->
+ error("-W given without warning");
+cl(["-Whelp"|_]) ->
+ help_warnings();
+cl(["-W"++Warn|T]) ->
+ append_var(dialyzer_warnings, [list_to_atom(Warn)]),
+ cl(T);
+cl(["--dump_callgraph"]) ->
+ error("No outfile specified for --dump_callgraph");
+cl(["--dump_callgraph", File|T]) ->
+ put(dialyzer_callgraph_file, File),
+ cl(T);
+cl(["--gui"|T]) ->
+ put(dialyzer_options_mode, {gui, gs}),
+ cl(T);
+cl(["--wx"|T]) ->
+ put(dialyzer_options_mode, {gui, wx}),
+ cl(T);
+cl([H|_] = L) ->
+ case filelib:is_file(H) orelse filelib:is_dir(H) of
+ true ->
+ NewTail = command_line(L),
+ cl(NewTail);
+ false ->
+ error("Unknown option: "++H)
+ end;
+cl([]) ->
+ {RetTag, Opts} =
+ case get(dialyzer_options_analysis_type) =:= plt_info of
+ true ->
+ put(dialyzer_options_analysis_type, plt_check),
+ {plt_info, cl_options()};
+ false ->
+ case get(dialyzer_options_mode) of
+ {gui,_} = GUI -> {GUI, common_options()};
+ cl ->
+ case get(dialyzer_options_analysis_type) =:= plt_check of
+ true -> {check_init, cl_options()};
+ false -> {cl, cl_options()}
+ end
+ end
+ end,
+ case dialyzer_options:build(Opts) of
+ {error, Msg} -> error(Msg);
+ OptsRecord -> {RetTag, OptsRecord}
+ end.
+
+%%-----------------------------------------------------------------------
+
+command_line(T0) ->
+ {Args, T} = collect_args(T0),
+ append_var(dialyzer_options_files, Args),
+ %% if all files specified are ".erl" files, set the 'src' flag automatically
+ case lists:all(fun(F) -> filename:extension(F) =:= ".erl" end, Args) of
+ true -> put(dialyzer_options_from, src_code);
+ false -> ok
+ end,
+ T.
+
+error(Str) ->
+ Msg = lists:flatten(Str),
+ throw({dialyzer_cl_parse_error, Msg}).
+
+init() ->
+ put(dialyzer_options_mode, cl),
+ put(dialyzer_options_files_rec, []),
+ put(dialyzer_options_report_mode, normal),
+ put(dialyzer_warnings, []),
+ DefaultOpts = #options{},
+ put(dialyzer_include, DefaultOpts#options.include_dirs),
+ put(dialyzer_options_defines, DefaultOpts#options.defines),
+ put(dialyzer_options_files, DefaultOpts#options.files),
+ put(dialyzer_output_format, formatted),
+ put(dialyzer_options_check_plt, DefaultOpts#options.check_plt),
+ ok.
+
+append_defines([Def, Val]) ->
+ {ok, Tokens, _} = erl_scan:string(Val++"."),
+ {ok, ErlVal} = erl_parse:parse_term(Tokens),
+ append_var(dialyzer_options_defines, [{list_to_atom(Def), ErlVal}]);
+append_defines([Def]) ->
+ append_var(dialyzer_options_defines, [{list_to_atom(Def), true}]).
+
+append_include(Dir) ->
+ append_var(dialyzer_include, [Dir]).
+
+append_var(Var, List) when is_list(List) ->
+ put(Var, get(Var) ++ List),
+ ok.
+
+%%-----------------------------------------------------------------------
+
+-spec collect_args([string()]) -> {[string()], [string()]}.
+
+collect_args(List) ->
+ collect_args_1(List, []).
+
+collect_args_1(["-"++_|_] = L, Acc) ->
+ {lists:reverse(Acc), L};
+collect_args_1([Arg|T], Acc) ->
+ collect_args_1(T, [Arg|Acc]);
+collect_args_1([], Acc) ->
+ {lists:reverse(Acc), []}.
+
+%%-----------------------------------------------------------------------
+
+cl_options() ->
+ [{files, get(dialyzer_options_files)},
+ {files_rec, get(dialyzer_options_files_rec)},
+ {output_file, get(dialyzer_output)},
+ {output_format, get(dialyzer_output_format)},
+ {analysis_type, get(dialyzer_options_analysis_type)},
+ {get_warnings, get(dialyzer_options_get_warnings)},
+ {callgraph_file, get(dialyzer_callgraph_file)}
+ |common_options()].
+
+common_options() ->
+ [{defines, get(dialyzer_options_defines)},
+ {from, get(dialyzer_options_from)},
+ {include_dirs, get(dialyzer_include)},
+ {init_plt, get(dialyzer_init_plt)},
+ {output_plt, get(dialyzer_output_plt)},
+ {report_mode, get(dialyzer_options_report_mode)},
+ {use_spec, get(dialyzer_options_use_contracts)},
+ {warnings, get(dialyzer_warnings)},
+ {check_plt, get(dialyzer_options_check_plt)}].
+
+%%-----------------------------------------------------------------------
+
+get_lib_dir([H|T], Acc) ->
+ NewElem =
+ case code:lib_dir(list_to_atom(H)) of
+ {error, bad_name} ->
+ case H =:= "erts" of % hack for including erts in an un-installed system
+ true -> filename:join(code:root_dir(), "erts/preloaded/ebin");
+ false -> H
+ end;
+ LibDir -> LibDir ++ "/ebin"
+ end,
+ get_lib_dir(T, [NewElem|Acc]);
+get_lib_dir([], Acc) ->
+ lists:reverse(Acc).
+
+%%-----------------------------------------------------------------------
+
+help_warnings() ->
+ S = warning_options_msg(),
+ io:put_chars(S),
+ erlang:halt(?RET_NOTHING_SUSPICIOUS).
+
+help_message() ->
+ S = "Usage: dialyzer [--help] [--version] [--shell] [--quiet] [--verbose]
+ [-pa dir]* [--plt plt] [-Ddefine]* [-I include_dir]*
+ [--output_plt file] [-Wwarn]* [--src] [--gui | --wx]
+ [-c applications] [-r applications] [-o outfile]
+ [--build_plt] [--add_to_plt] [--remove_from_plt]
+ [--check_plt] [--no_check_plt] [--plt_info] [--get_warnings]
+Options:
+ -c applications (or --command-line applications)
+ Use Dialyzer from the command line (no GUI) to detect defects in the
+ specified applications (directories or .erl or .beam files)
+ -r applications
+ Same as -c only that directories are searched recursively for
+ subdirectories containing .erl or .beam files (depending on the
+ type of analysis)
+ -o outfile (or --output outfile)
+ When using Dialyzer from the command line, send the analysis
+ results to the specified \"outfile\" rather than to stdout
+ --raw
+ When using Dialyzer from the command line, output the raw analysis
+ results (Erlang terms) instead of the formatted result.
+ The raw format is easier to post-process (for instance, to filter
+ warnings or to output HTML pages)
+ --src
+ Override the default, which is to analyze BEAM files, and
+ analyze starting from Erlang source code instead
+ -Dname (or -Dname=value)
+ When analyzing from source, pass the define to Dialyzer (**)
+ -I include_dir
+ When analyzing from source, pass the include_dir to Dialyzer (**)
+ -pa dir
+ Include dir in the path for Erlang (useful when analyzing files
+ that have '-include_lib()' directives)
+ --output_plt file
+ Store the plt at the specified file after building it
+ --plt plt
+ Use the specified plt as the initial plt (if the plt was built
+ during setup the files will be checked for consistency)
+ -Wwarn
+ A family of options which selectively turn on/off warnings
+ (for help on the names of warnings use dialyzer -Whelp)
+ --shell
+ Do not disable the Erlang shell while running the GUI
+ --version (or -v)
+ Prints the Dialyzer version and some more information and exits
+ --help (or -h)
+ Prints this message and exits
+ --quiet (or -q)
+ Makes Dialyzer a bit more quiet
+ --verbose
+ Makes Dialyzer a bit more verbose
+ --build_plt
+ The analysis starts from an empty plt and creates a new one from the
+ files specified with -c and -r. Only works for beam files.
+ Use --plt or --output_plt to override the default plt location.
+ --add_to_plt
+ The plt is extended to also include the files specified with -c and -r.
+ Use --plt to specify wich plt to start from, and --output_plt to
+ specify where to put the plt. Note that the analysis might include
+ files from the plt if they depend on the new files.
+ This option only works with beam files.
+ --remove_from_plt
+ The information from the files specified with -c and -r is removed
+ from the plt. Note that this may cause a re-analysis of the remaining
+ dependent files.
+ --check_plt
+ Checks the plt for consistency and rebuilds it if it is not up-to-date.
+ Actually, this option is of rare use as it is on by default.
+ --no_check_plt (or -n)
+ Skip the plt check when running Dialyzer. Useful when working with
+ installed plts that never change.
+ --plt_info
+ Makes Dialyzer print information about the plt and then quit. The plt
+ can be specified with --plt.
+ --get_warnings
+ Makes Dialyzer emit warnings even when manipulating the plt. Only
+ emits warnings for files that are actually analyzed.
+ --dump_callgraph file
+ Dump the call graph into the specified file whose format is determined
+ by the file name extension. Supported extensions are: raw, dot, and ps.
+ If something else is used as file name extension, default format '.raw'
+ will be used.
+ --gui
+ Use the gs-based GUI.
+ --wx
+ Use the wx-based GUI.
+
+Note:
+ * denotes that multiple occurrences of these options are possible.
+ ** options -D and -I work both from command-line and in the Dialyzer GUI;
+ the syntax of defines and includes is the same as that used by \"erlc\".
+
+" ++ warning_options_msg() ++ "
+The exit status of the command line version is:
+ 0 - No problems were encountered during the analysis and no
+ warnings were emitted.
+ 1 - Problems were encountered during the analysis.
+ 2 - No problems were encountered, but warnings were emitted.
+",
+ io:put_chars(S),
+ erlang:halt(?RET_NOTHING_SUSPICIOUS).
+
+warning_options_msg() ->
+ "Warning options:
+ -Wno_return
+ Suppress warnings for functions that will never return a value.
+ -Wno_unused
+ Suppress warnings for unused functions.
+ -Wno_improper_lists
+ Suppress warnings for construction of improper lists.
+ -Wno_tuple_as_fun
+ Suppress warnings for using tuples instead of funs.
+ -Wno_fun_app
+ Suppress warnings for fun applications that will fail.
+ -Wno_match
+ Suppress warnings for patterns that are unused or cannot match.
+ -Wno_opaque
+ Suppress warnings for violations of opaqueness of data types.
+ -Wunmatched_returns ***
+ Include warnings for function calls which ignore a structured return
+ value or do not match against one of many possible return value(s).
+ -Werror_handling ***
+ Include warnings for functions that only return by means of an exception.
+ -Wrace_conditions ***
+ Include warnings for possible race conditions.
+ -Wunderspecs ***
+ Warn about underspecified functions
+ (those whose -spec is strictly more allowing than the success typing).
+
+The following options are also available but their use is not recommended:
+(they are mostly for Dialyzer developers and internal debugging)
+ -Woverspecs ***
+ Warn about overspecified functions
+ (those whose -spec is strictly less allowing than the success typing).
+ -Wspecdiffs ***
+ Warn when the -spec is different than the success typing.
+
+*** Identifies options that turn on warnings rather than turning them off.
+".
diff --git a/lib/dialyzer/src/dialyzer_codeserver.erl b/lib/dialyzer/src/dialyzer_codeserver.erl
new file mode 100644
index 0000000000..624501fc49
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_codeserver.erl
@@ -0,0 +1,282 @@
+%% -*- erlang-indent-level: 2 -*-
+%%-----------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2006-2009. 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%
+%%
+
+%%%-------------------------------------------------------------------
+%%% File : dialyzer_codeserver.erl
+%%% Author : Tobias Lindahl <[email protected]>
+%%% Description :
+%%%
+%%% Created : 4 Apr 2005 by Tobias Lindahl <[email protected]>
+%%%-------------------------------------------------------------------
+-module(dialyzer_codeserver).
+
+-export([delete/1,
+ finalize_contracts/2,
+ finalize_records/2,
+ get_contracts/1,
+ get_exports/1,
+ get_records/1,
+ get_next_core_label/1,
+ get_temp_contracts/1,
+ get_temp_records/1,
+ insert/3,
+ insert_exports/2,
+ is_exported/2,
+ lookup_mod_code/2,
+ lookup_mfa_code/2,
+ lookup_mod_records/2,
+ lookup_mod_contracts/2,
+ lookup_mfa_contract/2,
+ new/0,
+ set_next_core_label/2,
+ set_temp_records/2,
+ store_records/3,
+ store_temp_records/3,
+ store_contracts/3,
+ store_temp_contracts/3]).
+
+-include("dialyzer.hrl").
+
+%%--------------------------------------------------------------------
+
+-record(dialyzer_codeserver, {table_pid :: pid(),
+ exports = sets:new() :: set(), % set(mfa())
+ next_core_label = 0 :: label(),
+ records = dict:new() :: dict(),
+ temp_records = dict:new() :: dict(),
+ contracts = dict:new() :: dict(),
+ temp_contracts = dict:new() :: dict()}).
+
+-opaque codeserver() :: #dialyzer_codeserver{}.
+
+%%--------------------------------------------------------------------
+
+-spec new() -> codeserver().
+
+new() ->
+ #dialyzer_codeserver{table_pid = table__new()}.
+
+-spec delete(codeserver()) -> 'ok'.
+
+delete(#dialyzer_codeserver{table_pid = TablePid}) ->
+ table__delete(TablePid).
+
+-spec insert(module(), cerl:c_module(), codeserver()) -> codeserver().
+
+insert(Mod, ModCode, CS) ->
+ NewTablePid = table__insert(CS#dialyzer_codeserver.table_pid, Mod, ModCode),
+ CS#dialyzer_codeserver{table_pid = NewTablePid}.
+
+-spec insert_exports([mfa()], codeserver()) -> codeserver().
+
+insert_exports(List, #dialyzer_codeserver{exports = Exports} = CS) ->
+ Set = sets:from_list(List),
+ NewExports = sets:union(Exports, Set),
+ CS#dialyzer_codeserver{exports = NewExports}.
+
+-spec is_exported(mfa(), codeserver()) -> boolean().
+
+is_exported(MFA, #dialyzer_codeserver{exports = Exports}) ->
+ sets:is_element(MFA, Exports).
+
+-spec get_exports(codeserver()) -> set(). % set(mfa())
+
+get_exports(#dialyzer_codeserver{exports = Exports}) ->
+ Exports.
+
+-spec lookup_mod_code(module(), codeserver()) -> cerl:c_module().
+
+lookup_mod_code(Mod, CS) when is_atom(Mod) ->
+ table__lookup(CS#dialyzer_codeserver.table_pid, Mod).
+
+-spec lookup_mfa_code(mfa(), codeserver()) -> {cerl:c_var(), cerl:c_fun()}.
+
+lookup_mfa_code({_M, _F, _A} = MFA, CS) ->
+ table__lookup(CS#dialyzer_codeserver.table_pid, MFA).
+
+-spec get_next_core_label(codeserver()) -> label().
+
+get_next_core_label(#dialyzer_codeserver{next_core_label = NCL}) ->
+ NCL.
+
+-spec set_next_core_label(label(), codeserver()) -> codeserver().
+
+set_next_core_label(NCL, CS) ->
+ CS#dialyzer_codeserver{next_core_label = NCL}.
+
+-spec store_records(module(), dict(), codeserver()) -> codeserver().
+
+store_records(Mod, Dict, #dialyzer_codeserver{records = RecDict} = CS)
+ when is_atom(Mod) ->
+ case dict:size(Dict) =:= 0 of
+ true -> CS;
+ false -> CS#dialyzer_codeserver{records = dict:store(Mod, Dict, RecDict)}
+ end.
+
+-spec lookup_mod_records(module(), codeserver()) -> dict().
+
+lookup_mod_records(Mod, #dialyzer_codeserver{records = RecDict})
+ when is_atom(Mod) ->
+ case dict:find(Mod, RecDict) of
+ error -> dict:new();
+ {ok, Dict} -> Dict
+ end.
+
+-spec get_records(codeserver()) -> dict().
+
+get_records(#dialyzer_codeserver{records = RecDict}) ->
+ RecDict.
+
+-spec store_temp_records(module(), dict(), codeserver()) -> codeserver().
+
+store_temp_records(Mod, Dict, #dialyzer_codeserver{temp_records = TempRecDict} = CS)
+ when is_atom(Mod) ->
+ case dict:size(Dict) =:= 0 of
+ true -> CS;
+ false -> CS#dialyzer_codeserver{temp_records = dict:store(Mod, Dict, TempRecDict)}
+ end.
+
+-spec get_temp_records(codeserver()) -> dict().
+
+get_temp_records(#dialyzer_codeserver{temp_records = TempRecDict}) ->
+ TempRecDict.
+
+-spec set_temp_records(dict(), codeserver()) -> codeserver().
+
+set_temp_records(Dict, CS) ->
+ CS#dialyzer_codeserver{temp_records = Dict}.
+
+-spec finalize_records(dict(), codeserver()) -> codeserver().
+
+finalize_records(Dict, CS) ->
+ CS#dialyzer_codeserver{records = Dict, temp_records = dict:new()}.
+
+-spec store_contracts(module(), dict(), codeserver()) -> codeserver().
+
+store_contracts(Mod, Dict, #dialyzer_codeserver{contracts = C} = CS)
+ when is_atom(Mod) ->
+ case dict:size(Dict) =:= 0 of
+ true -> CS;
+ false -> CS#dialyzer_codeserver{contracts = dict:store(Mod, Dict, C)}
+ end.
+
+-spec lookup_mod_contracts(module(), codeserver()) -> dict().
+
+lookup_mod_contracts(Mod, #dialyzer_codeserver{contracts = ContDict})
+ when is_atom(Mod) ->
+ case dict:find(Mod, ContDict) of
+ error -> dict:new();
+ {ok, Dict} -> Dict
+ end.
+
+-spec lookup_mfa_contract(mfa(), codeserver()) ->
+ 'error' | {'ok', dialyzer_contracts:file_contract()}.
+
+lookup_mfa_contract({M,_F,_A} = MFA, #dialyzer_codeserver{contracts = ContDict}) ->
+ case dict:find(M, ContDict) of
+ error -> error;
+ {ok, Dict} -> dict:find(MFA, Dict)
+ end.
+
+-spec get_contracts(codeserver()) -> dict().
+
+get_contracts(#dialyzer_codeserver{contracts = ContDict}) ->
+ ContDict.
+
+-spec store_temp_contracts(module(), dict(), codeserver()) -> codeserver().
+
+store_temp_contracts(Mod, Dict, #dialyzer_codeserver{temp_contracts = C} = CS)
+ when is_atom(Mod) ->
+ case dict:size(Dict) =:= 0 of
+ true -> CS;
+ false -> CS#dialyzer_codeserver{temp_contracts = dict:store(Mod, Dict, C)}
+ end.
+
+-spec get_temp_contracts(codeserver()) -> dict().
+
+get_temp_contracts(#dialyzer_codeserver{temp_contracts = TempContDict}) ->
+ TempContDict.
+
+-spec finalize_contracts(dict(), codeserver()) -> codeserver().
+
+finalize_contracts(Dict, CS) ->
+ CS#dialyzer_codeserver{contracts = Dict, temp_contracts = dict:new()}.
+
+table__new() ->
+ spawn_link(fun() -> table__loop(none, dict:new()) end).
+
+table__delete(TablePid) ->
+ TablePid ! stop,
+ ok.
+
+table__lookup(TablePid, Key) ->
+ TablePid ! {self(), lookup, Key},
+ receive
+ {TablePid, Key, Ans} -> Ans
+ end.
+
+table__insert(TablePid, Key, Val) ->
+ TablePid ! {insert, [{Key, term_to_binary(Val, [compressed])}]},
+ TablePid.
+
+table__loop(Cached, Map) ->
+ receive
+ stop -> ok;
+ {Pid, lookup, {M, F, A} = MFA} ->
+ {NewCached, Ans} =
+ case Cached of
+ {M, Tree} ->
+ [Val] = [VarFun || {Var, _Fun} = VarFun <- cerl:module_defs(Tree),
+ cerl:fname_id(Var) =:= F,
+ cerl:fname_arity(Var) =:= A],
+ {Cached, Val};
+ _ ->
+ Tree = fetch_and_expand(M, Map),
+ [Val] = [VarFun || {Var, _Fun} = VarFun <- cerl:module_defs(Tree),
+ cerl:fname_id(Var) =:= F,
+ cerl:fname_arity(Var) =:= A],
+ {{M, Tree}, Val}
+ end,
+ Pid ! {self(), MFA, Ans},
+ table__loop(NewCached, Map);
+ {Pid, lookup, Mod} when is_atom(Mod) ->
+ Ans = case Cached of
+ {Mod, Tree} -> Tree;
+ _ -> fetch_and_expand(Mod, Map)
+ end,
+ Pid ! {self(), Mod, Ans},
+ table__loop({Mod, Ans}, Map);
+ {insert, List} ->
+ NewMap = lists:foldl(fun({Key, Val}, AccMap) ->
+ dict:store(Key, Val, AccMap)
+ end, Map, List),
+ table__loop(Cached, NewMap)
+ end.
+
+fetch_and_expand(Mod, Map) ->
+ try
+ Bin = dict:fetch(Mod, Map),
+ binary_to_term(Bin)
+ catch
+ _:_ ->
+ S = atom_to_list(Mod),
+ Msg = "found no module named '" ++ S ++ "' in the analyzed files",
+ exit({error, Msg})
+ end.
diff --git a/lib/dialyzer/src/dialyzer_contracts.erl b/lib/dialyzer/src/dialyzer_contracts.erl
new file mode 100644
index 0000000000..e2680bb03d
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_contracts.erl
@@ -0,0 +1,492 @@
+%% -*- erlang-indent-level: 2 -*-
+%%-----------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2007-2009. 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%
+%%
+
+-module(dialyzer_contracts).
+
+-export([check_contract/2,
+ check_contracts/3,
+ contracts_without_fun/3,
+ contract_to_string/1,
+ get_invalid_contract_warnings/3,
+ get_contract_args/1,
+ get_contract_return/1,
+ get_contract_return/2,
+ %% get_contract_signature/1,
+ is_overloaded/1,
+ process_contract_remote_types/1,
+ store_tmp_contract/5]).
+
+%%-----------------------------------------------------------------------
+
+-include("dialyzer.hrl").
+
+%%-----------------------------------------------------------------------
+%% Types used in other parts of the system below
+%%-----------------------------------------------------------------------
+
+-type file_contract() :: {file_line(), #contract{}}.
+
+-type plt_contracts() :: [{mfa(), #contract{}}]. % actually, an orddict()
+
+%%-----------------------------------------------------------------------
+%% Internal record for contracts whose components have not been processed
+%% to expand records and/or remote types that they might contain.
+%%-----------------------------------------------------------------------
+
+-type tmp_contract_fun() :: fun((dict()) -> contract_pair()).
+
+-record(tmp_contract, {contract_funs = [] :: [tmp_contract_fun()],
+ forms = [] :: [{_, _}]}).
+
+%%-----------------------------------------------------------------------
+
+%%-define(DEBUG, true).
+
+-ifdef(DEBUG).
+-define(debug(X__, Y__), io:format(X__, Y__)).
+-else.
+-define(debug(X__, Y__), ok).
+-endif.
+
+%%-----------------------------------------------------------------------
+
+-spec get_contract_return(#contract{}) -> erl_types:erl_type().
+
+get_contract_return(#contract{contracts = Cs, args = GenArgs}) ->
+ process_contracts(Cs, GenArgs).
+
+-spec get_contract_return(#contract{}, [erl_types:erl_type()]) -> erl_types:erl_type().
+
+get_contract_return(#contract{contracts = Cs}, Args) ->
+ process_contracts(Cs, Args).
+
+-spec get_contract_args(#contract{}) -> [erl_types:erl_type()].
+
+get_contract_args(#contract{args = Args}) ->
+ Args.
+
+-spec get_contract_signature(#contract{}) -> erl_types:erl_type().
+
+get_contract_signature(#contract{contracts = Cs, args = GeneralDomain}) ->
+ Range = process_contracts(Cs, GeneralDomain),
+ erl_types:t_fun(GeneralDomain, Range).
+
+-spec is_overloaded(#contract{}) -> boolean().
+
+is_overloaded(#contract{contracts = Cs}) ->
+ case Cs of
+ [_] -> true;
+ [_,_|_] -> false
+ end.
+
+-spec contract_to_string(#contract{}) -> string().
+
+contract_to_string(#contract{forms = Forms}) ->
+ contract_to_string_1(Forms).
+
+contract_to_string_1([{Contract, []}]) ->
+ strip_fun(erl_types:t_form_to_string(Contract));
+contract_to_string_1([{Contract, []}|Rest]) ->
+ strip_fun(erl_types:t_form_to_string(Contract)) ++ "\n ; "
+ ++ contract_to_string_1(Rest);
+contract_to_string_1([{Contract, Constraints}]) ->
+ strip_fun(erl_types:t_form_to_string(Contract)) ++ " when "
+ ++ constraints_to_string(Constraints);
+contract_to_string_1([{Contract, Constraints}|Rest]) ->
+ strip_fun(erl_types:t_form_to_string(Contract)) ++ " when "
+ ++ constraints_to_string(Constraints) ++ ";" ++
+ contract_to_string_1(Rest).
+
+strip_fun("fun(" ++ String) ->
+ butlast(String).
+
+butlast([]) -> [];
+butlast([_]) -> [];
+butlast([H|T]) -> [H|butlast(T)].
+
+constraints_to_string([]) ->
+ "";
+constraints_to_string([{type, _, constraint, [{atom, _, What}, Types]}]) ->
+ atom_to_list(What) ++ "(" ++
+ sequence([erl_types:t_form_to_string(T) || T <- Types], ",") ++ ")";
+constraints_to_string([{type, _, constraint, [{atom, _, What}, Types]}|Rest]) ->
+ atom_to_list(What) ++ "(" ++
+ sequence([erl_types:t_form_to_string(T) || T <- Types], ",")
+ ++ "), " ++ constraints_to_string(Rest).
+
+sequence([], _Delimiter) -> "";
+sequence([H], _Delimiter) -> H;
+sequence([H|T], Delimiter) -> H ++ Delimiter ++ sequence(T, Delimiter).
+
+-spec process_contract_remote_types(dialyzer_codeserver:codeserver()) ->
+ dialyzer_codeserver:codeserver().
+
+process_contract_remote_types(CodeServer) ->
+ TmpContractDict = dialyzer_codeserver:get_temp_contracts(CodeServer),
+ RecordDict = dialyzer_codeserver:get_records(CodeServer),
+ ContractFun =
+ fun({_M, _F, _A}, {File, #tmp_contract{contract_funs = CFuns, forms = Forms}}) ->
+ NewCs = [CFun(RecordDict) || CFun <- CFuns],
+ Args = general_domain(NewCs),
+ {File, #contract{contracts = NewCs, args = Args, forms = Forms}}
+ end,
+ ModuleFun =
+ fun(_ModuleName, ContractDict) ->
+ dict:map(ContractFun, ContractDict)
+ end,
+ NewContractDict = dict:map(ModuleFun, TmpContractDict),
+ dialyzer_codeserver:finalize_contracts(NewContractDict, CodeServer).
+
+-spec check_contracts([{mfa(), file_contract()}],
+ dialyzer_callgraph:callgraph(), dict()) -> plt_contracts().
+
+check_contracts(Contracts, Callgraph, FunTypes) ->
+ FoldFun =
+ fun(Label, Type, NewContracts) ->
+ {ok, {M,F,A} = MFA} = dialyzer_callgraph:lookup_name(Label, Callgraph),
+ case orddict:find(MFA, Contracts) of
+ {ok, {_FileLine, Contract}} ->
+ case check_contract(Contract, Type) of
+ ok ->
+ case erl_bif_types:is_known(M, F, A) of
+ true ->
+ %% Disregard the contracts since
+ %% this is a known function.
+ NewContracts;
+ false ->
+ [{MFA, Contract}|NewContracts]
+ end;
+ {error, _Error} -> NewContracts
+ end;
+ error -> NewContracts
+ end
+ end,
+ dict:fold(FoldFun, [], FunTypes).
+
+%% Checks all components of a contract
+-spec check_contract(#contract{}, erl_types:erl_type()) -> 'ok' | {'error', term()}.
+
+check_contract(#contract{contracts = Contracts}, SuccType) ->
+ try
+ Contracts1 = [{Contract, insert_constraints(Constraints, dict:new())}
+ || {Contract, Constraints} <- Contracts],
+ Contracts2 = [erl_types:t_subst(Contract, Dict)
+ || {Contract, Dict} <- Contracts1],
+ GenDomains = [erl_types:t_fun_args(C) || C <- Contracts2],
+ case check_domains(GenDomains) of
+ error ->
+ {error, {overlapping_contract, []}};
+ ok ->
+ InfList = [erl_types:t_inf(Contract, SuccType, opaque)
+ || Contract <- Contracts2],
+ check_contract_inf_list(InfList, SuccType)
+ end
+ catch throw:{error, _} = Error -> Error
+ end.
+
+check_domains([_]) -> ok;
+check_domains([Dom|Doms]) ->
+ Fun = fun(D) ->
+ erl_types:any_none_or_unit(erl_types:t_inf_lists(Dom, D, opaque))
+ end,
+ case lists:all(Fun, Doms) of
+ true -> check_domains(Doms);
+ false -> error
+ end.
+
+%% Allow a contract if one of the overloaded contracts is possible.
+%% We used to be more strict, e.g., all overloaded contracts had to be
+%% possible.
+check_contract_inf_list([FunType|Left], SuccType) ->
+ FunArgs = erl_types:t_fun_args(FunType),
+ case lists:any(fun erl_types:t_is_none_or_unit/1, FunArgs) of
+ true -> check_contract_inf_list(Left, SuccType);
+ false ->
+ STRange = erl_types:t_fun_range(SuccType),
+ case erl_types:t_is_none_or_unit(STRange) of
+ true -> ok;
+ false ->
+ Range = erl_types:t_fun_range(FunType),
+ case erl_types:t_is_none(erl_types:t_inf(STRange, Range, opaque)) of
+ true -> check_contract_inf_list(Left, SuccType);
+ false -> ok
+ end
+ end
+ end;
+check_contract_inf_list([], _SuccType) ->
+ {error, invalid_contract}.
+
+%% This is the heart of the "range function"
+-spec process_contracts([contract_pair()], [erl_types:erl_type()]) -> erl_types:erl_type().
+
+process_contracts(OverContracts, Args) ->
+ process_contracts(OverContracts, Args, erl_types:t_none()).
+
+process_contracts([OverContract|Left], Args, AccRange) ->
+ NewAccRange =
+ case process_contract(OverContract, Args) of
+ error -> AccRange;
+ {ok, Range} -> erl_types:t_sup(AccRange, Range)
+ end,
+ process_contracts(Left, Args, NewAccRange);
+process_contracts([], _Args, AccRange) ->
+ AccRange.
+
+-spec process_contract(contract_pair(), [erl_types:erl_type()]) -> 'error' | {'ok', erl_types:erl_type()}.
+
+process_contract({Contract, Constraints}, CallTypes0) ->
+ CallTypesFun = erl_types:t_fun(CallTypes0, erl_types:t_any()),
+ ContArgsFun = erl_types:t_fun(erl_types:t_fun_args(Contract),
+ erl_types:t_any()),
+ ?debug("Instance: Contract: ~s\n Arguments: ~s\n",
+ [erl_types:t_to_string(ContArgsFun),
+ erl_types:t_to_string(CallTypesFun)]),
+ case solve_constraints(ContArgsFun, CallTypesFun, Constraints) of
+ {ok, VarDict} ->
+ {ok, erl_types:t_subst(erl_types:t_fun_range(Contract), VarDict)};
+ error -> error
+ end.
+
+solve_constraints(Contract, Call, Constraints) ->
+ %% First make sure the call follows the constraints
+ CDict = insert_constraints(Constraints, dict:new()),
+ Contract1 = erl_types:t_subst(Contract, CDict),
+ %% Just a safe over-approximation.
+ %% TODO: Find the types for type variables properly
+ ContrArgs = erl_types:t_fun_args(Contract1),
+ CallArgs = erl_types:t_fun_args(Call),
+ InfList = erl_types:t_inf_lists(ContrArgs, CallArgs),
+ case erl_types:any_none_or_unit(InfList) of
+ true -> error;
+ false -> {ok, CDict}
+ end.
+ %%Inf = erl_types:t_inf(Contract1, Call),
+ %% Then unify with the constrained call type.
+ %% ?debug("Call: ~s\n", [erl_types:t_to_string(Call)]),
+ %% ?debug("Contract: ~s\n", [erl_types:t_to_string(Contract)]),
+ %% ?debug("Contract1: ~s\n", [erl_types:t_to_string(Contract1)]),
+ %% ?debug("Inf: ~s\n", [erl_types:t_to_string(Inf)]),
+ %% erl_types:t_assign_variables_to_subtype(Contract, Inf).
+
+%% Checks the contracts for functions that are not implemented
+-spec contracts_without_fun(dict(), [_], dialyzer_callgraph:callgraph()) -> [dial_warning()].
+
+contracts_without_fun(Contracts, AllFuns0, Callgraph) ->
+ AllFuns1 = [{dialyzer_callgraph:lookup_name(Label, Callgraph), Arity}
+ || {Label, Arity} <- AllFuns0],
+ AllFuns2 = [{M, F, A} || {{ok, {M, F, _}}, A} <- AllFuns1],
+ AllContractMFAs = dict:fetch_keys(Contracts),
+ ErrorContractMFAs = AllContractMFAs -- AllFuns2,
+ [warn_spec_missing_fun(MFA, Contracts) || MFA <- ErrorContractMFAs].
+
+warn_spec_missing_fun({M, F, A} = MFA, Contracts) ->
+ {FileLine, _Contract} = dict:fetch(MFA, Contracts),
+ {?WARN_CONTRACT_SYNTAX, FileLine, {spec_missing_fun, [M, F, A]}}.
+
+%% This treats the "when" constraints. It will be extended, we hope.
+insert_constraints([{subtype, Type1, Type2}|Left], Dict) ->
+ case erl_types:t_is_var(Type1) of
+ true ->
+ Name = erl_types:t_var_name(Type1),
+ Dict1 = case dict:find(Name, Dict) of
+ error ->
+ dict:store(Name, Type2, Dict);
+ {ok, VarType} ->
+ dict:store(Name, erl_types:t_inf(VarType, Type2), Dict)
+ end,
+ insert_constraints(Left, Dict1);
+ false ->
+ %% A lot of things should change to add supertypes
+ throw({error, io_lib:format("First argument of is_subtype constraint "
+ "must be a type variable\n", [])})
+ end;
+insert_constraints([], Dict) -> Dict.
+
+-spec store_tmp_contract(mfa(), file_line(), [_], dict(), dict()) -> dict().
+
+store_tmp_contract(MFA, FileLine, TypeSpec, SpecDict, RecordsDict) ->
+ %% io:format("contract from form: ~p\n", [TypeSpec]),
+ TmpContract = contract_from_form(TypeSpec, RecordsDict),
+ %% io:format("contract: ~p\n", [Contract]),
+ dict:store(MFA, {FileLine, TmpContract}, SpecDict).
+
+contract_from_form(Forms, RecDict) ->
+ {CFuns, Forms1} = contract_from_form(Forms, RecDict, [], []),
+ #tmp_contract{contract_funs = CFuns, forms = Forms1}.
+
+contract_from_form([{type, _, 'fun', [_, _]} = Form | Left], RecDict,
+ TypeAcc, FormAcc) ->
+ TypeFun =
+ fun(AllRecords) ->
+ Type = erl_types:t_from_form(Form, RecDict),
+ NewType = erl_types:t_solve_remote(Type, AllRecords),
+ {NewType, []}
+ end,
+ NewTypeAcc = [TypeFun | TypeAcc],
+ NewFormAcc = [{Form, []} | FormAcc],
+ contract_from_form(Left, RecDict, NewTypeAcc, NewFormAcc);
+contract_from_form([{type, _L1, bounded_fun,
+ [{type, _L2, 'fun', [_, _]} = Form, Constr]}| Left],
+ RecDict, TypeAcc, FormAcc) ->
+ TypeFun =
+ fun(AllRecords) ->
+ Constr1 = [constraint_from_form(C, RecDict, AllRecords) || C <- Constr],
+ VarDict = insert_constraints(Constr1, dict:new()),
+ Type = erl_types:t_from_form(Form, RecDict, VarDict),
+ NewType = erl_types:t_solve_remote(Type, AllRecords),
+ {NewType, Constr1}
+ end,
+ NewTypeAcc = [TypeFun | TypeAcc],
+ NewFormAcc = [{Form, Constr} | FormAcc],
+ contract_from_form(Left, RecDict, NewTypeAcc, NewFormAcc);
+contract_from_form([], _RecDict, TypeAcc, FormAcc) ->
+ {lists:reverse(TypeAcc), lists:reverse(FormAcc)}.
+
+constraint_from_form({type, _, constraint, [{atom, _, is_subtype},
+ [Type1, Type2]]}, RecDict, AllRecords) ->
+ T1 = erl_types:t_from_form(Type1, RecDict),
+ T2 = erl_types:t_from_form(Type2, RecDict),
+ T3 = erl_types:t_solve_remote(T1, AllRecords),
+ T4 = erl_types:t_solve_remote(T2, AllRecords),
+ {subtype, T3, T4};
+constraint_from_form({type, _, constraint, [{atom,_,Name}, List]}, _RecDict, _) ->
+ N = length(List),
+ throw({error, io_lib:format("Unsupported type guard ~w/~w\n", [Name, N])}).
+
+%% Gets the most general domain of a list of domains of all
+%% the overloaded contracts
+
+general_domain(List) ->
+ general_domain(List, erl_types:t_none()).
+
+general_domain([{Sig, Constraints}|Left], AccSig) ->
+ Dict = insert_constraints(Constraints, dict:new()),
+ Sig1 = erl_types:t_subst(Sig, Dict),
+ general_domain(Left, erl_types:t_sup(AccSig, Sig1));
+general_domain([], AccSig) ->
+ %% Get rid of all variables in the domain.
+ AccSig1 = erl_types:subst_all_vars_to_any(AccSig),
+ erl_types:t_fun_args(AccSig1).
+
+-spec get_invalid_contract_warnings([module()], dialyzer_codeserver:codeserver(), dialyzer_plt:plt()) -> [dial_warning()].
+
+get_invalid_contract_warnings(Modules, CodeServer, Plt) ->
+ get_invalid_contract_warnings_modules(Modules, CodeServer, Plt, []).
+
+get_invalid_contract_warnings_modules([Mod|Mods], CodeServer, Plt, Acc) ->
+ Contracts1 = dialyzer_codeserver:lookup_mod_contracts(Mod, CodeServer),
+ Contracts2 = dict:to_list(Contracts1),
+ Records = dialyzer_codeserver:lookup_mod_records(Mod, CodeServer),
+ NewAcc = get_invalid_contract_warnings_funs(Contracts2, Plt, Records, Acc),
+ get_invalid_contract_warnings_modules(Mods, CodeServer, Plt, NewAcc);
+get_invalid_contract_warnings_modules([], _CodeServer, _Plt, Acc) ->
+ Acc.
+
+get_invalid_contract_warnings_funs([{MFA, {FileLine, Contract}}|Left],
+ Plt, RecDict, Acc) ->
+ case dialyzer_plt:lookup(Plt, MFA) of
+ none ->
+ %% This must be a contract for a non-available function. Just accept it.
+ get_invalid_contract_warnings_funs(Left, Plt, RecDict, Acc);
+ {value, {Ret, Args}} ->
+ Sig = erl_types:t_fun(Args, Ret),
+ NewAcc =
+ case check_contract(Contract, Sig) of
+ {error, invalid_contract} ->
+ [invalid_contract_warning(MFA, FileLine, Sig, RecDict)|Acc];
+ {error, Msg} ->
+ [{?WARN_CONTRACT_SYNTAX, FileLine, Msg}|Acc];
+ ok ->
+ {M, F, A} = MFA,
+ CSig0 = get_contract_signature(Contract),
+ CSig = erl_types:subst_all_vars_to_any(CSig0),
+ case erl_bif_types:is_known(M, F, A) of
+ true ->
+ %% This is strictly for contracts of functions also in
+ %% erl_bif_types
+ BifArgs = erl_bif_types:arg_types(M, F, A),
+ BifRet = erl_bif_types:type(M, F, A),
+ BifSig = erl_types:t_fun(BifArgs, BifRet),
+ case check_contract(Contract, BifSig) of
+ {error, _} ->
+ [invalid_contract_warning(MFA, FileLine, BifSig, RecDict)
+ |Acc];
+ ok ->
+ picky_contract_check(CSig, BifSig, MFA, FileLine,
+ Contract, RecDict, Acc)
+ end;
+ false ->
+ picky_contract_check(CSig, Sig, MFA, FileLine, Contract,
+ RecDict, Acc)
+ end
+ end,
+ get_invalid_contract_warnings_funs(Left, Plt, RecDict, NewAcc)
+ end;
+get_invalid_contract_warnings_funs([], _Plt, _RecDict, Acc) ->
+ Acc.
+
+invalid_contract_warning({M, F, A}, FileLine, Type, RecDict) ->
+ {?WARN_CONTRACT_TYPES, FileLine,
+ {invalid_contract, [M, F, A, dialyzer_utils:format_sig(Type, RecDict)]}}.
+
+picky_contract_check(CSig0, Sig0, MFA, FileLine, Contract, RecDict, Acc) ->
+ CSig = erl_types:t_abstract_records(CSig0, RecDict),
+ Sig = erl_types:t_abstract_records(Sig0, RecDict),
+ case erl_types:t_is_equal(CSig, Sig) of
+ true -> Acc;
+ false ->
+ case (erl_types:t_is_none(erl_types:t_fun_range(Sig)) andalso
+ erl_types:t_is_unit(erl_types:t_fun_range(CSig))) of
+ true -> Acc;
+ false ->
+ case extra_contract_warning(MFA, FileLine, Contract,
+ CSig, Sig, RecDict) of
+ no_warning -> Acc;
+ {warning, Warning} -> [Warning|Acc]
+ end
+ end
+ end.
+
+extra_contract_warning({M, F, A}, FileLine, Contract, CSig, Sig, RecDict) ->
+ SigString = lists:flatten(dialyzer_utils:format_sig(Sig, RecDict)),
+ ContractString0 = lists:flatten(dialyzer_utils:format_sig(CSig, RecDict)),
+ case SigString =:= ContractString0 of
+ true ->
+ %% The only difference is in record fields containing 'undefined' or not.
+ no_warning;
+ false ->
+ ContractString = contract_to_string(Contract),
+ {Tag, Msg} =
+ case erl_types:t_is_subtype(CSig, Sig) of
+ true ->
+ {?WARN_CONTRACT_SUBTYPE,
+ {contract_subtype, [M, F, A, ContractString, SigString]}};
+ false ->
+ case erl_types:t_is_subtype(Sig, CSig) of
+ true ->
+ {?WARN_CONTRACT_SUPERTYPE,
+ {contract_supertype, [M, F, A, ContractString, SigString]}};
+ false ->
+ {?WARN_CONTRACT_NOT_EQUAL,
+ {contract_diff, [M, F, A, ContractString, SigString]}}
+ end
+ end,
+ {warning, {Tag, FileLine, Msg}}
+ end.
diff --git a/lib/dialyzer/src/dialyzer_dataflow.erl b/lib/dialyzer/src/dialyzer_dataflow.erl
new file mode 100644
index 0000000000..178321ea18
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_dataflow.erl
@@ -0,0 +1,3468 @@
+%% -*- erlang-indent-level: 2 -*-
+%%--------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2006-2009. 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%
+%%
+
+%%%-------------------------------------------------------------------
+%%% File : dialyzer_dataflow.erl
+%%% Author : Tobias Lindahl <[email protected]>
+%%% Description :
+%%%
+%%% Created : 19 Apr 2005 by Tobias Lindahl <[email protected]>
+%%%-------------------------------------------------------------------
+
+-module(dialyzer_dataflow).
+
+-export([get_fun_types/4, get_warnings/5, format_args/3]).
+
+-export([state__add_warning/2, state__cleanup/1,
+ state__get_callgraph/1, state__get_races/1,
+ state__get_records/1, state__put_callgraph/2,
+ state__put_races/2, state__records_only/1]).
+
+%% Debug and test interfaces.
+-export([get_top_level_signatures/2, pp/1]).
+
+-include("dialyzer.hrl").
+
+-import(erl_types,
+ [any_none/1, t_any/0, t_atom/0, t_atom/1, t_atom_vals/1,
+ t_binary/0, t_boolean/0,
+ t_bitstr/0, t_bitstr/2, t_bitstr_concat/1, t_bitstr_match/2,
+ t_cons/0, t_cons/2, t_cons_hd/1, t_cons_tl/1, t_contains_opaque/1,
+ t_find_opaque_mismatch/2, 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_inf/2, t_inf/3, t_inf_lists/2, t_inf_lists/3,
+ t_integer/0, t_integers/1,
+ t_is_any/1, t_is_atom/1, t_is_atom/2, t_is_boolean/1, t_is_equal/2,
+ t_is_integer/1, t_is_nil/1, t_is_none/1, t_is_none_or_unit/1,
+ t_is_number/1, t_is_reference/1, t_is_pid/1, t_is_port/1,
+ t_is_subtype/2, t_is_unit/1,
+ t_limit/2, t_list/0, t_maybe_improper_list/0, t_module/0,
+ t_none/0, t_non_neg_integer/0, t_number/0, t_number_vals/1,
+ t_opaque_match_atom/2, t_opaque_match_record/2,
+ t_opaque_matching_structure/2,
+ t_pid/0, t_port/0, t_product/1, t_reference/0,
+ t_sup/1, t_sup/2, t_subtract/2, t_to_string/2, t_to_tlist/1,
+ t_tuple/0, t_tuple/1, t_tuple_args/1, t_tuple_subtypes/1,
+ t_unit/0, t_unopaque/1]).
+
+%%-define(DEBUG, true).
+%%-define(DEBUG_PP, true).
+%%-define(DEBUG_TIME, true).
+%%-define(DOT, true).
+
+-ifdef(DEBUG).
+-import(erl_types, [t_to_string/1]).
+-define(debug(S_, L_), io:format(S_, L_)).
+-else.
+-define(debug(S_, L_), ok).
+-endif.
+
+%%-define(debug1(S_, L_), io:format(S_, L_)).
+%%-define(debug1(S_, L_), ok).
+
+%%--------------------------------------------------------------------
+
+-define(no_arg, no_arg).
+
+-define(TYPE_LIMIT, 3).
+
+-record(state, {callgraph :: dialyzer_callgraph:callgraph(),
+ envs :: dict(),
+ fun_tab :: dict(),
+ plt :: dialyzer_plt:plt(),
+ opaques :: [erl_types:erl_type()],
+ races :: dialyzer_races:races(),
+ records :: dict(),
+ tree_map :: dict(),
+ warning_mode = false :: boolean(),
+ warnings = [] :: [dial_warning()],
+ work :: {[_], [_], set()}}).
+
+%% Exported Types
+
+-type state() :: #state{}.
+
+%%--------------------------------------------------------------------
+
+-spec get_warnings(cerl:c_module(), dialyzer_plt:plt(),
+ dialyzer_callgraph:callgraph(), dict(), set()) ->
+ {[dial_warning()], dict(), dict(), [label()], [string()]}.
+
+get_warnings(Tree, Plt, Callgraph, Records, NoWarnUnused) ->
+ State1 = analyze_module(Tree, Plt, Callgraph, Records, true),
+ State2 = find_mismatched_record_patterns(Tree, State1),
+ State3 =
+ state__renew_warnings(state__get_warnings(State2, NoWarnUnused), State2),
+ State4 = state__get_race_warnings(State3),
+ Callgraph1 = State2#state.callgraph,
+ {State4#state.warnings, state__all_fun_types(State4),
+ dialyzer_callgraph:get_race_code(Callgraph1),
+ dialyzer_callgraph:get_public_tables(Callgraph1),
+ dialyzer_callgraph:get_named_tables(Callgraph1)}.
+
+-spec get_fun_types(cerl:c_module(), dialyzer_plt:plt(),
+ dialyzer_callgraph:callgraph(), dict()) ->
+ {dict(), dict(), [label()], [string()]}.
+
+get_fun_types(Tree, Plt, Callgraph, Records) ->
+ State = analyze_module(Tree, Plt, Callgraph, Records, false),
+ Callgraph1 = State#state.callgraph,
+ {state__all_fun_types(State),
+ dialyzer_callgraph:get_race_code(Callgraph1),
+ dialyzer_callgraph:get_public_tables(Callgraph1),
+ dialyzer_callgraph:get_named_tables(Callgraph1)}.
+
+%%--------------------------------------------------------------------
+
+-spec pp(file:filename()) -> 'ok'.
+
+pp(File) ->
+ {ok, Code} = dialyzer_utils:get_core_from_src(File, [no_copt]),
+ Plt = get_def_plt(),
+ AnnTree = annotate_module(Code, Plt),
+ io:put_chars(cerl_prettypr:format(AnnTree, [{hook, cerl_typean:pp_hook()}])),
+ io:nl().
+
+%%--------------------------------------------------------------------
+%% This is used in the testsuite.
+
+-spec get_top_level_signatures(cerl:c_module(), dict()) ->
+ [{{atom(), arity()}, erl_types:erl_type()}].
+
+get_top_level_signatures(Code, Records) ->
+ {Tree, _} = cerl_trees:label(cerl:from_records(Code)),
+ Callgraph0 = dialyzer_callgraph:new(),
+ Callgraph1 = dialyzer_callgraph:scan_core_tree(Tree, Callgraph0),
+ {Callgraph2, _} = dialyzer_callgraph:remove_external(Callgraph1),
+ Callgraph = dialyzer_callgraph:finalize(Callgraph2),
+ to_dot(Callgraph),
+ Plt = get_def_plt(),
+ FunTypes = get_fun_types(Tree, Plt, Callgraph, Records),
+ FunTypes1 = lists:foldl(fun({V, F}, Acc) ->
+ Label = get_label(F),
+ case dict:find(Label, Acc) of
+ error ->
+ Arity = cerl:fname_arity(V),
+ Type = t_fun(lists:duplicate(Arity,
+ t_none()),
+ t_none()),
+ dict:store(Label, Type, Acc);
+ {ok, _} -> Acc
+ end
+ end, FunTypes, cerl:module_defs(Tree)),
+ dialyzer_callgraph:delete(Callgraph),
+ Sigs = [{{cerl:fname_id(V), cerl:fname_arity(V)},
+ dict:fetch(get_label(F), FunTypes1)}
+ || {V, F} <- cerl:module_defs(Tree)],
+ ordsets:from_list(Sigs).
+
+get_def_plt() ->
+ try
+ dialyzer_plt:from_file(dialyzer_plt:get_default_plt())
+ catch
+ throw:{dialyzer_error, _} -> dialyzer_plt:new()
+ end.
+
+%%% ===========================================================================
+%%%
+%%% Annotate all top level funs.
+%%%
+%%% ===========================================================================
+
+annotate_module(Code, Plt) ->
+ {Tree, _} = cerl_trees:label(cerl:from_records(Code)),
+ Callgraph0 = dialyzer_callgraph:new(),
+ Callgraph1 = dialyzer_callgraph:scan_core_tree(Tree, Callgraph0),
+ {Callgraph2, _} = dialyzer_callgraph:remove_external(Callgraph1),
+ Callgraph = dialyzer_callgraph:finalize(Callgraph2),
+ State = analyze_module(Tree, Plt, Callgraph),
+ Res = annotate(Tree, State),
+ dialyzer_callgraph:delete(Callgraph),
+ Res.
+
+annotate(Tree, State) ->
+ case cerl:subtrees(Tree) of
+ [] -> set_type(Tree, State);
+ List ->
+ NewSubTrees = [[annotate(Subtree, State) || Subtree <- Group]
+ || Group <- List],
+ NewTree = cerl:update_tree(Tree, NewSubTrees),
+ set_type(NewTree, State)
+ end.
+
+set_type(Tree, State) ->
+ case cerl:type(Tree) of
+ 'fun' ->
+ Type = state__fun_type(Tree, State),
+ case t_is_any(Type) of
+ true ->
+ cerl:set_ann(Tree, delete_ann(typesig, cerl:get_ann(Tree)));
+ false ->
+ cerl:set_ann(Tree, append_ann(typesig, Type, cerl:get_ann(Tree)))
+ end;
+ apply ->
+ case state__find_apply_return(Tree, State) of
+ unknown -> Tree;
+ ReturnType ->
+ case t_is_any(ReturnType) of
+ true ->
+ cerl:set_ann(Tree, delete_ann(type, cerl:get_ann(Tree)));
+ false ->
+ cerl:set_ann(Tree, append_ann(type, ReturnType,
+ cerl:get_ann(Tree)))
+ end
+ end;
+ _ ->
+ Tree
+ end.
+
+append_ann(Tag, Val, [X | Xs]) ->
+ if tuple_size(X) >= 1, element(1, X) =:= Tag ->
+ append_ann(Tag, Val, Xs);
+ true ->
+ [X | append_ann(Tag, Val, Xs)]
+ end;
+append_ann(Tag, Val, []) ->
+ [{Tag, Val}].
+
+delete_ann(Tag, [X | Xs]) ->
+ if tuple_size(X) >= 1, element(1, X) =:= Tag ->
+ delete_ann(Tag, Xs);
+ true ->
+ [X | delete_ann(Tag, Xs)]
+ end;
+delete_ann(_, []) ->
+ [].
+
+%%% ===========================================================================
+%%%
+%%% The analysis.
+%%%
+%%% ===========================================================================
+
+analyze_module(Tree, Plt, Callgraph) ->
+ analyze_module(Tree, Plt, Callgraph, dict:new(), false).
+
+analyze_module(Tree, Plt, Callgraph, Records, GetWarnings) ->
+ debug_pp(Tree, false),
+ Module = cerl:atom_val(cerl:module_name(Tree)),
+ TopFun = cerl:ann_c_fun([{label, top}], [], Tree),
+ State =
+ state__new(dialyzer_callgraph:race_code_new(Callgraph),
+ TopFun, Plt, Module, Records),
+ State1 = state__race_analysis(not GetWarnings, State),
+ State2 = analyze_loop(State1),
+ RaceCode = dialyzer_callgraph:get_race_code(Callgraph),
+ Callgraph1 = State2#state.callgraph,
+ RaceCode1 = dialyzer_callgraph:get_race_code(Callgraph1),
+ case GetWarnings of
+ true ->
+ State3 = state__set_warning_mode(State2),
+ State4 = analyze_loop(State3),
+ State5 = state__restore_race_code(RaceCode, State4),
+ dialyzer_races:race(State5);
+ false ->
+ state__restore_race_code(
+ dict:merge(fun (_K, V1, _V2) -> V1 end,
+ RaceCode, RaceCode1), State2)
+ end.
+
+analyze_loop(#state{callgraph = Callgraph, races = Races} = State) ->
+ case state__get_work(State) of
+ none -> state__clean_not_called(State);
+ {Fun, NewState} ->
+ ArgTypes = state__get_args(Fun, NewState),
+ case any_none(ArgTypes) of
+ true ->
+ ?debug("Not handling1 ~w: ~s\n",
+ [state__lookup_name(get_label(Fun), State),
+ t_to_string(t_product(ArgTypes))]),
+ analyze_loop(NewState);
+ false ->
+ case state__fun_env(Fun, NewState) of
+ none ->
+ ?debug("Not handling2 ~w: ~s\n",
+ [state__lookup_name(get_label(Fun), State),
+ t_to_string(t_product(ArgTypes))]),
+ analyze_loop(NewState);
+ Map ->
+ ?debug("Handling fun ~p: ~s\n",
+ [state__lookup_name(get_label(Fun), State),
+ t_to_string(state__fun_type(Fun, NewState))]),
+ NewState1 = state__mark_fun_as_handled(NewState, Fun),
+ Vars = cerl:fun_vars(Fun),
+ Map1 = enter_type_lists(Vars, ArgTypes, Map),
+ Body = cerl:fun_body(Fun),
+ FunLabel = get_label(Fun),
+ RaceDetection = dialyzer_callgraph:get_race_detection(Callgraph),
+ RaceAnalysis = dialyzer_races:get_race_analysis(Races),
+ NewState3 =
+ case RaceDetection andalso RaceAnalysis of
+ true ->
+ NewState2 = state__renew_curr_fun(
+ state__lookup_name(FunLabel, NewState1), FunLabel,
+ NewState1),
+ state__renew_race_list([], 0, NewState2);
+ false -> NewState1
+ end,
+ {NewState4, _Map2, BodyType} =
+ traverse(Body, Map1, NewState3),
+ ?debug("Done analyzing: ~w:~s\n",
+ [state__lookup_name(get_label(Fun), State),
+ t_to_string(t_fun(ArgTypes, BodyType))]),
+ NewState5 =
+ case RaceDetection andalso RaceAnalysis of
+ true ->
+ Races1 = NewState4#state.races,
+ Code = lists:reverse(dialyzer_races:get_race_list(Races1)),
+ Callgraph1 =
+ renew_code(dialyzer_races:get_curr_fun(Races1),
+ dialyzer_races:get_curr_fun_args(Races1),
+ Code,
+ state__warning_mode(NewState4),
+ NewState4#state.callgraph),
+ NewState4#state{callgraph = Callgraph1};
+ false -> NewState4
+ end,
+ NewState6 =
+ state__update_fun_entry(Fun, ArgTypes, BodyType, NewState5),
+ ?debug("done adding stuff for ~w\n",
+ [state__lookup_name(get_label(Fun), State)]),
+ analyze_loop(NewState6)
+ end
+ end
+ end.
+
+traverse(Tree, Map, State) ->
+ ?debug("Handling ~p\n", [cerl:type(Tree)]),
+ %%debug_pp_map(Map),
+ case cerl:type(Tree) of
+ alias ->
+ %% This only happens when checking for illegal record patterns
+ %% so the handling is a bit rudimentary.
+ traverse(cerl:alias_pat(Tree), Map, State);
+ apply ->
+ handle_apply(Tree, Map, State);
+ binary ->
+ Segs = cerl:binary_segments(Tree),
+ {State1, Map1, SegTypes} = traverse_list(Segs, Map, State),
+ {State1, Map1, t_bitstr_concat(SegTypes)};
+ bitstr ->
+ handle_bitstr(Tree, Map, State);
+ call ->
+ handle_call(Tree, Map, State);
+ 'case' ->
+ handle_case(Tree, Map, State);
+ 'catch' ->
+ {State1, _Map1, _} = traverse(cerl:catch_body(Tree), Map, State),
+ {State1, Map, t_any()};
+ cons ->
+ handle_cons(Tree, Map, State);
+ 'fun' ->
+ Type = state__fun_type(Tree, State),
+ case state__warning_mode(State) of
+ true -> {State, Map, Type};
+ false ->
+ State2 = state__add_work(get_label(Tree), State),
+ State3 = state__update_fun_env(Tree, Map, State2),
+ {State3, Map, Type}
+ end;
+ 'let' ->
+ handle_let(Tree, Map, State);
+ letrec ->
+ Defs = cerl:letrec_defs(Tree),
+ Body = cerl:letrec_body(Tree),
+ %% By not including the variables in scope we can assure that we
+ %% will get the current function type when using the variables.
+ FoldFun = fun({Var, Fun}, {AccState, AccMap}) ->
+ {NewAccState, NewAccMap0, FunType} =
+ traverse(Fun, AccMap, AccState),
+ NewAccMap = enter_type(Var, FunType, NewAccMap0),
+ {NewAccState, NewAccMap}
+ end,
+ {State1, Map1} = lists:foldl(FoldFun, {State, Map}, Defs),
+ traverse(Body, Map1, State1);
+ literal ->
+ %% This is needed for finding records
+ case cerl:unfold_literal(Tree) of
+ Tree ->
+ Type = literal_type(Tree),
+ NewType =
+ case erl_types:t_opaque_match_atom(Type, State#state.opaques) of
+ [Opaque] -> Opaque;
+ _ -> Type
+ end,
+ {State, Map, NewType};
+ NewTree -> traverse(NewTree, Map, State)
+ end;
+ module ->
+ handle_module(Tree, Map, State);
+ primop ->
+ Type =
+ case cerl:atom_val(cerl:primop_name(Tree)) of
+ match_fail -> t_none();
+ raise -> t_none();
+ bs_init_writable -> t_from_term(<<>>);
+ Other -> erlang:error({'Unsupported primop', Other})
+ end,
+ {State, Map, Type};
+ 'receive' ->
+ handle_receive(Tree, Map, State);
+ seq ->
+ Arg = cerl:seq_arg(Tree),
+ Body = cerl:seq_body(Tree),
+ {State1, Map1, ArgType} = SMA = traverse(Arg, Map, State),
+ case t_is_none_or_unit(ArgType) of
+ true ->
+ SMA;
+ false ->
+ State2 =
+ case (t_is_any(ArgType) orelse t_is_simple(ArgType)
+ orelse is_call_to_send(Arg)) of
+ true -> % do not warn in these cases
+ State1;
+ false ->
+ state__add_warning(State1, ?WARN_UNMATCHED_RETURN, Arg,
+ {unmatched_return,
+ [format_type(ArgType, State1)]})
+ end,
+ traverse(Body, Map1, State2)
+ end;
+ 'try' ->
+ handle_try(Tree, Map, State);
+ tuple ->
+ handle_tuple(Tree, Map, State);
+ values ->
+ Elements = cerl:values_es(Tree),
+ {State1, Map1, EsType} = traverse_list(Elements, Map, State),
+ Type = t_product(EsType),
+ {State1, Map1, Type};
+ var ->
+ ?debug("Looking up unknown variable: ~p\n", [Tree]),
+ case state__lookup_type_for_rec_var(Tree, State) of
+ error ->
+ LType = lookup_type(Tree, Map),
+ Opaques = State#state.opaques,
+ case t_opaque_match_record(LType, Opaques) of
+ [Opaque] -> {State, Map, Opaque};
+ _ ->
+ case t_opaque_match_atom(LType, Opaques) of
+ [Opaque] -> {State, Map, Opaque};
+ _ -> {State, Map, LType}
+ end
+ end;
+ {ok, Type} -> {State, Map, Type}
+ end;
+ Other ->
+ erlang:error({'Unsupported type', Other})
+ end.
+
+traverse_list(Trees, Map, State) ->
+ traverse_list(Trees, Map, State, []).
+
+traverse_list([Tree|Tail], Map, State, Acc) ->
+ {State1, Map1, Type} = traverse(Tree, Map, State),
+ traverse_list(Tail, Map1, State1, [Type|Acc]);
+traverse_list([], Map, State, Acc) ->
+ {State, Map, lists:reverse(Acc)}.
+
+%%________________________________________
+%%
+%% Special instructions
+%%
+
+handle_apply(Tree, Map, State) ->
+ Args = cerl:apply_args(Tree),
+ Op = cerl:apply_op(Tree),
+ {State1, Map1, ArgTypes} = traverse_list(Args, Map, State),
+ {State2, Map2, OpType} = traverse(Op, Map1, State1),
+ case any_none(ArgTypes) of
+ true ->
+ {State2, Map2, t_none()};
+ false ->
+ {CallSitesKnown, FunList} =
+ case state__lookup_call_site(Tree, State2) of
+ error -> {false, []};
+ {ok, [external]} -> {false, {}};
+ {ok, List} -> {true, List}
+ end,
+ case CallSitesKnown of
+ false ->
+ Arity = length(Args),
+ OpType1 = t_inf(OpType, t_fun(Arity, t_any())),
+ case t_is_none(OpType1) of
+ true ->
+ Msg = {fun_app_no_fun,
+ [format_cerl(Op), format_type(OpType, State2), Arity]},
+ State3 = state__add_warning(State2, ?WARN_FAILING_CALL,
+ Tree, Msg),
+ {State3, Map2, t_none()};
+ false ->
+ NewArgs = t_inf_lists(ArgTypes, t_fun_args(OpType1)),
+ case any_none(NewArgs) of
+ true ->
+ Msg = {fun_app_args,
+ [format_args(Args, ArgTypes, State),
+ format_type(OpType, State)]},
+ State3 = state__add_warning(State2, ?WARN_FAILING_CALL,
+ Tree, Msg),
+ {State3, enter_type(Op, OpType1, Map2), t_none()};
+ false ->
+ Map3 = enter_type_lists(Args, NewArgs, Map2),
+ {State2, enter_type(Op, OpType1, Map3), t_fun_range(OpType1)}
+ end
+ end;
+ true ->
+ FunInfoList = [{local, state__fun_info(Fun, State)}
+ || Fun <- FunList],
+ handle_apply_or_call(FunInfoList, Args, ArgTypes, Map2, Tree, State1)
+ end
+ end.
+
+handle_apply_or_call(FunInfoList, Args, ArgTypes, Map, Tree, State) ->
+ None = t_none(),
+ handle_apply_or_call(FunInfoList, Args, ArgTypes, Map, Tree, State,
+ [None || _ <- ArgTypes], None).
+
+handle_apply_or_call([{local, external}|Left], Args, ArgTypes, Map, Tree, State,
+ _AccArgTypes, _AccRet) ->
+ handle_apply_or_call(Left, Args, ArgTypes, Map, Tree, State,
+ ArgTypes, t_any());
+handle_apply_or_call([{TypeOfApply, {Fun, Sig, Contr, LocalRet}}|Left],
+ Args, ArgTypes, Map, Tree,
+ #state{callgraph = Callgraph, races = Races,
+ opaques = Opaques} = State,
+ AccArgTypes, AccRet) ->
+ Any = t_any(),
+ AnyArgs = [Any || _ <- Args],
+ GenSig = {AnyArgs, fun(_) -> t_any() end},
+ {CArgs, CRange} =
+ case Contr of
+ {value, #contract{args = As} = C} ->
+ {As, fun(FunArgs) ->
+ dialyzer_contracts:get_contract_return(C, FunArgs)
+ end};
+ none -> GenSig
+ end,
+ {BifArgs, BifRange} =
+ case TypeOfApply of
+ remote ->
+ {M, F, A} = Fun,
+ case erl_bif_types:is_known(M, F, A) of
+ true ->
+ BArgs = erl_bif_types:arg_types(M, F, A),
+ BRange =
+ fun(FunArgs) ->
+ ArgPos = erl_bif_types:structure_inspecting_args(M, F, A),
+ NewFunArgs =
+ case ArgPos =:= [] of
+ true -> FunArgs;
+ false -> % some positions need to be un-opaqued
+ N = length(FunArgs),
+ PFs = lists:zip(lists:seq(1, N), FunArgs),
+ [case ordsets:is_element(P, ArgPos) of
+ true -> erl_types:t_unopaque(FArg, Opaques);
+ false -> FArg
+ end || {P, FArg} <- PFs]
+ end,
+ erl_bif_types:type(M, F, A, NewFunArgs)
+ end,
+ {BArgs, BRange};
+ false -> GenSig
+ end;
+ local -> GenSig
+ end,
+ {SigArgs, SigRange} =
+ %% if there is hard-coded or contract information with opaque types,
+ %% the checking for possible type violations needs to take place w.r.t.
+ %% this information and not w.r.t. the structure-based success typing.
+ case prefer_opaque_types(CArgs, BifArgs) of
+ true -> {AnyArgs, t_any()}; % effectively forgets the success typing
+ false ->
+ case Sig of
+ {value, {SR, SA}} -> {SA, SR};
+ none -> {AnyArgs, t_any()}
+ end
+ end,
+ NewArgsSig = t_inf_lists(SigArgs, ArgTypes),
+ NewArgsContract = t_inf_lists(CArgs, ArgTypes),
+ NewArgsBif = t_inf_lists(BifArgs, ArgTypes),
+ NewArgTypes0 = t_inf_lists(NewArgsSig, NewArgsContract),
+ NewArgTypes = t_inf_lists(NewArgTypes0, NewArgsBif),
+ BifRet = BifRange(NewArgTypes),
+ ContrRet = CRange(NewArgTypes),
+ Mode = case t_contains_opaque(ContrRet) orelse t_contains_opaque(BifRet) of
+ true -> opaque;
+ false -> structured
+ end,
+ RetWithoutLocal = t_inf(t_inf(ContrRet, BifRet, Mode), SigRange, Mode),
+ ?debug("--------------------------------------------------------\n", []),
+ ?debug("Fun: ~p\n", [Fun]),
+ ?debug("Args: ~s\n", [erl_types:t_to_string(t_product(ArgTypes))]),
+ ?debug("NewArgsSig: ~s\n", [erl_types:t_to_string(t_product(NewArgsSig))]),
+ ?debug("NewArgsContract: ~s\n",
+ [erl_types:t_to_string(t_product(NewArgsContract))]),
+ ?debug("NewArgsBif: ~s\n", [erl_types:t_to_string(t_product(NewArgsBif))]),
+ ?debug("NewArgTypes: ~s\n", [erl_types:t_to_string(t_product(NewArgTypes))]),
+ ?debug("RetWithoutLocal: ~s\n", [erl_types:t_to_string(RetWithoutLocal)]),
+ ?debug("BifRet: ~s\n", [erl_types:t_to_string(BifRange(NewArgTypes))]),
+ ?debug("ContrRet: ~s\n", [erl_types:t_to_string(CRange(NewArgTypes))]),
+ ?debug("SigRet: ~s\n", [erl_types:t_to_string(SigRange)]),
+ State1 =
+ case dialyzer_callgraph:get_race_detection(Callgraph) andalso
+ dialyzer_races:get_race_analysis(Races) of
+ true ->
+ Ann = cerl:get_ann(Tree),
+ File = get_file(Ann),
+ Line = abs(get_line(Ann)),
+ dialyzer_races:store_race_call(Fun, ArgTypes, Args, {File, Line},
+ State);
+ false -> State
+ end,
+ FailedConj = any_none([RetWithoutLocal|NewArgTypes]),
+ IsFailBif = t_is_none(BifRange(BifArgs)),
+ IsFailSig = t_is_none(SigRange),
+ State2 =
+ case FailedConj andalso not (IsFailBif orelse IsFailSig) of
+ true ->
+ FailedSig = any_none(NewArgsSig),
+ FailedContract = any_none([CRange(NewArgsContract)|NewArgsContract]),
+ FailedBif = any_none([BifRange(NewArgsBif)|NewArgsBif]),
+ InfSig = t_inf(t_fun(SigArgs, SigRange),
+ t_fun(BifArgs, BifRange(BifArgs))),
+ FailReason = apply_fail_reason(FailedSig, FailedBif, FailedContract),
+ Msg = get_apply_fail_msg(Fun, Args, ArgTypes, NewArgTypes, InfSig,
+ Contr, CArgs, State1, FailReason),
+ WarnType = case Msg of
+ {call, _} -> ?WARN_FAILING_CALL;
+ {apply, _} -> ?WARN_FAILING_CALL;
+ {call_with_opaque, _} -> ?WARN_OPAQUE;
+ {call_without_opaque, _} -> ?WARN_OPAQUE;
+ {opaque_type_test, _} -> ?WARN_OPAQUE
+ end,
+ state__add_warning(State1, WarnType, Tree, Msg);
+ false -> State1
+ end,
+ State3 =
+ case TypeOfApply of
+ local ->
+ case state__is_escaping(Fun, State2) of
+ true -> State2;
+ false ->
+ ForwardArgs = [t_limit(X, ?TYPE_LIMIT) || X <- ArgTypes],
+ forward_args(Fun, ForwardArgs, State2)
+ end;
+ remote ->
+ add_bif_warnings(Fun, NewArgTypes, Tree, State2)
+ end,
+ NewAccArgTypes =
+ case FailedConj of
+ true -> AccArgTypes;
+ false -> [t_sup(X, Y) || {X, Y} <- lists:zip(NewArgTypes, AccArgTypes)]
+ end,
+ NewAccRet = t_sup(AccRet, t_inf(RetWithoutLocal, LocalRet, opaque)),
+ handle_apply_or_call(Left, Args, ArgTypes, Map, Tree,
+ State3, NewAccArgTypes, NewAccRet);
+handle_apply_or_call([], Args, _ArgTypes, Map, _Tree, State,
+ AccArgTypes, AccRet) ->
+ NewMap = enter_type_lists(Args, AccArgTypes, Map),
+ {State, NewMap, AccRet}.
+
+apply_fail_reason(FailedSig, FailedBif, FailedContract) ->
+ if
+ (FailedSig orelse FailedBif) andalso (not FailedContract) -> only_sig;
+ FailedContract andalso (not (FailedSig orelse FailedBif)) -> only_contract;
+ true -> both
+ end.
+
+get_apply_fail_msg(Fun, Args, ArgTypes, NewArgTypes,
+ Sig, Contract, ContrArgs, State, FailReason) ->
+ ArgStrings = format_args(Args, ArgTypes, State),
+ ContractInfo =
+ case Contract of
+ {value, #contract{} = C} ->
+ {dialyzer_contracts:is_overloaded(C),
+ dialyzer_contracts:contract_to_string(C)};
+ none -> {false, none}
+ end,
+ EnumArgTypes =
+ case NewArgTypes of
+ [] -> [];
+ _ -> lists:zip(lists:seq(1, length(NewArgTypes)), NewArgTypes)
+ end,
+ ArgNs = [Arg || {Arg, Type} <- EnumArgTypes, t_is_none(Type)],
+ case state__lookup_name(Fun, State) of
+ {M, F, _A} ->
+ case is_opaque_type_test_problem(Fun, NewArgTypes, State) of
+ true ->
+ [Opaque] = NewArgTypes,
+ {opaque_type_test, [atom_to_list(F), erl_types:t_to_string(Opaque)]};
+ false ->
+ SigArgs = t_fun_args(Sig),
+ case is_opaque_related_problem(ArgNs, ArgTypes) of
+ true -> %% an opaque term is used where a structured term is expected
+ ExpectedArgs =
+ case FailReason of
+ only_sig -> SigArgs;
+ _ -> ContrArgs
+ end,
+ {call_with_opaque, [M, F, ArgStrings, ArgNs, ExpectedArgs]};
+ false ->
+ case is_opaque_related_problem(ArgNs, SigArgs) orelse
+ is_opaque_related_problem(ArgNs, ContrArgs) of
+ true -> %% a structured term is used where an opaque is expected
+ ExpectedTriples =
+ case FailReason of
+ only_sig -> expected_arg_triples(ArgNs, SigArgs, State);
+ _ -> expected_arg_triples(ArgNs, ContrArgs, State)
+ end,
+ {call_without_opaque, [M, F, ArgStrings, ExpectedTriples]};
+ false -> %% there is a structured term clash in some argument
+ {call, [M, F, ArgStrings,
+ ArgNs, FailReason,
+ format_sig_args(Sig, State),
+ format_type(t_fun_range(Sig), State),
+ ContractInfo]}
+ end
+ end
+ end;
+ Label when is_integer(Label) ->
+ {apply, [ArgStrings,
+ ArgNs, FailReason,
+ format_sig_args(Sig, State),
+ format_type(t_fun_range(Sig), State),
+ ContractInfo]}
+ end.
+
+%% returns 'true' if we are running with opaque on (not checked yet),
+%% and there is either a contract or hard-coded type information with
+%% opaque types
+%% TODO: check that we are running with opaque types
+%% TODO: check the return type also
+prefer_opaque_types(CArgs, BifArgs) ->
+ t_contains_opaque(t_product(CArgs))
+ orelse t_contains_opaque(t_product(BifArgs)).
+
+is_opaque_related_problem(ArgNs, ArgTypes) ->
+ Fun = fun (N) -> erl_types:t_contains_opaque(lists:nth(N, ArgTypes)) end,
+ ArgNs =/= [] andalso lists:all(Fun, ArgNs).
+
+is_opaque_type_test_problem(Fun, ArgTypes, State) ->
+ case Fun of
+ {erlang, FN, 1} when FN =:= is_atom; FN =:= is_boolean;
+ FN =:= is_binary; FN =:= is_bitstring;
+ FN =:= is_float; FN =:= is_function;
+ FN =:= is_integer; FN =:= is_list;
+ FN =:= is_number; FN =:= is_pid; FN =:= is_port;
+ FN =:= is_reference; FN =:= is_tuple ->
+ [Type] = ArgTypes,
+ erl_types:t_is_opaque(Type) andalso
+ not lists:member(Type, State#state.opaques);
+ _ -> false
+ end.
+
+expected_arg_triples(ArgNs, ArgTypes, State) ->
+ [begin
+ Arg = lists:nth(N, ArgTypes),
+ {N, Arg, format_type(Arg, State)}
+ end || N <- ArgNs].
+
+add_bif_warnings({erlang, Op, 2}, [T1, T2] = Ts, Tree, State)
+ when Op =:= '=:='; Op =:= '==' ->
+ Inf = t_inf(T1, T2),
+ case t_is_none(Inf) andalso (not any_none(Ts))
+ andalso (not is_int_float_eq_comp(T1, Op, T2)) of
+ true ->
+ Args = case erl_types:t_is_opaque(T1) of
+ true -> [format_type(T2, State), Op, format_type(T1, State)];
+ false -> [format_type(T1, State), Op, format_type(T2, State)]
+ end,
+ case any_opaque(Ts) of
+ true ->
+ state__add_warning(State, ?WARN_OPAQUE, Tree, {opaque_eq, Args});
+ false ->
+ state__add_warning(State, ?WARN_MATCHING, Tree, {exact_eq, Args})
+ end;
+ false ->
+ State
+ end;
+add_bif_warnings({erlang, Op, 2}, [T1, T2] = Ts, Tree, State)
+ when Op =:= '=/='; Op =:= '/=' ->
+ Inf = t_inf(T1, T2),
+ case t_is_none(Inf) andalso (not any_none(Ts))
+ andalso (not is_int_float_eq_comp(T1, Op, T2)) andalso any_opaque(Ts) of
+ true ->
+ Args = case erl_types:t_is_opaque(T1) of
+ true -> [format_type(T2, State), Op, format_type(T1, State)];
+ false -> [format_type(T1, State), Op, format_type(T2, State)]
+ end,
+ state__add_warning(State, ?WARN_OPAQUE, Tree, {opaque_neq, Args});
+ false ->
+ State
+ end;
+add_bif_warnings(_, _, _, State) ->
+ State.
+
+is_int_float_eq_comp(T1, Op, T2) ->
+ (Op =:= '==' orelse Op =:= '/=') andalso
+ ((erl_types:t_is_float(T1) andalso erl_types:t_is_integer(T2)) orelse
+ (erl_types:t_is_integer(T1) andalso erl_types:t_is_float(T2))).
+
+%%----------------------------------------
+
+handle_bitstr(Tree, Map, State) ->
+ %% Construction of binaries.
+ Size = cerl:bitstr_size(Tree),
+ Val = cerl:bitstr_val(Tree),
+ BitstrType = cerl:concrete(cerl:bitstr_type(Tree)),
+ {State1, Map1, SizeType0} = traverse(Size, Map, State),
+ {State2, Map2, ValType0} = traverse(Val, Map1, State1),
+ case cerl:bitstr_bitsize(Tree) of
+ BitSz when BitSz =:= all orelse BitSz =:= utf ->
+ ValType =
+ case BitSz of
+ all ->
+ true = (BitstrType =:= binary),
+ t_inf(ValType0, t_bitstr());
+ utf ->
+ true = lists:member(BitstrType, [utf8, utf16, utf32]),
+ t_inf(ValType0, t_integer())
+ end,
+ Map3 = enter_type(Val, ValType, Map2),
+ case t_is_none(ValType) of
+ true ->
+ Msg = {bin_construction, ["value",
+ format_cerl(Val), format_cerl(Tree),
+ format_type(ValType0, State2)]},
+ State3 = state__add_warning(State2, ?WARN_BIN_CONSTRUCTION, Val, Msg),
+ {State3, Map3, t_none()};
+ false ->
+ {State2, Map3, t_bitstr()}
+ end;
+ BitSz when is_integer(BitSz) orelse BitSz =:= any ->
+ SizeType = t_inf(SizeType0, t_non_neg_integer()),
+ ValType =
+ case BitstrType of
+ binary -> t_inf(ValType0, t_bitstr());
+ float -> t_inf(ValType0, t_number());
+ integer -> t_inf(ValType0, t_integer())
+ end,
+ case any_none([SizeType, ValType]) of
+ true ->
+ {Msg, Offending} =
+ case t_is_none(SizeType) of
+ true ->
+ {{bin_construction,
+ ["size", format_cerl(Size), format_cerl(Tree),
+ format_type(SizeType0, State2)]},
+ Size};
+ false ->
+ {{bin_construction,
+ ["value", format_cerl(Val), format_cerl(Tree),
+ format_type(ValType0, State2)]},
+ Val}
+ end,
+ State3 = state__add_warning(State2, ?WARN_BIN_CONSTRUCTION,
+ Offending, Msg),
+ {State3, Map2, t_none()};
+ false ->
+ UnitVal = cerl:concrete(cerl:bitstr_unit(Tree)),
+ Type =
+ case t_number_vals(SizeType) of
+ [OneSize] -> t_bitstr(0, OneSize * UnitVal);
+ _ ->
+ MinSize = erl_types:number_min(SizeType),
+ t_bitstr(UnitVal, UnitVal * MinSize)
+ end,
+ Map3 = enter_type_lists([Val, Size, Tree],
+ [ValType, SizeType, Type], Map2),
+ {State2, Map3, Type}
+ end
+ end.
+
+%%----------------------------------------
+
+handle_call(Tree, Map, State) ->
+ M = cerl:call_module(Tree),
+ F = cerl:call_name(Tree),
+ Args = cerl:call_args(Tree),
+ MFAList = [M, F|Args],
+ {State1, Map1, [MType0, FType0|As]} = traverse_list(MFAList, Map, State),
+ %% Module and function names should be treated as *atoms* even if
+ %% they happen to be identical to an atom which is also involved in
+ %% the definition of an opaque data type
+ MType = t_inf(t_module(), t_unopaque(MType0)),
+ FType = t_inf(t_atom(), t_unopaque(FType0)),
+ Map2 = enter_type_lists([M, F], [MType, FType], Map1),
+ case any_none([MType, FType|As]) of
+ true ->
+ State2 =
+ case t_is_none(MType) andalso (not t_is_none(MType0)) of
+ true -> % This is a problem we just detected; not a known one
+ MS = format_cerl(M),
+ Msg = {app_call, [MS, format_cerl(F),
+ format_args(Args, As, State1),
+ MS, format_type(t_module(), State1),
+ format_type(MType0, State1)]},
+ state__add_warning(State1, ?WARN_FAILING_CALL, Tree, Msg);
+ false ->
+ case t_is_none(FType) andalso (not t_is_none(FType0)) of
+ true ->
+ FS = format_cerl(F),
+ Msg = {app_call, [format_cerl(M), FS,
+ format_args(Args, As, State1),
+ FS, format_type(t_atom(), State1),
+ format_type(FType0, State1)]},
+ state__add_warning(State1, ?WARN_FAILING_CALL, Tree, Msg);
+ false -> State1
+ end
+ end,
+ {State2, Map2, t_none()};
+ false ->
+ %% XXX: Consider doing this for all combinations of MF
+ case {t_atom_vals(MType), t_atom_vals(FType)} of
+ {[MAtom], [FAtom]} ->
+ FunInfo = [{remote, state__fun_info({MAtom, FAtom, length(Args)},
+ State1)}],
+ handle_apply_or_call(FunInfo, Args, As, Map2, Tree, State1);
+ {_MAtoms, _FAtoms} ->
+ {State1, Map2, t_any()}
+ end
+ end.
+
+%%----------------------------------------
+
+handle_case(Tree, Map, #state{callgraph = Callgraph} = State) ->
+ Arg = cerl:case_arg(Tree),
+ Clauses = filter_match_fail(cerl:case_clauses(Tree)),
+ {State1, Map1, ArgType} = SMA = traverse(Arg, Map, State),
+ case t_is_none_or_unit(ArgType) of
+ true -> SMA;
+ false ->
+ Races = State1#state.races,
+ State2 =
+ case dialyzer_callgraph:get_race_detection(Callgraph) andalso
+ dialyzer_races:get_race_analysis(Races) of
+ true ->
+ RaceList = dialyzer_races:get_race_list(Races),
+ RaceListSize = dialyzer_races:get_race_list_size(Races),
+ state__renew_race_list([beg_case|RaceList],
+ RaceListSize + 1, State1);
+ false -> State1
+ end,
+ {MapList, State3, Type} =
+ handle_clauses(Clauses, Arg, ArgType, ArgType, State2,
+ [], Map1, [], []),
+ Map2 = join_maps(MapList, Map1),
+ debug_pp_map(Map2),
+ {State3, Map2, Type}
+ end.
+
+%%----------------------------------------
+
+handle_cons(Tree, Map, State) ->
+ Hd = cerl:cons_hd(Tree),
+ Tl = cerl:cons_tl(Tree),
+ {State1, Map1, HdType} = traverse(Hd, Map, State),
+ {State2, Map2, TlType} = traverse(Tl, Map1, State1),
+ State3 =
+ case t_is_none(t_inf(TlType, t_list())) of
+ true ->
+ Msg = {improper_list_constr, [format_type(TlType, State2)]},
+ state__add_warning(State2, ?WARN_NON_PROPER_LIST, Tree, Msg);
+ false ->
+ State2
+ end,
+ Type = t_cons(HdType, TlType),
+ {State3, Map2, Type}.
+
+%%----------------------------------------
+
+handle_let(Tree, Map, #state{callgraph = Callgraph, races = Races} = State) ->
+ RaceAnalysis = dialyzer_races:get_race_analysis(Races),
+ RaceDetection = dialyzer_callgraph:get_race_detection(Callgraph),
+ Arg = cerl:let_arg(Tree),
+ Vars = cerl:let_vars(Tree),
+ {Map0, State0} =
+ case cerl:is_c_var(Arg) of
+ true ->
+ [Var] = Vars,
+ {enter_subst(Var, Arg, Map),
+ case RaceDetection andalso RaceAnalysis of
+ true ->
+ RaceList = dialyzer_races:get_race_list(Races),
+ RaceListSize = dialyzer_races:get_race_list_size(Races),
+ state__renew_race_list(
+ [dialyzer_races:let_tag_new(Var, Arg)|RaceList],
+ RaceListSize + 1, State);
+ false -> State
+ end};
+ false -> {Map, State}
+ end,
+ Body = cerl:let_body(Tree),
+ {State1, Map1, ArgTypes} = SMA = traverse(Arg, Map0, State0),
+ Callgraph1 = State1#state.callgraph,
+ Callgraph2 =
+ case RaceDetection andalso RaceAnalysis andalso cerl:is_c_call(Arg) of
+ true ->
+ Mod = cerl:call_module(Arg),
+ Name = cerl:call_name(Arg),
+ case cerl:is_literal(Mod) andalso
+ cerl:concrete(Mod) =:= ets andalso
+ cerl:is_literal(Name) andalso
+ cerl:concrete(Name) =:= new of
+ true ->
+ NewTable = dialyzer_races:get_new_table(State1#state.races),
+ renew_public_tables(Vars, NewTable,
+ state__warning_mode(State1),
+ Callgraph1);
+ false -> Callgraph1
+ end;
+ false -> Callgraph1
+ end,
+ State2 = State1#state{callgraph = Callgraph2},
+ case t_is_none_or_unit(ArgTypes) of
+ true -> SMA;
+ false ->
+ Map2 = enter_type_lists(Vars, t_to_tlist(ArgTypes), Map1),
+ traverse(Body, Map2, State2)
+ end.
+
+%%----------------------------------------
+
+handle_module(Tree, Map, State) ->
+ %% By not including the variables in scope we can assure that we
+ %% will get the current function type when using the variables.
+ Defs = cerl:module_defs(Tree),
+ PartFun = fun({_Var, Fun}) ->
+ state__is_escaping(get_label(Fun), State)
+ end,
+ {Defs1, Defs2} = lists:partition(PartFun, Defs),
+ Letrec = cerl:c_letrec(Defs1, cerl:c_int(42)),
+ {State1, Map1, _FunTypes} = traverse(Letrec, Map, State),
+ %% Also add environments for the other top-level functions.
+ VarTypes = [{Var, state__fun_type(Fun, State1)} || {Var, Fun} <- Defs],
+ EnvMap = enter_type_list(VarTypes, Map),
+ FoldFun = fun({_Var, Fun}, AccState) ->
+ state__update_fun_env(Fun, EnvMap, AccState)
+ end,
+ State2 = lists:foldl(FoldFun, State1, Defs2),
+ {State2, Map1, t_any()}.
+
+%%----------------------------------------
+
+handle_receive(Tree, Map,
+ #state{callgraph = Callgraph, races = Races} = State) ->
+ Clauses = filter_match_fail(cerl:receive_clauses(Tree)),
+ Timeout = cerl:receive_timeout(Tree),
+ State1 =
+ case dialyzer_callgraph:get_race_detection(Callgraph) andalso
+ dialyzer_races:get_race_analysis(Races) of
+ true ->
+ RaceList = dialyzer_races:get_race_list(Races),
+ RaceListSize = dialyzer_races:get_race_list_size(Races),
+ state__renew_race_list([beg_case|RaceList],
+ RaceListSize + 1, State);
+ false -> State
+ end,
+ {MapList, State2, ReceiveType} =
+ handle_clauses(Clauses, ?no_arg, t_any(), t_any(), State1, [], Map,
+ [], []),
+ Map1 = join_maps(MapList, Map),
+ {State3, Map2, TimeoutType} = traverse(Timeout, Map1, State2),
+ case (t_is_atom(TimeoutType) andalso
+ (t_atom_vals(TimeoutType) =:= ['infinity'])) of
+ true ->
+ {State3, Map2, ReceiveType};
+ false ->
+ Action = cerl:receive_action(Tree),
+ {State4, Map3, ActionType} = traverse(Action, Map, State3),
+ Map4 = join_maps([Map3, Map1], Map),
+ Type = t_sup(ReceiveType, ActionType),
+ {State4, Map4, Type}
+ end.
+
+%%----------------------------------------
+
+handle_try(Tree, Map, State) ->
+ Arg = cerl:try_arg(Tree),
+ EVars = cerl:try_evars(Tree),
+ Vars = cerl:try_vars(Tree),
+ Body = cerl:try_body(Tree),
+ Handler = cerl:try_handler(Tree),
+ {State1, Map1, ArgType} = traverse(Arg, Map, State),
+ Map2 = mark_as_fresh(Vars, Map1),
+ {SuccState, SuccMap, SuccType} =
+ case bind_pat_vars(Vars, t_to_tlist(ArgType), [], Map2, State1) of
+ {error, _, _, _, _} ->
+ {State1, map__new(), t_none()};
+ {SuccMap1, VarTypes} ->
+ %% Try to bind the argument. Will only succeed if
+ %% it is a simple structured term.
+ SuccMap2 =
+ case bind_pat_vars_reverse([Arg], [t_product(VarTypes)], [],
+ SuccMap1, State1) of
+ {error, _, _, _, _} -> SuccMap1;
+ {SM, _} -> SM
+ end,
+ traverse(Body, SuccMap2, State1)
+ end,
+ ExcMap1 = mark_as_fresh(EVars, Map),
+ {State2, ExcMap2, HandlerType} = traverse(Handler, ExcMap1, SuccState),
+ TryType = t_sup(SuccType, HandlerType),
+ {State2, join_maps([ExcMap2, SuccMap], Map1), TryType}.
+
+%%----------------------------------------
+
+handle_tuple(Tree, Map, State) ->
+ Elements = cerl:tuple_es(Tree),
+ {State1, Map1, EsType} = traverse_list(Elements, Map, State),
+ TupleType = t_tuple(EsType),
+ case t_is_none(TupleType) of
+ true ->
+ {State1, Map1, t_none()};
+ false ->
+ %% Let's find out if this is a record or opaque construction.
+ case Elements of
+ [Tag|Left] ->
+ case cerl:is_c_atom(Tag) of
+ true ->
+ TagVal = cerl:atom_val(Tag),
+ case t_opaque_match_record(TupleType, State1#state.opaques) of
+ [Opaque] ->
+ RecStruct = t_opaque_matching_structure(TupleType, Opaque),
+ RecFields = t_tuple_args(RecStruct),
+ case bind_pat_vars(Elements, RecFields, [], Map1, State1) of
+ {error, _, ErrorPat, ErrorType, _} ->
+ Msg = {record_constr,
+ [TagVal, format_patterns(ErrorPat),
+ format_type(ErrorType, State1)]},
+ State2 = state__add_warning(State1, ?WARN_MATCHING,
+ Tree, Msg),
+ {State2, Map1, t_none()};
+ {Map2, _ETypes} ->
+ {State1, Map2, Opaque}
+ end;
+ _ ->
+ case state__lookup_record(TagVal, length(Left), State1) of
+ error -> {State1, Map1, TupleType};
+ {ok, Prototype} ->
+ %% io:format("In handle_tuple:\n Prototype = ~p\n", [Prototype]),
+ InfTupleType = t_inf(Prototype, TupleType),
+ %% io:format(" TupleType = ~p,\n Inf = ~p\n", [TupleType, InfTupleType]),
+ case t_is_none(InfTupleType) of
+ true ->
+ Msg = {record_constr,
+ [format_type(TupleType, State1), TagVal]},
+ State2 = state__add_warning(State1, ?WARN_MATCHING,
+ Tree, Msg),
+ {State2, Map1, t_none()};
+ false ->
+ case bind_pat_vars(Elements, t_tuple_args(Prototype),
+ [], Map1, State1) of
+ {error, bind, ErrorPat, ErrorType, _} ->
+ %% io:format("error\n", []),
+ Msg = {record_constr,
+ [TagVal, format_patterns(ErrorPat),
+ format_type(ErrorType, State1)]},
+ State2 = state__add_warning(State1, ?WARN_MATCHING,
+ Tree, Msg),
+ {State2, Map1, t_none()};
+ {Map2, ETypes} ->
+ {State1, Map2, t_tuple(ETypes)}
+ end
+ end
+ end
+ end;
+ false ->
+ {State1, Map1, t_tuple(EsType)}
+ end;
+ [] ->
+ {State1, Map1, t_tuple([])}
+ end
+ end.
+
+%%----------------------------------------
+%% Clauses
+%%
+handle_clauses([C|Left], Arg, ArgType, OrigArgType,
+ #state{callgraph = Callgraph, races = Races} = State,
+ CaseTypes, MapIn, Acc, ClauseAcc) ->
+ RaceDetection = dialyzer_callgraph:get_race_detection(Callgraph),
+ RaceAnalysis = dialyzer_races:get_race_analysis(Races),
+ State1 =
+ case RaceDetection andalso RaceAnalysis of
+ true ->
+ RaceList = dialyzer_races:get_race_list(Races),
+ RaceListSize = dialyzer_races:get_race_list_size(Races),
+ state__renew_race_list(
+ [dialyzer_races:beg_clause_new(Arg, cerl:clause_pats(C),
+ cerl:clause_guard(C))|
+ RaceList], RaceListSize + 1,
+ State);
+ false -> State
+ end,
+ {State2, ClauseMap, BodyType, NewArgType} =
+ do_clause(C, Arg, ArgType, OrigArgType, MapIn, State1),
+ {NewClauseAcc, State3} =
+ case RaceDetection andalso RaceAnalysis of
+ true ->
+ Races1 = State2#state.races,
+ RaceList1 = dialyzer_races:get_race_list(Races1),
+ RaceListSize1 = dialyzer_races:get_race_list_size(Races1),
+ EndClause = dialyzer_races:end_clause_new(Arg, cerl:clause_pats(C),
+ cerl:clause_guard(C)),
+ {[EndClause|ClauseAcc],
+ state__renew_race_list([EndClause|RaceList1],
+ RaceListSize1 + 1, State2)};
+ false -> {ClauseAcc, State2}
+ end,
+ {NewCaseTypes, NewAcc} =
+ case t_is_none(BodyType) of
+ true -> {CaseTypes, Acc};
+ false -> {[BodyType|CaseTypes], [ClauseMap|Acc]}
+ end,
+ handle_clauses(Left, Arg, NewArgType, OrigArgType, State3,
+ NewCaseTypes, MapIn, NewAcc, NewClauseAcc);
+handle_clauses([], _Arg, _ArgType, _OrigArgType,
+ #state{callgraph = Callgraph, races = Races} = State,
+ CaseTypes, _MapIn, Acc, ClauseAcc) ->
+ State1 =
+ case dialyzer_callgraph:get_race_detection(Callgraph) andalso
+ dialyzer_races:get_race_analysis(Races) of
+ true ->
+ state__renew_race_list(
+ [dialyzer_races:end_case_new(ClauseAcc)|
+ dialyzer_races:get_race_list(Races)],
+ dialyzer_races:get_race_list_size(Races) + 1, State);
+ false -> State
+ end,
+ {lists:reverse(Acc), State1, t_sup(CaseTypes)}.
+
+do_clause(C, Arg, ArgType0, OrigArgType, Map,
+ #state{callgraph = Callgraph, races = Races} = State) ->
+ Pats = cerl:clause_pats(C),
+ Guard = cerl:clause_guard(C),
+ Body = cerl:clause_body(C),
+ RaceDetection = dialyzer_callgraph:get_race_detection(Callgraph),
+ RaceAnalysis = dialyzer_races:get_race_analysis(Races),
+ State1 =
+ case RaceDetection andalso RaceAnalysis of
+ true ->
+ state__renew_fun_args(Pats, State);
+ false -> State
+ end,
+ Map0 = mark_as_fresh(Pats, Map),
+ Map1 = if Arg =:= ?no_arg -> Map0;
+ true -> bind_subst(Arg, Pats, Map0)
+ end,
+ BindRes =
+ case t_is_none(ArgType0) of
+ true ->
+ {error, bind, Pats, ArgType0, ArgType0};
+ false ->
+ ArgTypes =
+ case t_is_any(ArgType0) of
+ true -> [ArgType0 || _ <- Pats];
+ false -> t_to_tlist(ArgType0)
+ end,
+ bind_pat_vars(Pats, ArgTypes, [], Map1, State1)
+ end,
+ case BindRes of
+ {error, BindOrOpaque, NewPats, Type, OpaqueTerm} ->
+ ?debug("Failed binding pattern: ~s\nto ~s\n",
+ [cerl_prettypr:format(C), format_type(ArgType0, State1)]),
+ case state__warning_mode(State1) of
+ false ->
+ {State1, Map, t_none(), ArgType0};
+ true ->
+ PatString =
+ case BindOrOpaque of
+ bind -> format_patterns(Pats);
+ opaque -> format_patterns(NewPats)
+ end,
+ {Msg, Force} =
+ case t_is_none(ArgType0) of
+ true ->
+ PatTypes = [PatString, format_type(OrigArgType, State1)],
+ %% See if this is covered by an earlier clause or if it
+ %% simply cannot match
+ OrigArgTypes =
+ case t_is_any(OrigArgType) of
+ true -> Any = t_any(), [Any || _ <- Pats];
+ false -> t_to_tlist(OrigArgType)
+ end,
+ case bind_pat_vars(Pats, OrigArgTypes, [], Map1, State1) of
+ {error, bind, _, _, _} -> {{pattern_match, PatTypes}, false};
+ {_, _} -> {{pattern_match_cov, PatTypes}, false}
+ end;
+ false ->
+ %% Try to find out if this is a default clause in a list
+ %% comprehension and supress this. A real Hack(tm)
+ Force0 =
+ case is_compiler_generated(cerl:get_ann(C)) of
+ true ->
+ case Pats of
+ [Pat] ->
+ case cerl:is_c_cons(Pat) of
+ true ->
+ not (cerl:is_c_var(cerl:cons_hd(Pat)) andalso
+ cerl:is_c_var(cerl:cons_tl(Pat)) andalso
+ cerl:is_literal(Guard) andalso
+ (cerl:concrete(Guard) =:= true));
+ false ->
+ true
+ end;
+ _ -> true
+ end;
+ false ->
+ true
+ end,
+ PatTypes = case BindOrOpaque of
+ bind -> [PatString, format_type(ArgType0, State1)];
+ opaque -> [PatString, format_type(Type, State1),
+ format_type(OpaqueTerm, State1)]
+ end,
+ FailedMsg = case BindOrOpaque of
+ bind -> {pattern_match, PatTypes};
+ opaque -> {opaque_match, PatTypes}
+ end,
+ {FailedMsg, Force0}
+ end,
+ WarnType = case Msg of
+ {opaque_match, _} -> ?WARN_OPAQUE;
+ {pattern_match, _} -> ?WARN_MATCHING;
+ {pattern_match_cov, _} -> ?WARN_MATCHING
+ end,
+ {state__add_warning(State1, WarnType, C, Msg, Force),
+ Map, t_none(), ArgType0}
+ end;
+ {Map2, PatTypes} ->
+ Map3 =
+ case Arg =:= ?no_arg of
+ true -> Map2;
+ false ->
+ %% Try to bind the argument. Will only succeed if
+ %% it is a simple structured term.
+ case bind_pat_vars_reverse([Arg], [t_product(PatTypes)],
+ [], Map2, State1) of
+ {error, _, _, _, _} -> Map2;
+ {NewMap, _} -> NewMap
+ end
+ end,
+ NewArgType =
+ case Arg =:= ?no_arg of
+ true -> ArgType0;
+ false ->
+ GenType = dialyzer_typesig:get_safe_underapprox(Pats, Guard),
+ t_subtract(t_product(t_to_tlist(ArgType0)), GenType)
+ end,
+ case bind_guard(Guard, Map3, State1) of
+ {error, Reason} ->
+ ?debug("Failed guard: ~s\n",
+ [cerl_prettypr:format(C, [{hook, cerl_typean:pp_hook()}])]),
+ PatString = format_patterns(Pats),
+ DefaultMsg =
+ case Pats =:= [] of
+ true -> {guard_fail, []};
+ false ->
+ {guard_fail_pat, [PatString, format_type(ArgType0, State1)]}
+ end,
+ State2 =
+ case Reason of
+ none -> state__add_warning(State1, ?WARN_MATCHING, C, DefaultMsg);
+ {FailGuard, Msg} ->
+ case is_compiler_generated(cerl:get_ann(FailGuard)) of
+ false ->
+ WarnType = case Msg of
+ {guard_fail, _} -> ?WARN_MATCHING;
+ {opaque_guard, _} -> ?WARN_OPAQUE
+ end,
+ state__add_warning(State1, WarnType, FailGuard, Msg);
+ true ->
+ state__add_warning(State1, ?WARN_MATCHING, C, Msg)
+ end
+ end,
+ {State2, Map, t_none(), NewArgType};
+ Map4 ->
+ {RetState, RetMap, BodyType} = traverse(Body, Map4, State1),
+ {RetState, RetMap, BodyType, NewArgType}
+ end
+ end.
+
+bind_subst(Arg, Pats, Map) ->
+ case cerl:type(Arg) of
+ values ->
+ bind_subst_list(cerl:values_es(Arg), Pats, Map);
+ var ->
+ [Pat] = Pats,
+ enter_subst(Arg, Pat, Map);
+ _ ->
+ Map
+ end.
+
+bind_subst_list([Arg|ArgLeft], [Pat|PatLeft], Map) ->
+ NewMap =
+ case {cerl:type(Arg), cerl:type(Pat)} of
+ {var, var} -> enter_subst(Arg, Pat, Map);
+ {var, alias} -> enter_subst(Arg, cerl:alias_pat(Pat), Map);
+ {literal, literal} -> Map;
+ {T, T} -> bind_subst_list(lists:flatten(cerl:subtrees(Arg)),
+ lists:flatten(cerl:subtrees(Pat)),
+ Map);
+ _ -> Map
+ end,
+ bind_subst_list(ArgLeft, PatLeft, NewMap);
+bind_subst_list([], [], Map) ->
+ Map.
+
+%%----------------------------------------
+%% Patterns
+%%
+
+bind_pat_vars(Pats, Types, Acc, Map, State) ->
+ try
+ bind_pat_vars(Pats, Types, Acc, Map, State, false)
+ catch
+ throw:Error -> Error % Error = {error, bind | opaque, ErrorPats, ErrorType}
+ end.
+
+bind_pat_vars_reverse(Pats, Types, Acc, Map, State) ->
+ try
+ bind_pat_vars(Pats, Types, Acc, Map, State, true)
+ catch
+ throw:Error -> Error % Error = {error, bind | opaque, ErrorPats, ErrorType}
+ end.
+
+bind_pat_vars([Pat|PatLeft], [Type|TypeLeft], Acc, Map, State, Rev) ->
+ ?debug("Binding pat: ~w to ~s\n", [cerl:type(Pat), format_type(Type, State)]),
+ {NewMap, TypeOut} =
+ case cerl:type(Pat) of
+ alias ->
+ AliasPat = cerl:alias_pat(Pat),
+ Var = cerl:alias_var(Pat),
+ Map1 = enter_subst(Var, AliasPat, Map),
+ {Map2, [PatType]} = bind_pat_vars([AliasPat], [Type], [],
+ Map1, State, Rev),
+ {enter_type(Var, PatType, Map2), PatType};
+ binary ->
+ %% Cannot bind the binary if we are in reverse match since
+ %% binary patterns and binary construction are not symmetric.
+ case Rev of
+ true -> {Map, t_bitstr()};
+ false ->
+ BinType = t_inf(t_bitstr(), Type),
+ case t_is_none(BinType) of
+ true -> bind_error([Pat], Type, t_none(), bind);
+ false ->
+ Segs = cerl:binary_segments(Pat),
+ {Map1, SegTypes} = bind_bin_segs(Segs, BinType, Map, State),
+ {Map1, t_bitstr_concat(SegTypes)}
+ end
+ end;
+ cons ->
+ Cons = t_inf(Type, t_cons()),
+ case t_is_none(Cons) of
+ true ->
+ case t_find_opaque_mismatch(t_cons(), Type) of
+ {ok, T1, T2} -> bind_error([Pat], T1, T2, opaque);
+ error -> bind_error([Pat], Type, t_none(), bind)
+ end;
+ false ->
+ {Map1, [HdType, TlType]} =
+ bind_pat_vars([cerl:cons_hd(Pat), cerl:cons_tl(Pat)],
+ [t_cons_hd(Cons), t_cons_tl(Cons)],
+ [], Map, State, Rev),
+ {Map1, t_cons(HdType, TlType)}
+ end;
+ literal ->
+ Literal = literal_type(Pat),
+ LiteralOrOpaque =
+ case t_opaque_match_atom(Literal, State#state.opaques) of
+ [Opaque] -> Opaque;
+ _ -> Literal
+ end,
+ case t_is_none(t_inf(LiteralOrOpaque, Type)) of
+ true ->
+ case t_find_opaque_mismatch(Literal, Type) of
+ {ok, T1, T2} ->
+ case lists:member(T2, State#state.opaques) of
+ true ->
+ NewType = erl_types:t_struct_from_opaque(Type, T2),
+ {Map1, _} =
+ bind_pat_vars([Pat], [NewType], [], Map, State, Rev),
+ {Map1, T2};
+ false -> bind_error([Pat], T1, T2, opaque)
+ end;
+ error -> bind_error([Pat], Type, t_none(), bind)
+ end;
+ false -> {Map, LiteralOrOpaque}
+ end;
+ tuple ->
+ Es = cerl:tuple_es(Pat),
+ Prototype =
+ case Es of
+ [] -> t_tuple([]);
+ [Tag|Left] ->
+ case cerl:is_c_atom(Tag) of
+ true ->
+ TagAtom = cerl:atom_val(Tag),
+ case state__lookup_record(TagAtom, length(Left), State) of
+ error -> t_tuple(length(Es));
+ {ok, Record} -> Record
+ end;
+ false -> t_tuple(length(Es))
+ end
+ end,
+ Tuple = t_inf(Prototype, Type),
+ case t_is_none(Tuple) of
+ true ->
+ case t_find_opaque_mismatch(Prototype, Type) of
+ {ok, T1, T2} ->
+ case lists:member(T2, State#state.opaques) of
+ true ->
+ NewType = erl_types:t_struct_from_opaque(Type, T2),
+ {Map1, _} =
+ bind_pat_vars([Pat], [NewType], [], Map, State, Rev),
+ {Map1, T2};
+ false -> bind_error([Pat], T1, T2, opaque)
+ end;
+ error -> bind_error([Pat], Type, t_none(), bind)
+ end;
+ false ->
+ SubTuples = t_tuple_subtypes(Tuple),
+ %% Need to call the top function to get the try-catch wrapper
+ Results =
+ case Rev of
+ true ->
+ [bind_pat_vars_reverse(Es, t_tuple_args(SubTuple), [],
+ Map, State)
+ || SubTuple <- SubTuples];
+ false ->
+ [bind_pat_vars(Es, t_tuple_args(SubTuple), [], Map, State)
+ || SubTuple <- SubTuples]
+ end,
+ case lists:keyfind(opaque, 2, Results) of
+ {error, opaque, _PatList, _Type, Opaque} ->
+ bind_error([Pat], Tuple, Opaque, opaque);
+ false ->
+ case [M || {M, _} <- Results, M =/= error] of
+ [] -> bind_error([Pat], Tuple, t_none(), bind);
+ Maps ->
+ Map1 = join_maps(Maps, Map),
+ TupleType = t_sup([t_tuple(EsTypes)
+ || {M, EsTypes} <- Results, M =/= error]),
+ {Map1, TupleType}
+ end
+ end
+ end;
+ values ->
+ Es = cerl:values_es(Pat),
+ {Map1, EsTypes} =
+ bind_pat_vars(Es, t_to_tlist(Type), [], Map, State, Rev),
+ {Map1, t_product(EsTypes)};
+ var ->
+ Opaques = State#state.opaques,
+ VarType1 =
+ case state__lookup_type_for_rec_var(Pat, State) of
+ error ->
+ LType = lookup_type(Pat, Map),
+ case t_opaque_match_record(LType, Opaques) of
+ [Opaque] -> Opaque;
+ _ ->
+ case t_opaque_match_atom(LType, Opaques) of
+ [Opaque] -> Opaque;
+ _ -> LType
+ end
+ end;
+ {ok, RecType} -> RecType
+ end,
+ %% Must do inf when binding args to pats. Vars in pats are fresh.
+ VarType2 = t_inf(VarType1, Type),
+ VarType3 =
+ case Opaques =/= [] of
+ true ->
+ case t_opaque_match_record(VarType2, Opaques) of
+ [OpaqueRec] -> OpaqueRec;
+ _ ->
+ case t_opaque_match_atom(VarType2, Opaques) of
+ [OpaqueAtom] -> OpaqueAtom;
+ _ -> VarType2
+ end
+ end;
+ false -> VarType2
+ end,
+ case t_is_none(VarType3) of
+ true ->
+ case t_find_opaque_mismatch(VarType1, Type) of
+ {ok, T1, T2} ->
+ bind_error([Pat], T1, T2, opaque);
+ error ->
+ bind_error([Pat], Type, t_none(), bind)
+ end;
+ false ->
+ Map1 = enter_type(Pat, VarType3, Map),
+ {Map1, VarType3}
+ end;
+ _Other ->
+ %% Catch all is needed when binding args to pats
+ ?debug("Failed match for ~p\n", [_Other]),
+ bind_error([Pat], Type, t_none(), bind)
+ end,
+ bind_pat_vars(PatLeft, TypeLeft, [TypeOut|Acc], NewMap, State, Rev);
+bind_pat_vars([], [], Acc, Map, _State, _Rev) ->
+ {Map, lists:reverse(Acc)}.
+
+bind_bin_segs(BinSegs, BinType, Map, State) ->
+ bind_bin_segs(BinSegs, BinType, [], Map, State).
+
+bind_bin_segs([Seg|Segs], BinType, Acc, Map, State) ->
+ Val = cerl:bitstr_val(Seg),
+ SegType = cerl:concrete(cerl:bitstr_type(Seg)),
+ UnitVal = cerl:concrete(cerl:bitstr_unit(Seg)),
+ case cerl:bitstr_bitsize(Seg) of
+ all ->
+ binary = SegType, [] = Segs, %% just an assert
+ T = t_inf(t_bitstr(UnitVal, 0), BinType),
+ {Map1, [Type]} = bind_pat_vars([Val], [T], [], Map, State, false),
+ bind_bin_segs(Segs, t_bitstr(0, 0), [Type|Acc], Map1, State);
+ utf -> % XXX: possibly can be strengthened
+ true = lists:member(SegType, [utf8, utf16, utf32]),
+ {Map1, [_]} = bind_pat_vars([Val], [t_integer()], [], Map, State, false),
+ Type = t_binary(),
+ bind_bin_segs(Segs, BinType, [Type|Acc], Map1, State);
+ BitSz when is_integer(BitSz) orelse BitSz =:= any ->
+ Size = cerl:bitstr_size(Seg),
+ {Map1, [SizeType]} =
+ bind_pat_vars([Size], [t_non_neg_integer()], [], Map, State, false),
+ Type =
+ case t_number_vals(SizeType) of
+ [OneSize] -> t_bitstr(0, UnitVal * OneSize);
+ _ ->
+ MinSize = erl_types:number_min(SizeType),
+ t_bitstr(UnitVal, UnitVal * MinSize)
+ end,
+ ValConstr =
+ case SegType of
+ binary -> Type; %% The same constraints as for the whole bitstr
+ float -> t_float();
+ integer ->
+ case t_number_vals(SizeType) of
+ unknown -> t_integer();
+ List ->
+ SizeVal = lists:max(List),
+ Flags = cerl:concrete(cerl:bitstr_flags(Seg)),
+ N = SizeVal * UnitVal,
+ case lists:member(signed, Flags) of
+ true -> t_from_range(-(1 bsl (N - 1)), 1 bsl (N - 1) - 1);
+ false -> t_from_range(0, 1 bsl N - 1)
+ end
+ end
+ end,
+ {Map2, [_]} = bind_pat_vars([Val], [ValConstr], [], Map1, State, false),
+ NewBinType = t_bitstr_match(Type, BinType),
+ case t_is_none(NewBinType) of
+ true -> bind_error([Seg], BinType, t_none(), bind);
+ false -> bind_bin_segs(Segs, NewBinType, [Type|Acc], Map2, State)
+ end
+ end;
+bind_bin_segs([], _BinType, Acc, Map, _State) ->
+ {Map, lists:reverse(Acc)}.
+
+bind_error(Pats, Type, OpaqueType, Error) ->
+ throw({error, Error, Pats, Type, OpaqueType}).
+
+%%----------------------------------------
+%% Guards
+%%
+
+bind_guard(Guard, Map, State) ->
+ try bind_guard(Guard, Map, dict:new(), pos, State) of
+ {Map1, _Type} -> Map1
+ catch
+ throw:{fail, Warning} -> {error, Warning};
+ throw:{fatal_fail, Warning} -> {error, Warning}
+ end.
+
+bind_guard(Guard, Map, Env, Eval, State) ->
+ ?debug("Handling ~w guard: ~s\n",
+ [Eval, cerl_prettypr:format(Guard, [{noann, true}])]),
+ case cerl:type(Guard) of
+ binary ->
+ {Map, t_binary()};
+ 'case' ->
+ Arg = cerl:case_arg(Guard),
+ Clauses = cerl:case_clauses(Guard),
+ bind_guard_case_clauses(Arg, Clauses, Map, Env, Eval, State);
+ cons ->
+ Hd = cerl:cons_hd(Guard),
+ Tl = cerl:cons_tl(Guard),
+ {Map1, HdType} = bind_guard(Hd, Map, Env, dont_know, State),
+ {Map2, TlType} = bind_guard(Tl, Map1, Env, dont_know, State),
+ {Map2, t_cons(HdType, TlType)};
+ literal ->
+ {Map, literal_type(Guard)};
+ 'try' ->
+ Arg = cerl:try_arg(Guard),
+ [Var] = cerl:try_vars(Guard),
+ %%?debug("Storing: ~w\n", [Var]),
+ NewEnv = dict:store(get_label(Var), Arg, Env),
+ bind_guard(cerl:try_body(Guard), Map, NewEnv, Eval, State);
+ tuple ->
+ Es0 = cerl:tuple_es(Guard),
+ {Map1, Es} = bind_guard_list(Es0, Map, Env, dont_know, State),
+ {Map1, t_tuple(Es)};
+ 'let' ->
+ Arg = cerl:let_arg(Guard),
+ [Var] = cerl:let_vars(Guard),
+ %%?debug("Storing: ~w\n", [Var]),
+ NewEnv = dict:store(get_label(Var), Arg, Env),
+ bind_guard(cerl:let_body(Guard), Map, NewEnv, Eval, State);
+ values ->
+ Es = cerl:values_es(Guard),
+ List = [bind_guard(V, Map, Env, dont_know, State) || V <- Es],
+ Type = t_product([T || {_, T} <- List]),
+ {Map, Type};
+ var ->
+ ?debug("Looking for var(~w)...", [cerl_trees:get_label(Guard)]),
+ case dict:find(get_label(Guard), Env) of
+ error ->
+ ?debug("Did not find it\n", []),
+ Type = lookup_type(Guard, Map),
+ Constr =
+ case Eval of
+ pos -> t_atom(true);
+ neg -> t_atom(false);
+ dont_know -> Type
+ end,
+ Inf = t_inf(Constr, Type),
+ {enter_type(Guard, Inf, Map), Inf};
+ {ok, Tree} ->
+ ?debug("Found it\n", []),
+ {Map1, Type} = bind_guard(Tree, Map, Env, Eval, State),
+ {enter_type(Guard, Type, Map1), Type}
+ end;
+ call ->
+ handle_guard_call(Guard, Map, Env, Eval, State)
+ end.
+
+handle_guard_call(Guard, Map, Env, Eval, State) ->
+ MFA = {cerl:atom_val(cerl:call_module(Guard)),
+ cerl:atom_val(cerl:call_name(Guard)),
+ cerl:call_arity(Guard)},
+ case MFA of
+ {erlang, F, 1} when F =:= is_atom; F =:= is_boolean;
+ F =:= is_binary; F =:= is_bitstring;
+ F =:= is_float; F =:= is_function;
+ F =:= is_integer; F =:= is_list;
+ F =:= is_number; F =:= is_pid; F =:= is_port;
+ F =:= is_reference; F =:= is_tuple ->
+ handle_guard_type_test(Guard, F, Map, Env, Eval, State);
+ {erlang, is_function, 2} ->
+ handle_guard_is_function(Guard, Map, Env, Eval, State);
+ MFA when (MFA =:= {erlang, internal_is_record, 3}) or
+ (MFA =:= {erlang, is_record, 3}) ->
+ handle_guard_is_record(Guard, Map, Env, Eval, State);
+ {erlang, '=:=', 2} ->
+ handle_guard_eqeq(Guard, Map, Env, Eval, State);
+ {erlang, '==', 2} ->
+ handle_guard_eq(Guard, Map, Env, Eval, State);
+ {erlang, 'and', 2} ->
+ handle_guard_and(Guard, Map, Env, Eval, State);
+ {erlang, 'or', 2} ->
+ handle_guard_or(Guard, Map, Env, Eval, State);
+ {erlang, 'not', 1} ->
+ handle_guard_not(Guard, Map, Env, Eval, State);
+ {erlang, Comp, 2} when Comp =:= '<'; Comp =:= '=<';
+ Comp =:= '>'; Comp =:= '>=' ->
+ handle_guard_comp(Guard, Comp, Map, Env, Eval, State);
+ _ ->
+ handle_guard_gen_fun(MFA, Guard, Map, Env, Eval, State)
+ end.
+
+handle_guard_gen_fun({M, F, A}, Guard, Map, Env, Eval, State) ->
+ Args = cerl:call_args(Guard),
+ {Map1, As0} = bind_guard_list(Args, Map, Env, dont_know, State),
+ MapFun = fun(Type) ->
+ case lists:member(Type, State#state.opaques) of
+ true -> erl_types:t_opaque_structure(Type);
+ false -> Type
+ end
+ end,
+ As = lists:map(MapFun, As0),
+ Mode = case As =:= As0 of
+ true -> structured;
+ false -> opaque
+ end,
+ BifRet = erl_bif_types:type(M, F, A, As),
+ case t_is_none(BifRet) of
+ true ->
+ %% Is this an error-bif?
+ case t_is_none(erl_bif_types:type(M, F, A)) of
+ true -> signal_guard_fail(Guard, As, State);
+ false -> signal_guard_fatal_fail(Guard, As, State)
+ end;
+ false ->
+ BifArgs = case erl_bif_types:arg_types(M, F, A) of
+ unknown -> lists:duplicate(A, t_any());
+ List -> List
+ end,
+ Map2 = enter_type_lists(Args, t_inf_lists(BifArgs, As0, Mode), Map1),
+ Ret =
+ case Eval of
+ pos -> t_inf(t_atom(true), BifRet);
+ neg -> t_inf(t_atom(false), BifRet);
+ dont_know -> BifRet
+ end,
+ case t_is_none(Ret) of
+ true ->
+ case Eval =:= pos of
+ true -> signal_guard_fail(Guard, As, State);
+ false -> throw({fail, none})
+ end;
+ false -> {Map2, Ret}
+ end
+ end.
+
+handle_guard_type_test(Guard, F, Map, Env, Eval, State) ->
+ [Arg] = cerl:call_args(Guard),
+ {Map1, ArgType} = bind_guard(Arg, Map, Env, dont_know, State),
+ case bind_type_test(Eval, F, ArgType, State) of
+ error ->
+ ?debug("Type test: ~w failed\n", [F]),
+ signal_guard_fail(Guard, [ArgType], State);
+ {ok, NewArgType, Ret} ->
+ ?debug("Type test: ~w succeeded, NewType: ~s, Ret: ~s\n",
+ [F, t_to_string(NewArgType), t_to_string(Ret)]),
+ {enter_type(Arg, NewArgType, Map1), Ret}
+ end.
+
+bind_type_test(Eval, TypeTest, ArgType, State) ->
+ Type = case TypeTest of
+ is_atom -> t_atom();
+ is_boolean -> t_boolean();
+ is_binary -> t_binary();
+ is_bitstring -> t_bitstr();
+ is_float -> t_float();
+ is_function -> t_fun();
+ is_integer -> t_integer();
+ is_list -> t_maybe_improper_list();
+ is_number -> t_number();
+ is_pid -> t_pid();
+ is_port -> t_port();
+ is_reference -> t_reference();
+ is_tuple -> t_tuple()
+ end,
+ Mode = determine_mode(ArgType, State#state.opaques),
+ case Eval of
+ pos ->
+ Inf = t_inf(Type, ArgType, Mode),
+ case t_is_none(Inf) of
+ true -> error;
+ false -> {ok, Inf, t_atom(true)}
+ end;
+ neg ->
+ case Mode of
+ opaque ->
+ Struct = erl_types:t_opaque_structure(ArgType),
+ case t_is_none(t_subtract(Struct, Type)) of
+ true -> error;
+ false -> {ok, ArgType, t_atom(false)}
+ end;
+ structured ->
+ Sub = t_subtract(ArgType, Type),
+ case t_is_none(Sub) of
+ true -> error;
+ false -> {ok, Sub, t_atom(false)}
+ end
+ end;
+ dont_know ->
+ {ok, ArgType, t_boolean()}
+ end.
+
+handle_guard_comp(Guard, Comp, Map, Env, Eval, State) ->
+ Args = cerl:call_args(Guard),
+ [Arg1, Arg2] = Args,
+ {Map1, ArgTypes} = bind_guard_list(Args, Map, Env, dont_know, State),
+ [Type1, Type2] = ArgTypes,
+ IsInt1 = t_is_integer(Type1),
+ IsInt2 = t_is_integer(Type2),
+ case {cerl:type(Arg1), cerl:type(Arg2)} of
+ {literal, literal} ->
+ case erlang:Comp(cerl:concrete(Arg1), cerl:concrete(Arg2)) of
+ true when Eval =:= pos -> {Map, t_atom(true)};
+ true when Eval =:= dont_know -> {Map, t_atom(true)};
+ true when Eval =:= neg -> {Map, t_atom(true)};
+ false when Eval =:= pos -> signal_guard_fail(Guard, ArgTypes, State);
+ false when Eval =:= dont_know -> {Map, t_atom(false)};
+ false when Eval =:= neg -> {Map, t_atom(false)}
+ end;
+ {literal, var} when IsInt1 andalso IsInt2 andalso (Eval =:= pos) ->
+ case bind_comp_literal_var(Arg1, Arg2, Type2, Comp, Map1) of
+ error -> signal_guard_fail(Guard, ArgTypes, State);
+ {ok, NewMap} -> {NewMap, t_atom(true)}
+ end;
+ {var, literal} when IsInt1 andalso IsInt2 andalso (Eval =:= pos) ->
+ case bind_comp_literal_var(Arg2, Arg1, Type1, invert_comp(Comp), Map1) of
+ error -> signal_guard_fail(Guard, ArgTypes, State);
+ {ok, NewMap} -> {NewMap, t_atom(true)}
+ end;
+ {_, _} ->
+ handle_guard_gen_fun({erlang, Comp, 2}, Guard, Map, Env, Eval, State)
+ end.
+
+invert_comp('=<') -> '>=';
+invert_comp('<') -> '>';
+invert_comp('>=') -> '=<';
+invert_comp('>') -> '<'.
+
+bind_comp_literal_var(Lit, Var, VarType, CompOp, Map) ->
+ LitVal = cerl:concrete(Lit),
+ NewVarType =
+ case t_number_vals(VarType) of
+ unknown ->
+ Range =
+ case CompOp of
+ '=<' -> t_from_range(LitVal, pos_inf);
+ '<' -> t_from_range(LitVal + 1, pos_inf);
+ '>=' -> t_from_range(neg_inf, LitVal);
+ '>' -> t_from_range(neg_inf, LitVal - 1)
+ end,
+ t_inf(Range, VarType);
+ NumberVals ->
+ NewNumberVals = [X || X <- NumberVals, erlang:CompOp(LitVal, X)],
+ t_integers(NewNumberVals)
+ end,
+ case t_is_none(NewVarType) of
+ true -> error;
+ false -> {ok, enter_type(Var, NewVarType, Map)}
+ end.
+
+handle_guard_is_function(Guard, Map, Env, Eval, State) ->
+ Args = cerl:call_args(Guard),
+ {Map1, ArgTypes0} = bind_guard_list(Args, Map, Env, dont_know, State),
+ [FunType0, ArityType0] = ArgTypes0,
+ ArityType = t_inf(ArityType0, t_integer()),
+ case t_is_none(ArityType) of
+ true -> signal_guard_fail(Guard, ArgTypes0, State);
+ false ->
+ FunTypeConstr =
+ case t_number_vals(ArityType) of
+ unknown -> t_fun();
+ Vals ->
+ t_sup([t_fun(lists:duplicate(X, t_any()), t_any()) || X <- Vals])
+ end,
+ FunType = t_inf(FunType0, FunTypeConstr),
+ case t_is_none(FunType) of
+ true ->
+ case Eval of
+ pos -> signal_guard_fail(Guard, ArgTypes0, State);
+ neg -> {Map1, t_atom(false)};
+ dont_know -> {Map1, t_atom(false)}
+ end;
+ false ->
+ case Eval of
+ pos -> {enter_type_lists(Args, [FunType, ArityType], Map1),
+ t_atom(true)};
+ neg -> {Map1, t_atom(false)};
+ dont_know -> {Map1, t_boolean()}
+ end
+ end
+ end.
+
+handle_guard_is_record(Guard, Map, Env, Eval, State) ->
+ Args = cerl:call_args(Guard),
+ [Rec, Tag0, Arity0] = Args,
+ Tag = cerl:atom_val(Tag0),
+ Arity = cerl:int_val(Arity0),
+ {Map1, RecType} = bind_guard(Rec, Map, Env, dont_know, State),
+ ArityMin1 = Arity - 1,
+ TupleType =
+ case state__lookup_record(Tag, ArityMin1, State) of
+ error -> t_tuple([t_atom(Tag)|lists:duplicate(ArityMin1, t_any())]);
+ {ok, Prototype} -> Prototype
+ end,
+ Mode = determine_mode(RecType, State#state.opaques),
+ NewTupleType =
+ case t_opaque_match_record(TupleType, State#state.opaques) of
+ [Opaque] -> Opaque;
+ _ -> TupleType
+ end,
+ Type = t_inf(NewTupleType, RecType, Mode),
+ case t_is_none(Type) of
+ true ->
+ case Eval of
+ pos -> signal_guard_fail(Guard,
+ [RecType, t_from_term(Tag),
+ t_from_term(Arity)],
+ State);
+ neg -> {Map1, t_atom(false)};
+ dont_know -> {Map1, t_atom(false)}
+ end;
+ false ->
+ case Eval of
+ pos -> {enter_type(Rec, Type, Map1), t_atom(true)};
+ neg -> {Map1, t_atom(false)};
+ dont_know -> {Map1, t_boolean()}
+ end
+ end.
+
+handle_guard_eq(Guard, Map, Env, Eval, State) ->
+ [Arg1, Arg2] = cerl:call_args(Guard),
+ case {cerl:type(Arg1), cerl:type(Arg2)} of
+ {literal, literal} ->
+ case cerl:concrete(Arg1) =:= cerl:concrete(Arg2) of
+ true ->
+ if
+ Eval =:= pos -> {Map, t_atom(true)};
+ Eval =:= neg -> throw({fail, none});
+ Eval =:= dont_know -> {Map, t_atom(true)}
+ end;
+ false ->
+ if
+ Eval =:= neg -> {Map, t_atom(false)};
+ Eval =:= dont_know -> {Map, t_atom(false)};
+ Eval =:= pos ->
+ ArgTypes = [t_from_term(cerl:concrete(Arg1)),
+ t_from_term(cerl:concrete(Arg2))],
+ signal_guard_fail(Guard, ArgTypes, State)
+ end
+ end;
+ {literal, _} when Eval =:= pos ->
+ case cerl:concrete(Arg1) of
+ Atom when is_atom(Atom) ->
+ bind_eqeq_guard_lit_other(Guard, Arg1, Arg2, Map, Env, State);
+ [] ->
+ bind_eqeq_guard_lit_other(Guard, Arg1, Arg2, Map, Env, State);
+ _ ->
+ bind_eq_guard(Guard, Arg1, Arg2, Map, Env, Eval, State)
+ end;
+ {_, literal} when Eval =:= pos ->
+ case cerl:concrete(Arg2) of
+ Atom when is_atom(Atom) ->
+ bind_eqeq_guard_lit_other(Guard, Arg2, Arg1, Map, Env, State);
+ [] ->
+ bind_eqeq_guard_lit_other(Guard, Arg2, Arg1, Map, Env, State);
+ _ ->
+ bind_eq_guard(Guard, Arg1, Arg2, Map, Env, Eval, State)
+ end;
+ {_, _} ->
+ bind_eq_guard(Guard, Arg1, Arg2, Map, Env, Eval, State)
+ end.
+
+bind_eq_guard(Guard, Arg1, Arg2, Map, Env, Eval, State) ->
+ {Map1, Type1} = bind_guard(Arg1, Map, Env, dont_know, State),
+ {Map2, Type2} = bind_guard(Arg2, Map1, Env, dont_know, State),
+ case (t_is_nil(Type1) orelse t_is_nil(Type2) orelse
+ t_is_atom(Type1) orelse t_is_atom(Type2)) of
+ true -> bind_eqeq_guard(Guard, Arg1, Arg2, Map, Env, Eval, State);
+ false ->
+ case Eval of
+ pos -> {Map2, t_atom(true)};
+ neg -> {Map2, t_atom(false)};
+ dont_know -> {Map2, t_boolean()}
+ end
+ end.
+
+handle_guard_eqeq(Guard, Map, Env, Eval, State) ->
+ [Arg1, Arg2] = cerl:call_args(Guard),
+ case {cerl:type(Arg1), cerl:type(Arg2)} of
+ {literal, literal} ->
+ case cerl:concrete(Arg1) =:= cerl:concrete(Arg2) of
+ true ->
+ if Eval =:= neg -> throw({fail, none});
+ Eval =:= pos -> {Map, t_atom(true)};
+ Eval =:= dont_know -> {Map, t_atom(true)}
+ end;
+ false ->
+ if Eval =:= neg -> {Map, t_atom(false)};
+ Eval =:= dont_know -> {Map, t_atom(false)};
+ Eval =:= pos ->
+ ArgTypes = [t_from_term(cerl:concrete(Arg1)),
+ t_from_term(cerl:concrete(Arg2))],
+ signal_guard_fail(Guard, ArgTypes, State)
+ end
+ end;
+ {literal, _} when Eval =:= pos ->
+ bind_eqeq_guard_lit_other(Guard, Arg1, Arg2, Map, Env, State);
+ {_, literal} when Eval =:= pos ->
+ bind_eqeq_guard_lit_other(Guard, Arg2, Arg1, Map, Env, State);
+ {_, _} ->
+ bind_eqeq_guard(Guard, Arg1, Arg2, Map, Env, Eval, State)
+ end.
+
+bind_eqeq_guard(Guard, Arg1, Arg2, Map, Env, Eval, State) ->
+ {Map1, Type1} = bind_guard(Arg1, Map, Env, dont_know, State),
+ {Map2, Type2} = bind_guard(Arg2, Map1, Env, dont_know, State),
+ ?debug("Types are:~s =:= ~s\n", [t_to_string(Type1),
+ t_to_string(Type2)]),
+ Inf = t_inf(Type1, Type2),
+ case t_is_none(Inf) of
+ true ->
+ case Eval of
+ neg -> {Map2, t_atom(false)};
+ dont_know -> {Map2, t_atom(false)};
+ pos -> signal_guard_fail(Guard, [Type1, Type2], State)
+ end;
+ false ->
+ case Eval of
+ pos ->
+ case {cerl:type(Arg1), cerl:type(Arg2)} of
+ {var, var} ->
+ Map3 = enter_subst(Arg1, Arg2, Map2),
+ Map4 = enter_type(Arg2, Inf, Map3),
+ {Map4, t_atom(true)};
+ {var, _} ->
+ Map3 = enter_type(Arg1, Inf, Map2),
+ {Map3, t_atom(true)};
+ {_, var} ->
+ Map3 = enter_type(Arg2, Inf, Map2),
+ {Map3, t_atom(true)};
+ {_, _} ->
+ {Map2, t_atom(true)}
+ end;
+ neg ->
+ {Map2, t_atom(false)};
+ dont_know ->
+ {Map2, t_boolean()}
+ end
+ end.
+
+bind_eqeq_guard_lit_other(Guard, Arg1, Arg2, Map, Env, State) ->
+ %% Assumes positive evaluation
+ case cerl:concrete(Arg1) of
+ true ->
+ {_, Type} = MT = bind_guard(Arg2, Map, Env, pos, State),
+ case t_is_atom(true, Type) of
+ true -> MT;
+ false ->
+ {_, Type0} = bind_guard(Arg2, Map, Env, dont_know, State),
+ signal_guard_fail(Guard, [Type0, t_atom(true)], State)
+ end;
+ false ->
+ {Map1, Type} = bind_guard(Arg2, Map, Env, neg, State),
+ case t_is_atom(false, Type) of
+ true -> {Map1, t_atom(true)};
+ false ->
+ {_, Type0} = bind_guard(Arg2, Map, Env, dont_know, State),
+ signal_guard_fail(Guard, [Type0, t_atom(true)], State)
+ end;
+ Term ->
+ LitType = t_from_term(Term),
+ {Map1, Type} = bind_guard(Arg2, Map, Env, dont_know, State),
+ case t_is_subtype(LitType, Type) of
+ false -> signal_guard_fail(Guard, [Type, LitType], State);
+ true ->
+ case cerl:is_c_var(Arg2) of
+ true -> {enter_type(Arg2, LitType, Map1), t_atom(true)};
+ false -> {Map1, t_atom(true)}
+ end
+ end
+ end.
+
+handle_guard_and(Guard, Map, Env, Eval, State) ->
+ [Arg1, Arg2] = cerl:call_args(Guard),
+ case Eval of
+ pos ->
+ {Map1, Type1} = bind_guard(Arg1, Map, Env, Eval, State),
+ case t_is_atom(true, Type1) of
+ false -> throw({fail, none});
+ true ->
+ {Map2, Type2} = bind_guard(Arg2, Map1, Env, Eval, State),
+ case t_is_atom(true, Type2) of
+ false -> throw({fail, none});
+ true -> {Map2, t_atom(true)}
+ end
+ end;
+ neg ->
+ {Map1, Type1} =
+ try bind_guard(Arg1, Map, Env, neg, State)
+ catch throw:{fail, _} -> bind_guard(Arg2, Map, Env, pos, State)
+ end,
+ {Map2, Type2} =
+ try bind_guard(Arg1, Map, Env, neg, State)
+ catch throw:{fail, _} -> bind_guard(Arg2, Map, Env, pos, State)
+ end,
+ case t_is_atom(false, Type1) orelse t_is_atom(false, Type2) of
+ true -> {join_maps([Map1, Map2], Map), t_atom(false)};
+ false -> throw({fail, none})
+ end;
+ dont_know ->
+ True = t_atom(true),
+ {Map1, Type1} = bind_guard(Arg1, Map, Env, dont_know, State),
+ case t_is_none(t_inf(Type1, t_boolean())) of
+ true -> throw({fail, none});
+ false ->
+ {Map2, Type2} = bind_guard(Arg2, Map1, Env, Eval, State),
+ case t_is_none(t_inf(Type2, t_boolean())) of
+ true -> throw({fail, none});
+ false -> {Map2, True}
+ end
+ end
+ end.
+
+handle_guard_or(Guard, Map, Env, Eval, State) ->
+ [Arg1, Arg2] = cerl:call_args(Guard),
+ case Eval of
+ pos ->
+ {Map1, Bool1} =
+ try bind_guard(Arg1, Map, Env, pos, State)
+ catch
+ throw:{fail,_} -> bind_guard(Arg1, Map, Env, dont_know, State)
+ end,
+ {Map2, Bool2} =
+ try bind_guard(Arg2, Map, Env, pos, State)
+ catch
+ throw:{fail,_} -> bind_guard(Arg2, Map, Env, dont_know, State)
+ end,
+ case ((t_is_atom(true, Bool1) andalso t_is_boolean(Bool2))
+ orelse
+ (t_is_atom(true, Bool2) andalso t_is_boolean(Bool1))) of
+ true -> {join_maps([Map1, Map2], Map), t_atom(true)};
+ false -> throw({fail, none})
+ end;
+ neg ->
+ {Map1, Type1} = bind_guard(Arg1, Map, Env, neg, State),
+ case t_is_atom(true, Type1) of
+ false -> throw({fail, none});
+ true ->
+ {Map2, Type2} = bind_guard(Arg2, Map1, Env, neg, State),
+ case t_is_atom(true, Type2) of
+ false -> throw({fail, none});
+ true -> {Map2, t_atom(false)}
+ end
+ end;
+ dont_know ->
+ {Map1, Bool1} = bind_guard(Arg1, Map, Env, dont_know, State),
+ {Map2, Bool2} = bind_guard(Arg2, Map, Env, dont_know, State),
+ case t_is_boolean(Bool1) andalso t_is_boolean(Bool2) of
+ true -> {join_maps([Map1, Map2], Map), t_sup(Bool1, Bool2)};
+ false -> throw({fail, none})
+ end
+ end.
+
+handle_guard_not(Guard, Map, Env, Eval, State) ->
+ [Arg] = cerl:call_args(Guard),
+ case Eval of
+ neg ->
+ {Map1, Type} = bind_guard(Arg, Map, Env, pos, State),
+ case t_is_atom(true, Type) of
+ true -> {Map1, t_atom(false)};
+ false -> throw({fail, none})
+ end;
+ pos ->
+ {Map1, Type} = bind_guard(Arg, Map, Env, neg, State),
+ case t_is_atom(false, Type) of
+ true -> {Map1, t_atom(true)};
+ false -> throw({fail, none})
+ end;
+ dont_know ->
+ {Map1, Type} = bind_guard(Arg, Map, Env, dont_know, State),
+ Bool = t_inf(Type, t_boolean()),
+ case t_is_none(Bool) of
+ true -> throw({fatal_fail, none});
+ false ->
+ case t_atom_vals(Bool) of
+ ['true'] -> {Map1, t_atom(false)};
+ ['false'] -> {Map1, t_atom(true)};
+ [_, _] -> {Map1, Bool}
+ end
+ end
+ end.
+
+bind_guard_list(Guards, Map, Env, Eval, State) ->
+ bind_guard_list(Guards, Map, Env, Eval, State, []).
+
+bind_guard_list([G|Gs], Map, Env, Eval, State, Acc) ->
+ {Map1, T} = bind_guard(G, Map, Env, Eval, State),
+ bind_guard_list(Gs, Map1, Env, Eval, State, [T|Acc]);
+bind_guard_list([], Map, _Env, _Eval, _State, Acc) ->
+ {Map, lists:reverse(Acc)}.
+
+-spec signal_guard_fail(cerl:c_call(), [erl_types:erl_type()], #state{}) ->
+ no_return().
+
+signal_guard_fail(Guard, ArgTypes, State) ->
+ Args = cerl:call_args(Guard),
+ F = cerl:atom_val(cerl:call_name(Guard)),
+ MFA = {cerl:atom_val(cerl:call_module(Guard)), F, length(Args)},
+ Msg =
+ case is_infix_op(MFA) of
+ true ->
+ [ArgType1, ArgType2] = ArgTypes,
+ [Arg1, Arg2] = Args,
+ {guard_fail, [format_args_1([Arg1], [ArgType1], State),
+ atom_to_list(F),
+ format_args_1([Arg2], [ArgType2], State)]};
+ false ->
+ mk_guard_msg(F, Args, ArgTypes, State)
+ end,
+ throw({fail, {Guard, Msg}}).
+
+is_infix_op({erlang, '=:=', 2}) -> true;
+is_infix_op({erlang, '==', 2}) -> true;
+is_infix_op({erlang, '=/=', 2}) -> true;
+is_infix_op({erlang, '=/', 2}) -> true;
+is_infix_op({erlang, '<', 2}) -> true;
+is_infix_op({erlang, '=<', 2}) -> true;
+is_infix_op({erlang, '>', 2}) -> true;
+is_infix_op({erlang, '>=', 2}) -> true;
+is_infix_op({M, F, A}) when is_atom(M), is_atom(F),
+ is_integer(A), 0 =< A, A =< 255 -> false.
+
+-spec signal_guard_fatal_fail(cerl:c_call(), [erl_types:erl_type()], #state{}) ->
+ no_return().
+
+signal_guard_fatal_fail(Guard, ArgTypes, State) ->
+ Args = cerl:call_args(Guard),
+ F = cerl:atom_val(cerl:call_name(Guard)),
+ Msg = mk_guard_msg(F, Args, ArgTypes, State),
+ throw({fatal_fail, {Guard, Msg}}).
+
+mk_guard_msg(F, Args, ArgTypes, State) ->
+ FArgs = [F, format_args(Args, ArgTypes, State)],
+ case any_has_opaque_subtype(ArgTypes) of
+ true -> {opaque_guard, FArgs};
+ false -> {guard_fail, FArgs}
+ end.
+
+bind_guard_case_clauses(Arg, Clauses, Map, Env, Eval, State) ->
+ Clauses1 = filter_fail_clauses(Clauses),
+ {GenMap, GenArgType} = bind_guard(Arg, Map, Env, dont_know, State),
+ bind_guard_case_clauses(GenArgType, GenMap, Arg, Clauses1, Map, Env, Eval,
+ t_none(), [], State).
+
+filter_fail_clauses([Clause|Left]) ->
+ case (cerl:clause_pats(Clause) =:= []) of
+ true ->
+ Body = cerl:clause_body(Clause),
+ case cerl:is_literal(Body) andalso (cerl:concrete(Body) =:= fail) of
+ true -> filter_fail_clauses(Left);
+ false -> [Clause|filter_fail_clauses(Left)]
+ end;
+ false ->
+ [Clause|filter_fail_clauses(Left)]
+ end;
+filter_fail_clauses([]) ->
+ [].
+
+bind_guard_case_clauses(GenArgType, GenMap, ArgExpr, [Clause|Left],
+ Map, Env, Eval, AccType, AccMaps, State) ->
+ Pats = cerl:clause_pats(Clause),
+ {NewMap0, ArgType} =
+ case Pats of
+ [Pat] ->
+ case cerl:is_literal(Pat) of
+ true ->
+ try
+ case cerl:concrete(Pat) of
+ true -> bind_guard(ArgExpr, Map, Env, pos, State);
+ false -> bind_guard(ArgExpr, Map, Env, neg, State);
+ _ -> {GenMap, GenArgType}
+ end
+ catch
+ throw:{fail, _} -> {none, GenArgType}
+ end;
+ false ->
+ {GenMap, GenArgType}
+ end;
+ _ -> {GenMap, GenArgType}
+ end,
+ NewMap1 =
+ case Pats =:= [] of
+ true -> NewMap0;
+ false ->
+ case t_is_none(ArgType) of
+ true -> none;
+ false ->
+ ArgTypes = case t_is_any(ArgType) of
+ true -> Any = t_any(), [Any || _ <- Pats];
+ false -> t_to_tlist(ArgType)
+ end,
+ case bind_pat_vars(Pats, ArgTypes, [], NewMap0, State) of
+ {error, _, _, _, _} -> none;
+ {PatMap, _PatTypes} -> PatMap
+ end
+ end
+ end,
+ Guard = cerl:clause_guard(Clause),
+ GenPatType = dialyzer_typesig:get_safe_underapprox(Pats, Guard),
+ NewGenArgType = t_subtract(GenArgType, GenPatType),
+ case (NewMap1 =:= none) orelse t_is_none(GenArgType) of
+ true ->
+ bind_guard_case_clauses(NewGenArgType, GenMap, ArgExpr, Left, Map, Env,
+ Eval, AccType, AccMaps, State);
+ false ->
+ {NewAccType, NewAccMaps} =
+ try
+ {NewMap2, GuardType} = bind_guard(Guard, NewMap1, Env, pos, State),
+ case t_is_none(t_inf(t_atom(true), GuardType)) of
+ true -> throw({fail, none});
+ false -> ok
+ end,
+ {NewMap3, CType} = bind_guard(cerl:clause_body(Clause), NewMap2,
+ Env, Eval, State),
+ case Eval of
+ pos ->
+ case t_is_atom(true, CType) of
+ true -> ok;
+ false -> throw({fail, none})
+ end;
+ neg ->
+ case t_is_atom(false, CType) of
+ true -> ok;
+ false -> throw({fail, none})
+ end;
+ dont_know ->
+ ok
+ end,
+ {t_sup(AccType, CType), [NewMap3|AccMaps]}
+ catch
+ throw:{fail, _What} -> {AccType, AccMaps}
+ end,
+ bind_guard_case_clauses(NewGenArgType, GenMap, ArgExpr, Left, Map, Env,
+ Eval, NewAccType, NewAccMaps, State)
+ end;
+bind_guard_case_clauses(_GenArgType, _GenMap, _ArgExpr, [], Map, _Env, _Eval,
+ AccType, AccMaps, _State) ->
+ case t_is_none(AccType) of
+ true -> throw({fail, none});
+ false -> {join_maps(AccMaps, Map), AccType}
+ end.
+
+%%% ===========================================================================
+%%%
+%%% Maps and types.
+%%%
+%%% ===========================================================================
+
+map__new() ->
+ {dict:new(), dict:new()}.
+
+join_maps(Maps, MapOut) ->
+ {Map, Subst} = MapOut,
+ Keys = ordsets:from_list(dict:fetch_keys(Map) ++ dict:fetch_keys(Subst)),
+ join_maps(Keys, Maps, MapOut).
+
+join_maps([Key|Left], Maps, MapOut) ->
+ Type = join_maps_one_key(Maps, Key, t_none()),
+ case t_is_equal(lookup_type(Key, MapOut), Type) of
+ true -> join_maps(Left, Maps, MapOut);
+ false -> join_maps(Left, Maps, enter_type(Key, Type, MapOut))
+ end;
+join_maps([], _Maps, MapOut) ->
+ MapOut.
+
+join_maps_one_key([Map|Left], Key, AccType) ->
+ case t_is_any(AccType) of
+ true ->
+ %% We can stop here
+ AccType;
+ false ->
+ join_maps_one_key(Left, Key, t_sup(lookup_type(Key, Map), AccType))
+ end;
+join_maps_one_key([], _Key, AccType) ->
+ AccType.
+
+enter_type_lists([Key|KeyTail], [Val|ValTail], Map) ->
+ Map1 = enter_type(Key, Val, Map),
+ enter_type_lists(KeyTail, ValTail, Map1);
+enter_type_lists([], [], Map) ->
+ Map.
+
+enter_type_list([{Key, Val}|Left], Map) ->
+ Map1 = enter_type(Key, Val, Map),
+ enter_type_list(Left, Map1);
+enter_type_list([], Map) ->
+ Map.
+
+enter_type(Key, Val, {Map, Subst} = MS) ->
+ case cerl:is_literal(Key) of
+ true -> MS;
+ false ->
+ case cerl:is_c_values(Key) of
+ true ->
+ Keys = cerl:values_es(Key),
+ case t_is_any(Val) orelse t_is_none(Val) of
+ true ->
+ enter_type_lists(Keys, [Val || _ <- Keys], MS);
+ false ->
+ enter_type_lists(cerl:values_es(Key), t_to_tlist(Val), MS)
+ end;
+ false ->
+ KeyLabel = get_label(Key),
+ case dict:find(KeyLabel, Subst) of
+ {ok, NewKey} ->
+ ?debug("Binding ~p to ~p\n", [KeyLabel, NewKey]),
+ enter_type(NewKey, Val, MS);
+ error ->
+ ?debug("Entering ~p :: ~s\n", [KeyLabel, t_to_string(Val)]),
+ case dict:find(KeyLabel, Map) of
+ {ok, Val} -> MS;
+ {ok, _OldVal} -> {dict:store(KeyLabel, Val, Map), Subst};
+ error -> {dict:store(KeyLabel, Val, Map), Subst}
+ end
+ end
+ end
+ end.
+
+enter_subst(Key, Val, {Map, Subst} = MS) ->
+ KeyLabel = get_label(Key),
+ case cerl:is_literal(Val) of
+ true ->
+ NewMap = dict:store(KeyLabel, literal_type(Val), Map),
+ {NewMap, Subst};
+ false ->
+ case cerl:is_c_var(Val) of
+ false -> MS;
+ true ->
+ ValLabel = get_label(Val),
+ case dict:find(ValLabel, Subst) of
+ {ok, NewVal} ->
+ enter_subst(Key, NewVal, MS);
+ error ->
+ if KeyLabel =:= ValLabel -> MS;
+ true ->
+ ?debug("Subst: storing ~p = ~p\n", [KeyLabel, ValLabel]),
+ NewSubst = dict:store(KeyLabel, ValLabel, Subst),
+ {Map, NewSubst}
+ end
+ end
+ end
+ end.
+
+lookup_type(Key, {Map, Subst}) ->
+ lookup(Key, Map, Subst, t_none()).
+
+lookup(Key, Map, Subst, AnyNone) ->
+ case cerl:is_literal(Key) of
+ true -> literal_type(Key);
+ false ->
+ Label = get_label(Key),
+ case dict:find(Label, Subst) of
+ {ok, NewKey} -> lookup(NewKey, Map, Subst, AnyNone);
+ error ->
+ case dict:find(Label, Map) of
+ {ok, Val} -> Val;
+ error -> AnyNone
+ end
+ end
+ end.
+
+lookup_fun_sig(Fun, Callgraph, Plt) ->
+ MFAorLabel =
+ case dialyzer_callgraph:lookup_name(Fun, Callgraph) of
+ error -> Fun;
+ {ok, MFA} -> MFA
+ end,
+ dialyzer_plt:lookup(Plt, MFAorLabel).
+
+literal_type(Lit) ->
+ t_from_term(cerl:concrete(Lit)).
+
+mark_as_fresh([Tree|Left], Map) ->
+ SubTrees1 = lists:append(cerl:subtrees(Tree)),
+ {SubTrees2, Map1} =
+ case cerl:type(Tree) of
+ bitstr ->
+ %% The Size field is not fresh.
+ {SubTrees1 -- [cerl:bitstr_size(Tree)], Map};
+ var ->
+ {SubTrees1, enter_type(Tree, t_any(), Map)};
+ _ ->
+ {SubTrees1, Map}
+ end,
+ mark_as_fresh(SubTrees2 ++ Left, Map1);
+mark_as_fresh([], Map) ->
+ Map.
+
+-ifdef(DEBUG).
+debug_pp_map(Map = {Map0, _Subst}) ->
+ Keys = dict:fetch_keys(Map0),
+ io:format("Map:\n", []),
+ lists:foreach(fun (Key) ->
+ io:format("\t~w :: ~s\n",
+ [Key, t_to_string(lookup_type(Key, Map))])
+ end, Keys),
+ ok.
+-else.
+debug_pp_map(_Map) -> ok.
+-endif.
+
+%%% ===========================================================================
+%%%
+%%% Utilities
+%%%
+%%% ===========================================================================
+
+get_label(L) when is_integer(L) ->
+ L;
+get_label(T) ->
+ cerl_trees:get_label(T).
+
+t_is_simple(ArgType) ->
+ t_is_atom(ArgType) orelse t_is_number(ArgType) orelse t_is_port(ArgType)
+ orelse t_is_pid(ArgType) orelse t_is_reference(ArgType)
+ orelse t_is_nil(ArgType).
+
+%% t_is_structured(ArgType) ->
+%% case t_is_nil(ArgType) of
+%% true -> false;
+%% false ->
+%% SType = t_inf(t_sup([t_list(), t_tuple(), t_binary()]), ArgType),
+%% t_is_equal(ArgType, SType)
+%% end.
+
+is_call_to_send(Tree) ->
+ case cerl:is_c_call(Tree) of
+ false -> false;
+ true ->
+ Mod = cerl:call_module(Tree),
+ Name = cerl:call_name(Tree),
+ Arity = cerl:call_arity(Tree),
+ cerl:is_c_atom(Mod)
+ andalso cerl:is_c_atom(Name)
+ andalso (cerl:atom_val(Name) =:= '!')
+ andalso (cerl:atom_val(Mod) =:= erlang)
+ andalso (Arity =:= 2)
+ end.
+
+any_opaque(Ts) ->
+ lists:any(fun erl_types:t_is_opaque/1, Ts).
+
+any_has_opaque_subtype(Ts) ->
+ lists:any(fun erl_types:t_has_opaque_subtype/1, Ts).
+
+filter_match_fail([Clause] = Cls) ->
+ Body = cerl:clause_body(Clause),
+ case cerl:type(Body) of
+ primop ->
+ case cerl:atom_val(cerl:primop_name(Body)) of
+ match_fail -> [];
+ raise -> [];
+ _ -> Cls
+ end;
+ _ -> Cls
+ end;
+filter_match_fail([H|T]) ->
+ [H|filter_match_fail(T)];
+filter_match_fail([]) ->
+ %% This can actually happen, for example in
+ %% receive after 1 -> ok end
+ [].
+
+determine_mode(Type, Opaques) ->
+ case lists:member(Type, Opaques) of
+ true -> opaque;
+ false -> structured
+ end.
+
+%%% ===========================================================================
+%%%
+%%% The State.
+%%%
+%%% ===========================================================================
+
+state__new(Callgraph, Tree, Plt, Module, Records) ->
+ TreeMap = build_tree_map(Tree),
+ Funs = dict:fetch_keys(TreeMap),
+ FunTab = init_fun_tab(Funs, dict:new(), TreeMap, Callgraph, Plt),
+ Work = init_work([get_label(Tree)]),
+ Env = dict:store(top, map__new(), dict:new()),
+ Opaques = erl_types:module_builtin_opaques(Module) ++
+ erl_types:t_opaque_from_records(Records),
+ #state{callgraph = Callgraph, envs = Env, fun_tab = FunTab, opaques = Opaques,
+ plt = Plt, races = dialyzer_races:new(), records = Records,
+ warning_mode = false, warnings = [], work = Work, tree_map = TreeMap}.
+
+state__mark_fun_as_handled(#state{fun_tab = FunTab} = State, Fun0) ->
+ Fun = get_label(Fun0),
+ case dict:find(Fun, FunTab) of
+ {ok, {not_handled, Entry}} ->
+ State#state{fun_tab = dict:store(Fun, Entry, FunTab)};
+ {ok, {_, _}} ->
+ State
+ end.
+
+state__warning_mode(#state{warning_mode = WM}) ->
+ WM.
+
+state__set_warning_mode(#state{tree_map = TreeMap, fun_tab = FunTab,
+ races = Races} = State) ->
+ ?debug("Starting warning pass\n", []),
+ Funs = dict:fetch_keys(TreeMap),
+ State#state{work = init_work([top|Funs--[top]]),
+ fun_tab = FunTab, warning_mode = true,
+ races = dialyzer_races:put_race_analysis(true, Races)}.
+
+state__restore_race_code(RaceCode, #state{callgraph = Callgraph} = State) ->
+ State#state{callgraph = dialyzer_callgraph:put_race_code(RaceCode,
+ Callgraph)}.
+
+state__race_analysis(Analysis, #state{races = Races} = State) ->
+ State#state{races = dialyzer_races:put_race_analysis(Analysis, Races)}.
+
+state__renew_curr_fun(CurrFun, CurrFunLabel,
+ #state{races = Races} = State) ->
+ State#state{races = dialyzer_races:put_curr_fun(CurrFun, CurrFunLabel,
+ Races)}.
+
+state__renew_fun_args(Args, #state{races = Races} = State) ->
+ case state__warning_mode(State) of
+ true -> State;
+ false ->
+ State#state{races = dialyzer_races:put_fun_args(Args, Races)}
+ end.
+
+state__renew_race_list(RaceList, RaceListSize,
+ #state{races = Races} = State) ->
+ State#state{races = dialyzer_races:put_race_list(RaceList, RaceListSize,
+ Races)}.
+
+state__renew_warnings(Warnings, State) ->
+ State#state{warnings = Warnings}.
+
+-spec state__add_warning(dial_warning(), state()) -> state().
+
+state__add_warning(Warn, #state{warnings = Warnings} = State) ->
+ State#state{warnings = [Warn|Warnings]}.
+
+state__add_warning(State, Tag, Tree, Msg) ->
+ state__add_warning(State, Tag, Tree, Msg, false).
+
+state__add_warning(#state{warning_mode = false} = State, _, _, _, _) ->
+ State;
+state__add_warning(#state{warnings = Warnings, warning_mode = true} = State,
+ Tag, Tree, Msg, Force) ->
+ Ann = cerl:get_ann(Tree),
+ case Force of
+ true ->
+ Warn = {Tag, {get_file(Ann), abs(get_line(Ann))}, Msg},
+ State#state{warnings = [Warn|Warnings]};
+ false ->
+ case is_compiler_generated(Ann) of
+ true -> State;
+ false ->
+ Warn = {Tag, {get_file(Ann), get_line(Ann)}, Msg},
+ State#state{warnings = [Warn|Warnings]}
+ end
+ end.
+
+state__get_race_warnings(#state{races = Races} = State) ->
+ {Races1, State1} = dialyzer_races:get_race_warnings(Races, State),
+ State1#state{races = Races1}.
+
+state__get_warnings(#state{tree_map = TreeMap, fun_tab = FunTab,
+ callgraph = Callgraph, plt = Plt} = State,
+ NoWarnUnused) ->
+ FoldFun =
+ fun({top, _}, AccState) -> AccState;
+ ({FunLbl, Fun}, AccState) ->
+ {NotCalled, Ret} =
+ case dict:fetch(get_label(Fun), FunTab) of
+ {not_handled, {_Args0, Ret0}} -> {true, Ret0};
+ {Args0, Ret0} -> {any_none(Args0), Ret0}
+ end,
+ case NotCalled of
+ true ->
+ {Warn, Msg} =
+ case dialyzer_callgraph:lookup_name(FunLbl, Callgraph) of
+ error -> {true, {unused_fun, []}};
+ {ok, {_M, F, A}} = MFA ->
+ {not sets:is_element(MFA, NoWarnUnused),
+ {unused_fun, [F, A]}}
+ end,
+ case Warn of
+ true -> state__add_warning(AccState, ?WARN_NOT_CALLED, Fun, Msg);
+ false -> AccState
+ end;
+ false ->
+ {Name, Contract} =
+ case dialyzer_callgraph:lookup_name(FunLbl, Callgraph) of
+ error -> {[], none};
+ {ok, {_M, F, A} = MFA} ->
+ {[F, A], dialyzer_plt:lookup_contract(Plt, MFA)}
+ end,
+ case t_is_none(Ret) of
+ true ->
+ %% Check if the function has a contract that allows this.
+ Warn =
+ case Contract of
+ none -> true;
+ {value, C} ->
+ GenRet = dialyzer_contracts:get_contract_return(C),
+ not t_is_unit(GenRet)
+ end,
+ case Warn of
+ true ->
+ case classify_returns(Fun) of
+ no_match ->
+ Msg = {no_return, [no_match|Name]},
+ state__add_warning(AccState, ?WARN_RETURN_NO_RETURN,
+ Fun, Msg);
+ only_explicit ->
+ Msg = {no_return, [only_explicit|Name]},
+ state__add_warning(AccState, ?WARN_RETURN_ONLY_EXIT,
+ Fun, Msg);
+ only_normal ->
+ Msg = {no_return, [only_normal|Name]},
+ state__add_warning(AccState, ?WARN_RETURN_NO_RETURN,
+ Fun, Msg);
+ both ->
+ Msg = {no_return, [both|Name]},
+ state__add_warning(AccState, ?WARN_RETURN_NO_RETURN,
+ Fun, Msg)
+ end;
+ false ->
+ AccState
+ end;
+ false ->
+ AccState
+ end
+ end
+ end,
+ #state{warnings = Warn} = lists:foldl(FoldFun, State, dict:to_list(TreeMap)),
+ Warn.
+
+state__is_escaping(Fun, #state{callgraph = Callgraph}) ->
+ dialyzer_callgraph:is_escaping(Fun, Callgraph).
+
+state__lookup_type_for_rec_var(Var, #state{callgraph = Callgraph} = State) ->
+ Label = get_label(Var),
+ case dialyzer_callgraph:lookup_rec_var(Label, Callgraph) of
+ error -> error;
+ {ok, MFA} ->
+ {ok, FunLabel} = dialyzer_callgraph:lookup_label(MFA, Callgraph),
+ {ok, state__fun_type(FunLabel, State)}
+ end.
+
+state__lookup_name({_, _, _} = MFA, #state{}) ->
+ MFA;
+state__lookup_name(top, #state{}) ->
+ top;
+state__lookup_name(Fun, #state{callgraph = Callgraph}) ->
+ case dialyzer_callgraph:lookup_name(Fun, Callgraph) of
+ {ok, MFA} -> MFA;
+ error -> Fun
+ end.
+
+state__lookup_record(Tag, Arity, #state{records = Records}) ->
+ case erl_types:lookup_record(Tag, Arity, Records) of
+ {ok, Fields} ->
+ {ok, t_tuple([t_atom(Tag)|
+ [FieldType || {_FieldName, FieldType} <- Fields]])};
+ error ->
+ error
+ end.
+
+state__get_args(Tree, #state{fun_tab = FunTab}) ->
+ Fun = get_label(Tree),
+ case dict:find(Fun, FunTab) of
+ {ok, {not_handled, {ArgTypes, _}}} -> ArgTypes;
+ {ok, {ArgTypes, _}} -> ArgTypes
+ end.
+
+build_tree_map(Tree) ->
+ Fun =
+ fun(T, Dict) ->
+ case cerl:is_c_fun(T) of
+ true ->
+ dict:store(get_label(T), T, Dict);
+ false ->
+ Dict
+ end
+ end,
+ cerl_trees:fold(Fun, dict:new(), Tree).
+
+init_fun_tab([top|Left], Dict, TreeMap, Callgraph, Plt) ->
+ NewDict = dict:store(top, {not_handled, {[], t_none()}}, Dict),
+ init_fun_tab(Left, NewDict, TreeMap, Callgraph, Plt);
+init_fun_tab([Fun|Left], Dict, TreeMap, Callgraph, Plt) ->
+ Arity = cerl:fun_arity(dict:fetch(Fun, TreeMap)),
+ FunEntry =
+ case dialyzer_callgraph:is_escaping(Fun, Callgraph) of
+ true ->
+ Args = lists:duplicate(Arity, t_any()),
+ case lookup_fun_sig(Fun, Callgraph, Plt) of
+ none -> {Args, t_unit()};
+ {value, {RetType, _}} ->
+ case t_is_none(RetType) of
+ true -> {Args, t_none()};
+ false -> {Args, t_unit()}
+ end
+ end;
+ false -> {lists:duplicate(Arity, t_none()), t_unit()}
+ end,
+ NewDict = dict:store(Fun, {not_handled, FunEntry}, Dict),
+ init_fun_tab(Left, NewDict, TreeMap, Callgraph, Plt);
+init_fun_tab([], Dict, _TreeMap, _Callgraph, _Plt) ->
+ Dict.
+
+state__update_fun_env(Tree, Map, #state{envs = Envs} = State) ->
+ NewEnvs = dict:store(get_label(Tree), Map, Envs),
+ State#state{envs = NewEnvs}.
+
+state__fun_env(Tree, #state{envs = Envs}) ->
+ Fun = get_label(Tree),
+ case dict:find(Fun, Envs) of
+ error -> none;
+ {ok, Map} -> Map
+ end.
+
+state__clean_not_called(#state{fun_tab = FunTab} = State) ->
+ NewFunTab =
+ dict:map(fun(top, Entry) -> Entry;
+ (_Fun, {not_handled, {Args, _}}) -> {Args, t_none()};
+ (_Fun, Entry) -> Entry
+ end, FunTab),
+ State#state{fun_tab = NewFunTab}.
+
+state__all_fun_types(#state{fun_tab = FunTab}) ->
+ Tab1 = dict:erase(top, FunTab),
+ dict:map(fun(_Fun, {Args, Ret}) -> t_fun(Args, Ret)end, Tab1).
+
+state__fun_type(Fun, #state{fun_tab = FunTab}) ->
+ Label =
+ if is_integer(Fun) -> Fun;
+ true -> get_label(Fun)
+ end,
+ case dict:find(Label, FunTab) of
+ {ok, {not_handled, {A, R}}} ->
+ t_fun(A, R);
+ {ok, {A, R}} ->
+ t_fun(A, R)
+ end.
+
+state__update_fun_entry(Tree, ArgTypes, Out0,
+ #state{fun_tab=FunTab, callgraph=CG, plt=Plt} = State)->
+ Fun = get_label(Tree),
+ Out1 =
+ if Fun =:= top -> Out0;
+ true ->
+ case lookup_fun_sig(Fun, CG, Plt) of
+ {value, {SigRet, _}} -> t_inf(SigRet, Out0, opaque);
+ none -> Out0
+ end
+ end,
+ Out = t_limit(Out1, ?TYPE_LIMIT),
+ case dict:find(Fun, FunTab) of
+ {ok, {ArgTypes, OldOut}} ->
+ case t_is_equal(OldOut, Out) of
+ true ->
+ ?debug("Fixpoint for ~w: ~s\n",
+ [state__lookup_name(Fun, State),
+ t_to_string(t_fun(ArgTypes, Out))]),
+ State;
+ false ->
+ NewEntry = {ArgTypes, Out},
+ ?debug("New Entry for ~w: ~s\n",
+ [state__lookup_name(Fun, State),
+ t_to_string(t_fun(ArgTypes, Out))]),
+ NewFunTab = dict:store(Fun, NewEntry, FunTab),
+ State1 = State#state{fun_tab = NewFunTab},
+ state__add_work_from_fun(Tree, State1)
+ end;
+ {ok, {NewArgTypes, _OldOut}} ->
+ %% Can only happen in self-recursive functions. Only update the out type.
+ NewEntry = {NewArgTypes, Out},
+ ?debug("New Entry for ~w: ~s\n",
+ [state__lookup_name(Fun, State),
+ t_to_string(t_fun(NewArgTypes, Out))]),
+ NewFunTab = dict:store(Fun, NewEntry, FunTab),
+ State1 = State#state{fun_tab = NewFunTab},
+ state__add_work_from_fun(Tree, State1)
+ end.
+
+state__add_work_from_fun(_Tree, #state{warning_mode = true} = State) ->
+ State;
+state__add_work_from_fun(Tree, #state{callgraph = Callgraph,
+ tree_map = TreeMap} = State) ->
+ case get_label(Tree) of
+ top -> State;
+ Label when is_integer(Label) ->
+ case dialyzer_callgraph:in_neighbours(Label, Callgraph) of
+ none -> State;
+ MFAList ->
+ LabelList = [dialyzer_callgraph:lookup_label(MFA, Callgraph)
+ || MFA <- MFAList],
+ %% Must filter the result for results in this module.
+ FilteredList = [L || {ok, L} <- LabelList, dict:is_key(L, TreeMap)],
+ ?debug("~w: Will try to add:~w\n",
+ [state__lookup_name(get_label(Tree), State), MFAList]),
+ lists:foldl(fun(L, AccState) ->
+ state__add_work(L, AccState)
+ end, State, FilteredList)
+ end
+ end.
+
+state__add_work(external, State) ->
+ State;
+state__add_work(top, State) ->
+ State;
+state__add_work(Fun, #state{work = Work} = State) ->
+ NewWork = add_work(Fun, Work),
+ State#state{work = NewWork}.
+
+state__get_work(#state{work = Work, tree_map = TreeMap} = State) ->
+ case get_work(Work) of
+ none -> none;
+ {Fun, NewWork} ->
+ {dict:fetch(Fun, TreeMap), State#state{work = NewWork}}
+ end.
+
+state__lookup_call_site(Tree, #state{callgraph = Callgraph}) ->
+ Label = get_label(Tree),
+ dialyzer_callgraph:lookup_call_site(Label, Callgraph).
+
+state__fun_info(external, #state{}) ->
+ external;
+state__fun_info({_, _, _} = MFA, #state{plt = PLT}) ->
+ {MFA,
+ dialyzer_plt:lookup(PLT, MFA),
+ dialyzer_plt:lookup_contract(PLT, MFA),
+ t_any()};
+state__fun_info(Fun, #state{callgraph = CG, fun_tab = FunTab, plt = PLT}) ->
+ {Sig, Contract} =
+ case dialyzer_callgraph:lookup_name(Fun, CG) of
+ error ->
+ {dialyzer_plt:lookup(PLT, Fun), none};
+ {ok, MFA} ->
+ {dialyzer_plt:lookup(PLT, MFA), dialyzer_plt:lookup_contract(PLT, MFA)}
+ end,
+ LocalRet =
+ case dict:fetch(Fun, FunTab) of
+ {not_handled, {_Args, Ret}} -> Ret;
+ {_Args, Ret} -> Ret
+ end,
+ {Fun, Sig, Contract, LocalRet}.
+
+state__find_apply_return(Tree, #state{callgraph = Callgraph} = State) ->
+ Apply = get_label(Tree),
+ case dialyzer_callgraph:lookup_call_site(Apply, Callgraph) of
+ error ->
+ unknown;
+ {ok, List} ->
+ case lists:member(external, List) of
+ true -> t_any();
+ false ->
+ FunTypes = [state__fun_type(F, State) || F <- List],
+ Returns = [t_fun_range(F) || F <- FunTypes],
+ t_sup(Returns)
+ end
+ end.
+
+forward_args(Fun, ArgTypes, #state{work = Work, fun_tab = FunTab} = State) ->
+ {OldArgTypes, OldOut, Fixpoint} =
+ case dict:find(Fun, FunTab) of
+ {ok, {not_handled, {OldArgTypes0, OldOut0}}} ->
+ {OldArgTypes0, OldOut0, false};
+ {ok, {OldArgTypes0, OldOut0}} ->
+ {OldArgTypes0, OldOut0,
+ t_is_subtype(t_product(ArgTypes), t_product(OldArgTypes0))}
+ end,
+ case Fixpoint of
+ true -> State;
+ false ->
+ NewArgTypes = [t_sup(X, Y) || {X, Y} <- lists:zip(ArgTypes, OldArgTypes)],
+ NewWork = add_work(Fun, Work),
+ ?debug("~w: forwarding args ~s\n",
+ [state__lookup_name(Fun, State),
+ t_to_string(t_product(NewArgTypes))]),
+ NewFunTab = dict:store(Fun, {NewArgTypes, OldOut}, FunTab),
+ State#state{work = NewWork, fun_tab = NewFunTab}
+ end.
+
+-spec state__cleanup(state()) -> state().
+
+state__cleanup(#state{callgraph = Callgraph,
+ races = Races,
+ records = Records}) ->
+ #state{callgraph = dialyzer_callgraph:cleanup(Callgraph),
+ races = dialyzer_races:cleanup(Races),
+ records = Records}.
+
+-spec state__get_callgraph(state()) -> dialyzer_callgraph:callgraph().
+
+state__get_callgraph(#state{callgraph = Callgraph}) ->
+ Callgraph.
+
+-spec state__get_races(state()) -> dialyzer_races:races().
+
+state__get_races(#state{races = Races}) ->
+ Races.
+
+-spec state__get_records(state()) -> dict().
+
+state__get_records(#state{records = Records}) ->
+ Records.
+
+-spec state__put_callgraph(dialyzer_callgraph:callgraph(), state()) ->
+ state().
+
+state__put_callgraph(Callgraph, State) ->
+ State#state{callgraph = Callgraph}.
+
+-spec state__put_races(dialyzer_races:races(), state()) -> state().
+
+state__put_races(Races, State) ->
+ State#state{races = Races}.
+
+-spec state__records_only(state()) -> state().
+
+state__records_only(#state{records = Records}) ->
+ #state{records = Records}.
+
+%%% ===========================================================================
+%%%
+%%% Races
+%%%
+%%% ===========================================================================
+
+renew_code(Fun, FunArgs, Code, WarningMode, Callgraph) ->
+ case WarningMode of
+ true -> Callgraph;
+ false ->
+ RaceCode = dialyzer_callgraph:get_race_code(Callgraph),
+ dialyzer_callgraph:put_race_code(
+ dict:store(Fun, [FunArgs, Code], RaceCode), Callgraph)
+ end.
+
+renew_public_tables([Var], Table, WarningMode, Callgraph) ->
+ case WarningMode of
+ true -> Callgraph;
+ false ->
+ case Table of
+ no_t -> Callgraph;
+ _Other ->
+ VarLabel = get_label(Var),
+ PTables = dialyzer_callgraph:get_public_tables(Callgraph),
+ dialyzer_callgraph:put_public_tables(
+ lists:usort([VarLabel|PTables]), Callgraph)
+ end
+ end.
+
+%%% ===========================================================================
+%%%
+%%% Worklist
+%%%
+%%% ===========================================================================
+
+init_work(List) ->
+ {List, [], sets:from_list(List)}.
+
+get_work({[], [], _Set}) ->
+ none;
+get_work({[H|T], Rev, Set}) ->
+ {H, {T, Rev, sets:del_element(H, Set)}};
+get_work({[], Rev, Set}) ->
+ get_work({lists:reverse(Rev), [], Set}).
+
+add_work(New, {List, Rev, Set} = Work) ->
+ case sets:is_element(New, Set) of
+ true -> Work;
+ false -> {List, [New|Rev], sets:add_element(New, Set)}
+ end.
+
+%%% ===========================================================================
+%%%
+%%% Utilities.
+%%%
+%%% ===========================================================================
+
+get_line([Line|_]) when is_integer(Line) -> Line;
+get_line([_|Tail]) -> get_line(Tail);
+get_line([]) -> -1.
+
+get_file([]) -> [];
+get_file([{file, File}|_]) -> File;
+get_file([_|Tail]) -> get_file(Tail).
+
+is_compiler_generated(Ann) ->
+ lists:member(compiler_generated, Ann) orelse (get_line(Ann) < 1).
+
+-spec format_args([term()], [erl_types:erl_type()], #state{}) ->
+ nonempty_string().
+
+format_args([], [], _State) ->
+ "()";
+format_args(ArgList, TypeList, State) ->
+ "(" ++ format_args_1(ArgList, TypeList, State) ++ ")".
+
+-spec format_args_1([term(),...], [erl_types:erl_type(),...], #state{}) ->
+ string().
+
+format_args_1([Arg], [Type], State) ->
+ format_arg(Arg) ++ format_type(Type, State);
+format_args_1([Arg|Args], [Type|Types], State) ->
+ String =
+ case cerl:is_literal(Arg) of
+ true -> format_cerl(Arg);
+ false -> format_arg(Arg) ++ format_type(Type, State)
+ end,
+ String ++ "," ++ format_args_1(Args, Types, State).
+
+format_arg(Arg) ->
+ Default = "",
+ case cerl:is_c_var(Arg) of
+ true ->
+ case cerl:var_name(Arg) of
+ Atom when is_atom(Atom) ->
+ case atom_to_list(Atom) of
+ "cor"++_ -> Default;
+ "rec"++_ -> Default;
+ Name -> Name ++ "::"
+ end;
+ _What -> Default
+ end;
+ false ->
+ Default
+ end.
+
+-spec format_type(erl_types:erl_type(), #state{}) -> string().
+
+format_type(Type, #state{records = R}) ->
+ t_to_string(Type, R).
+
+-spec format_sig_args(erl_types:erl_type(), #state{}) -> string().
+
+format_sig_args(Type, #state{records = R}) ->
+ SigArgs = t_fun_args(Type),
+ case SigArgs of
+ [] -> "()";
+ [SArg|SArgs] ->
+ lists:flatten("(" ++ t_to_string(SArg, R)
+ ++ ["," ++ t_to_string(T, R) || T <- SArgs] ++ ")")
+ end.
+
+format_cerl(Tree) ->
+ cerl_prettypr:format(cerl:set_ann(Tree, []),
+ [{hook, dialyzer_utils:pp_hook()},
+ {noann, true},
+ {paper, 100000}, %% These guys strip
+ {ribbon, 100000} %% newlines.
+ ]).
+
+format_patterns(Pats) ->
+ NewPats = map_pats(cerl:c_values(Pats)),
+ String = format_cerl(NewPats),
+ case Pats of
+ [PosVar] ->
+ case cerl:is_c_var(PosVar) andalso (cerl:var_name(PosVar) =/= '') of
+ true -> "variable "++String;
+ false -> "pattern "++String
+ end;
+ _ ->
+ "pattern "++String
+ end.
+
+map_pats(Pats) ->
+ Fun = fun(Tree) ->
+ case cerl:is_c_var(Tree) of
+ true ->
+ case cerl:var_name(Tree) of
+ Atom when is_atom(Atom) ->
+ case atom_to_list(Atom) of
+ "cor"++_ -> cerl:c_var('');
+ "rec"++_ -> cerl:c_var('');
+ _ -> cerl:set_ann(Tree, [])
+ end;
+ _What -> cerl:c_var('')
+ end;
+ false ->
+ cerl:set_ann(Tree, [])
+ end
+ end,
+ cerl_trees:map(Fun, Pats).
+
+classify_returns(Tree) ->
+ case find_terminals(cerl:fun_body(Tree)) of
+ {false, false} -> no_match;
+ {true, false} -> only_explicit;
+ {false, true} -> only_normal;
+ {true, true} -> both
+ end.
+
+find_terminals(Tree) ->
+ case cerl:type(Tree) of
+ apply -> {false, true};
+ binary -> {false, true};
+ bitstr -> {false, true};
+ call ->
+ M0 = cerl:call_module(Tree),
+ F0 = cerl:call_name(Tree),
+ A = length(cerl:call_args(Tree)),
+ case cerl:is_literal(M0) andalso cerl:is_literal(F0) of
+ false ->
+ %% We cannot make assumptions. Say that both are true.
+ {true, true};
+ true ->
+ M = cerl:concrete(M0),
+ F = cerl:concrete(F0),
+ case (erl_bif_types:is_known(M, F, A)
+ andalso t_is_none(erl_bif_types:type(M, F, A))) of
+ true -> {true, false};
+ false -> {false, true}
+ end
+ end;
+ 'case' -> find_terminals_list(cerl:case_clauses(Tree));
+ 'catch' -> find_terminals(cerl:catch_body(Tree));
+ clause -> find_terminals(cerl:clause_body(Tree));
+ cons -> {false, true};
+ 'fun' -> {false, true};
+ 'let' -> find_terminals(cerl:let_body(Tree));
+ letrec -> find_terminals(cerl:letrec_body(Tree));
+ literal -> {false, true};
+ primop -> {false, false}; %% match_fail, etc. are not explicit exits.
+ 'receive' ->
+ Timeout = cerl:receive_timeout(Tree),
+ Clauses = cerl:receive_clauses(Tree),
+ case (cerl:is_literal(Timeout) andalso
+ (cerl:concrete(Timeout) =:= infinity)) of
+ true ->
+ if Clauses =:= [] -> {false, true}; %% A never ending receive.
+ true -> find_terminals_list(Clauses)
+ end;
+ false -> find_terminals_list([cerl:receive_action(Tree)|Clauses])
+ end;
+ seq -> find_terminals(cerl:seq_body(Tree));
+ 'try' ->
+ find_terminals_list([cerl:try_handler(Tree), cerl:try_body(Tree)]);
+ tuple -> {false, true};
+ values -> {false, true};
+ var -> {false, true}
+ end.
+
+find_terminals_list(List) ->
+ find_terminals_list(List, false, false).
+
+find_terminals_list([Tree|Left], Explicit1, Normal1) ->
+ {Explicit2, Normal2} = find_terminals(Tree),
+ case {Explicit1 or Explicit2, Normal1 or Normal2} of
+ {true, true} = Ans -> Ans;
+ {NewExplicit, NewNormal} ->
+ find_terminals_list(Left, NewExplicit, NewNormal)
+ end;
+find_terminals_list([], Explicit, Normal) ->
+ {Explicit, Normal}.
+
+%%----------------------------------------------------------------------------
+
+%% If you write a record pattern in a matching that violates the
+%% definition it will never match. However, the warning is lost in the
+%% regular analysis. This after-pass catches it.
+
+find_mismatched_record_patterns(Tree, State) ->
+ cerl_trees:fold(
+ fun(SubTree, AccState) ->
+ case cerl:is_c_clause(SubTree) of
+ true -> lists:foldl(fun(P, AccState1) ->
+ find_rec_warnings(P, AccState1)
+ end, AccState, cerl:clause_pats(SubTree));
+ false -> AccState
+ end
+ end, State, Tree).
+
+find_rec_warnings(Tree, State) ->
+ cerl_trees:fold(
+ fun(SubTree, AccState) ->
+ case cerl:is_c_tuple(SubTree) of
+ true -> find_rec_warnings_tuple(SubTree, AccState);
+ false -> AccState
+ end
+ end, State, Tree).
+
+find_rec_warnings_tuple(Tree, State) ->
+ Elements = cerl:tuple_es(Tree),
+ {_, _, EsType} = traverse_list(Elements, map__new(), State),
+ TupleType = t_tuple(EsType),
+ case t_is_none(TupleType) of
+ true -> State;
+ false ->
+ %% Let's find out if this is a record construction.
+ case Elements of
+ [Tag|Left] ->
+ case cerl:is_c_atom(Tag) of
+ true ->
+ TagVal = cerl:atom_val(Tag),
+ case state__lookup_record(TagVal, length(Left), State) of
+ error -> State;
+ {ok, Prototype} ->
+ InfTupleType = t_inf(Prototype, TupleType),
+ case t_is_none(InfTupleType) of
+ true ->
+ Msg = {record_matching,
+ [format_patterns([Tree]), TagVal]},
+ state__add_warning(State, ?WARN_MATCHING, Tree, Msg);
+ false ->
+ State
+ end
+ end;
+ false ->
+ State
+ end;
+ _ ->
+ State
+ end
+ end.
+
+%%----------------------------------------------------------------------------
+
+-ifdef(DEBUG_PP).
+debug_pp(Tree, true) ->
+ io:put_chars(cerl_prettypr:format(Tree, [{hook, cerl_typean:pp_hook()}])),
+ io:nl(),
+ ok;
+debug_pp(Tree, false) ->
+ io:put_chars(cerl_prettypr:format(strip_annotations(Tree))),
+ io:nl(),
+ ok.
+
+strip_annotations(Tree) ->
+ Fun = fun(T) ->
+ case cerl:type(T) of
+ var ->
+ cerl:set_ann(T, [{label, cerl_trees:get_label(T)}]);
+ 'fun' ->
+ cerl:set_ann(T, [{label, cerl_trees:get_label(T)}]);
+ _ ->
+ cerl:set_ann(T, [])
+ end
+ end,
+ cerl_trees:map(Fun, Tree).
+
+-else.
+
+debug_pp(_Tree, _UseHook) ->
+ ok.
+-endif.
+
+%%----------------------------------------------------------------------------
+
+-spec to_dot(dialyzer_callgraph:callgraph()) -> 'ok'.
+
+-ifdef(DOT).
+to_dot(CG) ->
+ dialyzer_callgraph:to_dot(CG).
+-else.
+to_dot(_CG) ->
+ ok.
+-endif.
+
+%%----------------------------------------------------------------------------
diff --git a/lib/dialyzer/src/dialyzer_dep.erl b/lib/dialyzer/src/dialyzer_dep.erl
new file mode 100644
index 0000000000..670433f003
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_dep.erl
@@ -0,0 +1,580 @@
+%% -*- erlang-indent-level: 2 -*-
+%%-----------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2006-2009. 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%
+%%
+
+%%%-------------------------------------------------------------------
+%%% File : dialyzer_dep.erl
+%%% Author : Tobias Lindahl <[email protected]>
+%%%
+%%% Description: A pretty limited but efficient escape/dependency
+%%% analysis of Core Erlang.
+%%%
+%%% Created : 28 Oct 2005 by Tobias Lindahl <[email protected]>
+%%%-------------------------------------------------------------------
+-module(dialyzer_dep).
+
+-export([analyze/1]).
+-define(NO_UNUSED, true).
+-ifndef(NO_UNUSED).
+-export([test/1]).
+-endif.
+
+-include("dialyzer.hrl").
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%
+%% analyze(CoreTree) -> {Deps, Esc, Calls}.
+%%
+%% Deps = a dict mapping labels of functions to an ordset of functions
+%% it calls.
+%%
+%% Esc = an ordset of the labels of escaping functions. A function
+%% is considered to escape if the control escapes a function,
+%% i.e., this analysis is not module-local but rather
+%% function-local.
+%%
+%% Calls = a dict mapping apply:s to an ordset of function labels to
+%% which the operation can refer to. If 'external' is part of
+%% the set the operation can be externally defined.
+%%
+
+-spec analyze(cerl:c_module()) -> {dict(), ordset('external' | label()), dict()}.
+
+analyze(Tree) ->
+ %% io:format("Handling ~w\n", [cerl:atom_val(cerl:module_name(Tree))]),
+ {_, State} = traverse(Tree, map__new(), state__new(Tree), top),
+ Esc = state__esc(State),
+ %% Add dependency from 'external' to all escaping function
+ State1 = state__add_deps(external, output(Esc), State),
+ Deps = state__deps(State1),
+ Calls = state__calls(State1),
+ {map__finalize(Deps), set__to_ordsets(Esc), map__finalize(Calls)}.
+
+traverse(Tree, Out, State, CurrentFun) ->
+ %% io:format("Type: ~w\n", [cerl:type(Tree)]),
+ case cerl:type(Tree) of
+ apply ->
+ Op = cerl:apply_op(Tree),
+ Args = cerl:apply_args(Tree),
+ %% Op is always a variable and should not be marked as escaping
+ %% based on its use.
+ case var =:= cerl:type(Op) of
+ false -> erlang:error({apply_op_not_a_variable, cerl:type(Op)});
+ true -> ok
+ end,
+ OpFuns = case map__lookup(cerl_trees:get_label(Op), Out) of
+ none -> output(none);
+ {value, OF} -> OF
+ end,
+ {ArgFuns, State2} = traverse_list(Args, Out, State, CurrentFun),
+ State3 = state__add_esc(merge_outs(ArgFuns), State2),
+ State4 = state__add_deps(CurrentFun, OpFuns, State3),
+ State5 = state__store_callsite(cerl_trees:get_label(Tree),
+ OpFuns, length(Args), State4),
+ {output(set__singleton(external)), State5};
+ binary ->
+ {output(none), State};
+ 'case' ->
+ Arg = cerl:case_arg(Tree),
+ {Funs, NewState} = traverse(Arg, Out, State, CurrentFun),
+ Clauses = cerl:case_clauses(Tree),
+ traverse_clauses(Clauses, Funs, Out, NewState, CurrentFun);
+ call ->
+ Args = cerl:call_args(Tree),
+ {ArgFuns, State1} = traverse_list(Args, Out, State, CurrentFun),
+ remote_call(Tree, merge_outs(ArgFuns), State1);
+ 'catch' ->
+ traverse(cerl:catch_body(Tree), Out, State, CurrentFun);
+ cons ->
+ {HdFuns, State1} = traverse(cerl:cons_hd(Tree), Out, State, CurrentFun),
+ {TlFuns, State2} = traverse(cerl:cons_tl(Tree), Out, State1, CurrentFun),
+ {merge_outs([HdFuns, TlFuns]), State2};
+ 'fun' ->
+ %% io:format("Entering fun: ~w\n", [cerl_trees:get_label(Tree)]),
+ Body = cerl:fun_body(Tree),
+ Label = cerl_trees:get_label(Tree),
+ State1 =
+ if CurrentFun =:= top ->
+ state__add_deps(top, output(set__singleton(Label)), State);
+ true ->
+ O1 = output(set__singleton(CurrentFun)),
+ O2 = output(set__singleton(Label)),
+ TmpState = state__add_deps(Label, O1, State),
+ state__add_deps(CurrentFun, O2,TmpState)
+ end,
+ {BodyFuns, State2} = traverse(Body, Out, State1,
+ cerl_trees:get_label(Tree)),
+ {output(set__singleton(Label)), state__add_esc(BodyFuns, State2)};
+ 'let' ->
+ Vars = cerl:let_vars(Tree),
+ Arg = cerl:let_arg(Tree),
+ Body = cerl:let_body(Tree),
+ {ArgFuns, State1} = traverse(Arg, Out, State, CurrentFun),
+ Out1 = bind_list(Vars, ArgFuns, Out),
+ traverse(Body, Out1, State1, CurrentFun);
+ letrec ->
+ Defs = cerl:letrec_defs(Tree),
+ Body = cerl:letrec_body(Tree),
+ Out1 = bind_defs(Defs, Out),
+ State1 = traverse_defs(Defs, Out1, State, CurrentFun),
+ traverse(Body, Out1, State1, CurrentFun);
+ literal ->
+ {output(none), State};
+ module ->
+ Defs = cerl:module_defs(Tree),
+ Out1 = bind_defs(Defs, Out),
+ State1 = traverse_defs(Defs, Out1, State, CurrentFun),
+ {output(none), State1};
+ primop ->
+ Args = cerl:primop_args(Tree),
+ {ArgFuns, State1} = traverse_list(Args, Out, State, CurrentFun),
+ primop(Tree, merge_outs(ArgFuns), State1);
+ 'receive' ->
+ Clauses = cerl:receive_clauses(Tree),
+ TimeOut = cerl:receive_timeout(Tree),
+ Action = cerl:receive_action(Tree),
+ {ClauseFuns, State1} =
+ traverse_clauses(Clauses, output(none), Out, State, CurrentFun),
+ {_, State2} = traverse(TimeOut, Out, State1, CurrentFun),
+ {ActionFuns, State3} = traverse(Action, Out, State2, CurrentFun),
+ {merge_outs([ClauseFuns, ActionFuns]), State3};
+ seq ->
+ {_, State1} = traverse(cerl:seq_arg(Tree), Out, State, CurrentFun),
+ traverse(cerl:seq_body(Tree), Out, State1, CurrentFun);
+ 'try' ->
+ Arg = cerl:try_arg(Tree),
+ Body = cerl:try_body(Tree),
+ Vars = cerl:try_vars(Tree),
+ EVars = cerl:try_evars(Tree),
+ Handler = cerl:try_handler(Tree),
+ {ArgFuns, State1} = traverse(Arg, Out, State, CurrentFun),
+ Out1 = bind_list(Vars, ArgFuns, Out),
+ {BodyFuns, State2} = traverse(Body, Out1, State1, CurrentFun),
+ Out2 = bind_single(EVars, output(set__singleton(external)), Out),
+ {HandlerFuns, State3} = traverse(Handler, Out2, State2, CurrentFun),
+ {merge_outs([BodyFuns, HandlerFuns]), State3};
+ tuple ->
+ Args = cerl:tuple_es(Tree),
+ {List, State1} = traverse_list(Args, Out, State, CurrentFun),
+ {merge_outs(List), State1};
+ values ->
+ traverse_list(cerl:values_es(Tree), Out, State, CurrentFun);
+ var ->
+ case map__lookup(cerl_trees:get_label(Tree), Out) of
+ none -> {output(none), State};
+ {value, Val} ->
+ case is_only_external(Val) of
+ true ->
+ %% Do nothing
+ {Val, State};
+ false ->
+ %% If this is used in a function this means a dependency.
+ {Val, state__add_deps(CurrentFun, Val, State)}
+ end
+ end
+ end.
+
+traverse_list(Trees, Out, State, CurrentFun) ->
+ traverse_list(Trees, Out, State, CurrentFun, []).
+
+traverse_list([Tree|Left], Out, State, CurrentFun, Acc) ->
+ {X, State1} = traverse(Tree, Out, State, CurrentFun),
+ traverse_list(Left, Out, State1, CurrentFun, [X|Acc]);
+traverse_list([], _Out, State, _CurrentFun, Acc) ->
+ {output(lists:reverse(Acc)), State}.
+
+traverse_defs([{_, Fun}|Left], Out, State, CurrentFun) ->
+ {_, State1} = traverse(Fun, Out, State, CurrentFun),
+ traverse_defs(Left, Out, State1, CurrentFun);
+traverse_defs([], _Out, State, _CurrentFun) ->
+ State.
+
+traverse_clauses(Clauses, ArgFuns, Out, State, CurrentFun) ->
+ case filter_match_fail(Clauses) of
+ [] ->
+ %% Can happen for example with receives used as timouts.
+ {output(none), State};
+ Clauses1 ->
+ traverse_clauses(Clauses1, ArgFuns, Out, State, CurrentFun, [])
+ end.
+
+traverse_clauses([Clause|Left], ArgFuns, Out, State, CurrentFun, Acc) ->
+ Pats = cerl:clause_pats(Clause),
+ Guard = cerl:clause_guard(Clause),
+ Body = cerl:clause_body(Clause),
+ Out1 = bind_pats_list(Pats, ArgFuns, Out),
+ {_, State2} = traverse(Guard, Out1, State, CurrentFun),
+ {BodyFuns, State3} = traverse(Body, Out1, State2, CurrentFun),
+ traverse_clauses(Left, ArgFuns, Out, State3, CurrentFun, [BodyFuns|Acc]);
+traverse_clauses([], _ArgFuns, _Out, State, _CurrentFun, Acc) ->
+ {merge_outs(Acc), State}.
+
+filter_match_fail([Clause]) ->
+ Body = cerl:clause_body(Clause),
+ case cerl:type(Body) of
+ primop ->
+ case cerl:atom_val(cerl:primop_name(Body)) of
+ match_fail -> [];
+ raise -> [];
+ _ -> [Clause]
+ end;
+ _ -> [Clause]
+ end;
+filter_match_fail([H|T]) ->
+ [H|filter_match_fail(T)];
+filter_match_fail([]) ->
+ %% This can actually happen, for example in
+ %% receive after 1 -> ok end
+ [].
+
+remote_call(Tree, ArgFuns, State) ->
+ M = cerl:call_module(Tree),
+ F = cerl:call_name(Tree),
+ A = length(cerl:call_args(Tree)),
+ case cerl:is_c_atom(M) andalso cerl:is_c_atom(F) of
+ false ->
+ %% Unknown function.
+ {output(set__singleton(external)), state__add_esc(ArgFuns, State)};
+ true ->
+ M1 = cerl:atom_val(M),
+ F1 = cerl:atom_val(F),
+ Literal = cerl_closurean:is_literal_op(M1, F1, A),
+ case erl_bifs:is_pure(M1, F1, A) of
+ true ->
+ case Literal of
+ true ->
+ {output(none), State};
+ false ->
+ {output(set__singleton(external)), state__add_esc(ArgFuns, State)}
+ end;
+ false ->
+ State1 = case cerl_closurean:is_escape_op(M1, F1, A) of
+ true -> state__add_esc(ArgFuns, State);
+ false -> State
+ end,
+ case Literal of
+ true -> {output(none), State1};
+ false -> {add_external(ArgFuns), State1}
+ end
+ end
+ end.
+
+primop(Tree, ArgFuns, State) ->
+ F = cerl:atom_val(cerl:primop_name(Tree)),
+ A = length(cerl:primop_args(Tree)),
+ State1 = case cerl_closurean:is_escape_op(F, A) of
+ true -> state__add_esc(ArgFuns, State);
+ false -> State
+ end,
+ case cerl_closurean:is_literal_op(F, A) of
+ true -> {output(none), State1};
+ false -> {ArgFuns, State1}
+ end.
+
+%%------------------------------------------------------------
+%% Set
+%%
+
+-record(set, {set :: set()}).
+
+set__singleton(Val) ->
+ #set{set = sets:add_element(Val, sets:new())}.
+
+set__from_list(List) ->
+ #set{set = sets:from_list(List)}.
+
+set__is_element(_El, none) ->
+ false;
+set__is_element(El, #set{set = Set}) ->
+ sets:is_element(El, Set).
+
+set__union(none, Set) -> Set;
+set__union(Set, none) -> Set;
+set__union(#set{set = S1}, #set{set = S2}) -> #set{set = sets:union(S1, S2)}.
+
+set__to_ordsets(none) -> [];
+set__to_ordsets(#set{set = Set}) -> ordsets:from_list(sets:to_list(Set)).
+
+set__size(none) -> 0;
+set__size(#set{set = Set}) -> sets:size(Set).
+
+set__filter(#set{set = Set}, Fun) ->
+ NewSet = sets:filter(Fun, Set),
+ case sets:size(NewSet) =:= 0 of
+ true -> none;
+ false -> #set{set = NewSet}
+ end.
+
+%%------------------------------------------------------------
+%% Outputs
+%%
+
+-record(output, {type :: 'single' | 'list',
+ content :: 'none' | #set{} | [{output,_,_}]}).
+
+output(none) -> #output{type = single, content = none};
+output(S = #set{}) -> #output{type = single, content = S};
+output(List) when is_list(List) -> #output{type = list, content = List}.
+
+merge_outs([H|T]) ->
+ merge_outs(T, H);
+merge_outs(#output{type = list, content = [H|T]}) ->
+ merge_outs(T, H);
+merge_outs(#output{type = list, content = []}) ->
+ output(none).
+
+merge_outs([#output{content = none}|Left], O) ->
+ merge_outs(Left, O);
+merge_outs([O|Left], #output{content = none}) ->
+ merge_outs(Left, O);
+merge_outs([#output{type = single, content = S1}|Left],
+ #output{type = single, content = S2}) ->
+ merge_outs(Left, output(set__union(S1, S2)));
+merge_outs([#output{type = list, content = L1}|Left],
+ #output{type = list, content = L2}) ->
+ NewList = [merge_outs([X, Y]) || {X, Y} <- lists:zip(L1, L2)],
+ merge_outs(Left, output(NewList));
+merge_outs([], Res) ->
+ Res.
+
+filter_outs(#output{type = single, content = S}, Fun) ->
+ output(set__filter(S, Fun)).
+
+add_external(#output{type = single, content = Set}) ->
+ output(set__union(Set, set__singleton(external)));
+add_external(#output{type = list, content = List}) ->
+ output([add_external(O) || O <- List]).
+
+is_only_external(#output{type = single, content = Set}) ->
+ set__is_element(external, Set) andalso (set__size(Set) =:= 1).
+
+%%------------------------------------------------------------
+%% Map
+%%
+
+map__new() ->
+ dict:new().
+
+map__add(_Label, none, Map) ->
+ Map;
+map__add(Label, Set, Map) ->
+ case map__lookup(Label, Map) of
+ {value, OldSet} ->
+ NewSet = set__union(OldSet, Set),
+ map__store(Label, NewSet, Map);
+ none ->
+ map__store(Label, Set, Map)
+ end.
+
+map__store(Label, Val, Map) ->
+ dict:store(Label, Val, Map).
+
+map__lookup(Label, Map) ->
+ case dict:find(Label, Map) of
+ {ok, Val} -> {value, Val};
+ error -> none
+ end.
+
+map__finalize(Map) ->
+ dict:map(fun (_Key, #set{} = Set) -> set__to_ordsets(Set);
+ (_Key, #output{type = single, content = Set}) ->
+ set__to_ordsets(Set)
+ end, Map).
+
+%%------------------------------------------------------------
+%% Binding outs in the map
+%%
+
+bind_pats_list(_Pats, #output{content = none}, Map) ->
+ Map;
+bind_pats_list([Pat], #output{type = single} = O, Map) ->
+ bind_single(all_vars(Pat), O, Map);
+bind_pats_list(Pats, #output{type = list, content = List}, Map) ->
+ bind_pats_list(Pats, List, Map);
+bind_pats_list([Pat|PatLeft],
+ [#output{type = single} = O|SetLeft], Map)->
+ Map1 = bind_single(all_vars(Pat), O, Map),
+ bind_pats_list(PatLeft, SetLeft, Map1);
+bind_pats_list([Pat|PatLeft],
+ [#output{type = list, content = List}|SetLeft], Map) ->
+ Map1 = case cerl:is_c_values(Pat) of
+ true -> bind_pats_list(cerl:values_es(Pat), List, Map);
+ false -> bind_single(all_vars(Pat), merge_outs(List), Map)
+ end,
+ bind_pats_list(PatLeft, SetLeft, Map1);
+bind_pats_list([], [], Map) ->
+ Map.
+
+bind_single([Var|Left], O, Map) ->
+ bind_single(Left, O, map__store(cerl_trees:get_label(Var), O, Map));
+bind_single([], _O, Map) ->
+ Map.
+
+bind_list(List, #output{type = single} = O, Map) ->
+ bind_single(List, O, Map);
+bind_list(List1, #output{type = list, content = List2}, Map) ->
+ bind_list1(List1, List2, Map).
+
+bind_list1([Var|VarLeft], [O|OLeft], Map) ->
+ bind_list1(VarLeft, OLeft, map__store(cerl_trees:get_label(Var), O, Map));
+bind_list1([], [], Map) ->
+ Map.
+
+bind_defs([{Var, Fun}|Left], Map) ->
+ O = output(set__singleton(cerl_trees:get_label(Fun))),
+ Map1 = map__store(cerl_trees:get_label(Var), O, Map),
+ bind_defs(Left, Map1);
+bind_defs([], Map) ->
+ Map.
+
+all_vars(Tree) ->
+ all_vars(Tree, []).
+
+all_vars(Tree, AccIn) ->
+ cerl_trees:fold(fun(SubTree, Acc) ->
+ case cerl:is_c_var(SubTree) of
+ true -> [SubTree|Acc];
+ false -> Acc
+ end
+ end, AccIn, Tree).
+
+%%------------------------------------------------------------
+%% The state
+%%
+
+-type local_set() :: 'none' | #set{}.
+
+-record(state, {deps :: dict(),
+ esc :: local_set(),
+ call :: dict(),
+ arities :: dict()}).
+
+state__new(Tree) ->
+ Exports = set__from_list([X || X <- cerl:module_exports(Tree)]),
+ InitEsc = set__from_list([cerl_trees:get_label(Fun)
+ || {Var, Fun} <- cerl:module_defs(Tree),
+ set__is_element(Var, Exports)]),
+ Arities = cerl_trees:fold(fun find_arities/2, dict:new(), Tree),
+ #state{deps = map__new(), esc = InitEsc, call = map__new(), arities = Arities}.
+
+find_arities(Tree, AccMap) ->
+ case cerl:is_c_fun(Tree) of
+ true ->
+ Label = cerl_trees:get_label(Tree),
+ Arity = cerl:fun_arity(Tree),
+ dict:store(Label, Arity, AccMap);
+ false ->
+ AccMap
+ end.
+
+state__add_deps(_From, #output{content = none}, State) ->
+ State;
+state__add_deps(From, #output{type = single, content=To},
+ #state{deps = Map} = State) ->
+ %% io:format("Adding deps from ~w to ~w\n", [From, set__to_ordsets(To)]),
+ State#state{deps = map__add(From, To, Map)}.
+
+state__deps(#state{deps = Deps}) ->
+ Deps.
+
+state__add_esc(#output{content = none}, State) ->
+ State;
+state__add_esc(#output{type = single, content = Set},
+ #state{esc = Esc} = State) ->
+ State#state{esc = set__union(Set, Esc)}.
+
+state__esc(#state{esc = Esc}) ->
+ Esc.
+
+state__store_callsite(_From, #output{content = none}, _CallArity, State) ->
+ State;
+state__store_callsite(From, To, CallArity,
+ #state{call = Calls, arities = Arities} = State) ->
+ Filter = fun(external) -> true;
+ (Fun) -> CallArity =:= dict:fetch(Fun, Arities)
+ end,
+ case filter_outs(To, Filter) of
+ #output{content = none} -> State;
+ To1 -> State#state{call = map__store(From, To1, Calls)}
+ end.
+
+state__calls(#state{call = Calls}) ->
+ Calls.
+
+%%------------------------------------------------------------
+%% A test function. Not part of the intended interface.
+%%
+
+-ifndef(NO_UNUSED).
+
+test(Mod) ->
+ {ok, _, Code} = compile:file(Mod, [to_core, binary]),
+ Tree = cerl:from_records(Code),
+ {LabeledTree, _} = cerl_trees:label(Tree),
+ {Deps, Esc, Calls} = analyze(LabeledTree),
+ Edges0 = dict:fold(fun(Caller, Set, Acc) ->
+ [[{Caller, Callee} || Callee <- Set]|Acc]
+ end, [], Deps),
+ Edges1 = lists:flatten(Edges0),
+ Edges = [Edge || {X,_Y} = Edge <- Edges1, X =/= top],
+ Fun = fun(SubTree, Acc) ->
+ case cerl:type(SubTree) of
+ 'fun' ->
+ case lists:keyfind(id, 1, cerl:get_ann(SubTree)) of
+ false -> Acc;
+ {id, ID} ->
+ dict:store(cerl_trees:get_label(SubTree), ID, Acc)
+ end;
+ module ->
+ Defs = cerl:module_defs(SubTree),
+ lists:foldl(fun({Var, Fun}, Acc1) ->
+ dict:store(cerl_trees:get_label(Fun),
+ {cerl:fname_id(Var),
+ cerl:fname_arity(Var)},
+ Acc1)
+ end, Acc, Defs);
+ letrec ->
+ Defs = cerl:letrec_defs(SubTree),
+ lists:foldl(fun({Var, Fun}, Acc1) ->
+ dict:store(cerl_trees:get_label(Fun),
+ {cerl:fname_id(Var),
+ cerl:fname_arity(Var)},
+ Acc1)
+ end, Acc, Defs);
+ _ -> Acc
+ end
+ end,
+ NameMap1 = cerl_trees:fold(Fun, dict:new(), LabeledTree),
+ NameMap = dict:store(external, external, NameMap1),
+ NamedEdges = [{dict:fetch(X, NameMap), dict:fetch(Y, NameMap)}
+ || {X, Y} <- Edges],
+ NamedEsc = [dict:fetch(X, NameMap) || X <- Esc],
+ %% Color the edges
+ ColorEsc = [{X, {color, red}} || X <- NamedEsc],
+ CallEdges0 = dict:fold(fun(Caller, Set, Acc) ->
+ [[{Caller, Callee} || Callee <- Set]|Acc]
+ end, [], Calls),
+ CallEdges = lists:flatten(CallEdges0),
+ NamedCallEdges = [{X, dict:fetch(Y, NameMap)} || {X, Y} <- CallEdges],
+ AllNamedEdges = NamedEdges ++ NamedCallEdges,
+ hipe_dot:translate_list(AllNamedEdges, "/tmp/cg.dot", "CG", ColorEsc),
+ os:cmd("dot -T ps -o /tmp/cg.ps /tmp/cg.dot"),
+ ok.
+
+-endif.
diff --git a/lib/dialyzer/src/dialyzer_explanation.erl b/lib/dialyzer/src/dialyzer_explanation.erl
new file mode 100644
index 0000000000..afc2c1965f
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_explanation.erl
@@ -0,0 +1,52 @@
+%% -*- erlang-indent-level: 2 -*-
+%%-----------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2009. 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%
+%%
+
+%%%-------------------------------------------------------------------
+%%% File : dialyzer_explanation.erl
+%%% Author : Elli Fragkaki <[email protected]>
+%%% Description :
+%%%-------------------------------------------------------------------
+
+-module(dialyzer_explanation).
+
+-export([expl_loop/3]).
+
+-include("dialyzer.hrl").
+
+-spec expl_loop(pid(), dialyzer_codeserver:codeserver(), dialyzer_plt:plt()) ->
+ no_return().
+
+expl_loop(Parent, CServer, Plt) ->
+ receive
+ {Parent, warning, _Warning} ->
+ send_explanation(Parent, none),
+ expl_loop(Parent, CServer, Plt);
+ {Parent, further, _Explanation} ->
+ Parent ! {self(), further, none},
+ expl_loop(Parent, CServer, Plt);
+ Other ->
+ io:format("Unknown message: ~p\n", [Other]),
+ expl_loop(Parent, CServer, Plt)
+ end.
+
+send_explanation(Parent, Expl) ->
+ Parent ! {self(), explanation, Expl},
+ ok.
+
diff --git a/lib/dialyzer/src/dialyzer_gui.erl b/lib/dialyzer/src/dialyzer_gui.erl
new file mode 100644
index 0000000000..f353638cdf
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_gui.erl
@@ -0,0 +1,1349 @@
+%% -*- erlang-indent-level: 2 -*-
+%%------------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2006-2009. 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%
+%%
+
+%%%-----------------------------------------------------------------------
+%%% File : dialyzer_gui.erl
+%%% Authors : Tobias Lindahl <[email protected]>
+%%% Kostis Sagonas <[email protected]>
+%%% Description : The graphical user interface for the Dialyzer tool.
+%%%
+%%% Created : 27 Apr 2004 by Tobias Lindahl <[email protected]>
+%%%-----------------------------------------------------------------------
+
+-module(dialyzer_gui).
+
+-export([start/1]).
+
+-include("dialyzer.hrl").
+
+%%------------------------------------------------------------------------
+
+-define(DIALYZER_ERROR_TITLE, "Dialyzer Error").
+-define(DIALYZER_MESSAGE_TITLE, "Dialyzer Message").
+
+%%------------------------------------------------------------------------
+
+-type gs_object() :: any(). %% XXX: should be imported from gs
+
+-record(mode, {start_byte_code :: gs_object(),
+ start_src_code :: gs_object()}).
+
+-record(menu, {file_save_log :: gs_object(),
+ file_save_warn :: gs_object(),
+ file_quit :: gs_object(),
+ help_about :: gs_object(),
+ help_manual :: gs_object(),
+ help_warnings :: gs_object(),
+ opts_macros :: gs_object(),
+ opts_includes :: gs_object(),
+ plt_empty :: gs_object(),
+ plt_search_doc :: gs_object(),
+ plt_show_doc :: gs_object(),
+ warnings :: gs_object()}).
+
+-record(gui_state, {add_all :: gs_object(),
+ add_file :: gs_object(),
+ add_rec :: gs_object(),
+ chosen_box :: gs_object(),
+ analysis_pid :: pid(),
+ del_file :: gs_object(),
+ doc_plt :: dialyzer_plt:plt(),
+ clear_chosen :: gs_object(),
+ clear_log :: gs_object(),
+ clear_warn :: gs_object(),
+ init_plt :: dialyzer_plt:plt(),
+ dir_entry :: gs_object(),
+ file_box :: gs_object(),
+ file_wd :: gs_object(),
+ gs :: gs_object(),
+ log :: gs_object(),
+ menu :: #menu{},
+ mode :: #mode{},
+ options :: #options{},
+ packer :: gs_object(),
+ run :: gs_object(),
+ stop :: gs_object(),
+ top :: gs_object(),
+ warnings_box :: gs_object(),
+ backend_pid :: pid()}).
+
+%%------------------------------------------------------------------------
+
+-spec start(#options{}) -> ?RET_NOTHING_SUSPICIOUS.
+
+start(DialyzerOptions = #options{from = From, init_plt = InitPltFile,
+ legal_warnings = LegalWarnings}) ->
+ process_flag(trap_exit, true),
+
+ GS = gs:start(),
+ code:add_pathsa(["."]),
+ WH = [{width, 1000}, {height, 550}],
+ EmptySpace = {stretch, 1},
+
+ {ok, Host} = inet:gethostname(),
+ %% --------- Top Window --------------
+ TopWin = gs:window(GS, [{title, "Dialyzer " ++ ?VSN ++ " @ " ++ Host},
+ {configure, true},
+ {default, listbox, {bg, white}},
+ {default, editor, {bg, white}},
+ {default, entry, {bg, white}},
+ {default, button, {font, {helvetica, bold, 12}}},
+ {default, label, {font, {helvetica, bold, 12}}}
+ |WH]),
+ Packer = gs:frame(TopWin, [{packer_x, [{stretch, 3},{fixed, 200},
+ {stretch, 7}]},
+ {packer_y, [{fixed, 25}, {fixed, 20},
+ {stretch, 1, 50},
+ {fixed, 25}, {fixed, 20},
+ {stretch, 1, 50},
+ {fixed, 25}]}]),
+
+ %% --------- Chosen box --------------
+ gs:label(Packer, [{label, {text, "Directories or modules to analyze"}},
+ {height, 20}, {pack_xy, {1, 2}}]),
+ ChosenBox = gs:listbox(Packer, [{pack_xy, {1, 3}}, {vscroll, right},
+ {selectmode, multiple}]),
+
+ %% --------- File box --------------
+ gs:label(Packer, [{label, {text, "File"}}, {height, 20}, {pack_xy, {1,5}}]),
+ FilePacker = gs:frame(Packer, [{packer_x, [{fixed, 30}, {stretch, 1, 100}]},
+ {packer_y, [{fixed, 25}, {stretch, 1, 25}]},
+ {pack_xy, {1, 6}}]),
+ gs:label(FilePacker, [{label, {text, "Dir:"}}, {pack_xy, {1, 1}}]),
+ DirEntry = gs:entry(FilePacker, [{height, 30}, {pack_xy, {2, 1}},
+ {keypress, true}]),
+ File = gs:listbox(FilePacker, [{pack_x, {1,2}}, {pack_y, 2},
+ {selectmode, multiple}, {doubleclick, true},
+ {vscroll, right}]),
+
+ %% --------- Options --------------
+ gs:label(Packer, [{label, {text, "Analysis Options"}},
+ {height, 20}, {pack_xy, {2, 2}}]),
+ ModePacker = gs:frame(Packer, [{packer_x, [{fixed, 75}, {fixed, 120}]},
+ {packer_y, [{fixed, 20}, {fixed, 20},
+ {fixed, 20},
+ %% EmptySpace,
+ {fixed, 20}, {fixed, 20},
+ {fixed, 20}, EmptySpace]},
+ {bw, 10}, {relief, flat},
+ {default, {radiobutton, {align, w}}},
+ {default, {label, {align, w}}},
+ {pack_xy, {2, 3}}]),
+
+ %% Bytecode vs. Source code
+ gs:label(ModePacker, [{label, {text, "File Type:"}},
+ {height, 20}, {pack_xy, {1,1}}]),
+ {ByteSel, SrcSel} = case From of
+ byte_code -> {[{select, true}], []};
+ src_code -> {[], [{select, true}]}
+ end,
+ ModeByteCode = gs:radiobutton(ModePacker,
+ ByteSel ++ [{group, start_from},
+ {label, {text,"BeamFiles"}},
+ {pack_xy, {2,1}}]),
+ ModeSrcCode = gs:radiobutton(ModePacker,
+ SrcSel ++ [{group, start_from},
+ {label, {text,"SourceFiles"}},
+ {pack_xy, {2,2}}]),
+ Mode = #mode{start_byte_code = ModeByteCode,
+ start_src_code = ModeSrcCode},
+
+ %% --------- Log box --------------
+ gs:label(Packer, [{label, {text, "Log"}}, {height, 20}, {pack_xy, {3,2}}]),
+ Log = gs:editor(Packer, [{pack_x, 3}, {pack_y, 3}, {enable, false},
+ {font, {courier, 12}}, {vscroll, right},
+ {wrap, word}]),
+
+ %% --------- Warnings box --------------
+ gs:label(Packer, [{label, {text, "Warnings"}},{height, 20},{pack_xy, {3,5}}]),
+ WarningsBox = gs:editor(Packer, [{pack_x, {2,3}}, {pack_y, 6},
+ {enable, false},
+ {font, {courier, 12}}, {vscroll, right},
+ {wrap, word}]),
+
+ %% --------- Buttons --------------
+ ButtonPackerHighLeft =
+ gs:frame(Packer, [{packer_x, [{fixed, 50}, {fixed, 65}, EmptySpace]},
+ {pack_xy, {1,4}}]),
+ ButtonPackerHighRight =
+ gs:frame(Packer, [{packer_x, [{fixed, 70}, {fixed, 70}, EmptySpace]},
+ {pack_xy, {3,4}}]),
+ ButtonPackerLowLeft =
+ gs:frame(Packer, [{packer_x, [{fixed, 50},
+ {fixed, 60},
+ {fixed, 110},
+ EmptySpace]},
+ {pack_xy, {1,7}}]),
+ ButtonPackerLowRight =
+ gs:frame(Packer, [{packer_x, [{fixed, 100},
+ {fixed, 70},
+ EmptySpace,
+ {fixed, 70},
+ {fixed, 70}]},
+ {pack_x, {2,3}}, {pack_y, 7}]),
+
+ WHButton = [{width, 60}, {height, 20}],
+ AddFile = gs:button(ButtonPackerLowLeft, [{pack_xy, {1, 1}},
+ {label, {text,"Add"}}|WHButton]),
+ AddAll = gs:button(ButtonPackerLowLeft, [{pack_xy, {2, 1}},
+ {label, {text,"Add All"}}|WHButton]),
+ AddRec = gs:button(ButtonPackerLowLeft, [{pack_xy, {3, 1}},
+ {label, {text,"Add Recursively"}}
+ |WHButton]),
+ DelFile = gs:button(ButtonPackerHighLeft, [{pack_xy, {1, 1}},
+ {label, {text,"Delete"}}|WHButton]),
+ ClearChosen = gs:button(ButtonPackerHighLeft, [{pack_xy, {2, 1}},
+ {label, {text,"Delete All"}}
+ |WHButton]),
+ ClearLog = gs:button(ButtonPackerHighRight, [{pack_xy, {1, 1}},
+ {label, {text,"Clear Log"}}
+ |WHButton]),
+ ClearWarn = gs:button(ButtonPackerLowRight, [{pack_xy, {1, 1}},
+ {label, {text,"Clear Warnings"}}
+ |WHButton]),
+
+ Run = gs:button(ButtonPackerLowRight, [{pack_xy, {4, 1}},
+ {label, {text,"Run"}}|WHButton]),
+ Stop = gs:button(ButtonPackerLowRight, [{pack_xy, {5, 1}}, {enable, false},
+ {label, {text,"Stop"}}|WHButton]),
+
+ %% --------- Menu --------------
+ MenuBar = gs:menubar(TopWin, []),
+
+ %% File Menu
+ MenuBarFile = gs:menubutton(MenuBar, [{label, {text, "File"}}]),
+ MenuFile = gs:menu(MenuBarFile, []),
+ MenuFileSaveWarn = gs:menuitem(MenuFile, [{label, {text, "Save Warnings"}}]),
+ MenuFileSaveLog = gs:menuitem(MenuFile, [{label, {text, "Save Log"}}]),
+ MenuFileQuit = gs:menuitem(MenuFile, [{label, {text, "Quit"}}]),
+
+ %% Warnings Menu
+ MenuBarWarn = gs:menubutton(MenuBar, [{label, {text, "Warnings"}}]),
+ MenuWarn = gs:menu(MenuBarWarn, []),
+ MenuWarnMatch = gs:menuitem(MenuWarn, [{label, {text, "Match failures"}},
+ {itemtype, check}, {select, true}]),
+ MenuWarnFailingCall = gs:menuitem(MenuWarn,
+ [{label, {text, "Failing function calls"}},
+ {itemtype, check}, {select, true}]),
+ MenuWarnFunApp = gs:menuitem(MenuWarn, [{label,
+ {text, "Bad fun applications"}},
+ {itemtype, check}, {select, true}]),
+ MenuWarnOpaque = gs:menuitem(MenuWarn, [{label,
+ {text, "Opaqueness violations"}},
+ {itemtype, check}, {select, true}]),
+ MenuWarnLists = gs:menuitem(MenuWarn,
+ [{label, {text, "Improper list constructions"}},
+ {itemtype, check}, {select, true}]),
+ MenuWarnNotCalled = gs:menuitem(MenuWarn,
+ [{label, {text, "Unused functions"}},
+ {itemtype, check}, {select, true}]),
+ MenuWarnReturnOnlyExit = gs:menuitem(MenuWarn,
+ [{label,
+ {text, "Error handling functions"}},
+ {itemtype, check}, {select, false}]),
+ MenuWarnReturnNoReturn = gs:menuitem(MenuWarn,
+ [{label,
+ {text, "Functions of no return"}},
+ {itemtype, check}, {select, true}]),
+ MenuWarnCallNonExported = gs:menuitem(MenuWarn,
+ [{label,
+ {text, "Call to unexported function"}},
+ {itemtype, check}, {select, true}]),
+ MenuWarnRaceCondition = gs:menuitem(MenuWarn,
+ [{label,
+ {text,"Possible race conditions"}},
+ {itemtype, check}, {select, false}]),
+ MenuWarnContractTypes = gs:menuitem(MenuWarn,
+ [{label, {text, "Wrong contracts"}},
+ {itemtype, check}, {select, true}]),
+ MenuWarnContractSyntax = gs:menuitem(MenuWarn,
+ [{label,
+ {text, "Wrong contract syntax"}},
+ {itemtype, check}, {select, true}]),
+
+ %% PLT Menu
+ MenuBarPLT = gs:menubutton(MenuBar, [{label, {text,"PLT"}}]),
+ MenuPLT = gs:menu(MenuBarPLT, []),
+ MenuPLTEmpty = gs:menuitem(MenuPLT, [{label, {text, "Init with empty PLT"}},
+ {itemtype, check}, {select, false}]),
+ MenuPLTShow = gs:menuitem(MenuPLT, [{label, {text, "Show contents"}}]),
+ MenuPLTSearch = gs:menuitem(MenuPLT, [{label, {text, "Search contents"}}]),
+
+ %% Options Menu
+ MenuBarOpts = gs:menubutton(MenuBar, [{label,{text,"Options"}}]),
+ MenuOpts = gs:menu(MenuBarOpts, []),
+ MenuOptsMacros = gs:menuitem(MenuOpts,
+ [{label, {text, "Manage Macro Definitions"}}]),
+ MenuOptsIncludes = gs:menuitem(MenuOpts,
+ [{label, {text, "Manage Include Directories"}}]),
+
+ %% Help
+ MenuBarHelp = gs:menubutton(MenuBar, [{label, {text, "Help"}}, {side, right}]),
+ MenuHelp = gs:menu(MenuBarHelp, []),
+ MenuHelpManual = gs:menuitem(MenuHelp, [{label, {text, "Manual"}}]),
+ MenuHelpWarnings = gs:menuitem(MenuHelp, [{label, {text, "Warning Options"}}]),
+ MenuHelpAbout = gs:menuitem(MenuHelp, [{label, {text, "About"}}]),
+
+ Warnings = [{?WARN_RETURN_NO_RETURN, MenuWarnReturnNoReturn},
+ {?WARN_RETURN_ONLY_EXIT, MenuWarnReturnOnlyExit},
+ {?WARN_NOT_CALLED, MenuWarnNotCalled},
+ {?WARN_NON_PROPER_LIST, MenuWarnLists},
+ {?WARN_FUN_APP, MenuWarnFunApp},
+ {?WARN_MATCHING, MenuWarnMatch},
+ {?WARN_OPAQUE, MenuWarnOpaque},
+ {?WARN_FAILING_CALL, MenuWarnFailingCall},
+ {?WARN_CALLGRAPH, MenuWarnCallNonExported},
+ {?WARN_RACE_CONDITION, MenuWarnRaceCondition},
+ %% For contracts.
+ {?WARN_CONTRACT_TYPES, MenuWarnContractTypes},
+ {?WARN_CONTRACT_SYNTAX, MenuWarnContractSyntax}
+ ],
+
+ init_warnings(Warnings, LegalWarnings),
+
+ Menu = #menu{file_quit = MenuFileQuit,
+ plt_empty = MenuPLTEmpty,
+ help_manual = MenuHelpManual,
+ help_about = MenuHelpAbout,
+ help_warnings = MenuHelpWarnings,
+ opts_macros = MenuOptsMacros,
+ opts_includes = MenuOptsIncludes,
+ plt_search_doc = MenuPLTSearch,
+ plt_show_doc = MenuPLTShow,
+ file_save_log = MenuFileSaveLog,
+ file_save_warn = MenuFileSaveWarn,
+ warnings = Warnings},
+
+ %% --------- Init --------------
+ gs:config(TopWin, [{map, true}]),
+ gs:config(Packer, WH),
+ {ok, CWD} = file:get_cwd(),
+
+ InitPlt = try dialyzer_plt:from_file(InitPltFile)
+ catch throw:{dialyzer_error, _} -> dialyzer_plt:new()
+ end,
+
+ State = #gui_state{add_all = AddAll,
+ add_file = AddFile,
+ add_rec = AddRec,
+ chosen_box = ChosenBox,
+ clear_chosen = ClearChosen,
+ clear_log = ClearLog,
+ clear_warn = ClearWarn,
+ del_file = DelFile,
+ doc_plt = dialyzer_plt:new(),
+ dir_entry = DirEntry,
+ file_box = File,
+ file_wd = CWD,
+ gs = GS,
+ init_plt = InitPlt,
+ log = Log,
+ menu = Menu,
+ mode = Mode,
+ options = DialyzerOptions,
+ packer = Packer,
+ run = Run,
+ stop = Stop,
+ top = TopWin,
+ warnings_box = WarningsBox},
+ NewState = change_dir_or_add_file(State, "."),
+ gui_loop(NewState).
+
+%% ----------------------------------------------------------------
+%%
+%% Main GUI Loop
+%%
+
+-spec gui_loop(#gui_state{}) -> ?RET_NOTHING_SUSPICIOUS.
+
+gui_loop(#gui_state{add_all = AddAll, add_file = AddFile, add_rec = AddRec,
+ backend_pid = BackendPid, chosen_box = ChosenBox,
+ clear_chosen = ClearChosen, clear_log = ClearLog,
+ clear_warn = ClearWarn, del_file = DelFile,
+ dir_entry = DirEntry, file_box = File, log = Log,
+ menu = Menu, packer = Packer, run = Run, stop = Stop,
+ top = TopWin, warnings_box = Warn} = State) ->
+ %% --- Menu ---
+ Quit = Menu#menu.file_quit,
+ Manual = Menu#menu.help_manual,
+ Warnings = Menu#menu.help_warnings,
+ About = Menu#menu.help_about,
+ SaveLog = Menu#menu.file_save_log,
+ SaveWarn = Menu#menu.file_save_warn,
+ SearchPlt = Menu#menu.plt_search_doc,
+ ShowPlt = Menu#menu.plt_show_doc,
+ Macros = Menu#menu.opts_macros,
+ Includes = Menu#menu.opts_includes,
+
+ receive
+ {gs, TopWin, configure, _Data, [W, H|_]} ->
+ gs:config(Packer, [{width, W}, {height, H}]),
+ gui_loop(State);
+ {gs, TopWin, destroy, _Data, _Args} ->
+ ?RET_NOTHING_SUSPICIOUS;
+ {gs, File, doubleclick, _, [_Id, Text|_]} ->
+ NewState = change_dir_or_add_file(State, Text),
+ gui_loop(NewState);
+ {gs, DirEntry, keypress, _, ['Return'|_]} ->
+ gs:config(TopWin, [{setfocus, true}]),
+ NewState = change_dir_absolute(State, gs:read(DirEntry, text)),
+ gui_loop(NewState);
+ {gs, DirEntry, keypress, _, _} ->
+ gui_loop(State);
+ %% ----- Buttons -----
+ {gs, AddFile, click, _, _} ->
+ handle_add_files(State),
+ gui_loop(State);
+ {gs, AddAll, click, _, _} ->
+ handle_add_all_click(State),
+ gui_loop(State);
+ {gs, AddRec, click, _, _} ->
+ handle_add_rec_click(State),
+ gui_loop(State);
+ {gs, DelFile, click, _, _} ->
+ handle_file_delete(State),
+ gui_loop(State);
+ {gs, ClearChosen, click, _, _} ->
+ gs:config(ChosenBox, [clear]),
+ gui_loop(State);
+ {gs, ClearLog, click, _, _} ->
+ Log = State#gui_state.log,
+ gs:config(Log, [{enable, true}]),
+ gs:config(Log, [clear]),
+ gs:config(Log, [{enable, false}]),
+ gui_loop(State);
+ {gs, ClearWarn, click, _, _} ->
+ Warn = State#gui_state.warnings_box,
+ gs:config(Warn, [{enable, true}]),
+ gs:config(Warn, [clear]),
+ gs:config(Warn, [{enable, false}]),
+ gui_loop(State);
+ {gs, Run, click, _, _} ->
+ NewState = start_analysis(State),
+ gui_loop(NewState);
+ {gs, Stop, click, _, _} ->
+ config_gui_stop(State),
+ BackendPid ! {self(), stop},
+ update_editor(Log, "\n***** Analysis stopped ****\n"),
+ gui_loop(State);
+ %% ----- Menu -----
+ {gs, Quit, click, _, _} ->
+ case maybe_quit(State) of
+ true -> ?RET_NOTHING_SUSPICIOUS;
+ false -> gui_loop(State)
+ end;
+ {gs, Manual, click, _, _} ->
+ spawn_link(fun() -> manual(State) end),
+ gui_loop(State);
+ {gs, Warnings, click, _, _} ->
+ spawn_link(fun() -> warnings(State) end),
+ gui_loop(State);
+ {gs, About, click, _, _} ->
+ spawn_link(fun() -> about(State) end),
+ gui_loop(State);
+ {gs, SaveLog, click, _, _} ->
+ save_log(State),
+ gui_loop(State);
+ {gs, SaveWarn, click, _, _} ->
+ save_warn(State),
+ gui_loop(State);
+ {gs, SearchPlt, click, _, _} ->
+ spawn_link(fun() -> search_doc_plt(State) end),
+ gui_loop(State);
+ {gs, ShowPlt, click, _, _} ->
+ spawn_link(fun() -> show_doc_plt(State) end),
+ gui_loop(State);
+ {gs, Macros, click, _, _} ->
+ Self = self(),
+ spawn_link(fun() -> macro_dialog(State, Self) end),
+ gui_loop(State);
+ {gs, Includes, click, _, _} ->
+ Self = self(),
+ spawn_link(fun() -> include_dialog(State, Self) end),
+ gui_loop(State);
+ {new_options, NewOptions} ->
+ NewState = State#gui_state{options = NewOptions},
+ gui_loop(NewState);
+ %% ----- Analysis -----
+ {BackendPid, ext_calls, ExtCalls} ->
+ Msg = io_lib:format("The following functions are called "
+ "but type information about them is not available.\n"
+ "The analysis might get more precise by including "
+ "the modules containing these functions:\n\n\t~p\n",
+ [ExtCalls]),
+ free_editor(State, "Analysis done", Msg),
+ gui_loop(State);
+ {BackendPid, log, LogMsg} ->
+ update_editor(Log, LogMsg),
+ gui_loop(State);
+ {BackendPid, warnings, Warns} ->
+ SortedWarns = lists:keysort(2, Warns), %% Sort on file/line
+ WarnList = [dialyzer:format_warning(W) || W <- SortedWarns],
+ update_editor(Warn, lists:flatten(WarnList)),
+ gui_loop(State);
+ {BackendPid, done, _NewPlt, NewDocPlt} ->
+ message(State, "Analysis done"),
+ config_gui_stop(State),
+ gui_loop(State#gui_state{doc_plt = NewDocPlt});
+ {'EXIT', BackendPid, {error, Reason}} ->
+ free_editor(State, ?DIALYZER_ERROR_TITLE, Reason),
+ config_gui_stop(State),
+ gui_loop(State);
+ {'EXIT', BackendPid, Reason} when Reason =/= 'normal' ->
+ free_editor(State, ?DIALYZER_ERROR_TITLE, io_lib:format("~p", [Reason])),
+ config_gui_stop(State),
+ gui_loop(State);
+ _Other ->
+ %% io:format("Received ~p\n", [Other]),
+ gui_loop(State)
+ end.
+
+%% ----------------------------------------------------------------
+%%
+%% Main window actions
+%%
+
+%% ---- Adding and deleting files ----
+
+handle_add_all_click(#gui_state{chosen_box = ChosenBox, file_box = File,
+ file_wd = FWD, mode = Mode}) ->
+ case gs:read(File, items) of
+ [] ->
+ ok;
+ Add0 ->
+ gs:config(File, [{selection, clear}]),
+ Add1 = ordsets:subtract(Add0, [".."]),
+ Add = ordsets:from_list([filename:join(FWD, X) || X <- Add1]),
+ case gs:read(Mode#mode.start_byte_code, select) of
+ true ->
+ add_files(filter_mods(Add, ".beam"), ChosenBox, byte_code);
+ false ->
+ add_files(filter_mods(Add, ".erl"), ChosenBox, src_code)
+ end
+ end.
+
+all_subdirs(Dirs) ->
+ all_subdirs(Dirs, []).
+
+all_subdirs([Dir|T], Acc) ->
+ {ok, Files} = file:list_dir(Dir),
+ SubDirs = lists:zf(fun(F) ->
+ SubDir = filename:join(Dir, F),
+ case filelib:is_dir(SubDir) of
+ true -> {true, SubDir};
+ false -> false
+ end
+ end, Files),
+ NewAcc = ordsets:union(ordsets:from_list(SubDirs), Acc),
+ all_subdirs(T ++ SubDirs, NewAcc);
+all_subdirs([], Acc) ->
+ Acc.
+
+handle_add_rec_click(#gui_state{chosen_box = ChosenBox, file_box = File,
+ file_wd = FWD, mode = Mode}) ->
+ case gs:read(File, selection) of
+ [] ->
+ ok;
+ List ->
+ gs:config(File, [{selection, clear}]),
+ Dirs1 = [gs:read(File, {get, X}) || X <- List],
+ Dirs2 = ordsets:from_list([filename:join(FWD, X) || X <- Dirs1]),
+ Dirs3 = ordsets:filter(fun(X) -> filelib:is_dir(X) end, Dirs2),
+ TargetDirs = ordsets:union(Dirs3, all_subdirs(Dirs3)),
+ {Code, Ext} = case gs:read(Mode#mode.start_byte_code, select) of
+ true -> {byte_code, ".beam"};
+ false -> {src_code, ".erl"}
+ end,
+ add_files(filter_mods(TargetDirs, Ext), ChosenBox, Code)
+ end.
+
+handle_add_files(#gui_state{chosen_box = ChosenBox, file_box = File,
+ file_wd = FWD, mode = Mode}) ->
+ case gs:read(File, selection) of
+ [] ->
+ ok;
+ List ->
+ gs:config(File, [{selection, clear}]),
+ Add0 = [gs:read(File, {get, X}) || X <- List],
+ Add = ordsets:from_list([filename:join(FWD, X) || X <- Add0]),
+ case gs:read(Mode#mode.start_byte_code, select) of
+ true ->
+ add_files(filter_mods(Add, ".beam"), ChosenBox, byte_code);
+ false ->
+ add_files(filter_mods(Add, ".erl"), ChosenBox, src_code)
+ end
+ end.
+
+filter_mods(Mods, Extension) ->
+ Fun = fun(X) ->
+ filename:extension(X) =:= Extension
+ orelse
+ (filelib:is_dir(X) andalso
+ contains_files(X, Extension))
+ end,
+ ordsets:filter(Fun, Mods).
+
+contains_files(Dir, Extension) ->
+ {ok, Files} = file:list_dir(Dir),
+ lists:any(fun(X) -> filename:extension(X) =:= Extension end, Files).
+
+add_files(Add, ChosenBox, Type) ->
+ Set = gs:read(ChosenBox, items),
+ Set1 =
+ case Type of
+ byte_code -> filter_mods(Set, ".beam");
+ src_code -> filter_mods(Set, ".erl")
+ end,
+ Files = ordsets:union(Add, Set1),
+ gs:config(ChosenBox, [{items, Files}]),
+ ok.
+
+handle_file_delete(#gui_state{chosen_box = ChosenBox}) ->
+ List = gs:read(ChosenBox, selection),
+ lists:foreach(fun(X) -> gs:config(ChosenBox, [{del, X}]) end,
+ lists:reverse(lists:sort(List))).
+
+%% ---- Other ----
+
+change_dir_or_add_file(#gui_state{file_wd = FWD, mode = Mode, dir_entry = Dir,
+ chosen_box = CBox, file_box = File} = State,
+ Text) ->
+ NewWDorFile =
+ case Text of
+ ".." -> filename:join(butlast(filename:split(FWD)));
+ "." -> FWD;
+ _ -> filename:join(FWD, Text)
+ end,
+ case filelib:is_dir(NewWDorFile) of
+ true ->
+ gs:config(Dir, [{text, NewWDorFile}]),
+ {ok, List} = file:list_dir(NewWDorFile),
+ gs:config(File, [{items, [".."|lists:sort(List)]}]),
+ State#gui_state{file_wd = NewWDorFile};
+ false ->
+ case gs:read(Mode#mode.start_byte_code, select) of
+ true ->
+ case filter_mods([NewWDorFile], ".beam") of
+ [] -> ok;
+ RealFiles -> add_files(RealFiles, CBox, byte_code)
+ end;
+ false ->
+ case filter_mods([NewWDorFile], ".erl") of
+ [] -> ok;
+ RealFiles -> add_files(RealFiles, CBox, src_code)
+ end
+ end,
+ State
+ end.
+
+butlast([H1, H2 | T]) ->
+ [H1 | butlast([H2|T])];
+butlast([_]) ->
+ [];
+butlast([]) ->
+ ["/"].
+
+change_dir_absolute(#gui_state{file_wd = FWD, dir_entry = Dir,
+ file_box = File} = State,
+ Text) ->
+ case filelib:is_dir(Text) of
+ true ->
+ WD = filename:join(FWD, Text),
+ gs:config(Dir, [{text, WD}]),
+ {ok, List} = file:list_dir(WD),
+ gs:config(File, [{items, [".."|lists:sort(List)]}]),
+ State#gui_state{file_wd = WD};
+ false ->
+ State
+ end.
+
+init_warnings([{Tag, GSItem}|Left], LegalWarnings) ->
+ Select = ordsets:is_element(Tag, LegalWarnings),
+ gs:config(GSItem, [{select, Select}]),
+ init_warnings(Left, LegalWarnings);
+init_warnings([], _LegalWarnings) ->
+ ok.
+
+config_gui_start(State) ->
+ Enabled = [{enable, true}],
+ Disabled = [{enable, false}],
+ gs:config(State#gui_state.stop, Enabled),
+ gs:config(State#gui_state.run, Disabled),
+ gs:config(State#gui_state.del_file, Disabled),
+ gs:config(State#gui_state.clear_chosen, Disabled),
+ gs:config(State#gui_state.add_file, Disabled),
+ gs:config(State#gui_state.add_all, Disabled),
+ gs:config(State#gui_state.add_rec, Disabled),
+ gs:config(State#gui_state.clear_warn, Disabled),
+ gs:config(State#gui_state.clear_log, Disabled),
+ Menu = State#gui_state.menu,
+ gs:config(Menu#menu.file_save_warn, Disabled),
+ gs:config(Menu#menu.file_save_log, Disabled),
+ gs:config(Menu#menu.opts_macros, Disabled),
+ gs:config(Menu#menu.opts_includes, Disabled),
+ gs:config(Menu#menu.plt_empty, Disabled),
+ gs:config(Menu#menu.plt_search_doc, Disabled),
+ gs:config(Menu#menu.plt_show_doc, Disabled),
+ Mode = State#gui_state.mode,
+ gs:config(Mode#mode.start_byte_code, Disabled),
+ gs:config(Mode#mode.start_src_code, Disabled).
+
+config_gui_stop(State) ->
+ Enabled = [{enable, true}],
+ Disabled = [{enable, false}],
+ gs:config(State#gui_state.stop, Disabled),
+ gs:config(State#gui_state.run, Enabled),
+ gs:config(State#gui_state.del_file, Enabled),
+ gs:config(State#gui_state.clear_chosen, Enabled),
+ gs:config(State#gui_state.add_file, Enabled),
+ gs:config(State#gui_state.add_all, Enabled),
+ gs:config(State#gui_state.add_rec, Enabled),
+ gs:config(State#gui_state.clear_warn, Enabled),
+ gs:config(State#gui_state.clear_log, Enabled),
+ Menu = State#gui_state.menu,
+ gs:config(Menu#menu.file_save_warn, Enabled),
+ gs:config(Menu#menu.file_save_log, Enabled),
+ gs:config(Menu#menu.opts_macros, Enabled),
+ gs:config(Menu#menu.opts_includes, Enabled),
+ gs:config(Menu#menu.plt_empty, Enabled),
+ gs:config(Menu#menu.plt_search_doc, Enabled),
+ gs:config(Menu#menu.plt_show_doc, Enabled),
+ Mode = State#gui_state.mode,
+ gs:config(Mode#mode.start_byte_code, Enabled),
+ gs:config(Mode#mode.start_src_code, Enabled).
+
+%% ----------------------------------------------------------------
+%%
+%% Messages
+%%
+
+message(State, Message) ->
+ output_sms(State, ?DIALYZER_MESSAGE_TITLE, Message).
+
+error_sms(State, Message) ->
+ output_sms(State, ?DIALYZER_ERROR_TITLE, Message).
+
+%%
+%% This function is to be used *only* for small messages because lines
+%% are not wrapped and the created window has a limited area for text.
+%% For bigger messages, the function free_editor/3 is to be used.
+%%
+output_sms(#gui_state{gs = GS, top = TopWin}, Title, Message) ->
+ %% Lines = string:words(Message, $\n),
+ %% io:format("The message has ~w lines\n", [Lines]),
+ WH = [{width, 400}, {height, 100}],
+ MessageWin = gs:window(GS, [{title, Title},
+ {default, button, {font, {helvetica, bold, 12}}}
+ |WH]),
+ MessagePacker = gs:frame(MessageWin, [{packer_y, [{fixed, 75}, {fixed, 25}]},
+ {packer_x, [{fixed, 175},{fixed, 50},
+ {fixed, 175}]}]),
+ gs:label(MessagePacker, [{pack_x, {1, 3}}, {pack_y, 1},
+ {label, {text, Message}}]),
+ OK = gs:button(MessagePacker, [{label, {text, "OK"}}, {pack_xy, {2, 2}}]),
+ gs:config(MessageWin, [{map, true}]),
+ gs:config(MessagePacker, WH),
+ message_loop(OK, MessageWin, TopWin).
+
+message_loop(Ok, Win, TopWin) ->
+ receive
+ {gs, Ok, click, _, _} ->
+ gs:destroy(Win);
+ {gs, Win, destroy, _, _} ->
+ ok;
+ {gs, TopWin, destroy, _, _} ->
+ exit(normal);
+ {gs, _, _, _, _} ->
+ message_loop(Ok, Win, TopWin)
+ end.
+
+dialog(#gui_state{gs = GS, top = TopWin}, Message, OkLabel, CancelLabel) ->
+ WH = [{width, 400}, {height, 100}],
+ WHButton = [{width, 70}, {height, 20}],
+ DialogWin = gs:window(GS, [{title, "Dialyzer Message"},
+ {default, button, {font, {helvetica, bold, 12}}}
+ |WH]),
+ DialogPacker = gs:frame(DialogWin, [{packer_y, [{fixed, 75}, {fixed, 25}]},
+ {packer_x, [{fixed, 150}, {fixed, 50},
+ {fixed, 50}, {fixed, 150}]}]),
+ gs:label(DialogPacker, [{pack_x, {1,4}}, {pack_y, 1},
+ {label, {text, Message}}]),
+ Ok = gs:button(DialogPacker, [{label, {text, OkLabel}},
+ {pack_xy, {2,2}}|WHButton]),
+ Cancel = gs:button(DialogPacker, [{label, {text, CancelLabel}},
+ {pack_xy, {3,2}}|WHButton]),
+ gs:config(DialogWin, [{map, true}]),
+ gs:config(DialogPacker, WH),
+ dialog_loop(Ok, Cancel, DialogWin, TopWin).
+
+dialog_loop(Ok, Cancel, Win, TopWin) ->
+ receive
+ {gs, Ok, click, _, _} ->
+ gs:destroy(Win),
+ true;
+ {gs, Cancel, click, _, _} ->
+ gs:destroy(Win),
+ false;
+ {gs, Win, destroy, _, _} ->
+ false;
+ {gs, TopWin, destroy, _, _} ->
+ exit(normal);
+ {gs, _, _, _, _} ->
+ dialog_loop(Ok, Cancel, Win, TopWin)
+ end.
+
+maybe_quit(#gui_state{top = TopWin} = State) ->
+ case dialog(State, "Do you really want to quit?", "Yes", "No") of
+ true ->
+ flush(),
+ gs:destroy(TopWin),
+ gs:stop(),
+ true;
+ false ->
+ false
+ end.
+
+
+%% ----------------------------------------------------------------
+%%
+%% Menu actions
+%%
+
+%% ---- Help Menu ----
+
+manual(State) ->
+ help_menu_common(State, "Dialyzer Manual", 500, "manual.txt", white).
+
+warnings(State) ->
+ help_menu_common(State, "Dialyzer Warnings", 500, "warnings.txt", white).
+
+about(State) ->
+ help_menu_common(State, "About Dialyzer", 160, "about.txt", yellow).
+
+help_menu_common(#gui_state{gs = GS, top = TopWin} = State,
+ Title, Height, TxtFileName, BackGroundColor) ->
+ WH = [{width, 600}, {height, Height}],
+ Win = gs:window(GS, [{title, Title}, {configure, true},
+ {default, editor, {bg, BackGroundColor}} | WH]),
+ EmptySpace = {stretch, 1},
+ Frame = gs:frame(Win, [{packer_x, [EmptySpace, {fixed, 60}, EmptySpace]},
+ {packer_y, [EmptySpace, {fixed, 30}]} | WH]),
+ Editor = gs:editor(Frame, [{pack_x, {1, 3}}, {pack_y, 1},
+ {font, {courier, 12}}, {vscroll, right},
+ {wrap, word}]),
+ Button = gs:button(Frame, [{label, {text, "Ok"}}, {pack_xy, {2, 2}}]),
+ gs:config(Win, [{map, true}]),
+ gs:config(Frame, WH),
+ AboutFile = filename:join([code:lib_dir(dialyzer), "doc", TxtFileName]),
+ case gs:config(Editor, {load, AboutFile}) of
+ {error, Reason} ->
+ gs:destroy(Win),
+ error_sms(State,
+ io_lib:format("Could not find doc/~s file!\n\n ~p",
+ [TxtFileName, Reason]));
+ ok ->
+ gs:config(Editor, [{enable, false}]),
+ show_info_loop(TopWin, Win, Frame, Button)
+ end.
+
+%% ---- File Menu ----
+
+save_log(#gui_state{file_wd = CWD, log = Log} = State) ->
+ {Win, Entry, OkButton, CancelButton} = file_box(State, "Save Log", CWD),
+ save_loop(State, OkButton, CancelButton, Entry, Win, Log).
+
+save_warn(#gui_state{file_wd = CWD, warnings_box = WBox} = State) ->
+ {Win, Entry, OkButton, CancelButton} = file_box(State, "Save Warnings", CWD),
+ save_loop(State, OkButton, CancelButton, Entry, Win, WBox).
+
+file_box(#gui_state{gs = GS}, Title, Default) ->
+ WH = [{width, 400}, {height, 75}],
+ Win = gs:window(GS, [{title, Title}|WH]),
+ Fix25 = {fixed, 27}, Fix75 = {fixed, 75},
+ WinPacker = gs:frame(Win, [{packer_y, [Fix25, Fix25, Fix25]},
+ {packer_x, [Fix75, Fix75, Fix75, {fixed, 175}]}]),
+ gs:label(WinPacker, [{pack_xy, {1,2}}, {label, {text, "Enter file:"}}]),
+ Entry = gs:entry(WinPacker, [{pack_x, {2,4}}, {pack_y, 2}, {keypress, true}]),
+ OkButton = gs:button(WinPacker, [{label, {text, "Ok"}}, {pack_xy, {2,3}}]),
+ CancelButton = gs:button(WinPacker, [{label, {text, "Cancel"}},
+ {pack_xy, {3,3}}]),
+ gs:config(Entry, [{text, Default}]),
+ gs:config(Win, [{map, true}]),
+ gs:config(WinPacker, WH),
+ {Win, Entry, OkButton, CancelButton}.
+
+save_loop(#gui_state{top = TopWin} = State,
+ OkButton, CancelButton, Entry, Save, Editor) ->
+ receive
+ {gs, OkButton, click, _, _} ->
+ File = gs:read(Entry, text),
+ case gs:config(Editor, [{save, File}]) of
+ {error, _} ->
+ error_sms(State, "Could not write to file:\n" ++ File),
+ save_loop(State, OkButton, CancelButton, Entry, Save, Editor);
+ _ ->
+ gs:destroy(Save)
+ end;
+ {gs, Entry, keypress, _, ['Return'|_]} ->
+ File = gs:read(Entry, text),
+ case gs:config(Editor, [{save, File}]) of
+ {error, _} ->
+ error_sms(State, "Could not write to file:\n" ++ File),
+ save_loop(State, OkButton, CancelButton, Entry, Save, Editor);
+ _ ->
+ gs:destroy(Save)
+ end;
+ {gs, Entry, keypress, _, _} ->
+ save_loop(State, OkButton, CancelButton, Entry, Save, Editor);
+ {gs, CancelButton, click, _, _} ->
+ gs:destroy(Save);
+ {gs, TopWin, destroy, _, _} ->
+ exit(normal);
+ {gs, Save, destroy, _, _} ->
+ ok;
+ {gs, _, _, _, _} ->
+ save_loop(State, OkButton, CancelButton, Entry, Save, Editor)
+ end.
+
+%% ---- Plt Menu ----
+
+search_doc_plt(#gui_state{gs = GS, top = TopWin} = State) ->
+ WH = [{width, 400}, {height, 100}],
+ WHB = [{width, 120}, {height, 30}],
+ Title = io_lib:format("Search the PLT", []),
+ Win = gs:window(GS, [{title, Title}, {configure, true},
+ {default, editor, {bg, white}} | WH]),
+ EmptySpace = {stretch, 1},
+ Frame = gs:frame(Win, [{packer_x, [EmptySpace, EmptySpace, EmptySpace]},
+ {packer_y, [{fixed, 30}, {fixed, 30},
+ EmptySpace, {fixed, 30}]} | WH]),
+ gs:label(Frame, [{pack_xy, {1,1}}, {label, {text, "Module"}}]),
+ ModEntry = gs:entry(Frame, [{pack_xy, {1,2}}]),
+ gs:label(Frame, [{pack_xy, {2,1}}, {label, {text, "Function"}}]),
+ FunEntry = gs:entry(Frame, [{pack_xy, {2,2}}]),
+ gs:label(Frame, [{pack_xy, {3,1}}, {label, {text, "Arity"}}]),
+ ArityEntry = gs:entry(Frame, [{pack_xy, {3,2}}]),
+ ButtonPacker = gs:frame(Frame, [{pack_xy, {2,4}},
+ {packer_x, [{fixed, 60}, {fixed, 60}]},
+ {packer_y, {fixed, 30}}]),
+ SearchButton = gs:button(ButtonPacker, [{label, {text, "Search"}},
+ {pack_xy, {1,1}}]),
+ CancelButton = gs:button(ButtonPacker, [{label, {text, "Cancel"}},
+ {pack_xy, {2,1}}]),
+ gs:config(Win, [{map, true}]),
+ gs:config(Frame, WH),
+ gs:config(ButtonPacker, WHB),
+ search_doc_plt_loop(State, CancelButton, SearchButton, ModEntry,
+ FunEntry, ArityEntry, Win, TopWin).
+
+search_doc_plt_loop(State, CancelButton, SearchButton, ModEntry,
+ FunEntry, ArityEntry, Win, TopWin) ->
+ receive
+ {gs, CancelButton, click, _, _} ->
+ gs:destroy(Win),
+ ok;
+ {gs, TopWin, destroy, _, _} ->
+ exit(normal);
+ {gs, SearchButton, click, _, _} ->
+ M = format_search(gs:read(ModEntry, text)),
+ F = format_search(gs:read(FunEntry, text)),
+ A = format_search(gs:read(ArityEntry, text)),
+ case dialyzer_plt:get_specs(State#gui_state.doc_plt, M, F, A) of
+ "" ->
+ error_sms(State, "No such function"),
+ search_doc_plt_loop(State, CancelButton, SearchButton, ModEntry,
+ FunEntry, ArityEntry, Win, TopWin);
+ NonEmptyString ->
+ gs:destroy(Win),
+ free_editor(State, "Content of PLT", NonEmptyString)
+ end
+ end.
+
+format_search([]) ->
+ '_';
+format_search(String) ->
+ try list_to_integer(String)
+ catch error:_ -> list_to_atom(String)
+ end.
+
+show_doc_plt(#gui_state{doc_plt = DocPLT} = State) ->
+ case dialyzer_plt:get_specs(DocPLT) of
+ "" -> error_sms(State, "No analysis has been made yet!\n");
+ NonEmptyString -> free_editor(State, "Content of PLT", NonEmptyString)
+ end.
+
+free_editor(#gui_state{gs = GS, top = TopWin}, Title, Contents0) ->
+ Contents = lists:flatten(Contents0),
+ Tokens = string:tokens(Contents, "\n"),
+ NofLines = length(Tokens),
+ LongestLine = lists:max([length(X) || X <- Tokens]),
+ Height0 = NofLines * 25 + 80,
+ Height = if Height0 > 500 -> 500; true -> Height0 end,
+ Width0 = LongestLine * 7 + 60,
+ Width = if Width0 > 800 -> 800; true -> Width0 end,
+ WH = [{width, Width}, {height, Height}],
+ Win = gs:window(GS, [{title, Title}, {configure, true},
+ {default, editor, {bg, white}} | WH]),
+ EmptySpace = {stretch, 1},
+ Frame = gs:frame(Win, [{packer_x, [EmptySpace, {fixed, 60}, EmptySpace]},
+ {packer_y, [EmptySpace, {fixed, 30}]}
+ | WH]),
+ Editor = gs:editor(Frame, [{pack_x, {1,3}}, {pack_y, 1},
+ {font, {courier, 12}}, {vscroll, right},
+ {wrap, word}, {enable, true}]),
+ Button = gs:button(Frame, [{label, {text, "Ok"}}, {pack_xy, {2,2}}]),
+ gs:config(Editor, [{insert, {insert, Contents}}]),
+ gs:config(Editor, [{enable, false}]),
+ gs:config(Win, [{map, true}]),
+ gs:config(Frame, WH),
+ show_info_loop(TopWin, Win, Frame, Button).
+
+%% ---- Common ----
+
+show_info_loop(TopWin, Win, Frame, Button) ->
+ receive
+ {gs, Button, click, _, _} ->
+ gs:destroy(Win);
+ {gs, TopWin, destroy, _, _} ->
+ exit(normal);
+ {gs, Win, destroy, _, _} ->
+ ok;
+ {gs, Win, configure, _Data, [W, H|_]} ->
+ gs:config(Frame, [{width, W}, {height, H}]),
+ show_info_loop(TopWin, Win, Frame, Button)
+ end.
+
+include_dialog(#gui_state{gs = GS, options = Options}, Parent) ->
+ WH = [{width, 300}, {height, 400}],
+ Title = io_lib:format("Include Directories", []),
+ Win = gs:window(GS, [{title, Title}, {configure, true},
+ {default, entry, {bg, white}}| WH]),
+ EmptySpace = {stretch, 1},
+ Frame = gs:frame(Win, [{packer_x, [EmptySpace]},
+ {packer_y, [{fixed, 30}, {fixed, 30}, {fixed, 30},
+ EmptySpace, {fixed, 30}, {fixed, 30}]}
+ | WH]),
+ gs:label(Frame, [{pack_xy, {1,1}}, {label, {text, "Directory"}}]),
+ DirEntry = gs:entry(Frame, [{pack_xy, {1,2}}]),
+ ButtonPacker1 = gs:frame(Frame, [{pack_xy, {1,3}},
+ {packer_x, [{fixed, 70}, {fixed, 70},
+ EmptySpace]},
+ {packer_y, {fixed, 30}}]),
+ AddButton = gs:button(ButtonPacker1, [{label, {text, "Add"}},
+ {pack_xy, {1,1}}]),
+ Dirs = [io_lib:format("~s", [X]) || X <- Options#options.include_dirs],
+ DirBox = gs:listbox(Frame, [{pack_xy, {1,4}}, {vscroll, right},
+ {bg, white}, {configure, true},
+ {selectmode, multiple}, {items, Dirs}]),
+ ButtonPacker2 = gs:frame(Frame, [{pack_xy, {1,5}},
+ {packer_x, [{fixed, 60}, {fixed, 70},
+ EmptySpace]},
+ {packer_y, {fixed, 30}}]),
+ DeleteButton = gs:button(ButtonPacker2, [{label, {text, "Delete"}},
+ {pack_xy, {1,1}}]),
+ DeleteAllButton = gs:button(ButtonPacker2, [{label, {text, "Delete All"}},
+ {pack_xy, {2,1}}]),
+ ButtonPacker3 = gs:frame(Frame, [{pack_xy, {1,6}},
+ {packer_x, [EmptySpace,
+ {fixed, 60}, {fixed, 60}]},
+ {packer_y, {fixed, 30}}]),
+ OkButton = gs:button(ButtonPacker3, [{label, {text, "Ok"}},
+ {pack_xy, {2,1}}]),
+ CancelButton = gs:button(ButtonPacker3, [{label, {text, "Cancel"}},
+ {pack_xy, {3,1}}]),
+ gs:config(Win, [{map, true}]),
+ gs:config(Frame, WH),
+ include_loop(Parent, Options, Frame, AddButton, DeleteAllButton, DeleteButton,
+ DirBox, DirEntry, OkButton, CancelButton, Win).
+
+include_loop(Parent, Options, Frame, AddButton, DeleteAllButton, DeleteButton,
+ DirBox, DirEntry, OkButton, CancelButton, Win) ->
+ receive
+ {gs, CancelButton, click, _, _} ->
+ gs:destroy(Win),
+ ok;
+ {gs, OkButton, click, _, _} ->
+ gs:destroy(Win),
+ Parent ! {new_options, Options},
+ ok;
+ {gs, Win, configure, _Data, [W, H|_]} ->
+ gs:config(Frame, [{width, W}, {height, H}]),
+ include_loop(Parent, Options, Frame, AddButton, DeleteAllButton,
+ DeleteButton, DirBox, DirEntry, OkButton, CancelButton, Win);
+ {gs, AddButton, click, _, _} ->
+ Dirs = Options#options.include_dirs,
+ NewDirs =
+ case gs:read(DirEntry, text) of
+ [] -> Dirs;
+ Add -> [Add|Dirs]
+ end,
+ NewOptions = Options#options{include_dirs = NewDirs},
+ gs:config(DirBox, [{items, NewDirs}]),
+ include_loop(Parent, NewOptions, Frame, AddButton, DeleteAllButton,
+ DeleteButton, DirBox, DirEntry, OkButton, CancelButton, Win);
+ {gs, DeleteAllButton, click, _, _} ->
+ gs:config(DirBox, [clear]),
+ NewOptions = Options#options{include_dirs = []},
+ include_loop(Parent, NewOptions, Frame, AddButton, DeleteAllButton,
+ DeleteButton, DirBox, DirEntry, OkButton, CancelButton, Win);
+ {gs, DeleteButton, click, _, _} ->
+ NewOptions =
+ case gs:read(DirBox, selection) of
+ [] ->
+ Options;
+ List ->
+ lists:foreach(fun(X) -> gs:config(DirBox, [{del, X}]) end,
+ lists:sort(List)),
+ NewDirs = gs:read(DirBox, items),
+ Options#options{include_dirs = NewDirs}
+ end,
+ include_loop(Parent, NewOptions, Frame, AddButton, DeleteAllButton,
+ DeleteButton, DirBox, DirEntry, OkButton, CancelButton, Win);
+ {gs, Win, destroy, _, _} ->
+ ok
+ end.
+
+macro_dialog(#gui_state{gs = GS, options = Options}, Parent) ->
+ WH = [{width, 300}, {height, 400}],
+ Title = io_lib:format("Macro Definitions", []),
+ Win = gs:window(GS, [{title, Title}, {configure, true},
+ {default, entry, {bg, white}}| WH]),
+ EmptySpace = {stretch, 1},
+ Frame = gs:frame(Win, [{packer_x, [EmptySpace, EmptySpace]},
+ {packer_y, [{fixed, 30}, {fixed, 30}, {fixed, 30},
+ EmptySpace, {fixed, 30}, {fixed, 30}]}
+ | WH]),
+ gs:label(Frame, [{pack_xy, {1,1}}, {label, {text, "Macro"}}]),
+ MacroEntry = gs:entry(Frame, [{pack_xy, {1,2}}]),
+ gs:label(Frame, [{pack_xy, {2,1}}, {label, {text, "Term"}}]),
+ TermEntry = gs:entry(Frame, [{pack_xy, {2,2}}]),
+ ButtonPacker1 = gs:frame(Frame, [{pack_x, {1,2}}, {pack_y, 3},
+ {packer_x, [{fixed, 70},{fixed, 70},
+ EmptySpace]},
+ {packer_y, {fixed, 30}}]),
+ AddButton = gs:button(ButtonPacker1, [{label, {text, "Add"}},
+ {pack_xy, {1,1}}]),
+ Macros = [io_lib:format("~p = ~p",[X,Y]) || {X,Y} <- Options#options.defines],
+ MacroBox = gs:listbox(Frame, [{pack_x, {1,2}}, {pack_y, 4}, {vscroll, right},
+ {bg, white}, {configure, true},
+ {selectmode, multiple},
+ {items, Macros}]),
+ ButtonPacker2 = gs:frame(Frame, [{pack_x, {1,2}}, {pack_y, 5},
+ {packer_x, [{fixed, 60}, {fixed, 70},
+ EmptySpace]},
+ {packer_y, {fixed, 30}}]),
+ DeleteButton = gs:button(ButtonPacker2, [{label, {text, "Delete"}},
+ {pack_xy, {1,1}}]),
+ DeleteAllButton = gs:button(ButtonPacker2, [{label, {text, "Delete All"}},
+ {pack_xy, {2,1}}]),
+ ButtonPacker3 = gs:frame(Frame, [{pack_x, {1,2}}, {pack_y, 6},
+ {packer_x, [EmptySpace,
+ {fixed, 60}, {fixed, 60}]},
+ {packer_y, {fixed, 30}}]),
+ OkButton = gs:button(ButtonPacker3, [{label, {text, "Ok"}},
+ {pack_xy, {2,1}}]),
+ CancelButton = gs:button(ButtonPacker3, [{label, {text, "Cancel"}},
+ {pack_xy, {3,1}}]),
+ gs:config(Win, [{map, true}]),
+ gs:config(Frame, WH),
+ macro_loop(Parent, Options, Frame, AddButton, DeleteAllButton, DeleteButton,
+ MacroBox, MacroEntry, TermEntry, OkButton, CancelButton, Win).
+
+macro_loop(Parent, Options, Frame, AddButton, DeleteAllButton, DeleteButton,
+ MacroBox, MacroEntry, TermEntry, OkButton, CancelButton, Win) ->
+ receive
+ {gs, CancelButton, click, _, _} ->
+ gs:destroy(Win),
+ ok;
+ {gs, OkButton, click, _, _} ->
+ gs:destroy(Win),
+ Parent ! {new_options, Options},
+ ok;
+ {gs, Win, configure, _Data, [W, H|_]} ->
+ gs:config(Frame, [{width, W}, {height, H}]),
+ macro_loop(Parent, Options, Frame, AddButton, DeleteAllButton,
+ DeleteButton, MacroBox, MacroEntry, TermEntry, OkButton,
+ CancelButton, Win);
+ {gs, AddButton, click, _, _} ->
+ Defines = Options#options.defines,
+ NewDefines =
+ case gs:read(MacroEntry, text) of
+ "" -> Defines;
+ Macro ->
+ Empty = [{text, ""}],
+ case gs:read(TermEntry, text) of
+ "" ->
+ gs:config(MacroEntry, Empty),
+ orddict:store(list_to_atom(Macro), true, Defines);
+ String ->
+ case parse(String) of
+ {ok, Term} ->
+ gs:config(MacroEntry, Empty),
+ gs:config(TermEntry, Empty),
+ orddict:store(list_to_atom(Macro), Term, Defines);
+ {error, _Reason} ->
+ Defines
+ end
+ end
+ end,
+ NewOptions = Options#options{defines = NewDefines},
+ NewEntries = [io_lib:format("~p = ~p", [X, Y]) || {X, Y} <- NewDefines],
+ gs:config(MacroBox, [{items, NewEntries}]),
+ macro_loop(Parent, NewOptions, Frame, AddButton, DeleteAllButton,
+ DeleteButton, MacroBox, MacroEntry, TermEntry, OkButton,
+ CancelButton, Win);
+ {gs, DeleteAllButton, click, _, _} ->
+ gs:config(MacroBox, [clear]),
+ NewOptions = Options#options{defines = []},
+ macro_loop(Parent, NewOptions, Frame, AddButton, DeleteAllButton,
+ DeleteButton, MacroBox, MacroEntry, TermEntry, OkButton,
+ CancelButton, Win);
+ {gs, DeleteButton, click, _, _} ->
+ NewOptions =
+ case gs:read(MacroBox, selection) of
+ [] ->
+ Options;
+ List ->
+ gs:config(MacroBox, [{selection, clear}]),
+ Fun =
+ fun(X) ->
+ Val = gs:read(MacroBox, {get, X}),
+ [MacroName|_] = re:split(Val, " ", [{return, list}]),
+ list_to_atom(MacroName)
+ end,
+ Delete = [Fun(X) || X <- List],
+ lists:foreach(fun(X) -> gs:config(MacroBox, [{del, X}]) end,
+ lists:reverse(lists:sort(List))),
+ Defines = Options#options.defines,
+ NewDefines = lists:foldl(fun(X, Acc) ->
+ orddict:erase(X, Acc)
+ end,
+ Defines, Delete),
+ Options#options{defines = NewDefines}
+ end,
+ macro_loop(Parent, NewOptions, Frame, AddButton, DeleteAllButton,
+ DeleteButton, MacroBox, MacroEntry, TermEntry, OkButton,
+ CancelButton, Win);
+ {gs, Win, destroy, _, _} ->
+ ok
+ end.
+
+parse(String) ->
+ case erl_scan:string(String ++ ".", 1) of
+ {ok, Ts, _} ->
+ case erl_parse:parse_exprs(Ts) of
+ {ok, [Expr]} ->
+ try erl_parse:normalise(Expr)
+ catch error:Reason -> {error, Reason}
+ end;
+ {error, E} ->
+ parse_error(E)
+ end;
+ {error, E, _} ->
+ parse_error(E)
+ end.
+
+parse_error(E) ->
+ S = io_lib:fwrite("Error parsing expression: ~P.", [E,15]),
+ {error, S}.
+
+%% ----------------------------------------------------------------
+%%
+%% Run the analysis
+%%
+
+start_analysis(State) ->
+ Analysis = build_analysis_record(State),
+ case get_anal_files(State, Analysis#analysis.start_from) of
+ error ->
+ Msg = "You must choose one or more files or dirs\n"
+ "before starting the analysis!",
+ error_sms(State, Msg),
+ config_gui_stop(State),
+ State;
+ {ok, Files} ->
+ Msg = "\n========== Starting Analysis ==========\n\n",
+ update_editor(State#gui_state.log, Msg),
+ NewAnalysis = Analysis#analysis{files = Files},
+ run_analysis(State, NewAnalysis)
+ end.
+
+build_analysis_record(#gui_state{mode = Mode, menu = Menu, options = Options,
+ init_plt = InitPlt0}) ->
+ StartFrom =
+ case gs:read(Mode#mode.start_byte_code, select) of
+ true -> byte_code;
+ false -> src_code
+ end,
+ InitPlt =
+ case gs:read(Menu#menu.plt_empty, select) of
+ true -> dialyzer_plt:new();
+ false -> InitPlt0
+ end,
+ #analysis{defines = Options#options.defines,
+ include_dirs = Options#options.include_dirs,
+ plt = InitPlt,
+ start_from = StartFrom}.
+
+get_anal_files(#gui_state{chosen_box = ChosenBox}, StartFrom) ->
+ Files = gs:read(ChosenBox, items),
+ FilteredMods =
+ case StartFrom of
+ src_code -> filter_mods(Files, ".erl");
+ byte_code -> filter_mods(Files, ".beam")
+ end,
+ FilteredDirs = [X || X <- Files, filelib:is_dir(X)],
+ case ordsets:union(FilteredMods, FilteredDirs) of
+ [] -> error;
+ Set -> {ok, Set}
+ end.
+
+run_analysis(State, Analysis) ->
+ config_gui_start(State),
+ Self = self(),
+ NewAnalysis = Analysis#analysis{doc_plt = dialyzer_plt:new()},
+ LegalWarnings = find_legal_warnings(State),
+ Fun =
+ fun() ->
+ dialyzer_analysis_callgraph:start(Self, LegalWarnings, NewAnalysis)
+ end,
+ BackendPid = spawn_link(Fun),
+ State#gui_state{backend_pid = BackendPid}.
+
+find_legal_warnings(#gui_state{menu = #menu{warnings = Warnings}}) ->
+ ordsets:from_list([Tag || {Tag, GSItem} <- Warnings,
+ gs:read(GSItem, select) =:= true]).
+
+flush() ->
+ receive
+ _ -> flush()
+ after
+ 0 -> ok
+ end.
+
+update_editor(Editor, Msg) ->
+ gs:config(Editor, [{enable, true}]),
+ NofRows = gs:read(Editor, size),
+ gs:config(Editor, [{insertpos, 'end'}]),
+ gs:config(Editor, [{insert, {insert, Msg}}]),
+ NewNofRows = gs:read(Editor, size),
+ ScrollPos = gs:read(Editor, vscrollpos),
+ gs:config(Editor, [{vscrollpos, ScrollPos + NewNofRows - NofRows}]),
+ gs:config(Editor, [{enable, false}]).
diff --git a/lib/dialyzer/src/dialyzer_gui_wx.erl b/lib/dialyzer/src/dialyzer_gui_wx.erl
new file mode 100644
index 0000000000..2d97f88680
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_gui_wx.erl
@@ -0,0 +1,1243 @@
+%% -*- erlang-indent-level: 2 -*-
+%%------------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2009. 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%
+%%
+
+%%%-----------------------------------------------------------------------
+%%% File : dialyzer_gui_wx.erl
+%%% Authors : Elli Fragkaki <[email protected]>
+%%% Description : The wx-based graphical user interface of dialyzer.
+%%%
+%%% Created : 07 Oct 2009 by Elli Fragkaki <[email protected]>
+%%%-----------------------------------------------------------------------
+
+-module(dialyzer_gui_wx).
+
+-export([start/1]).
+
+-include("dialyzer.hrl").
+-include("dialyzer_gui_wx.hrl").
+
+%%------------------------------------------------------------------------
+
+-define(DIALYZER_ERROR_TITLE, "Dialyzer Error").
+-define(DIALYZER_MESSAGE_TITLE, "Dialyzer Message").
+
+%%------------------------------------------------------------------------
+
+-type wx_object() :: any(). %% XXX: should be imported from wx
+
+-record(menu, {file :: wx_object(),
+ warnings :: wx_object(),
+ plt :: wx_object(),
+ options :: wx_object(),
+ help :: wx_object()}).
+
+-record(gui_state, {add :: wx_object(),
+ add_dir :: wx_object(),
+ add_rec :: wx_object(),
+ chosen_box :: wx_object(),
+ analysis_pid :: pid(),
+ del_file :: wx_object(),
+ doc_plt :: dialyzer_plt:plt(),
+ clear_chosen :: wx_object(),
+ clear_log :: wx_object(),
+ explain_warn :: wx_object(),
+ clear_warn :: wx_object(),
+ init_plt :: dialyzer_plt:plt(),
+ dir_entry :: wx_object(),
+ file_box :: wx_object(),
+ files_to_analyze :: ordset(string()),
+ gui :: wx_object(),
+ log :: wx_object(),
+ menu :: #menu{},
+ mode :: wx_object(),
+ options :: #options{},
+ run :: wx_object(),
+ stop :: wx_object(),
+ frame :: wx_object(),
+ warnings_box :: wx_object(),
+ explanation_box :: wx_object(),
+ wantedWarnings :: list(),
+ rawWarnings :: list(),
+ backend_pid :: pid(),
+ expl_pid :: pid()}).
+
+%%------------------------------------------------------------------------
+
+-spec start(#options{}) -> ?RET_NOTHING_SUSPICIOUS.
+
+start(DialyzerOptions) ->
+ process_flag(trap_exit, true),
+ Wx = wx:new(),
+ State = wx:batch(fun() -> create_window(Wx, DialyzerOptions) end),
+ gui_loop(State).
+
+create_window(Wx, DialyzerOptions) ->
+ {ok, Host} = inet:gethostname(),
+
+ %%---------- initializing frame ---------
+ Frame = wxFrame:new(Wx, -1, "Dialyzer " ++ ?VSN ++ " @ " ++ Host),
+ wxFrame:connect(Frame, close_window),
+ FileMenu = createFileMenu(),
+ WarningsMenu = createWarningsMenu(),
+ PltMenu = createPltMenu(),
+ OptionsMenu = createOptionsMenu(),
+ HelpMenu = createHelpMenu(),
+
+ MenuBar = wxMenuBar:new(),
+ wxMenuBar:append(MenuBar, FileMenu, "File"),
+ wxMenuBar:append(MenuBar, WarningsMenu, "Warnings"),
+ wxMenuBar:append(MenuBar, PltMenu, "Plt"),
+ wxMenuBar:append(MenuBar, OptionsMenu, "Options"),
+ wxMenuBar:append(MenuBar, HelpMenu, "Help"),
+ wxFrame:setMenuBar(Frame, MenuBar),
+ ok = wxFrame:connect(Frame, command_menu_selected),
+
+ %%----------- Set Labels -------------
+ Lab1 = wxStaticText:new(Frame, ?LABEL1, "Directories or modules to analyze"),
+ OptionsLabel = wxStaticText:new(Frame, ?LABEL2, "Analysis Options"),
+ LogLabel = wxStaticText:new(Frame, ?LABEL3, "Log"),
+ FileLabel = wxStaticText:new(Frame, ?LABEL4, "File: "),
+ DirLabel = wxStaticText:new(Frame, ?LABEL5, "Dir: "),
+ WarningsLabel = wxStaticText:new(Frame, ?LABEL6, "Warnings"),
+
+ %%---------- Set TextBoxes -----------
+ ChosenBox = wxListBox:new(Frame, ?ChosenBox,
+ [{size, {250,200}},
+ {style, ?wxLB_EXTENDED bor ?wxLB_HSCROLL
+ bor ?wxLB_NEEDED_SB}]),
+ LogBox = wxTextCtrl:new(Frame, ?LogBox,
+ [{size, {530,200}},
+ {style, ?wxTE_MULTILINE
+ bor ?wxTE_READONLY bor ?wxHSCROLL}]),
+ DefaultPath = code:root_dir(),
+
+ FilePicker = wxFilePickerCtrl:new(Frame, ?FilePicker,
+ [{path, DefaultPath},
+ {message, "Choose File to Analyse"},
+ {style,?wxFLP_FILE_MUST_EXIST bor ?wxFLP_USE_TEXTCTRL}]),
+ wxPickerBase:setTextCtrlProportion(FilePicker,3),
+ wxPickerBase:setPickerCtrlProportion(FilePicker,2),
+ DirPicker = wxDirPickerCtrl:new(Frame, ?DirPicker,
+ [{path, DefaultPath},
+ {message, "Choose Directory to Analyze"},
+ {style,?wxDIRP_DIR_MUST_EXIST bor ?wxDIRP_USE_TEXTCTRL}]),
+ WarningsBox = wxListBox:new(Frame, ?WarningsBox,
+ [{size, {700,200}},
+ {style, ?wxLB_HSCROLL
+ bor ?wxLB_NEEDED_SB}]),
+
+ %%--------- Set Buttons --------------
+ DeleteButton = wxButton:new(Frame, ?Del_Button, [{label, "Delete"}]),
+ DeleteAllButton = wxButton:new(Frame, ?DelAll_Button, [{label, "Delete All"}]),
+ FileType = wxRadioBox:new(Frame, ?RADIOBOX, " File Type: " , {1,1}, {150,90},
+ [["BeamFiles"],["SourceFiles"]]),
+ ClearLogButton = wxButton:new(Frame, ?ClearLog_Button, [{label, "Clear Log"}]),
+ AddButton = wxButton:new(Frame, ?Add_Button, [{label, "Add"}]),
+ AddDirButton = wxButton:new(Frame, ?AddDir_Button, [{label, "Add Dir"}]),
+ AddRecButton = wxButton:new(Frame, ?AddRec_Button, [{label, "Add Recursively"}]),
+ ExplainWarnButton = wxButton:new(Frame, ?ExplWarn_Button, [{label, "Explain Warning"}]),
+ ClearWarningsButton = wxButton:new(Frame, ?ClearWarn_Button, [{label, "Clear Warnings"}]),
+ RunButton = wxButton:new(Frame, ?Run_Button, [{label, "Run"}]),
+ StopButton = wxButton:new(Frame, ?Stop_Button, [{label, "Stop"}]),
+ wxWindow:disable(StopButton),
+ %%--------- Connect Buttons -----------
+ wxButton:connect(DeleteButton, command_button_clicked),
+ wxButton:connect(DeleteAllButton, command_button_clicked),
+ wxButton:connect(ClearLogButton, command_button_clicked),
+ wxButton:connect(AddButton, command_button_clicked),
+ wxButton:connect(AddDirButton, command_button_clicked),
+ wxButton:connect(AddRecButton, command_button_clicked),
+ wxButton:connect(ExplainWarnButton, command_button_clicked),
+ wxButton:connect(ClearWarningsButton, command_button_clicked),
+ wxButton:connect(RunButton, command_button_clicked),
+ wxButton:connect(StopButton, command_button_clicked),
+
+ %%------------Set Layout ------------
+ All = wxBoxSizer:new(?wxVERTICAL),
+ Top = wxBoxSizer:new(?wxHORIZONTAL),
+ Left = wxBoxSizer:new(?wxVERTICAL),
+ Right = wxBoxSizer:new(?wxVERTICAL),
+ RightUp = wxBoxSizer:new(?wxHORIZONTAL),
+
+ Opts = [{flag,?wxEXPAND bor ?wxALL}, {proportion,1}, {border, 1}],
+ Opts3 = [{flag,?wxEXPAND bor ?wxALL}, {proportion,3}, {border, 1}],
+ Center = [{flag, ?wxALIGN_CENTER_HORIZONTAL}],
+
+ ChooseItem = wxBoxSizer:new(?wxVERTICAL),
+ FileTypeItem = wxBoxSizer:new(?wxVERTICAL),
+ LogItem = wxBoxSizer:new(?wxVERTICAL),
+ FileDirItem = wxBoxSizer:new(?wxVERTICAL),
+ FileItem = wxBoxSizer:new(?wxHORIZONTAL),
+ DirItem = wxBoxSizer:new(?wxHORIZONTAL),
+ AddDirButtons = wxBoxSizer:new(?wxHORIZONTAL),
+ WarningsItem = wxBoxSizer:new(?wxVERTICAL),
+ ChooseButtons = wxBoxSizer:new(?wxHORIZONTAL),
+ WarnButtons = wxBoxSizer:new(?wxHORIZONTAL),
+ RunButtons = wxBoxSizer:new(?wxHORIZONTAL),
+ Buttons = wxFlexGridSizer:new(3),
+
+ wxSizer:add(ChooseButtons, DeleteButton, ?BorderOpt),
+ wxSizer:add(ChooseButtons, DeleteAllButton, ?BorderOpt),
+ wxSizer:add(ChooseItem, Lab1, Center),
+ wxSizer:add(ChooseItem, ChosenBox, Opts),
+ wxSizer:add(ChooseItem, ChooseButtons, ?BorderOpt),
+ wxSizer:add(FileTypeItem, OptionsLabel),
+ wxSizer:add(FileTypeItem, FileType, [{border, 5}, {flag, ?wxALL}]),
+ wxSizer:add(LogItem, LogLabel, Center),
+ wxSizer:add(LogItem, LogBox, Opts3),
+ wxSizer:add(LogItem, ClearLogButton, ?BorderOpt),
+ wxSizer:add(FileItem, FileLabel),
+ wxSizer:add(FileItem, FilePicker),
+ wxSizer:add(DirItem, DirLabel),
+ wxSizer:add(DirItem, DirPicker),
+ wxSizer:add(AddDirButtons, AddDirButton, ?BorderOpt),
+ wxSizer:add(AddDirButtons, AddRecButton, ?BorderOpt),
+ wxSizer:add(FileDirItem, FileItem),
+ wxSizer:add(FileDirItem, AddButton, ?BorderOpt),
+ wxSizer:add(FileDirItem, DirItem, ?BorderOpt),
+ wxSizer:add(FileDirItem, AddDirButtons, ?BorderOpt),
+ wxSizer:add(WarnButtons, ExplainWarnButton, ?BorderOpt),
+ wxSizer:add(WarnButtons, ClearWarningsButton, ?BorderOpt),
+ wxSizer:add(RunButtons, RunButton, ?BorderOpt),
+ wxSizer:add(RunButtons, StopButton, ?BorderOpt),
+ wxSizer:add(Buttons, WarnButtons),
+ wxSizer:add(Buttons, wxStaticText:new(Frame, ?LABEL7, ""), [{flag, ?wxEXPAND}]),
+ wxSizer:add(Buttons, RunButtons),
+ wxFlexGridSizer:addGrowableCol(Buttons, 1),
+ wxSizer:add(WarningsItem, WarningsLabel, Center),
+ wxSizer:add(WarningsItem, WarningsBox, Opts3),
+ wxSizer:add(WarningsItem, Buttons, [{flag, ?wxEXPAND bor ?wxALL},?Border]),
+
+ wxSizer:add(Left, ChooseItem, Opts),
+ wxSizer:add(Left, FileDirItem, [{proportion, 1}, {border, 60}, {flag, ?wxTOP}]),
+ wxSizer:add(RightUp, FileTypeItem, ?BorderOpt),
+ wxSizer:add(RightUp, LogItem, Opts3),
+ wxSizer:add(Right, RightUp, Opts3),
+ wxSizer:add(Right, WarningsItem, Opts3),
+ wxSizer:add(Top, Left, Opts),
+ wxSizer:add(Top, Right, Opts3),
+
+ wxSizer:add(All, Top, Opts),
+ wxWindow:setSizer(Frame, All),
+ wxWindow:setSizeHints(Frame, {1150,600}),
+ wxWindow:show(Frame),
+
+ Warnings = [{?WARN_RETURN_NO_RETURN, ?menuID_WARN_NO_RETURN_FUN},
+ {?WARN_RETURN_ONLY_EXIT, ?menuID_WARN_ERROR_HANDLING_FUN},
+ {?WARN_NOT_CALLED, ?menuID_WARN_UNUSED_FUN},
+ {?WARN_NON_PROPER_LIST, ?menuID_WARN_LIST_CONSTR},
+ {?WARN_FUN_APP, ?menuID_WARN_BAD_FUN},
+ {?WARN_MATCHING, ?menuID_WARN_MATCH_FAILURES},
+ {?WARN_OPAQUE, ?menuID_WARN_OPAQUE},
+ {?WARN_FAILING_CALL, ?menuID_WARN_FAIL_FUN_CALLS},
+ {?WARN_CALLGRAPH, ?menuID_WARN_UNEXPORTED_FUN},
+ {?WARN_RACE_CONDITION, ?menuID_WARN_RACE_CONDITIONS},
+ %% For contracts.
+ {?WARN_CONTRACT_TYPES,?menuID_WARN_WRONG_CONTRACTS},
+ {?WARN_CONTRACT_SYNTAX, ?menuID_WARN_CONTRACT_SYNTAX}
+ ],
+ Menu = #menu{file = FileMenu,
+ warnings = WarningsMenu,
+ plt = PltMenu,
+ options =OptionsMenu,
+ help = HelpMenu},
+
+ InitPlt = try dialyzer_plt:from_file(DialyzerOptions#options.init_plt)
+ catch throw:{dialyzer_error, _} -> dialyzer_plt:new()
+ end,
+
+ #gui_state{add = AddButton,
+ add_dir = AddDirButton,
+ add_rec = AddRecButton,
+ chosen_box = ChosenBox,
+ clear_chosen = DeleteAllButton,
+ clear_log = ClearLogButton,
+ explain_warn = ExplainWarnButton,
+ clear_warn = ClearWarningsButton,
+ del_file = DeleteButton,
+ doc_plt = dialyzer_plt:new(),
+ dir_entry = DirPicker,
+ file_box = FilePicker,
+ files_to_analyze = ordsets:new(),
+ gui = Wx,
+ init_plt = InitPlt,
+ log = LogBox,
+ menu = Menu,
+ mode = FileType,
+ options = DialyzerOptions,
+ run = RunButton,
+ stop = StopButton,
+ frame = Frame,
+ warnings_box = WarningsBox,
+ wantedWarnings = Warnings,
+ rawWarnings = []}.
+
+createFileMenu() ->
+ FileMenu = wxMenu:new(),
+ wxMenu:append(FileMenu, wxMenuItem:new([{id, ?menuID_FILE_SAVE_WARNINGS},
+ {text, "Save &Warnings"}])),
+ wxMenu:append(FileMenu, wxMenuItem:new([{id, ?menuID_FILE_SAVE_LOG},
+ {text, "Save &Log"}])),
+ wxMenu:append(FileMenu, wxMenuItem:new([{id, ?menuID_FILE_QUIT},
+ {text, "E&xit\tAlt-X"}])),
+ FileMenu.
+
+createWarningsMenu() ->
+ WarningsMenu = wxMenu:new(),
+ wxMenu:appendCheckItem(WarningsMenu,
+ ?menuID_WARN_MATCH_FAILURES,
+ "Match failures"),
+ wxMenu:check(WarningsMenu, ?menuID_WARN_MATCH_FAILURES, true),
+ wxMenu:appendCheckItem(WarningsMenu,
+ ?menuID_WARN_FAIL_FUN_CALLS,
+ "Failing function calls"),
+ wxMenu:check(WarningsMenu, ?menuID_WARN_FAIL_FUN_CALLS, true),
+ wxMenu:appendCheckItem(WarningsMenu,
+ ?menuID_WARN_BAD_FUN,
+ "Bad fun applications"),
+ wxMenu:check(WarningsMenu, ?menuID_WARN_BAD_FUN, true),
+ wxMenu:appendCheckItem(WarningsMenu,
+ ?menuID_WARN_OPAQUE,
+ "Opaqueness violations"),
+ wxMenu:check(WarningsMenu, ?menuID_WARN_OPAQUE, true),
+ wxMenu:appendCheckItem(WarningsMenu,
+ ?menuID_WARN_LIST_CONSTR,
+ "Improper list constructions"),
+ wxMenu:check(WarningsMenu, ?menuID_WARN_LIST_CONSTR, true),
+ wxMenu:appendCheckItem(WarningsMenu,
+ ?menuID_WARN_UNUSED_FUN,
+ "Unused functions"),
+ wxMenu:check(WarningsMenu, ?menuID_WARN_UNUSED_FUN, true),
+ wxMenu:appendCheckItem(WarningsMenu,
+ ?menuID_WARN_ERROR_HANDLING_FUN,
+ "Error handling functions"),
+ wxMenu:appendCheckItem(WarningsMenu,
+ ?menuID_WARN_NO_RETURN_FUN,
+ "Functions of no return"),
+ wxMenu:check(WarningsMenu, ?menuID_WARN_NO_RETURN_FUN, true),
+ wxMenu:appendCheckItem(WarningsMenu,
+ ?menuID_WARN_UNEXPORTED_FUN,
+ "Call to unexported function"),
+ wxMenu:check(WarningsMenu, ?menuID_WARN_UNEXPORTED_FUN, true),
+ wxMenu:appendCheckItem(WarningsMenu,
+ ?menuID_WARN_RACE_CONDITIONS,
+ "Possible race conditions"),
+ wxMenu:appendCheckItem(WarningsMenu,
+ ?menuID_WARN_WRONG_CONTRACTS,
+ "Wrong contracts"),
+ wxMenu:check(WarningsMenu, ?menuID_WARN_WRONG_CONTRACTS, true),
+ wxMenu:appendCheckItem(WarningsMenu,
+ ?menuID_WARN_CONTRACT_SYNTAX,
+ "Wrong contract syntax"),
+ wxMenu:check(WarningsMenu, ?menuID_WARN_CONTRACT_SYNTAX, true),
+ WarningsMenu.
+
+createPltMenu() ->
+ PltMenu = wxMenu:new(),
+ wxMenu:appendCheckItem(PltMenu,
+ ?menuID_PLT_INIT_EMPTY,
+ "Init with empty PLT"),
+ wxMenu:append(PltMenu, wxMenuItem:new([{id, ?menuID_PLT_SHOW_CONTENTS},
+ {text, "Show contents"}])),
+ wxMenu:append(PltMenu, wxMenuItem:new([{id, ?menuID_PLT_SEARCH_CONTENTS},
+ {text, "Search contents"}])),
+ PltMenu.
+
+createOptionsMenu() ->
+ OptsMenu = wxMenu:new(),
+ wxMenu:append(OptsMenu, wxMenuItem:new([{id, ?menuID_OPTIONS_MACRO},
+ {text, "Manage Macro Definitions"}])),
+ wxMenu:append(OptsMenu, wxMenuItem:new([{id, ?menuID_OPTIONS_INCLUDE_DIR},
+ {text, "Manage Include Directories"}])),
+ OptsMenu.
+
+createHelpMenu() ->
+ HelpMenu = wxMenu:new(),
+ wxMenu:append(HelpMenu, wxMenuItem:new([{id, ?menuID_HELP_MANUAL},
+ {text, "Manual"}])),
+ wxMenu:append(HelpMenu, wxMenuItem:new([{id, ?menuID_HELP_WARNING_OPTIONS},
+ {text, "Warning Options"}])),
+ wxMenu:append(HelpMenu, wxMenuItem:new([{id, ?menuID_HELP_ABOUT},
+ {text, "About"}])),
+ HelpMenu.
+
+%% ----------------------------------------------------------------
+%%
+%% Main GUI Loop
+%%
+
+-spec gui_loop(#gui_state{}) -> ?RET_NOTHING_SUSPICIOUS.
+
+gui_loop(#gui_state{backend_pid = BackendPid, doc_plt = DocPlt,
+ log = Log, frame = Frame,
+ warnings_box = WarningsBox} = State) ->
+ receive
+ #wx{event = #wxClose{}} ->
+ io:format("~p Closing window ~n", [self()]),
+ ok = wxFrame:setStatusText(Frame, "Closing...",[]),
+ wxWindow:destroy(Frame),
+ ?RET_NOTHING_SUSPICIOUS;
+ %% ----- Menu -----
+ #wx{id = ?menuID_FILE_SAVE_LOG, obj = Frame,
+ event = #wxCommand{type = command_menu_selected}} ->
+ save_file(State, log),
+ gui_loop(State);
+ #wx{id=?menuID_FILE_SAVE_WARNINGS, obj=Frame,
+ event=#wxCommand{type=command_menu_selected}} ->
+ save_file(State, warnings),
+ gui_loop(State);
+ #wx{id=?menuID_FILE_QUIT, obj=Frame,
+ event=#wxCommand{type=command_menu_selected}} ->
+ case maybe_quit(State) of
+ true -> ?RET_NOTHING_SUSPICIOUS;
+ false -> gui_loop(State)
+ end;
+ #wx{id=?menuID_PLT_SHOW_CONTENTS, obj=Frame,
+ event=#wxCommand{type=command_menu_selected}} ->
+ show_doc_plt(State),
+ gui_loop(State);
+ #wx{id=?menuID_PLT_SEARCH_CONTENTS, obj=Frame,
+ event=#wxCommand{type=command_menu_selected}} ->
+ case dialyzer_plt:get_specs(DocPlt) of
+ "" -> error_sms(State, "No analysis has been made yet!\n");
+ _ -> search_doc_plt(State)
+ end,
+ gui_loop(State);
+ #wx{id=?menuID_OPTIONS_INCLUDE_DIR, obj=Frame,
+ event=#wxCommand{type=command_menu_selected}} ->
+ NewOptions = include_dialog(State),
+ NewState = State#gui_state{options = NewOptions},
+ gui_loop(NewState);
+ #wx{id=?menuID_OPTIONS_MACRO, obj=Frame,
+ event=#wxCommand{type=command_menu_selected}} ->
+ NewOptions = macro_dialog(State),
+ NewState = State#gui_state{options = NewOptions},
+ gui_loop(NewState);
+ #wx{id=?menuID_HELP_MANUAL, obj=Frame,
+ event=#wxCommand{type=command_menu_selected}} ->
+ handle_help(State, "Dialyzer Manual", "manual.txt"),
+ gui_loop(State);
+ #wx{id=?menuID_HELP_WARNING_OPTIONS, obj=Frame,
+ event=#wxCommand{type=command_menu_selected}} ->
+ handle_help(State, "Dialyzer Warnings", "warnings.txt"),
+ gui_loop(State);
+ #wx{id=?menuID_HELP_ABOUT, obj=Frame,
+ event=#wxCommand{type=command_menu_selected}} ->
+ Message = " This is DIALYZER version " ++ ?VSN ++ " \n"++
+ "DIALYZER is a DIscrepany AnaLYZer for ERlang programs.\n\n"++
+ " Copyright (C) Tobias Lindahl <[email protected]>\n"++
+ " Kostis Sagonas <[email protected]>\n\n",
+ output_sms(State, "About Dialyzer", Message, info),
+ gui_loop(State);
+ %% ------ Buttons ---------
+ #wx{id=?Add_Button,
+ event=#wxCommand{type=command_button_clicked}} ->
+ State1 = handle_add_files(State),
+ gui_loop(State1);
+ #wx{id=?AddDir_Button,
+ event=#wxCommand{type=command_button_clicked}} ->
+ State1 = handle_add_dir(State),
+ gui_loop(State1);
+ #wx{id=?AddRec_Button,
+ event=#wxCommand{type=command_button_clicked}} ->
+ State1 = handle_add_rec(State),
+ gui_loop(State1);
+ #wx{id=?Del_Button,
+ event=#wxCommand{type=command_button_clicked}} ->
+ State1 = handle_file_delete(State),
+ gui_loop(State1);
+ #wx{id=?DelAll_Button,
+ event=#wxCommand{type=command_button_clicked}} ->
+ State1 = handle_file_delete_all(State),
+ gui_loop(State1);
+ #wx{id=?ClearLog_Button,
+ event=#wxCommand{type=command_button_clicked}} ->
+ wxTextCtrl:clear(State#gui_state.log),
+ gui_loop(State);
+ #wx{id=?ExplWarn_Button,
+ event=#wxCommand{type=command_button_clicked}} ->
+ handle_explanation(State),
+ gui_loop(State);
+ #wx{id=?ClearWarn_Button,
+ event=#wxCommand{type=command_button_clicked}} ->
+ wxListBox:clear(WarningsBox),
+ NewState = State#gui_state{rawWarnings = []},
+ gui_loop(NewState);
+ #wx{id=?Run_Button,
+ event=#wxCommand{type=command_button_clicked}} ->
+ NewState = start_analysis(State),
+ gui_loop(NewState);
+ #wx{id=?Stop_Button,
+ event=#wxCommand{type=command_button_clicked}} ->
+ BackendPid ! {self(), stop},
+ config_gui_stop(State),
+ update_editor(Log, "\n***** Analysis stopped ****\n"),
+ gui_loop(State);
+ %% ----- Analysis -----
+ {BackendPid, ext_calls, ExtCalls} ->
+ Msg = io_lib:format("The following functions are called "
+ "but type information about them is not available.\n"
+ "The analysis might get more precise by including "
+ "the modules containing these functions:\n\n\t~p\n",
+ [ExtCalls]),
+ free_editor(State,"Analysis Done", Msg),
+ gui_loop(State);
+ {BackendPid, log, LogMsg} ->
+ update_editor(Log, LogMsg),
+ gui_loop(State);
+ {BackendPid, warnings, Warns} ->
+ SortedWarns = lists:keysort(2, Warns), %% Sort on file/line
+ NewState = add_warnings(State, SortedWarns),
+ gui_loop(NewState);
+ {BackendPid, cserver, CServer, Plt} ->
+ Self = self(),
+ Fun =
+ fun() ->
+ dialyzer_explanation:expl_loop(Self, CServer, Plt)
+ end,
+ ExplanationPid = spawn_link(Fun),
+ gui_loop(State#gui_state{expl_pid = ExplanationPid});
+ {BackendPid, done, _NewPlt, NewDocPlt} ->
+ message(State, "Analysis done"),
+ config_gui_stop(State),
+ gui_loop(State#gui_state{doc_plt = NewDocPlt});
+ {'EXIT', BackendPid, {error, Reason}} ->
+ free_editor(State, ?DIALYZER_ERROR_TITLE, Reason),
+ config_gui_stop(State),
+ gui_loop(State);
+ {'EXIT', BackendPid, Reason} when Reason =/= 'normal' ->
+ free_editor(State, ?DIALYZER_ERROR_TITLE, io_lib:format("~p", [Reason])),
+ config_gui_stop(State),
+ gui_loop(State)
+ end.
+
+maybe_quit(#gui_state{frame = Frame} = State) ->
+ case dialog(State, "Do you really want to quit?", ?DIALYZER_MESSAGE_TITLE) of
+ true ->
+ wxWindow:destroy(Frame),
+ true;
+ false ->
+ false
+ end.
+
+%% ------------ Yes/No Question ------------
+dialog(#gui_state{frame = Frame}, Message, Title) ->
+ MessageWin = wxMessageDialog:new(Frame,Message,[{caption, Title},{style, ?wxYES_NO bor ?wxICON_QUESTION bor ?wxNO_DEFAULT}]),
+ case wxDialog:showModal(MessageWin) of
+ ?wxID_YES ->
+ true;
+ ?wxID_NO ->
+ false;
+ ?wxID_CANCEL ->
+ false
+ end.
+
+search_doc_plt(#gui_state{gui = Wx} = State) ->
+ Dialog = wxFrame:new(Wx, ?SearchPltDialog, "Search the PLT",[{size,{400,100}},{style, ?wxSTAY_ON_TOP}]),
+ Size = {size,{120,30}},
+ ModLabel = wxStaticText:new(Dialog, ?ModLabel, "Module"),
+ ModText = wxTextCtrl:new(Dialog, ?ModText,[Size]),
+ FunLabel = wxStaticText:new(Dialog, ?FunLabel, "Function"),
+ FunText = wxTextCtrl:new(Dialog, ?FunText,[Size]),
+ ArLabel = wxStaticText:new(Dialog, ?ArLabel, "Arity"),
+ ArText = wxTextCtrl:new(Dialog, ?ArText,[Size]),
+ SearchButton = wxButton:new(Dialog, ?SearchButton, [{label, "Search"}]),
+ wxButton:connect(SearchButton, command_button_clicked),
+ Cancel = wxButton:new(Dialog, ?Search_Cancel, [{label, "Cancel"}]),
+ wxButton:connect(Cancel, command_button_clicked),
+
+ Layout = wxBoxSizer:new(?wxVERTICAL),
+ Top = wxBoxSizer:new(?wxHORIZONTAL),
+ ModLayout = wxBoxSizer:new(?wxVERTICAL),
+ FunLayout = wxBoxSizer:new(?wxVERTICAL),
+ ArLayout = wxBoxSizer:new(?wxVERTICAL),
+ Buttons = wxBoxSizer:new(?wxHORIZONTAL),
+
+ wxSizer:add(ModLayout, ModLabel, ?BorderOpt),
+ wxSizer:add(ModLayout,ModText, ?BorderOpt),
+ wxSizer:add(FunLayout, FunLabel, ?BorderOpt),
+ wxSizer:add(FunLayout,FunText, ?BorderOpt),
+ wxSizer:add(ArLayout, ArLabel, ?BorderOpt),
+ wxSizer:add(ArLayout,ArText, ?BorderOpt),
+ wxSizer:add(Buttons, SearchButton, ?BorderOpt),
+ wxSizer:add(Buttons,Cancel, ?BorderOpt),
+
+ wxSizer:add(Top, ModLayout),
+ wxSizer:add(Top, FunLayout),
+ wxSizer:add(Top, ArLayout),
+ wxSizer:add(Layout, Top,[{flag, ?wxALIGN_CENTER}]),
+ wxSizer:add(Layout, Buttons,[{flag, ?wxALIGN_CENTER bor ?wxBOTTOM}]),
+ wxFrame:connect(Dialog, close_window),
+ wxWindow:setSizer(Dialog, Layout),
+ wxFrame:show(Dialog),
+ search_plt_loop(State, Dialog, ModText, FunText, ArText, SearchButton, Cancel).
+
+search_plt_loop(State= #gui_state{doc_plt = DocPlt, frame = Frame}, Win, ModText, FunText, ArText, Search, Cancel) ->
+ receive
+ #wx{id = ?Search_Cancel,
+ event = #wxCommand{type = command_button_clicked}} ->
+ wxWindow:destroy(Win);
+ #wx{id = ?SearchPltDialog, event = #wxClose{type = close_window}} ->
+ wxWindow:destroy(Win);
+ #wx{event = #wxClose{type = close_window}} ->
+ wxWindow:destroy(Win),
+ wxWindow:destroy(Frame);
+ #wx{id = ?SearchButton,
+ event = #wxCommand{type = command_button_clicked}} ->
+ M = format_search(wxTextCtrl:getValue(ModText)),
+ F = format_search(wxTextCtrl:getValue(FunText)),
+ A = format_search(wxTextCtrl:getValue(ArText)),
+
+ if
+ (M == '_') or (F == '_') or (A == '_') ->
+ error_sms(State, "Please give:\n Module (atom)\n Function (atom)\n Arity (integer)\n"),
+ search_plt_loop(State, Win, ModText, FunText, ArText, Search, Cancel);
+ true ->
+ case dialyzer_plt:get_specs(DocPlt, M, F, A) of
+ none ->
+ error_sms(State, "No such function"),
+ search_plt_loop(State, Win, ModText, FunText, ArText, Search, Cancel);
+ NonEmptyString ->
+ wxWindow:destroy(Win),
+ free_editor(State, "Content of PLT", NonEmptyString)
+ end
+ end
+ end.
+
+format_search([]) ->
+ '_';
+format_search(String) ->
+ try list_to_integer(String)
+ catch error:_ -> list_to_atom(String)
+ end.
+
+show_doc_plt(#gui_state{doc_plt = DocPLT} = State) ->
+ case dialyzer_plt:get_specs(DocPLT) of
+ "" -> error_sms(State, "No analysis has been made yet!\n");
+ NonEmptyString -> free_editor(State, "Content of PLT", NonEmptyString)
+ end.
+
+message(State, Message) ->
+ output_sms(State, ?DIALYZER_MESSAGE_TITLE, Message, info).
+
+error_sms(State, Message) ->
+ output_sms(State, ?DIALYZER_ERROR_TITLE, Message, error).
+
+output_sms(#gui_state{frame = Frame}, Title, Message, Type) ->
+ case Type of
+ error ->
+ MessageWin = wxMessageDialog:new(Frame,Message,[{caption, Title},{style, ?wxOK bor ?wxICON_ERROR}]);
+ info ->
+ MessageWin = wxMessageDialog:new(Frame,Message,[{caption, Title},{style, ?wxOK bor ?wxICON_INFORMATION}])
+ end,
+ wxWindow:setSizeHints(MessageWin, {350,100}),
+ wxDialog:showModal(MessageWin).
+
+free_editor(#gui_state{gui = Wx, frame = Frame}, Title, Contents0) ->
+ Contents = lists:flatten(Contents0),
+ Tokens = string:tokens(Contents, "\n"),
+ NofLines = length(Tokens),
+ LongestLine = lists:max([length(X) || X <- Tokens]),
+ Height0 = NofLines * 25 + 80,
+ Height = if Height0 > 500 -> 500; true -> Height0 end,
+ Width0 = LongestLine * 7 + 60,
+ Width = if Width0 > 800 -> 800; true -> Width0 end,
+ Size = {size,{Width, Height}},
+ Win = wxFrame:new(Wx, ?Message, Title, [{size,{Width+4, Height+50}}]),
+
+ Editor = wxTextCtrl:new(Win, ?Message_Info,
+ [Size,
+ {style, ?wxTE_MULTILINE
+ bor ?wxTE_READONLY bor ?wxVSCROLL bor ?wxEXPAND}]),
+ wxTextCtrl:appendText(Editor, Contents),
+ wxFrame:connect(Win, close_window),
+ Ok = wxButton:new(Win, ?Message_Ok, [{label, "OK"}]),
+ wxButton:connect(Ok, command_button_clicked),
+ Layout = wxBoxSizer:new(?wxVERTICAL),
+
+ wxSizer:add(Layout, Editor, ?BorderOpt),
+ wxSizer:add(Layout, Ok, [{flag, ?wxALIGN_CENTER bor ?wxBOTTOM bor ?wxALL}, ?Border]),
+ wxWindow:setSizer(Win, Layout),
+ wxWindow:show(Win),
+ show_info_loop(Frame, Win).
+
+show_info_loop(Frame, Win) ->
+ receive
+ #wx{id = ?Message_Ok, event = #wxCommand{type = command_button_clicked}} ->
+ wxWindow:destroy(Win);
+ #wx{id = ?Message, event = #wxClose{type = close_window}} ->
+ wxWindow:destroy(Win);
+ #wx{event = #wxClose{type = close_window}} ->
+ wxWindow:destroy(Frame)
+ end.
+
+handle_add_files(#gui_state{chosen_box = ChosenBox, file_box = FileBox,
+ files_to_analyze = FileList,
+ mode = Mode} = State) ->
+ case wxFilePickerCtrl:getPath(FileBox) of
+ "" ->
+ State;
+ File ->
+ NewFile = ordsets:new(),
+ NewFile1 = ordsets:add_element(File,NewFile),
+ Ext =
+ case wxRadioBox:getSelection(Mode) of
+ 0 -> ".beam";
+ 1-> ".erl"
+ end,
+ State#gui_state{files_to_analyze = add_files(filter_mods(NewFile1, Ext), FileList, ChosenBox, Ext)}
+ end.
+
+handle_add_dir(#gui_state{chosen_box = ChosenBox, dir_entry = DirBox,
+ files_to_analyze = FileList,
+ mode = Mode} = State) ->
+ case wxDirPickerCtrl:getPath(DirBox) of
+ "" ->
+ State;
+ Dir ->
+ NewDir = ordsets:new(),
+ NewDir1 = ordsets:add_element(Dir,NewDir),
+ Ext = case wxRadioBox:getSelection(Mode) of
+ 0 -> ".beam";
+ 1-> ".erl"
+ end,
+ State#gui_state{files_to_analyze = add_files(filter_mods(NewDir1,Ext), FileList, ChosenBox, Ext)}
+ end.
+
+handle_add_rec(#gui_state{chosen_box = ChosenBox, dir_entry = DirBox, files_to_analyze = FileList,
+ mode = Mode} = State) ->
+ case wxDirPickerCtrl:getPath(DirBox) of
+ "" ->
+ State;
+ Dir ->
+ NewDir = ordsets:new(),
+ NewDir1 = ordsets:add_element(Dir,NewDir),
+ TargetDirs = ordsets:union(NewDir1, all_subdirs(NewDir1)),
+ case wxRadioBox:getSelection(Mode) of
+ 0 -> Ext = ".beam";
+ 1-> Ext = ".erl"
+ end,
+ State#gui_state{files_to_analyze = add_files(filter_mods(TargetDirs,Ext), FileList, ChosenBox, Ext)}
+ end.
+
+handle_file_delete(#gui_state{chosen_box = ChosenBox,
+ files_to_analyze = FileList} = State) ->
+ {_, List} = wxListBox:getSelections(ChosenBox),
+ Set = ordsets:from_list([wxControlWithItems:getString(ChosenBox, X) || X <- List]),
+ FileList1 = ordsets:subtract(FileList,Set),
+ lists:foreach(fun (X) -> wxListBox:delete(ChosenBox, X) end, List),
+ State#gui_state{files_to_analyze = FileList1}.
+
+handle_file_delete_all(#gui_state{chosen_box = ChosenBox} = State) ->
+ wxListBox:clear(ChosenBox),
+ State#gui_state{files_to_analyze = ordsets:new()}.
+
+add_files(File, FileList, ChosenBox, Ext) ->
+ Set = filter_mods(FileList, Ext),
+ Files = ordsets:union(File, Set),
+ Files1 = ordsets:to_list(Files),
+ wxListBox:set(ChosenBox, Files1),
+ Files.
+
+filter_mods(Mods, Extension) ->
+ Fun = fun(X) ->
+ filename:extension(X) =:= Extension
+ orelse
+ (filelib:is_dir(X) andalso
+ contains_files(X, Extension))
+ end,
+ ordsets:filter(Fun, Mods).
+
+contains_files(Dir, Extension) ->
+ {ok, Files} = file:list_dir(Dir),
+ lists:any(fun(X) -> filename:extension(X) =:= Extension end, Files).
+
+all_subdirs(Dirs) ->
+ all_subdirs(Dirs, []).
+
+all_subdirs([Dir|T], Acc) ->
+ {ok, Files} = file:list_dir(Dir),
+ SubDirs = lists:zf(fun(F) ->
+ SubDir = filename:join(Dir, F),
+ case filelib:is_dir(SubDir) of
+ true -> {true, SubDir};
+ false -> false
+ end
+ end, Files),
+ NewAcc = ordsets:union(ordsets:from_list(SubDirs), Acc),
+ all_subdirs(T ++ SubDirs, NewAcc);
+all_subdirs([], Acc) ->
+ Acc.
+
+start_analysis(State) ->
+ Analysis = build_analysis_record(State),
+ case get_anal_files(State, Analysis#analysis.start_from) of
+ error ->
+ Msg = "You must choose one or more files or dirs\n"
+ "before starting the analysis!",
+ error_sms(State, Msg),
+ config_gui_stop(State),
+ State;
+ {ok, Files} ->
+ Msg = "\n========== Starting Analysis ==========\n\n",
+ update_editor(State#gui_state.log, Msg),
+ NewAnalysis = Analysis#analysis{files = Files},
+ run_analysis(State, NewAnalysis)
+ end.
+
+build_analysis_record(#gui_state{mode = Mode, menu = Menu, options = Options,
+ init_plt = InitPlt0}) ->
+ StartFrom =
+ case wxRadioBox:getSelection(Mode) of
+ 0 -> byte_code;
+ 1 -> src_code
+ end,
+ InitPlt =
+ case wxMenu:isChecked(Menu#menu.plt,?menuID_PLT_INIT_EMPTY) of
+ true -> dialyzer_plt:new();
+ false -> InitPlt0
+ end,
+ #analysis{defines = Options#options.defines,
+ include_dirs = Options#options.include_dirs,
+ plt = InitPlt,
+ start_from = StartFrom}.
+
+get_anal_files(#gui_state{files_to_analyze = Files}, StartFrom) ->
+ FilteredMods =
+ case StartFrom of
+ src_code -> filter_mods(Files, ".erl");
+ byte_code -> filter_mods(Files, ".beam")
+ end,
+ FilteredDirs = [X || X <- Files, filelib:is_dir(X)],
+ case ordsets:union(FilteredMods, FilteredDirs) of
+ [] -> error;
+ Set -> {ok, Set}
+ end.
+
+run_analysis(State, Analysis) ->
+ config_gui_start(State),
+ Self = self(),
+ NewAnalysis = Analysis#analysis{doc_plt = dialyzer_plt:new()},
+ LegalWarnings = find_legal_warnings(State),
+ Fun =
+ fun() ->
+ dialyzer_analysis_callgraph:start(Self, LegalWarnings, NewAnalysis)
+ end,
+ BackendPid = spawn_link(Fun),
+ State#gui_state{backend_pid = BackendPid}.
+
+find_legal_warnings(#gui_state{menu = #menu{warnings = MenuWarnings},
+ wantedWarnings = Warnings }) ->
+ ordsets:from_list([Tag || {Tag, MenuItem} <- Warnings,
+ wxMenu:isChecked(MenuWarnings, MenuItem)]).
+
+update_editor(Editor, Msg) ->
+ wxTextCtrl:appendText(Editor,Msg).
+
+config_gui_stop(State) ->
+ wxWindow:disable(State#gui_state.stop),
+ wxWindow:enable(State#gui_state.run),
+ wxWindow:enable(State#gui_state.del_file),
+ wxWindow:enable(State#gui_state.clear_chosen),
+ wxWindow:enable(State#gui_state.add),
+ wxWindow:enable(State#gui_state.add_dir),
+ wxWindow:enable(State#gui_state.add_rec),
+ wxWindow:enable(State#gui_state.clear_warn),
+ wxWindow:enable(State#gui_state.clear_log),
+ Menu = State#gui_state.menu,
+ wxMenu:enable(Menu#menu.file,?menuID_FILE_SAVE_WARNINGS,true),
+ wxMenu:enable(Menu#menu.file,?menuID_FILE_SAVE_LOG,true),
+ wxMenu:enable(Menu#menu.options,?menuID_OPTIONS_MACRO,true),
+ wxMenu:enable(Menu#menu.options,?menuID_OPTIONS_INCLUDE_DIR,true),
+ wxMenu:enable(Menu#menu.plt,?menuID_PLT_INIT_EMPTY,true),
+ wxMenu:enable(Menu#menu.plt,?menuID_PLT_SHOW_CONTENTS,true),
+ wxMenu:enable(Menu#menu.plt,?menuID_PLT_SEARCH_CONTENTS,true),
+ wxRadioBox:enable(State#gui_state.mode).
+
+config_gui_start(State) ->
+ wxWindow:enable(State#gui_state.stop),
+ wxWindow:disable(State#gui_state.run),
+ wxWindow:disable(State#gui_state.del_file),
+ wxWindow:disable(State#gui_state.clear_chosen),
+ wxWindow:disable(State#gui_state.add),
+ wxWindow:disable(State#gui_state.add_dir),
+ wxWindow:disable(State#gui_state.add_rec),
+ wxWindow:disable(State#gui_state.clear_warn),
+ wxWindow:disable(State#gui_state.clear_log),
+ Menu = State#gui_state.menu,
+ wxMenu:enable(Menu#menu.file,?menuID_FILE_SAVE_WARNINGS, false),
+ wxMenu:enable(Menu#menu.file,?menuID_FILE_SAVE_LOG, false),
+ wxMenu:enable(Menu#menu.options,?menuID_OPTIONS_MACRO, false),
+ wxMenu:enable(Menu#menu.options,?menuID_OPTIONS_INCLUDE_DIR, false),
+ wxMenu:enable(Menu#menu.plt,?menuID_PLT_INIT_EMPTY, false),
+ wxMenu:enable(Menu#menu.plt,?menuID_PLT_SHOW_CONTENTS, false),
+ wxMenu:enable(Menu#menu.plt,?menuID_PLT_SEARCH_CONTENTS, false),
+ wxRadioBox:disable(State#gui_state.mode).
+
+save_file(#gui_state{frame = Frame, warnings_box = WBox, log = Log} = State, Type) ->
+ case Type of
+ warnings ->
+ Message = "Save Warnings",
+ Box = WBox;
+ log -> Message = "Save Log",
+ Box = Log
+ end,
+ case wxTextCtrl:getValue(Box) of
+ "" -> error_sms(State,"There is nothing to save...\n");
+ _ ->
+ DefaultPath = code:root_dir(),
+ FileDialog = wxFileDialog:new(Frame,
+ [{defaultDir, DefaultPath},
+ {message, Message},
+ {style,?wxFD_SAVE bor ?wxFD_OVERWRITE_PROMPT}]),
+ case wxFileDialog:showModal(FileDialog) of
+ ?wxID_OK -> Path = wxFileDialog:getPath(FileDialog),
+ case wxTextCtrl:saveFile(Box,[{file,Path}]) of
+ true -> ok;
+ false -> error_sms(State,"Could not write to file:\n" ++ Path)
+ end;
+ ?wxID_CANCEL -> wxWindow:destroy(FileDialog);
+ _ -> error_sms(State,"Could not write to file:\n")
+ end
+ end.
+
+include_dialog(#gui_state{gui = Wx, frame = Frame, options = Options}) ->
+ Size = {size,{300,480}},
+ Dialog = wxFrame:new(Wx, ?IncludeDir, "Include Directories",[Size]),
+ DirLabel = wxStaticText:new(Dialog, ?InclLabel, "Directory: "),
+ DefaultPath = code:root_dir(),
+ DirPicker = wxDirPickerCtrl:new(Dialog, ?InclPicker,
+ [{path, DefaultPath},
+ {message, "Choose Directory to Include"},
+ {style,?wxDIRP_DIR_MUST_EXIST bor ?wxDIRP_USE_TEXTCTRL}]),
+ Box = wxListBox:new(Dialog, ?InclBox,
+ [{size, {200,300}},
+ {style, ?wxLB_EXTENDED bor ?wxLB_HSCROLL
+ bor ?wxLB_NEEDED_SB}]),
+ AddButton = wxButton:new(Dialog, ?InclAdd, [{label, "Add"}]),
+ DeleteButton = wxButton:new(Dialog, ?InclDel, [{label, "Delete"}]),
+ DeleteAllButton = wxButton:new(Dialog, ?InclDelAll, [{label, "Delete All"}]),
+ Ok = wxButton:new(Dialog, ?InclOk, [{label, "OK"}]),
+ Cancel = wxButton:new(Dialog, ?InclCancel, [{label, "Cancel"}]),
+ wxButton:connect(AddButton, command_button_clicked),
+ wxButton:connect(DeleteButton, command_button_clicked),
+ wxButton:connect(DeleteAllButton, command_button_clicked),
+ wxButton:connect(Ok, command_button_clicked),
+ wxButton:connect(Cancel, command_button_clicked),
+ Dirs = [io_lib:format("~s", [X])
+ || X <- Options#options.include_dirs],
+ wxListBox:set(Box, Dirs),
+ Layout = wxBoxSizer:new(?wxVERTICAL),
+ Buttons = wxBoxSizer:new(?wxHORIZONTAL),
+ Buttons1 = wxBoxSizer:new(?wxHORIZONTAL),
+
+ wxSizer:add(Layout, DirLabel, [{flag, ?wxALIGN_CENTER_HORIZONTAL}]),
+ wxSizer:add(Layout, DirPicker, [{flag, ?wxALIGN_CENTER_HORIZONTAL}]),
+ wxSizer:add(Layout,AddButton, [{flag, ?wxALIGN_CENTER_HORIZONTAL bor ?wxALL}, ?Border]),
+ wxSizer:add(Layout,Box, [{flag, ?wxALIGN_CENTER_HORIZONTAL bor ?wxALL}, ?Border]),
+ wxSizer:add(Buttons, DeleteButton, ?BorderOpt),
+ wxSizer:add(Buttons, DeleteAllButton, ?BorderOpt),
+ wxSizer:add(Layout,Buttons, [{flag, ?wxALIGN_CENTER_HORIZONTAL}]),
+ wxSizer:add(Buttons1, Ok, ?BorderOpt),
+ wxSizer:add(Buttons1,Cancel, ?BorderOpt),
+ wxSizer:add(Layout,Buttons1,[{flag, ?wxALIGN_RIGHT bor ?wxBOTTOM}]),
+
+ wxFrame:connect(Dialog, close_window),
+ wxWindow:setSizer(Dialog, Layout),
+ wxFrame:show(Dialog),
+ include_loop(Options, Dialog, Box, DirPicker, Frame).
+
+include_loop(Options, Win, Box, DirPicker, Frame) ->
+ receive
+ #wx{id = ?InclCancel,
+ event = #wxCommand{type = command_button_clicked}} ->
+ wxWindow:destroy(Win),
+ Options;
+ #wx{id = ?IncludeDir, event = #wxClose{type = close_window}} ->
+ wxWindow:destroy(Win),
+ Options;
+ #wx{event = #wxClose{type = close_window}} ->
+ wxWindow:destroy(Win),
+ wxWindow:destroy(Frame);
+ #wx{id = ?InclOk,
+ event = #wxCommand{type = command_button_clicked}} ->
+ wxWindow:destroy(Win),
+ Options;
+ #wx{id = ?InclAdd,
+ event = #wxCommand{type = command_button_clicked}} ->
+ Dirs = Options#options.include_dirs,
+ NewDirs =
+ case wxDirPickerCtrl:getPath(DirPicker) of
+ "" -> Dirs;
+ Add -> [Add|Dirs]
+ end,
+ NewOptions = Options#options{include_dirs = NewDirs},
+ wxListBox:set(Box, NewDirs),
+ include_loop(NewOptions, Win, Box, DirPicker, Frame);
+ #wx{id = ?InclDel,
+ event = #wxCommand{type = command_button_clicked}} ->
+ NewOptions =
+ case wxListBox:getSelections(Box) of
+ {0,_} -> Options;
+ {_,List} ->
+ DelList = [wxControlWithItems:getString(Box,X) || X <- List],
+ NewDirs = Options#options.include_dirs -- DelList,
+ lists:foreach(fun (X) -> wxListBox:delete(Box, X) end, List),
+ Options#options{include_dirs = NewDirs}
+ end,
+ include_loop(NewOptions, Win, Box, DirPicker, Frame);
+ #wx{id = ?InclDelAll,
+ event = #wxCommand{type = command_button_clicked}} ->
+ wxListBox:clear(Box),
+ NewOptions = Options#options{include_dirs = []},
+ include_loop(NewOptions, Win, Box, DirPicker, Frame)
+ end.
+
+macro_dialog(#gui_state{gui = Wx, frame = Frame, options = Options}) ->
+ Size = {size,{300,480}},
+ Size1 = {size,{120,30}},
+ Dialog = wxFrame:new(Wx, ?MacroDir, "Macro Definitions",[Size]),
+ MacroLabel = wxStaticText:new(Dialog, ?MacroLabel, "Macro"),
+ TermLabel = wxStaticText:new(Dialog, ?TermLabel, "Term"),
+ MacroText = wxTextCtrl:new(Dialog, ?MacroText, [Size1]),
+ TermText = wxTextCtrl:new(Dialog, ?TermText, [Size1]),
+ Box = wxListBox:new(Dialog, ?MacroBox,
+ [{size, {250,300}},
+ {style, ?wxLB_EXTENDED bor ?wxLB_HSCROLL
+ bor ?wxLB_NEEDED_SB}]),
+
+ AddButton = wxButton:new(Dialog, ?MacroAdd, [{label, "Add"}]),
+ DeleteButton = wxButton:new(Dialog, ?MacroDel, [{label, "Delete"}]),
+ DeleteAllButton = wxButton:new(Dialog, ?MacroDelAll, [{label, "Delete All"}]),
+ Ok = wxButton:new(Dialog, ?MacroOk, [{label, "OK"}]),
+ Cancel = wxButton:new(Dialog, ?MacroCancel, [{label, "Cancel"}]),
+ wxButton:connect(AddButton, command_button_clicked),
+ wxButton:connect(DeleteButton, command_button_clicked),
+ wxButton:connect(DeleteAllButton, command_button_clicked),
+ wxButton:connect(Ok, command_button_clicked),
+ wxButton:connect(Cancel, command_button_clicked),
+
+ Macros = [io_lib:format("~p = ~p", [X, Y])
+ || {X,Y} <- Options#options.defines],
+
+ wxListBox:set(Box, Macros),
+ Layout = wxBoxSizer:new(?wxVERTICAL),
+ Item = wxBoxSizer:new(?wxHORIZONTAL),
+ MacroItem = wxBoxSizer:new(?wxVERTICAL),
+ TermItem = wxBoxSizer:new(?wxVERTICAL),
+ Buttons = wxBoxSizer:new(?wxHORIZONTAL),
+ Buttons1 = wxBoxSizer:new(?wxHORIZONTAL),
+
+ wxSizer:add(MacroItem, MacroLabel, ?BorderOpt),
+ wxSizer:add(MacroItem, MacroText, ?BorderOpt),
+ wxSizer:add(TermItem, TermLabel, ?BorderOpt),
+ wxSizer:add(TermItem, TermText, ?BorderOpt),
+ wxSizer:add(Item, MacroItem),
+ wxSizer:add(Item, TermItem),
+ wxSizer:add(Layout, Item, [{flag, ?wxALIGN_CENTER_HORIZONTAL}]),
+ wxSizer:add(Layout, AddButton, [{flag, ?wxALIGN_CENTER_HORIZONTAL bor ?wxALL}, ?Border]),
+ wxSizer:add(Layout, Box, [{flag, ?wxALIGN_CENTER_HORIZONTAL bor ?wxALL}, ?Border]),
+ wxSizer:add(Buttons, DeleteButton, ?BorderOpt),
+ wxSizer:add(Buttons, DeleteAllButton, ?BorderOpt),
+ wxSizer:add(Layout, Buttons, [{flag, ?wxALIGN_CENTER_HORIZONTAL}]),
+ wxSizer:add(Buttons1, Ok, ?BorderOpt),
+ wxSizer:add(Buttons1, Cancel, ?BorderOpt),
+ wxSizer:add(Layout, Buttons1, [{flag, ?wxALIGN_RIGHT bor ?wxBOTTOM}]),
+
+ wxFrame:connect(Dialog, close_window),
+ wxWindow:setSizer(Dialog, Layout),
+ wxFrame:show(Dialog),
+ macro_loop(Options, Dialog, Box, MacroText, TermText, Frame).
+
+macro_loop(Options, Win, Box, MacroText, TermText, Frame) ->
+ receive
+ #wx{id = ?MacroCancel,
+ event = #wxCommand{type = command_button_clicked}} ->
+ wxWindow:destroy(Win),
+ Options;
+ #wx{id = ?MacroDir, event = #wxClose{type = close_window}} ->
+ wxWindow:destroy(Win),
+ Options;
+ #wx{event = #wxClose{type = close_window}} ->
+ wxWindow:destroy(Win),
+ wxWindow:destroy(Frame);
+ #wx{id = ?MacroOk,
+ event = #wxCommand{type = command_button_clicked}} ->
+ wxWindow:destroy(Win),
+ Options;
+ #wx{id = ?MacroAdd,
+ event = #wxCommand{type = command_button_clicked}} ->
+ Defines = Options#options.defines,
+ NewDefines =
+ case wxTextCtrl:getValue(MacroText) of
+ "" -> Defines;
+ Macro ->
+ case wxTextCtrl:getValue(TermText) of
+ "" ->
+ orddict:store(list_to_atom(Macro), true, Defines);
+ String ->
+ orddict:store(list_to_atom(Macro), String, Defines)
+ end
+ end,
+ NewOptions = Options#options{defines = NewDefines},
+ NewEntries = [io_lib:format("~p = ~p", [X, Y]) || {X, Y} <- NewDefines],
+ wxListBox:set(Box, NewEntries),
+ macro_loop(NewOptions, Win, Box, MacroText, TermText, Frame);
+ #wx{id = ?MacroDel,
+ event = #wxCommand{type = command_button_clicked}} ->
+ NewOptions =
+ case wxListBox:getSelections(Box) of
+ {0, _} -> Options;
+ {_, List} ->
+ Fun =
+ fun(X) ->
+ Val = wxControlWithItems:getString(Box,X),
+ [MacroName|_] = re:split(Val, " ", [{return, list}]),
+ list_to_atom(MacroName)
+ end,
+ Delete = [Fun(X) || X <- List],
+ lists:foreach(fun (X) -> wxListBox:delete(Box, X) end, List),
+ Defines = Options#options.defines,
+ NewDefines = lists:foldl(fun(X, Acc) ->
+ orddict:erase(X, Acc)
+ end,
+ Defines, Delete),
+ Options#options{defines = NewDefines}
+ end,
+ macro_loop(NewOptions, Win, Box, MacroText, TermText, Frame);
+ #wx{id = ?MacroDelAll,
+ event = #wxCommand{type = command_button_clicked}} ->
+ wxListBox:clear(Box),
+ NewOptions = Options#options{defines = []},
+ macro_loop(NewOptions, Win, Box, MacroText, TermText, Frame)
+ end.
+
+handle_help(State, Title, Txt) ->
+ FileName = filename:join([code:lib_dir(dialyzer), "doc", Txt]),
+ case file:open(FileName, [read]) of
+ {error, Reason} ->
+ error_sms(State,
+ io_lib:format("Could not find doc/~s file!\n\n ~p",
+ [Txt, Reason]));
+ {ok, _Handle} ->
+ case file:read_file(FileName) of
+ {error, Reason} ->
+ error_sms(State,
+ io_lib:format("Could not read doc/~s file!\n\n ~p",
+ [Txt, Reason]));
+ {ok, Binary} ->
+ Contents = binary_to_list(Binary),
+ free_editor(State, Title, Contents)
+ end
+ end.
+
+add_warnings(#gui_state{warnings_box = WarnBox,
+ rawWarnings = RawWarns} = State, Warnings) ->
+ NewRawWarns = RawWarns ++ Warnings,
+ WarnList = [dialyzer:format_warning(W) -- "\n" || W <- NewRawWarns],
+ wxListBox:set(WarnBox, WarnList),
+ State#gui_state{rawWarnings = NewRawWarns}.
+
+handle_explanation(#gui_state{rawWarnings = RawWarns,
+ warnings_box = WarnBox,
+ expl_pid = ExplPid} = State) ->
+ case wxListBox:isEmpty(WarnBox) of
+ true -> error_sms(State, "\nThere are no warnings.\nRun the dialyzer first.");
+ false ->
+ case wxListBox:getSelections(WarnBox)of
+ {0, []} ->
+ error_sms(State,"\nYou must choose a warning to be explained\n");
+ {_, [WarnNumber]} ->
+ Warn = lists:nth(WarnNumber+1,RawWarns),
+ Self = self(),
+ ExplPid ! {Self, warning, Warn},
+ explanation_loop(State)
+ end
+ end.
+
+explanation_loop(#gui_state{expl_pid = ExplPid} = State) ->
+ receive
+ {ExplPid, explanation, Explanation} ->
+ show_explanation(State, Explanation);
+ _ -> io:format("Unknown message\n"),
+ explanation_loop(State)
+ end.
+
+show_explanation(#gui_state{gui = Wx} = State, Explanation) ->
+ case Explanation of
+ none ->
+ output_sms(State, ?DIALYZER_MESSAGE_TITLE,
+ "There is not any explanation for this error!\n", info);
+ Expl ->
+ ExplString = format_explanation(Expl),
+ Size = {size,{700, 300}},
+ Win = wxFrame:new(Wx, ?ExplWin, "Dialyzer Explanation", [{size,{740, 350}}]),
+
+ Editor = wxTextCtrl:new(Win, ?ExplText,
+ [Size,
+ {style, ?wxTE_MULTILINE
+ bor ?wxTE_READONLY bor ?wxVSCROLL bor ?wxEXPAND}]),
+ wxTextCtrl:appendText(Editor, ExplString),
+ wxFrame:connect(Win, close_window),
+ ExplButton = wxButton:new(Win, ?ExplButton, [{label, "Further Explain"}]),
+ wxButton:connect(ExplButton, command_button_clicked),
+ Ok = wxButton:new(Win, ?ExplOk, [{label, "OK"}]),
+ wxButton:connect(Ok, command_button_clicked),
+ Layout = wxBoxSizer:new(?wxVERTICAL),
+ Buttons = wxBoxSizer:new(?wxHORIZONTAL),
+ wxSizer:add(Buttons, ExplButton, ?BorderOpt),
+ wxSizer:add(Buttons, Ok, ?BorderOpt),
+ wxSizer:add(Layout, Editor,[{flag, ?wxALIGN_CENTER_HORIZONTAL bor ?wxALL}, ?Border]),
+ wxSizer:add(Layout, Buttons,[{flag, ?wxALIGN_CENTER_HORIZONTAL}]),
+ wxWindow:setSizer(Win, Layout),
+ wxWindow:show(Win),
+ show_explanation_loop(State#gui_state{explanation_box = Editor}, Win, Explanation)
+ end.
+
+show_explanation_loop(#gui_state{frame = Frame, expl_pid = ExplPid} = State, Win, Explanation) ->
+ receive
+ {ExplPid, none, _} ->
+ output_sms(State, ?DIALYZER_MESSAGE_TITLE,
+ "There is not any other explanation for this error!\n", info),
+ show_explanation_loop(State, Win, Explanation);
+ {ExplPid, further, NewExplanation} ->
+ update_explanation(State, NewExplanation),
+ show_explanation_loop(State, Win, NewExplanation);
+ #wx{id = ?ExplButton, event = #wxCommand{type = command_button_clicked}} ->
+ ExplPid ! {self(), further, Explanation},
+ show_explanation_loop(State, Win, Explanation);
+ #wx{id = ?ExplOk, event = #wxCommand{type = command_button_clicked}} ->
+ wxWindow:destroy(Win);
+ #wx{id = ?ExplWin, event = #wxClose{type = close_window}} ->
+ wxWindow:destroy(Win);
+ #wx{event = #wxClose{type = close_window}} ->
+ wxWindow:destroy(Frame)
+ end.
+
+update_explanation(#gui_state{explanation_box = Box}, Explanation) ->
+ ExplString = format_explanation(Explanation),
+ wxTextCtrl:appendText(Box, "\n --------------------------- \n"),
+ wxTextCtrl:appendText(Box, ExplString).
+
+format_explanation({function_return, {M, F, A}, NewList}) ->
+ io_lib:format("The function ~p: ~p/~p returns ~p\n",
+ [M, F, A, erl_types:t_to_string(NewList)]);
+format_explanation(Explanation) ->
+ io_lib:format("~p\n", [Explanation]).
diff --git a/lib/dialyzer/src/dialyzer_gui_wx.hrl b/lib/dialyzer/src/dialyzer_gui_wx.hrl
new file mode 100644
index 0000000000..e81eeb1ab5
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_gui_wx.hrl
@@ -0,0 +1,112 @@
+-include_lib("wx/include/wx.hrl").
+
+
+-define(TEXTSIZE, 9).
+
+-define(Border, {border, 2}).
+-define(BorderOpt,[{flag,?wxALL}, ?Border]).
+
+-define(menuID_FILE_QUIT, 102).
+-define(menuID_FILE_SAVE_WARNINGS, 100).
+-define(menuID_FILE_SAVE_LOG, 101).
+
+-define(menuID_WARN_MATCH_FAILURES, 200).
+-define(menuID_WARN_FAIL_FUN_CALLS, 201).
+-define(menuID_WARN_BAD_FUN, 202).
+-define(menuID_WARN_OPAQUE, 203).
+-define(menuID_WARN_LIST_CONSTR, 204).
+-define(menuID_WARN_UNUSED_FUN, 205).
+-define(menuID_WARN_ERROR_HANDLING_FUN, 206).
+-define(menuID_WARN_NO_RETURN_FUN, 207).
+-define(menuID_WARN_UNEXPORTED_FUN, 208).
+-define(menuID_WARN_RACE_CONDITIONS, 209).
+-define(menuID_WARN_WRONG_CONTRACTS, 210).
+-define(menuID_WARN_CONTRACT_SYNTAX, 211).
+
+-define(menuID_PLT_INIT_EMPTY, 300).
+-define(menuID_PLT_SHOW_CONTENTS, 301).
+-define(menuID_PLT_SEARCH_CONTENTS, 302).
+
+-define(menuID_OPTIONS_MACRO, 400).
+-define(menuID_OPTIONS_INCLUDE_DIR, 401).
+
+-define(menuID_HELP_MANUAL, 500).
+-define(menuID_HELP_WARNING_OPTIONS, 501).
+-define(menuID_HELP_ABOUT, 499).
+
+-define(LABEL1,502).
+-define(LABEL2,503).
+-define(LABEL3,504).
+-define(LABEL4,505).
+-define(LABEL5,505).
+-define(LABEL6,506).
+-define(LABEL7,507).
+-define(LABEL8,508).
+-define(LABEL9,509).
+
+-define(ChosenBox,510).
+-define(LogBox,511).
+-define(FilePicker,512).
+-define(DirPicker,513).
+-define(WarningsBox,521).
+
+-define(Del_Button,514).
+-define(DelAll_Button,515).
+-define(ClearLog_Button,516).
+-define(Add_Button,517).
+-define(AddDir_Button,532).
+-define(AddRec_Button,518).
+-define(ClearWarn_Button,519).
+-define(Run_Button,520).
+-define(Stop_Button,522).
+-define(ExplWarn_Button,523).
+-define(RADIOBOX, 524).
+
+-define(Dialog, 525).
+-define(Dialog_Ok, 526).
+-define(Dialog_Cancel, 527).
+-define(Dialog_Mes, 528).
+
+-define(MESSAGE, 529).
+-define(Message_Info, 530).
+-define(Message_Ok, 531).
+
+
+-define(Message, 534).
+-define(SaveWarn, 533).
+-define(SearchPltDialog, 535).
+-define(ModLabel, 536).
+-define(FunLabel, 537).
+-define(ArLabel, 538).
+-define(ModText, 539).
+-define(FunText, 540).
+-define(ArText, 541).
+-define(SearchButton, 542).
+-define(Search_Cancel, 543).
+
+-define(IncludeDir, 544).
+-define(InclLabel, 545).
+-define(InclPicker, 546).
+-define(InclBox, 547).
+-define(InclAdd, 548).
+-define(InclDel, 549).
+-define(InclDelAll, 550).
+-define(InclOk, 551).
+-define(InclCancel, 552).
+
+-define(MacroDir, 553).
+-define(MacroLabel, 554).
+-define(MacroText, 555).
+-define(TermLabel, 556).
+-define(TermText, 557).
+-define(MacroBox, 558).
+-define(MacroAdd, 559).
+-define(MacroDel, 560).
+-define(MacroDelAll, 561).
+-define(MacroOk, 562).
+-define(MacroCancel, 563).
+
+-define(ExplWin, 564).
+-define(ExplText, 565).
+-define(ExplButton, 566).
+-define(ExplOk, 567).
diff --git a/lib/dialyzer/src/dialyzer_options.erl b/lib/dialyzer/src/dialyzer_options.erl
new file mode 100644
index 0000000000..6531073072
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_options.erl
@@ -0,0 +1,269 @@
+%% -*- erlang-indent-level: 2 -*-
+%%-----------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2006-2009. 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%
+%%
+
+%%%----------------------------------------------------------------------
+%%% File : dialyzer_options.erl
+%%% Authors : Richard Carlsson <[email protected]>
+%%% Description : Provides a better way to start Dialyzer from a script.
+%%%
+%%% Created : 17 Oct 2004 by Richard Carlsson <[email protected]>
+%%%----------------------------------------------------------------------
+
+-module(dialyzer_options).
+
+-export([build/1]).
+
+-include("dialyzer.hrl").
+
+%%-----------------------------------------------------------------------
+
+-spec build(dial_options()) -> #options{} | {'error', string()}.
+
+build(Opts) ->
+ DefaultWarns = [?WARN_RETURN_NO_RETURN,
+ ?WARN_NOT_CALLED,
+ ?WARN_NON_PROPER_LIST,
+ ?WARN_FUN_APP,
+ ?WARN_MATCHING,
+ ?WARN_OPAQUE,
+ ?WARN_CALLGRAPH,
+ ?WARN_FAILING_CALL,
+ ?WARN_BIN_CONSTRUCTION,
+ ?WARN_CALLGRAPH,
+ ?WARN_CONTRACT_TYPES,
+ ?WARN_CONTRACT_SYNTAX],
+ DefaultWarns1 = ordsets:from_list(DefaultWarns),
+ InitPlt = dialyzer_plt:get_default_plt(),
+ DefaultOpts = #options{},
+ DefaultOpts1 = DefaultOpts#options{legal_warnings = DefaultWarns1,
+ init_plt = InitPlt},
+ try
+ NewOpts = build_options(Opts, DefaultOpts1),
+ postprocess_opts(NewOpts)
+ catch
+ throw:{dialyzer_options_error, Msg} -> {error, Msg}
+ end.
+
+postprocess_opts(Opts = #options{}) ->
+ Opts1 = check_output_plt(Opts),
+ adapt_get_warnings(Opts1).
+
+check_output_plt(Opts = #options{analysis_type = Mode, from = From,
+ output_plt = OutPLT}) ->
+ case is_plt_mode(Mode) of
+ true ->
+ case From =:= byte_code of
+ true -> Opts;
+ false ->
+ Msg = "Byte code compiled with debug_info is needed to build the PLT",
+ throw({dialyzer_error, Msg})
+ end;
+ false ->
+ case OutPLT =:= none of
+ true -> Opts;
+ false ->
+ Msg = io_lib:format("Output PLT cannot be specified "
+ "in analysis mode ~w", [Mode]),
+ throw({dialyzer_error, lists:flatten(Msg)})
+ end
+ end.
+
+adapt_get_warnings(Opts = #options{analysis_type = Mode,
+ get_warnings = Warns}) ->
+ %% Warnings are off by default in plt mode, and on by default in
+ %% success typings mode. User defined warning mode overrides the
+ %% default.
+ case is_plt_mode(Mode) of
+ true ->
+ case Warns =:= maybe of
+ true -> Opts#options{get_warnings = false};
+ false -> Opts
+ end;
+ false ->
+ case Warns =:= maybe of
+ true -> Opts#options{get_warnings = true};
+ false -> Opts
+ end
+ end.
+
+-spec bad_option(string(), term()) -> no_return().
+
+bad_option(String, Term) ->
+ Msg = io_lib:format("~s: ~P", [String, Term, 25]),
+ throw({dialyzer_options_error, lists:flatten(Msg)}).
+
+build_options([{OptName, undefined}|Rest], Options) when is_atom(OptName) ->
+ build_options(Rest, Options);
+build_options([{OptionName, Value} = Term|Rest], Options) ->
+ case OptionName of
+ files ->
+ assert_filenames(Term, Value),
+ build_options(Rest, Options#options{files = Value});
+ files_rec ->
+ assert_filenames(Term, Value),
+ build_options(Rest, Options#options{files_rec = Value});
+ analysis_type ->
+ NewOptions =
+ case Value of
+ succ_typings -> Options#options{analysis_type = Value};
+ plt_add -> Options#options{analysis_type = Value};
+ plt_build -> Options#options{analysis_type = Value};
+ plt_check -> Options#options{analysis_type = Value};
+ plt_remove -> Options#options{analysis_type = Value};
+ dataflow -> bad_option("Analysis type is no longer supported", Term);
+ old_style -> bad_option("Analysis type is no longer supported", Term);
+ Other -> bad_option("Unknown analysis type", Other)
+ end,
+ assert_plt_op(Options, NewOptions),
+ build_options(Rest, NewOptions);
+ check_plt when is_boolean(Value) ->
+ build_options(Rest, Options#options{check_plt = Value});
+ defines ->
+ assert_defines(Term, Value),
+ OldVal = Options#options.defines,
+ NewVal = ordsets:union(ordsets:from_list(Value), OldVal),
+ build_options(Rest, Options#options{defines = NewVal});
+ from when Value =:= byte_code; Value =:= src_code ->
+ build_options(Rest, Options#options{from = Value});
+ get_warnings ->
+ build_options(Rest, Options#options{get_warnings = Value});
+ init_plt ->
+ assert_filenames([Term], [Value]),
+ build_options(Rest, Options#options{init_plt = Value});
+ include_dirs ->
+ assert_filenames(Term, Value),
+ OldVal = Options#options.include_dirs,
+ NewVal = ordsets:union(ordsets:from_list(Value), OldVal),
+ build_options(Rest, Options#options{include_dirs = NewVal});
+ use_spec ->
+ build_options(Rest, Options#options{use_contracts = Value});
+ old_style ->
+ bad_option("Analysis type is no longer supported", old_style);
+ output_file ->
+ assert_filename(Value),
+ build_options(Rest, Options#options{output_file = Value});
+ output_format ->
+ assert_output_format(Value),
+ build_options(Rest, Options#options{output_format = Value});
+ output_plt ->
+ assert_filename(Value),
+ build_options(Rest, Options#options{output_plt = Value});
+ report_mode ->
+ build_options(Rest, Options#options{report_mode = Value});
+ erlang_mode ->
+ build_options(Rest, Options#options{erlang_mode = true});
+ warnings ->
+ NewWarnings = build_warnings(Value, Options#options.legal_warnings),
+ build_options(Rest, Options#options{legal_warnings = NewWarnings});
+ callgraph_file ->
+ assert_filename(Value),
+ build_options(Rest, Options#options{callgraph_file = Value});
+ _ ->
+ bad_option("Unknown dialyzer command line option", Term)
+ end;
+build_options([], Options) ->
+ Options.
+
+assert_filenames(Term, [FileName|Left]) when length(FileName) >= 0 ->
+ case filelib:is_file(FileName) orelse filelib:is_dir(FileName) of
+ true -> ok;
+ false -> bad_option("No such file or directory", FileName)
+ end,
+ assert_filenames(Term, Left);
+assert_filenames(_Term, []) ->
+ ok;
+assert_filenames(Term, [_|_]) ->
+ bad_option("Malformed or non-existing filename", Term).
+
+assert_filename(FileName) when length(FileName) >= 0 ->
+ ok;
+assert_filename(FileName) ->
+ bad_option("Malformed or non-existing filename", FileName).
+
+assert_defines(Term, [{Macro, _Value}|Defs]) when is_atom(Macro) ->
+ assert_defines(Term, Defs);
+assert_defines(_Term, []) ->
+ ok;
+assert_defines(Term, [_|_]) ->
+ bad_option("Malformed define", Term).
+
+assert_output_format(raw) ->
+ ok;
+assert_output_format(formatted) ->
+ ok;
+assert_output_format(Term) ->
+ bad_option("Illegal value for output_format", Term).
+
+assert_plt_op(#options{analysis_type = OldVal},
+ #options{analysis_type = NewVal}) ->
+ case is_plt_mode(OldVal) andalso is_plt_mode(NewVal) of
+ true -> bad_option("Options cannot be combined", [OldVal, NewVal]);
+ false -> ok
+ end.
+
+is_plt_mode(plt_add) -> true;
+is_plt_mode(plt_build) -> true;
+is_plt_mode(plt_remove) -> true;
+is_plt_mode(plt_check) -> true;
+is_plt_mode(succ_typings) -> false.
+
+-spec build_warnings([atom()], [dial_warning()]) -> [dial_warning()].
+
+build_warnings([Opt|Opts], Warnings) ->
+ NewWarnings =
+ case Opt of
+ no_return ->
+ ordsets:del_element(?WARN_RETURN_NO_RETURN, Warnings);
+ no_unused ->
+ ordsets:del_element(?WARN_NOT_CALLED, Warnings);
+ no_improper_lists ->
+ ordsets:del_element(?WARN_NON_PROPER_LIST, Warnings);
+ no_fun_app ->
+ ordsets:del_element(?WARN_FUN_APP, Warnings);
+ no_match ->
+ ordsets:del_element(?WARN_MATCHING, Warnings);
+ no_opaque ->
+ ordsets:del_element(?WARN_OPAQUE, Warnings);
+ no_fail_call ->
+ ordsets:del_element(?WARN_FAILING_CALL, Warnings);
+ no_contracts ->
+ Warnings1 = ordsets:del_element(?WARN_CONTRACT_SYNTAX, Warnings),
+ ordsets:del_element(?WARN_CONTRACT_TYPES, Warnings1);
+ unmatched_returns ->
+ ordsets:add_element(?WARN_UNMATCHED_RETURN, Warnings);
+ error_handling ->
+ ordsets:add_element(?WARN_RETURN_ONLY_EXIT, Warnings);
+ race_conditions ->
+ ordsets:add_element(?WARN_RACE_CONDITION, Warnings);
+ specdiffs ->
+ S = ordsets:from_list([?WARN_CONTRACT_SUBTYPE,
+ ?WARN_CONTRACT_SUPERTYPE,
+ ?WARN_CONTRACT_NOT_EQUAL]),
+ ordsets:union(S, Warnings);
+ overspecs ->
+ ordsets:add_element(?WARN_CONTRACT_SUBTYPE, Warnings);
+ underspecs ->
+ ordsets:add_element(?WARN_CONTRACT_SUPERTYPE, Warnings);
+ OtherAtom ->
+ bad_option("Unknown dialyzer warning option", OtherAtom)
+ end,
+ build_warnings(Opts, NewWarnings);
+build_warnings([], Warnings) ->
+ Warnings.
diff --git a/lib/dialyzer/src/dialyzer_plt.erl b/lib/dialyzer/src/dialyzer_plt.erl
new file mode 100644
index 0000000000..f2e0fe1e97
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_plt.erl
@@ -0,0 +1,576 @@
+%% -*- erlang-indent-level: 2 -*-
+%%----------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2006-2009. 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%
+%%
+
+%%%-------------------------------------------------------------------
+%%% File : dialyzer_plt.erl
+%%% Author : Tobias Lindahl <[email protected]>
+%%% Description : Interface to display information in the persistent
+%%% lookup tables.
+%%%
+%%% Created : 23 Jul 2004 by Tobias Lindahl <[email protected]>
+%%%-------------------------------------------------------------------
+-module(dialyzer_plt).
+
+-export([check_plt/3,
+ compute_md5_from_files/1,
+ contains_mfa/2,
+ contains_module/2,
+ delete_contract_list/2,
+ delete_list/2,
+ delete_module/2,
+ included_files/1,
+ from_file/1,
+ get_default_plt/0,
+ get_types/1,
+ %% insert/3,
+ insert_list/2,
+ insert_contract_list/2,
+ insert_types/2,
+ lookup/2,
+ lookup_contract/2,
+ lookup_module/2,
+ merge_plts/1,
+ new/0,
+ plt_and_info_from_file/1,
+ get_specs/1,
+ get_specs/4,
+ to_file/4
+ ]).
+
+%% Debug utilities
+-export([pp_non_returning/0, pp_mod/1]).
+
+%%----------------------------------------------------------------------
+
+-type mod_deps() :: dict().
+
+%% The following are used for searching the PLT when using the GUI
+%% (e.g. in show or search PLT contents). The user might be searching
+%% with a partial specification, in which case the missing items
+%% default to '_'
+-type arity_patt() :: '_' | arity().
+-type mfa_patt() :: {module(), atom(), arity_patt()}.
+
+%%----------------------------------------------------------------------
+
+-record(dialyzer_plt, {info = table_new() :: dict(),
+ types = table_new() :: dict(),
+ contracts = table_new() :: dict()}).
+-opaque plt() :: #dialyzer_plt{}.
+
+-include("dialyzer.hrl").
+
+-type file_md5() :: {file:filename(), binary()}.
+-type plt_info() :: {[file_md5()], dict()}.
+
+-record(dialyzer_file_plt, {version = "" :: string(),
+ file_md5_list = [] :: [file_md5()],
+ info = dict:new() :: dict(),
+ contracts = dict:new() :: dict(),
+ types = dict:new() :: dict(),
+ mod_deps :: mod_deps(),
+ implementation_md5 = [] :: [file_md5()]
+ }).
+
+%%----------------------------------------------------------------------
+
+-spec new() -> plt().
+
+new() ->
+ #dialyzer_plt{}.
+
+-spec delete_module(plt(), module()) -> plt().
+
+delete_module(#dialyzer_plt{info = Info, types = Types, contracts = Contracts},
+ Mod) ->
+ #dialyzer_plt{info = table_delete_module(Info, Mod),
+ types = table_delete_module2(Types, Mod),
+ contracts = table_delete_module(Contracts, Mod)}.
+
+-spec delete_list(plt(), [mfa() | integer()]) -> plt().
+
+delete_list(#dialyzer_plt{info = Info, types = Types, contracts = Contracts},
+ List) ->
+ #dialyzer_plt{info = table_delete_list(Info, List),
+ types = Types,
+ contracts = table_delete_list(Contracts, List)}.
+
+-spec insert_contract_list(plt(), dialyzer_contracts:plt_contracts()) -> plt().
+
+insert_contract_list(#dialyzer_plt{contracts = Contracts} = PLT, List) ->
+ PLT#dialyzer_plt{contracts = table_insert_list(Contracts, List)}.
+
+-spec lookup_contract(plt(), mfa_patt()) -> 'none' | {'value', #contract{}}.
+
+lookup_contract(#dialyzer_plt{contracts = Contracts},
+ {M, F, _} = MFA) when is_atom(M), is_atom(F) ->
+ table_lookup(Contracts, MFA).
+
+-spec delete_contract_list(plt(), [mfa()]) -> plt().
+
+delete_contract_list(#dialyzer_plt{contracts = Contracts} = PLT, List) ->
+ PLT#dialyzer_plt{contracts = table_delete_list(Contracts, List)}.
+
+%% -spec insert(plt(), mfa() | integer(), {_, _}) -> plt().
+%%
+%% insert(#dialyzer_plt{info = Info} = PLT, Id, Types) ->
+%% PLT#dialyzer_plt{info = table_insert(Info, Id, Types)}.
+
+-type ret_args_types() :: {erl_types:erl_type(), [erl_types:erl_type()]}.
+
+-spec insert_list(plt(), [{mfa() | integer(), ret_args_types()}]) -> plt().
+
+insert_list(#dialyzer_plt{info = Info} = PLT, List) ->
+ PLT#dialyzer_plt{info = table_insert_list(Info, List)}.
+
+-spec lookup(plt(), integer() | mfa_patt()) ->
+ 'none' | {'value', ret_args_types()}.
+
+lookup(#dialyzer_plt{info = Info}, {M, F, _} = MFA) when is_atom(M), is_atom(F) ->
+ table_lookup(Info, MFA);
+lookup(#dialyzer_plt{info = Info}, Label) when is_integer(Label) ->
+ table_lookup(Info, Label).
+
+-spec insert_types(plt(), dict()) -> plt().
+
+insert_types(PLT, Rec) ->
+ PLT#dialyzer_plt{types = Rec}.
+
+-spec get_types(plt()) -> dict().
+
+get_types(#dialyzer_plt{types = Types}) ->
+ Types.
+
+-type mfa_types() :: {mfa(), erl_types:erl_type(), [erl_types:erl_type()]}.
+
+-spec lookup_module(plt(), module()) -> 'none' | {'value', [mfa_types()]}.
+
+lookup_module(#dialyzer_plt{info = Info}, M) when is_atom(M) ->
+ table_lookup_module(Info, M).
+
+-spec contains_module(plt(), module()) -> boolean().
+
+contains_module(#dialyzer_plt{info = Info, contracts = Cs}, M) when is_atom(M) ->
+ table_contains_module(Info, M) orelse table_contains_module(Cs, M).
+
+-spec contains_mfa(plt(), mfa()) -> boolean().
+
+contains_mfa(#dialyzer_plt{info = Info, contracts = Contracts}, MFA) ->
+ (table_lookup(Info, MFA) =/= none)
+ orelse (table_lookup(Contracts, MFA) =/= none).
+
+-spec get_default_plt() -> file:filename().
+
+get_default_plt() ->
+ case os:getenv("DIALYZER_PLT") of
+ false ->
+ case os:getenv("HOME") of
+ false ->
+ error("The HOME environment variable needs to be set " ++
+ "so that Dialyzer knows where to find the default PLT");
+ HomeDir -> filename:join(HomeDir, ".dialyzer_plt")
+ end;
+ UserSpecPlt -> UserSpecPlt
+ end.
+
+-spec plt_and_info_from_file(file:filename()) -> {plt(), plt_info()}.
+
+plt_and_info_from_file(FileName) ->
+ from_file(FileName, true).
+
+-spec from_file(file:filename()) -> plt().
+
+from_file(FileName) ->
+ from_file(FileName, false).
+
+from_file(FileName, ReturnInfo) ->
+ case get_record_from_file(FileName) of
+ {ok, Rec} ->
+ case check_version(Rec) of
+ error ->
+ Msg = io_lib:format("Old PLT file ~s\n", [FileName]),
+ error(Msg);
+ ok ->
+ Plt = #dialyzer_plt{info = Rec#dialyzer_file_plt.info,
+ types = Rec#dialyzer_file_plt.types,
+ contracts = Rec#dialyzer_file_plt.contracts},
+ case ReturnInfo of
+ false -> Plt;
+ true ->
+ PltInfo = {Rec#dialyzer_file_plt.file_md5_list,
+ Rec#dialyzer_file_plt.mod_deps},
+ {Plt, PltInfo}
+ end
+ end;
+ {error, Reason} ->
+ error(io_lib:format("Could not read PLT file ~s: ~p\n",
+ [FileName, Reason]))
+ end.
+
+-type inc_file_err_rsn() :: 'no_such_file' | 'read_error'.
+-spec included_files(file:filename()) -> {'ok', [file:filename()]}
+ | {'error', inc_file_err_rsn()}.
+
+included_files(FileName) ->
+ case get_record_from_file(FileName) of
+ {ok, #dialyzer_file_plt{file_md5_list = Md5}} ->
+ {ok, [File || {File, _} <- Md5]};
+ {error, _What} = Error ->
+ Error
+ end.
+
+check_version(#dialyzer_file_plt{version=?VSN, implementation_md5=ImplMd5}) ->
+ case compute_new_md5(ImplMd5, [], []) of
+ ok -> ok;
+ {differ, _, _} -> error;
+ {error, _} -> error
+ end;
+check_version(#dialyzer_file_plt{}) -> error.
+
+get_record_from_file(FileName) ->
+ case file:read_file(FileName) of
+ {ok, Bin} ->
+ try binary_to_term(Bin) of
+ #dialyzer_file_plt{} = FilePLT -> {ok, FilePLT};
+ _ -> {error, not_valid}
+ catch
+ _:_ -> {error, not_valid}
+ end;
+ {error, enoent} ->
+ {error, no_such_file};
+ {error, _} ->
+ {error, read_error}
+ end.
+
+-spec merge_plts([plt()]) -> plt().
+
+merge_plts(List) ->
+ InfoList = [Info || #dialyzer_plt{info = Info} <- List],
+ TypesList = [Types || #dialyzer_plt{types = Types} <- List],
+ ContractsList = [Contracts || #dialyzer_plt{contracts = Contracts} <- List],
+ #dialyzer_plt{info = table_merge(InfoList),
+ types = table_merge(TypesList),
+ contracts = table_merge(ContractsList)}.
+
+-spec to_file(file:filename(), plt(), mod_deps(), {[file_md5()], mod_deps()}) -> 'ok'.
+
+to_file(FileName,
+ #dialyzer_plt{info = Info, types = Types, contracts = Contracts},
+ ModDeps, {MD5, OldModDeps}) ->
+ NewModDeps = dict:merge(fun(_Key, OldVal, NewVal) ->
+ ordsets:union(OldVal, NewVal)
+ end,
+ OldModDeps, ModDeps),
+ ImplMd5 = compute_implementation_md5(),
+ Record = #dialyzer_file_plt{version = ?VSN,
+ file_md5_list = MD5,
+ info = Info,
+ contracts = Contracts,
+ types = Types,
+ mod_deps = NewModDeps,
+ implementation_md5 = ImplMd5},
+ Bin = term_to_binary(Record, [compressed]),
+ case file:write_file(FileName, Bin) of
+ ok -> ok;
+ {error, Reason} ->
+ Msg = io_lib:format("Could not write PLT file ~s: ~w\n",
+ [FileName, Reason]),
+ throw({dialyzer_error, Msg})
+ end.
+
+-type md5_diff() :: [{'differ', atom()} | {'removed', atom()}].
+-type check_error() :: 'not_valid' | 'no_such_file' | 'read_error'
+ | {'no_file_to_remove', file:filename()}.
+
+-spec check_plt(file:filename(), [file:filename()], [file:filename()]) ->
+ 'ok'
+ | {'error', check_error()}
+ | {'differ', [file_md5()], md5_diff(), mod_deps()}
+ | {'old_version', [file_md5()]}.
+
+check_plt(FileName, RemoveFiles, AddFiles) ->
+ case get_record_from_file(FileName) of
+ {ok, #dialyzer_file_plt{file_md5_list = Md5, mod_deps = ModDeps} = Rec} ->
+ case check_version(Rec) of
+ ok ->
+ case compute_new_md5(Md5, RemoveFiles, AddFiles) of
+ ok -> ok;
+ {differ, NewMd5, DiffMd5} -> {differ, NewMd5, DiffMd5, ModDeps};
+ {error, _What} = Err -> Err
+ end;
+ error ->
+ case compute_new_md5(Md5, RemoveFiles, AddFiles) of
+ ok -> {old_version, Md5};
+ {differ, NewMd5, _DiffMd5} -> {old_version, NewMd5};
+ {error, _What} = Err -> Err
+ end
+ end;
+ Error -> Error
+ end.
+
+compute_new_md5(Md5, [], []) ->
+ compute_new_md5_1(Md5, [], []);
+compute_new_md5(Md5, RemoveFiles0, AddFiles0) ->
+ %% Assume that files are first removed and then added. Files that
+ %% are both removed and added will be checked for consistency in the
+ %% normal way. If they have moved, we assume that they differ.
+ RemoveFiles = RemoveFiles0 -- AddFiles0,
+ AddFiles = AddFiles0 -- RemoveFiles0,
+ InitDiffList = init_diff_list(RemoveFiles, AddFiles),
+ case init_md5_list(Md5, RemoveFiles, AddFiles) of
+ {ok, NewMd5} -> compute_new_md5_1(NewMd5, [], InitDiffList);
+ {error, _What} = Error -> Error
+ end.
+
+compute_new_md5_1([{File, Md5} = Entry|Entries], NewList, Diff) ->
+ case compute_md5_from_file(File) of
+ Md5 -> compute_new_md5_1(Entries, [Entry|NewList], Diff);
+ NewMd5 ->
+ ModName = beam_file_to_module(File),
+ compute_new_md5_1(Entries, [{File, NewMd5}|NewList], [{differ, ModName}|Diff])
+ end;
+compute_new_md5_1([], _NewList, []) ->
+ ok;
+compute_new_md5_1([], NewList, Diff) ->
+ {differ, lists:keysort(1, NewList), Diff}.
+
+-spec compute_implementation_md5() -> [file_md5()].
+
+compute_implementation_md5() ->
+ Dir = code:lib_dir(hipe),
+ Files1 = ["erl_bif_types.beam", "erl_types.beam"],
+ Files2 = [filename:join([Dir, "ebin", F]) || F <- Files1],
+ compute_md5_from_files(Files2).
+
+-spec compute_md5_from_files([file:filename()]) -> [file_md5()].
+
+compute_md5_from_files(Files) ->
+ lists:keysort(1, [{F, compute_md5_from_file(F)} || F <- Files]).
+
+compute_md5_from_file(File) ->
+ case filelib:is_regular(File) of
+ false ->
+ Msg = io_lib:format("Not a regular file: ~s\n", [File]),
+ throw({dialyzer_error, Msg});
+ true ->
+ case dialyzer_utils:get_abstract_code_from_beam(File) of
+ error ->
+ Msg = io_lib:format("Could not get abstract code for file: ~s (please recompile it with +debug_info)\n", [File]),
+ throw({dialyzer_error, Msg});
+ {ok, Abs} ->
+ erlang:md5(term_to_binary(Abs))
+ end
+ end.
+
+init_diff_list(RemoveFiles, AddFiles) ->
+ RemoveSet0 = sets:from_list([beam_file_to_module(F) || F <- RemoveFiles]),
+ AddSet0 = sets:from_list([beam_file_to_module(F) || F <- AddFiles]),
+ DiffSet = sets:intersection(AddSet0, RemoveSet0),
+ RemoveSet = sets:subtract(RemoveSet0, DiffSet),
+ %% Added files and diff files will appear as diff files from the md5 check.
+ [{removed, F} || F <- sets:to_list(RemoveSet)].
+
+init_md5_list(Md5, RemoveFiles, AddFiles) ->
+ Files = [{remove, F} || F <- RemoveFiles] ++ [{add, F} || F <- AddFiles],
+ DiffFiles = lists:keysort(2, Files),
+ Md5Sorted = lists:keysort(1, Md5),
+ init_md5_list_1(Md5Sorted, DiffFiles, []).
+
+init_md5_list_1([{File, _Md5}|Md5Left], [{remove, File}|DiffLeft], Acc) ->
+ init_md5_list_1(Md5Left, DiffLeft, Acc);
+init_md5_list_1([{File, _Md5} = Entry|Md5Left], [{add, File}|DiffLeft], Acc) ->
+ init_md5_list_1(Md5Left, DiffLeft, [Entry|Acc]);
+init_md5_list_1([{File1, _Md5} = Entry|Md5Left] = Md5List,
+ [{Tag, File2}|DiffLeft] = DiffList, Acc) ->
+ case File1 < File2 of
+ true -> init_md5_list_1(Md5Left, DiffList, [Entry|Acc]);
+ false ->
+ %% Just an assert.
+ true = File1 > File2,
+ case Tag of
+ add -> init_md5_list_1(Md5List, DiffLeft, [{File2, <<>>}|Acc]);
+ remove -> {error, {no_file_to_remove, File2}}
+ end
+ end;
+init_md5_list_1([], DiffList, Acc) ->
+ AddFiles = [{F, <<>>} || {add, F} <- DiffList],
+ {ok, lists:reverse(Acc, AddFiles)};
+init_md5_list_1(Md5List, [], Acc) ->
+ {ok, lists:reverse(Acc, Md5List)}.
+
+%%---------------------------------------------------------------------------
+%% Edoc
+
+-spec get_specs(plt()) -> string().
+
+get_specs(#dialyzer_plt{info = Info}) ->
+ %% TODO: Should print contracts as well.
+ List =
+ lists:sort([{MFA, Val} || {MFA = {_,_,_}, Val} <- table_to_list(Info)]),
+ lists:flatten(create_specs(List, [])).
+
+beam_file_to_module(Filename) ->
+ list_to_atom(filename:basename(Filename, ".beam")).
+
+-spec get_specs(plt(), module(), atom(), arity_patt()) -> 'none' | string().
+
+get_specs(#dialyzer_plt{info = Info}, M, F, A) when is_atom(M), is_atom(F) ->
+ MFA = {M, F, A},
+ case table_lookup(Info, MFA) of
+ none -> none;
+ {value, Val} -> lists:flatten(create_specs([{MFA, Val}], []))
+ end.
+
+create_specs([{{M, F, _A}, {Ret, Args}}|Left], M) ->
+ [io_lib:format("-spec ~w(~s) -> ~s\n",
+ [F, expand_args(Args), erl_types:t_to_string(Ret)])
+ | create_specs(Left, M)];
+create_specs(List = [{{M, _F, _A}, {_Ret, _Args}}| _], _M) ->
+ [io_lib:format("\n\n%% ------- Module: ~w -------\n\n", [M])
+ | create_specs(List, M)];
+create_specs([], _) ->
+ [].
+
+expand_args([]) ->
+ [];
+expand_args([ArgType]) ->
+ case erl_types:t_is_any(ArgType) of
+ true -> ["_"];
+ false -> [erl_types:t_to_string(ArgType)]
+ end;
+expand_args([ArgType|Left]) ->
+ [case erl_types:t_is_any(ArgType) of
+ true -> "_";
+ false -> erl_types:t_to_string(ArgType)
+ end ++
+ ","|expand_args(Left)].
+
+error(Msg) ->
+ throw({dialyzer_error, lists:flatten(Msg)}).
+
+%%---------------------------------------------------------------------------
+%% Ets table
+
+table_new() ->
+ dict:new().
+
+table_to_list(Plt) ->
+ dict:to_list(Plt).
+
+table_delete_module(Plt, Mod) ->
+ dict:filter(fun({M, _F, _A}, _Val) -> M =/= Mod;
+ (_, _) -> true
+ end, Plt).
+
+table_delete_module2(Plt, Mod) ->
+ dict:filter(fun(M, _Val) -> M =/= Mod end, Plt).
+
+table_delete_list(Plt, [H|T]) ->
+ table_delete_list(dict:erase(H, Plt), T);
+table_delete_list(Plt, []) ->
+ Plt.
+
+table_insert_list(Plt, [{Key, Val}|Left]) ->
+ table_insert_list(table_insert(Plt, Key, Val), Left);
+table_insert_list(Plt, []) ->
+ Plt.
+
+table_insert(Plt, Key, {_Ret, _Arg} = Obj) ->
+ dict:store(Key, Obj, Plt);
+table_insert(Plt, Key, #contract{} = C) ->
+ dict:store(Key, C, Plt).
+
+table_lookup(Plt, Obj) ->
+ case dict:find(Obj, Plt) of
+ error -> none;
+ {ok, Val} -> {value, Val}
+ end.
+
+table_lookup_module(Plt, Mod) ->
+ List = dict:fold(fun(Key, Val, Acc) ->
+ case Key of
+ {Mod, _F, _A} -> [{Key, element(1, Val),
+ element(2, Val)}|Acc];
+ _ -> Acc
+ end
+ end, [], Plt),
+ case List =:= [] of
+ true -> none;
+ false -> {value, List}
+ end.
+
+table_contains_module(Plt, Mod) ->
+ dict:fold(fun({M, _F, _A}, _Val, _Acc) when M =:= Mod -> true;
+ (_, _, Acc) -> Acc
+ end, false, Plt).
+
+table_merge([H|T]) ->
+ table_merge(T, H).
+
+table_merge([], Acc) ->
+ Acc;
+table_merge([Plt|Left], Acc) ->
+ NewAcc = dict:merge(fun(_Key, Val, Val) -> Val end, Plt, Acc),
+ table_merge(Left, NewAcc).
+
+%%---------------------------------------------------------------------------
+%% Debug utilities.
+
+-spec pp_non_returning() -> 'ok'.
+
+pp_non_returning() ->
+ PltFile = get_default_plt(),
+ Plt = from_file(PltFile),
+ List = table_to_list(Plt#dialyzer_plt.info),
+ Unit = [{MFA, erl_types:t_fun(Args, Ret)} || {MFA, {Ret, Args}} <- List,
+ erl_types:t_is_unit(Ret)],
+ None = [{MFA, erl_types:t_fun(Args, Ret)} || {MFA, {Ret, Args}} <- List,
+ erl_types:t_is_none(Ret)],
+ io:format("=========================================\n"),
+ io:format("= Loops =\n"),
+ io:format("=========================================\n\n"),
+ lists:foreach(fun({{M, F, _}, Type}) ->
+ io:format("~w:~w~s.\n",
+ [M, F, dialyzer_utils:format_sig(Type)])
+ end, lists:sort(Unit)),
+ io:format("\n"),
+ io:format("=========================================\n"),
+ io:format("= Errors =\n"),
+ io:format("=========================================\n\n"),
+ lists:foreach(fun({{M, F, _}, Type}) ->
+ io:format("~w:~w~s.\n",
+ [M, F, dialyzer_utils:format_sig(Type)])
+ end, lists:sort(None)).
+
+-spec pp_mod(module()) -> 'ok'.
+
+pp_mod(Mod) when is_atom(Mod) ->
+ PltFile = get_default_plt(),
+ Plt = from_file(PltFile),
+ case lookup_module(Plt, Mod) of
+ {value, List} ->
+ lists:foreach(fun({{_, F, _}, Ret, Args}) ->
+ T = erl_types:t_fun(Args, Ret),
+ S = dialyzer_utils:format_sig(T),
+ io:format("-spec ~w~s.\n", [F, S])
+ end, lists:sort(List));
+ none ->
+ io:format("dialyzer: Found no module named '~s' in the PLT\n", [Mod])
+ end.
diff --git a/lib/dialyzer/src/dialyzer_races.erl b/lib/dialyzer/src/dialyzer_races.erl
new file mode 100644
index 0000000000..5857f7a03d
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_races.erl
@@ -0,0 +1,2426 @@
+%% -*- erlang-indent-level: 2 -*-
+%%-----------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2008-2009. 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%
+%%
+
+%%%----------------------------------------------------------------------
+%%% File : dialyzer_races.erl
+%%% Author : Maria Christakis <[email protected]>
+%%% Description : Utility functions for race condition detection
+%%%
+%%% Created : 21 Nov 2008 by Maria Christakis <[email protected]>
+%%%----------------------------------------------------------------------
+-module(dialyzer_races).
+
+%% Race Analysis
+
+-export([store_race_call/5, race/1, get_race_warnings/2, format_args/4]).
+
+%% Record Interfaces
+
+-export([beg_clause_new/3, cleanup/1, end_case_new/1, end_clause_new/3,
+ get_curr_fun/1, get_curr_fun_args/1, get_new_table/1,
+ get_race_analysis/1, get_race_list/1, get_race_list_size/1,
+ let_tag_new/2, new/0, put_curr_fun/3, put_fun_args/2,
+ put_race_analysis/2, put_race_list/3]).
+
+-include("dialyzer.hrl").
+
+%%% ===========================================================================
+%%%
+%%% Definitions
+%%%
+%%% ===========================================================================
+
+-define(local, 5).
+-define(no_arg, no_arg).
+-define(no_label, no_label).
+
+-define(WARN_WHEREIS_REGISTER, warn_whereis_register).
+-define(WARN_ETS_LOOKUP_INSERT, warn_ets_lookup_insert).
+-define(WARN_MNESIA_DIRTY_READ_WRITE, warn_mnesia_dirty_read_write).
+-define(WARN_NO_WARN, warn_no_warn).
+
+%%% ===========================================================================
+%%%
+%%% Local Types
+%%%
+%%% ===========================================================================
+
+-type mfa_or_funlbl() :: label() | mfa().
+
+-type label_type() :: label() | [label()] | {label()} | ?no_label.
+-type args() :: [label_type() | [string()]].
+-type core_vars() :: cerl:cerl() | ?no_arg.
+-type var_to_map() :: core_vars() | [cerl:cerl()].
+-type core_args() :: [core_vars()] | 'empty'.
+-type op() :: 'bind' | 'unbind'.
+
+-type dep_calls() :: 'whereis' | 'ets_lookup' | 'mnesia_dirty_read'.
+-type warn_calls() :: 'register' | 'ets_insert' | 'mnesia_dirty_write'.
+-type call() :: 'whereis' | 'register' | 'ets_new' | 'ets_lookup'
+ | 'ets_insert' | 'mnesia_dirty_read1'
+ | 'mnesia_dirty_read2' | 'mnesia_dirty_write1'
+ | 'mnesia_dirty_write2' | 'function_call'.
+-type race_tag() :: 'whereis_register' | 'ets_lookup_insert'
+ | 'mnesia_dirty_read_write'.
+
+-record(beg_clause, {arg :: var_to_map(),
+ pats :: var_to_map(),
+ guard :: cerl:cerl()}).
+-record(end_clause, {arg :: var_to_map(),
+ pats :: var_to_map(),
+ guard :: cerl:cerl()}).
+-record(end_case, {clauses :: [#end_clause{}]}).
+-record(curr_fun, {status :: 'in' | 'out',
+ mfa :: mfa_or_funlbl(),
+ label :: label(),
+ def_vars :: [core_vars()],
+ arg_types :: [erl_types:erl_type()],
+ call_vars :: [core_vars()],
+ var_map :: dict()}).
+-record(dep_call, {call_name :: dep_calls(),
+ args :: args(),
+ arg_types :: [erl_types:erl_type()],
+ vars :: [core_vars()],
+ state :: _,
+ file_line :: file_line(),
+ var_map :: dict()}).
+-record(fun_call, {caller :: mfa_or_funlbl(),
+ callee :: mfa_or_funlbl(),
+ arg_types :: [erl_types:erl_type()],
+ vars :: [core_vars()]}).
+-record(let_tag, {var :: var_to_map(),
+ arg :: var_to_map()}).
+-record(warn_call, {call_name :: warn_calls(),
+ args :: args(),
+ var_map :: dict()}).
+
+-type case_tags() :: 'beg_case' | #beg_clause{} | #end_clause{} | #end_case{}.
+-type code() :: [#dep_call{} | #warn_call{} | #fun_call{} |
+ #curr_fun{} | #let_tag{} | case_tags() | race_tag()].
+
+-type table_var() :: label() | ?no_label.
+-type table() :: {'named', table_var(), [string()]} | 'other' | 'no_t'.
+
+-record(race_fun, {mfa :: mfa(),
+ args :: args(),
+ arg_types :: [erl_types:erl_type()],
+ vars :: [core_vars()],
+ file_line :: file_line(),
+ index :: non_neg_integer(),
+ fun_mfa :: mfa_or_funlbl(),
+ fun_label :: label()}).
+
+-record(races, {curr_fun :: mfa_or_funlbl(),
+ curr_fun_label :: label(),
+ curr_fun_args = 'empty' :: core_args(),
+ new_table = 'no_t' :: table(),
+ race_list = [] :: code(),
+ race_list_size = 0 :: non_neg_integer(),
+ race_tags = [] :: [#race_fun{}],
+ %% true for fun types and warning mode
+ race_analysis = false :: boolean(),
+ race_warnings = [] :: [dial_warning()]}).
+
+%%% ===========================================================================
+%%%
+%%% Exported Types
+%%%
+%%% ===========================================================================
+
+-opaque races() :: #races{}.
+
+%%% ===========================================================================
+%%%
+%%% Race Analysis
+%%%
+%%% ===========================================================================
+
+-spec store_race_call(mfa_or_funlbl(), [erl_types:erl_type()], [core_vars()],
+ file_line(), dialyzer_dataflow:state()) ->
+ dialyzer_dataflow:state().
+
+store_race_call(Fun, ArgTypes, Args, FileLine, State) ->
+ Races = dialyzer_dataflow:state__get_races(State),
+ CurrFun = Races#races.curr_fun,
+ CurrFunLabel = Races#races.curr_fun_label,
+ RaceTags = Races#races.race_tags,
+ CleanState = dialyzer_dataflow:state__records_only(State),
+ {NewRaceList, NewRaceListSize, NewRaceTags, NewTable} =
+ case CurrFun of
+ {_Module, module_info, A} when A =:= 0 orelse A =:= 1 ->
+ {[], 0, RaceTags, no_t};
+ _Thing ->
+ RaceList = Races#races.race_list,
+ RaceListSize = Races#races.race_list_size,
+ case Fun of
+ {erlang, get_module_info, A} when A =:= 1 orelse A =:= 2 ->
+ {[], 0, RaceTags, no_t};
+ {erlang, register, 2} ->
+ VarArgs = format_args(Args, ArgTypes, CleanState, register),
+ RaceFun = #race_fun{mfa = Fun, args = VarArgs,
+ arg_types = ArgTypes, vars = Args,
+ file_line = FileLine, index = RaceListSize,
+ fun_mfa = CurrFun, fun_label = CurrFunLabel},
+ {[#warn_call{call_name = register, args = VarArgs}|
+ RaceList], RaceListSize + 1, [RaceFun|RaceTags], no_t};
+ {erlang, whereis, 1} ->
+ VarArgs = format_args(Args, ArgTypes, CleanState, whereis),
+ {[#dep_call{call_name = whereis, args = VarArgs,
+ arg_types = ArgTypes, vars = Args,
+ state = CleanState, file_line = FileLine}|
+ RaceList], RaceListSize + 1, RaceTags, no_t};
+ {ets, insert, 2} ->
+ VarArgs = format_args(Args, ArgTypes, CleanState, ets_insert),
+ RaceFun = #race_fun{mfa = Fun, args = VarArgs,
+ arg_types = ArgTypes, vars = Args,
+ file_line = FileLine, index = RaceListSize,
+ fun_mfa = CurrFun, fun_label = CurrFunLabel},
+ {[#warn_call{call_name = ets_insert, args = VarArgs}|
+ RaceList], RaceListSize + 1, [RaceFun|RaceTags], no_t};
+ {ets, lookup, 2} ->
+ VarArgs = format_args(Args, ArgTypes, CleanState, ets_lookup),
+ {[#dep_call{call_name = ets_lookup, args = VarArgs,
+ arg_types = ArgTypes, vars = Args,
+ state = CleanState, file_line = FileLine}|
+ RaceList], RaceListSize + 1, RaceTags, no_t};
+ {ets, new, 2} ->
+ VarArgs = format_args(Args, ArgTypes, CleanState, ets_new),
+ [VarArgs1, VarArgs2, _, Options] = VarArgs,
+ NewTable1 =
+ case lists:member("'public'", Options) of
+ true ->
+ case lists:member("'named_table'", Options) of
+ true ->
+ {named, VarArgs1, VarArgs2};
+ false -> other
+ end;
+ false -> no_t
+ end,
+ {RaceList, RaceListSize, RaceTags, NewTable1};
+ {mnesia, dirty_read, A} when A =:= 1 orelse A =:= 2 ->
+ VarArgs =
+ case A of
+ 1 ->
+ format_args(Args, ArgTypes, CleanState, mnesia_dirty_read1);
+ 2 ->
+ format_args(Args, ArgTypes, CleanState, mnesia_dirty_read2)
+ end,
+ {[#dep_call{call_name = mnesia_dirty_read, args = VarArgs,
+ arg_types = ArgTypes, vars = Args,
+ state = CleanState, file_line = FileLine}|RaceList],
+ RaceListSize + 1, RaceTags, no_t};
+ {mnesia, dirty_write, A} when A =:= 1 orelse A =:= 2 ->
+ VarArgs =
+ case A of
+ 1 ->
+ format_args(Args, ArgTypes, CleanState, mnesia_dirty_write1);
+ 2 ->
+ format_args(Args, ArgTypes, CleanState, mnesia_dirty_write2)
+ end,
+ RaceFun = #race_fun{mfa = Fun, args = VarArgs,
+ arg_types = ArgTypes, vars = Args,
+ file_line = FileLine, index = RaceListSize,
+ fun_mfa = CurrFun, fun_label = CurrFunLabel},
+ {[#warn_call{call_name = mnesia_dirty_write,
+ args = VarArgs}|RaceList],
+ RaceListSize + 1, [RaceFun|RaceTags], no_t};
+ Int when is_integer(Int) ->
+ {[#fun_call{caller = CurrFun, callee = Int, arg_types = ArgTypes,
+ vars = Args}|RaceList],
+ RaceListSize + 1, RaceTags, no_t};
+ _Other ->
+ Callgraph = dialyzer_dataflow:state__get_callgraph(State),
+ case digraph:vertex(dialyzer_callgraph:get_digraph(Callgraph),
+ Fun) of
+ {Fun, confirmed} ->
+ {[#fun_call{caller = CurrFun, callee = Fun,
+ arg_types = ArgTypes, vars = Args}|RaceList],
+ RaceListSize + 1, RaceTags, no_t};
+ false ->
+ {RaceList, RaceListSize, RaceTags, no_t}
+ end
+ end
+ end,
+ state__renew_info(NewRaceList, NewRaceListSize, NewRaceTags, NewTable, State).
+
+-spec race(dialyzer_dataflow:state()) -> dialyzer_dataflow:state().
+
+race(State) ->
+ Races = dialyzer_dataflow:state__get_races(State),
+ RaceTags = Races#races.race_tags,
+ RetState =
+ case RaceTags of
+ [] -> State;
+ [#race_fun{mfa = Fun,
+ args = VarArgs, arg_types = ArgTypes,
+ vars = Args, file_line = FileLine,
+ index = Index, fun_mfa = CurrFun,
+ fun_label = CurrFunLabel}|T] ->
+ Callgraph = dialyzer_dataflow:state__get_callgraph(State),
+ {ok, [_Args, Code]} =
+ dict:find(CurrFun, dialyzer_callgraph:get_race_code(Callgraph)),
+ RaceList = lists:reverse(Code),
+ RaceWarnTag =
+ case Fun of
+ {erlang, register, 2} -> ?WARN_WHEREIS_REGISTER;
+ {ets, insert, 2} -> ?WARN_ETS_LOOKUP_INSERT;
+ {mnesia, dirty_write, _A} -> ?WARN_MNESIA_DIRTY_READ_WRITE
+ end,
+ State1 =
+ state__renew_curr_fun(CurrFun,
+ state__renew_curr_fun_label(CurrFunLabel,
+ state__renew_race_list(lists:nthtail(length(RaceList) - Index,
+ RaceList), State))),
+ DepList = fixup_race_list(RaceWarnTag, VarArgs, State1),
+ {State2, RaceWarn} =
+ get_race_warn(Fun, Args, ArgTypes, DepList, State),
+ race(
+ state__add_race_warning(
+ state__renew_race_tags(T, State2), RaceWarn, RaceWarnTag,
+ FileLine))
+ end,
+ state__renew_race_tags([], RetState).
+
+fixup_race_list(RaceWarnTag, WarnVarArgs, State) ->
+ Races = dialyzer_dataflow:state__get_races(State),
+ CurrFun = Races#races.curr_fun,
+ CurrFunLabel = Races#races.curr_fun_label,
+ RaceList = Races#races.race_list,
+ Callgraph = dialyzer_dataflow:state__get_callgraph(State),
+ Digraph = dialyzer_callgraph:get_digraph(Callgraph),
+ Calls = digraph:edges(Digraph),
+ RaceTag =
+ case RaceWarnTag of
+ ?WARN_WHEREIS_REGISTER -> whereis_register;
+ ?WARN_ETS_LOOKUP_INSERT -> ets_lookup_insert;
+ ?WARN_MNESIA_DIRTY_READ_WRITE -> mnesia_dirty_read_write
+ end,
+ NewRaceList = [RaceTag|RaceList],
+ CleanState = dialyzer_dataflow:state__cleanup(State),
+ NewState = state__renew_race_list(NewRaceList, CleanState),
+ DepList1 =
+ fixup_race_forward_pullout(CurrFun, CurrFunLabel, Calls,
+ lists:reverse(NewRaceList), [], CurrFun,
+ WarnVarArgs, RaceWarnTag, dict:new(),
+ [], [], [], 2 * ?local, NewState),
+ Parents =
+ fixup_race_backward(CurrFun, Calls, Calls, [], ?local),
+ UParents = lists:usort(Parents),
+ Filtered =
+ filter_parents(UParents, UParents, Digraph),
+ NewParents =
+ case lists:member(CurrFun, Filtered) of
+ true -> Filtered;
+ false -> [CurrFun|Filtered]
+ end,
+ DepList2 =
+ fixup_race_list_helper(NewParents, Calls, CurrFun, WarnVarArgs,
+ RaceWarnTag, NewState),
+ lists:usort(cleanup_dep_calls(DepList1 ++ DepList2)).
+
+fixup_race_list_helper(Parents, Calls, CurrFun, WarnVarArgs, RaceWarnTag,
+ State) ->
+ case Parents of
+ [] -> [];
+ [Head|Tail] ->
+ Callgraph = dialyzer_dataflow:state__get_callgraph(State),
+ Code =
+ case dict:find(Head, dialyzer_callgraph:get_race_code(Callgraph)) of
+ error -> [];
+ {ok, [_A, C]} -> C
+ end,
+ {ok, FunLabel} = dialyzer_callgraph:lookup_label(Head, Callgraph),
+ DepList1 =
+ fixup_race_forward_pullout(Head, FunLabel, Calls, Code, [], CurrFun,
+ WarnVarArgs, RaceWarnTag, dict:new(),
+ [], [], [], 2 * ?local, State),
+ DepList2 =
+ fixup_race_list_helper(Tail, Calls, CurrFun, WarnVarArgs,
+ RaceWarnTag, State),
+ DepList1 ++ DepList2
+ end.
+
+%%% ===========================================================================
+%%%
+%%% Forward Analysis
+%%%
+%%% ===========================================================================
+
+fixup_race_forward_pullout(CurrFun, CurrFunLabel, Calls, Code, RaceList,
+ InitFun, WarnVarArgs, RaceWarnTag, RaceVarMap,
+ FunDefVars, FunCallVars, FunArgTypes, NestingLevel,
+ State) ->
+ {DepList, NewCurrFun, NewCurrFunLabel, NewCalls,
+ NewCode, NewRaceList, NewRaceVarMap, NewFunDefVars,
+ NewFunCallVars, NewFunArgTypes, NewNestingLevel} =
+ fixup_race_forward(CurrFun, CurrFunLabel, Calls, Code, RaceList,
+ InitFun, WarnVarArgs, RaceWarnTag, RaceVarMap,
+ FunDefVars, FunCallVars, FunArgTypes, NestingLevel,
+ cleanup_race_code(State)),
+ case NewCode of
+ [] -> DepList;
+ [#fun_call{caller = NewCurrFun, callee = Call, arg_types = FunTypes,
+ vars = FunArgs}|Tail] ->
+ Callgraph = dialyzer_dataflow:state__get_callgraph(State),
+ OkCall = {ok, Call},
+ {Name, Label} =
+ case is_integer(Call) of
+ true ->
+ case dialyzer_callgraph:lookup_name(Call, Callgraph) of
+ error -> {OkCall, OkCall};
+ N -> {N, OkCall}
+ end;
+ false ->
+ {OkCall, dialyzer_callgraph:lookup_label(Call, Callgraph)}
+ end,
+ {NewCurrFun1, NewCurrFunLabel1, NewCalls1, NewCode1, NewRaceList1,
+ NewRaceVarMap1, NewFunDefVars1, NewFunCallVars1, NewFunArgTypes1,
+ NewNestingLevel1} =
+ case Label =:= error of
+ true ->
+ {NewCurrFun, NewCurrFunLabel, NewCalls, Tail, NewRaceList,
+ NewRaceVarMap, NewFunDefVars, NewFunCallVars, NewFunArgTypes,
+ NewNestingLevel};
+ false ->
+ {ok, Fun} = Name,
+ {ok, Int} = Label,
+ case dict:find(Fun,
+ dialyzer_callgraph:get_race_code(Callgraph)) of
+ error ->
+ {NewCurrFun, NewCurrFunLabel, NewCalls, Tail, NewRaceList,
+ NewRaceVarMap, NewFunDefVars, NewFunCallVars, NewFunArgTypes,
+ NewNestingLevel};
+ {ok, [Args, CodeB]} ->
+ Races = dialyzer_dataflow:state__get_races(State),
+ {RetCurrFun, RetCurrFunLabel, RetCalls, RetCode,
+ RetRaceList, RetRaceVarMap, RetFunDefVars, RetFunCallVars,
+ RetFunArgTypes, RetNestingLevel} =
+ fixup_race_forward_helper(NewCurrFun,
+ NewCurrFunLabel, Fun, Int, NewCalls, NewCalls,
+ [#curr_fun{status = out, mfa = NewCurrFun,
+ label = NewCurrFunLabel,
+ var_map = NewRaceVarMap,
+ def_vars = NewFunDefVars,
+ call_vars = NewFunCallVars,
+ arg_types = NewFunArgTypes}|
+ Tail],
+ NewRaceList, InitFun, FunArgs, FunTypes, RaceWarnTag,
+ NewRaceVarMap, NewFunDefVars, NewFunCallVars,
+ NewFunArgTypes, NewNestingLevel, Args, CodeB,
+ Races#races.race_list),
+ case RetCode of
+ [#curr_fun{}|_CodeTail] ->
+ {NewCurrFun, NewCurrFunLabel, RetCalls, RetCode,
+ RetRaceList, NewRaceVarMap, NewFunDefVars,
+ NewFunCallVars, NewFunArgTypes, RetNestingLevel};
+ _Else ->
+ {RetCurrFun, RetCurrFunLabel, RetCalls, RetCode,
+ RetRaceList, RetRaceVarMap, RetFunDefVars,
+ RetFunCallVars, RetFunArgTypes, RetNestingLevel}
+ end
+ end
+ end,
+ DepList ++
+ fixup_race_forward_pullout(NewCurrFun1, NewCurrFunLabel1, NewCalls1,
+ NewCode1, NewRaceList1, InitFun, WarnVarArgs,
+ RaceWarnTag, NewRaceVarMap1, NewFunDefVars1,
+ NewFunCallVars1, NewFunArgTypes1,
+ NewNestingLevel1, State)
+ end.
+
+fixup_race_forward(CurrFun, CurrFunLabel, Calls, Code, RaceList,
+ InitFun, WarnVarArgs, RaceWarnTag, RaceVarMap,
+ FunDefVars, FunCallVars, FunArgTypes, NestingLevel,
+ State) ->
+ case Code of
+ [] ->
+ {[], CurrFun, CurrFunLabel, Calls, Code, RaceList, RaceVarMap,
+ FunDefVars, FunCallVars, FunArgTypes, NestingLevel};
+ [Head|Tail] ->
+ Callgraph = dialyzer_dataflow:state__get_callgraph(State),
+ {NewRL, DepList, NewNL, Return} =
+ case Head of
+ #dep_call{call_name = whereis} ->
+ case RaceWarnTag of
+ ?WARN_WHEREIS_REGISTER ->
+ {[Head#dep_call{var_map = RaceVarMap}|RaceList],
+ [], NestingLevel, false};
+ _Other ->
+ {RaceList, [], NestingLevel, false}
+ end;
+ #dep_call{call_name = ets_lookup, args = DepCallArgs} ->
+ case RaceWarnTag of
+ ?WARN_ETS_LOOKUP_INSERT ->
+ [Tab, Names, _, _] = DepCallArgs,
+ case compare_var_list(Tab,
+ dialyzer_callgraph:get_public_tables(Callgraph),
+ RaceVarMap)
+ orelse
+ length(Names --
+ dialyzer_callgraph:get_named_tables(Callgraph)) <
+ length(Names) of
+ true ->
+ {[Head#dep_call{var_map = RaceVarMap}|RaceList],
+ [], NestingLevel, false};
+ false ->
+ {RaceList, [], NestingLevel, false}
+ end;
+ _Other ->
+ {RaceList, [], NestingLevel, false}
+ end;
+ #dep_call{call_name = mnesia_dirty_read} ->
+ case RaceWarnTag of
+ ?WARN_MNESIA_DIRTY_READ_WRITE ->
+ {[Head#dep_call{var_map = RaceVarMap}|RaceList],
+ [], NestingLevel, false};
+ _Other ->
+ {RaceList, [], NestingLevel, false}
+ end;
+ #warn_call{call_name = register} ->
+ case RaceWarnTag of
+ ?WARN_WHEREIS_REGISTER ->
+ {[Head#warn_call{var_map = RaceVarMap}|RaceList],
+ [], NestingLevel, false};
+ _Other ->
+ {RaceList, [], NestingLevel, false}
+ end;
+ #warn_call{call_name = ets_insert, args = WarnCallArgs} ->
+ case RaceWarnTag of
+ ?WARN_ETS_LOOKUP_INSERT ->
+ [Tab, Names, _, _] = WarnCallArgs,
+ case compare_var_list(Tab,
+ dialyzer_callgraph:get_public_tables(Callgraph),
+ RaceVarMap)
+ orelse
+ length(Names --
+ dialyzer_callgraph:get_named_tables(Callgraph)) <
+ length(Names) of
+ true ->
+ {[Head#warn_call{var_map = RaceVarMap}|RaceList],
+ [], NestingLevel, false};
+ false ->
+ {RaceList, [], NestingLevel, false}
+ end;
+ _Other ->
+ {RaceList, [], NestingLevel, false}
+ end;
+ #warn_call{call_name = mnesia_dirty_write} ->
+ case RaceWarnTag of
+ ?WARN_MNESIA_DIRTY_READ_WRITE ->
+ {[Head#warn_call{var_map = RaceVarMap}|RaceList],
+ [], NestingLevel, false};
+ _Other ->
+ {RaceList, [], NestingLevel, false}
+ end;
+ #fun_call{caller = CurrFun, callee = InitFun} ->
+ {RaceList, [], NestingLevel, false};
+ #fun_call{caller = CurrFun} ->
+ {RaceList, [], NestingLevel - 1, false};
+ beg_case ->
+ {[Head|RaceList], [], NestingLevel, false};
+ #beg_clause{} ->
+ {[#beg_clause{}|RaceList], [], NestingLevel, false};
+ #end_clause{} ->
+ {[#end_clause{}|RaceList], [], NestingLevel, false};
+ #end_case{} ->
+ {[Head|RaceList], [], NestingLevel, false};
+ #let_tag{} ->
+ {RaceList, [], NestingLevel, false};
+ #curr_fun{status = in, mfa = InitFun,
+ label = _InitFunLabel, var_map = _NewRVM,
+ def_vars = NewFDV, call_vars = NewFCV,
+ arg_types = _NewFAT} ->
+ {[#curr_fun{status = out, var_map = RaceVarMap,
+ def_vars = NewFDV, call_vars = NewFCV}|
+ RaceList], [], NestingLevel - 1, false};
+ #curr_fun{status = in, def_vars = NewFDV,
+ call_vars = NewFCV} ->
+ {[#curr_fun{status = out, var_map = RaceVarMap,
+ def_vars = NewFDV, call_vars = NewFCV}|
+ RaceList],
+ [], NestingLevel - 1, false};
+ #curr_fun{status = out} ->
+ {[#curr_fun{status = in, var_map = RaceVarMap}|RaceList], [],
+ NestingLevel + 1, false};
+ RaceTag ->
+ PublicTables = dialyzer_callgraph:get_public_tables(Callgraph),
+ NamedTables = dialyzer_callgraph:get_named_tables(Callgraph),
+ WarnVarArgs1 =
+ var_type_analysis(FunDefVars, FunArgTypes, WarnVarArgs,
+ RaceWarnTag, RaceVarMap,
+ dialyzer_dataflow:state__records_only(State)),
+ {NewDepList, IsPublic, _Return} =
+ get_deplist_paths(RaceList, WarnVarArgs1, RaceWarnTag,
+ RaceVarMap, 0, PublicTables, NamedTables),
+ {NewHead, NewDepList1} =
+ case RaceTag of
+ whereis_register ->
+ {[#warn_call{call_name = register, args = WarnVarArgs,
+ var_map = RaceVarMap}],
+ NewDepList};
+ ets_lookup_insert ->
+ NewWarnCall =
+ [#warn_call{call_name = ets_insert, args = WarnVarArgs,
+ var_map = RaceVarMap}],
+ [Tab, Names, _, _] = WarnVarArgs,
+ case IsPublic orelse
+ compare_var_list(Tab, PublicTables, RaceVarMap)
+ orelse
+ length(Names -- NamedTables) < length(Names) of
+ true ->
+ {NewWarnCall, NewDepList};
+ false -> {NewWarnCall, []}
+ end;
+ mnesia_dirty_read_write ->
+ {[#warn_call{call_name = mnesia_dirty_write,
+ args = WarnVarArgs, var_map = RaceVarMap}],
+ NewDepList}
+ end,
+ {NewHead ++ RaceList, NewDepList1, NestingLevel,
+ is_last_race(RaceTag, InitFun, Tail, Callgraph)}
+ end,
+ {NewCurrFun, NewCurrFunLabel, NewCode, NewRaceList, NewRaceVarMap,
+ NewFunDefVars, NewFunCallVars, NewFunArgTypes, NewNestingLevel,
+ PullOut} =
+ case Head of
+ #fun_call{caller = CurrFun} ->
+ case NewNL =:= 0 of
+ true ->
+ {CurrFun, CurrFunLabel, Tail, NewRL, RaceVarMap,
+ FunDefVars, FunCallVars, FunArgTypes, NewNL, false};
+ false ->
+ {CurrFun, CurrFunLabel, Code, NewRL, RaceVarMap,
+ FunDefVars, FunCallVars, FunArgTypes, NewNL, true}
+ end;
+ #beg_clause{arg = Arg, pats = Pats, guard = Guard} ->
+ {RaceVarMap1, RemoveClause} =
+ race_var_map_guard(Arg, Pats, Guard, RaceVarMap, bind),
+ case RemoveClause of
+ true ->
+ {RaceList2,
+ #curr_fun{mfa = CurrFun2, label = CurrFunLabel2,
+ var_map = RaceVarMap2, def_vars = FunDefVars2,
+ call_vars = FunCallVars2, arg_types = FunArgTypes2},
+ Code2, NestingLevel2} =
+ remove_clause(NewRL,
+ #curr_fun{mfa = CurrFun, label = CurrFunLabel,
+ var_map = RaceVarMap1,
+ def_vars = FunDefVars,
+ call_vars = FunCallVars,
+ arg_types = FunArgTypes},
+ Tail, NewNL),
+ {CurrFun2, CurrFunLabel2, Code2, RaceList2,
+ RaceVarMap2, FunDefVars2, FunCallVars2, FunArgTypes2,
+ NestingLevel2, false};
+ false ->
+ {CurrFun, CurrFunLabel, Tail, NewRL, RaceVarMap1,
+ FunDefVars, FunCallVars, FunArgTypes, NewNL, false}
+ end;
+ #end_clause{arg = Arg, pats = Pats, guard = Guard} ->
+ {RaceVarMap1, _RemoveClause} =
+ race_var_map_guard(Arg, Pats, Guard, RaceVarMap, unbind),
+ {CurrFun, CurrFunLabel, Tail, NewRL, RaceVarMap1,
+ FunDefVars, FunCallVars, FunArgTypes, NewNL,
+ false};
+ #end_case{clauses = Clauses} ->
+ RaceVarMap1 =
+ race_var_map_clauses(Clauses, RaceVarMap),
+ {CurrFun, CurrFunLabel, Tail, NewRL, RaceVarMap1,
+ FunDefVars, FunCallVars, FunArgTypes, NewNL,
+ false};
+ #let_tag{var = Var, arg = Arg} ->
+ {CurrFun, CurrFunLabel, Tail, NewRL,
+ race_var_map(Var, Arg, RaceVarMap, bind), FunDefVars,
+ FunCallVars, FunArgTypes, NewNL, false};
+ #curr_fun{mfa = CurrFun1, label = CurrFunLabel1,
+ var_map = RaceVarMap1, def_vars = FunDefVars1,
+ call_vars = FunCallVars1, arg_types = FunArgTypes1} ->
+ case NewNL =:= 0 of
+ true ->
+ {CurrFun, CurrFunLabel,
+ remove_nonlocal_functions(Tail, 1), NewRL, RaceVarMap,
+ FunDefVars, FunCallVars, FunArgTypes, NewNL, false};
+ false ->
+ {CurrFun1, CurrFunLabel1, Tail, NewRL, RaceVarMap1,
+ FunDefVars1, FunCallVars1, FunArgTypes1, NewNL, false}
+ end;
+ _Thing ->
+ {CurrFun, CurrFunLabel, Tail, NewRL, RaceVarMap,
+ FunDefVars, FunCallVars, FunArgTypes, NewNL, false}
+ end,
+ case Return of
+ true ->
+ {DepList, NewCurrFun, NewCurrFunLabel, Calls,
+ [], NewRaceList, NewRaceVarMap, NewFunDefVars,
+ NewFunCallVars, NewFunArgTypes, NewNestingLevel};
+ false ->
+ NewNestingLevel1 =
+ case NewNestingLevel =:= 0 of
+ true -> NewNestingLevel + 1;
+ false -> NewNestingLevel
+ end,
+ case PullOut of
+ true ->
+ {DepList, NewCurrFun, NewCurrFunLabel, Calls,
+ NewCode, NewRaceList, NewRaceVarMap, NewFunDefVars,
+ NewFunCallVars, NewFunArgTypes, NewNestingLevel1};
+ false ->
+ {RetDepList, NewCurrFun1, NewCurrFunLabel1, NewCalls1,
+ NewCode1, NewRaceList1, NewRaceVarMap1, NewFunDefVars1,
+ NewFunCallVars1, NewFunArgTypes1, NewNestingLevel2} =
+ fixup_race_forward(NewCurrFun, NewCurrFunLabel, Calls,
+ NewCode, NewRaceList, InitFun, WarnVarArgs,
+ RaceWarnTag, NewRaceVarMap, NewFunDefVars,
+ NewFunCallVars, NewFunArgTypes,
+ NewNestingLevel1, State),
+ {DepList ++ RetDepList, NewCurrFun1, NewCurrFunLabel1,
+ NewCalls1, NewCode1, NewRaceList1, NewRaceVarMap1,
+ NewFunDefVars1, NewFunCallVars1, NewFunArgTypes1,
+ NewNestingLevel2}
+ end
+ end
+ end.
+
+get_deplist_paths(RaceList, WarnVarArgs, RaceWarnTag, RaceVarMap, CurrLevel,
+ PublicTables, NamedTables) ->
+ case RaceList of
+ [] -> {[], false, true};
+ [Head|Tail] ->
+ case Head of
+ #end_case{} ->
+ {RaceList1, DepList1, IsPublic1, Continue1} =
+ handle_case(Tail, WarnVarArgs, RaceWarnTag, RaceVarMap, CurrLevel,
+ PublicTables, NamedTables),
+ case Continue1 of
+ true ->
+ {DepList2, IsPublic2, Continue2} =
+ get_deplist_paths(RaceList1, WarnVarArgs, RaceWarnTag,
+ RaceVarMap, CurrLevel, PublicTables,
+ NamedTables),
+ {DepList1 ++ DepList2, IsPublic1 orelse IsPublic2, Continue2};
+ false -> {DepList1, IsPublic1, false}
+ end;
+ #beg_clause{} ->
+ get_deplist_paths(fixup_before_case_path(Tail), WarnVarArgs,
+ RaceWarnTag, RaceVarMap, CurrLevel, PublicTables,
+ NamedTables);
+ #curr_fun{status = in, var_map = RaceVarMap1} ->
+ {DepList, IsPublic, Continue} =
+ get_deplist_paths(Tail, WarnVarArgs, RaceWarnTag, RaceVarMap,
+ CurrLevel + 1, PublicTables, NamedTables),
+ IsPublic1 =
+ case RaceWarnTag of
+ ?WARN_ETS_LOOKUP_INSERT ->
+ [Tabs, Names, _, _] = WarnVarArgs,
+ IsPublic orelse
+ lists:any(
+ fun (T) ->
+ compare_var_list(T, PublicTables, RaceVarMap1)
+ end, Tabs)
+ orelse
+ length(Names -- NamedTables) < length(Names);
+ _ -> true
+ end,
+ {DepList, IsPublic1, Continue};
+ #curr_fun{status = out, var_map = RaceVarMap1, def_vars = FunDefVars,
+ call_vars = FunCallVars} ->
+ WarnVarArgs1 =
+ var_analysis([format_arg(DefVar) || DefVar <- FunDefVars],
+ [format_arg(CallVar) || CallVar <- FunCallVars],
+ WarnVarArgs, RaceWarnTag),
+ {WarnVarArgs2, Stop} =
+ case RaceWarnTag of
+ ?WARN_WHEREIS_REGISTER ->
+ [WVA1, WVA2, WVA3, WVA4] = WarnVarArgs1,
+ Vars =
+ lists:flatten(
+ [find_all_bound_vars(V, RaceVarMap1) || V <- WVA1]),
+ case {Vars, CurrLevel} of
+ {[], 0} ->
+ {WarnVarArgs, true};
+ {[], _} ->
+ {WarnVarArgs, false};
+ _ ->
+ {[Vars, WVA2, WVA3, WVA4], false}
+ end;
+ ?WARN_ETS_LOOKUP_INSERT ->
+ [WVA1, WVA2, WVA3, WVA4] = WarnVarArgs1,
+ Vars1 =
+ lists:flatten(
+ [find_all_bound_vars(V1, RaceVarMap1) || V1 <- WVA1]),
+ Vars2 =
+ lists:flatten(
+ [find_all_bound_vars(V2, RaceVarMap1) || V2 <- WVA3]),
+ case {Vars1, Vars2, CurrLevel} of
+ {[], _, 0} ->
+ {WarnVarArgs, true};
+ {[], _, _} ->
+ {WarnVarArgs, false};
+ {_, [], 0} ->
+ {WarnVarArgs, true};
+ {_, [], _} ->
+ {WarnVarArgs, false};
+ _ ->
+ {[Vars1, WVA2, Vars2, WVA4], false}
+ end;
+ ?WARN_MNESIA_DIRTY_READ_WRITE ->
+ [WVA1, WVA2|T] = WarnVarArgs1,
+ Vars =
+ lists:flatten(
+ [find_all_bound_vars(V, RaceVarMap1) || V <- WVA1]),
+ case {Vars, CurrLevel} of
+ {[], 0} ->
+ {WarnVarArgs, true};
+ {[], _} ->
+ {WarnVarArgs, false};
+ _ ->
+ {[Vars, WVA2|T], false}
+ end
+ end,
+ case Stop of
+ true -> {[], false, false};
+ false ->
+ CurrLevel1 =
+ case CurrLevel of
+ 0 -> CurrLevel;
+ _ -> CurrLevel - 1
+ end,
+ get_deplist_paths(Tail, WarnVarArgs2, RaceWarnTag, RaceVarMap1,
+ CurrLevel1, PublicTables, NamedTables)
+ end;
+ #warn_call{call_name = register, args = WarnVarArgs1,
+ var_map = RaceVarMap1} ->
+ case compare_first_arg(WarnVarArgs, WarnVarArgs1, RaceVarMap1) of
+ true -> {[], false, false};
+ NewWarnVarArgs ->
+ get_deplist_paths(Tail, NewWarnVarArgs, RaceWarnTag, RaceVarMap,
+ CurrLevel, PublicTables, NamedTables)
+ end;
+ #warn_call{call_name = ets_insert, args = WarnVarArgs1,
+ var_map = RaceVarMap1} ->
+ case compare_ets_insert(WarnVarArgs, WarnVarArgs1, RaceVarMap1) of
+ true -> {[], false, false};
+ NewWarnVarArgs ->
+ get_deplist_paths(Tail, NewWarnVarArgs, RaceWarnTag, RaceVarMap,
+ CurrLevel, PublicTables, NamedTables)
+ end;
+ #warn_call{call_name = mnesia_dirty_write, args = WarnVarArgs1,
+ var_map = RaceVarMap1} ->
+ case compare_first_arg(WarnVarArgs, WarnVarArgs1, RaceVarMap1) of
+ true -> {[], false, false};
+ NewWarnVarArgs ->
+ get_deplist_paths(Tail, NewWarnVarArgs, RaceWarnTag, RaceVarMap,
+ CurrLevel, PublicTables, NamedTables)
+ end;
+ #dep_call{var_map = RaceVarMap1} ->
+ {DepList, IsPublic, Continue} =
+ get_deplist_paths(Tail, WarnVarArgs, RaceWarnTag, RaceVarMap,
+ CurrLevel, PublicTables, NamedTables),
+ {refine_race(Head, WarnVarArgs, RaceWarnTag, DepList, RaceVarMap1),
+ IsPublic, Continue}
+ end
+ end.
+
+handle_case(RaceList, WarnVarArgs, RaceWarnTag, RaceVarMap, CurrLevel,
+ PublicTables, NamedTables) ->
+ case RaceList of
+ [] -> {[], [], false, true};
+ [Head|Tail] ->
+ case Head of
+ #end_clause{} ->
+ {RestRaceList, DepList1, IsPublic1, Continue1} =
+ do_clause(Tail, WarnVarArgs, RaceWarnTag, RaceVarMap, CurrLevel,
+ PublicTables, NamedTables),
+ {RetRaceList, DepList2, IsPublic2, Continue2} =
+ handle_case(RestRaceList, WarnVarArgs, RaceWarnTag, RaceVarMap,
+ CurrLevel, PublicTables, NamedTables),
+ {RetRaceList, DepList1 ++ DepList2, IsPublic1 orelse IsPublic2,
+ Continue1 orelse Continue2};
+ beg_case -> {Tail, [], false, false}
+ end
+ end.
+
+do_clause(RaceList, WarnVarArgs, RaceWarnTag, RaceVarMap, CurrLevel,
+ PublicTables, NamedTables) ->
+ {DepList, IsPublic, Continue} =
+ get_deplist_paths(fixup_case_path(RaceList, 0), WarnVarArgs,
+ RaceWarnTag, RaceVarMap, CurrLevel,
+ PublicTables, NamedTables),
+ {fixup_case_rest_paths(RaceList, 0), DepList, IsPublic, Continue}.
+
+fixup_case_path(RaceList, NestingLevel) ->
+ case RaceList of
+ [] -> [];
+ [Head|Tail] ->
+ {NewNestingLevel, Return} =
+ case Head of
+ beg_case -> {NestingLevel - 1, false};
+ #end_case{} -> {NestingLevel + 1, false};
+ #beg_clause{} ->
+ case NestingLevel =:= 0 of
+ true -> {NestingLevel, true};
+ false -> {NestingLevel, false}
+ end;
+ _Other -> {NestingLevel, false}
+ end,
+ case Return of
+ true -> [];
+ false -> [Head|fixup_case_path(Tail, NewNestingLevel)]
+ end
+ end.
+
+%% Gets the race list before a case clause.
+fixup_before_case_path(RaceList) ->
+ case RaceList of
+ [] -> [];
+ [Head|Tail] ->
+ case Head of
+ #end_clause{} ->
+ fixup_before_case_path(fixup_case_rest_paths(Tail, 0));
+ beg_case -> Tail
+ end
+ end.
+
+fixup_case_rest_paths(RaceList, NestingLevel) ->
+ case RaceList of
+ [] -> [];
+ [Head|Tail] ->
+ {NewNestingLevel, Return} =
+ case Head of
+ beg_case -> {NestingLevel - 1, false};
+ #end_case{} -> {NestingLevel + 1, false};
+ #beg_clause{} ->
+ case NestingLevel =:= 0 of
+ true -> {NestingLevel, true};
+ false -> {NestingLevel, false}
+ end;
+ _Other -> {NestingLevel, false}
+ end,
+ case Return of
+ true -> Tail;
+ false -> fixup_case_rest_paths(Tail, NewNestingLevel)
+ end
+ end.
+
+fixup_race_forward_helper(CurrFun, CurrFunLabel, Fun, FunLabel,
+ Calls, CallsToAnalyze, Code, RaceList,
+ InitFun, NewFunArgs, NewFunTypes,
+ RaceWarnTag, RaceVarMap, FunDefVars,
+ FunCallVars, FunArgTypes, NestingLevel,
+ Args, CodeB, StateRaceList) ->
+ case Calls of
+ [] ->
+ {NewRaceList,
+ #curr_fun{mfa = NewCurrFun, label = NewCurrFunLabel,
+ var_map = NewRaceVarMap, def_vars = NewFunDefVars,
+ call_vars = NewFunCallVars, arg_types = NewFunArgTypes},
+ NewCode, NewNestingLevel} =
+ remove_clause(RaceList,
+ #curr_fun{mfa = CurrFun, label = CurrFunLabel, var_map = RaceVarMap,
+ def_vars = FunDefVars, call_vars = FunCallVars,
+ arg_types = FunArgTypes},
+ Code, NestingLevel),
+ {NewCurrFun, NewCurrFunLabel, CallsToAnalyze, NewCode, NewRaceList,
+ NewRaceVarMap, NewFunDefVars, NewFunCallVars, NewFunArgTypes,
+ NewNestingLevel};
+ [Head|Tail] ->
+ case Head of
+ {InitFun, InitFun} when CurrFun =:= InitFun, Fun =:= InitFun ->
+ NewCallsToAnalyze = lists:delete(Head, CallsToAnalyze),
+ NewRaceVarMap =
+ race_var_map(Args, NewFunArgs, RaceVarMap, bind),
+ RetC =
+ fixup_all_calls(InitFun, InitFun, FunLabel, Args,
+ CodeB ++
+ [#curr_fun{status = out, mfa = InitFun,
+ label = CurrFunLabel, var_map = RaceVarMap,
+ def_vars = FunDefVars, call_vars = FunCallVars,
+ arg_types = FunArgTypes}],
+ Code, RaceVarMap),
+ NewCode =
+ fixup_all_calls(InitFun, InitFun, FunLabel, Args,
+ CodeB ++
+ [#curr_fun{status = out, mfa = InitFun,
+ label = CurrFunLabel, var_map = NewRaceVarMap,
+ def_vars = Args, call_vars = NewFunArgs,
+ arg_types = NewFunTypes}],
+ [#curr_fun{status = in, mfa = Fun,
+ label = FunLabel, var_map = NewRaceVarMap,
+ def_vars = Args, call_vars = NewFunArgs,
+ arg_types = NewFunTypes}|
+ lists:reverse(StateRaceList)] ++
+ RetC, NewRaceVarMap),
+ {InitFun, FunLabel, NewCallsToAnalyze, NewCode, RaceList,
+ NewRaceVarMap, Args, NewFunArgs, NewFunTypes, NestingLevel};
+ {CurrFun, Fun} ->
+ NewCallsToAnalyze = lists:delete(Head, CallsToAnalyze),
+ NewRaceVarMap =
+ race_var_map(Args, NewFunArgs, RaceVarMap, bind),
+ RetC =
+ case Fun of
+ InitFun ->
+ fixup_all_calls(CurrFun, Fun, FunLabel, Args,
+ lists:reverse(StateRaceList) ++
+ [#curr_fun{status = out, mfa = CurrFun,
+ label = CurrFunLabel, var_map = RaceVarMap,
+ def_vars = FunDefVars, call_vars = FunCallVars,
+ arg_types = FunArgTypes}],
+ Code, RaceVarMap);
+ _Other1 ->
+ fixup_all_calls(CurrFun, Fun, FunLabel, Args,
+ CodeB ++
+ [#curr_fun{status = out, mfa = CurrFun,
+ label = CurrFunLabel, var_map = RaceVarMap,
+ def_vars = FunDefVars, call_vars = FunCallVars,
+ arg_types = FunArgTypes}],
+ Code, RaceVarMap)
+ end,
+ NewCode =
+ case Fun of
+ InitFun ->
+ [#curr_fun{status = in, mfa = Fun,
+ label = FunLabel, var_map = NewRaceVarMap,
+ def_vars = Args, call_vars = NewFunArgs,
+ arg_types = NewFunTypes}|
+ lists:reverse(StateRaceList)] ++
+ RetC;
+ _ ->
+ [#curr_fun{status = in, mfa = Fun,
+ label = FunLabel, var_map = NewRaceVarMap,
+ def_vars = Args, call_vars = NewFunArgs,
+ arg_types = NewFunTypes}|CodeB] ++
+ RetC
+ end,
+ {Fun, FunLabel, NewCallsToAnalyze, NewCode, RaceList, NewRaceVarMap,
+ Args, NewFunArgs, NewFunTypes, NestingLevel};
+ {_TupleA, _TupleB} ->
+ fixup_race_forward_helper(CurrFun, CurrFunLabel, Fun, FunLabel,
+ Tail, CallsToAnalyze, Code, RaceList, InitFun, NewFunArgs,
+ NewFunTypes, RaceWarnTag, RaceVarMap, FunDefVars, FunCallVars,
+ FunArgTypes, NestingLevel, Args, CodeB, StateRaceList)
+ end
+ end.
+
+%%% ===========================================================================
+%%%
+%%% Backward Analysis
+%%%
+%%% ===========================================================================
+
+fixup_race_backward(CurrFun, Calls, CallsToAnalyze, Parents, Height) ->
+ case Height =:= 0 of
+ true -> Parents;
+ false ->
+ case Calls of
+ [] ->
+ case is_integer(CurrFun) orelse lists:member(CurrFun, Parents) of
+ true -> Parents;
+ false -> [CurrFun|Parents]
+ end;
+ [Head|Tail] ->
+ MorePaths =
+ case Head of
+ {Parent, CurrFun} -> true;
+ {Parent, _TupleB} -> false
+ end,
+ case MorePaths of
+ true ->
+ NewCallsToAnalyze = lists:delete(Head, CallsToAnalyze),
+ NewParents =
+ fixup_race_backward(Parent, NewCallsToAnalyze,
+ NewCallsToAnalyze, Parents, Height - 1),
+ fixup_race_backward(CurrFun, Tail, NewCallsToAnalyze, NewParents,
+ Height);
+ false ->
+ fixup_race_backward(CurrFun, Tail, CallsToAnalyze, Parents,
+ Height)
+ end
+ end
+ end.
+
+%%% ===========================================================================
+%%%
+%%% Utilities
+%%%
+%%% ===========================================================================
+
+are_bound_labels(Label1, Label2, RaceVarMap) ->
+ case dict:find(Label1, RaceVarMap) of
+ error -> false;
+ {ok, Labels} ->
+ lists:member(Label2, Labels) orelse
+ are_bound_labels_helper(Labels, Label1, Label2, RaceVarMap)
+ end.
+
+are_bound_labels_helper(Labels, OldLabel, CompLabel, RaceVarMap) ->
+ case dict:size(RaceVarMap) of
+ 0 -> false;
+ _ ->
+ case Labels of
+ [] -> false;
+ [Head|Tail] ->
+ NewRaceVarMap = dict:erase(OldLabel, RaceVarMap),
+ are_bound_labels(Head, CompLabel, NewRaceVarMap) orelse
+ are_bound_labels_helper(Tail, Head, CompLabel, NewRaceVarMap)
+ end
+ end.
+
+are_bound_vars(Vars1, Vars2, RaceVarMap) ->
+ case is_list(Vars1) andalso is_list(Vars2) of
+ true ->
+ case Vars1 of
+ [] -> false;
+ [AHead|ATail] ->
+ case Vars2 of
+ [] -> false;
+ [PHead|PTail] ->
+ are_bound_vars(AHead, PHead, RaceVarMap) andalso
+ are_bound_vars(ATail, PTail, RaceVarMap)
+ end
+ end;
+ false ->
+ {NewVars1, NewVars2, IsList} =
+ case is_list(Vars1) of
+ true ->
+ case Vars1 of
+ [Var1] -> {Var1, Vars2, true};
+ _Thing -> {Vars1, Vars2, false}
+ end;
+ false ->
+ case is_list(Vars2) of
+ true ->
+ case Vars2 of
+ [Var2] -> {Vars1, Var2, true};
+ _Thing -> {Vars1, Vars2, false}
+ end;
+ false -> {Vars1, Vars2, true}
+ end
+ end,
+ case IsList of
+ true ->
+ case cerl:type(NewVars1) of
+ var ->
+ case cerl:type(NewVars2) of
+ var ->
+ ALabel = cerl_trees:get_label(NewVars1),
+ PLabel = cerl_trees:get_label(NewVars2),
+ are_bound_labels(ALabel, PLabel, RaceVarMap) orelse
+ are_bound_labels(PLabel, ALabel, RaceVarMap);
+ alias ->
+ are_bound_vars(NewVars1, cerl:alias_var(NewVars2),
+ RaceVarMap);
+ values ->
+ are_bound_vars(NewVars1, cerl:values_es(NewVars2),
+ RaceVarMap);
+ _Other -> false
+ end;
+ tuple ->
+ case cerl:type(NewVars2) of
+ tuple ->
+ are_bound_vars(cerl:tuple_es(NewVars1),
+ cerl:tuple_es(NewVars2), RaceVarMap);
+ alias ->
+ are_bound_vars(NewVars1, cerl:alias_var(NewVars2),
+ RaceVarMap);
+ values ->
+ are_bound_vars(NewVars1, cerl:values_es(NewVars2),
+ RaceVarMap);
+ _Other -> false
+ end;
+ cons ->
+ case cerl:type(NewVars2) of
+ cons ->
+ are_bound_vars(cerl:cons_hd(NewVars1),
+ cerl:cons_hd(NewVars2), RaceVarMap)
+ andalso
+ are_bound_vars(cerl:cons_tl(NewVars1),
+ cerl:cons_tl(NewVars2), RaceVarMap);
+ alias ->
+ are_bound_vars(NewVars1, cerl:alias_var(NewVars2),
+ RaceVarMap);
+ values ->
+ are_bound_vars(NewVars1, cerl:values_es(NewVars2),
+ RaceVarMap);
+ _Other -> false
+ end;
+ alias ->
+ case cerl:type(NewVars2) of
+ alias ->
+ are_bound_vars(cerl:alias_var(NewVars1),
+ cerl:alias_var(NewVars2), RaceVarMap);
+ _Other ->
+ are_bound_vars(cerl:alias_var(NewVars1),
+ NewVars2, RaceVarMap)
+ end;
+ values ->
+ case cerl:type(NewVars2) of
+ values ->
+ are_bound_vars(cerl:values_es(NewVars1),
+ cerl:values_es(NewVars2), RaceVarMap);
+ _Other ->
+ are_bound_vars(cerl:values_es(NewVars1),
+ NewVars2, RaceVarMap)
+ end;
+ _Other -> false
+ end;
+ false -> false
+ end
+ end.
+
+callgraph__renew_tables(Table, Callgraph) ->
+ case Table of
+ {named, NameLabel, Names} ->
+ PTablesToAdd =
+ case NameLabel of
+ ?no_label -> [];
+ _Other -> [NameLabel]
+ end,
+ NamesToAdd = filter_named_tables(Names),
+ PTables = dialyzer_callgraph:get_public_tables(Callgraph),
+ NTables = dialyzer_callgraph:get_named_tables(Callgraph),
+ dialyzer_callgraph:put_public_tables(
+ lists:usort(PTablesToAdd ++ PTables),
+ dialyzer_callgraph:put_named_tables(
+ NamesToAdd ++ NTables, Callgraph));
+ _Other ->
+ Callgraph
+ end.
+
+cleanup_clause_code(#curr_fun{mfa = CurrFun} = CurrTuple, Code,
+ NestingLevel, LocalNestingLevel) ->
+ case Code of
+ [] -> {CurrTuple, []};
+ [Head|Tail] ->
+ {NewLocalNestingLevel, NewNestingLevel, NewCurrTuple, Return} =
+ case Head of
+ beg_case ->
+ {LocalNestingLevel, NestingLevel + 1, CurrTuple, false};
+ #end_case{} ->
+ {LocalNestingLevel, NestingLevel - 1, CurrTuple, false};
+ #end_clause{} ->
+ case NestingLevel =:= 0 of
+ true ->
+ {LocalNestingLevel, NestingLevel, CurrTuple, true};
+ false ->
+ {LocalNestingLevel, NestingLevel, CurrTuple, false}
+ end;
+ #fun_call{caller = CurrFun} ->
+ {LocalNestingLevel - 1, NestingLevel, CurrTuple, false};
+ #curr_fun{status = in} ->
+ {LocalNestingLevel - 1, NestingLevel, Head, false};
+ #curr_fun{status = out} ->
+ {LocalNestingLevel + 1, NestingLevel, Head, false};
+ Other when Other =/= #fun_call{} ->
+ {LocalNestingLevel, NestingLevel, CurrTuple, false}
+ end,
+ case Return of
+ true -> {NewCurrTuple, Tail};
+ false ->
+ cleanup_clause_code(NewCurrTuple, Tail, NewNestingLevel,
+ NewLocalNestingLevel)
+ end
+ end.
+
+cleanup_dep_calls(DepList) ->
+ case DepList of
+ [] -> [];
+ [#dep_call{call_name = CallName, arg_types = ArgTypes,
+ vars = Vars, state = State, file_line = FileLine}|T] ->
+ [#dep_call{call_name = CallName, arg_types = ArgTypes,
+ vars = Vars, state = State, file_line = FileLine}|
+ cleanup_dep_calls(T)]
+ end.
+
+cleanup_race_code(State) ->
+ Callgraph = dialyzer_dataflow:state__get_callgraph(State),
+ dialyzer_dataflow:state__put_callgraph(
+ dialyzer_callgraph:race_code_new(Callgraph), State).
+
+filter_named_tables(NamesList) ->
+ case NamesList of
+ [] -> [];
+ [Head|Tail] ->
+ NewHead =
+ case string:rstr(Head, "()") of
+ 0 -> [Head];
+ _Other -> []
+ end,
+ NewHead ++ filter_named_tables(Tail)
+ end.
+
+filter_parents(Parents, NewParents, Digraph) ->
+ case Parents of
+ [] -> NewParents;
+ [Head|Tail] ->
+ NewParents1 = filter_parents_helper1(Head, Tail, NewParents, Digraph),
+ filter_parents(Tail, NewParents1, Digraph)
+ end.
+
+filter_parents_helper1(First, Rest, NewParents, Digraph) ->
+ case Rest of
+ [] -> NewParents;
+ [Head|Tail] ->
+ NewParents1 = filter_parents_helper2(First, Head, NewParents, Digraph),
+ filter_parents_helper1(First, Tail, NewParents1, Digraph)
+ end.
+
+filter_parents_helper2(Parent1, Parent2, NewParents, Digraph) ->
+ case digraph:get_path(Digraph, Parent1, Parent2) of
+ false ->
+ case digraph:get_path(Digraph, Parent2, Parent1) of
+ false -> NewParents;
+ _Vertices -> NewParents -- [Parent1]
+ end;
+ _Vertices -> NewParents -- [Parent2]
+ end.
+
+find_all_bound_vars(Label, RaceVarMap) ->
+ case dict:find(Label, RaceVarMap) of
+ error -> [Label];
+ {ok, Labels} ->
+ lists:usort(Labels ++
+ find_all_bound_vars_helper(Labels, Label, RaceVarMap))
+ end.
+
+find_all_bound_vars_helper(Labels, Label, RaceVarMap) ->
+ case dict:size(RaceVarMap) of
+ 0 -> [];
+ _ ->
+ case Labels of
+ [] -> [];
+ [Head|Tail] ->
+ NewRaceVarMap = dict:erase(Label, RaceVarMap),
+ find_all_bound_vars(Head, NewRaceVarMap) ++
+ find_all_bound_vars_helper(Tail, Head, NewRaceVarMap)
+ end
+ end.
+
+fixup_all_calls(CurrFun, NextFun, NextFunLabel, Args, CodeToReplace,
+ Code, RaceVarMap) ->
+ case Code of
+ [] -> [];
+ [Head|Tail] ->
+ NewCode =
+ case Head of
+ #fun_call{caller = CurrFun, callee = Callee,
+ arg_types = FunArgTypes, vars = FunArgs}
+ when Callee =:= NextFun orelse Callee =:= NextFunLabel ->
+ RaceVarMap1 = race_var_map(Args, FunArgs, RaceVarMap, bind),
+ [#curr_fun{status = in, mfa = NextFun, label = NextFunLabel,
+ var_map = RaceVarMap1, def_vars = Args,
+ call_vars = FunArgs, arg_types = FunArgTypes}|
+ CodeToReplace];
+ _Other -> [Head]
+ end,
+ RetCode =
+ fixup_all_calls(CurrFun, NextFun, NextFunLabel, Args, CodeToReplace,
+ Tail, RaceVarMap),
+ NewCode ++ RetCode
+ end.
+
+is_last_race(RaceTag, InitFun, Code, Callgraph) ->
+ case Code of
+ [] -> true;
+ [Head|Tail] ->
+ case Head of
+ RaceTag -> false;
+ #fun_call{callee = Fun} ->
+ FunName =
+ case is_integer(Fun) of
+ true ->
+ case dialyzer_callgraph:lookup_name(Fun, Callgraph) of
+ error -> Fun;
+ {ok, Name} -> Name
+ end;
+ false -> Fun
+ end,
+ Digraph = dialyzer_callgraph:get_digraph(Callgraph),
+ case FunName =:= InitFun orelse
+ digraph:get_path(Digraph, FunName, InitFun) of
+ false -> is_last_race(RaceTag, InitFun, Tail, Callgraph);
+ _Vertices -> false
+ end;
+ _Other -> is_last_race(RaceTag, InitFun, Tail, Callgraph)
+ end
+ end.
+
+lists_key_member(Member, List, N) when is_integer(Member) ->
+ case List of
+ [] -> 0;
+ [Head|Tail] ->
+ NewN = N + 1,
+ case Head of
+ Member -> NewN;
+ _Other -> lists_key_member(Member, Tail, NewN)
+ end
+ end;
+lists_key_member(_M, _L, _N) ->
+ 0.
+
+lists_key_member_lists(MemberList, List) ->
+ case MemberList of
+ [] -> 0;
+ [Head|Tail] ->
+ case lists_key_member(Head, List, 0) of
+ 0 -> lists_key_member_lists(Tail, List);
+ Other -> Other
+ end
+ end.
+
+lists_key_members_lists(MemberList, List) ->
+ case MemberList of
+ [] -> [];
+ [Head|Tail] ->
+ lists:usort(
+ lists_key_members_lists_helper(Head, List, 1) ++
+ lists_key_members_lists(Tail, List))
+ end.
+
+lists_key_members_lists_helper(Elem, List, N) when is_integer(Elem) ->
+ case List of
+ [] -> [];
+ [Head|Tail] ->
+ NewHead =
+ case Head =:= Elem of
+ true -> [N];
+ false -> []
+ end,
+ NewHead ++ lists_key_members_lists_helper(Elem, Tail, N + 1)
+ end;
+lists_key_members_lists_helper(_Elem, _List, _N) ->
+ [0].
+
+lists_key_replace(N, List, NewMember) ->
+ {Before, [_|After]} = lists:split(N - 1, List),
+ Before ++ [NewMember|After].
+
+lists_get(0, _List) -> ?no_label;
+lists_get(N, List) -> lists:nth(N, List).
+
+refine_race(RaceCall, WarnVarArgs, RaceWarnTag, DependencyList, RaceVarMap) ->
+ case RaceWarnTag of
+ ?WARN_WHEREIS_REGISTER ->
+ case RaceCall of
+ #dep_call{call_name = ets_lookup} ->
+ DependencyList;
+ #dep_call{call_name = mnesia_dirty_read} ->
+ DependencyList;
+ #dep_call{call_name = whereis, args = VarArgs} ->
+ refine_race_helper(RaceCall, VarArgs, WarnVarArgs, RaceWarnTag,
+ DependencyList, RaceVarMap)
+ end;
+ ?WARN_ETS_LOOKUP_INSERT ->
+ case RaceCall of
+ #dep_call{call_name = whereis} ->
+ DependencyList;
+ #dep_call{call_name = mnesia_dirty_read} ->
+ DependencyList;
+ #dep_call{call_name = ets_lookup, args = VarArgs} ->
+ refine_race_helper(RaceCall, VarArgs, WarnVarArgs, RaceWarnTag,
+ DependencyList, RaceVarMap)
+ end;
+ ?WARN_MNESIA_DIRTY_READ_WRITE ->
+ case RaceCall of
+ #dep_call{call_name = whereis} ->
+ DependencyList;
+ #dep_call{call_name = ets_lookup} ->
+ DependencyList;
+ #dep_call{call_name = mnesia_dirty_read, args = VarArgs} ->
+ refine_race_helper(RaceCall, VarArgs, WarnVarArgs, RaceWarnTag,
+ DependencyList, RaceVarMap)
+ end
+ end.
+
+refine_race_helper(RaceCall, VarArgs, WarnVarArgs, RaceWarnTag, DependencyList,
+ RaceVarMap) ->
+ case compare_types(VarArgs, WarnVarArgs, RaceWarnTag, RaceVarMap) of
+ true -> [RaceCall|DependencyList];
+ false -> DependencyList
+ end.
+
+remove_clause(RaceList, CurrTuple, Code, NestingLevel) ->
+ NewRaceList = fixup_case_rest_paths(RaceList, 0),
+ {NewCurrTuple, NewCode} =
+ cleanup_clause_code(CurrTuple, Code, 0, NestingLevel),
+ ReturnTuple = {NewRaceList, NewCurrTuple, NewCode, NestingLevel},
+ case NewRaceList of
+ [beg_case|RTail] ->
+ case NewCode of
+ [#end_case{}|CTail] ->
+ remove_clause(RTail, NewCurrTuple, CTail, NestingLevel);
+ _Other -> ReturnTuple
+ end;
+ _Else -> ReturnTuple
+ end.
+
+remove_nonlocal_functions(Code, NestingLevel) ->
+ case Code of
+ [] -> [];
+ [H|T] ->
+ NewNL =
+ case H of
+ #curr_fun{status = in} ->
+ NestingLevel + 1;
+ #curr_fun{status = out} ->
+ NestingLevel - 1;
+ _Other ->
+ NestingLevel
+ end,
+ case NewNL =:= 0 of
+ true -> T;
+ false -> remove_nonlocal_functions(T, NewNL)
+ end
+ end.
+
+renew_curr_fun(CurrFun, Races) ->
+ Races#races{curr_fun = CurrFun}.
+
+renew_curr_fun_label(CurrFunLabel, Races) ->
+ Races#races{curr_fun_label = CurrFunLabel}.
+
+renew_race_list(RaceList, Races) ->
+ Races#races{race_list = RaceList}.
+
+renew_race_list_size(RaceListSize, Races) ->
+ Races#races{race_list_size = RaceListSize}.
+
+renew_race_tags(RaceTags, Races) ->
+ Races#races{race_tags = RaceTags}.
+
+renew_table(Table, Races) ->
+ Races#races{new_table = Table}.
+
+state__renew_curr_fun(CurrFun, State) ->
+ Races = dialyzer_dataflow:state__get_races(State),
+ dialyzer_dataflow:state__put_races(renew_curr_fun(CurrFun, Races), State).
+
+state__renew_curr_fun_label(CurrFunLabel, State) ->
+ Races = dialyzer_dataflow:state__get_races(State),
+ dialyzer_dataflow:state__put_races(
+ renew_curr_fun_label(CurrFunLabel, Races), State).
+
+state__renew_race_list(RaceList, State) ->
+ Races = dialyzer_dataflow:state__get_races(State),
+ dialyzer_dataflow:state__put_races(renew_race_list(RaceList, Races), State).
+
+state__renew_race_tags(RaceTags, State) ->
+ Races = dialyzer_dataflow:state__get_races(State),
+ dialyzer_dataflow:state__put_races(renew_race_tags(RaceTags, Races), State).
+
+state__renew_info(RaceList, RaceListSize, RaceTags, Table, State) ->
+ Callgraph = dialyzer_dataflow:state__get_callgraph(State),
+ Races = dialyzer_dataflow:state__get_races(State),
+ dialyzer_dataflow:state__put_callgraph(
+ callgraph__renew_tables(Table, Callgraph),
+ dialyzer_dataflow:state__put_races(
+ renew_table(Table,
+ renew_race_list(RaceList,
+ renew_race_list_size(RaceListSize,
+ renew_race_tags(RaceTags, Races)))), State)).
+
+%%% ===========================================================================
+%%%
+%%% Variable and Type Utilities
+%%%
+%%% ===========================================================================
+
+any_args(StrList) ->
+ case StrList of
+ [] -> false;
+ [Head|Tail] ->
+ case string:rstr(Head, "()") of
+ 0 -> any_args(Tail);
+ _Other -> true
+ end
+ end.
+
+-spec bind_dict_vars(label(), label(), dict()) -> dict().
+
+bind_dict_vars(Key, Label, RaceVarMap) ->
+ case Key =:= Label of
+ true -> RaceVarMap;
+ false ->
+ case dict:find(Key, RaceVarMap) of
+ error -> dict:store(Key, [Label], RaceVarMap);
+ {ok, Labels} ->
+ case lists:member(Label, Labels) of
+ true -> RaceVarMap;
+ false -> dict:store(Key, [Label|Labels], RaceVarMap)
+ end
+ end
+ end.
+
+bind_dict_vars_list(Key, Labels, RaceVarMap) ->
+ case Labels of
+ [] -> RaceVarMap;
+ [Head|Tail] ->
+ bind_dict_vars_list(Key, Tail, bind_dict_vars(Key, Head, RaceVarMap))
+ end.
+
+compare_ets_insert(OldWarnVarArgs, NewWarnVarArgs, RaceVarMap) ->
+ [Old1, Old2, Old3, Old4] = OldWarnVarArgs,
+ [New1, New2, New3, New4] = NewWarnVarArgs,
+ Bool =
+ case any_args(Old2) of
+ true -> compare_var_list(New1, Old1, RaceVarMap);
+ false ->
+ case any_args(New2) of
+ true -> compare_var_list(New1, Old1, RaceVarMap);
+ false -> compare_var_list(New1, Old1, RaceVarMap)
+ orelse (Old2 =:= New2)
+ end
+ end,
+ case Bool of
+ true ->
+ case any_args(Old4) of
+ true ->
+ case compare_list_vars(Old3, ets_list_args(New3), [], RaceVarMap) of
+ true -> true;
+ Args3 -> lists_key_replace(3, OldWarnVarArgs, Args3)
+ end;
+ false ->
+ case any_args(New4) of
+ true ->
+ case compare_list_vars(Old3, ets_list_args(New3), [],
+ RaceVarMap) of
+ true -> true;
+ Args3 -> lists_key_replace(3, OldWarnVarArgs, Args3)
+ end;
+ false ->
+ case compare_list_vars(Old3, ets_list_args(New3), [],
+ RaceVarMap) of
+ true -> true;
+ Args3 ->
+ lists_key_replace(4,
+ lists_key_replace(3, OldWarnVarArgs, Args3), Old4 -- New4)
+ end
+ end
+ end;
+ false -> OldWarnVarArgs
+ end.
+
+compare_first_arg(OldWarnVarArgs, NewWarnVarArgs, RaceVarMap) ->
+ [Old1, Old2|_OldT] = OldWarnVarArgs,
+ [New1, New2|_NewT] = NewWarnVarArgs,
+ case any_args(Old2) of
+ true ->
+ case compare_var_list(New1, Old1, RaceVarMap) of
+ true -> true;
+ false -> OldWarnVarArgs
+ end;
+ false ->
+ case any_args(New2) of
+ true ->
+ case compare_var_list(New1, Old1, RaceVarMap) of
+ true -> true;
+ false -> OldWarnVarArgs
+ end;
+ false ->
+ case compare_var_list(New1, Old1, RaceVarMap) of
+ true -> true;
+ false -> lists_key_replace(2, OldWarnVarArgs, Old2 -- New2)
+ end
+ end
+ end.
+
+compare_argtypes(ArgTypes, WarnArgTypes) ->
+ lists:any(fun (X) -> lists:member(X, WarnArgTypes) end, ArgTypes).
+
+%% Compares the argument types of the two suspicious calls.
+compare_types(VarArgs, WarnVarArgs, RaceWarnTag, RaceVarMap) ->
+ case RaceWarnTag of
+ ?WARN_WHEREIS_REGISTER ->
+ [VA1, VA2] = VarArgs,
+ [WVA1, WVA2, _, _] = WarnVarArgs,
+ case any_args(VA2) of
+ true -> compare_var_list(VA1, WVA1, RaceVarMap);
+ false ->
+ case any_args(WVA2) of
+ true -> compare_var_list(VA1, WVA1, RaceVarMap);
+ false ->
+ compare_var_list(VA1, WVA1, RaceVarMap) orelse
+ compare_argtypes(VA2, WVA2)
+
+ end
+ end;
+ ?WARN_ETS_LOOKUP_INSERT ->
+ [VA1, VA2, VA3, VA4] = VarArgs,
+ [WVA1, WVA2, WVA3, WVA4] = WarnVarArgs,
+ Bool =
+ case any_args(VA2) of
+ true -> compare_var_list(VA1, WVA1, RaceVarMap);
+ false ->
+ case any_args(WVA2) of
+ true -> compare_var_list(VA1, WVA1, RaceVarMap);
+ false ->
+ compare_var_list(VA1, WVA1, RaceVarMap) orelse
+ compare_argtypes(VA2, WVA2)
+ end
+ end,
+ Bool andalso
+ (case any_args(VA4) of
+ true ->
+ compare_var_list(VA3, WVA3, RaceVarMap);
+ false ->
+ case any_args(WVA4) of
+ true ->
+ compare_var_list(VA3, WVA3, RaceVarMap);
+ false ->
+ compare_var_list(VA3, WVA3, RaceVarMap)
+ orelse compare_argtypes(VA4, WVA4)
+ end
+ end);
+ ?WARN_MNESIA_DIRTY_READ_WRITE ->
+ [VA1, VA2|_] = VarArgs, %% Two or four elements
+ [WVA1, WVA2|_] = WarnVarArgs,
+ case any_args(VA2) of
+ true -> compare_var_list(VA1, WVA1, RaceVarMap);
+ false ->
+ case any_args(WVA2) of
+ true -> compare_var_list(VA1, WVA1, RaceVarMap);
+ false ->
+ compare_var_list(VA1, WVA1, RaceVarMap) orelse
+ compare_argtypes(VA2, WVA2)
+ end
+ end
+ end.
+
+compare_list_vars(VarList1, VarList2, NewVarList1, RaceVarMap) ->
+ case VarList1 of
+ [] ->
+ case NewVarList1 of
+ [] -> true;
+ _Other -> NewVarList1
+ end;
+ [Head|Tail] ->
+ NewHead =
+ case compare_var_list(Head, VarList2, RaceVarMap) of
+ true -> [];
+ false -> [Head]
+ end,
+ compare_list_vars(Tail, VarList2, NewHead ++ NewVarList1, RaceVarMap)
+ end.
+
+compare_vars(Var1, Var2, RaceVarMap) when is_integer(Var1), is_integer(Var2) ->
+ Var1 =:= Var2 orelse
+ are_bound_labels(Var1, Var2, RaceVarMap) orelse
+ are_bound_labels(Var2, Var1, RaceVarMap);
+compare_vars(_Var1, _Var2, _RaceVarMap) ->
+ false.
+
+-spec compare_var_list(label_type(), [label_type()], dict()) -> boolean().
+
+compare_var_list(Var, VarList, RaceVarMap) ->
+ lists:any(fun (V) -> compare_vars(Var, V, RaceVarMap) end, VarList).
+
+ets_list_args(MaybeList) ->
+ case is_list(MaybeList) of
+ true -> [ets_tuple_args(T) || T <- MaybeList];
+ false -> [ets_tuple_args(MaybeList)]
+ end.
+
+ets_list_argtypes(ListStr) ->
+ ListStr1 = string:strip(ListStr, left, $[),
+ ListStr2 = string:strip(ListStr1, right, $]),
+ ListStr3 = string:strip(ListStr2, right, $.),
+ string:strip(ListStr3, right, $,).
+
+ets_tuple_args(MaybeTuple) ->
+ case is_tuple(MaybeTuple) of
+ true -> element(1, MaybeTuple);
+ false -> ?no_label
+ end.
+
+ets_tuple_argtypes2(TupleList, ElemList) ->
+ case TupleList of
+ [] -> ElemList;
+ [H|T] ->
+ ets_tuple_argtypes2(T,
+ ets_tuple_argtypes2_helper(H, [], 0) ++ ElemList)
+ end.
+
+ets_tuple_argtypes2_helper(TupleStr, ElemStr, NestingLevel) ->
+ case TupleStr of
+ [] -> [];
+ [H|T] ->
+ {NewElemStr, NewNestingLevel, Return} =
+ case H of
+ ${ when NestingLevel =:= 0 ->
+ {ElemStr, NestingLevel + 1, false};
+ ${ ->
+ {[H|ElemStr], NestingLevel + 1, false};
+ $[ ->
+ {[H|ElemStr], NestingLevel + 1, false};
+ $( ->
+ {[H|ElemStr], NestingLevel + 1, false};
+ $} ->
+ {[H|ElemStr], NestingLevel - 1, false};
+ $] ->
+ {[H|ElemStr], NestingLevel - 1, false};
+ $) ->
+ {[H|ElemStr], NestingLevel - 1, false};
+ $, when NestingLevel =:= 1 ->
+ {lists:reverse(ElemStr), NestingLevel, true};
+ _Other ->
+ {[H|ElemStr], NestingLevel, false}
+ end,
+ case Return of
+ true -> string:tokens(NewElemStr, " |");
+ false ->
+ ets_tuple_argtypes2_helper(T, NewElemStr, NewNestingLevel)
+ end
+ end.
+
+ets_tuple_argtypes1(Str, Tuple, TupleList, NestingLevel) ->
+ case Str of
+ [] -> TupleList;
+ [H|T] ->
+ {NewTuple, NewNestingLevel, Add} =
+ case H of
+ ${ ->
+ {[H|Tuple], NestingLevel + 1, false};
+ $} ->
+ case NestingLevel of
+ 1 ->
+ {[H|Tuple], NestingLevel - 1, true};
+ _Else ->
+ {[H|Tuple], NestingLevel - 1, false}
+ end;
+ _Other1 when NestingLevel =:= 0 ->
+ {Tuple, NestingLevel, false};
+ _Other2 ->
+ {[H|Tuple], NestingLevel, false}
+ end,
+ case Add of
+ true ->
+ ets_tuple_argtypes1(T, [],
+ [lists:reverse(NewTuple)|TupleList],
+ NewNestingLevel);
+ false ->
+ ets_tuple_argtypes1(T, NewTuple, TupleList, NewNestingLevel)
+ end
+ end.
+
+format_arg(Arg) ->
+ case cerl:type(Arg) of
+ var -> cerl_trees:get_label(Arg);
+ tuple -> list_to_tuple([format_arg(A) || A <- cerl:tuple_es(Arg)]);
+ cons -> [format_arg(cerl:cons_hd(Arg))|format_arg(cerl:cons_tl(Arg))];
+ alias -> format_arg(cerl:alias_var(Arg));
+ literal ->
+ case cerl:is_c_nil(Arg) of
+ true -> [];
+ false -> ?no_label
+ end;
+ _Other -> ?no_label
+ end.
+
+-spec format_args([core_vars()], [erl_types:erl_type()],
+ dialyzer_dataflow:state(), call()) ->
+ args().
+
+format_args([], [], _State, _Call) ->
+ [];
+format_args(ArgList, TypeList, CleanState, Call) ->
+ format_args_2(format_args_1(ArgList, TypeList, CleanState), Call).
+
+format_args_1([Arg], [Type], CleanState) ->
+ [format_arg(Arg), format_type(Type, CleanState)];
+format_args_1([Arg|Args], [Type|Types], CleanState) ->
+ List =
+ case cerl:is_literal(Arg) of
+ true -> [?no_label, format_cerl(Arg)];
+ false -> [format_arg(Arg), format_type(Type, CleanState)]
+ end,
+ List ++ format_args_1(Args, Types, CleanState).
+
+format_args_2(StrArgList, Call) ->
+ case Call of
+ whereis ->
+ lists_key_replace(2, StrArgList,
+ string:tokens(lists:nth(2, StrArgList), " |"));
+ register ->
+ lists_key_replace(2, StrArgList,
+ string:tokens(lists:nth(2, StrArgList), " |"));
+ ets_new ->
+ StrArgList1 = lists_key_replace(2, StrArgList,
+ string:tokens(lists:nth(2, StrArgList), " |")),
+ lists_key_replace(4, StrArgList1,
+ string:tokens(ets_list_argtypes(lists:nth(4, StrArgList1)), " |"));
+ ets_lookup ->
+ StrArgList1 = lists_key_replace(2, StrArgList,
+ string:tokens(lists:nth(2, StrArgList), " |")),
+ lists_key_replace(4, StrArgList1,
+ string:tokens(lists:nth(4, StrArgList1), " |"));
+ ets_insert ->
+ StrArgList1 = lists_key_replace(2, StrArgList,
+ string:tokens(lists:nth(2, StrArgList), " |")),
+ lists_key_replace(4, StrArgList1,
+ ets_tuple_argtypes2(
+ ets_tuple_argtypes1(lists:nth(4, StrArgList1), [], [], 0),
+ []));
+ mnesia_dirty_read1 ->
+ lists_key_replace(2, StrArgList,
+ [mnesia_tuple_argtypes(T) || T <- string:tokens(
+ lists:nth(2, StrArgList), " |")]);
+ mnesia_dirty_read2 ->
+ lists_key_replace(2, StrArgList,
+ string:tokens(lists:nth(2, StrArgList), " |"));
+ mnesia_dirty_write1 ->
+ lists_key_replace(2, StrArgList,
+ [mnesia_record_tab(R) || R <- string:tokens(
+ lists:nth(2, StrArgList), " |")]);
+ mnesia_dirty_write2 ->
+ lists_key_replace(2, StrArgList,
+ string:tokens(lists:nth(2, StrArgList), " |"));
+ function_call -> StrArgList
+ end.
+
+format_cerl(Tree) ->
+ cerl_prettypr:format(cerl:set_ann(Tree, []),
+ [{hook, dialyzer_utils:pp_hook()},
+ {noann, true},
+ {paper, 100000},
+ {ribbon, 100000}
+ ]).
+
+format_type(Type, State) ->
+ R = dialyzer_dataflow:state__get_records(State),
+ erl_types:t_to_string(Type, R).
+
+mnesia_record_tab(RecordStr) ->
+ case string:str(RecordStr, "#") =:= 1 of
+ true ->
+ "'" ++
+ string:sub_string(RecordStr, 2, string:str(RecordStr, "{") - 1) ++
+ "'";
+ false -> RecordStr
+ end.
+
+mnesia_tuple_argtypes(TupleStr) ->
+ TupleStr1 = string:strip(TupleStr, left, ${),
+ [TupleStr2|_T] = string:tokens(TupleStr1, " ,"),
+ lists:flatten(string:tokens(TupleStr2, " |")).
+
+-spec race_var_map(var_to_map(), cerl:cerl() | [cerl:cerl()], dict(), op()) -> dict().
+
+race_var_map(Vars1, Vars2, RaceVarMap, Op) ->
+ case Vars1 =:= ?no_arg of
+ true -> RaceVarMap;
+ false ->
+ case is_list(Vars1) andalso is_list(Vars2) of
+ true ->
+ case Vars1 of
+ [] -> RaceVarMap;
+ [AHead|ATail] ->
+ case Vars2 of
+ [] -> RaceVarMap;
+ [PHead|PTail] ->
+ NewRaceVarMap = race_var_map(AHead, PHead, RaceVarMap, Op),
+ race_var_map(ATail, PTail, NewRaceVarMap, Op)
+ end
+ end;
+ false ->
+ {NewVars1, NewVars2, Bool} =
+ case is_list(Vars1) of
+ true ->
+ case Vars1 of
+ [Var1] -> {Var1, Vars2, true};
+ _Thing -> {Vars1, Vars2, false}
+ end;
+ false ->
+ case is_list(Vars2) of
+ true ->
+ case Vars2 of
+ [Var2] -> {Vars1, Var2, true};
+ _Thing -> {Vars1, Vars2, false}
+ end;
+ false -> {Vars1, Vars2, true}
+ end
+ end,
+ case Bool of
+ true ->
+ case cerl:type(NewVars1) of
+ var ->
+ case cerl:type(NewVars2) of
+ var ->
+ ALabel = cerl_trees:get_label(NewVars1),
+ PLabel = cerl_trees:get_label(NewVars2),
+ case Op of
+ bind ->
+ TempRaceVarMap =
+ bind_dict_vars(ALabel, PLabel, RaceVarMap),
+ bind_dict_vars(PLabel, ALabel, TempRaceVarMap);
+ unbind ->
+ TempRaceVarMap =
+ unbind_dict_vars(ALabel, PLabel, RaceVarMap),
+ unbind_dict_vars(PLabel, ALabel, TempRaceVarMap)
+ end;
+ alias ->
+ race_var_map(NewVars1, cerl:alias_var(NewVars2),
+ RaceVarMap, Op);
+ values ->
+ race_var_map(NewVars1, cerl:values_es(NewVars2),
+ RaceVarMap, Op);
+ _Other -> RaceVarMap
+ end;
+ tuple ->
+ case cerl:type(NewVars2) of
+ tuple ->
+ race_var_map(cerl:tuple_es(NewVars1),
+ cerl:tuple_es(NewVars2), RaceVarMap, Op);
+ alias ->
+ race_var_map(NewVars1, cerl:alias_var(NewVars2),
+ RaceVarMap, Op);
+ values ->
+ race_var_map(NewVars1, cerl:values_es(NewVars2),
+ RaceVarMap, Op);
+ _Other -> RaceVarMap
+ end;
+ cons ->
+ case cerl:type(NewVars2) of
+ cons ->
+ NewRaceVarMap = race_var_map(cerl:cons_hd(NewVars1),
+ cerl:cons_hd(NewVars2), RaceVarMap, Op),
+ race_var_map(cerl:cons_tl(NewVars1),
+ cerl:cons_tl(NewVars2), NewRaceVarMap, Op);
+ alias ->
+ race_var_map(NewVars1, cerl:alias_var(NewVars2),
+ RaceVarMap, Op);
+ values ->
+ race_var_map(NewVars1, cerl:values_es(NewVars2),
+ RaceVarMap, Op);
+ _Other -> RaceVarMap
+ end;
+ alias ->
+ case cerl:type(NewVars2) of
+ alias ->
+ race_var_map(cerl:alias_var(NewVars1),
+ cerl:alias_var(NewVars2), RaceVarMap, Op);
+ _Other ->
+ race_var_map(cerl:alias_var(NewVars1),
+ NewVars2, RaceVarMap, Op)
+ end;
+ values ->
+ case cerl:type(NewVars2) of
+ values ->
+ race_var_map(cerl:values_es(NewVars1),
+ cerl:values_es(NewVars2), RaceVarMap, Op);
+ _Other ->
+ race_var_map(cerl:values_es(NewVars1),
+ NewVars2, RaceVarMap, Op)
+ end;
+ _Other -> RaceVarMap
+ end;
+ false -> RaceVarMap
+ end
+ end
+ end.
+
+race_var_map_clauses(Clauses, RaceVarMap) ->
+ case Clauses of
+ [] -> RaceVarMap;
+ [#end_clause{arg = Arg, pats = Pats, guard = Guard}|T] ->
+ {RaceVarMap1, _RemoveClause} =
+ race_var_map_guard(Arg, Pats, Guard, RaceVarMap, bind),
+ race_var_map_clauses(T, RaceVarMap1)
+ end.
+
+race_var_map_guard(Arg, Pats, Guard, RaceVarMap, Op) ->
+ {NewRaceVarMap, RemoveClause} =
+ case cerl:type(Guard) of
+ call ->
+ CallName = cerl:call_name(Guard),
+ case cerl:is_literal(CallName) of
+ true ->
+ case cerl:concrete(CallName) of
+ '=:=' ->
+ [Arg1, Arg2] = cerl:call_args(Guard),
+ {race_var_map(Arg1, Arg2, RaceVarMap, Op), false};
+ '==' ->
+ [Arg1, Arg2] = cerl:call_args(Guard),
+ {race_var_map(Arg1, Arg2, RaceVarMap, Op), false};
+ '=/=' ->
+ case Op of
+ bind ->
+ [Arg1, Arg2] = cerl:call_args(Guard),
+ {RaceVarMap, are_bound_vars(Arg1, Arg2, RaceVarMap)};
+ unbind -> {RaceVarMap, false}
+ end;
+ _Other -> {RaceVarMap, false}
+ end;
+ false -> {RaceVarMap, false}
+ end;
+ _Other -> {RaceVarMap, false}
+ end,
+ {RaceVarMap1, RemoveClause1} =
+ race_var_map_guard_helper1(Arg, Pats,
+ race_var_map(Arg, Pats, NewRaceVarMap, Op), Op),
+ {RaceVarMap1, RemoveClause orelse RemoveClause1}.
+
+race_var_map_guard_helper1(Arg, Pats, RaceVarMap, Op) ->
+ case Arg =:= ?no_arg of
+ true -> {RaceVarMap, false};
+ false ->
+ case cerl:type(Arg) of
+ call ->
+ case Pats of
+ [NewPat] ->
+ ModName = cerl:call_module(Arg),
+ CallName = cerl:call_name(Arg),
+ case cerl:is_literal(ModName) andalso
+ cerl:is_literal(CallName) of
+ true ->
+ case {cerl:concrete(ModName),
+ cerl:concrete(CallName)} of
+ {erlang, '=:='} ->
+ race_var_map_guard_helper2(Arg, NewPat, true,
+ RaceVarMap, Op);
+ {erlang, '=='} ->
+ race_var_map_guard_helper2(Arg, NewPat, true,
+ RaceVarMap, Op);
+ {erlang, '=/='} ->
+ race_var_map_guard_helper2(Arg, NewPat, false,
+ RaceVarMap, Op);
+ _Else -> {RaceVarMap, false}
+ end;
+ false -> {RaceVarMap, false}
+ end;
+ _Other -> {RaceVarMap, false}
+ end;
+ _Other -> {RaceVarMap, false}
+ end
+ end.
+
+race_var_map_guard_helper2(Arg, Pat, Bool, RaceVarMap, Op) ->
+ case cerl:type(Pat) of
+ literal ->
+ [Arg1, Arg2] = cerl:call_args(Arg),
+ case cerl:concrete(Pat) of
+ Bool ->
+ {race_var_map(Arg1, Arg2, RaceVarMap, Op), false};
+ _Else ->
+ case Op of
+ bind ->
+ {RaceVarMap, are_bound_vars(Arg1, Arg2, RaceVarMap)};
+ unbind -> {RaceVarMap, false}
+ end
+ end;
+ _Else -> {RaceVarMap, false}
+ end.
+
+unbind_dict_vars(Var, Var, RaceVarMap) ->
+ RaceVarMap;
+unbind_dict_vars(Var1, Var2, RaceVarMap) ->
+ case dict:find(Var1, RaceVarMap) of
+ error -> RaceVarMap;
+ {ok, Labels} ->
+ case Labels of
+ [] -> dict:erase(Var1, RaceVarMap);
+ _Else ->
+ case lists:member(Var2, Labels) of
+ true ->
+ unbind_dict_vars(Var1, Var2,
+ bind_dict_vars_list(Var1, Labels -- [Var2],
+ dict:erase(Var1, RaceVarMap)));
+ false ->
+ unbind_dict_vars_helper(Labels, Var1, Var2, RaceVarMap)
+ end
+ end
+ end.
+
+unbind_dict_vars_helper(Labels, Key, CompLabel, RaceVarMap) ->
+ case dict:size(RaceVarMap) of
+ 0 -> RaceVarMap;
+ _ ->
+ case Labels of
+ [] -> RaceVarMap;
+ [Head|Tail] ->
+ NewRaceVarMap =
+ case are_bound_labels(Head, CompLabel, RaceVarMap) orelse
+ are_bound_labels(CompLabel, Head, RaceVarMap) of
+ true ->
+ bind_dict_vars_list(Key, Labels -- [Head],
+ dict:erase(Key, RaceVarMap));
+ false -> RaceVarMap
+ end,
+ unbind_dict_vars_helper(Tail, Key, CompLabel, NewRaceVarMap)
+ end
+ end.
+
+var_analysis(FunDefArgs, FunCallArgs, WarnVarArgs, RaceWarnTag) ->
+ case RaceWarnTag of
+ ?WARN_WHEREIS_REGISTER ->
+ [WVA1, WVA2, WVA3, WVA4] = WarnVarArgs,
+ ArgNos = lists_key_members_lists(WVA1, FunDefArgs),
+ [[lists_get(N, FunCallArgs) || N <- ArgNos], WVA2, WVA3, WVA4];
+ ?WARN_ETS_LOOKUP_INSERT ->
+ [WVA1, WVA2, WVA3, WVA4] = WarnVarArgs,
+ ArgNos1 = lists_key_members_lists(WVA1, FunDefArgs),
+ ArgNos2 = lists_key_members_lists(WVA3, FunDefArgs),
+ [[lists_get(N1, FunCallArgs) || N1 <- ArgNos1], WVA2,
+ [lists_get(N2, FunCallArgs) || N2 <- ArgNos2], WVA4];
+ ?WARN_MNESIA_DIRTY_READ_WRITE ->
+ [WVA1, WVA2|T] = WarnVarArgs,
+ ArgNos = lists_key_members_lists(WVA1, FunDefArgs),
+ [[lists_get(N, FunCallArgs) || N <- ArgNos], WVA2|T]
+ end.
+
+var_type_analysis(FunDefArgs, FunCallTypes, WarnVarArgs, RaceWarnTag,
+ RaceVarMap, CleanState) ->
+ FunVarArgs = format_args(FunDefArgs, FunCallTypes, CleanState,
+ function_call),
+ case RaceWarnTag of
+ ?WARN_WHEREIS_REGISTER ->
+ [WVA1, WVA2, WVA3, WVA4] = WarnVarArgs,
+ Vars = find_all_bound_vars(WVA1, RaceVarMap),
+ case lists_key_member_lists(Vars, FunVarArgs) of
+ 0 -> [Vars, WVA2, WVA3, WVA4];
+ N when is_integer(N) ->
+ NewWVA2 = string:tokens(lists:nth(N + 1, FunVarArgs), " |"),
+ [Vars, NewWVA2, WVA3, WVA4]
+ end;
+ ?WARN_ETS_LOOKUP_INSERT ->
+ [WVA1, WVA2, WVA3, WVA4] = WarnVarArgs,
+ Vars1 = find_all_bound_vars(WVA1, RaceVarMap),
+ FirstVarArg =
+ case lists_key_member_lists(Vars1, FunVarArgs) of
+ 0 -> [Vars1, WVA2];
+ N1 when is_integer(N1) ->
+ NewWVA2 = string:tokens(lists:nth(N1 + 1, FunVarArgs), " |"),
+ [Vars1, NewWVA2]
+ end,
+ Vars2 =
+ lists:flatten(
+ [find_all_bound_vars(A, RaceVarMap) || A <- ets_list_args(WVA3)]),
+ case lists_key_member_lists(Vars2, FunVarArgs) of
+ 0 -> FirstVarArg ++ [Vars2, WVA4];
+ N2 when is_integer(N2) ->
+ NewWVA4 =
+ ets_tuple_argtypes2(
+ ets_tuple_argtypes1(lists:nth(N2 + 1, FunVarArgs), [], [], 0),
+ []),
+ FirstVarArg ++ [Vars2, NewWVA4]
+
+ end;
+ ?WARN_MNESIA_DIRTY_READ_WRITE ->
+ [WVA1, WVA2|T] = WarnVarArgs,
+ Arity =
+ case T of
+ [] -> 1;
+ _Else -> 2
+ end,
+ Vars = find_all_bound_vars(WVA1, RaceVarMap),
+ case lists_key_member_lists(Vars, FunVarArgs) of
+ 0 -> [Vars, WVA2|T];
+ N when is_integer(N) ->
+ NewWVA2 =
+ case Arity of
+ 1 ->
+ [mnesia_record_tab(R) || R <- string:tokens(
+ lists:nth(2, FunVarArgs), " |")];
+ 2 ->
+ string:tokens(lists:nth(N + 1, FunVarArgs), " |")
+ end,
+ [Vars, NewWVA2|T]
+ end
+ end.
+
+%%% ===========================================================================
+%%%
+%%% Warning Format Utilities
+%%%
+%%% ===========================================================================
+
+add_race_warning(Warn, #races{race_warnings = Warns} = Races) ->
+ Races#races{race_warnings = [Warn|Warns]}.
+
+get_race_warn(Fun, Args, ArgTypes, DepList, State) ->
+ {M, F, _A} = Fun,
+ case DepList of
+ [] -> {State, no_race};
+ _Other ->
+ {State, {race_condition, [M, F, Args, ArgTypes, State, DepList]}}
+ end.
+
+-spec get_race_warnings(races(), dialyzer_dataflow:state()) ->
+ {races(), dialyzer_dataflow:state()}.
+
+get_race_warnings(#races{race_warnings = RaceWarnings}, State) ->
+ get_race_warnings_helper(RaceWarnings, State).
+
+get_race_warnings_helper(Warnings, State) ->
+ case Warnings of
+ [] ->
+ {dialyzer_dataflow:state__get_races(State), State};
+ [H|T] ->
+ {RaceWarnTag, FileLine, {race_condition, [M, F, A, AT, S, DepList]}} = H,
+ Reason =
+ case RaceWarnTag of
+ ?WARN_WHEREIS_REGISTER ->
+ get_reason(lists:keysort(7, DepList),
+ "might fail due to a possible race condition "
+ "caused by its combination with ");
+ ?WARN_ETS_LOOKUP_INSERT ->
+ get_reason(lists:keysort(7, DepList),
+ "might have an unintended effect due to " ++
+ "a possible race condition " ++
+ "caused by its combination with ");
+ ?WARN_MNESIA_DIRTY_READ_WRITE ->
+ get_reason(lists:keysort(7, DepList),
+ "might have an unintended effect due to " ++
+ "a possible race condition " ++
+ "caused by its combination with ")
+ end,
+ W =
+ {?WARN_RACE_CONDITION, FileLine,
+ {race_condition,
+ [M, F, dialyzer_dataflow:format_args(A, AT, S), Reason]}},
+ get_race_warnings_helper(T,
+ dialyzer_dataflow:state__add_warning(W, State))
+ end.
+
+get_reason(DependencyList, Reason) ->
+ case DependencyList of
+ [] -> "";
+ [#dep_call{call_name = Call, arg_types = ArgTypes, vars = Args,
+ state = State, file_line = {File, Line}}|T] ->
+ R =
+ Reason ++
+ case Call of
+ whereis -> "the erlang:whereis";
+ ets_lookup -> "the ets:lookup";
+ mnesia_dirty_read -> "the mnesia:dirty_read"
+ end ++
+ dialyzer_dataflow:format_args(Args, ArgTypes, State) ++
+ " call in " ++
+ filename:basename(File) ++
+ " on line " ++
+ lists:flatten(io_lib:write(Line)),
+ case T of
+ [] -> R;
+ _ -> get_reason(T, R ++ ", ")
+ end
+ end.
+
+state__add_race_warning(State, RaceWarn, RaceWarnTag, FileLine) ->
+ case RaceWarn of
+ no_race -> State;
+ _Else ->
+ Races = dialyzer_dataflow:state__get_races(State),
+ Warn = {RaceWarnTag, FileLine, RaceWarn},
+ dialyzer_dataflow:state__put_races(add_race_warning(Warn, Races), State)
+ end.
+
+%%% ===========================================================================
+%%%
+%%% Record Interfaces
+%%%
+%%% ===========================================================================
+
+-spec beg_clause_new(var_to_map(), var_to_map(), cerl:cerl()) ->
+ #beg_clause{}.
+
+beg_clause_new(Arg, Pats, Guard) ->
+ #beg_clause{arg = Arg, pats = Pats, guard = Guard}.
+
+-spec cleanup(races()) -> races().
+
+cleanup(#races{race_list = RaceList}) ->
+ #races{race_list = RaceList}.
+
+-spec end_case_new([#end_clause{}]) -> #end_case{}.
+
+end_case_new(Clauses) ->
+ #end_case{clauses = Clauses}.
+
+-spec end_clause_new(var_to_map(), var_to_map(), cerl:cerl()) ->
+ #end_clause{}.
+
+end_clause_new(Arg, Pats, Guard) ->
+ #end_clause{arg = Arg, pats = Pats, guard = Guard}.
+
+-spec get_curr_fun(races()) -> mfa_or_funlbl().
+
+get_curr_fun(#races{curr_fun = CurrFun}) ->
+ CurrFun.
+
+-spec get_curr_fun_args(races()) -> core_args().
+
+get_curr_fun_args(#races{curr_fun_args = CurrFunArgs}) ->
+ CurrFunArgs.
+
+-spec get_new_table(races()) -> table().
+
+get_new_table(#races{new_table = Table}) ->
+ Table.
+
+-spec get_race_analysis(races()) -> boolean().
+
+get_race_analysis(#races{race_analysis = RaceAnalysis}) ->
+ RaceAnalysis.
+
+-spec get_race_list(races()) -> code().
+
+get_race_list(#races{race_list = RaceList}) ->
+ RaceList.
+
+-spec get_race_list_size(races()) -> non_neg_integer().
+
+get_race_list_size(#races{race_list_size = RaceListSize}) ->
+ RaceListSize.
+
+-spec let_tag_new(var_to_map(), var_to_map()) -> #let_tag{}.
+
+let_tag_new(Var, Arg) ->
+ #let_tag{var = Var, arg = Arg}.
+
+-spec new() -> races().
+
+new() -> #races{}.
+
+-spec put_curr_fun(mfa_or_funlbl(), label(), races()) ->
+ races().
+
+put_curr_fun(CurrFun, CurrFunLabel, Races) ->
+ Races#races{curr_fun = CurrFun,
+ curr_fun_label = CurrFunLabel,
+ curr_fun_args = empty}.
+
+-spec put_fun_args(core_args(), races()) -> races().
+
+put_fun_args(Args, #races{curr_fun_args = CurrFunArgs} = Races) ->
+ case CurrFunArgs of
+ empty -> Races#races{curr_fun_args = Args};
+ _Other -> Races
+ end.
+
+-spec put_race_analysis(boolean(), races()) ->
+ races().
+
+put_race_analysis(Analysis, Races) ->
+ Races#races{race_analysis = Analysis}.
+
+-spec put_race_list(code(), non_neg_integer(), races()) ->
+ races().
+
+put_race_list(RaceList, RaceListSize, Races) ->
+ Races#races{race_list = RaceList,
+ race_list_size = RaceListSize}.
diff --git a/lib/dialyzer/src/dialyzer_succ_typings.erl b/lib/dialyzer/src/dialyzer_succ_typings.erl
new file mode 100644
index 0000000000..dd8480f1f2
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_succ_typings.erl
@@ -0,0 +1,540 @@
+%% -*- erlang-indent-level: 2 -*-
+%%-----------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2006-2009. 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%
+%%
+
+%%%-------------------------------------------------------------------
+%%% File : dialyzer_succ_typings.erl
+%%% Author : Tobias Lindahl <[email protected]>
+%%% Description :
+%%%
+%%% Created : 11 Sep 2006 by Tobias Lindahl <[email protected]>
+%%%-------------------------------------------------------------------
+-module(dialyzer_succ_typings).
+
+-export([analyze_callgraph/3,
+ analyze_callgraph/4,
+ get_warnings/6]).
+
+%% These are only intended as debug functions.
+-export([doit/1,
+ get_top_level_signatures/3]).
+
+%%-define(DEBUG, true).
+%%-define(DEBUG_PP, true).
+
+-ifdef(DEBUG).
+-define(debug(X__, Y__), io:format(X__, Y__)).
+-else.
+-define(debug(X__, Y__), ok).
+-endif.
+
+-define(TYPE_LIMIT, 4).
+
+%%--------------------------------------------------------------------
+
+-include("dialyzer.hrl").
+
+%%--------------------------------------------------------------------
+%% State record -- local to this module
+
+-type parent() :: 'none' | pid().
+
+-record(st, {callgraph :: dialyzer_callgraph:callgraph(),
+ codeserver :: dialyzer_codeserver:codeserver(),
+ no_warn_unused :: set(),
+ parent = none :: parent(),
+ plt :: dialyzer_plt:plt()}).
+
+%%--------------------------------------------------------------------
+
+-spec analyze_callgraph(dialyzer_callgraph:callgraph(), dialyzer_plt:plt(),
+ dialyzer_codeserver:codeserver()) ->
+ dialyzer_plt:plt().
+
+analyze_callgraph(Callgraph, Plt, Codeserver) ->
+ analyze_callgraph(Callgraph, Plt, Codeserver, none).
+
+-spec analyze_callgraph(dialyzer_callgraph:callgraph(), dialyzer_plt:plt(),
+ dialyzer_codeserver:codeserver(), parent()) ->
+ dialyzer_plt:plt().
+
+analyze_callgraph(Callgraph, Plt, Codeserver, Parent) ->
+ State = #st{callgraph = Callgraph, plt = Plt,
+ codeserver = Codeserver, parent = Parent},
+ NewState = get_refined_success_typings(State),
+ NewState#st.plt.
+
+%%--------------------------------------------------------------------
+
+get_refined_success_typings(State) ->
+ case find_succ_typings(State) of
+ {fixpoint, State1} -> State1;
+ {not_fixpoint, NotFixpoint1, State1} ->
+ Callgraph = State1#st.callgraph,
+ NotFixpoint2 = [lookup_name(F, Callgraph) || F <- NotFixpoint1],
+ ModulePostorder =
+ dialyzer_callgraph:module_postorder_from_funs(NotFixpoint2, Callgraph),
+ case refine_succ_typings(ModulePostorder, State1) of
+ {fixpoint, State2} ->
+ State2;
+ {not_fixpoint, NotFixpoint3, State2} ->
+ Callgraph1 = State2#st.callgraph,
+ %% Need to reset the callgraph.
+ NotFixpoint4 = [lookup_name(F, Callgraph1) || F <- NotFixpoint3],
+ Callgraph2 = dialyzer_callgraph:reset_from_funs(NotFixpoint4,
+ Callgraph1),
+ get_refined_success_typings(State2#st{callgraph = Callgraph2})
+ end
+ end.
+
+-type doc_plt() :: 'undefined' | dialyzer_plt:plt().
+-spec get_warnings(dialyzer_callgraph:callgraph(), dialyzer_plt:plt(),
+ doc_plt(), dialyzer_codeserver:codeserver(), set(),
+ pid()) ->
+ {[dial_warning()], dialyzer_plt:plt(), doc_plt()}.
+
+get_warnings(Callgraph, Plt, DocPlt, Codeserver, NoWarnUnused, Parent) ->
+ InitState = #st{callgraph = Callgraph, codeserver = Codeserver,
+ no_warn_unused = NoWarnUnused, parent = Parent, plt = Plt},
+ NewState = get_refined_success_typings(InitState),
+ Mods = dialyzer_callgraph:modules(NewState#st.callgraph),
+ CWarns = dialyzer_contracts:get_invalid_contract_warnings(Mods, Codeserver,
+ NewState#st.plt),
+ get_warnings_from_modules(Mods, NewState, DocPlt, CWarns).
+
+get_warnings_from_modules([M|Ms], State, DocPlt, Acc) when is_atom(M) ->
+ send_log(State#st.parent, io_lib:format("Getting warnings for ~w\n", [M])),
+ #st{callgraph = Callgraph, codeserver = Codeserver,
+ no_warn_unused = NoWarnUnused, plt = Plt} = State,
+ ModCode = dialyzer_codeserver:lookup_mod_code(M, Codeserver),
+ Records = dialyzer_codeserver:lookup_mod_records(M, Codeserver),
+ Contracts = dialyzer_codeserver:lookup_mod_contracts(M, Codeserver),
+ AllFuns = collect_fun_info([ModCode]),
+ %% Check if there are contracts for functions that do not exist
+ Warnings1 =
+ dialyzer_contracts:contracts_without_fun(Contracts, AllFuns, Callgraph),
+ {Warnings2, FunTypes, RaceCode, PublicTables, NamedTables} =
+ dialyzer_dataflow:get_warnings(ModCode, Plt, Callgraph, Records, NoWarnUnused),
+ NewDocPlt = insert_into_doc_plt(FunTypes, Callgraph, DocPlt),
+ NewCallgraph =
+ dialyzer_callgraph:renew_race_info(Callgraph, RaceCode, PublicTables,
+ NamedTables),
+ State1 = st__renew_state_calls(NewCallgraph, State),
+ get_warnings_from_modules(Ms, State1, NewDocPlt, [Warnings1,Warnings2|Acc]);
+get_warnings_from_modules([], #st{plt = Plt}, DocPlt, Acc) ->
+ {lists:flatten(Acc), Plt, DocPlt}.
+
+refine_succ_typings(ModulePostorder, State) ->
+ ?debug("Module postorder: ~p\n", [ModulePostorder]),
+ refine_succ_typings(ModulePostorder, State, []).
+
+refine_succ_typings([SCC|SCCs], State, Fixpoint) ->
+ Msg = io_lib:format("Dataflow of one SCC: ~w\n", [SCC]),
+ send_log(State#st.parent, Msg),
+ ?debug("~s\n", [Msg]),
+ {NewState, FixpointFromScc} =
+ case SCC of
+ [M] -> refine_one_module(M, State);
+ [_|_] -> refine_one_scc(SCC, State)
+ end,
+ NewFixpoint = ordsets:union(Fixpoint, FixpointFromScc),
+ refine_succ_typings(SCCs, NewState, NewFixpoint);
+refine_succ_typings([], State, Fixpoint) ->
+ case Fixpoint =:= [] of
+ true -> {fixpoint, State};
+ false -> {not_fixpoint, Fixpoint, State}
+ end.
+
+-spec refine_one_module(module(), #st{}) -> {#st{}, [label()]}. % ordset
+
+refine_one_module(M, State) ->
+ #st{callgraph = Callgraph, codeserver = CodeServer, plt = PLT} = State,
+ ModCode = dialyzer_codeserver:lookup_mod_code(M, CodeServer),
+ AllFuns = collect_fun_info([ModCode]),
+ FunTypes = get_fun_types_from_plt(AllFuns, State),
+ Records = dialyzer_codeserver:lookup_mod_records(M, CodeServer),
+ {NewFunTypes, RaceCode, PublicTables, NamedTables} =
+ dialyzer_dataflow:get_fun_types(ModCode, PLT, Callgraph, Records),
+ NewCallgraph =
+ dialyzer_callgraph:renew_race_info(Callgraph, RaceCode, PublicTables,
+ NamedTables),
+ case reached_fixpoint(FunTypes, NewFunTypes) of
+ true ->
+ State1 = st__renew_state_calls(NewCallgraph, State),
+ {State1, ordsets:new()};
+ {false, NotFixpoint} ->
+ ?debug("Not fixpoint\n", []),
+ NewState = insert_into_plt(dict:from_list(NotFixpoint), State),
+ NewState1 = st__renew_state_calls(NewCallgraph, NewState),
+ {NewState1, ordsets:from_list([FunLbl || {FunLbl,_Type} <- NotFixpoint])}
+ end.
+
+st__renew_state_calls(Callgraph, State) ->
+ State#st{callgraph = Callgraph}.
+
+refine_one_scc(SCC, State) ->
+ refine_one_scc(SCC, State, []).
+
+refine_one_scc(SCC, State, AccFixpoint) ->
+ {NewState, FixpointFromScc} = refine_mods_in_scc(SCC, State, []),
+ case FixpointFromScc =:= [] of
+ true -> {NewState, AccFixpoint};
+ false ->
+ NewAccFixpoint = ordsets:union(AccFixpoint, FixpointFromScc),
+ refine_one_scc(SCC, NewState, NewAccFixpoint)
+ end.
+
+refine_mods_in_scc([Mod|Mods], State, Fixpoint) ->
+ {NewState, FixpointFromModule} = refine_one_module(Mod, State),
+ NewFixpoint = ordsets:union(FixpointFromModule, Fixpoint),
+ refine_mods_in_scc(Mods, NewState, NewFixpoint);
+refine_mods_in_scc([], State, Fixpoint) ->
+ {State, Fixpoint}.
+
+reached_fixpoint(OldTypes, NewTypes) ->
+ reached_fixpoint(OldTypes, NewTypes, false).
+
+reached_fixpoint_strict(OldTypes, NewTypes) ->
+ case reached_fixpoint(OldTypes, NewTypes, true) of
+ true -> true;
+ {false, _} -> false
+ end.
+
+reached_fixpoint(OldTypes0, NewTypes0, Strict) ->
+ MapFun = fun(_Key, Type) ->
+ case is_failed_or_not_called_fun(Type) of
+ true -> failed_fun;
+ false -> erl_types:t_limit(Type, ?TYPE_LIMIT)
+ end
+ end,
+ OldTypes = dict:map(MapFun, OldTypes0),
+ NewTypes = dict:map(MapFun, NewTypes0),
+ compare_types(OldTypes, NewTypes, Strict).
+
+is_failed_or_not_called_fun(Type) ->
+ erl_types:any_none([erl_types:t_fun_range(Type)|erl_types:t_fun_args(Type)]).
+
+compare_types(Dict1, Dict2, Strict) ->
+ List1 = lists:keysort(1, dict:to_list(Dict1)),
+ List2 = lists:keysort(1, dict:to_list(Dict2)),
+ compare_types_1(List1, List2, Strict, []).
+
+compare_types_1([{X, _Type1}|Left1], [{X, failed_fun}|Left2],
+ Strict, NotFixpoint) ->
+ compare_types_1(Left1, Left2, Strict, NotFixpoint);
+compare_types_1([{X, failed_fun}|Left1], [{X, _Type2}|Left2],
+ Strict, NotFixpoint) ->
+ compare_types_1(Left1, Left2, Strict, NotFixpoint);
+compare_types_1([{X, Type1}|Left1], [{X, Type2}|Left2], Strict, NotFixpoint) ->
+ Res = case Strict of
+ true -> erl_types:t_is_equal(Type1, Type2);
+ false -> erl_types:t_is_subtype(Type1, Type2)
+ end,
+ case Res of
+ true -> compare_types_1(Left1, Left2, Strict, NotFixpoint);
+ false ->
+ ?debug("Failed fixpoint for ~w: ~s =/= ~s\n",
+ [X, erl_types:t_to_string(Type1), erl_types:t_to_string(Type2)]),
+ compare_types_1(Left1, Left2, Strict, [{X, Type2}|NotFixpoint])
+ end;
+compare_types_1([_|Left1], List2, Strict, NotFixpoint) ->
+ %% If the function was not called.
+ compare_types_1(Left1, List2, Strict, NotFixpoint);
+compare_types_1([], [], _Strict, NotFixpoint) ->
+ case NotFixpoint =:= [] of
+ true -> true;
+ false -> {false, NotFixpoint}
+ end.
+
+find_succ_typings(State) ->
+ find_succ_typings(State, []).
+
+find_succ_typings(#st{callgraph = Callgraph, parent = Parent} = State,
+ NotFixpoint) ->
+ case dialyzer_callgraph:take_scc(Callgraph) of
+ {ok, SCC, NewCallgraph} ->
+ Msg = io_lib:format("Typesig analysis for SCC: ~w\n", [format_scc(SCC)]),
+ ?debug("~s", [Msg]),
+ send_log(Parent, Msg),
+ {NewState, NewNotFixpoint1} =
+ analyze_scc(SCC, State#st{callgraph = NewCallgraph}),
+ NewNotFixpoint2 = ordsets:union(NewNotFixpoint1, NotFixpoint),
+ find_succ_typings(NewState, NewNotFixpoint2);
+ none ->
+ ?debug("==================== Typesig done ====================\n\n", []),
+ case NotFixpoint =:= [] of
+ true -> {fixpoint, State};
+ false -> {not_fixpoint, NotFixpoint, State}
+ end
+ end.
+
+analyze_scc(SCC, #st{codeserver = Codeserver} = State) ->
+ SCC_Info = [{MFA,
+ dialyzer_codeserver:lookup_mfa_code(MFA, Codeserver),
+ dialyzer_codeserver:lookup_mod_records(M, Codeserver)}
+ || {M, _, _} = MFA <- SCC],
+ Contracts1 = [{MFA, dialyzer_codeserver:lookup_mfa_contract(MFA, Codeserver)}
+ || {_, _, _} = MFA <- SCC],
+ Contracts2 = [{MFA, Contract} || {MFA, {ok, Contract}} <- Contracts1],
+ Contracts3 = orddict:from_list(Contracts2),
+ {SuccTypes, PltContracts, NotFixpoint} =
+ find_succ_types_for_scc(SCC_Info, Contracts3, State),
+ State1 = insert_into_plt(SuccTypes, State),
+ ContrPlt = dialyzer_plt:insert_contract_list(State1#st.plt, PltContracts),
+ {State1#st{plt = ContrPlt}, NotFixpoint}.
+
+find_succ_types_for_scc(SCC_Info, Contracts,
+ #st{codeserver = Codeserver,
+ callgraph = Callgraph, plt = Plt} = State) ->
+ %% Assume that the PLT contains the current propagated types
+ AllFuns = collect_fun_info([Fun || {_MFA, {_Var, Fun}, _Rec} <- SCC_Info]),
+ PropTypes = get_fun_types_from_plt(AllFuns, State),
+ MFAs = [MFA || {MFA, {_Var, _Fun}, _Rec} <- SCC_Info],
+ NextLabel = dialyzer_codeserver:get_next_core_label(Codeserver),
+ Plt1 = dialyzer_plt:delete_contract_list(Plt, MFAs),
+ FunTypes = dialyzer_typesig:analyze_scc(SCC_Info, NextLabel,
+ Callgraph, Plt1, PropTypes),
+ AllFunSet = sets:from_list([X || {X, _} <- AllFuns]),
+ FilteredFunTypes = dict:filter(fun(X, _) ->
+ sets:is_element(X, AllFunSet)
+ end, FunTypes),
+ %% Check contracts
+ PltContracts = dialyzer_contracts:check_contracts(Contracts, Callgraph,
+ FilteredFunTypes),
+ ContractFixpoint =
+ lists:all(fun({MFA, _C}) ->
+ %% Check the non-deleted PLT
+ case dialyzer_plt:lookup_contract(Plt, MFA) of
+ none -> false;
+ {value, _} -> true
+ end
+ end, PltContracts),
+ case (ContractFixpoint andalso
+ reached_fixpoint_strict(PropTypes, FilteredFunTypes)) of
+ true ->
+ {FilteredFunTypes, PltContracts, []};
+ false ->
+ ?debug("Not fixpoint for: ~w\n", [AllFuns]),
+ {FilteredFunTypes, PltContracts,
+ ordsets:from_list([Fun || {Fun, _Arity} <- AllFuns])}
+ end.
+
+get_fun_types_from_plt(FunList, State) ->
+ get_fun_types_from_plt(FunList, State, dict:new()).
+
+get_fun_types_from_plt([{FunLabel, Arity}|Left], State, Map) ->
+ Type = lookup_fun_type(FunLabel, Arity, State),
+ get_fun_types_from_plt(Left, State, dict:store(FunLabel, Type, Map));
+get_fun_types_from_plt([], _State, Map) ->
+ Map.
+
+collect_fun_info(Trees) ->
+ collect_fun_info(Trees, []).
+
+collect_fun_info([Tree|Trees], List) ->
+ Fun = fun(SubTree, Acc) ->
+ case cerl:is_c_fun(SubTree) of
+ true ->
+ [{cerl_trees:get_label(SubTree), cerl:fun_arity(SubTree)}|Acc];
+ false -> Acc
+ end
+ end,
+ collect_fun_info(Trees, cerl_trees:fold(Fun, List, Tree));
+collect_fun_info([], List) ->
+ List.
+
+lookup_fun_type(Label, Arity, #st{callgraph = Callgraph, plt = Plt}) ->
+ ID = lookup_name(Label, Callgraph),
+ case dialyzer_plt:lookup(Plt, ID) of
+ none -> erl_types:t_fun(Arity, erl_types:t_any());
+ {value, {RetT, ArgT}} -> erl_types:t_fun(ArgT, RetT)
+ end.
+
+insert_into_doc_plt(_FunTypes, _Callgraph, undefined) ->
+ undefined;
+insert_into_doc_plt(FunTypes, Callgraph, DocPlt) ->
+ SuccTypes = format_succ_types(FunTypes, Callgraph),
+ dialyzer_plt:insert_list(DocPlt, SuccTypes).
+
+insert_into_plt(SuccTypes0, #st{callgraph = Callgraph, plt = Plt} = State) ->
+ SuccTypes = format_succ_types(SuccTypes0, Callgraph),
+ debug_pp_succ_typings(SuccTypes),
+ State#st{plt = dialyzer_plt:insert_list(Plt, SuccTypes)}.
+
+format_succ_types(SuccTypes, Callgraph) ->
+ format_succ_types(dict:to_list(SuccTypes), Callgraph, []).
+
+format_succ_types([{Label, Type0}|Left], Callgraph, Acc) ->
+ Type = erl_types:t_limit(Type0, ?TYPE_LIMIT+1),
+ Id = lookup_name(Label, Callgraph),
+ NewTuple = {Id, {erl_types:t_fun_range(Type), erl_types:t_fun_args(Type)}},
+ format_succ_types(Left, Callgraph, [NewTuple|Acc]);
+format_succ_types([], _Callgraph, Acc) ->
+ Acc.
+
+-ifdef(DEBUG).
+debug_pp_succ_typings(SuccTypes) ->
+ ?debug("Succ typings:\n", []),
+ [?debug(" ~w :: ~s\n",
+ [MFA, erl_types:t_to_string(erl_types:t_fun(ArgT, RetT))])
+ || {MFA, {RetT, ArgT}} <- SuccTypes],
+ ?debug("Contracts:\n", []),
+ [?debug(" ~w :: ~s\n",
+ [MFA, erl_types:t_to_string(erl_types:t_fun(ArgT, RetFun(ArgT)))])
+ || {MFA, {contract, RetFun, ArgT}} <- SuccTypes],
+ ?debug("\n", []),
+ ok.
+-else.
+debug_pp_succ_typings(_) ->
+ ok.
+-endif.
+
+lookup_name(F, CG) ->
+ case dialyzer_callgraph:lookup_name(F, CG) of
+ error -> F;
+ {ok, Name} -> Name
+ end.
+
+send_log(none, _Msg) ->
+ ok;
+send_log(Parent, Msg) ->
+ Parent ! {self(), log, lists:flatten(Msg)},
+ ok.
+
+format_scc(SCC) ->
+ [MFA || {_M, _F, _A} = MFA <- SCC].
+
+%% ============================================================================
+%%
+%% Debug interface.
+%%
+%% ============================================================================
+
+-spec doit(module() | string()) -> 'ok'.
+
+doit(Module) ->
+ {ok, AbstrCode} = dialyzer_utils:get_abstract_code_from_src(Module),
+ {ok, Code} = dialyzer_utils:get_core_from_abstract_code(AbstrCode),
+ {ok, Records} = dialyzer_utils:get_record_and_type_info(AbstrCode),
+ %% contract typing info in dictionary format
+ {ok, Contracts} =
+ dialyzer_utils:get_spec_info(cerl:concrete(cerl:module_name(Code)),
+ AbstrCode, Records),
+ Sigs0 = get_top_level_signatures(Code, Records, Contracts),
+ M = if is_atom(Module) ->
+ list_to_atom(filename:basename(atom_to_list(Module)));
+ is_list(Module) ->
+ list_to_atom(filename:basename(Module))
+ end,
+ Sigs1 = [{{M, F, A}, Type} || {{F, A}, Type} <- Sigs0],
+ Sigs = ordsets:from_list(Sigs1),
+ io:format("==================== Final result ====================\n\n", []),
+ pp_signatures(Sigs, Records),
+ ok.
+
+-spec get_top_level_signatures(cerl:c_module(), dict(), dict()) ->
+ [{{atom(), arity()}, erl_types:erl_type()}].
+
+get_top_level_signatures(Code, Records, Contracts) ->
+ Tree = cerl:from_records(Code),
+ {LabeledTree, NextLabel} = cerl_trees:label(Tree),
+ Plt = get_def_plt(),
+ ModuleName = cerl:atom_val(cerl:module_name(LabeledTree)),
+ Plt1 = dialyzer_plt:delete_module(Plt, ModuleName),
+ Plt2 = analyze_module(LabeledTree, NextLabel, Plt1, Records, Contracts),
+ M = cerl:concrete(cerl:module_name(Tree)),
+ Functions = [{M, cerl:fname_id(V), cerl:fname_arity(V)}
+ || {V, _F} <- cerl:module_defs(LabeledTree)],
+ %% First contracts check
+ AllContracts = dict:fetch_keys(Contracts),
+ ErrorContracts = AllContracts -- Functions,
+ lists:foreach(fun(C) ->
+ io:format("Contract for non-existing function: ~w\n",[C])
+ end, ErrorContracts),
+ Types = [{MFA, dialyzer_plt:lookup(Plt2, MFA)} || MFA <- Functions],
+ Sigs = [{{F, A}, erl_types:t_fun(ArgT, RetT)}
+ || {{_M, F, A}, {value, {RetT, ArgT}}} <- Types],
+ ordsets:from_list(Sigs).
+
+get_def_plt() ->
+ try
+ dialyzer_plt:from_file(dialyzer_plt:get_default_plt())
+ catch
+ error:no_such_file -> dialyzer_plt:new();
+ throw:{dialyzer_error, _} -> dialyzer_plt:new()
+ end.
+
+pp_signatures([{{_, module_info, 0}, _}|Left], Records) ->
+ pp_signatures(Left, Records);
+pp_signatures([{{_, module_info, 1}, _}|Left], Records) ->
+ pp_signatures(Left, Records);
+pp_signatures([{{M, F, _A}, Type}|Left], Records) ->
+ TypeString =
+ case cerl:is_literal(Type) of
+%% Commented out so that dialyzer does not complain
+%% false ->
+%% "fun(" ++ String = erl_types:t_to_string(Type, Records),
+%% string:substr(String, 1, length(String)-1);
+ true ->
+ io_lib:format("~w", [cerl:concrete(Type)])
+ end,
+ io:format("~w:~w~s\n", [M, F, TypeString]),
+ pp_signatures(Left, Records);
+pp_signatures([], _Records) ->
+ ok.
+
+-ifdef(DEBUG_PP).
+debug_pp(Tree, _Map) ->
+ Tree1 = strip_annotations(Tree),
+ io:put_chars(cerl_prettypr:format(Tree1)),
+ io:nl().
+
+strip_annotations(Tree) ->
+ cerl_trees:map(fun(T) ->
+ case cerl:is_literal(T) orelse cerl:is_c_values(T) of
+ true -> cerl:set_ann(T, []);
+ false ->
+ Label = cerl_trees:get_label(T),
+ cerl:set_ann(T, [{'label', Label}])
+ end
+ end, Tree).
+-else.
+debug_pp(_Tree, _Map) ->
+ ok.
+-endif. % DEBUG_PP
+
+%%
+%% Analysis of a single module
+%%
+analyze_module(LabeledTree, NextLbl, Plt, Records, Contracts) ->
+ debug_pp(LabeledTree, dict:new()),
+ CallGraph1 = dialyzer_callgraph:new(),
+ CallGraph2 = dialyzer_callgraph:scan_core_tree(LabeledTree, CallGraph1),
+ {CallGraph3, _Ext} = dialyzer_callgraph:remove_external(CallGraph2),
+ CallGraph4 = dialyzer_callgraph:finalize(CallGraph3),
+ CodeServer1 = dialyzer_codeserver:new(),
+ Mod = cerl:concrete(cerl:module_name(LabeledTree)),
+ CodeServer2 = dialyzer_codeserver:insert(Mod, LabeledTree, CodeServer1),
+ CodeServer3 = dialyzer_codeserver:set_next_core_label(NextLbl, CodeServer2),
+ CodeServer4 = dialyzer_codeserver:store_records(Mod, Records, CodeServer3),
+ CodeServer5 = dialyzer_codeserver:store_contracts(Mod, Contracts, CodeServer4),
+ Res = analyze_callgraph(CallGraph4, Plt, CodeServer5),
+ dialyzer_callgraph:delete(CallGraph4),
+ dialyzer_codeserver:delete(CodeServer5),
+ Res.
diff --git a/lib/dialyzer/src/dialyzer_typesig.erl b/lib/dialyzer/src/dialyzer_typesig.erl
new file mode 100644
index 0000000000..aeb20d4fae
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_typesig.erl
@@ -0,0 +1,2756 @@
+%% -*- erlang-indent-level: 2 -*-
+%%-----------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2006-2009. 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%
+%%
+
+%%%-------------------------------------------------------------------
+%%% File : dialyzer_typesig.erl
+%%% Author : Tobias Lindahl <[email protected]>
+%%% Description :
+%%%
+%%% Created : 25 Apr 2005 by Tobias Lindahl <[email protected]>
+%%%-------------------------------------------------------------------
+
+-module(dialyzer_typesig).
+
+-export([analyze_scc/5]).
+-export([get_safe_underapprox/2]).
+
+-import(erl_types,
+ [t_any/0, t_atom/0, t_atom_vals/1,
+ t_binary/0, t_bitstr/0, t_bitstr/2, t_bitstr_concat/1, t_boolean/0,
+ t_collect_vars/1, t_cons/2, t_cons_hd/1, t_cons_tl/1,
+ 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_has_var/1,
+ t_inf/2, t_inf/3, t_integer/0,
+ t_is_any/1, t_is_atom/1, t_is_atom/2, t_is_cons/1, t_is_equal/2,
+ t_is_float/1, t_is_fun/1,
+ t_is_integer/1, t_non_neg_integer/0,
+ t_is_list/1, t_is_nil/1, t_is_none/1, t_is_number/1,
+ t_is_subtype/2, t_limit/2, t_list/0, t_list/1,
+ t_list_elements/1, t_nonempty_list/1, t_maybe_improper_list/0,
+ t_module/0, t_number/0, t_number_vals/1,
+ t_opaque_match_record/2, t_opaque_matching_structure/2,
+ t_opaque_from_records/1,
+ t_pid/0, t_port/0, t_product/1, t_reference/0,
+ t_subst/2, t_subtract/2, t_subtract_list/2, t_sup/1, t_sup/2,
+ t_timeout/0, t_tuple/0, t_tuple/1,
+ t_unify/2, t_var/1, t_var_name/1,
+ t_none/0, t_unit/0]).
+
+-include("dialyzer.hrl").
+
+%%-----------------------------------------------------------------------------
+
+-type dep() :: integer(). %% type variable names used as constraint ids
+-type type_var() :: erl_types:erl_type(). %% actually: {'c','var',_,_}
+
+-record(fun_var, {'fun' :: fun((_) -> erl_types:erl_type()), deps :: [dep()]}).
+
+-type constr_op() :: 'eq' | 'sub'.
+-type fvar_or_type() :: #fun_var{} | erl_types:erl_type().
+
+-record(constraint, {lhs :: erl_types:erl_type(),
+ op :: constr_op(),
+ rhs :: fvar_or_type(),
+ deps :: [dep()]}).
+
+-record(constraint_list, {type :: 'conj' | 'disj',
+ list :: [_], % [constr()] but it needs recursion :-(
+ deps :: [dep()],
+ id :: {'list', dep()}}).
+
+-record(constraint_ref, {id :: type_var(), deps :: [dep()]}).
+
+-type constr() :: #constraint{} | #constraint_list{} | #constraint_ref{}.
+
+-type typesig_scc() :: [{mfa(), {cerl:c_var(), cerl:c_fun()}, dict()}].
+-type typesig_funmap() :: [{type_var(), type_var()}]. %% Orddict
+
+-record(state, {callgraph :: dialyzer_callgraph:callgraph(),
+ cs = [] :: [constr()],
+ cmap = dict:new() :: dict(),
+ fun_map = [] :: typesig_funmap(),
+ fun_arities = dict:new() :: dict(),
+ in_match = false :: boolean(),
+ in_guard = false :: boolean(),
+ name_map = dict:new() :: dict(),
+ next_label :: label(),
+ non_self_recs = [] :: [label()],
+ plt :: dialyzer_plt:plt(),
+ prop_types = dict:new() :: dict(),
+ records = dict:new() :: dict(),
+ opaques = [] :: [erl_types:erl_type()],
+ scc = [] :: [type_var()]}).
+
+%%-----------------------------------------------------------------------------
+
+-define(TYPE_LIMIT, 4).
+-define(INTERNAL_TYPE_LIMIT, 5).
+
+%%-define(DEBUG, true).
+%%-define(DEBUG_CONSTRAINTS, true).
+-ifdef(DEBUG).
+-define(DEBUG_NAME_MAP, true).
+-endif.
+%%-define(DEBUG_NAME_MAP, true).
+
+-ifdef(DEBUG).
+-define(debug(__String, __Args), io:format(__String, __Args)).
+-else.
+-define(debug(__String, __Args), ok).
+-endif.
+
+%% ============================================================================
+%%
+%% The analysis.
+%%
+%% ============================================================================
+
+%%-----------------------------------------------------------------------------
+%% Analysis of strongly connected components.
+%%
+%% analyze_scc(SCC, NextLabel, CallGraph, PLT, PropTypes) -> FunTypes
+%%
+%% SCC - [{MFA, Def, Records}]
+%% where Def = {Var, Fun} as in the Core Erlang module definitions.
+%% Records = dict(RecName, {Arity, [{FieldName, FieldType}]})
+%% NextLabel - An integer that is higher than any label in the code.
+%% CallGraph - A callgraph as produced by dialyzer_callgraph.erl
+%% Note: The callgraph must have been built with all the
+%% code that the SCC is a part of.
+%% PLT - A dialyzer PLT. This PLT should contain available information
+%% about functions that can be called by this SCC.
+%% PropTypes - A dictionary.
+%% FunTypes - A dictionary.
+%%-----------------------------------------------------------------------------
+
+-spec analyze_scc(typesig_scc(), label(),
+ dialyzer_callgraph:callgraph(),
+ dialyzer_plt:plt(), dict()) -> dict().
+
+analyze_scc(SCC, NextLabel, CallGraph, Plt, PropTypes) ->
+ assert_format_of_scc(SCC),
+ State1 = new_state(SCC, NextLabel, CallGraph, Plt, PropTypes),
+ DefSet = add_def_list([Var || {_MFA, {Var, _Fun}, _Rec} <- SCC], sets:new()),
+ State2 = traverse_scc(SCC, DefSet, State1),
+ State3 = state__finalize(State2),
+ Funs = state__scc(State3),
+ pp_constrs_scc(Funs, State3),
+ constraints_to_dot_scc(Funs, State3),
+ solve(Funs, State3).
+
+assert_format_of_scc([{_MFA, {_Var, _Fun}, _Records}|Left]) ->
+ assert_format_of_scc(Left);
+assert_format_of_scc([]) ->
+ ok.
+
+%% ============================================================================
+%%
+%% Gets the constraints by traversing the code.
+%%
+%% ============================================================================
+
+traverse_scc([{MFA, Def, Rec}|Left], DefSet, AccState) ->
+ TmpState1 = state__set_rec_dict(AccState, Rec),
+ TmpState2 = state__set_opaques(TmpState1, MFA),
+ DummyLetrec = cerl:c_letrec([Def], cerl:c_atom(foo)),
+ {NewAccState, _} = traverse(DummyLetrec, DefSet, TmpState2),
+ traverse_scc(Left, DefSet, NewAccState);
+traverse_scc([], _DefSet, AccState) ->
+ AccState.
+
+traverse(Tree, DefinedVars, State) ->
+ ?debug("Handling ~p\n", [cerl:type(Tree)]),
+ case cerl:type(Tree) of
+ alias ->
+ Var = cerl:alias_var(Tree),
+ Pat = cerl:alias_pat(Tree),
+ DefinedVars1 = add_def(Var, DefinedVars),
+ {State1, PatVar} = traverse(Pat, DefinedVars1, State),
+ State2 = state__store_conj(mk_var(Var), eq, PatVar, State1),
+ {State2, PatVar};
+ apply ->
+ Args = cerl:apply_args(Tree),
+ Arity = length(Args),
+ Op = cerl:apply_op(Tree),
+ {State0, ArgTypes} = traverse_list(Args, DefinedVars, State),
+ {State1, OpType} = traverse(Op, DefinedVars, State0),
+ {State2, FunType} = state__get_fun_prototype(OpType, Arity, State1),
+ State3 = state__store_conj(FunType, eq, OpType, State2),
+ State4 = state__store_conj(mk_var(Tree), sub, t_fun_range(FunType),
+ State3),
+ State5 = state__store_conj_lists(ArgTypes, sub, t_fun_args(FunType),
+ State4),
+ case state__lookup_apply(Tree, State) of
+ unknown ->
+ {State5, mk_var(Tree)};
+ FunLabels ->
+ case get_apply_constr(FunLabels, mk_var(Tree), ArgTypes, State5) of
+ error -> {State5, mk_var(Tree)};
+ {ok, State6} -> {State6, mk_var(Tree)}
+ end
+ end;
+ binary ->
+ {State1, SegTypes} = traverse_list(cerl:binary_segments(Tree),
+ DefinedVars, State),
+ Type = mk_fun_var(fun(Map) ->
+ TmpSegTypes = lookup_type_list(SegTypes, Map),
+ t_bitstr_concat(TmpSegTypes)
+ end, SegTypes),
+ {state__store_conj(mk_var(Tree), sub, Type, State1), mk_var(Tree)};
+ bitstr ->
+ Size = cerl:bitstr_size(Tree),
+ UnitVal = cerl:int_val(cerl:bitstr_unit(Tree)),
+ Val = cerl:bitstr_val(Tree),
+ {State1, [SizeType, ValType]} =
+ traverse_list([Size, Val], DefinedVars, State),
+ {State2, TypeConstr} =
+ case cerl:bitstr_bitsize(Tree) of
+ all -> {State1, t_bitstr(UnitVal, 0)};
+ utf -> {State1, t_binary()}; % contains an integer number of bytes
+ N when is_integer(N) -> {State1, t_bitstr(0, N)};
+ any -> % Size is not a literal
+ {state__store_conj(SizeType, sub, t_non_neg_integer(), State1),
+ mk_fun_var(bitstr_constr(SizeType, UnitVal), [SizeType])}
+ end,
+ ValTypeConstr =
+ case cerl:concrete(cerl:bitstr_type(Tree)) of
+ binary -> TypeConstr;
+ float ->
+ case state__is_in_match(State1) of
+ true -> t_float();
+ false -> t_number()
+ end;
+ integer ->
+ case state__is_in_match(State1) of
+ true ->
+ Flags = cerl:concrete(cerl:bitstr_flags(Tree)),
+ mk_fun_var(bitstr_val_constr(SizeType, UnitVal, Flags),
+ [SizeType]);
+ false -> t_integer()
+ end;
+ utf8 -> t_integer();
+ utf16 -> t_integer();
+ utf32 -> t_integer()
+ end,
+ State3 = state__store_conj(ValType, sub, ValTypeConstr, State2),
+ State4 = state__store_conj(mk_var(Tree), sub, TypeConstr, State3),
+ {State4, mk_var(Tree)};
+ 'case' ->
+ Arg = cerl:case_arg(Tree),
+ Clauses = filter_match_fail(cerl:case_clauses(Tree)),
+ {State1, ArgVar} = traverse(Arg, DefinedVars, State),
+ handle_clauses(Clauses, mk_var(Tree), ArgVar, DefinedVars, State1);
+ call ->
+ handle_call(Tree, DefinedVars, State);
+ 'catch' ->
+ %% XXX: Perhaps there is something to say about this.
+ {State, mk_var(Tree)};
+ cons ->
+ Hd = cerl:cons_hd(Tree),
+ Tl = cerl:cons_tl(Tree),
+ {State1, [HdVar, TlVar]} = traverse_list([Hd, Tl], DefinedVars, State),
+ case cerl:is_literal(cerl:fold_literal(Tree)) of
+ true ->
+ %% We do not need to do anything more here.
+ {State, t_cons(HdVar, TlVar)};
+ false ->
+ ConsVar = mk_var(Tree),
+ ConsType = mk_fun_var(fun(Map) ->
+ t_cons(lookup_type(HdVar, Map),
+ lookup_type(TlVar, Map))
+ end, [HdVar, TlVar]),
+ HdType = mk_fun_var(fun(Map) ->
+ Cons = lookup_type(ConsVar, Map),
+ case t_is_cons(Cons) of
+ false -> t_any();
+ true -> t_cons_hd(Cons)
+ end
+ end, [ConsVar]),
+ TlType = mk_fun_var(fun(Map) ->
+ Cons = lookup_type(ConsVar, Map),
+ case t_is_cons(Cons) of
+ false -> t_any();
+ true -> t_cons_tl(Cons)
+ end
+ end, [ConsVar]),
+ State2 = state__store_conj_lists([HdVar, TlVar, ConsVar], sub,
+ [HdType, TlType, ConsType],
+ State1),
+ {State2, ConsVar}
+ end;
+ 'fun' ->
+ Body = cerl:fun_body(Tree),
+ Vars = cerl:fun_vars(Tree),
+ DefinedVars1 = add_def_list(Vars, DefinedVars),
+ State0 = state__new_constraint_context(State),
+ FunFailType =
+ case state__prop_domain(cerl_trees:get_label(Tree), State0) of
+ error -> t_fun(length(Vars), t_none());
+ {ok, Dom} -> t_fun(Dom, t_none())
+ end,
+ State2 =
+ try
+ State1 = case state__add_prop_constrs(Tree, State0) of
+ not_called -> State0;
+ PropState -> PropState
+ end,
+ {BodyState, BodyVar} = traverse(Body, DefinedVars1, State1),
+ state__store_conj(mk_var(Tree), eq,
+ t_fun(mk_var_list(Vars), BodyVar), BodyState)
+ catch
+ throw:error ->
+ state__store_conj(mk_var(Tree), eq, FunFailType, State0)
+ end,
+ Cs = state__cs(State2),
+ State3 = state__store_constrs(mk_var(Tree), Cs, State2),
+ Ref = mk_constraint_ref(mk_var(Tree), get_deps(Cs)),
+ OldCs = state__cs(State),
+ State4 = state__new_constraint_context(State3),
+ State5 = state__store_conj_list([OldCs, Ref], State4),
+ State6 = state__store_fun_arity(Tree, State5),
+ {State6, mk_var(Tree)};
+ 'let' ->
+ Vars = cerl:let_vars(Tree),
+ Arg = cerl:let_arg(Tree),
+ Body = cerl:let_body(Tree),
+ {State1, ArgVars} = traverse(Arg, DefinedVars, State),
+ State2 = state__store_conj(t_product(mk_var_list(Vars)), eq,
+ ArgVars, State1),
+ DefinedVars1 = add_def_list(Vars, DefinedVars),
+ traverse(Body, DefinedVars1, State2);
+ letrec ->
+ Defs = cerl:letrec_defs(Tree),
+ Body = cerl:letrec_body(Tree),
+ Funs = [Fun || {_Var, Fun} <- Defs],
+ Vars = [Var || {Var, _Fun} <- Defs],
+ State1 = state__store_funs(Vars, Funs, State),
+ DefinedVars1 = add_def_list(Vars, DefinedVars),
+ {State2, _} = traverse_list(Funs, DefinedVars1, State1),
+ traverse(Body, DefinedVars1, State2);
+ literal ->
+ %% This is needed for finding records
+ case cerl:unfold_literal(Tree) of
+ Tree ->
+ Type = t_from_term(cerl:concrete(Tree)),
+ NewType =
+ case erl_types:t_opaque_match_atom(Type, State#state.opaques) of
+ [Opaque] -> Opaque;
+ _ -> Type
+ end,
+ {State, NewType};
+ NewTree -> traverse(NewTree, DefinedVars, State)
+ end;
+ module ->
+ Defs = cerl:module_defs(Tree),
+ Funs = [Fun || {_Var, Fun} <- Defs],
+ Vars = [Var || {Var, _Fun} <- Defs],
+ DefinedVars1 = add_def_list(Vars, DefinedVars),
+ State1 = state__store_funs(Vars, Funs, State),
+ FoldFun = fun(Fun, AccState) ->
+ {S, _} = traverse(Fun, DefinedVars1,
+ state__new_constraint_context(AccState)),
+ S
+ end,
+ lists:foldl(FoldFun, State1, Funs);
+ primop ->
+ case cerl:atom_val(cerl:primop_name(Tree)) of
+ match_fail -> throw(error);
+ raise -> throw(error);
+ bs_init_writable -> {State, t_from_term(<<>>)};
+ Other -> erlang:error({'Unsupported primop', Other})
+ end;
+ 'receive' ->
+ Clauses = filter_match_fail(cerl:receive_clauses(Tree)),
+ Timeout = cerl:receive_timeout(Tree),
+ case (cerl:is_c_atom(Timeout) andalso
+ (cerl:atom_val(Timeout) =:= infinity)) of
+ true ->
+ handle_clauses(Clauses, mk_var(Tree), [], DefinedVars, State);
+ false ->
+ Action = cerl:receive_action(Tree),
+ {State1, TimeoutVar} = traverse(Timeout, DefinedVars, State),
+ State2 = state__store_conj(TimeoutVar, sub, t_timeout(), State1),
+ handle_clauses(Clauses, mk_var(Tree), [], Action, DefinedVars, State2)
+ end;
+ seq ->
+ Body = cerl:seq_body(Tree),
+ Arg = cerl:seq_arg(Tree),
+ {State1, _} = traverse(Arg, DefinedVars, State),
+ traverse(Body, DefinedVars, State1);
+ 'try' ->
+ handle_try(Tree, DefinedVars, State);
+ tuple ->
+ Elements = cerl:tuple_es(Tree),
+ {State1, EVars} = traverse_list(Elements, DefinedVars, State),
+ {State2, TupleType} =
+ case cerl:is_literal(cerl:fold_literal(Tree)) of
+ true ->
+ %% We do not need to do anything more here.
+ {State, t_tuple(EVars)};
+ false ->
+ %% We have the same basic problem as in products, but we want to
+ %% make sure that everything that can be used as tags for the
+ %% disjoint unions stays in the tuple.
+ Fun = fun(Var, AccState) ->
+ case t_has_var(Var) of
+ true ->
+ {AccState1, NewVar} = state__mk_var(AccState),
+ {NewVar,
+ state__store_conj(Var, eq, NewVar, AccState1)};
+ false ->
+ {Var, AccState}
+ end
+ end,
+ {NewEvars, TmpState} = lists:mapfoldl(Fun, State1, EVars),
+ {TmpState, t_tuple(NewEvars)}
+ end,
+ case Elements of
+ [Tag|Fields] ->
+ case cerl:is_c_atom(Tag) of
+ true ->
+ %% Check if an opaque term is constructed.
+ case t_opaque_match_record(TupleType, State#state.opaques) of
+ [Opaque] ->
+ OpStruct = t_opaque_matching_structure(TupleType, Opaque),
+ State3 = state__store_conj(TupleType, sub, OpStruct, State2),
+ {State3, Opaque};
+ %% Check if a record is constructed.
+ _ ->
+ Arity = length(Fields),
+ case state__lookup_record(State2, cerl:atom_val(Tag), Arity) of
+ error -> {State2, TupleType};
+ {ok, RecType} ->
+ State3 = state__store_conj(TupleType, sub, RecType, State2),
+ {State3, TupleType}
+ end
+ end;
+ false -> {State2, TupleType}
+ end;
+ [] -> {State2, TupleType}
+ end;
+ values ->
+ %% We can get into trouble when unifying products that have the
+ %% same element appearing several times. Handle these cases by
+ %% introducing fresh variables and constraining them to be equal
+ %% to the original ones. This is similar to what happens in
+ %% pattern matching where the matching is done on fresh
+ %% variables and guards assert that the matching is correct.
+ Elements = cerl:values_es(Tree),
+ {State1, EVars} = traverse_list(Elements, DefinedVars, State),
+ Arity = length(EVars),
+ Unique = length(ordsets:from_list(EVars)),
+ case Arity =:= Unique of
+ true -> {State1, t_product(EVars)};
+ false ->
+ {State2, Vars} = state__mk_vars(Arity, State1),
+ State3 = state__store_conj_lists(Vars, eq, EVars, State2),
+ {State3, t_product(Vars)}
+ end;
+ var ->
+ case is_def(Tree, DefinedVars) of
+ true -> {State, mk_var(Tree)};
+ false ->
+ %% If we are analyzing SCCs this can be a function variable.
+ case state__lookup_undef_var(Tree, State) of
+ error -> erlang:error({'Undefined variable', Tree});
+ {ok, Type} ->
+ {State1, NewVar} = state__mk_var(State),
+ {state__store_conj(NewVar, sub, Type, State1), NewVar}
+ end
+ end;
+ Other ->
+ erlang:error({'Unsupported type', Other})
+ end.
+
+traverse_list(Trees, DefinedVars, State) ->
+ traverse_list(Trees, DefinedVars, State, []).
+
+traverse_list([Tree|Tail], DefinedVars, State, Acc) ->
+ {State1, Var} = traverse(Tree, DefinedVars, State),
+ traverse_list(Tail, DefinedVars, State1, [Var|Acc]);
+traverse_list([], _DefinedVars, State, Acc) ->
+ {State, lists:reverse(Acc)}.
+
+add_def(Var, Set) ->
+ sets:add_element(cerl_trees:get_label(Var), Set).
+
+add_def_list([H|T], Set) ->
+ add_def_list(T, add_def(H, Set));
+add_def_list([], Set) ->
+ Set.
+
+add_def_from_tree(T, DefinedVars) ->
+ Vars = cerl_trees:fold(fun(X, Acc) ->
+ case cerl:is_c_var(X) of
+ true -> [X|Acc];
+ false -> Acc
+ end
+ end, [], T),
+ add_def_list(Vars, DefinedVars).
+
+add_def_from_tree_list([H|T], DefinedVars) ->
+ add_def_from_tree_list(T, add_def_from_tree(H, DefinedVars));
+add_def_from_tree_list([], DefinedVars) ->
+ DefinedVars.
+
+is_def(Var, Set) ->
+ sets:is_element(cerl_trees:get_label(Var), Set).
+
+%%----------------------------------------
+%% Try
+%%
+
+handle_try(Tree, DefinedVars, State) ->
+ Arg = cerl:try_arg(Tree),
+ Vars = cerl:try_vars(Tree),
+ EVars = cerl:try_evars(Tree),
+ Body = cerl:try_body(Tree),
+ Handler = cerl:try_handler(Tree),
+ State1 = state__new_constraint_context(State),
+ {ArgBodyState, BodyVar} =
+ try
+ {State2, ArgVar} = traverse(Arg, DefinedVars, State1),
+ DefinedVars1 = add_def_list(Vars, DefinedVars),
+ {State3, BodyVar1} = traverse(Body, DefinedVars1, State2),
+ State4 = state__store_conj(t_product(mk_var_list(Vars)), eq, ArgVar,
+ State3),
+ {State4, BodyVar1}
+ catch
+ throw:error ->
+ {State1, t_none()}
+ end,
+ State6 = state__new_constraint_context(ArgBodyState),
+ {HandlerState, HandlerVar} =
+ try
+ DefinedVars2 = add_def_list([X || X <- EVars, cerl:is_c_var(X)],
+ DefinedVars),
+ traverse(Handler, DefinedVars2, State6)
+ catch
+ throw:error ->
+ {State6, t_none()}
+ end,
+ ArgBodyCs = state__cs(ArgBodyState),
+ HandlerCs = state__cs(HandlerState),
+ TreeVar = mk_var(Tree),
+ OldCs = state__cs(State),
+ case state__is_in_guard(State) of
+ true ->
+ Conj1 = mk_conj_constraint_list([ArgBodyCs,
+ mk_constraint(BodyVar, eq, TreeVar)]),
+ Disj = mk_disj_constraint_list([Conj1,
+ mk_constraint(HandlerVar, eq, TreeVar)]),
+ NewState1 = state__new_constraint_context(HandlerState),
+ Conj2 = mk_conj_constraint_list([OldCs, Disj]),
+ NewState2 = state__store_conj(Conj2, NewState1),
+ {NewState2, TreeVar};
+ false ->
+ {NewCs, ReturnVar} =
+ case {t_is_none(BodyVar), t_is_none(HandlerVar)} of
+ {false, false} ->
+ Conj1 =
+ mk_conj_constraint_list([ArgBodyCs,
+ mk_constraint(TreeVar, eq, BodyVar)]),
+ Conj2 =
+ mk_conj_constraint_list([HandlerCs,
+ mk_constraint(TreeVar, eq, HandlerVar)]),
+ Disj = mk_disj_constraint_list([Conj1, Conj2]),
+ {Disj, mk_var(Tree)};
+ {false, true} ->
+ {mk_conj_constraint_list([ArgBodyCs,
+ mk_constraint(TreeVar, eq, BodyVar)]),
+ BodyVar};
+ {true, false} ->
+ {mk_conj_constraint_list([HandlerCs,
+ mk_constraint(TreeVar, eq, HandlerVar)]),
+ HandlerVar};
+ {true, true} ->
+ ?debug("Throw failed\n", []),
+ throw(error)
+ end,
+ Conj = mk_conj_constraint_list([OldCs, NewCs]),
+ NewState1 = state__new_constraint_context(HandlerState),
+ NewState2 = state__store_conj(Conj, NewState1),
+ {NewState2, ReturnVar}
+ end.
+
+%%----------------------------------------
+%% Call
+%%
+
+handle_call(Call, DefinedVars, State) ->
+ Args = cerl:call_args(Call),
+ Mod = cerl:call_module(Call),
+ Fun = cerl:call_name(Call),
+ Dst = mk_var(Call),
+ case cerl:is_c_atom(Mod) andalso cerl:is_c_atom(Fun) of
+ true ->
+ M = cerl:atom_val(Mod),
+ F = cerl:atom_val(Fun),
+ A = length(Args),
+ MFA = {M, F, A},
+ {State1, ArgVars} = traverse_list(Args, DefinedVars, State),
+ case state__lookup_rec_var_in_scope(MFA, State) of
+ error ->
+ case get_bif_constr(MFA, Dst, ArgVars, State1) of
+ none ->
+ {get_plt_constr(MFA, Dst, ArgVars, State1), Dst};
+ C ->
+ {state__store_conj(C, State1), Dst}
+ end;
+ {ok, Var} ->
+ %% This is part of the SCC currently analyzed.
+ %% Intercept and change this to an apply instead.
+ ?debug("Found the call to ~w\n", [MFA]),
+ Label = cerl_trees:get_label(Call),
+ Apply = cerl:ann_c_apply([{label, Label}], Var, Args),
+ traverse(Apply, DefinedVars, State)
+ end;
+ false ->
+ {State1, MF} = traverse_list([Mod, Fun], DefinedVars, State),
+ {state__store_conj_lists(MF, sub, [t_module(), t_atom()], State1), Dst}
+ end.
+
+get_plt_constr(MFA, Dst, ArgVars, State) ->
+ Plt = state__plt(State),
+ PltRes = dialyzer_plt:lookup(Plt, MFA),
+ case dialyzer_plt:lookup_contract(Plt, MFA) of
+ none ->
+ case PltRes of
+ none -> State;
+ {value, {PltRetType, PltArgTypes}} ->
+ state__store_conj_lists([Dst|ArgVars], sub,
+ [PltRetType|PltArgTypes], State)
+ end;
+ {value, #contract{args = GenArgs} = C} ->
+ {RetType, ArgCs} =
+ case PltRes of
+ none ->
+ {mk_fun_var(fun(Map) ->
+ ArgTypes = lookup_type_list(ArgVars, Map),
+ dialyzer_contracts:get_contract_return(C, ArgTypes)
+ end, ArgVars), GenArgs};
+ {value, {PltRetType, PltArgTypes}} ->
+ %% Need to combine the contract with the success typing.
+ {mk_fun_var(
+ fun(Map) ->
+ ArgTypes = lookup_type_list(ArgVars, Map),
+ CRet = dialyzer_contracts:get_contract_return(C, ArgTypes),
+ t_inf(CRet, PltRetType, opaque)
+ end, ArgVars),
+ [t_inf(X, Y, opaque) || {X, Y} <- lists:zip(GenArgs, PltArgTypes)]}
+ end,
+ state__store_conj_lists([Dst|ArgVars], sub, [RetType|ArgCs], State)
+ end.
+
+filter_match_fail([Clause] = Cls) ->
+ Body = cerl:clause_body(Clause),
+ case cerl:type(Body) of
+ primop ->
+ case cerl:atom_val(cerl:primop_name(Body)) of
+ match_fail -> [];
+ raise -> [];
+ _ -> Cls
+ end;
+ _ -> Cls
+ end;
+filter_match_fail([H|T]) ->
+ [H|filter_match_fail(T)];
+filter_match_fail([]) ->
+ %% This can actually happen, for example in
+ %% receive after 1 -> ok end
+ [].
+
+%% If there is a significant number of clauses, we cannot apply the
+%% list subtraction scheme since it causes the analysis to be too
+%% slow. Typically, this only affects automatically generated files.
+%% Anyway, and the dataflow analysis doesn't suffer from this, so we
+%% will get some information anyway.
+-define(MAX_NOF_CLAUSES, 15).
+
+handle_clauses(Clauses, TopVar, Arg, DefinedVars, State) ->
+ handle_clauses(Clauses, TopVar, Arg, none, DefinedVars, State).
+
+handle_clauses([], _, _, Action, DefinedVars, State) when Action =/= none ->
+ %% Can happen when a receive has no clauses, see filter_match_fail.
+ traverse(Action, DefinedVars, State);
+handle_clauses(Clauses, TopVar, Arg, Action, DefinedVars, State) ->
+ SubtrTypeList =
+ if length(Clauses) > ?MAX_NOF_CLAUSES -> overflow;
+ true -> []
+ end,
+ {State1, CList} = handle_clauses_1(Clauses, TopVar, Arg, DefinedVars,
+ State, SubtrTypeList, []),
+ {NewCs, NewState} =
+ case Action of
+ none ->
+ if CList =:= [] -> throw(error);
+ true -> {CList, State1}
+ end;
+ _ ->
+ try
+ {State2, ActionVar} = traverse(Action, DefinedVars, State1),
+ TmpC = mk_constraint(TopVar, eq, ActionVar),
+ ActionCs = mk_conj_constraint_list([state__cs(State2),TmpC]),
+ {[ActionCs|CList], State2}
+ catch
+ throw:error ->
+ if CList =:= [] -> throw(error);
+ true -> {CList, State1}
+ end
+ end
+ end,
+ OldCs = state__cs(State),
+ NewCList = mk_disj_constraint_list(NewCs),
+ FinalState = state__new_constraint_context(NewState),
+ {state__store_conj_list([OldCs, NewCList], FinalState), TopVar}.
+
+handle_clauses_1([Clause|Tail], TopVar, Arg, DefinedVars,
+ State, SubtrTypes, Acc) ->
+ State0 = state__new_constraint_context(State),
+ Pats = cerl:clause_pats(Clause),
+ Guard = cerl:clause_guard(Clause),
+ Body = cerl:clause_body(Clause),
+ NewSubtrTypes =
+ case SubtrTypes =:= overflow of
+ true -> overflow;
+ false ->
+ ordsets:add_element(get_safe_underapprox(Pats, Guard), SubtrTypes)
+ end,
+ try
+ DefinedVars1 = add_def_from_tree_list(Pats, DefinedVars),
+ State1 = state__set_in_match(State0, true),
+ {State2, PatVars} = traverse_list(Pats, DefinedVars1, State1),
+ State3 =
+ case Arg =:= [] of
+ true -> State2;
+ false ->
+ S = state__store_conj(Arg, eq, t_product(PatVars), State2),
+ case SubtrTypes =:= overflow of
+ true -> S;
+ false ->
+ SubtrPatVar = mk_fun_var(fun(Map) ->
+ TmpType = lookup_type(Arg, Map),
+ t_subtract_list(TmpType, SubtrTypes)
+ end, [Arg]),
+ state__store_conj(Arg, sub, SubtrPatVar, S)
+ end
+ end,
+ State4 = handle_guard(Guard, DefinedVars1, State3),
+ {State5, BodyVar} = traverse(Body, DefinedVars1,
+ state__set_in_match(State4, false)),
+ State6 = state__store_conj(TopVar, eq, BodyVar, State5),
+ Cs = state__cs(State6),
+ handle_clauses_1(Tail, TopVar, Arg, DefinedVars, State6,
+ NewSubtrTypes, [Cs|Acc])
+ catch
+ throw:error ->
+ handle_clauses_1(Tail, TopVar, Arg, DefinedVars,
+ State, NewSubtrTypes, Acc)
+ end;
+handle_clauses_1([], _TopVar, _Arg, _DefinedVars, State, _SubtrType, Acc) ->
+ {state__new_constraint_context(State), Acc}.
+
+-spec get_safe_underapprox([cerl:c_values()], cerl:cerl()) -> erl_types:erl_type().
+
+get_safe_underapprox(Pats, Guard) ->
+ try
+ Map1 = cerl_trees:fold(fun(X, Acc) ->
+ case cerl:is_c_var(X) of
+ true ->
+ dict:store(cerl_trees:get_label(X), t_any(),
+ Acc);
+ false -> Acc
+ end
+ end, dict:new(), cerl:c_values(Pats)),
+ {Type, Map2} = get_underapprox_from_guard(Guard, Map1),
+ Map3 = case t_is_none(t_inf(t_from_term(true), Type)) of
+ true -> throw(dont_know);
+ false ->
+ case cerl:is_c_var(Guard) of
+ false -> Map2;
+ true ->
+ dict:store(cerl_trees:get_label(Guard),
+ t_from_term(true), Map2)
+ end
+ end,
+ {Ts, _Map4} = get_safe_underapprox_1(Pats, [], Map3),
+ t_product(Ts)
+ catch
+ throw:dont_know -> t_none()
+ end.
+
+get_underapprox_from_guard(Tree, Map) ->
+ True = t_from_term(true),
+ case cerl:type(Tree) of
+ call ->
+ case {cerl:concrete(cerl:call_module(Tree)),
+ cerl:concrete(cerl:call_name(Tree)),
+ length(cerl:call_args(Tree))} of
+ {erlang, is_function, 2} ->
+ [Fun, Arity] = cerl:call_args(Tree),
+ case cerl:is_c_int(Arity) of
+ false -> throw(dont_know);
+ true ->
+ {FunType, Map1} = get_underapprox_from_guard(Fun, Map),
+ Inf = t_inf(FunType, t_fun(cerl:int_val(Arity), t_any())),
+ case t_is_none(Inf) of
+ true -> throw(dont_know);
+ false ->
+ {True, dict:store(cerl_trees:get_label(Fun), Inf, Map1)}
+ end
+ end;
+ MFA ->
+ case get_type_test(MFA) of
+ {ok, Type} ->
+ [Arg] = cerl:call_args(Tree),
+ {ArgType, Map1} = get_underapprox_from_guard(Arg, Map),
+ Inf = t_inf(Type, ArgType),
+ case t_is_none(Inf) of
+ true -> throw(dont_know);
+ false ->
+ case cerl:is_literal(Arg) of
+ true -> {True, Map1};
+ false ->
+ {True, dict:store(cerl_trees:get_label(Arg), Inf, Map1)}
+ end
+ end;
+ error ->
+ case MFA of
+ {erlang, '=:=', 2} -> throw(dont_know);
+ {erlang, '==', 2} -> throw(dont_know);
+ {erlang, 'and', 2} ->
+ [Arg1, Arg2] = cerl:call_args(Tree),
+ case ((cerl:is_c_var(Arg1) orelse cerl:is_literal(Arg1))
+ andalso
+ (cerl:is_c_var(Arg2) orelse cerl:is_literal(Arg2))) of
+ true ->
+ {Arg1Type, _} = get_underapprox_from_guard(Arg1, Map),
+ {Arg2Type, _} = get_underapprox_from_guard(Arg1, Map),
+ case (t_is_equal(True, Arg1Type) andalso
+ t_is_equal(True, Arg2Type)) of
+ true -> {True, Map};
+ false -> throw(dont_know)
+ end;
+ false ->
+ throw(dont_know)
+ end;
+ {erlang, 'or', 2} -> throw(dont_know);
+ _ -> throw(dont_know)
+ end
+ end
+ end;
+ var ->
+ Type =
+ case dict:find(cerl_trees:get_label(Tree), Map) of
+ error -> throw(dont_know);
+ {ok, T} -> T
+ end,
+ {Type, Map};
+ literal ->
+ case cerl:unfold_literal(Tree) of
+ Tree ->
+ Type =
+ case cerl:concrete(Tree) of
+ Int when is_integer(Int) -> t_from_term(Int);
+ Atom when is_atom(Atom) -> t_from_term(Atom);
+ _Other -> throw(dont_know)
+ end,
+ {Type, Map};
+ OtherTree ->
+ get_underapprox_from_guard(OtherTree, Map)
+ end;
+ _ ->
+ throw(dont_know)
+ end.
+
+%%
+%% The guard test {erlang, is_function, 2} is handled specially by the
+%% function get_underapprox_from_guard/2
+%%
+get_type_test({erlang, is_atom, 1}) -> {ok, t_atom()};
+get_type_test({erlang, is_boolean, 1}) -> {ok, t_boolean()};
+get_type_test({erlang, is_binary, 1}) -> {ok, t_binary()};
+get_type_test({erlang, is_bitstring, 1}) -> {ok, t_bitstr()};
+get_type_test({erlang, is_float, 1}) -> {ok, t_float()};
+get_type_test({erlang, is_function, 1}) -> {ok, t_fun()};
+get_type_test({erlang, is_integer, 1}) -> {ok, t_integer()};
+get_type_test({erlang, is_list, 1}) -> {ok, t_list()};
+get_type_test({erlang, is_number, 1}) -> {ok, t_number()};
+get_type_test({erlang, is_pid, 1}) -> {ok, t_pid()};
+get_type_test({erlang, is_port, 1}) -> {ok, t_port()};
+%% get_type_test({erlang, is_record, 2}) -> {ok, t_tuple()};
+%% get_type_test({erlang, is_record, 3}) -> {ok, t_tuple()};
+get_type_test({erlang, is_reference, 1}) -> {ok, t_reference()};
+get_type_test({erlang, is_tuple, 1}) -> {ok, t_tuple()};
+get_type_test({M, F, A}) when is_atom(M), is_atom(F), is_integer(A) -> error.
+
+bitstr_constr(SizeType, UnitVal) ->
+ fun(Map) ->
+ TmpSizeType = lookup_type(SizeType, Map),
+ case t_is_subtype(TmpSizeType, t_non_neg_integer()) of
+ true ->
+ case t_number_vals(TmpSizeType) of
+ [OneSize] -> t_bitstr(0, OneSize * UnitVal);
+ _ ->
+ MinSize = erl_types:number_min(TmpSizeType),
+ t_bitstr(UnitVal, MinSize * UnitVal)
+ end;
+ false ->
+ t_bitstr(UnitVal, 0)
+ end
+ end.
+
+bitstr_val_constr(SizeType, UnitVal, Flags) ->
+ fun(Map) ->
+ TmpSizeType = lookup_type(SizeType, Map),
+ case t_is_subtype(TmpSizeType, t_non_neg_integer()) of
+ true ->
+ case erl_types:number_max(TmpSizeType) of
+ N when is_integer(N), N < 128 -> %% Avoid illegal arithmetic
+ TotalSizeVal = N * UnitVal,
+ {RangeMin, RangeMax} =
+ case lists:member(signed, Flags) of
+ true -> {-(1 bsl (TotalSizeVal - 1)),
+ 1 bsl (TotalSizeVal - 1) - 1};
+ false -> {0, 1 bsl TotalSizeVal - 1}
+ end,
+ t_from_range(RangeMin, RangeMax);
+ _ ->
+ t_integer()
+ end;
+ false ->
+ t_integer()
+ end
+ end.
+
+get_safe_underapprox_1([Pat|Left], Acc, Map) ->
+ case cerl:type(Pat) of
+ alias ->
+ APat = cerl:alias_pat(Pat),
+ AVar = cerl:alias_var(Pat),
+ {[VarType], Map1} = get_safe_underapprox_1([AVar], [], Map),
+ {[PatType], Map2} = get_safe_underapprox_1([APat], [], Map1),
+ Inf = t_inf(VarType, PatType),
+ case t_is_none(Inf) of
+ true -> throw(dont_know);
+ false ->
+ Map3 = dict:store(cerl_trees:get_label(AVar), Inf, Map2),
+ get_safe_underapprox_1(Left, [Inf|Acc], Map3)
+ end;
+ binary ->
+ %% TODO: Can maybe do something here
+ throw(dont_know);
+ cons ->
+ {[Hd, Tl], Map1} =
+ get_safe_underapprox_1([cerl:cons_hd(Pat), cerl:cons_tl(Pat)], [], Map),
+ case t_is_any(Tl) of
+ true -> get_safe_underapprox_1(Left, [t_nonempty_list(Hd)|Acc], Map1);
+ false -> throw(dont_know)
+ end;
+ literal ->
+ case cerl:unfold_literal(Pat) of
+ Pat ->
+ Type =
+ case cerl:concrete(Pat) of
+ Int when is_integer(Int) -> t_from_term(Int);
+ Atom when is_atom(Atom) -> t_from_term(Atom);
+ [] -> t_from_term([]);
+ _Other -> throw(dont_know)
+ end,
+ get_safe_underapprox_1(Left, [Type|Acc], Map);
+ OtherPat ->
+ get_safe_underapprox_1([OtherPat|Left], Acc, Map)
+ end;
+ tuple ->
+ Es = cerl:tuple_es(Pat),
+ {Ts, Map1} = get_safe_underapprox_1(Es, [], Map),
+ Type = t_tuple(Ts),
+ get_safe_underapprox_1(Left, [Type|Acc], Map1);
+ values ->
+ Es = cerl:values_es(Pat),
+ {Ts, Map1} = get_safe_underapprox_1(Es, [], Map),
+ Type = t_product(Ts),
+ get_safe_underapprox_1(Left, [Type|Acc], Map1);
+ var ->
+ case dict:find(cerl_trees:get_label(Pat), Map) of
+ error -> throw(dont_know);
+ {ok, VarType} -> get_safe_underapprox_1(Left, [VarType|Acc], Map)
+ end
+ end;
+get_safe_underapprox_1([], Acc, Map) ->
+ {lists:reverse(Acc), Map}.
+
+%%----------------------------------------
+%% Guards
+%%
+
+handle_guard(Guard, DefinedVars, State) ->
+ True = t_from_term(true),
+ State1 = state__set_in_guard(State, true),
+ State2 = state__new_constraint_context(State1),
+ {State3, Return} = traverse(Guard, DefinedVars, State2),
+ State4 = state__store_conj(Return, eq, True, State3),
+ Cs = state__cs(State4),
+ NewCs = mk_disj_norm_form(Cs),
+ OldCs = state__cs(State),
+ State5 = state__set_in_guard(State4, state__is_in_guard(State)),
+ State6 = state__new_constraint_context(State5),
+ state__store_conj(mk_conj_constraint_list([OldCs, NewCs]), State6).
+
+%%=============================================================================
+%%
+%% BIF constraints
+%%
+%%=============================================================================
+
+get_bif_constr({erlang, Op, 2}, Dst, Args = [Arg1, Arg2], _State)
+ when Op =:= '+'; Op =:= '-'; Op =:= '*' ->
+ ReturnType = mk_fun_var(fun(Map) ->
+ TmpArgTypes = lookup_type_list(Args, Map),
+ erl_bif_types:type(erlang, Op, 2, TmpArgTypes)
+ end, Args),
+ ArgFun =
+ fun(A, Pos) ->
+ F =
+ fun(Map) ->
+ DstType = lookup_type(Dst, Map),
+ AType = lookup_type(A, Map),
+ case t_is_integer(DstType) of
+ true ->
+ case t_is_integer(AType) of
+ true ->
+ eval_inv_arith(Op, Pos, DstType, AType);
+ false ->
+ %% This must be temporary.
+ t_integer()
+ end;
+ false ->
+ case t_is_float(DstType) of
+ true ->
+ case t_is_integer(AType) of
+ true -> t_float();
+ false -> t_number()
+ end;
+ false ->
+ t_number()
+ end
+ end
+ end,
+ mk_fun_var(F, [Dst, A])
+ end,
+ Arg1FunVar = ArgFun(Arg2, 2),
+ Arg2FunVar = ArgFun(Arg1, 1),
+ mk_conj_constraint_list([mk_constraint(Dst, sub, ReturnType),
+ mk_constraint(Arg1, sub, Arg1FunVar),
+ mk_constraint(Arg2, sub, Arg2FunVar)]);
+get_bif_constr({erlang, Op, 2}, Dst, [Arg1, Arg2] = Args, _State)
+ when Op =:= '<'; Op =:= '=<'; Op =:= '>'; Op =:= '>=' ->
+ ArgFun =
+ fun(LocalArg1, LocalArg2, LocalOp) ->
+ fun(Map) ->
+ DstType = lookup_type(Dst, Map),
+ IsTrue = t_is_atom(true, DstType),
+ IsFalse = t_is_atom(false, DstType),
+ case IsTrue orelse IsFalse of
+ true ->
+ Arg1Type = lookup_type(LocalArg1, Map),
+ Arg2Type = lookup_type(LocalArg2, Map),
+ case t_is_integer(Arg1Type) andalso t_is_integer(Arg2Type) of
+ true ->
+ Max1 = erl_types:number_max(Arg1Type),
+ Min1 = erl_types:number_min(Arg1Type),
+ Max2 = erl_types:number_max(Arg2Type),
+ Min2 = erl_types:number_min(Arg2Type),
+ case LocalOp of
+ '=<' ->
+ if IsTrue -> t_from_range(Min1, Max2);
+ IsFalse -> t_from_range(range_inc(Min2), Max1)
+ end;
+ '<' ->
+ if IsTrue -> t_from_range(Min1, range_dec(Max2));
+ IsFalse -> t_from_range(Min2, Max1)
+ end;
+ '>=' ->
+ if IsTrue -> t_from_range(Min2, Max1);
+ IsFalse -> t_from_range(Min1, range_dec(Max2))
+ end;
+ '>' ->
+ if IsTrue -> t_from_range(range_inc(Min2), Max1);
+ IsFalse -> t_from_range(Min1, Max2)
+ end
+ end;
+ false -> t_any()
+ end;
+ false -> t_any()
+ end
+ end
+ end,
+ {Arg1Fun, Arg2Fun} =
+ case Op of
+ '<' -> {ArgFun(Arg1, Arg2, '<'), ArgFun(Arg2, Arg1, '>=')};
+ '=<' -> {ArgFun(Arg1, Arg2, '=<'), ArgFun(Arg2, Arg1, '>=')};
+ '>' -> {ArgFun(Arg1, Arg2, '>'), ArgFun(Arg2, Arg1, '<')};
+ '>=' -> {ArgFun(Arg1, Arg2, '>='), ArgFun(Arg2, Arg1, '=<')}
+ end,
+ DstArgs = [Dst, Arg1, Arg2],
+ Arg1Var = mk_fun_var(Arg1Fun, DstArgs),
+ Arg2Var = mk_fun_var(Arg2Fun, DstArgs),
+ DstVar = mk_fun_var(fun(Map) ->
+ TmpArgTypes = lookup_type_list(Args, Map),
+ erl_bif_types:type(erlang, Op, 2, TmpArgTypes)
+ end, Args),
+ mk_conj_constraint_list([mk_constraint(Dst, sub, DstVar),
+ mk_constraint(Arg1, sub, Arg1Var),
+ mk_constraint(Arg2, sub, Arg2Var)]);
+get_bif_constr({erlang, '++', 2}, Dst, [Hd, Tl] = Args, _State) ->
+ HdFun = fun(Map) ->
+ DstType = lookup_type(Dst, Map),
+ case t_is_cons(DstType) of
+ true -> t_list(t_cons_hd(DstType));
+ false ->
+ case t_is_list(DstType) of
+ true ->
+ case t_is_nil(DstType) of
+ true -> DstType;
+ false -> t_list(t_list_elements(DstType))
+ end;
+ false -> t_list()
+ end
+ end
+ end,
+ TlFun = fun(Map) ->
+ DstType = lookup_type(Dst, Map),
+ case t_is_cons(DstType) of
+ true -> t_sup(t_cons_tl(DstType), DstType);
+ false ->
+ case t_is_list(DstType) of
+ true ->
+ case t_is_nil(DstType) of
+ true -> DstType;
+ false -> t_list(t_list_elements(DstType))
+ end;
+ false -> t_any()
+ end
+ end
+ end,
+ DstL = [Dst],
+ HdVar = mk_fun_var(HdFun, DstL),
+ TlVar = mk_fun_var(TlFun, DstL),
+ ArgTypes = erl_bif_types:arg_types(erlang, '++', 2),
+ ReturnType = mk_fun_var(fun(Map) ->
+ TmpArgTypes = lookup_type_list(Args, Map),
+ erl_bif_types:type(erlang, '++', 2, TmpArgTypes)
+ end, Args),
+ Cs = mk_constraints(Args, sub, ArgTypes),
+ mk_conj_constraint_list([mk_constraint(Dst, sub, ReturnType),
+ mk_constraint(Hd, sub, HdVar),
+ mk_constraint(Tl, sub, TlVar)
+ |Cs]);
+get_bif_constr({erlang, is_atom, 1}, Dst, [Arg], State) ->
+ get_bif_test_constr(Dst, Arg, t_atom(), State);
+get_bif_constr({erlang, is_binary, 1}, Dst, [Arg], State) ->
+ get_bif_test_constr(Dst, Arg, t_binary(), State);
+get_bif_constr({erlang, is_bitstring, 1}, Dst, [Arg], State) ->
+ get_bif_test_constr(Dst, Arg, t_bitstr(), State);
+get_bif_constr({erlang, is_boolean, 1}, Dst, [Arg], State) ->
+ get_bif_test_constr(Dst, Arg, t_boolean(), State);
+get_bif_constr({erlang, is_float, 1}, Dst, [Arg], State) ->
+ get_bif_test_constr(Dst, Arg, t_float(), State);
+get_bif_constr({erlang, is_function, 1}, Dst, [Arg], State) ->
+ get_bif_test_constr(Dst, Arg, t_fun(), State);
+get_bif_constr({erlang, is_function, 2}, Dst, [Fun, Arity], _State) ->
+ ArgFun = fun(Map) ->
+ DstType = lookup_type(Dst, Map),
+ case t_is_atom(true, DstType) of
+ true ->
+ ArityType = lookup_type(Arity, Map),
+ case t_number_vals(ArityType) of
+ unknown -> t_fun();
+ Vals -> t_sup([t_fun(X, t_any()) || X <- Vals])
+ end;
+ false -> t_any()
+ end
+ end,
+ ArgV = mk_fun_var(ArgFun, [Dst, Arity]),
+ mk_conj_constraint_list([mk_constraint(Dst, sub, t_boolean()),
+ mk_constraint(Arity, sub, t_integer()),
+ mk_constraint(Fun, sub, ArgV)]);
+get_bif_constr({erlang, is_integer, 1}, Dst, [Arg], State) ->
+ get_bif_test_constr(Dst, Arg, t_integer(), State);
+get_bif_constr({erlang, is_list, 1}, Dst, [Arg], State) ->
+ get_bif_test_constr(Dst, Arg, t_maybe_improper_list(), State);
+get_bif_constr({erlang, is_number, 1}, Dst, [Arg], State) ->
+ get_bif_test_constr(Dst, Arg, t_number(), State);
+get_bif_constr({erlang, is_pid, 1}, Dst, [Arg], State) ->
+ get_bif_test_constr(Dst, Arg, t_pid(), State);
+get_bif_constr({erlang, is_port, 1}, Dst, [Arg], State) ->
+ get_bif_test_constr(Dst, Arg, t_port(), State);
+get_bif_constr({erlang, is_reference, 1}, Dst, [Arg], State) ->
+ get_bif_test_constr(Dst, Arg, t_reference(), State);
+get_bif_constr({erlang, is_record, 2}, Dst, [Var, Tag] = Args, _State) ->
+ ArgFun = fun(Map) ->
+ case t_is_atom(true, lookup_type(Dst, Map)) of
+ true -> t_tuple();
+ false -> t_any()
+ end
+ end,
+ ArgV = mk_fun_var(ArgFun, [Dst]),
+ DstFun = fun(Map) ->
+ TmpArgTypes = lookup_type_list(Args, Map),
+ erl_bif_types:type(erlang, is_record, 2, TmpArgTypes)
+ end,
+ DstV = mk_fun_var(DstFun, Args),
+ mk_conj_constraint_list([mk_constraint(Dst, sub, DstV),
+ mk_constraint(Tag, sub, t_atom()),
+ mk_constraint(Var, sub, ArgV)]);
+get_bif_constr({erlang, is_record, 3}, Dst, [Var, Tag, Arity] = Args, State) ->
+ %% TODO: Revise this to make it precise for Tag and Arity.
+ ArgFun =
+ fun(Map) ->
+ case t_is_atom(true, lookup_type(Dst, Map)) of
+ true ->
+ ArityType = lookup_type(Arity, Map),
+ case t_is_integer(ArityType) of
+ true ->
+ case t_number_vals(ArityType) of
+ [ArityVal] ->
+ TagType = lookup_type(Tag, Map),
+ case t_is_atom(TagType) of
+ true ->
+ AnyElems = lists:duplicate(ArityVal-1, t_any()),
+ GenRecord = t_tuple([TagType|AnyElems]),
+ case t_atom_vals(TagType) of
+ [TagVal] ->
+ case state__lookup_record(State, TagVal,
+ ArityVal - 1) of
+ {ok, Type} ->
+ AllOpaques = State#state.opaques,
+ case t_opaque_match_record(Type, AllOpaques) of
+ [Opaque] -> Opaque;
+ _ -> Type
+ end;
+ error -> GenRecord
+ end;
+ _ -> GenRecord
+ end;
+ false -> t_tuple(ArityVal)
+ end;
+ _ -> t_tuple()
+ end;
+ false -> t_tuple()
+ end;
+ false -> t_any()
+ end
+ end,
+ ArgV = mk_fun_var(ArgFun, [Tag, Arity, Dst]),
+ DstFun = fun(Map) ->
+ [TmpVar, TmpTag, TmpArity] = TmpArgTypes = lookup_type_list(Args, Map),
+ TmpArgTypes2 =
+ case lists:member(TmpVar, State#state.opaques) of
+ true ->
+ case t_is_integer(TmpArity) of
+ true ->
+ case t_number_vals(TmpArity) of
+ [TmpArityVal] ->
+ case t_is_atom(TmpTag) of
+ true ->
+ case t_atom_vals(TmpTag) of
+ [TmpTagVal] ->
+ case state__lookup_record(State, TmpTagVal, TmpArityVal - 1) of
+ {ok, TmpType} ->
+ case t_is_none(t_inf(TmpType, TmpVar, opaque)) of
+ true -> TmpArgTypes;
+ false -> [TmpType, TmpTag, TmpArity]
+ end;
+ error -> TmpArgTypes
+ end;
+ _ -> TmpArgTypes
+ end;
+ false -> TmpArgTypes
+ end;
+ _ -> TmpArgTypes
+ end;
+ false -> TmpArgTypes
+ end;
+ false -> TmpArgTypes
+ end,
+ erl_bif_types:type(erlang, is_record, 3, TmpArgTypes2)
+ end,
+ DstV = mk_fun_var(DstFun, Args),
+ mk_conj_constraint_list([mk_constraint(Dst, sub, DstV),
+ mk_constraint(Arity, sub, t_integer()),
+ mk_constraint(Tag, sub, t_atom()),
+ mk_constraint(Var, sub, ArgV)]);
+get_bif_constr({erlang, is_tuple, 1}, Dst, [Arg], State) ->
+ get_bif_test_constr(Dst, Arg, t_tuple(), State);
+get_bif_constr({erlang, 'and', 2}, Dst, [Arg1, Arg2] = Args, _State) ->
+ True = t_from_term(true),
+ False = t_from_term(false),
+ ArgFun = fun(Var) ->
+ fun(Map) ->
+ DstType = lookup_type(Dst, Map),
+ case t_is_atom(true, DstType) of
+ true -> True;
+ false ->
+ case t_is_atom(false, DstType) of
+ true ->
+ case t_is_atom(true, lookup_type(Var, Map)) of
+ true -> False;
+ false -> t_boolean()
+ end;
+ false ->
+ t_boolean()
+ end
+ end
+ end
+ end,
+ DstFun = fun(Map) ->
+ Arg1Type = lookup_type(Arg1, Map),
+ case t_is_atom(false, Arg1Type) of
+ true -> False;
+ false ->
+ Arg2Type = lookup_type(Arg2, Map),
+ case t_is_atom(false, Arg2Type) of
+ true -> False;
+ false ->
+ case (t_is_atom(true, Arg1Type)
+ andalso t_is_atom(true, Arg2Type)) of
+ true -> True;
+ false -> t_boolean()
+ end
+ end
+ end
+ end,
+ ArgV1 = mk_fun_var(ArgFun(Arg2), [Arg2, Dst]),
+ ArgV2 = mk_fun_var(ArgFun(Arg1), [Arg1, Dst]),
+ DstV = mk_fun_var(DstFun, Args),
+ mk_conj_constraint_list([mk_constraint(Dst, sub, DstV),
+ mk_constraint(Arg1, sub, ArgV1),
+ mk_constraint(Arg2, sub, ArgV2)]);
+get_bif_constr({erlang, 'or', 2}, Dst, [Arg1, Arg2] = Args, _State) ->
+ True = t_from_term(true),
+ False = t_from_term(false),
+ ArgFun = fun(Var) ->
+ fun(Map) ->
+ DstType = lookup_type(Dst, Map),
+ case t_is_atom(false, DstType) of
+ true -> False;
+ false ->
+ case t_is_atom(true, DstType) of
+ true ->
+ case t_is_atom(false, lookup_type(Var, Map)) of
+ true -> True;
+ false -> t_boolean()
+ end;
+ false ->
+ t_boolean()
+ end
+ end
+ end
+ end,
+ DstFun = fun(Map) ->
+ Arg1Type = lookup_type(Arg1, Map),
+ case t_is_atom(true, Arg1Type) of
+ true -> True;
+ false ->
+ Arg2Type = lookup_type(Arg2, Map),
+ case t_is_atom(true, Arg2Type) of
+ true -> True;
+ false ->
+ case (t_is_atom(false, Arg1Type)
+ andalso t_is_atom(false, Arg2Type)) of
+ true -> False;
+ false -> t_boolean()
+ end
+ end
+ end
+ end,
+ ArgV1 = mk_fun_var(ArgFun(Arg2), [Arg2, Dst]),
+ ArgV2 = mk_fun_var(ArgFun(Arg1), [Arg1, Dst]),
+ DstV = mk_fun_var(DstFun, Args),
+ Disj = mk_disj_constraint_list([mk_constraint(Arg1, sub, True),
+ mk_constraint(Arg2, sub, True),
+ mk_constraint(Dst, sub, False)]),
+ mk_conj_constraint_list([mk_constraint(Dst, sub, DstV),
+ mk_constraint(Arg1, sub, ArgV1),
+ mk_constraint(Arg2, sub, ArgV2),
+ Disj]);
+get_bif_constr({erlang, 'not', 1}, Dst, [Arg] = Args, _State) ->
+ True = t_from_term(true),
+ False = t_from_term(false),
+ Fun = fun(Var) ->
+ fun(Map) ->
+ Type = lookup_type(Var, Map),
+ case t_is_atom(true, Type) of
+ true -> False;
+ false ->
+ case t_is_atom(false, Type) of
+ true -> True;
+ false -> t_boolean()
+ end
+ end
+ end
+ end,
+ ArgV = mk_fun_var(Fun(Dst), [Dst]),
+ DstV = mk_fun_var(Fun(Arg), Args),
+ mk_conj_constraint_list([mk_constraint(Arg, sub, ArgV),
+ mk_constraint(Dst, sub, DstV)]);
+get_bif_constr({erlang, '=:=', 2}, Dst, [Arg1, Arg2] = Args, _State) ->
+ ArgFun =
+ fun(Self, OtherVar) ->
+ fun(Map) ->
+ DstType = lookup_type(Dst, Map),
+ OtherVarType = lookup_type(OtherVar, Map),
+ case t_is_atom(true, DstType) of
+ true -> OtherVarType;
+ false ->
+ case t_is_atom(false, DstType) of
+ true ->
+ case is_singleton_type(OtherVarType) of
+ true -> t_subtract(lookup_type(Self, Map), OtherVarType);
+ false -> t_any()
+ end;
+ false ->
+ t_any()
+ end
+ end
+ end
+ end,
+ DstFun = fun(Map) ->
+ ArgType1 = lookup_type(Arg1, Map),
+ ArgType2 = lookup_type(Arg2, Map),
+ case t_is_none(t_inf(ArgType1, ArgType2)) of
+ true -> t_from_term(false);
+ false -> t_boolean()
+ end
+ end,
+ DstArgs = [Dst, Arg1, Arg2],
+ ArgV1 = mk_fun_var(ArgFun(Arg1, Arg2), DstArgs),
+ ArgV2 = mk_fun_var(ArgFun(Arg2, Arg1), DstArgs),
+ DstV = mk_fun_var(DstFun, Args),
+ mk_conj_constraint_list([mk_constraint(Dst, sub, DstV),
+ mk_constraint(Arg1, sub, ArgV1),
+ mk_constraint(Arg2, sub, ArgV2)]);
+get_bif_constr({erlang, '==', 2}, Dst, [Arg1, Arg2] = Args, _State) ->
+ DstFun = fun(Map) ->
+ TmpArgTypes = lookup_type_list(Args, Map),
+ erl_bif_types:type(erlang, '==', 2, TmpArgTypes)
+ end,
+ ArgFun =
+ fun(Var, Self) ->
+ fun(Map) ->
+ VarType = lookup_type(Var, Map),
+ DstType = lookup_type(Dst, Map),
+ case is_singleton_non_number_type(VarType) of
+ true ->
+ case t_is_atom(true, DstType) of
+ true -> VarType;
+ false ->
+ case t_is_atom(false, DstType) of
+ true -> t_subtract(lookup_type(Self, Map), VarType);
+ false -> t_any()
+ end
+ end;
+ false ->
+ case t_is_atom(true, DstType) of
+ true ->
+ case t_is_number(VarType) of
+ true -> t_number();
+ false ->
+ case t_is_atom(VarType) of
+ true -> VarType;
+ false -> t_any()
+ end
+ end;
+ false ->
+ t_any()
+ end
+ end
+ end
+ end,
+ DstV = mk_fun_var(DstFun, Args),
+ ArgL = [Arg1, Arg2, Dst],
+ ArgV1 = mk_fun_var(ArgFun(Arg2, Arg1), ArgL),
+ ArgV2 = mk_fun_var(ArgFun(Arg1, Arg2), ArgL),
+ mk_conj_constraint_list([mk_constraint(Dst, sub, DstV),
+ mk_constraint(Arg1, sub, ArgV1),
+ mk_constraint(Arg2, sub, ArgV2)]);
+get_bif_constr({erlang, element, 2} = _BIF, Dst, Args, State) ->
+ GenType = erl_bif_types:type(erlang, element, 2),
+ case t_is_none(GenType) of
+ true -> ?debug("Bif: ~w failed\n", [_BIF]), throw(error);
+ false ->
+ Fun = fun(Map) ->
+ [I, T] = ATs = lookup_type_list(Args, Map),
+ ATs2 = case lists:member(T, State#state.opaques) of
+ true -> [I, erl_types:t_opaque_structure(T)];
+ false -> ATs
+ end,
+ erl_bif_types:type(erlang, element, 2, ATs2)
+ end,
+ ReturnType = mk_fun_var(Fun, Args),
+ ArgTypes = erl_bif_types:arg_types(erlang, element, 2),
+ Cs = mk_constraints(Args, sub, ArgTypes),
+ mk_conj_constraint_list([mk_constraint(Dst, sub, ReturnType)|Cs])
+ end;
+get_bif_constr({M, F, A} = _BIF, Dst, Args, _State) ->
+ GenType = erl_bif_types:type(M, F, A),
+ case t_is_none(GenType) of
+ true -> ?debug("Bif: ~w failed\n", [_BIF]), throw(error);
+ false ->
+ ReturnType = mk_fun_var(fun(Map) ->
+ TmpArgTypes = lookup_type_list(Args, Map),
+ erl_bif_types:type(M, F, A, TmpArgTypes)
+ end, Args),
+ case erl_bif_types:is_known(M, F, A) of
+ false ->
+ case t_is_any(GenType) of
+ true ->
+ none;
+ false ->
+ mk_constraint(Dst, sub, ReturnType)
+ end;
+ true ->
+ ArgTypes = erl_bif_types:arg_types(M, F, A),
+ Cs = mk_constraints(Args, sub, ArgTypes),
+ mk_conj_constraint_list([mk_constraint(Dst, sub, ReturnType)|Cs])
+ end
+ end.
+
+eval_inv_arith('+', _Pos, Dst, Arg) ->
+ erl_bif_types:type(erlang, '-', 2, [Dst, Arg]);
+eval_inv_arith('*', _Pos, Dst, Arg) ->
+ case t_number_vals(Arg) of
+ [0] -> t_integer();
+ _ ->
+ TmpRet = erl_bif_types:type(erlang, 'div', 2, [Dst, Arg]),
+ Zero = t_from_term(0),
+ %% If 0 is not part of the result, it cannot be part of the argument.
+ case t_is_subtype(Zero, Dst) of
+ false -> t_subtract(TmpRet, Zero);
+ true -> TmpRet
+ end
+ end;
+eval_inv_arith('-', 1, Dst, Arg) ->
+ erl_bif_types:type(erlang, '-', 2, [Arg, Dst]);
+eval_inv_arith('-', 2, Dst, Arg) ->
+ erl_bif_types:type(erlang, '+', 2, [Arg, Dst]).
+
+range_inc(neg_inf) -> neg_inf;
+range_inc(pos_inf) -> pos_inf;
+range_inc(Int) when is_integer(Int) -> Int + 1.
+
+range_dec(neg_inf) -> neg_inf;
+range_dec(pos_inf) -> pos_inf;
+range_dec(Int) when is_integer(Int) -> Int - 1.
+
+get_bif_test_constr(Dst, Arg, Type, State) ->
+ ArgFun = fun(Map) ->
+ DstType = lookup_type(Dst, Map),
+ case t_is_atom(true, DstType) of
+ true -> Type;
+ false -> t_any()
+ end
+ end,
+ ArgV = mk_fun_var(ArgFun, [Dst]),
+ DstFun = fun(Map) ->
+ ArgType = lookup_type(Arg, Map),
+ case t_is_none(t_inf(ArgType, Type)) of
+ true ->
+ case lists:member(ArgType, State#state.opaques) of
+ true ->
+ OpaqueStruct = erl_types:t_opaque_structure(ArgType),
+ case t_is_none(t_inf(OpaqueStruct, Type)) of
+ true -> t_from_term(false);
+ false ->
+ case t_is_subtype(ArgType, Type) of
+ true -> t_from_term(true);
+ false -> t_boolean()
+ end
+ end;
+ false -> t_from_term(false)
+ end;
+ false ->
+ case t_is_subtype(ArgType, Type) of
+ true -> t_from_term(true);
+ false -> t_boolean()
+ end
+ end
+ end,
+ DstV = mk_fun_var(DstFun, [Arg]),
+ mk_conj_constraint_list([mk_constraint(Dst, sub, DstV),
+ mk_constraint(Arg, sub, ArgV)]).
+
+%%=============================================================================
+%%
+%% Constraint solver.
+%%
+%%=============================================================================
+
+solve([Fun], State) ->
+ ?debug("============ Analyzing Fun: ~w ===========\n",
+ [debug_lookup_name(Fun)]),
+ solve_fun(Fun, dict:new(), State);
+solve([_|_] = SCC, State) ->
+ ?debug("============ Analyzing SCC: ~w ===========\n",
+ [[debug_lookup_name(F) || F <- SCC]]),
+ solve_scc(SCC, dict:new(), State, false).
+
+solve_fun(Fun, FunMap, State) ->
+ Cs = state__get_cs(Fun, State),
+ Deps = get_deps(Cs),
+ Ref = mk_constraint_ref(Fun, Deps),
+ %% Note that functions are always considered to succeed.
+ {ok, _MapDict, NewMap} = solve_ref_or_list(Ref, FunMap, dict:new(), State),
+ NewType = lookup_type(Fun, NewMap),
+ NewFunMap1 = case state__get_rec_var(Fun, State) of
+ error -> FunMap;
+ {ok, Var} -> enter_type(Var, NewType, FunMap)
+ end,
+ enter_type(Fun, NewType, NewFunMap1).
+
+solve_scc(SCC, Map, State, TryingUnit) ->
+ State1 = state__mark_as_non_self_rec(SCC, State),
+ Vars0 = [{Fun, state__get_rec_var(Fun, State)} || Fun <- SCC],
+ Vars = [Var || {_, {ok, Var}} <- Vars0],
+ Funs = [Fun || {Fun, {ok, _}} <- Vars0],
+ Types = unsafe_lookup_type_list(Funs, Map),
+ RecTypes = [t_limit(Type, ?TYPE_LIMIT) || Type <- Types],
+ CleanMap = lists:foldl(fun(Fun, AccFunMap) ->
+ dict:erase(t_var_name(Fun), AccFunMap)
+ end, Map, SCC),
+ Map1 = enter_type_lists(Vars, RecTypes, CleanMap),
+ ?debug("Checking SCC: ~w\n", [[debug_lookup_name(F) || F <- SCC]]),
+ SolveFun = fun(X, Y) -> scc_fold_fun(X, Y, State1) end,
+ Map2 = lists:foldl(SolveFun, Map1, SCC),
+ FunSet = ordsets:from_list([t_var_name(F) || F <- SCC]),
+ case maps_are_equal(Map2, Map, FunSet) of
+ true ->
+ ?debug("SCC ~w reached fixpoint\n", [SCC]),
+ NewTypes = unsafe_lookup_type_list(Funs, Map2),
+ case lists:all(fun(T) -> t_is_none(t_fun_range(T)) end, NewTypes)
+ andalso TryingUnit =:= false of
+ true ->
+ UnitTypes = [t_fun(state__fun_arity(F, State), t_unit())
+ || F <- Funs],
+ Map3 = enter_type_lists(Funs, UnitTypes, Map2),
+ solve_scc(SCC, Map3, State, true);
+ false ->
+ Map2
+ end;
+ false ->
+ ?debug("SCC ~w did not reach fixpoint\n", [SCC]),
+ solve_scc(SCC, Map2, State, TryingUnit)
+ end.
+
+scc_fold_fun(F, FunMap, State) ->
+ Deps = get_deps(state__get_cs(F, State)),
+ Cs = mk_constraint_ref(F, Deps),
+ %% Note that functions are always considered to succeed.
+ {ok, _NewMapDict, Map} = solve_ref_or_list(Cs, FunMap, dict:new(), State),
+ NewType0 = unsafe_lookup_type(F, Map),
+ NewType = t_limit(NewType0, ?TYPE_LIMIT),
+ NewFunMap = case state__get_rec_var(F, State) of
+ {ok, R} ->
+ enter_type(R, NewType, enter_type(F, NewType, FunMap));
+ error ->
+ enter_type(F, NewType, FunMap)
+ end,
+ ?debug("Done solving for function ~w :: ~s\n", [debug_lookup_name(F),
+ format_type(NewType)]),
+ NewFunMap.
+
+solve_ref_or_list(#constraint_ref{id = Id, deps = Deps},
+ Map, MapDict, State) ->
+ {OldLocalMap, Check} =
+ case dict:find(Id, MapDict) of
+ error -> {dict:new(), false};
+ {ok, M} -> {M, true}
+ end,
+ ?debug("Checking ref to fun: ~w\n", [debug_lookup_name(Id)]),
+ CheckDeps = ordsets:del_element(t_var_name(Id), Deps),
+ case Check andalso maps_are_equal(OldLocalMap, Map, CheckDeps) of
+ true ->
+ ?debug("Equal\n", []),
+ {ok, MapDict, Map};
+ false ->
+ ?debug("Not equal. Solving\n", []),
+ Cs = state__get_cs(Id, State),
+ Res =
+ case state__is_self_rec(Id, State) of
+ true -> solve_self_recursive(Cs, Map, MapDict, Id, t_none(), State);
+ false -> solve_ref_or_list(Cs, Map, MapDict, State)
+ end,
+ case Res of
+ {error, NewMapDict} ->
+ ?debug("Error solving for function ~p\n", [debug_lookup_name(Id)]),
+ Arity = state__fun_arity(Id, State),
+ FunType =
+ case state__prop_domain(t_var_name(Id), State) of
+ error -> t_fun(Arity, t_none());
+ {ok, Dom} -> t_fun(Dom, t_none())
+ end,
+ NewMap1 = enter_type(Id, FunType, Map),
+ NewMap2 =
+ case state__get_rec_var(Id, State) of
+ {ok, Var} -> enter_type(Var, FunType, NewMap1);
+ error -> NewMap1
+ end,
+ {ok, dict:store(Id, NewMap2, NewMapDict), NewMap2};
+ {ok, NewMapDict, NewMap} ->
+ ?debug("Done solving fun: ~p\n", [debug_lookup_name(Id)]),
+ FunType = lookup_type(Id, NewMap),
+ NewMap1 = enter_type(Id, FunType, Map),
+ NewMap2 =
+ case state__get_rec_var(Id, State) of
+ {ok, Var} -> enter_type(Var, FunType, NewMap1);
+ error -> NewMap1
+ end,
+ {ok, dict:store(Id, NewMap2, NewMapDict), NewMap2}
+ end
+ end;
+solve_ref_or_list(#constraint_list{type=Type, list = Cs, deps = Deps, id = Id},
+ Map, MapDict, State) ->
+ {OldLocalMap, Check} =
+ case dict:find(Id, MapDict) of
+ error -> {dict:new(), false};
+ {ok, M} -> {M, true}
+ end,
+ ?debug("Checking ref to list: ~w\n", [Id]),
+ case Check andalso maps_are_equal(OldLocalMap, Map, Deps) of
+ true ->
+ ?debug("~w equal ~w\n", [Type, Id]),
+ {ok, MapDict, Map};
+ false ->
+ ?debug("~w not equal: ~w. Solving\n", [Type, Id]),
+ solve_clist(Cs, Type, Id, Deps, MapDict, Map, State)
+ end.
+
+solve_self_recursive(Cs, Map, MapDict, Id, RecType0, State) ->
+ ?debug("Solving self recursive ~w\n", [debug_lookup_name(Id)]),
+ {ok, RecVar} = state__get_rec_var(Id, State),
+ ?debug("OldRecType ~s\n", [format_type(RecType0)]),
+ RecType = t_limit(RecType0, ?TYPE_LIMIT),
+ Map1 = enter_type(RecVar, RecType, dict:erase(t_var_name(Id), Map)),
+ ?debug("\tMap in: ~p\n",[[{X, format_type(Y)}||{X, Y}<-dict:to_list(Map1)]]),
+ case solve_ref_or_list(Cs, Map1, MapDict, State) of
+ {error, _} = Error ->
+ case t_is_none(RecType0) of
+ true ->
+ %% Try again and assume that this is a non-terminating function.
+ Arity = state__fun_arity(Id, State),
+ NewRecType = t_fun(lists:duplicate(Arity, t_any()), t_unit()),
+ solve_self_recursive(Cs, Map, MapDict, Id, NewRecType, State);
+ false ->
+ Error
+ end;
+ {ok, NewMapDict, NewMap} ->
+ ?debug("\tMap: ~p\n",
+ [[{X, format_type(Y)} || {X, Y} <- dict:to_list(NewMap)]]),
+ NewRecType = unsafe_lookup_type(Id, NewMap),
+ case t_is_equal(NewRecType, RecType0) of
+ true ->
+ {ok, NewMapDict, enter_type(RecVar, NewRecType, NewMap)};
+ false ->
+ solve_self_recursive(Cs, Map, MapDict, Id, NewRecType, State)
+ end
+ end.
+
+solve_clist(Cs, conj, Id, Deps, MapDict, Map, State) ->
+ case solve_cs(Cs, Map, MapDict, State) of
+ {error, _} = Error -> Error;
+ {ok, NewMapDict, NewMap} = Ret ->
+ case Cs of
+ [_] ->
+ %% Just a special case for one conjunctive constraint.
+ Ret;
+ _ ->
+ case maps_are_equal(Map, NewMap, Deps) of
+ true -> {ok, dict:store(Id, NewMap, NewMapDict), NewMap};
+ false -> solve_clist(Cs, conj, Id, Deps, NewMapDict, NewMap, State)
+ end
+ end
+ end;
+solve_clist(Cs, disj, Id, _Deps, MapDict, Map, State) ->
+ Fun = fun(C, Dict) ->
+ case solve_ref_or_list(C, Map, Dict, State) of
+ {ok, NewDict, NewMap} -> {{ok, NewMap}, NewDict};
+ {error, _NewDict} = Error -> Error
+ end
+ end,
+ {Maps, NewMapDict} = lists:mapfoldl(Fun, MapDict, Cs),
+ case [X || {ok, X} <- Maps] of
+ [] -> {error, NewMapDict};
+ MapList ->
+ NewMap = join_maps(MapList),
+ {ok, dict:store(Id, NewMap, NewMapDict), NewMap}
+ end.
+
+solve_cs([#constraint_ref{} = C|Tail], Map, MapDict, State) ->
+ case solve_ref_or_list(C, Map, MapDict, State) of
+ {ok, NewMapDict, Map1} -> solve_cs(Tail, Map1, NewMapDict, State);
+ {error, _NewMapDict} = Error -> Error
+ end;
+solve_cs([#constraint_list{} = C|Tail], Map, MapDict, State) ->
+ case solve_ref_or_list(C, Map, MapDict, State) of
+ {ok, NewMapDict, Map1} -> solve_cs(Tail, Map1, NewMapDict, State);
+ {error, _NewMapDict} = Error -> Error
+ end;
+solve_cs([#constraint{} = C|Tail], Map, MapDict, State) ->
+ case solve_one_c(C, Map) of
+ error ->
+ ?debug("+++++++++++\nFailed: ~s :: ~s ~w ~s :: ~s\n+++++++++++\n",
+ [format_type(C#constraint.lhs),
+ format_type(lookup_type(C#constraint.lhs, Map)),
+ C#constraint.op,
+ format_type(C#constraint.rhs),
+ format_type(lookup_type(C#constraint.rhs, Map))]),
+ {error, MapDict};
+ {ok, NewMap} ->
+ solve_cs(Tail, NewMap, MapDict, State)
+ end;
+solve_cs([], Map, MapDict, _State) ->
+ {ok, MapDict, Map}.
+
+solve_one_c(#constraint{lhs = Lhs, rhs = Rhs, op = Op}, Map) ->
+ LhsType = lookup_type(Lhs, Map),
+ RhsType = lookup_type(Rhs, Map),
+ Inf = t_inf(LhsType, RhsType, opaque),
+ ?debug("Solving: ~s :: ~s ~w ~s :: ~s\n\tInf: ~s\n",
+ [format_type(Lhs), format_type(LhsType), Op,
+ format_type(Rhs), format_type(RhsType), format_type(Inf)]),
+ case t_is_none(Inf) of
+ true -> error;
+ false ->
+ case Op of
+ sub -> solve_subtype(Lhs, Inf, Map);
+ eq ->
+ case solve_subtype(Lhs, Inf, Map) of
+ error -> error;
+ {ok, Map1} -> solve_subtype(Rhs, Inf, Map1)
+ end
+ end
+ end.
+
+solve_subtype(Type, Inf, Map) ->
+ %% case cerl:is_literal(Type) of
+ %% true ->
+ %% case t_is_subtype(t_from_term(cerl:concrete(Type)), Inf) of
+ %% true -> {ok, Map};
+ %% false -> error
+ %% end;
+ %% false ->
+ try t_unify(Type, Inf) of
+ {_, List} -> {ok, enter_type_list(List, Map)}
+ catch
+ throw:{mismatch, _T1, _T2} ->
+ ?debug("Mismatch between ~s and ~s\n",
+ [format_type(_T1), format_type(_T2)]),
+ error
+ end.
+ %% end.
+
+%% ============================================================================
+%%
+%% Maps and types.
+%%
+%% ============================================================================
+
+join_maps(Maps) ->
+ Keys = lists:foldl(fun(TmpMap, AccKeys) ->
+ [Key || Key <- AccKeys, dict:is_key(Key, TmpMap)]
+ end,
+ dict:fetch_keys(hd(Maps)), tl(Maps)),
+ join_maps(Keys, Maps, dict:new()).
+
+join_maps([Key|Left], Maps = [Map|MapsLeft], AccMap) ->
+ NewType = join_one_key(Key, MapsLeft, lookup_type(Key, Map)),
+ NewAccMap = enter_type(Key, NewType, AccMap),
+ join_maps(Left, Maps, NewAccMap);
+join_maps([], _Maps, AccMap) ->
+ AccMap.
+
+join_one_key(Key, [Map|Maps], Type) ->
+ case t_is_any(Type) of
+ true -> Type;
+ false ->
+ NewType = lookup_type(Key, Map),
+ case t_is_equal(NewType, Type) of
+ true -> join_one_key(Key, Maps, Type);
+ false -> join_one_key(Key, Maps, t_sup(NewType, Type))
+ end
+ end;
+join_one_key(_Key, [], Type) ->
+ Type.
+
+maps_are_equal(Map1, Map2, Deps) ->
+ NewDeps = prune_keys(Map1, Map2, Deps),
+ maps_are_equal_1(Map1, Map2, NewDeps).
+
+maps_are_equal_1(Map1, Map2, [H|Tail]) ->
+ T1 = lookup_type(H, Map1),
+ T2 = lookup_type(H, Map2),
+ case t_is_equal(T1, T2) of
+ true -> maps_are_equal_1(Map1, Map2, Tail);
+ false ->
+ ?debug("~w: ~s =/= ~s\n", [H, format_type(T1), format_type(T2)]),
+ false
+ end;
+maps_are_equal_1(_Map1, _Map2, []) ->
+ true.
+
+-define(PRUNE_LIMIT, 100).
+
+prune_keys(Map1, Map2, Deps) ->
+ %% This is only worthwhile if the number of deps is reasonably large,
+ %% and also bigger than the number of elements in the maps.
+ NofDeps = length(Deps),
+ case NofDeps > ?PRUNE_LIMIT of
+ true ->
+ Keys1 = dict:fetch_keys(Map1),
+ case length(Keys1) > NofDeps of
+ true ->
+ Set1 = lists:sort(Keys1),
+ Set2 = lists:sort(dict:fetch_keys(Map2)),
+ ordsets:intersection(ordsets:union(Set1, Set2), Deps);
+ false ->
+ Deps
+ end;
+ false ->
+ Deps
+ end.
+
+enter_type(Key, Val, Map) when is_integer(Key) ->
+ ?debug("Entering ~s :: ~s\n", [format_type(t_var(Key)), format_type(Val)]),
+ case t_is_any(Val) of
+ true ->
+ dict:erase(Key, Map);
+ false ->
+ LimitedVal = t_limit(Val, ?INTERNAL_TYPE_LIMIT),
+ case dict:find(Key, Map) of
+ {ok, LimitedVal} -> Map;
+ {ok, _} -> dict:store(Key, LimitedVal, Map);
+ error -> dict:store(Key, LimitedVal, Map)
+ end
+ end;
+enter_type(Key, Val, Map) ->
+ ?debug("Entering ~s :: ~s\n", [format_type(Key), format_type(Val)]),
+ KeyName = t_var_name(Key),
+ case t_is_any(Val) of
+ true ->
+ dict:erase(KeyName, Map);
+ false ->
+ LimitedVal = t_limit(Val, ?INTERNAL_TYPE_LIMIT),
+ case dict:find(KeyName, Map) of
+ {ok, LimitedVal} -> Map;
+ {ok, _} -> dict:store(KeyName, LimitedVal, Map);
+ error -> dict:store(KeyName, LimitedVal, Map)
+ end
+ end.
+
+enter_type_lists([Key|KeyTail], [Val|ValTail], Map) ->
+ Map1 = enter_type(Key, Val, Map),
+ enter_type_lists(KeyTail, ValTail, Map1);
+enter_type_lists([], [], Map) ->
+ Map.
+
+enter_type_list([{Key, Val}|Tail], Map) ->
+ Map1 = enter_type(Key, Val, Map),
+ enter_type_list(Tail, Map1);
+enter_type_list([], Map) ->
+ Map.
+
+lookup_type_list(List, Map) ->
+ [lookup_type(X, Map) || X <- List].
+
+unsafe_lookup_type(Key, Map) ->
+ case dict:find(t_var_name(Key), Map) of
+ {ok, Type} -> Type;
+ error -> t_none()
+ end.
+
+unsafe_lookup_type_list(List, Map) ->
+ [unsafe_lookup_type(X, Map) || X <- List].
+
+lookup_type(Key, Map) when is_integer(Key) ->
+ case dict:find(Key, Map) of
+ error -> t_any();
+ {ok, Val} -> Val
+ end;
+lookup_type(#fun_var{'fun' = Fun}, Map) ->
+ Fun(Map);
+lookup_type(Key, Map) ->
+ %% Seems unused and dialyzer complains about it -- commented out.
+ %% case cerl:is_literal(Key) of
+ %% true -> t_from_term(cerl:concrete(Key));
+ %% false ->
+ Subst = t_subst(Key, Map),
+ t_sup(Subst, Subst).
+ %% end.
+
+mk_var(Var) ->
+ case cerl:is_literal(Var) of
+ true -> Var;
+ false ->
+ case cerl:is_c_values(Var) of
+ true -> t_product(mk_var_no_lit_list(cerl:values_es(Var)));
+ false -> t_var(cerl_trees:get_label(Var))
+ end
+ end.
+
+mk_var_list(List) ->
+ [mk_var(X) || X <- List].
+
+mk_var_no_lit(Var) ->
+ case cerl:is_literal(Var) of
+ true -> t_from_term(cerl:concrete(Var));
+ false -> mk_var(Var)
+ end.
+
+mk_var_no_lit_list(List) ->
+ [mk_var_no_lit(X) || X <- List].
+
+%% ============================================================================
+%%
+%% The State.
+%%
+%% ============================================================================
+
+new_state(SCC0, NextLabel, CallGraph, Plt, PropTypes) ->
+ NameMap = dict:from_list([{MFA, Var} || {MFA, {Var, _Fun}, _Rec} <- SCC0]),
+ SCC = [mk_var(Fun) || {_MFA, {_Var, Fun}, _Rec} <- SCC0],
+ #state{callgraph = CallGraph, name_map = NameMap, next_label = NextLabel,
+ prop_types = PropTypes, plt = Plt, scc = SCC}.
+
+state__set_rec_dict(State, RecDict) ->
+ State#state{records = RecDict}.
+
+state__set_opaques(#state{records = RecDict} = State, {M, _F, _A}) ->
+ Opaques =
+ erl_types:module_builtin_opaques(M) ++ t_opaque_from_records(RecDict),
+ State#state{opaques = Opaques}.
+
+state__lookup_record(#state{records = Records}, Tag, Arity) ->
+ case erl_types:lookup_record(Tag, Arity, Records) of
+ {ok, Fields} ->
+ {ok, t_tuple([t_from_term(Tag)|
+ [FieldType || {_FieldName, FieldType} <- Fields]])};
+ error ->
+ error
+ end.
+
+state__set_in_match(State, Bool) ->
+ State#state{in_match = Bool}.
+
+state__is_in_match(#state{in_match = Bool}) ->
+ Bool.
+
+state__set_in_guard(State, Bool) ->
+ State#state{in_guard = Bool}.
+
+state__is_in_guard(#state{in_guard = Bool}) ->
+ Bool.
+
+state__get_fun_prototype(Op, Arity, State) ->
+ case t_is_fun(Op) of
+ true -> {State, Op};
+ false ->
+ {State1, [Ret|Args]} = state__mk_vars(Arity+1, State),
+ Fun = t_fun(Args, Ret),
+ {State1, Fun}
+ end.
+
+state__lookup_rec_var_in_scope(MFA, #state{name_map = NameMap}) ->
+ dict:find(MFA, NameMap).
+
+state__store_fun_arity(Tree, #state{fun_arities = Map} = State) ->
+ Arity = length(cerl:fun_vars(Tree)),
+ Id = mk_var(Tree),
+ State#state{fun_arities = dict:store(Id, Arity, Map)}.
+
+state__fun_arity(Id, #state{fun_arities = Map}) ->
+ dict:fetch(Id, Map).
+
+state__lookup_undef_var(Tree, #state{callgraph = CG, plt = Plt}) ->
+ Label = cerl_trees:get_label(Tree),
+ case dialyzer_callgraph:lookup_rec_var(Label, CG) of
+ error -> error;
+ {ok, MFA} ->
+ case dialyzer_plt:lookup(Plt, MFA) of
+ none -> error;
+ {value, {RetType, ArgTypes}} -> {ok, t_fun(ArgTypes, RetType)}
+ end
+ end.
+
+state__lookup_apply(Tree, #state{callgraph = Callgraph}) ->
+ Apply = cerl_trees:get_label(Tree),
+ case dialyzer_callgraph:lookup_call_site(Apply, Callgraph) of
+ error ->
+ unknown;
+ {ok, List} ->
+ case lists:member(external, List) of
+ true -> unknown;
+ false -> List
+ end
+ end.
+
+get_apply_constr(FunLabels, Dst, ArgTypes, #state{callgraph = CG} = State) ->
+ MFAs = [dialyzer_callgraph:lookup_name(Label, CG) || Label <- FunLabels],
+ case lists:member(error, MFAs) of
+ true -> error;
+ false ->
+ Constrs = [begin
+ State1 = state__new_constraint_context(State),
+ State2 = get_plt_constr(MFA, Dst, ArgTypes, State1),
+ state__cs(State2)
+ end || {ok, MFA} <- MFAs],
+ ApplyConstr = mk_disj_constraint_list(Constrs),
+ {ok, state__store_conj(ApplyConstr, State)}
+ end.
+
+state__scc(#state{scc = SCC}) ->
+ SCC.
+
+state__plt(#state{plt = PLT}) ->
+ PLT.
+
+state__new_constraint_context(State) ->
+ State#state{cs = []}.
+
+state__prop_domain(FunLabel, #state{prop_types = PropTypes}) ->
+ case dict:find(FunLabel, PropTypes) of
+ error -> error;
+ {ok, {_Range_Fun, Dom}} -> {ok, Dom};
+ {ok, FunType} -> {ok, t_fun_args(FunType)}
+ end.
+
+state__add_prop_constrs(Tree, #state{prop_types = PropTypes} = State) ->
+ Label = cerl_trees:get_label(Tree),
+ case dict:find(Label, PropTypes) of
+ error -> State;
+ {ok, FunType} ->
+ case t_fun_args(FunType) of
+ unknown -> State;
+ ArgTypes ->
+ case erl_types:any_none(ArgTypes) of
+ true -> not_called;
+ false ->
+ ?debug("Adding propagated constr: ~s for function ~w\n",
+ [format_type(FunType), debug_lookup_name(mk_var(Tree))]),
+ FunVar = mk_var(Tree),
+ state__store_conj(FunVar, sub, FunType, State)
+ end
+ end
+ end.
+
+state__cs(#state{cs = Cs}) ->
+ mk_conj_constraint_list(Cs).
+
+state__store_conj(C, #state{cs = Cs} = State) ->
+ State#state{cs = [C|Cs]}.
+
+state__store_conj_list([H|T], State) ->
+ State1 = state__store_conj(H, State),
+ state__store_conj_list(T, State1);
+state__store_conj_list([], State) ->
+ State.
+
+state__store_conj(Lhs, Op, Rhs, #state{cs = Cs} = State) ->
+ State#state{cs = [mk_constraint(Lhs, Op, Rhs)|Cs]}.
+
+state__store_conj_lists(List1, Op, List2, State) ->
+ {NewList1, NewList2} = strip_of_any_constrs(List1, List2),
+ state__store_conj_lists_1(NewList1, Op, NewList2, State).
+
+strip_of_any_constrs(List1, List2) ->
+ strip_of_any_constrs(List1, List2, [], []).
+
+strip_of_any_constrs([T1|Left1], [T2|Left2], Acc1, Acc2) ->
+ case t_is_any(T1) orelse constraint_opnd_is_any(T2) of
+ true -> strip_of_any_constrs(Left1, Left2, Acc1, Acc2);
+ false -> strip_of_any_constrs(Left1, Left2, [T1|Acc1], [T2|Acc2])
+ end;
+strip_of_any_constrs([], [], Acc1, Acc2) ->
+ {Acc1, Acc2}.
+
+state__store_conj_lists_1([Arg1|Arg1Tail], Op, [Arg2|Arg2Tail], State) ->
+ State1 = state__store_conj(Arg1, Op, Arg2, State),
+ state__store_conj_lists_1(Arg1Tail, Op, Arg2Tail, State1);
+state__store_conj_lists_1([], _Op, [], State) ->
+ State.
+
+state__mk_var(#state{next_label = NL} = State) ->
+ {State#state{next_label = NL+1}, t_var(NL)}.
+
+state__mk_vars(N, #state{next_label = NL} = State) ->
+ NewLabel = NL + N,
+ Vars = [t_var(X) || X <- lists:seq(NL, NewLabel-1)],
+ {State#state{next_label = NewLabel}, Vars}.
+
+state__store_constrs(Id, Cs, #state{cmap = Dict} = State) ->
+ NewDict = dict:store(Id, Cs, Dict),
+ State#state{cmap = NewDict}.
+
+state__get_cs(Var, #state{cmap = Dict}) ->
+ dict:fetch(Var, Dict).
+
+%% The functions here will not be treated as self recursive.
+%% These functions will need to be handled as such manually.
+state__mark_as_non_self_rec(SCC, #state{non_self_recs = NS} = State) ->
+ State#state{non_self_recs = ordsets:union(NS, ordsets:from_list(SCC))}.
+
+state__is_self_rec(Fun, #state{callgraph = CallGraph, non_self_recs = NS}) ->
+ case ordsets:is_element(Fun, NS) of
+ true -> false;
+ false -> dialyzer_callgraph:is_self_rec(t_var_name(Fun), CallGraph)
+ end.
+
+state__store_funs(Vars0, Funs0, #state{fun_map = Map} = State) ->
+ debug_make_name_map(Vars0, Funs0),
+ Vars = mk_var_list(Vars0),
+ Funs = mk_var_list(Funs0),
+ NewMap = lists:foldl(fun({Var, Fun}, MP) -> orddict:store(Var, Fun, MP) end,
+ Map, lists:zip(Vars, Funs)),
+ State#state{fun_map = NewMap}.
+
+state__get_rec_var(Fun, #state{fun_map = Map}) ->
+ case [V || {V, FV} <- Map, FV =:= Fun] of
+ [Var] -> {ok, Var};
+ [] -> error
+ end.
+
+state__finalize(State) ->
+ State1 = enumerate_constraints(State),
+ order_fun_constraints(State1).
+
+%% ============================================================================
+%%
+%% Constraints
+%%
+%% ============================================================================
+
+-spec mk_constraint(erl_types:erl_type(), constr_op(), fvar_or_type()) -> #constraint{}.
+
+mk_constraint(Lhs, Op, Rhs) ->
+ case t_is_any(Lhs) orelse constraint_opnd_is_any(Rhs) of
+ false ->
+ Deps = find_constraint_deps([Lhs, Rhs]),
+ C0 = mk_constraint_1(Lhs, Op, Rhs),
+ C = C0#constraint{deps = Deps},
+ case Deps =:= [] of
+ true ->
+ %% This constraint is constant. Solve it immediately.
+ case solve_one_c(C, dict:new()) of
+ error -> throw(error);
+ _ ->
+ %% This is always true, keep it anyway for logistic reasons
+ C
+ end;
+ false ->
+ C
+ end;
+ true ->
+ C = mk_constraint_1(t_any(), Op, t_any()),
+ C#constraint{deps = []}
+ end.
+
+%% the following function is used so that we do not call
+%% erl_types:t_is_any/1 with a term other than an erl_type()
+-spec constraint_opnd_is_any(fvar_or_type()) -> boolean().
+
+constraint_opnd_is_any(#fun_var{}) -> false;
+constraint_opnd_is_any(Type) -> t_is_any(Type).
+
+-spec mk_fun_var(fun((_) -> erl_types:erl_type()), [erl_types:erl_type()]) -> #fun_var{}.
+
+mk_fun_var(Fun, Types) ->
+ Deps = [t_var_name(Var) || Var <- t_collect_vars(t_product(Types))],
+ #fun_var{'fun' = Fun, deps = ordsets:from_list(Deps)}.
+
+-spec get_deps(constr()) -> [dep()].
+
+get_deps(#constraint{deps = D}) -> D;
+get_deps(#constraint_list{deps = D}) -> D;
+get_deps(#constraint_ref{deps = D}) -> D.
+
+-spec find_constraint_deps([fvar_or_type()]) -> [dep()].
+
+find_constraint_deps(List) ->
+ ordsets:from_list(find_constraint_deps(List, [])).
+
+find_constraint_deps([#fun_var{deps = Deps}|Tail], Acc) ->
+ find_constraint_deps(Tail, [Deps|Acc]);
+find_constraint_deps([Type|Tail], Acc) ->
+ NewAcc = [[t_var_name(D) || D <- t_collect_vars(Type)]|Acc],
+ find_constraint_deps(Tail, NewAcc);
+find_constraint_deps([], Acc) ->
+ lists:flatten(Acc).
+
+mk_constraint_1(Lhs, eq, Rhs) when Lhs < Rhs ->
+ #constraint{lhs = Lhs, op = eq, rhs = Rhs};
+mk_constraint_1(Lhs, eq, Rhs) ->
+ #constraint{lhs = Rhs, op = eq, rhs = Lhs};
+mk_constraint_1(Lhs, Op, Rhs) ->
+ #constraint{lhs = Lhs, op = Op, rhs = Rhs}.
+
+mk_constraints([Lhs|LhsTail], Op, [Rhs|RhsTail]) ->
+ [mk_constraint(Lhs, Op, Rhs)|mk_constraints(LhsTail, Op, RhsTail)];
+mk_constraints([], _Op, []) ->
+ [].
+
+mk_constraint_ref(Id, Deps) ->
+ #constraint_ref{id = Id, deps = Deps}.
+
+mk_constraint_list(Type, List) ->
+ List1 = ordsets:from_list(lift_lists(Type, List)),
+ List2 = ordsets:filter(fun(X) -> get_deps(X) =/= [] end, List1),
+ Deps = calculate_deps(List2),
+ case Deps =:= [] of
+ true -> #constraint_list{type = conj,
+ list = [mk_constraint(t_any(), eq, t_any())],
+ deps = []};
+ false -> #constraint_list{type = Type, list = List2, deps = Deps}
+ end.
+
+lift_lists(Type, List) ->
+ lift_lists(Type, List, []).
+
+lift_lists(Type, [#constraint_list{type = Type, list = List}|Tail], Acc) ->
+ lift_lists(Type, Tail, List++Acc);
+lift_lists(Type, [C|Tail], Acc) ->
+ lift_lists(Type, Tail, [C|Acc]);
+lift_lists(_Type, [], Acc) ->
+ Acc.
+
+update_constraint_list(CL, List) ->
+ CL#constraint_list{list = List}.
+
+%% We expand guard constraints into dijunctive normal form to gain
+%% precision in simple guards. However, because of the exponential
+%% growth of this expansion in the presens of disjunctions we can even
+%% get into trouble while expanding.
+%%
+%% To limit this we only expand when the number of disjunctions are
+%% below a certain limit. This limit is currently set based on the
+%% behaviour of boolean 'or'.
+%%
+%% V1 = V2 or V3
+%%
+%% Gives us in simplified form the constraints
+%%
+%% <Some cs> * ((V1 = true) + (V2 = true) + (V1 = false))
+%%
+%% and thus a three-parted disjunction. If want to allow for two
+%% levels of disjunction we need to have 3^2 = 9 disjunctions. If we
+%% want three levels we need 3^3 = 27 disjunctions. More than that
+%% seems unnecessary and tends to blow up.
+%%
+%% Note that by not expanding we lose some precision, but we get a
+%% safe over approximation.
+
+-define(DISJ_NORM_FORM_LIMIT, 28).
+
+mk_disj_norm_form(#constraint_list{} = CL) ->
+ try
+ List1 = expand_to_conjunctions(CL),
+ mk_disj_constraint_list(List1)
+ catch
+ throw:too_many_disj -> CL
+ end.
+
+expand_to_conjunctions(#constraint_list{type = conj, list = List}) ->
+ List1 = [C || C <- List, is_simple_constraint(C)],
+ List2 = [expand_to_conjunctions(C) || #constraint_list{} = C <- List],
+ case List2 =:= [] of
+ true -> [mk_conj_constraint_list(List1)];
+ false ->
+ case List2 of
+ [JustOneList] ->
+ [mk_conj_constraint_list([L|List1]) || L <- JustOneList];
+ _ ->
+ combine_conj_lists(List2, List1)
+ end
+ end;
+expand_to_conjunctions(#constraint_list{type = disj, list = List}) ->
+ if length(List) > ?DISJ_NORM_FORM_LIMIT -> throw(too_many_disj);
+ true -> ok
+ end,
+ List1 = [C || C <- List, is_simple_constraint(C)],
+ %% Just an assert.
+ [] = [C || #constraint{} = C <- List1],
+ Expanded = lists:flatten([expand_to_conjunctions(C)
+ || #constraint_list{} = C <- List]),
+ ReturnList = Expanded ++ List1,
+ if length(ReturnList) > ?DISJ_NORM_FORM_LIMIT -> throw(too_many_disj);
+ true -> ReturnList
+ end.
+
+is_simple_constraint(#constraint{}) -> true;
+is_simple_constraint(#constraint_ref{}) -> true;
+is_simple_constraint(#constraint_list{}) -> false.
+
+combine_conj_lists([List1, List2|Left], Prefix) ->
+ NewList = [mk_conj_constraint_list([L1, L2]) || L1 <- List1, L2 <- List2],
+ if length(NewList) > ?DISJ_NORM_FORM_LIMIT -> throw(too_many_disj);
+ true -> ok
+ end,
+ combine_conj_lists([NewList|Left], Prefix);
+combine_conj_lists([List], Prefix) ->
+ [mk_conj_constraint_list([mk_conj_constraint_list(Prefix), L]) || L <- List].
+
+calculate_deps(List) ->
+ calculate_deps(List, []).
+
+calculate_deps([H|Tail], Acc) ->
+ Deps = get_deps(H),
+ calculate_deps(Tail, [Deps|Acc]);
+calculate_deps([], Acc) ->
+ ordsets:from_list(lists:flatten(Acc)).
+
+mk_conj_constraint_list(List) ->
+ mk_constraint_list(conj, List).
+
+mk_disj_constraint_list([NotReallyAList]) ->
+ NotReallyAList;
+mk_disj_constraint_list(List) ->
+ %% Make sure each element in the list is either a conjunction or a
+ %% ref. Wrap single constraints into conjunctions.
+ List1 = [wrap_simple_constr(C) || C <- List],
+ mk_constraint_list(disj, List1).
+
+wrap_simple_constr(#constraint{} = C) -> mk_conj_constraint_list([C]);
+wrap_simple_constr(#constraint_list{} = C) -> C;
+wrap_simple_constr(#constraint_ref{} = C) -> C.
+
+enumerate_constraints(State) ->
+ Cs = [mk_constraint_ref(Id, get_deps(state__get_cs(Id, State)))
+ || Id <- state__scc(State)],
+ {_, _, NewState} = enumerate_constraints(Cs, 0, [], State),
+ NewState.
+
+enumerate_constraints([#constraint_ref{id = Id} = C|Tail], N, Acc, State) ->
+ Cs = state__get_cs(Id, State),
+ {[NewCs], NewN, NewState1} = enumerate_constraints([Cs], N, [], State),
+ NewState2 = state__store_constrs(Id, NewCs, NewState1),
+ enumerate_constraints(Tail, NewN+1, [C|Acc], NewState2);
+enumerate_constraints([#constraint_list{type = conj, list = List} = C|Tail],
+ N, Acc, State) ->
+ %% Separate the flat constraints from the deep ones to make a
+ %% separate fixpoint interation over the flat ones for speed.
+ {Flat, Deep} = lists:splitwith(fun(#constraint{}) -> true;
+ (#constraint_list{}) -> false;
+ (#constraint_ref{}) -> false
+ end, List),
+ {NewFlat, N1, State1} = enumerate_constraints(Flat, N, [], State),
+ {NewDeep, N2, State2} = enumerate_constraints(Deep, N1, [], State1),
+ {NewList, N3} =
+ case shorter_than_two(NewFlat) orelse (NewDeep =:= []) of
+ true -> {NewFlat ++ NewDeep, N2};
+ false ->
+ {NewCLists, TmpN} = group_constraints_in_components(NewFlat, N2),
+ {NewCLists ++ NewDeep, TmpN}
+ end,
+ NewAcc = [C#constraint_list{list = NewList, id = {list, N3}}|Acc],
+ enumerate_constraints(Tail, N3+1, NewAcc, State2);
+enumerate_constraints([#constraint_list{list = List, type = disj} = C|Tail],
+ N, Acc, State) ->
+ {NewList, NewN, NewState} = enumerate_constraints(List, N, [], State),
+ NewAcc = [C#constraint_list{list = NewList, id = {list, NewN}}|Acc],
+ enumerate_constraints(Tail, NewN+1, NewAcc, NewState);
+enumerate_constraints([#constraint{} = C|Tail], N, Acc, State) ->
+ enumerate_constraints(Tail, N, [C|Acc], State);
+enumerate_constraints([], N, Acc, State) ->
+ {lists:reverse(Acc), N, State}.
+
+shorter_than_two([]) -> true;
+shorter_than_two([_]) -> true;
+shorter_than_two([_|_]) -> false.
+
+group_constraints_in_components(Cs, N) ->
+ DepList = [Deps || #constraint{deps = Deps} <- Cs],
+ case find_dep_components(DepList, []) of
+ [_] -> {Cs, N};
+ [_|_] = Components ->
+ ConstrComp = [[C || #constraint{deps = D} = C <- Cs,
+ ordsets:is_subset(D, Comp)]
+ || Comp <- Components],
+ lists:mapfoldl(fun(CComp, TmpN) ->
+ TmpCList = mk_conj_constraint_list(CComp),
+ {TmpCList#constraint_list{id = {list, TmpN}},
+ TmpN + 1}
+ end, N, ConstrComp)
+ end.
+
+find_dep_components([Set|Left], AccComponents) ->
+ {Component, Ungrouped} = find_dep_components(Left, Set, []),
+ case Component =:= Set of
+ true -> find_dep_components(Ungrouped, [Component|AccComponents]);
+ false -> find_dep_components([Component|Ungrouped], AccComponents)
+ end;
+find_dep_components([], AccComponents) ->
+ AccComponents.
+
+find_dep_components([Set|Left], AccSet, Ungrouped) ->
+ case ordsets:intersection(Set, AccSet) of
+ [] -> find_dep_components(Left, AccSet, [Set|Ungrouped]);
+ [_|_] -> find_dep_components(Left, ordsets:union(Set, AccSet), Ungrouped)
+ end;
+find_dep_components([], AccSet, Ungrouped) ->
+ {AccSet, Ungrouped}.
+
+%% Put the fun ref constraints last in any conjunction since we need
+%% to separate the environment from the interior of the function.
+order_fun_constraints(State) ->
+ Cs = [mk_constraint_ref(Id, get_deps(state__get_cs(Id, State)))
+ || Id <- state__scc(State)],
+ order_fun_constraints(Cs, State).
+
+order_fun_constraints([#constraint_ref{id = Id}|Tail], State) ->
+ Cs = state__get_cs(Id, State),
+ {[NewCs], State1} = order_fun_constraints([Cs], [], [], State),
+ NewState = state__store_constrs(Id, NewCs, State1),
+ order_fun_constraints(Tail, NewState);
+order_fun_constraints([], State) ->
+ State.
+
+order_fun_constraints([#constraint_ref{} = C|Tail], Funs, Acc, State) ->
+ order_fun_constraints(Tail, [C|Funs], Acc, State);
+order_fun_constraints([#constraint_list{list = List, type = Type} = C|Tail],
+ Funs, Acc, State) ->
+ {NewList, NewState} =
+ case Type of
+ conj -> order_fun_constraints(List, [], [], State);
+ disj ->
+ FoldFun = fun(X, AccState) ->
+ {[NewX], NewAccState} =
+ order_fun_constraints([X], [], [], AccState),
+ {NewX, NewAccState}
+ end,
+ lists:mapfoldl(FoldFun, State, List)
+ end,
+ NewAcc = [update_constraint_list(C, NewList)|Acc],
+ order_fun_constraints(Tail, Funs, NewAcc, NewState);
+order_fun_constraints([#constraint{} = C|Tail], Funs, Acc, State) ->
+ order_fun_constraints(Tail, Funs, [C|Acc], State);
+order_fun_constraints([], Funs, Acc, State) ->
+ NewState = order_fun_constraints(Funs, State),
+ {lists:reverse(Acc)++Funs, NewState}.
+
+%% ============================================================================
+%%
+%% Utilities.
+%%
+%% ============================================================================
+
+is_singleton_non_number_type(Type) ->
+ case t_is_number(Type) of
+ true -> false;
+ false -> is_singleton_type(Type)
+ end.
+
+is_singleton_type(Type) ->
+ case t_is_atom(Type) of
+ true ->
+ case t_atom_vals(Type) of
+ unknown -> false;
+ [_] -> true;
+ [_|_] -> false
+ end;
+ false ->
+ case t_is_integer(Type) of
+ true ->
+ case t_number_vals(Type) of
+ unknown -> false;
+ [_] -> true;
+ [_|_] -> false
+ end;
+ false ->
+ t_is_nil(Type)
+ end
+ end.
+
+%% ============================================================================
+%%
+%% Pretty printer and debug facilities.
+%%
+%% ============================================================================
+
+-ifdef(DEBUG_CONSTRAINTS).
+-ifndef(DEBUG).
+-define(DEBUG, true).
+-endif.
+-endif.
+
+-ifdef(DEBUG).
+format_type(#fun_var{deps = Deps}) ->
+ io_lib:format("Fun(~s)", [lists:flatten([format_type(t_var(X))||X<-Deps])]);
+format_type(Type) ->
+ case cerl:is_literal(Type) of
+ true -> io_lib:format("~w", [cerl:concrete(Type)]);
+ false -> erl_types:t_to_string(Type)
+ end.
+-endif.
+
+-ifdef(DEBUG_NAME_MAP).
+debug_make_name_map(Vars, Funs) ->
+ Map = get(dialyzer_typesig_map),
+ NewMap =
+ if Map =:= undefined -> debug_make_name_map(Vars, Funs, dict:new());
+ true -> debug_make_name_map(Vars, Funs, Map)
+ end,
+ put(dialyzer_typesig_map, NewMap).
+
+debug_make_name_map([Var|VarLeft], [Fun|FunLeft], Map) ->
+ Name = {cerl:fname_id(Var), cerl:fname_arity(Var)},
+ FunLabel = cerl_trees:get_label(Fun),
+ debug_make_name_map(VarLeft, FunLeft, dict:store(FunLabel, Name, Map));
+debug_make_name_map([], [], Map) ->
+ Map.
+
+debug_lookup_name(Var) ->
+ case dict:find(t_var_name(Var), get(dialyzer_typesig_map)) of
+ error -> Var;
+ {ok, Name} -> Name
+ end.
+
+-else.
+debug_make_name_map(_Vars, _Funs) ->
+ ok.
+-endif.
+
+-ifdef(DEBUG_CONSTRAINTS).
+pp_constrs_scc(SCC, State) ->
+ [pp_constrs(Fun, state__get_cs(Fun, State), State) || Fun <- SCC].
+
+pp_constrs(Fun, Cs, State) ->
+ io:format("Constraints for fun: ~w\n", [debug_lookup_name(Fun)]),
+ MaxDepth = pp_constraints(Cs, State),
+ io:format("Depth: ~w\n", [MaxDepth]).
+
+pp_constraints(Cs, State) ->
+ Res = pp_constraints([Cs], none, 0, 0, State),
+ io:nl(),
+ Res.
+
+pp_constraints([List|Tail], Separator, Level, MaxDepth,
+ State) when is_list(List) ->
+ pp_constraints(List++Tail, Separator, Level, MaxDepth, State);
+pp_constraints([#constraint_ref{id = Id}|Left], Separator,
+ Level, MaxDepth, State) ->
+ Cs = state__get_cs(Id, State),
+ io:format("%Ref ~w%", [t_var_name(Id)]),
+ pp_constraints([Cs|Left], Separator, Level, MaxDepth, State);
+pp_constraints([#constraint{lhs = Lhs, op = Op, rhs = Rhs}], _Separator,
+ Level, MaxDepth, _State) ->
+ io:format("~s ~w ~s", [format_type(Lhs), Op, format_type(Rhs)]),
+ erlang:max(Level, MaxDepth);
+pp_constraints([#constraint{lhs = Lhs, op = Op, rhs = Rhs}|Tail], Separator,
+ Level, MaxDepth, State) ->
+ io:format("~s ~w ~s ~s ", [format_type(Lhs), Op, format_type(Rhs),Separator]),
+ pp_constraints(Tail, Separator, Level, MaxDepth, State);
+pp_constraints([#constraint_list{type = Type, list = List, id = Id}],
+ _Separator, Level, MaxDepth, State) ->
+ io:format("%List ~w(", [Id]),
+ NewSeparator = case Type of
+ conj -> "*";
+ disj -> "+"
+ end,
+ NewMaxDepth = pp_constraints(List, NewSeparator, Level + 1, MaxDepth, State),
+ io:format(")", []),
+ NewMaxDepth;
+pp_constraints([#constraint_list{type = Type, list = List, id = Id}|Tail],
+ Separator, Level, MaxDepth, State) ->
+ io:format("List ~w(", [Id]),
+ NewSeparator = case Type of
+ conj -> "*";
+ disj -> "+"
+ end,
+ NewMaxDepth = pp_constraints(List, NewSeparator, Level+1, MaxDepth, State),
+ io:format(") ~s\n~s ", [Separator, Separator]),
+ pp_constraints(Tail, Separator, Level, NewMaxDepth, State).
+-else.
+pp_constrs_scc(_SCC, _State) ->
+ ok.
+-endif.
+
+-ifdef(TO_DOT).
+
+constraints_to_dot_scc(SCC, State) ->
+ io:format("SCC: ~p\n", [SCC]),
+ Name = lists:flatten([io_lib:format("'~w'", [debug_lookup_name(Fun)])
+ || Fun <- SCC]),
+ Cs = [state__get_cs(Fun, State) || Fun <- SCC],
+ constraints_to_dot(Cs, Name, State).
+
+constraints_to_dot(Cs0, Name, State) ->
+ NofCs = length(Cs0),
+ Cs = lists:zip(lists:seq(1, NofCs), Cs0),
+ {Graph, Opts, _N} = constraints_to_nodes(Cs, NofCs + 1, 1, [], [], State),
+ hipe_dot:translate_list(Graph, "/tmp/cs.dot", "foo", Opts),
+ Res = os:cmd("dot -o /tmp/"++ Name ++ ".ps -T ps /tmp/cs.dot"),
+ io:format("Res: ~p~n", [Res]),
+ ok.
+
+constraints_to_nodes([{Name, #constraint_list{type = Type, list = List, id=Id}}
+ |Left], N, Level, Graph, Opts, State) ->
+ N1 = N + length(List),
+ NewList = lists:zip(lists:seq(N, N1 - 1), List),
+ Names = [SubName || {SubName, _C} <- NewList],
+ Edges = [{Name, SubName} || SubName <- Names],
+ ThisNode = [{Name, Opt} || Opt <- [{label,
+ lists:flatten(io_lib:format("~w", [Id]))},
+ {shape, get_shape(Type)},
+ {level, Level}]],
+ {NewGraph, NewOpts, N2} = constraints_to_nodes(NewList, N1, Level+1,
+ [Edges|Graph],
+ [ThisNode|Opts], State),
+ constraints_to_nodes(Left, N2, Level, NewGraph, NewOpts, State);
+constraints_to_nodes([{Name, #constraint{lhs = Lhs, op = Op, rhs = Rhs}}|Left],
+ N, Level, Graph, Opts, State) ->
+ Label = lists:flatten(io_lib:format("~s ~w ~s",
+ [format_type(Lhs), Op,
+ format_type(Rhs)])),
+ ThisNode = [{Name, Opt} || Opt <- [{label, Label}, {level, Level}]],
+ NewOpts = [ThisNode|Opts],
+ constraints_to_nodes(Left, N, Level, Graph, NewOpts, State);
+constraints_to_nodes([{Name, #constraint_ref{id = Id0}}|Left],
+ N, Level, Graph, Opts, State) ->
+ Id = debug_lookup_name(Id0),
+ CList = state__get_cs(Id0, State),
+ ThisNode = [{Name, Opt} || Opt <- [{label,
+ lists:flatten(io_lib:format("~w", [Id]))},
+ {shape, ellipse},
+ {level, Level}]],
+ NewList = [{N, CList}],
+ {NewGraph, NewOpts, N1} = constraints_to_nodes(NewList, N + 1, Level + 1,
+ [{Name, N}|Graph],
+ [ThisNode|Opts], State),
+ constraints_to_nodes(Left, N1, Level, NewGraph, NewOpts, State);
+constraints_to_nodes([], N, _Level, Graph, Opts, _State) ->
+ {lists:flatten(Graph), lists:flatten(Opts), N}.
+
+get_shape(conj) -> box;
+get_shape(disj) -> diamond.
+
+-else.
+constraints_to_dot_scc(_SCC, _State) ->
+ ok.
+-endif.
diff --git a/lib/dialyzer/src/dialyzer_utils.erl b/lib/dialyzer/src/dialyzer_utils.erl
new file mode 100644
index 0000000000..fa9ad2eae2
--- /dev/null
+++ b/lib/dialyzer/src/dialyzer_utils.erl
@@ -0,0 +1,458 @@
+%% -*- erlang-indent-level: 2 -*-
+%%-----------------------------------------------------------------------
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2006-2009. 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%
+%%
+
+%%%-------------------------------------------------------------------
+%%% File : dialyzer_utils.erl
+%%% Author : Tobias Lindahl <[email protected]>
+%%% Description :
+%%%
+%%% Created : 5 Dec 2006 by Tobias Lindahl <[email protected]>
+%%%-------------------------------------------------------------------
+-module(dialyzer_utils).
+
+-export([
+ format_sig/1,
+ format_sig/2,
+ get_abstract_code_from_beam/1,
+ get_abstract_code_from_src/1,
+ get_abstract_code_from_src/2,
+ get_core_from_abstract_code/1,
+ get_core_from_abstract_code/2,
+ get_core_from_src/1,
+ get_core_from_src/2,
+ get_record_and_type_info/1,
+ get_spec_info/3,
+ merge_records/2,
+ pp_hook/0,
+ process_record_remote_types/1,
+ src_compiler_opts/0
+ ]).
+
+-include("dialyzer.hrl").
+
+%%
+%% Types that need to be imported from somewhere else
+%%
+
+-type abstract_code() :: [tuple()]. %% XXX: refine
+-type comp_options() :: [atom()]. %% XXX: only a resticted set of options used
+
+%% ============================================================================
+%%
+%% Compilation utils
+%%
+%% ============================================================================
+
+-spec get_abstract_code_from_src(atom() | file:filename()) ->
+ {'ok', abstract_code()} | {'error', [string()]}.
+
+get_abstract_code_from_src(File) ->
+ get_abstract_code_from_src(File, src_compiler_opts()).
+
+-spec get_abstract_code_from_src(atom() | file:filename(), comp_options()) ->
+ {'ok', abstract_code()} | {'error', [string()]}.
+
+get_abstract_code_from_src(File, Opts) ->
+ case compile:file(File, [to_pp, binary|Opts]) of
+ error -> {error, []};
+ {error, Errors, _} -> {error, format_errors(Errors)};
+ {ok, _, AbstrCode} -> {ok, AbstrCode}
+ end.
+
+-type get_core_from_src_ret() :: {'ok', cerl:c_module()} | {'error', string()}.
+
+-spec get_core_from_src(file:filename()) -> get_core_from_src_ret().
+
+get_core_from_src(File) ->
+ get_core_from_src(File, []).
+
+-spec get_core_from_src(file:filename(), comp_options()) -> get_core_from_src_ret().
+
+get_core_from_src(File, Opts) ->
+ case get_abstract_code_from_src(File, Opts) of
+ {error, _} = Error -> Error;
+ {ok, AbstrCode} ->
+ case get_core_from_abstract_code(AbstrCode, Opts) of
+ error -> {error, " Could not get Core Erlang code from abstract code"};
+ {ok, _Core} = C -> C
+ end
+ end.
+
+-spec get_abstract_code_from_beam(file:filename()) -> 'error' | {'ok', abstract_code()}.
+
+get_abstract_code_from_beam(File) ->
+ case beam_lib:chunks(File, [abstract_code]) of
+ {ok, {_, List}} ->
+ case lists:keyfind(abstract_code, 1, List) of
+ {abstract_code, {raw_abstract_v1, Abstr}} -> {ok, Abstr};
+ _ -> error
+ end;
+ _ ->
+ %% No or unsuitable abstract code.
+ error
+ end.
+
+-type get_core_from_abs_ret() :: {'ok', cerl:c_module()} | 'error'.
+
+-spec get_core_from_abstract_code(abstract_code()) -> get_core_from_abs_ret().
+
+get_core_from_abstract_code(AbstrCode) ->
+ get_core_from_abstract_code(AbstrCode, []).
+
+-spec get_core_from_abstract_code(abstract_code(), comp_options()) -> get_core_from_abs_ret().
+
+get_core_from_abstract_code(AbstrCode, Opts) ->
+ %% We do not want the parse_transforms around since we already
+ %% performed them. In some cases we end up in trouble when
+ %% performing them again.
+ AbstrCode1 = cleanup_parse_transforms(AbstrCode),
+ try compile:forms(AbstrCode1, Opts ++ src_compiler_opts()) of
+ {ok, _, Core} -> {ok, Core};
+ _What -> error
+ catch
+ error:_ -> error
+ end.
+
+%% ============================================================================
+%%
+%% Typed Records
+%%
+%% ============================================================================
+
+-spec get_record_and_type_info(abstract_code()) ->
+ {'ok', dict()} | {'error', string()}.
+
+get_record_and_type_info(AbstractCode) ->
+ Module = get_module(AbstractCode),
+ get_record_and_type_info(AbstractCode, Module, dict:new()).
+
+-spec get_record_and_type_info(abstract_code(), atom(), dict()) ->
+ {'ok', dict()} | {'error', string()}.
+
+get_record_and_type_info([{attribute, _, record, {Name, Fields0}}|Left],
+ Module, RecDict) ->
+ case get_record_fields(Fields0, RecDict) of
+ {ok, Fields} ->
+ Arity = length(Fields),
+ Fun = fun(OldOrdDict) -> orddict:store(Arity, Fields, OldOrdDict) end,
+ NewRecDict = dict:update({record, Name}, Fun, [{Arity, Fields}], RecDict),
+ get_record_and_type_info(Left, Module, NewRecDict);
+ {error, Error} ->
+ {error, lists:flatten(io_lib:format(" Error while parsing #~w{}: ~s\n",
+ [Name, Error]))}
+ end;
+get_record_and_type_info([{attribute, _, type, {{record, Name}, Fields0, []}}
+ |Left], Module, RecDict) ->
+ %% This overrides the original record declaration.
+ case get_record_fields(Fields0, RecDict) of
+ {ok, Fields} ->
+ Arity = length(Fields),
+ Fun = fun(OldOrdDict) -> orddict:store(Arity, Fields, OldOrdDict) end,
+ NewRecDict = dict:update({record, Name}, Fun, [{Arity, Fields}], RecDict),
+ get_record_and_type_info(Left, Module, NewRecDict);
+ {error, Error} ->
+ {error, lists:flatten(io_lib:format(" Error while parsing #~w{}: ~s\n",
+ [Name, Error]))}
+ end;
+get_record_and_type_info([{attribute, _, Attr, {Name, TypeForm}}|Left],
+ Module, RecDict) when Attr =:= 'type'; Attr =:= 'opaque' ->
+ try
+ NewRecDict = add_new_type(Attr, Name, TypeForm, [], Module, RecDict),
+ get_record_and_type_info(Left, Module, NewRecDict)
+ catch
+ throw:{error, _} = Error -> Error
+ end;
+get_record_and_type_info([{attribute, _, Attr, {Name, TypeForm, Args}}|Left],
+ Module, RecDict) when Attr =:= 'type'; Attr =:= 'opaque' ->
+ try
+ NewRecDict = add_new_type(Attr, Name, TypeForm, Args, Module, RecDict),
+ get_record_and_type_info(Left, Module, NewRecDict)
+ catch
+ throw:{error, _} = Error -> Error
+ end;
+get_record_and_type_info([_Other|Left], Module, RecDict) ->
+ get_record_and_type_info(Left, Module, RecDict);
+get_record_and_type_info([], _Module, RecDict) ->
+ {ok, RecDict}.
+
+add_new_type(TypeOrOpaque, Name, TypeForm, ArgForms, Module, RecDict) ->
+ case erl_types:type_is_defined(TypeOrOpaque, Name, RecDict) of
+ true ->
+ throw({error, io_lib:format("Type already defined: ~w\n", [Name])});
+ false ->
+ ArgTypes = [erl_types:t_from_form(X) || X <- ArgForms],
+ _Type = erl_types:t_from_form(TypeForm, RecDict),
+ case lists:all(fun erl_types:t_is_var/1, ArgTypes) of
+ true ->
+ ArgNames = [erl_types:t_var_name(X) || X <- ArgTypes],
+ dict:store({TypeOrOpaque, Name}, {Module, TypeForm, ArgNames}, RecDict);
+ false ->
+ throw({error, io_lib:format("Type declaration for ~w does not "
+ "have variables as parameters", [Name])})
+ end
+ end.
+
+get_record_fields(Fields, RecDict) ->
+ get_record_fields(Fields, RecDict, []).
+
+get_record_fields([{typed_record_field, OrdRecField, TypeForm}|Left],
+ RecDict, Acc) ->
+ Name =
+ case OrdRecField of
+ {record_field, _Line, Name0} -> erl_parse:normalise(Name0);
+ {record_field, _Line, Name0, _Init} -> erl_parse:normalise(Name0)
+ end,
+ try
+ Type = erl_types:t_from_form(TypeForm, RecDict),
+ get_record_fields(Left, RecDict, [{Name, Type}|Acc])
+ catch
+ throw:{error, _} = Error -> Error
+ end;
+get_record_fields([{record_field, _Line, Name}|Left], RecDict, Acc) ->
+ NewAcc = [{erl_parse:normalise(Name), erl_types:t_any()}|Acc],
+ get_record_fields(Left, RecDict, NewAcc);
+get_record_fields([{record_field, _Line, Name, _Init}|Left], RecDict, Acc) ->
+ NewAcc = [{erl_parse:normalise(Name), erl_types:t_any()}|Acc],
+ get_record_fields(Left, RecDict, NewAcc);
+get_record_fields([], _RecDict, Acc) ->
+ {ok, lists:reverse(Acc)}.
+
+-spec process_record_remote_types(dialyzer_codeserver:codeserver()) -> dialyzer_codeserver:codeserver().
+
+process_record_remote_types(CServer) ->
+ TempRecords = dialyzer_codeserver:get_temp_records(CServer),
+ RecordFun =
+ fun(Key, Value) ->
+ case Key of
+ {record, _Name} ->
+ FieldFun =
+ fun(_Arity, Fields) ->
+ [{Name, erl_types:t_solve_remote(Field, TempRecords)} || {Name, Field} <- Fields]
+ end,
+ orddict:map(FieldFun, Value);
+ _Other -> Value
+ end
+ end,
+ ModuleFun =
+ fun(_Module, Record) ->
+ dict:map(RecordFun, Record)
+ end,
+ NewRecords = dict:map(ModuleFun, TempRecords),
+ dialyzer_codeserver:finalize_records(NewRecords, CServer).
+
+-spec merge_records(dict(), dict()) -> dict().
+
+merge_records(NewRecords, OldRecords) ->
+ dict:merge(fun(_Key, NewVal, _OldVal) -> NewVal end, NewRecords, OldRecords).
+
+%% ============================================================================
+%%
+%% Spec info
+%%
+%% ============================================================================
+
+-spec get_spec_info(module(), abstract_code(), dict()) ->
+ {'ok', dict()} | {'error', string()}.
+
+get_spec_info(ModName, AbstractCode, RecordsDict) ->
+ get_spec_info(AbstractCode, dict:new(), RecordsDict, ModName, "nofile").
+
+%% TypeSpec is a list of conditional contracts for a function.
+%% Each contract is of the form {[Argument], Range, [Constraint]} where
+%% - Argument and Range are in erl_types:erl_type() format and
+%% - Constraint is of the form {subtype, T1, T2} where T1 and T2
+%% are erl_types:erl_type()
+
+get_spec_info([{attribute, Ln, spec, {Id, TypeSpec}}|Left],
+ SpecDict, RecordsDict, ModName, File) when is_list(TypeSpec) ->
+ MFA = case Id of
+ {_, _, _} = T -> T;
+ {F, A} -> {ModName, F, A}
+ end,
+ try dict:find(MFA, SpecDict) of
+ error ->
+ NewSpecDict =
+ dialyzer_contracts:store_tmp_contract(MFA, {File, Ln}, TypeSpec,
+ SpecDict, RecordsDict),
+ get_spec_info(Left, NewSpecDict, RecordsDict, ModName, File);
+ {ok, {{OtherFile, L},_C}} ->
+ {Mod, Fun, Arity} = MFA,
+ Msg = io_lib:format(" Contract for function ~w:~w/~w "
+ "already defined in ~s:~w\n",
+ [Mod, Fun, Arity, OtherFile, L]),
+ throw({error, Msg})
+ catch
+ throw:{error, Error} ->
+ {error, lists:flatten(io_lib:format(" Error while parsing contract "
+ "in line ~w: ~s\n", [Ln, Error]))}
+ end;
+get_spec_info([{attribute, _, file, {IncludeFile, _}}|Left],
+ SpecDict, RecordsDict, ModName, _File) ->
+ get_spec_info(Left, SpecDict, RecordsDict, ModName, IncludeFile);
+get_spec_info([_Other|Left], SpecDict, RecordsDict, ModName, File) ->
+ get_spec_info(Left, SpecDict, RecordsDict, ModName, File);
+get_spec_info([], SpecDict, _RecordsDict, _ModName, _File) ->
+ {ok, SpecDict}.
+
+%% ============================================================================
+%%
+%% Util utils
+%%
+%% ============================================================================
+
+-spec src_compiler_opts() -> comp_options().
+
+src_compiler_opts() ->
+ [no_copt, to_core, binary, return_errors,
+ no_inline, strict_record_tests, strict_record_updates].
+
+-spec get_module(abstract_code()) -> module().
+
+get_module([{attribute, _, module, {M, _As}} | _]) -> M;
+get_module([{attribute, _, module, M} | _]) -> M;
+get_module([_ | Rest]) -> get_module(Rest).
+
+-spec cleanup_parse_transforms(abstract_code()) -> abstract_code().
+
+cleanup_parse_transforms([{attribute, _, compile, {parse_transform, _}}|Left]) ->
+ cleanup_parse_transforms(Left);
+cleanup_parse_transforms([Other|Left]) ->
+ [Other|cleanup_parse_transforms(Left)];
+cleanup_parse_transforms([]) ->
+ [].
+
+-spec format_errors([{module(), string()}]) -> [string()].
+
+format_errors([{Mod, Errors}|Left]) ->
+ FormatedError =
+ [io_lib:format("~s:~w: ~s\n", [Mod, Line, M:format_error(Desc)])
+ || {Line, M, Desc} <- Errors],
+ [lists:flatten(FormatedError) | format_errors(Left)];
+format_errors([]) ->
+ [].
+
+-spec format_sig(erl_types:erl_type()) -> string().
+
+format_sig(Type) ->
+ format_sig(Type, dict:new()).
+
+-spec format_sig(erl_types:erl_type(), dict()) -> string().
+
+format_sig(Type, RecDict) ->
+ "fun(" ++ Sig = lists:flatten(erl_types:t_to_string(Type, RecDict)),
+ ")" ++ RevSig = lists:reverse(Sig),
+ lists:reverse(RevSig).
+
+%%-------------------------------------------------------------------
+%% Author : Per Gustafsson <[email protected]>
+%% Description : Provides better printing of binaries.
+%% Created : 5 March 2007
+%%-------------------------------------------------------------------
+
+pp_hook() ->
+ fun pp_hook/3.
+
+-spec pp_hook() -> fun((cerl:cerl(), _, _) -> term()).
+
+pp_hook(Node, Ctxt, Cont) ->
+ case cerl:type(Node) of
+ binary ->
+ pp_binary(Node, Ctxt, Cont);
+ bitstr ->
+ pp_segment(Node, Ctxt, Cont);
+ _ ->
+ Cont(Node, Ctxt)
+ end.
+
+pp_binary(Node, Ctxt, Cont) ->
+ prettypr:beside(prettypr:text("<<"),
+ prettypr:beside(pp_segments(cerl:binary_segments(Node),
+ Ctxt, Cont),
+ prettypr:text(">>"))).
+
+pp_segments([Seg], Ctxt, Cont) ->
+ pp_segment(Seg, Ctxt, Cont);
+pp_segments([], _Ctxt, _Cont) ->
+ prettypr:text("");
+pp_segments([Seg|Rest], Ctxt, Cont) ->
+ prettypr:beside(pp_segment(Seg, Ctxt, Cont),
+ prettypr:beside(prettypr:text(","),
+ pp_segments(Rest, Ctxt, Cont))).
+
+pp_segment(Node, Ctxt, Cont) ->
+ Val = cerl:bitstr_val(Node),
+ Size = cerl:bitstr_size(Node),
+ Unit = cerl:bitstr_unit(Node),
+ Type = cerl:bitstr_type(Node),
+ Flags = cerl:bitstr_flags(Node),
+ prettypr:beside(Cont(Val, Ctxt),
+ prettypr:beside(pp_size(Size, Ctxt, Cont),
+ prettypr:beside(pp_opts(Type, Flags),
+ pp_unit(Unit, Ctxt, Cont)))).
+
+pp_size(Size, Ctxt, Cont) ->
+ case cerl:is_c_atom(Size) of
+ true ->
+ prettypr:text("");
+ false ->
+ prettypr:beside(prettypr:text(":"), Cont(Size, Ctxt))
+ end.
+
+pp_opts(Type, Flags) ->
+ FinalFlags =
+ case cerl:atom_val(Type) of
+ binary -> [];
+ float -> keep_endian(cerl:concrete(Flags));
+ integer -> keep_all(cerl:concrete(Flags));
+ utf8 -> [];
+ utf16 -> [];
+ utf32 -> []
+ end,
+ prettypr:beside(prettypr:text("/"),
+ prettypr:beside(pp_atom(Type),
+ pp_flags(FinalFlags))).
+
+pp_flags([]) ->
+ prettypr:text("");
+pp_flags([Flag|Flags]) ->
+ prettypr:beside(prettypr:text("-"),
+ prettypr:beside(pp_atom(Flag),
+ pp_flags(Flags))).
+
+keep_endian(Flags) ->
+ [cerl:c_atom(X) || X <- Flags, (X =:= little) or (X =:= native)].
+
+keep_all(Flags) ->
+ [cerl:c_atom(X) || X <- Flags,
+ (X =:= little) or (X =:= native) or (X =:= signed)].
+
+pp_unit(Unit, Ctxt, Cont) ->
+ case cerl:concrete(Unit) of
+ N when is_integer(N) ->
+ prettypr:beside(prettypr:text("-"),
+ prettypr:beside(prettypr:text("unit:"),
+ Cont(Unit, Ctxt)));
+ _ -> % Other value: e.g. 'undefined' when UTF
+ prettypr:text("")
+ end.
+
+pp_atom(Atom) ->
+ String = atom_to_list(cerl:atom_val(Atom)),
+ prettypr:text(String).