Remove unused race detection related code

4 files changed, 87 insertions, 108 deletions

diff --git a/lib/dialyzer/src/dialyzer_callgraph.erl b/lib/dialyzer/src/dialyzer_callgraph.erl
index ddda27adb4..fd6bc89e25 100644
--- a/lib/dialyzer/src/dialyzer_callgraph.erl
+++ b/lib/dialyzer/src/dialyzer_callgraph.erl
@@ -49,6 +49,7 @@
 	 in_neighbours/2,
 	 renew_race_info/4,
 	 renew_race_code/2,
+	 renew_race_public_tables/2,
 	 reset_from_funs/2,
 	 scan_core_tree/2,
 	 strip_module_deps/2,
@@ -248,6 +249,11 @@ renew_race_code(Races, #callgraph{race_code = RaceCode} = Callgraph) ->
   Code = lists:reverse(dialyzer_races:get_race_list(Races)),
   Callgraph#callgraph{race_code = dict:store(Fun, [FunArgs, Code], RaceCode)}.
 
+-spec renew_race_public_tables(label(), callgraph()) -> callgraph().
+
+renew_race_public_tables(VarLabel, #callgraph{public_tables = PT} = CG) ->
+  CG#callgraph{public_tables = ordsets:add_element(VarLabel, PT)}.
+
 -spec get_depends_on(scc(), callgraph()) -> [scc()].
 
 get_depends_on(SCC, #callgraph{active_digraph = DG}) ->
diff --git a/lib/dialyzer/src/dialyzer_dataflow.erl b/lib/dialyzer/src/dialyzer_dataflow.erl
index a72116d1f2..f554143bb6 100644
--- a/lib/dialyzer/src/dialyzer_dataflow.erl
+++ b/lib/dialyzer/src/dialyzer_dataflow.erl
@@ -111,7 +111,7 @@
 
 -spec get_warnings(cerl:c_module(), dialyzer_plt:plt(),
                    dialyzer_callgraph:callgraph(), dict(), set()) ->
-	{[dial_warning()], dict(), dict(), [label()], [string()]}.
+	{[dial_warning()], dict()}.
 
 get_warnings(Tree, Plt, Callgraph, Records, NoWarnUnused) ->
   State1 = analyze_module(Tree, Plt, Callgraph, Records, true),
@@ -119,23 +119,15 @@ get_warnings(Tree, Plt, Callgraph, Records, NoWarnUnused) ->
   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)}.
+  {State4#state.warnings, state__all_fun_types(State4)}.
 
 -spec get_fun_types(cerl:c_module(), dialyzer_plt:plt(),
                     dialyzer_callgraph:callgraph(), dict()) ->
-	{dict(), dict(), [label()], [string()]}.
+	{dict(), dialyzer_callgraph:callgraph()}.
 
 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)}.
