anchor.diff:  	  end,
       refac_syntax_lib:fold(Fun, {[], []}, AnnAST).
   
  -
   collect_apps(FileName, Node, {M, F, A}) ->
       Fun = fun (T, {S1,S2}) ->
  -		case refac_syntax:type(T) of
  -		    application ->
  -			Ann = refac_syntax:get_ann(refac_syntax:application_operator(T)),
  -			Args = refac_syntax:application_arguments(T),
  -			case lists:keysearch(fun_def, 1, Ann) of 
  -			    {value, {fun_def, {M, F, A, _, _}}}  ->
  -				{[true|S1], S2};
  -			    {value, {fun_def, {erlang, apply, 3, _, _}}} ->
  -				[ModName,FunName, Arity] = Args, 
  -				handle_special_funs(FileName, T,{ModName, FunName, Arity},{M, F, A}, S1, S2);
  -			    {value, {fun_def, {erlang, spawn, 3, _, _}}} ->
  -			       	[ModName,FunName, Arity] = Args, 
  -				handle_special_funs(FileName, T,{ModName, FunName, Arity},{M, F, A}, S1, S2);
  -			    {value, {fun_def, {erlang, spawn, 4, _, _}}} ->
  -				[_, ModName,FunName, Arity] = Args, 
  -				handle_special_funs(FileName, T,{ModName, FunName, Arity},{M, F, A}, S1, S2);			 
  -			    {value, {fun_def, {erlang, spawn_link, 3, _, _}}} ->
  -				[ModName,FunName, Arity] = Args, 
  -				handle_special_funs(FileName, T,{ModName, FunName, Arity},{M, F, A}, S1, S2);
  -			    {value, {fun_def, {erlang, spawn_link, 4, _, _}}} ->
  -				[_, ModName,FunName, Arity] = Args, 
  -				handle_special_funs(FileName, T,{ModName, FunName, Arity},{M, F, A}, S1, S2);
  -			    {value, {fun_def, {erlang, spawn_monitor, 3, _, _}}} ->
  -				[_, ModName,FunName, Arity] = Args, 
  -				handle_special_funs(FileName, T,{ModName, FunName, Arity},{M, F, A}, S1, S2);
  -			    {value, {fun_def, {erlang, spawn_opt, 4, _, _}}} ->
  -			        [ModName,FunName, Arity,_] = Args, 
  -				handle_special_funs(FileName, T,{ModName, FunName, Arity},{M, F, A}, S1, S2);
  -			    {value, {fun_def, {erlang, spawn_opt, 5, _, _}}} ->
  -				[_,ModName,FunName, Arity,_] = Args, 
  -				handle_special_funs(FileName, T,{ModName, FunName, Arity},{M, F, A}, S1, S2);
  -			    {value, _} ->
  -				{S1, S2};
  -			    false -> 
  -				{{Line, _},_EndLoc}  = refac_util:get_range(T),
  -				Arity = length(refac_syntax:application_arguments(T)),
  -			        case Arity of 
  -				    A -> {S1, [{FileName, Line, refac_prettypr:format(T)}|S2]};
  -				    _ -> {S1, S2}
  -				end
  -			end;
  -		    arity_qualifier ->
  -			Body = refac_syntax:arity_qualifier_body(T),
  -			case lists:keysearch(fun_def,1, refac_syntax:get_ann(Body)) of
  -			    {value, {fun_def, {M, F, A, _, _}}} ->
  -					{[true|S1], S2};
  -			    {value, _} ->
  -				{S1,S2};
  -			    false ->
  -				{{Line, _},_EndLoc}  = refac_util:get_range(T),
  -				{S1, [{FileName, Line, refac_prettypr:format(T)}|S2]}
  -			end;
  -		    _ -> {S1, S2}
  -		end
  +		  case refac_syntax:type(T) of
  +		      atom ->
  +			  case refac_syntax:atom_value(T) of
  +			      F -> 
  +				  Ann =refac_syntax:get_ann(T),
  +				  case lists:keysearch(type, 1,Ann) of
  +				      {value, {type, {f_atom, [M, F, A]}}} ->
  +					  {[true|S1], S2};
  +				      {value, {type, {f_atom, [M1, F1, A1]}}} ->
  +					  case is_atom(M1) andalso  M1 /= M orelse 
  +					      is_atom(F1) andalso F1/=M orelse 
  +					      is_integer(A1) andalso A1/=A of 
  +					      true ->
  +						  {S1, S2};
  +					      false ->
  +						  {Line, _Col} = refac_syntax:get_pos(T),
  +						  {S1, [{FileName, Line, refac_prettypr:format(T)} | S2]}
  +					  end;
  +				      {value, {type, _}} ->
  +					  {S1, S2};
  +				      false ->
  +					  {Line, _Col} = refac_syntax:get_pos(T),
  +					  {S1, [{FileName, Line, refac_prettypr:format(T)} | S2]}
  +				  end;
  +			      _ ->{S1, S2}
  +			  end;
  +		      _ ->{S1, S2}
  +		  end
   	  end,
       refac_syntax_lib:fold(Fun, {[], []}, Node).
  -
  -handle_special_funs(FileName, T, {ModName, FunName, Args}, {M, F, A}, S1, S2) ->
  -    ModName1 = case refac_syntax:type(ModName) of
  -		 atom -> refac_syntax:atom_value(ModName);
  -		 _ -> ?not_sure_atom
  -	       end,
  -    FunName1 = case refac_syntax:type(FunName) of
  -		 atom -> refac_syntax:atom_value(FunName);
  -		 _ -> ?not_sure_atom
  -	       end,
  -    Arity1 = case refac_syntax:type(Args) of
  -	       list -> refac_syntax:list_length(Args);
  -	       _ -> ?not_sure_atom
  -	     end,
  -    case ModName1 of
  -      M ->
  -	  case FunName1 of
  -	    F ->
  -		case Arity1 of
  -		  A -> {[true | S1], S2};
  -		  ?not_sure_atom ->
  -		      {{Line, _}, _EndLoc} = refac_util:get_range(T),
  -		      {S1, [{FileName, Line, refac_prettypr:format(T)} | S2]};
  -		  _ -> {S1, S2}
  -		end;
  -	    ?not_sure_atom ->
  -		case Arity1 of
  -		  A ->
  -		      {{Line, _}, _EndLoc} = refac_util:get_range(T),
  -		      {S1, [{FileName, Line, refac_prettypr:format(T)} | S2]};
  -		  ?not_sure_atom ->
  -		      {{Line, _}, _EndLoc} = refac_util:get_range(T),
  -		      {S1, [{FileName, Line, refac_prettypr:format(T)} | S2]};
  -		  _ -> {S1, S2}
  -		end;
  -	    _ -> {S1, S2}
  -	  end;
  -      ?not_sure_atom ->
  -	  case FunName1 of
  -	    F ->
  -		case Arity1 of
  -		  A ->
  -		      {{Line, _}, _EndLoc} = refac_util:get_range(T),
  -		      {S1, [{FileName, Line, refac_prettypr:format(T)} | S2]};
  -		  _ -> {S1, S2}
  -		end;
  -	    ?not_sure_atom ->
  -		case Arity1 of
  -		  A ->
  -		      {{Line, _}, _EndLoc} = refac_util:get_range(T),
  -		      {S1, [{FileName, Line, refac_prettypr:format(T)} | S2]};
  -		  ?not_sure_atom ->
  -		      {{Line, _}, _EndLoc} = refac_util:get_range(T),
  -		      {S1, [{FileName, Line, refac_prettypr:format(T)} | S2]};
  -		  _ -> {S1, S2}
  -		end;
  -	    _ -> {S1, S2}
  -	  end;
  -      _ -> {S1, S2}
  -    end.
  -
  -	    			       
  +    
   %%==========================================================================================
   %%-spec(caller_called_modules(FName::filename(), SearchPaths::[dir()], TabWidth::integer()) -> ok).
   caller_called_modules(FName, SearchPaths, TabWidth) ->
  
