anchor.diff:          erl_syntax_lib:fold(Fun, Acc, TopLevelSyntaxTree)
           end, StartAcc, FileSyntaxTree).
   
  -find_in_file_syntax_tree(FileSyntaxTree, Fun) ->
  -    fold_in_file_syntax_tree(FileSyntaxTree, {undefined, undefined}, 
  +find_in_file_syntax_tree(FileSyntaxTree, Fun1) ->
  +    DefaultVal = case Fun1 of
  +        {function, Fun} -> {{undefined, undefined}, undefined};
  +        Fun -> {undefined, undefined}
  +    end,
  +    fold_in_file_syntax_tree(FileSyntaxTree, DefaultVal, 
           fun (SyntaxTree, {SingleAcc, CurrentFile}) ->
               UpdatedFile = case SyntaxTree of
                   {attribute, _, file, {FileName, _}} -> FileName;
  
positive.code:             undefined
      end.
  
  find_record_field_use(_Record, [], _Column) ->
      undefined;
  find_record_field_use(Record, [{record_field, _, {atom, {_, StartColumn}, Field}, _} | Tail], Column) ->
      EndColumn = StartColumn + length(atom_to_list(Field)),
      if
          StartColumn =< Column andalso Column =< EndColumn -> {field, Record, Field};
          true -> find_record_field_use(Record, Tail, Column)
      end.
  
  find_element({module_use, Module}, _CurrentFileSyntaxTree, _CurrentFile) ->
      {SyntaxTree, File} = lsp_syntax:module_syntax_tree(Module),
      case find_module(SyntaxTree, Module) of
          {attribute, {Line, Column}, _} -> {File, Line, Column};
          _ -> undefined
      end;
  find_element({hrl, HrlFile}, _CurrentFileSyntaxTree, _CurrentFile) ->
      {HrlFile, 1, 1};
  find_element({function_use, Module, Function, Arity}, _CurrentFileSyntaxTree, _CurrentFile) ->
      {SyntaxTree, File} = lsp_syntax:module_syntax_tree(Module),
      case find_function(SyntaxTree, Function, Arity) of
          {function, {Line, Column}, _Function, _Arity, _Clauses} -> {File, Line, Column};
          _ -> undefined
      end;
  find_element({record, Record}, CurrentFileSyntaxTree, _CurrentFile) ->
      case find_record(CurrentFileSyntaxTree, Record) of
  
negative.code:     end.
  
  find_function(FileSyntaxTree, Function, Arity) ->
      Fun = fun (SyntaxTree, DefaultTree, _File) ->
          case SyntaxTree of 
          {function, _Position, FoundFunction, FoundArity, _Clauses} when FoundFunction =:= Function ->
              case FoundArity of
                  Arity -> {SyntaxTree, undefined};
                  _ -> {undefined, SyntaxTree}
              end;
          _ ->
              {undefined, DefaultTree}
          end
      end,
      {SyntaxTree1, _File} = find_in_file_syntax_tree(FileSyntaxTree, {function, Fun}),
      case SyntaxTree1 of
          {undefined, SyntaxTree} -> skip;
          {SyntaxTree, _} -> skip
      end,
      SyntaxTree.
  
  find_module(FileSyntaxTree, Module) ->
  