dialyzer: Use less memory for the PLT when analyzing

The two tables for (record) types and exported types are no longer
kept in memory (by the PLT) when analyzing, which reduces memory
consumption.

A first step towards removing (or replacing) the #plt{} record.

1 files changed, 33 insertions, 35 deletions

diff --git a/lib/dialyzer/src/dialyzer_codeserver.erl b/lib/dialyzer/src/dialyzer_codeserver.erl
index e15569388e..a1a7370eff 100644
--- a/lib/dialyzer/src/dialyzer_codeserver.erl
+++ b/lib/dialyzer/src/dialyzer_codeserver.erl
@@ -30,9 +30,10 @@
 	 get_contracts/1,
 	 get_callbacks/1,
          get_exported_types/1,
+         extract_exported_types/1,
 	 get_exports/1,
-	 get_records/1,
 	 get_records_table/1,
+         extract_records/1,
 	 get_next_core_label/1,
          get_temp_contracts/2,
          all_temp_modules/1,
@@ -54,7 +55,6 @@
          lookup_meta_info/2,
 	 new/0,
 	 set_next_core_label/2,
-	 set_temp_records/2,
 	 store_temp_records/3,
          translate_fake_file/3]).
 
@@ -69,7 +69,6 @@
 -type  set_ets() :: ets:tid().
 
 -type types()         :: erl_types:type_table().
--type mod_records()   :: erl_types:mod_records().
 
 -type contracts()     :: #{mfa() => dialyzer_contracts:file_contract()}.
 
@@ -81,8 +80,8 @@
 
 -record(codeserver, {next_core_label = 0 :: label(),
 		     code		 :: dict_ets(),
-                     exported_types      :: set_ets(), % set(mfa())
-		     records             :: map_ets(),
+                     exported_types      :: 'clean' | set_ets(), % set(mfa())
+		     records             :: 'clean' | map_ets(),
 		     contracts           :: map_ets(),
 		     callbacks           :: map_ets(),
                      fun_meta_info       :: dict_ets(), % {mfa(), meta_info()}
@@ -108,9 +107,6 @@ ets_map_store(Key, Element, Table) ->
   true = ets:insert(Table, {Key, Element}),
   Table.
 
-ets_dict_store_dict(Dict, Table) ->
-  true = ets:insert(Table, dict:to_list(Dict)).
-
 ets_dict_to_dict(Table) ->
   Fold = fun({Key,Value}, Dict) -> dict:store(Key, Value, Dict) end,
   ets:foldl(Fold, dict:new(), Table).
@@ -165,11 +161,8 @@ new() ->
 
 -spec delete(codeserver()) -> 'ok'.
 
-delete(#codeserver{code = Code, exported_types = ExportedTypes,
-		   records = Records, contracts = Contracts,
-		   callbacks = Callbacks}) ->
-  lists:foreach(fun ets:delete/1,
-		[Code, ExportedTypes, Records, Contracts, Callbacks]).
+delete(CServer) ->
+  lists:foreach(fun(Table) -> true = ets:delete(Table) end, tables(CServer)).
 
 -spec insert(atom(), cerl:c_module(), codeserver()) -> codeserver().
 
@@ -223,6 +216,11 @@ is_exported(MFA, #codeserver{exports = Exports}) ->
 get_exported_types(#codeserver{exported_types = ExpTypes}) ->
   ets_set_to_set(ExpTypes).
 
+-spec extract_exported_types(codeserver()) -> {codeserver(), set_ets()}.
+
+extract_exported_types(#codeserver{exported_types = ExpTypes} = CS) ->
+  {CS#codeserver{exported_types = 'clean'}, ExpTypes}.
+
 -spec get_exports(codeserver()) -> sets:set(mfa()).
 
 get_exports(#codeserver{exports = Exports}) ->
@@ -275,10 +273,10 @@ lookup_mod_records(Mod, #codeserver{records = RecDict}) when is_atom(Mod) ->
 get_records_table(#codeserver{records = RecDict}) ->
   RecDict.
 
--spec get_records(codeserver()) -> mod_records().
+-spec extract_records(codeserver()) -> {codeserver(), map_ets()}.
 
-get_records(#codeserver{records = RecDict}) ->
-  ets_dict_to_dict(RecDict).
+extract_records(#codeserver{records = RecDict} = CS) ->
+  {CS#codeserver{records = clean}, RecDict}.
 
 -spec store_temp_records(module(), types(), codeserver()) -> codeserver().
 
@@ -302,14 +300,6 @@ lookup_temp_mod_records(Mod, #codeserver{temp_records = TempRecDict}) ->
     {ok, Map} -> Map
   end.
 
--spec set_temp_records(mod_records(), codeserver()) -> codeserver().
-
-set_temp_records(Dict, CS) ->
-  true = ets:delete(CS#codeserver.temp_records),
-  TempRecords = ets:new(dialyzer_codeserver_temp_records,[]),
-  true = ets_dict_store_dict(Dict, TempRecords),
-  CS#codeserver{temp_records = TempRecords}.
-
 -spec finalize_records(codeserver()) -> codeserver().
 
 finalize_records(#codeserver{temp_records = TmpRecords,
@@ -399,17 +389,25 @@ get_temp_contracts(Mod, #codeserver{temp_contracts = TempContDict,
 
 -spec give_away(codeserver(), pid()) -> 'ok'.
 
-give_away(#codeserver{temp_records = TempRecords,
-                      temp_contracts = TempContracts,
-                      temp_callbacks = TempCallbacks,
-                      records = Records,
-                      contracts = Contracts,
-                      callbacks = Callbacks}, Pid) ->
-  _ = [true = ets:give_away(Table, Pid, any) ||
-        Table <- [TempRecords, TempContracts, TempCallbacks,
-                  Records, Contracts, Callbacks],
-        Table =/= clean],
-  ok.
+give_away(CServer, Pid) ->
+  lists:foreach(fun(Table) -> true = ets:give_away(Table, Pid, any)
+                end, tables(CServer)).
+
+tables(#codeserver{code = Code,
+                   fun_meta_info = FunMetaInfo,
+                   exports = Exports,
+                   temp_exported_types = TempExpTypes,
+                   temp_records = TempRecords,
+                   temp_contracts = TempContracts,
+                   temp_callbacks = TempCallbacks,
+                   exported_types = ExportedTypes,
+                   records = Records,
+                   contracts = Contracts,
+                   callbacks = Callbacks}) ->
+  [Table ||  Table <- [Code, FunMetaInfo, Exports, TempExpTypes,
+                       TempRecords, TempContracts, TempCallbacks,
+                       ExportedTypes, Records, Contracts, Callbacks],
+             Table =/= clean].
 
 -spec finalize_contracts(codeserver()) -> codeserver().