anchor.diff:      check_side_effect(Def, Side_Effect_Tab, OtherTab).
   
   
  -
   check_side_effect(Node, LibPlt, LocalPlt) ->
       LookUp = fun (MFA) ->
   		     case lookup(LibPlt, MFA) of
  
positive.code: 			   end
  		     end
  	     end,
      case refac_syntax:type(Node) of
        receive_expr -> true;
        infix_expr -> Op = refac_syntax:operator_literal(refac_syntax:infix_expr_operator(Node)),
  		    Op == "!";
        fun_expr -> false;
        implicit_fun -> false;
        application ->
  	  Operator = refac_syntax:application_operator(Node),
  	  Arity = length(refac_syntax:application_arguments(Node)),
  	  case refac_syntax:type(Operator) of
  	    atom ->
  		Op = refac_syntax:atom_value(Operator),
  		{value, {fun_def, {M, _N, _A, _P1, _P}}} = lists:keysearch(fun_def, 1, refac_syntax:get_ann(Operator)),
  		LookUp({M, Op, Arity});
  	    module_qualifier ->
  		Mod = refac_syntax:module_qualifier_argument(Operator),
  		Body = refac_syntax:module_qualifier_body(Operator),
  		case {refac_syntax:type(Mod), refac_syntax:type(Body)} of
  		  {atom, atom} ->
  		      M = refac_syntax:atom_value(Mod),
  		      Op = refac_syntax:atom_value(Body),
  		      LookUp({M, Op, Arity});
  		  _ -> unknown
  		end;
  	    _ -> unknown
  	  end;
        arity_qualifier ->
  	  Fun = refac_syntax:arity_qualifier_body(Node),
  	  A = refac_syntax:arity_qualifier_argument(Node),
  	  case {refac_syntax:type(Fun), refac_syntax:type(A)} of
  	    {atom, integer} ->
  		FunName = refac_syntax:atom_value(Fun),
  		Arity = refac_syntax:integer_value(A),
  		{value, {fun_def, {M, _N, _A, _P1, _P}}} = lists:keysearch(fun_def, 1, refac_syntax:get_ann(FunName)),
  		LookUp({M, FunName, Arity});
  	    _ -> unknown
  	  end;
        atom -> false;
        _ ->
  	  case refac_syntax:subtrees(Node) of
  	    [] -> false;
  	    Ts ->
  		Res = lists:flatten([[check_side_effect(T, LibPlt, LocalPlt) || T <- G] || G <- Ts]),
  		case lists:member(true, Res) of
  		  true -> true;
  		  false ->
  		      case lists:member(unknown, Res) of
  			true -> unknown;
  			_ -> false
  		      end
  		end
  	  end
      end.
  
  normalise_file_name(Filename) ->
  
negative.code: has_side_effect(_File, Node, _SearchPaths) ->
      LibSideEffectFile = list_to_atom(filename:join(?WRANGLER_DIR, "plt/side_effect_plt")),
      LibPlt = from_dets(lib_side_effect_plt, LibSideEffectFile),
      try  check_side_effect(Node, LibPlt, none) of
  	 true -> 
  	    dets:close(LibSideEffectFile),
  	    ets:delete(LibPlt),
  	    true;
  	 false -> dets:close(LibSideEffectFile),
  		  ets:delete(LibPlt),
  		  false;
  	 unknown ->
  	    dets:close(LibSideEffectFile),
  	    ets:delete(LibPlt),
  	    unknown
      catch
  	_E1:_E2 ->
  	    unknown
      end.
  
   %% The following is too slow for a large project.
  