dialyzer_races

Types

---

args() = [label_type() | [string()]]

call() = whereis
               | register
               | unregister
               | ets_new
               | ets_lookup
               | ets_insert
               | mnesia_dirty_read1
               | mnesia_dirty_read2
               | mnesia_dirty_write1
               | mnesia_dirty_write2
               | function_call

case_tags() = beg_case
                    | #beg_clause{arg = undefined | var_to_map1(),
                                  pats = undefined | var_to_map1(),
                                  guard = undefined | cerl:cerl()}
                    | #end_clause{arg = undefined | var_to_map1(),
                                  pats = undefined | var_to_map1(),
                                  guard = undefined | cerl:cerl()}
                    | #end_case{clauses = undefined
                                         | [#end_clause{arg = undefined
                                                             | var_to_map1(),
                                                        pats = undefined
                                                              | var_to_map1(),
                                                        guard = undefined
                                                               | cerl:cerl()}]}

code() =
            [#dep_call{call_name = undefined | dep_calls(),
                       args = undefined | args(),
                       arg_types = undefined | [erl_types:erl_type()],
                       vars = undefined | [core_vars()],
                       state = undefined | dialyzer_dataflow:state(),
                       file_line = undefined | file_line(),
                       var_map = undefined | dict:dict()} |
             #fun_call{caller = undefined
                               | dialyzer_callgraph:mfa_or_funlbl(),
                       callee = undefined
                               | dialyzer_callgraph:mfa_or_funlbl(),
                       arg_types = undefined | [erl_types:erl_type()],
                       vars = undefined | [core_vars()]} |
             #warn_call{call_name = undefined | warn_calls(),
                        args = undefined | args(),
                        var_map = undefined | dict:dict()} |
             #curr_fun{status = undefined | in | out,
                       mfa = undefined
                            | dialyzer_callgraph:mfa_or_funlbl(),
                       label = undefined | label(),
                       def_vars = undefined | [core_vars()],
                       arg_types = undefined | [erl_types:erl_type()],
                       call_vars = undefined | [core_vars()],
                       var_map = undefined | dict:dict()} |
             #let_tag{var = undefined | var_to_map1(),
                      arg = undefined | var_to_map1()} |
             case_tags() |
             race_tag()]

core_args() = [core_vars()] | empty

core_vars() = cerl:cerl() | no_arg | bypassed

dep_calls() = whereis | ets_lookup | mnesia_dirty_read

file_line() = {file:filename(), integer() >= 0}

label() = integer() >= 0

label_type() = label() | [label()] | {label()} | no_label

race_tag() = whereis_register
                   | whereis_unregister
                   | ets_lookup_insert
                   | mnesia_dirty_read_write

races()

table() = {named, table_var(), [string()]} | other | no_t

table_var() = label() | no_label

var_to_map1() = core_vars() | [cerl:cerl()]

warn_calls() = register
                     | unregister
                     | ets_insert
                     | mnesia_dirty_write

Functions

---

store_race_call(Fun::mfa_or_funlbl() (see module dialyzer_callgraph), ArgTypes::[erl_type() (see module erl_types)], Args::[core_vars()], FileLine::file_line(), State::state() (see module dialyzer_dataflow)) -> state() (see module dialyzer_dataflow)

race(State::state() (see module dialyzer_dataflow)) -> state() (see module dialyzer_dataflow)

format_args(ArgList::[core_vars()], TypeList::[erl_type() (see module erl_types)], State::state() (see module dialyzer_dataflow), Call::call()) -> args()

get_race_warnings(Races::races(), State::state() (see module dialyzer_dataflow)) -> {races(), state() (see module dialyzer_dataflow)}

beg_clause_new(Arg::var_to_map1(), Pats::var_to_map1(), Guard::cerl() (see module cerl)) -> #beg_clause{arg=undefined | var_to_map1(), pats=undefined | var_to_map1(), guard=undefined | cerl() (see module cerl)}

cleanup(Races::races()) -> races()

end_case_new(End_clause::[#end_clause{arg=undefined | var_to_map1(), pats=undefined | var_to_map1(), guard=undefined | cerl() (see module cerl)}]) -> #end_case{clauses=undefined | [#end_clause{arg=undefined | var_to_map1(), pats=undefined | var_to_map1(), guard=undefined | cerl() (see module cerl)}]}

end_clause_new(Arg::var_to_map1(), Pats::var_to_map1(), Guard::cerl() (see module cerl)) -> #end_clause{arg=undefined | var_to_map1(), pats=undefined | var_to_map1(), guard=undefined | cerl() (see module cerl)}

get_curr_fun(Races::races()) -> mfa_or_funlbl() (see module dialyzer_callgraph)

get_curr_fun_args(Races::races()) -> core_args()

get_new_table(Races::races()) -> table()

get_race_analysis(Races::races()) -> boolean()

get_race_list(Races::races()) -> code()

get_race_list_size(Races::races()) -> non_neg_integer()

get_race_list_and_size(Races::races()) -> {code(), non_neg_integer()}

let_tag_new(Var::var_to_map1(), Arg::var_to_map1()) -> #let_tag{var=undefined | var_to_map1(), arg=undefined | var_to_map1()}

new() -> races()

put_curr_fun(CurrFun::mfa_or_funlbl() (see module dialyzer_callgraph), CurrFunLabel::label(), Races::races()) -> races()

put_fun_args(Args::core_args(), Races::races()) -> races()

put_race_analysis(Analysis::boolean(), Races::races()) -> races()

put_race_list(RaceList::code(), RaceListSize::non_neg_integer(), Races::races()) -> races()