anchor.diff:    NameMap = dict:from_list(List),
     MFAs = [MFA || {MFA, _Var} <- List],
     SCC = [mk_var(Fun) || {_MFA, {_Var, Fun}, _Rec} <- SCC0],
  +  SelfRecs = [F || F <- SCC,
  +		   dialyzer_callgraph:is_self_rec(t_var_name(F), CallGraph)],
     #state{callgraph = CallGraph, name_map = NameMap, next_label = NextLabel,
   	 prop_types = PropTypes, plt = Plt, scc = ordsets:from_list(SCC),
  -	 mfas = MFAs}.
  +	 mfas = MFAs, self_recs = ordsets:from_list(SelfRecs)}.
   
   state__set_rec_dict(State, RecDict) ->
     State#state{records = RecDict}.
  
positive.code: 		module                     :: module(),
  		name_map      = dict:new() :: dict(),
  		next_label                 :: label(),
  		non_self_recs = []         :: [label()],
  		plt                        :: dialyzer_plt:plt(),
  		prop_types    = dict:new() :: dict(),
  		records       = dict:new() :: dict(),
  
negative.code: 
  %% The functions here will not be treated as self recursive.
  %% These functions will need to be handled as such manually.
  state__mark_as_non_self_rec(SCC, #state{self_recs = SelfRecs} = State) ->
    %% TODO: Check if the result is always empty and just set it to [] if so.
    State#state{self_recs = ordsets:subtract(SelfRecs, ordsets:from_list(SCC))}.
  
  state__is_self_rec(Fun, #state{self_recs = SelfRecs}) ->
    ordsets:is_element(Fun, SelfRecs).
  
  state__store_funs(Vars0, Funs0, #state{fun_map = Map} = State) ->
    debug_make_name_map(Vars0, Funs0),
  