Simplify dialyzer_succ_typings code

2 files changed, 20 insertions, 12 deletions

diff --git a/lib/dialyzer/src/dialyzer_succ_typings.erl b/lib/dialyzer/src/dialyzer_succ_typings.erl
index 4d86bb34a7..3d21452a63 100644
--- a/lib/dialyzer/src/dialyzer_succ_typings.erl
+++ b/lib/dialyzer/src/dialyzer_succ_typings.erl
@@ -330,23 +330,20 @@ analyze_scc(SCC, #st{codeserver = Codeserver} = State) ->
 		|| {_, _, _} = MFA <- SCC],
   Contracts2 = [{MFA, Contract} || {MFA, {ok, Contract}} <- Contracts1],
   Contracts3 = orddict:from_list(Contracts2),
+  NextLabel = dialyzer_codeserver:get_next_core_label(Codeserver),
   {SuccTypes, PltContracts, NotFixpoint} = 
-    find_succ_types_for_scc(SCC_Info, Contracts3, State),
+    find_succ_types_for_scc(SCC_Info, Contracts3, NextLabel, 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) ->
+find_succ_types_for_scc(SCC_Info, Contracts, NextLabel,
+			#st{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),
+					  Callgraph, Plt, PropTypes),
   AllFunSet = sets:from_list([X || {X, _} <- AllFuns]),
   FilteredFunTypes = dict:filter(fun(X, _) ->
 				      sets:is_element(X, AllFunSet) 
diff --git a/lib/dialyzer/src/dialyzer_typesig.erl b/lib/dialyzer/src/dialyzer_typesig.erl
index 4268814859..14ebfc992f 100644
--- a/lib/dialyzer/src/dialyzer_typesig.erl
+++ b/lib/dialyzer/src/dialyzer_typesig.erl
@@ -106,7 +106,9 @@
 		prop_types    = dict:new() :: dict(),
 		records       = dict:new() :: dict(),
 		opaques       = []         :: [erl_types:erl_type()],
-		scc           = []         :: [type_var()]}).
+		scc           = []         :: [type_var()],
+		mfas                       :: [tuple()]
+	       }).
 
 %%-----------------------------------------------------------------------------
 
@@ -646,8 +648,14 @@ get_plt_constr(MFA, Dst, ArgVars, State) ->
   PltRes = dialyzer_plt:lookup(Plt, MFA),
   Opaques = State#state.opaques,
   Module = State#state.module,
+  SCCMFAs = State#state.mfas,
   {FunModule, _, _} = MFA,
-  case dialyzer_plt:lookup_contract(Plt, MFA) of
+  Contract =
+    case lists:member(MFA, SCCMFAs) of
+      true -> none;
+      false -> dialyzer_plt:lookup_contract(Plt, MFA)
+    end,
+  case Contract of
     none ->
       case PltRes of
 	none -> State;
@@ -2078,10 +2086,13 @@ mk_var_no_lit_list(List) ->
 %% ============================================================================
 
 new_state(SCC0, NextLabel, CallGraph, Plt, PropTypes) ->
-  NameMap = dict:from_list([{MFA, Var} || {MFA, {Var, _Fun}, _Rec} <- SCC0]),
+  List = [{MFA, Var} || {MFA, {Var, _Fun}, _Rec} <- SCC0],
+  NameMap = dict:from_list(List),
+  MFAs = [MFA || {MFA, _Var} <- List],
   SCC = [mk_var(Fun) || {_MFA, {_Var, Fun}, _Rec} <- SCC0],
   #state{callgraph = CallGraph, name_map = NameMap, next_label = NextLabel,
-	 prop_types = PropTypes, plt = Plt, scc = ordsets:from_list(SCC)}.
+	 prop_types = PropTypes, plt = Plt, scc = ordsets:from_list(SCC),
+	 mfas = MFAs}.
 
 state__set_rec_dict(State, RecDict) ->
   State#state{records = RecDict}.