positive.code: 			 end, Files),
      non_flush_format_result(lists:usort(Funs)).
  
  
  
  not_flush_unknown_messages(FName, SearchPaths, TabWidth) ->
      {ok, {AnnAST, Info}} = refac_util:parse_annotate_file(FName, true, SearchPaths, TabWidth),
      ModName = get_module_name(FName, Info),
  
negative.code:     
  get_caller_funs(FileName, {M, F, A}, SearchPaths, TabWidth) ->		  
      %% 'true' is used in the following function call, so macros are not expanded.
      %% erxpanding macros does work not properly at the moment.
      {ok, {AnnAST, Info}} = refac_util:parse_annotate_file(FileName, true, SearchPaths, TabWidth),
      ModName = get_module_name(FileName, Info),
      Fun = fun(Node, {S1, S2}) ->
  		  case refac_syntax:type(Node) of 
  		      function -> 
  			  FunName = refac_syntax:data(refac_syntax:function_name(Node)),
  			  FunArity = refac_syntax:function_arity(Node),		
  			  case {ModName, FunName, FunArity} == {M, F, A} of
  			      false ->
  				  {Sure, UnSure}= collect_apps(FileName, Node, {M, F, A});
  			      true ->
  				  {Sure1,UnSure1} = lists:unzip([collect_apps(FileName, C, {M,F,A})
  								 ||C<-refac_syntax:function_clauses(Node)]),
  				  {Sure, UnSure} ={lists:append(Sure1), lists:append(UnSure1)}
  			  end,
  			  case {Sure, UnSure} of 
  			      {[], []} -> {S1, S2};
  			      {[], [_H|_]} -> {S1, UnSure++S2};
  