anchor.diff:  			Arity = refac_syntax:function_arity(T),
   			case has_receive_expr(T) of
   			  {true, Line} ->
  -			      case is_non_tail_recursive_server(FName, Info, T, {ModName, FunName, Arity}, Line, SearchPaths) of
  +			      case is_non_tail_recursive_server(T, {ModName, FunName, Arity}, Line, SearchPaths) of
   				true -> [{ModName, FunName, Arity} | S];
   				_ -> S
   			      end;
  
positive.code: 	_ -> {true, lists:min(LineNums)}
      end.
  
  is_non_tail_recursive_server(FileName, Info, FunDef, {ModName, FunName, Arity}, Line, SearchPaths) ->
      Fun = fun (T, S) ->
  		  case refac_syntax:type(T) of
  		    receive_expr ->
  
negative.code:     CandidateSccs = refac_syntax_lib:fold(Fun, [], FunDef),
      case CandidateSccs of
        [] -> false;
        _ -> lists:any(fun (Scc) -> check_candidate_scc(FunDef, Scc, Line) end, CandidateSccs)
      end.
  
  
  
  check_candidate_scc(FunDef, Scc, Line) ->
      %%InscopeFuns = refac_util:auto_imported_bifs() ++ refac_util:inscope_funs(Info), 
      MFAs = [MFA || {MFA, _} <- Scc],
      DummyExp = refac_syntax:atom(undefined),
      F = fun (T, Acc) ->
  		case refac_syntax:type(T)      %% To think: any other cases here?
  		    of
  		  clause -> Exprs = refac_syntax:clause_body(T),
  			    Acc ++ [Exprs];
  		  application -> Exprs = refac_syntax:application_arguments(T),
  				 Acc ++ [Exprs ++ [DummyExp]];
  		  tuple -> Exprs = refac_syntax:tuple_elements(T),
  			   Acc ++ [Exprs ++ [DummyExp]];
  		  list -> Exprs = refac_syntax:list_prefix(T),
  			  Acc ++ [Exprs ++ [DummyExp]];
  		  list_comp ->
  		      Acc ++ [[T, DummyExp]];
  		  block_expr ->
  		      Exprs = refac_syntax:block_expr_body(T),
  		      Acc ++ [Exprs];
  		  infix_expr ->
  		      Acc ++ [[T, DummyExp]];
  		  prefix_expr ->
  		      Acc ++ [[T, DummyExp]];
  		  _ -> Acc
  		end
  	end,
      F1 = fun (Es) ->
  		 F11 = fun (E) ->
  			       {_, {EndLine, _}} = refac_util:get_range(E),
  			       case EndLine >= Line of
  				 true ->
  				     CalledFuns = wrangler_callgraph_server:called_funs(E),
  				     case lists:subtract(CalledFuns, MFAs) of
  				       CalledFuns -> false;
  				       _ -> true
  				     end;
  				 _ -> false
  			       end
  		       end,
  		 R = [F11(E) || E <- Es],
  		 lists:any(fun (E) -> E == true end, tl(lists:reverse(R)))
  	 end,
      ListOfExpLists = refac_syntax_lib:fold(F, [], FunDef),
      ExpLists1 = lists:map(F1, ListOfExpLists),
      lists:any(fun (E) -> E == true end, ExpLists1).
         
  
  
  