dialyzer: Do not keep the code server's type info on the heap

The table used during translation of forms to types used to be a
dictionary of the type info (-type(), -opaque(), and -record()) for
all modules. Now it is reduced to the modules that are needed to
handle references to types in other modules.

The PLT:s type info is still kept on the heap.

5 files changed, 151 insertions, 108 deletions

diff --git a/lib/dialyzer/src/dialyzer_analysis_callgraph.erl b/lib/dialyzer/src/dialyzer_analysis_callgraph.erl
index ae1e4d8c38..a3bb2b858d 100644
--- a/lib/dialyzer/src/dialyzer_analysis_callgraph.erl
+++ b/lib/dialyzer/src/dialyzer_analysis_callgraph.erl
@@ -114,7 +114,6 @@ loop(#server_state{parent = Parent} = State,
 %% The Analysis
 %%--------------------------------------------------------------------
 
-%% Calls to erlang:garbage_collect() help to reduce the heap size.
 analysis_start(Parent, Analysis, LegalWarnings) ->
   CServer = dialyzer_codeserver:new(),
   Plt = Analysis#analysis.plt,
@@ -136,11 +135,9 @@ analysis_start(Parent, Analysis, LegalWarnings) ->
   %% Remote type postprocessing
   NewCServer =
     try
-      NewRecords = dialyzer_codeserver:get_temp_records(TmpCServer0),
+      TmpCServer1 = dialyzer_utils:merge_types(TmpCServer0, Plt),
       NewExpTypes = dialyzer_codeserver:get_temp_exported_types(TmpCServer0),
-      OldRecords = dialyzer_plt:get_types(Plt),
       OldExpTypes0 = dialyzer_plt:get_exported_types(Plt),
-      MergedRecords = dialyzer_utils:merge_records(NewRecords, OldRecords),
       RemMods =
         [case Analysis#analysis.start_from of
            byte_code -> list_to_atom(filename:basename(F, ".beam"));
@@ -148,10 +145,9 @@ analysis_start(Parent, Analysis, LegalWarnings) ->
          end || F <- Files],
       OldExpTypes1 = dialyzer_utils:sets_filter(RemMods, OldExpTypes0),
       MergedExpTypes = sets:union(NewExpTypes, OldExpTypes1),
-      TmpCServer1 = dialyzer_codeserver:set_temp_records(MergedRecords, TmpCServer0),
       TmpCServer2 =
         dialyzer_codeserver:finalize_exported_types(MergedExpTypes, TmpCServer1),
-      erlang:garbage_collect(),
+      erlang:garbage_collect(), % reduce heap size
       ?timing(State#analysis_state.timing_server, "remote",
               contracts_and_records(TmpCServer2))
     catch
@@ -200,11 +196,9 @@ contracts_and_records(CodeServer) ->
 contrs_and_recs(TmpCServer2) ->
   fun() ->
       Parent = receive {Pid, go} -> Pid end,
-      {TmpCServer3, RecordDict} =
-        dialyzer_utils:process_record_remote_types(TmpCServer2),
+      TmpCServer3 = dialyzer_utils:process_record_remote_types(TmpCServer2),
       TmpServer4 =
-        dialyzer_contracts:process_contract_remote_types(TmpCServer3,
-                                                         RecordDict),
+        dialyzer_contracts:process_contract_remote_types(TmpCServer3),
       dialyzer_codeserver:give_away(TmpServer4, Parent),
       exit(TmpServer4)
   end.
diff --git a/lib/dialyzer/src/dialyzer_codeserver.erl b/lib/dialyzer/src/dialyzer_codeserver.erl
index f53c713bfe..aa779e0e39 100644
--- a/lib/dialyzer/src/dialyzer_codeserver.erl
+++ b/lib/dialyzer/src/dialyzer_codeserver.erl
@@ -26,18 +26,20 @@
          give_away/2,
 	 finalize_contracts/1,
          finalize_exported_types/2,
-	 finalize_records/2,
+	 finalize_records/1,
 	 get_contracts/1,
 	 get_callbacks/1,
          get_exported_types/1,
 	 get_exports/1,
 	 get_records/1,
+	 get_records_table/1,
 	 get_next_core_label/1,
          get_temp_contracts/2,
-         contracts_modules/1,
+         all_temp_modules/1,
          store_contracts/4,
          get_temp_exported_types/1,
-	 get_temp_records/1,
+         get_temp_records_table/1,
+	 lookup_temp_mod_records/2,
 	 insert/3,
 	 insert_exports/2,
          insert_temp_exported_types/2,
@@ -269,6 +271,11 @@ lookup_mod_records(Mod, #codeserver{records = RecDict}) when is_atom(Mod) ->
     {ok, Map} -> Map
   end.
 
+-spec get_records_table(codeserver()) -> map_ets().
+
+get_records_table(#codeserver{records = RecDict}) ->
+  RecDict.
+
 -spec get_records(codeserver()) -> mod_records().
 
 get_records(#codeserver{records = RecDict}) ->
@@ -283,10 +290,18 @@ store_temp_records(Mod, Map, #codeserver{temp_records = TempRecDict} = CS)
     false -> CS#codeserver{temp_records = ets_map_store(Mod, Map, TempRecDict)}
   end.
 
--spec get_temp_records(codeserver()) -> mod_records().
+-spec get_temp_records_table(codeserver()) -> map_ets().
+
+get_temp_records_table(#codeserver{temp_records = TempRecDict}) ->
+  TempRecDict.
+
+-spec lookup_temp_mod_records(module(), codeserver()) -> types().
 
-get_temp_records(#codeserver{temp_records = TempRecDict}) ->
-  ets_dict_to_dict(TempRecDict).
+lookup_temp_mod_records(Mod, #codeserver{temp_records = TempRecDict}) ->
+  case ets_dict_find(Mod, TempRecDict) of
+    error -> maps:new();
+    {ok, Map} -> Map
+  end.
 
 -spec set_temp_records(mod_records(), codeserver()) -> codeserver().
 
@@ -296,13 +311,13 @@ set_temp_records(Dict, CS) ->
   true = ets_dict_store_dict(Dict, TempRecords),
   CS#codeserver{temp_records = TempRecords}.
 
--spec finalize_records(mod_records(), codeserver()) -> codeserver().
+-spec finalize_records(codeserver()) -> codeserver().
 
-finalize_records(Dict, #codeserver{temp_records = TmpRecords,
-                                   records = Records} = CS) ->
-  true = ets:delete(TmpRecords),
-  true = ets_dict_store_dict(Dict, Records),
-  CS#codeserver{temp_records = clean}.
+finalize_records(#codeserver{temp_records = TmpRecords,
+                             records = Records} = CS) ->
+  true = ets:delete(Records),
+  ets:rename(TmpRecords, dialyzer_codeserver_records),
+  CS#codeserver{temp_records = clean, records = TmpRecords}.
 
 -spec lookup_mod_contracts(atom(), codeserver()) -> contracts().
 
@@ -348,12 +363,14 @@ store_temp_contracts(Mod, SpecMap, CallbackMap,
 		     #codeserver{temp_contracts = Cn,
 				 temp_callbacks = Cb} = CS)
   when is_atom(Mod) ->
+  %% Make sure Mod is stored even if there are not callbacks or
+  %% contracts.
   CS1 = CS#codeserver{temp_contracts = ets_map_store(Mod, SpecMap, Cn)},
   CS1#codeserver{temp_callbacks = ets_map_store(Mod, CallbackMap, Cb)}.
 
--spec contracts_modules(codeserver()) -> [module()].
+-spec all_temp_modules(codeserver()) -> [module()].
 
-contracts_modules(#codeserver{temp_contracts = TempContTable}) ->
+all_temp_modules(#codeserver{temp_contracts = TempContTable}) ->
   ets:select(TempContTable, [{{'$1', '$2'}, [], ['$1']}]).
 
 -spec store_contracts(module(), contracts(), contracts(), codeserver()) ->
diff --git a/lib/dialyzer/src/dialyzer_contracts.erl b/lib/dialyzer/src/dialyzer_contracts.erl
index 2078e58ce8..45f9099f4e 100644
--- a/lib/dialyzer/src/dialyzer_contracts.erl
+++ b/lib/dialyzer/src/dialyzer_contracts.erl
@@ -24,7 +24,7 @@
 	 get_contract_return/2,
 	 %% get_contract_signature/1,
 	 is_overloaded/1,
-	 process_contract_remote_types/2,
+	 process_contract_remote_types/1,
 	 store_tmp_contract/5]).
 
 -export_type([file_contract/0, plt_contracts/0]).
@@ -139,18 +139,18 @@ sequence([], _Delimiter) -> "";
 sequence([H], _Delimiter) -> H;
 sequence([H|T], Delimiter) -> H ++ Delimiter ++ sequence(T, Delimiter).
 
--spec process_contract_remote_types(dialyzer_codeserver:codeserver(),
-                                    erl_types:mod_records()) ->
+-spec process_contract_remote_types(dialyzer_codeserver:codeserver()) ->
                                        dialyzer_codeserver:codeserver().
 
-process_contract_remote_types(CodeServer, RecordDict) ->
-  Mods = dialyzer_codeserver:contracts_modules(CodeServer),
+process_contract_remote_types(CodeServer) ->
+  Mods = dialyzer_codeserver:all_temp_modules(CodeServer),
+  RecordTable = dialyzer_codeserver:get_records_table(CodeServer),
   ExpTypes = dialyzer_codeserver:get_exported_types(CodeServer),
   ContractFun =
     fun({{_M, _F, _A}=MFA, {File, TmpContract, Xtra}}, C0) ->
         #tmp_contract{contract_funs = CFuns, forms = Forms} = TmpContract,
         {NewCs, C2} = lists:mapfoldl(fun(CFun, C1) ->
-                                         CFun(ExpTypes, RecordDict, C1)
+                                         CFun(ExpTypes, RecordTable, C1)
                                      end, C0, CFuns),
         Args = general_domain(NewCs),
         Contract = #contract{contracts = NewCs, args = Args, forms = Forms},
@@ -451,10 +451,10 @@ contract_from_form(Forms, MFA, RecDict, FileLine) ->
 contract_from_form([{type, _, 'fun', [_, _]} = Form | Left], MFA, RecDict,
 		   FileLine, TypeAcc, FormAcc) ->
   TypeFun =
-    fun(ExpTypes, AllRecords, Cache) ->
+    fun(ExpTypes, RecordTable, Cache) ->
 	{NewType, NewCache} =
 	  try
-            from_form_with_check(Form, ExpTypes, MFA, AllRecords, Cache)
+            from_form_with_check(Form, ExpTypes, MFA, RecordTable, Cache)
 	  catch
 	    throw:{error, Msg} ->
 	      {File, Line} = FileLine,
@@ -472,12 +472,12 @@ contract_from_form([{type, _L1, bounded_fun,
 		     [{type, _L2, 'fun', [_, _]} = Form, Constr]}| Left],
 		   MFA, RecDict, FileLine, TypeAcc, FormAcc) ->
   TypeFun =
-    fun(ExpTypes, AllRecords, Cache) ->
+    fun(ExpTypes, RecordTable, Cache) ->
 	{Constr1, VarTable, Cache1} =
-	  process_constraints(Constr, MFA, RecDict, ExpTypes, AllRecords,
+	  process_constraints(Constr, MFA, RecDict, ExpTypes, RecordTable,
                               Cache),
         {NewType, NewCache} =
-          from_form_with_check(Form, ExpTypes, MFA, AllRecords,
+          from_form_with_check(Form, ExpTypes, MFA, RecordTable,
                                VarTable, Cache1),
         NewTypeNoVars = erl_types:subst_all_vars_to_any(NewType),
 	{{NewTypeNoVars, Constr1}, NewCache}
@@ -488,28 +488,28 @@ contract_from_form([{type, _L1, bounded_fun,
 contract_from_form([], _MFA, _RecDict, _FileLine, TypeAcc, FormAcc) ->
   {lists:reverse(TypeAcc), lists:reverse(FormAcc)}.
 
-process_constraints(Constrs, MFA, RecDict, ExpTypes, AllRecords, Cache) ->
+process_constraints(Constrs, MFA, RecDict, ExpTypes, RecordTable, Cache) ->
   {Init0, NewCache} = initialize_constraints(Constrs, MFA, RecDict, ExpTypes,
-                                             AllRecords, Cache),
+                                             RecordTable, Cache),
   Init = remove_cycles(Init0),
-  constraints_fixpoint(Init, MFA, RecDict, ExpTypes, AllRecords, NewCache).
+  constraints_fixpoint(Init, MFA, RecDict, ExpTypes, RecordTable, NewCache).
 
-initialize_constraints(Constrs, MFA, RecDict, ExpTypes, AllRecords, Cache) ->
-  initialize_constraints(Constrs, MFA, RecDict, ExpTypes, AllRecords,
+initialize_constraints(Constrs, MFA, RecDict, ExpTypes, RecordTable, Cache) ->
+  initialize_constraints(Constrs, MFA, RecDict, ExpTypes, RecordTable,
                          Cache, []).
 
-initialize_constraints([], _MFA, _RecDict, _ExpTypes, _AllRecords,
+initialize_constraints([], _MFA, _RecDict, _ExpTypes, _RecordTable,
                        Cache, Acc) ->
   {Acc, Cache};
-initialize_constraints([Constr|Rest], MFA, RecDict, ExpTypes, AllRecords,
+initialize_constraints([Constr|Rest], MFA, RecDict, ExpTypes, RecordTable,
                        Cache, Acc) ->
   case Constr of
     {type, _, constraint, [{atom, _, is_subtype}, [Type1, Type2]]} ->
       VarTable = erl_types:var_table__new(),
       {T1, NewCache} =
-        final_form(Type1, ExpTypes, MFA, AllRecords, VarTable, Cache),
+        final_form(Type1, ExpTypes, MFA, RecordTable, VarTable, Cache),
       Entry = {T1, Type2},
-      initialize_constraints(Rest, MFA, RecDict, ExpTypes, AllRecords,
+      initialize_constraints(Rest, MFA, RecDict, ExpTypes, RecordTable,
                              NewCache, [Entry|Acc]);
     {type, _, constraint, [{atom,_,Name}, List]} ->
       N = length(List),
@@ -517,18 +517,18 @@ initialize_constraints([Constr|Rest], MFA, RecDict, ExpTypes, AllRecords,
 	     io_lib:format("Unsupported type guard ~w/~w\n", [Name, N])})
   end.
 
-constraints_fixpoint(Constrs, MFA, RecDict, ExpTypes, AllRecords, Cache) ->
+constraints_fixpoint(Constrs, MFA, RecDict, ExpTypes, RecordTable, Cache) ->
   VarTable = erl_types:var_table__new(),
   {VarTab, NewCache} =
-    constraints_to_dict(Constrs, MFA, RecDict, ExpTypes, AllRecords,
+    constraints_to_dict(Constrs, MFA, RecDict, ExpTypes, RecordTable,
                         VarTable, Cache),
   constraints_fixpoint(VarTab, MFA, Constrs, RecDict, ExpTypes,
-                       AllRecords, NewCache).
+                       RecordTable, NewCache).
 
 constraints_fixpoint(OldVarTab, MFA, Constrs, RecDict, ExpTypes,
-                     AllRecords, Cache) ->
+                     RecordTable, Cache) ->
   {NewVarTab, NewCache} =
-    constraints_to_dict(Constrs, MFA, RecDict, ExpTypes, AllRecords,
+    constraints_to_dict(Constrs, MFA, RecDict, ExpTypes, RecordTable,
                         OldVarTab, Cache),
   case NewVarTab of
     OldVarTab ->
@@ -540,38 +540,38 @@ constraints_fixpoint(OldVarTab, MFA, Constrs, RecDict, ExpTypes,
       {FinalConstrs, NewVarTab, NewCache};
     _Other ->
       constraints_fixpoint(NewVarTab, MFA, Constrs, RecDict, ExpTypes,
-                           AllRecords, NewCache)
+                           RecordTable, NewCache)
   end.
 
-final_form(Form, ExpTypes, MFA, AllRecords, VarTable, Cache) ->
-  from_form_with_check(Form, ExpTypes, MFA, AllRecords, VarTable, Cache).
+final_form(Form, ExpTypes, MFA, RecordTable, VarTable, Cache) ->
+  from_form_with_check(Form, ExpTypes, MFA, RecordTable, VarTable, Cache).
 
-from_form_with_check(Form, ExpTypes, MFA, AllRecords, Cache) ->
+from_form_with_check(Form, ExpTypes, MFA, RecordTable, Cache) ->
   VarTable = erl_types:var_table__new(),
-  from_form_with_check(Form, ExpTypes, MFA, AllRecords, VarTable, Cache).
+  from_form_with_check(Form, ExpTypes, MFA, RecordTable, VarTable, Cache).
 
-from_form_with_check(Form, ExpTypes, MFA, AllRecords, VarTable, Cache) ->
+from_form_with_check(Form, ExpTypes, MFA, RecordTable, VarTable, Cache) ->
   Site = {spec, MFA},
-  C1 = erl_types:t_check_record_fields(Form, ExpTypes, Site, AllRecords,
+  C1 = erl_types:t_check_record_fields(Form, ExpTypes, Site, RecordTable,
                                        VarTable, Cache),
-  erl_types:t_from_form(Form, ExpTypes, Site, AllRecords, VarTable, C1).
+  erl_types:t_from_form(Form, ExpTypes, Site, RecordTable, VarTable, C1).
 
-constraints_to_dict(Constrs, MFA, RecDict, ExpTypes, AllRecords,
+constraints_to_dict(Constrs, MFA, RecDict, ExpTypes, RecordTable,
                     VarTab, Cache) ->
   {Subtypes, NewCache} =
-    constraints_to_subs(Constrs, MFA, RecDict, ExpTypes, AllRecords,
+    constraints_to_subs(Constrs, MFA, RecDict, ExpTypes, RecordTable,
                         VarTab, Cache, []),
   {insert_constraints(Subtypes), NewCache}.
 
-constraints_to_subs([], _MFA, _RecDict, _ExpTypes, _AllRecords,
+constraints_to_subs([], _MFA, _RecDict, _ExpTypes, _RecordTable,
                     _VarTab, Cache, Acc) ->
   {Acc, Cache};
-constraints_to_subs([{T1, Form2}|Rest], MFA, RecDict, ExpTypes, AllRecords,
+constraints_to_subs([{T1, Form2}|Rest], MFA, RecDict, ExpTypes, RecordTable,
                     VarTab, Cache, Acc) ->
   {T2, NewCache} =
-    final_form(Form2, ExpTypes, MFA, AllRecords, VarTab, Cache),
+    final_form(Form2, ExpTypes, MFA, RecordTable, VarTab, Cache),
   NewAcc = [{subtype, T1, T2}|Acc],
-  constraints_to_subs(Rest, MFA, RecDict, ExpTypes, AllRecords,
+  constraints_to_subs(Rest, MFA, RecDict, ExpTypes, RecordTable,
                       VarTab, NewCache, NewAcc).
 
 %% Replaces variables with '_' when necessary to break up cycles among
diff --git a/lib/dialyzer/src/dialyzer_plt.erl b/lib/dialyzer/src/dialyzer_plt.erl
index 37c22fef48..1bf30cf83b 100644
--- a/lib/dialyzer/src/dialyzer_plt.erl
+++ b/lib/dialyzer/src/dialyzer_plt.erl
@@ -32,6 +32,7 @@
 	 from_file/1,
 	 get_default_plt/0,
 	 get_types/1,
+         get_module_types/2,
          get_exported_types/1,
 	 %% insert/3,
 	 insert_list/2,
@@ -199,6 +200,12 @@ insert_exported_types(PLT, Set) ->
 get_types(#plt{types = Types}) ->
   Types.
 
+-spec get_module_types(plt(), atom()) ->
+                          'none' | {'value', erl_types:type_table()}.
+
+get_module_types(#plt{types = Types}, M) when is_atom(M) ->
+  table_lookup(Types, M).
+
 -spec get_exported_types(plt()) -> sets:set().
 
 get_exported_types(#plt{exported_types = ExpTypes}) ->
diff --git a/lib/dialyzer/src/dialyzer_utils.erl b/lib/dialyzer/src/dialyzer_utils.erl
index 432d27571b..9eaf95c1a2 100644
--- a/lib/dialyzer/src/dialyzer_utils.erl
+++ b/lib/dialyzer/src/dialyzer_utils.erl
@@ -37,9 +37,9 @@
          get_fun_meta_info/3,
          is_suppressed_fun/2,
          is_suppressed_tag/3,
-	 merge_records/2,
 	 pp_hook/0,
 	 process_record_remote_types/1,
+         merge_types/2,
          sets_filter/2,
 	 src_compiler_opts/0,
 	 refold_pattern/1,
@@ -188,7 +188,6 @@ get_core_from_abstract_code(AbstrCode, Opts) ->
 %% ============================================================================
 
 -type type_table() :: erl_types:type_table().
--type mod_records()   :: dict:dict(module(), type_table()).
 
 -spec get_record_and_type_info(abstract_code()) ->
 	{'ok', type_table()} | {'error', string()}.
@@ -289,18 +288,18 @@ get_record_fields([{record_field, _Line, Name, _Init}|Left], RecDict, Acc) ->
 get_record_fields([], _RecDict, Acc) ->
   lists:reverse(Acc).
 
--spec process_record_remote_types(codeserver()) ->
-                                     {codeserver(), mod_records()}.
+-spec process_record_remote_types(codeserver()) -> codeserver().
 
 %% The field types are cached. Used during analysis when handling records.
 process_record_remote_types(CServer) ->
-  TempRecords = dialyzer_codeserver:get_temp_records(CServer),
   ExpTypes = dialyzer_codeserver:get_exported_types(CServer),
-  TempRecords1 = process_opaque_types0(TempRecords, ExpTypes),
-  %% A cache (not the field type cache) is used for speeding things up a bit.
+  Mods = dialyzer_codeserver:all_temp_modules(CServer),
+  process_opaque_types0(Mods, CServer, ExpTypes),
   VarTable = erl_types:var_table__new(),
+  RecordTable = dialyzer_codeserver:get_temp_records_table(CServer),
   ModuleFun =
-    fun({Module, Record}) ->
+    fun(Module) ->
+        RecordMap = dialyzer_codeserver:lookup_temp_mod_records(Module, CServer),
         RecordFun =
           fun({Key, Value}, C2) ->
               case Key of
@@ -313,7 +312,7 @@ process_record_remote_types(CServer) ->
                                              {FieldT, C6} =
                                                erl_types:t_from_form
                                                  (Field, ExpTypes, Site,
-                                                  TempRecords1, VarTable,
+                                                  RecordTable, VarTable,
                                                   C5),
                                           {{FieldName, Field, FieldT}, C6}
                                       end, C4, Fields),
@@ -328,30 +327,29 @@ process_record_remote_types(CServer) ->
           end,
         Cache = erl_types:cache__new(),
         {RecordList, _NewCache} =
-          lists:mapfoldl(RecordFun, Cache, maps:to_list(Record)),
-        {Module, maps:from_list(RecordList)}
+          lists:mapfoldl(RecordFun, Cache, maps:to_list(RecordMap)),
+        dialyzer_codeserver:store_temp_records(Module,
+                                               maps:from_list(RecordList),
+                                               CServer)
     end,
-  NewRecordsList = lists:map(ModuleFun, dict:to_list(TempRecords1)),
-  NewRecords = dict:from_list(NewRecordsList),
-  check_record_fields(NewRecords, ExpTypes),
-  {dialyzer_codeserver:finalize_records(NewRecords, CServer), NewRecords}.
+  lists:foreach(ModuleFun, Mods),
+  check_record_fields(Mods, CServer, ExpTypes),
+  dialyzer_codeserver:finalize_records(CServer).
 
 %% erl_types:t_from_form() substitutes the declaration of opaque types
 %% for the expanded type in some cases. To make sure the initial type,
 %% any(), is not used, the expansion is done twice.
 %% XXX: Recursive opaque types are not handled well.
-process_opaque_types0(TempRecords0, TempExpTypes) ->
-  Cache = erl_types:cache__new(),
-  {TempRecords1, Cache1} =
-    process_opaque_types(TempRecords0, TempExpTypes, Cache),
-  {TempRecords, _NewCache} =
-    process_opaque_types(TempRecords1, TempExpTypes, Cache1),
-  TempRecords.
-
-process_opaque_types(TempRecords, TempExpTypes, Cache) ->
+process_opaque_types0(AllModules, CServer, TempExpTypes) ->
+  process_opaque_types(AllModules, CServer, TempExpTypes),
+  process_opaque_types(AllModules, CServer, TempExpTypes).
+
+process_opaque_types(AllModules, CServer, TempExpTypes) ->
   VarTable = erl_types:var_table__new(),
+  RecordTable = dialyzer_codeserver:get_temp_records_table(CServer),
   ModuleFun =
-    fun({Module, Record}, C0) ->
+    fun(Module) ->
+        RecordMap = dialyzer_codeserver:lookup_temp_mod_records(Module, CServer),
         RecordFun =
           fun({Key, Value}, C2) ->
               case Key of
@@ -360,32 +358,32 @@ process_opaque_types(TempRecords, TempExpTypes, Cache) ->
                   Site = {type, {Module, Name, NArgs}},
                   {Type, C3} =
                     erl_types:t_from_form(Form, TempExpTypes, Site,
-                                          TempRecords, VarTable, C2),
+                                          RecordTable, VarTable, C2),
                   {{Key, {F, Type}}, C3};
                 _Other -> {{Key, Value}, C2}
               end
           end,
-        {RecordList, C1} =
-          lists:mapfoldl(RecordFun, C0, maps:to_list(Record)),
-        {{Module, maps:from_list(RecordList)}, C1}
-        %% dict:map(RecordFun, Record)
+        C0 = erl_types:cache__new(),
+        {RecordList, _NewCache} =
+          lists:mapfoldl(RecordFun, C0, maps:to_list(RecordMap)),
+        dialyzer_codeserver:store_temp_records(Module,
+                                               maps:from_list(RecordList),
+                                               CServer)
     end,
-  {TempRecordList, NewCache} =
-    lists:mapfoldl(ModuleFun, Cache, dict:to_list(TempRecords)),
-  {dict:from_list(TempRecordList), NewCache}.
-  %% dict:map(ModuleFun, TempRecords).
+  lists:foreach(ModuleFun, AllModules).
 
-check_record_fields(Records, TempExpTypes) ->
-  Cache = erl_types:cache__new(),
+check_record_fields(AllModules, CServer, TempExpTypes) ->
   VarTable = erl_types:var_table__new(),
+  RecordTable = dialyzer_codeserver:get_temp_records_table(CServer),
   CheckFun =
-    fun({Module, Element}, C0) ->
+    fun(Module) ->
         CheckForm = fun(Form, Site, C1) ->
                         erl_types:t_check_record_fields(Form, TempExpTypes,
-                                                        Site, Records,
+                                                        Site, RecordTable,
                                                         VarTable, C1)
                   end,
-        ElemFun =
+        RecordMap = dialyzer_codeserver:lookup_temp_mod_records(Module, CServer),
+        RecordFun =
           fun({Key, Value}, C2) ->
               case Key of
                 {record, Name} ->
@@ -406,10 +404,10 @@ check_record_fields(Records, TempExpTypes) ->
                   msg_with_position(Fun, FileLine)
               end
           end,
-        lists:foldl(ElemFun, C0, maps:to_list(Element))
+        C0 = erl_types:cache__new(),
+        _ = lists:foldl(RecordFun, C0, maps:to_list(RecordMap))
     end,
-  _NewCache = lists:foldl(CheckFun, Cache, dict:to_list(Records)),
-  ok.
+  lists:foreach(CheckFun, AllModules).
 
 msg_with_position(Fun, FileLine) ->
   try Fun()
@@ -421,10 +419,37 @@ msg_with_position(Fun, FileLine) ->
       throw({error, NewMsg})
   end.
 
--spec merge_records(mod_records(), mod_records()) -> mod_records().
+-spec merge_types(codeserver(), dialyzer_plt:plt()) -> codeserver().
 
-merge_records(NewRecords, OldRecords) ->
-  dict:merge(fun(_Key, NewVal, _OldVal) -> NewVal end, NewRecords, OldRecords).
+merge_types(CServer, Plt) ->
+  AllNewModules = dialyzer_codeserver:all_temp_modules(CServer),
+  AllNewModulesSet = sets:from_list(AllNewModules),
+  AllOldModulesSet = dialyzer_plt:all_modules(Plt),
+  AllModulesSet = sets:union(AllNewModulesSet, AllOldModulesSet),
+  ModuleFun =
+    fun(Module) ->
+        KeepOldFun =
+          fun() ->
+              case dialyzer_plt:get_module_types(Plt, Module) of
+                none -> no;
+                {value, OldRecords} ->
+                  case sets:is_element(Module, AllNewModulesSet) of
+                    true -> no;
+                    false -> {yes, OldRecords}
+                  end
+              end
+          end,
+        Records =
+          case KeepOldFun() of
+            no ->
+              dialyzer_codeserver:lookup_temp_mod_records(Module, CServer);
+            {yes, OldRecords} ->
+              OldRecords
+          end,
+        dialyzer_codeserver:store_temp_records(Module, Records, CServer)
+    end,
+  lists:foreach(ModuleFun, sets:to_list(AllModulesSet)),
+  CServer.
 
 %% ============================================================================
 %%