+  {state__all_fun_types(State), State#state.callgraph}.
 
 %%--------------------------------------------------------------------
 
@@ -307,7 +299,7 @@ analyze_module(Tree, Plt, Callgraph, Records, GetWarnings) ->
       State2
   end.
 
-analyze_loop(#state{callgraph = Callgraph, races = Races} = State) ->
+analyze_loop(State) ->
   case state__get_work(State) of
     none -> State;
     {Fun, NewState1} ->
@@ -333,10 +325,9 @@ analyze_loop(#state{callgraph = Callgraph, races = Races} = State) ->
 	      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),
+	      IsRaceAnalysisEnabled = is_race_analysis_enabled(State),
               NewState3 =
-                case RaceDetection andalso RaceAnalysis of
+                case IsRaceAnalysisEnabled of
                   true ->
                     NewState2 = state__renew_curr_fun(
                       state__lookup_name(FunLabel, NewState1), FunLabel,
@@ -350,7 +341,7 @@ analyze_loop(#state{callgraph = Callgraph, races = Races} = State) ->
 		     [state__lookup_name(get_label(Fun), State),
 		      t_to_string(t_fun(ArgTypes, BodyType))]),
               NewState5 =
-                case RaceDetection andalso RaceAnalysis of
+                case IsRaceAnalysisEnabled of
                   true -> renew_race_code(NewState4);
                   false -> NewState4
                 end,
@@ -566,9 +557,7 @@ handle_apply_or_call([{local, external}|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) ->
+                     #state{opaques = Opaques} = State, AccArgTypes, AccRet) ->
   Any = t_any(),
   AnyArgs = [Any || _ <- Args],
   GenSig = {AnyArgs, fun(_) -> t_any() end},
@@ -664,8 +653,7 @@ handle_apply_or_call([{TypeOfApply, {Fun, Sig, Contr, LocalRet}}|Left],
   ?debug("ContrRet: ~s\n", [erl_types:t_to_string(CRange(TmpArgTypes))]),
   ?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
+    case is_race_analysis_enabled(State) of
       true ->
         Ann = cerl:get_ann(Tree),
         File = get_file(Ann),
@@ -1031,20 +1019,17 @@ handle_call(Tree, Map, State) ->
 
 %%----------------------------------------
 
-handle_case(Tree, Map, #state{callgraph = Callgraph} = State) ->
+handle_case(Tree, Map, 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
+        case is_race_analysis_enabled(State) of
           true ->
-	    RaceList = dialyzer_races:get_race_list(Races),
-            RaceListSize = dialyzer_races:get_race_list_size(Races),
+	    {RaceList, RaceListSize} = get_race_list_and_size(State1),
             state__renew_race_list([beg_case|RaceList],
                                    RaceListSize + 1, State1);
           false -> State1
@@ -1078,9 +1063,8 @@ handle_cons(Tree, Map, State) ->
 
 %%----------------------------------------
 
-handle_let(Tree, Map, #state{callgraph = Callgraph, races = Races} = State) ->
-  RaceAnalysis = dialyzer_races:get_race_analysis(Races),
-  RaceDetection = dialyzer_callgraph:get_race_detection(Callgraph),
+handle_let(Tree, Map, State) ->
+  IsRaceAnalysisEnabled = is_race_analysis_enabled(State),
   Arg = cerl:let_arg(Tree),
   Vars = cerl:let_vars(Tree),
   {Map0, State0} =
@@ -1088,10 +1072,9 @@ handle_let(Tree, Map, #state{callgraph = Callgraph, races = Races} = State) ->
       true ->
 	[Var] = Vars,
 	{enter_subst(Var, Arg, Map),
-         case RaceDetection andalso RaceAnalysis of
+         case IsRaceAnalysisEnabled of
            true ->
-             RaceList = dialyzer_races:get_race_list(Races),
-             RaceListSize = dialyzer_races:get_race_list_size(Races),
+	    {RaceList, RaceListSize} = get_race_list_and_size(State),
              state__renew_race_list(
                [dialyzer_races:let_tag_new(Var, Arg)|RaceList],
                RaceListSize + 1, State);
@@ -1101,9 +1084,8 @@ handle_let(Tree, Map, #state{callgraph = Callgraph, races = Races} = 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
+  State2 =
+    case IsRaceAnalysisEnabled andalso cerl:is_c_call(Arg) of
       true ->
         Mod = cerl:call_module(Arg),
         Name = cerl:call_name(Arg),
@@ -1111,16 +1093,11 @@ handle_let(Tree, Map, #state{callgraph = Callgraph, races = Races} = State) ->
              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
+          true -> renew_race_public_tables(Vars, State1);
+          false -> State1
         end;
-      false -> Callgraph1
+      false -> State1
     end,
-  State2 = State1#state{callgraph = Callgraph2},
   case t_is_none_or_unit(ArgTypes) of
     true -> SMA;
     false ->
@@ -1151,16 +1128,13 @@ handle_module(Tree, Map, State) ->
 
 %%----------------------------------------
 
-handle_receive(Tree, Map,
-               #state{callgraph = Callgraph, races = Races} = State) ->
+handle_receive(Tree, Map, 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
+    case is_race_analysis_enabled(State) of
       true ->
-	RaceList = dialyzer_races:get_race_list(Races),
-        RaceListSize = dialyzer_races:get_race_list_size(Races),
+	{RaceList, RaceListSize} = get_race_list_and_size(State),
         state__renew_race_list([beg_case|RaceList],
                                RaceListSize + 1, State);
       false -> State
@@ -1283,16 +1257,13 @@ handle_tuple(Tree, Map, State) ->
 %%----------------------------------------
 %% 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),
+handle_clauses([C|Left], Arg, ArgType, OrigArgType, State, CaseTypes, MapIn,
+	       Acc, ClauseAcc) ->
+  IsRaceAnalysisEnabled = is_race_analysis_enabled(State),
   State1 =
-    case RaceDetection andalso RaceAnalysis of
+    case IsRaceAnalysisEnabled of
       true ->
-	RaceList = dialyzer_races:get_race_list(Races),
-        RaceListSize = dialyzer_races:get_race_list_size(Races),
+	{RaceList, RaceListSize} = get_race_list_and_size(State),
         state__renew_race_list(
           [dialyzer_races:beg_clause_new(Arg, cerl:clause_pats(C),
                                          cerl:clause_guard(C))|
@@ -1303,11 +1274,9 @@ handle_clauses([C|Left], Arg, ArgType, OrigArgType,
   {State2, ClauseMap, BodyType, NewArgType} =
     do_clause(C, Arg, ArgType, OrigArgType, MapIn, State1),
   {NewClauseAcc, State3} =
-    case RaceDetection andalso RaceAnalysis of
+    case IsRaceAnalysisEnabled of
       true ->
-        Races1 = State2#state.races,
-        RaceList1 = dialyzer_races:get_race_list(Races1),
-        RaceListSize1 = dialyzer_races:get_race_list_size(Races1),
+	{RaceList1, RaceListSize1} = get_race_list_and_size(State2),
         EndClause = dialyzer_races:end_clause_new(Arg, cerl:clause_pats(C),
                                                   cerl:clause_guard(C)),
         {[EndClause|ClauseAcc],
@@ -1322,30 +1291,25 @@ handle_clauses([C|Left], Arg, ArgType, OrigArgType,
     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) ->
+handle_clauses([], _Arg, _ArgType, _OrigArgType, State, CaseTypes, _MapIn, Acc,
+	       ClauseAcc) ->
   State1 =
-    case dialyzer_callgraph:get_race_detection(Callgraph) andalso
-         dialyzer_races:get_race_analysis(Races) of
+    case is_race_analysis_enabled(State) of
       true ->
+	{RaceList, RaceListSize} = get_race_list_and_size(State),
         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);
+          [dialyzer_races:end_case_new(ClauseAcc)|RaceList],
+	  RaceListSize + 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) ->
+do_clause(C, Arg, ArgType0, OrigArgType, Map, 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
+    case is_race_analysis_enabled(State) of
       true ->
         state__renew_fun_args(Pats, State);
       false -> State
@@ -3322,6 +3286,14 @@ state__records_only(#state{records = Records}) ->
 %%%
 %%% ===========================================================================
 
+is_race_analysis_enabled(#state{races = Races, callgraph = Callgraph}) ->
+  RaceDetection = dialyzer_callgraph:get_race_detection(Callgraph),
+  RaceAnalysis = dialyzer_races:get_race_analysis(Races),
+  RaceDetection andalso RaceAnalysis.
+
+get_race_list_and_size(#state{races = Races}) ->
+  dialyzer_races:get_race_list_and_size(Races).
+
 renew_race_code(#state{races = Races, callgraph = Callgraph,
 		       warning_mode = WarningMode} = State) ->
   case WarningMode of
@@ -3331,17 +3303,19 @@ renew_race_code(#state{races = Races, callgraph = Callgraph,
       State#state{callgraph = NewCallgraph}
   end.
 
-renew_public_tables([Var], Table, WarningMode, Callgraph) ->
+renew_race_public_tables([Var], #state{races = Races, callgraph = Callgraph,
+				      warning_mode = WarningMode} = State) ->
   case WarningMode of
-    true -> Callgraph;
+    true -> State;
     false ->
+      Table = dialyzer_races:get_new_table(Races),
       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)
+	no_t -> State;
+	_Other ->
+	  VarLabel = get_label(Var),
+	  NewCallgraph =
+	    dialyzer_callgraph:renew_race_public_tables(VarLabel, Callgraph),
+	  State#state{callgraph = NewCallgraph}
       end
   end.
 
diff --git a/lib/dialyzer/src/dialyzer_races.erl b/lib/dialyzer/src/dialyzer_races.erl
index cc635b0eef..89b45990d9 100644
--- a/lib/dialyzer/src/dialyzer_races.erl
+++ b/lib/dialyzer/src/dialyzer_races.erl
@@ -36,6 +36,7 @@
 -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,
+	 get_race_list_and_size/1,
          let_tag_new/2, new/0, put_curr_fun/3, put_fun_args/2,
          put_race_analysis/2, put_race_list/3]).
 
@@ -2434,6 +2435,12 @@ get_race_list(#races{race_list = RaceList}) ->
 get_race_list_size(#races{race_list_size = RaceListSize}) ->
   RaceListSize.
 
+-spec get_race_list_and_size(races()) -> {code(), non_neg_integer()}.
+
+get_race_list_and_size(#races{race_list = RaceList,
+			      race_list_size = RaceListSize}) ->
+  {RaceList, RaceListSize}.
+
 -spec let_tag_new(var_to_map1(), var_to_map1()) -> #let_tag{}.
 
 let_tag_new(Var, Arg) ->
diff --git a/lib/dialyzer/src/dialyzer_succ_typings.erl b/lib/dialyzer/src/dialyzer_succ_typings.erl
index 740081a33f..21cc13d849 100644
--- a/lib/dialyzer/src/dialyzer_succ_typings.erl
+++ b/lib/dialyzer/src/dialyzer_succ_typings.erl
@@ -142,17 +142,14 @@ get_warnings_from_modules([M|Ms], State, DocPlt, Acc) when is_atom(M) ->
   %% Check if there are contracts for functions that do not exist
   Warnings1 = 
     dialyzer_contracts:contracts_without_fun(Contracts, AllFuns, Callgraph),
-  {RawWarnings2, FunTypes, RaceCode, PublicTables, NamedTables} =
-    dialyzer_dataflow:get_warnings(ModCode, Plt, Callgraph, Records, NoWarnUnused),
+  {RawWarnings2, FunTypes} =
+    dialyzer_dataflow:get_warnings(ModCode, Plt, Callgraph,
+				   Records, NoWarnUnused),
   {NewAcc, Warnings2} = postprocess_dataflow_warns(RawWarnings2, State, Acc),
   Attrs = cerl:module_attrs(ModCode),
   Warnings3 = dialyzer_behaviours:check_callbacks(M, Attrs, Plt, Codeserver),
   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,
+  get_warnings_from_modules(Ms, State, NewDocPlt,
 			    [Warnings1, Warnings2, Warnings3|NewAcc]);
 get_warnings_from_modules([], #st{plt = Plt}, DocPlt, Acc) ->
   {lists:flatten(Acc), Plt, DocPlt}.
@@ -195,45 +192,40 @@ refine_succ_typings(ModulePostorder, State) ->
   refine_succ_typings(ModulePostorder, State, []).
 
 refine_succ_typings([M|Rest], State, Fixpoint) ->
+  #st{callgraph = Callgraph, codeserver = CodeServer, plt = PLT} = State,
   Msg = io_lib:format("Dataflow of module: ~w\n", [M]),
   send_log(State#st.parent, Msg),
   ?debug("~s\n", [Msg]),
-  {NewState, FixpointFromScc} = refine_one_module(M, State),
+  {NewCallgraph, FixpointFromScc} =
+    refine_one_module(M, Callgraph, CodeServer, PLT),
   NewFixpoint = ordsets:union(Fixpoint, FixpointFromScc),
-  refine_succ_typings(Rest, NewState, NewFixpoint);
+  refine_succ_typings(Rest, State#st{callgraph = NewCallgraph}, 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
+-spec refine_one_module(module(), dialyzer_callgraph:callgraph(),
+			dialyzer_codeserver:codeserver(), dialyzer_plt:plt()) ->
+        {dialyzer_callgraph:callgraph(), [label()]}. % ordset
 
-refine_one_module(M, State) ->
-  #st{callgraph = Callgraph, codeserver = CodeServer, plt = PLT} = State,
+refine_one_module(M, Callgraph, CodeServer, PLT) ->
   ModCode = dialyzer_codeserver:lookup_mod_code(M, CodeServer),
   AllFuns = collect_fun_info([ModCode]),
   Records = dialyzer_codeserver:lookup_mod_records(M, CodeServer),
-  {NewFunTypes, RaceCode, PublicTables, NamedTables} =
+  {NewFunTypes, NewCallgraph} =
     dialyzer_dataflow:get_fun_types(ModCode, PLT, Callgraph, Records),
-  NewCallgraph =
-    dialyzer_callgraph:renew_race_info(Callgraph, RaceCode, PublicTables,
-                                       NamedTables),
   FunTypes = get_fun_types_from_plt(AllFuns, Callgraph, PLT),
-  State1 = st__renew_state_calls(NewCallgraph, State),
   case reached_fixpoint(FunTypes, NewFunTypes) of
     true ->
-      {State1, ordsets:new()};
+      {NewCallgraph, ordsets:new()};
     {false, NotFixpoint} ->
       ?debug("Not fixpoint\n", []),
-      NewPlt = insert_into_plt(dict:from_list(NotFixpoint), Callgraph, PLT),
-      {State1#st{plt = NewPlt},
-       ordsets:from_list([FunLbl || {FunLbl,_Type} <- NotFixpoint])}
+      insert_into_plt(dict:from_list(NotFixpoint), Callgraph, PLT),
+      {NewCallgraph, ordsets:from_list([FunLbl || {FunLbl,_Type} <- NotFixpoint])}
   end.
 
-st__renew_state_calls(Callgraph, State) ->
-  State#st{callgraph = Callgraph}.
-
 reached_fixpoint(OldTypes, NewTypes) ->
   reached_fixpoint(OldTypes, NewTypes, false).