anchor.diff:  	eof_marker -> refac_syntax:add_ann({range, {{L, C}, {L, C}}}, Node);
   	nil -> refac_syntax:add_ann({range, {{L, C}, {L, C + 1}}}, Node);
   	module_qualifier ->
  -	    calc_and_add_range_to_node(Node, module_qualifier_argument, module_qualifier_body);
  +            Arg = refac_syntax:module_qualifier_argument(Node),
  +            Field = refac_syntax:module_qualifier_body(Node),
  +            {S1,_E1} = get_range(Arg),
  +            {_S2,E2} = get_range(Field),
  +            Node1 = refac_syntax:set_pos(Node, S1),
  +            refac_syntax:add_ann({range,{S1,E2}},Node1);
   	list ->  
               Es = list_elements(Node),
               case Es/=[] of
  
positive.code: %%-spec add_range(syntaxTree(), [token()]) -> syntaxTree(). 
  add_range(AST, Toks) ->
      QAtomPs= [Pos||{qatom, Pos, _Atom}<-Toks],
      ast_traverse_api:full_buTP(fun do_add_range/2, AST, {Toks, QAtomPs}).
  
  do_add_range(Node, {Toks, QAtomPs}) ->
      {L, C} = case refac_syntax:get_pos(Node) of
  
negative.code: 		_ -> {_S2, E2} = get_range(Value),refac_syntax:add_ann({range, {S1, E2}}, Node)
  	    end;
  	typed_record_field ->   %% This is not correct; need to be fixed later!
                  Field = refac_syntax:typed_record_field(Node),
                  {S1, _E1} = get_range(Field),
                  Type = refac_syntax:typed_record_type(Node),
                  {_S2, E2} = get_range(Type),
                  refac_syntax:add_ann({range, {S1, E2}}, Node);
  	record_expr ->
                  Arg = refac_syntax:record_expr_argument(Node),
                  Type = refac_syntax:record_expr_type(Node),
                  Toks2 = lists:dropwhile(fun(B)->
                                                 element(2, B)/= {L,C}
                                         end, Toks),
                  [{'#', _}, {_, Pos1, _}|_] = Toks2,
                  Type1 = add_range(refac_syntax:set_pos(Type, Pos1), Toks),
                  Fields = refac_syntax:record_expr_fields(Node),
                  {S1, E1} = case Arg of
                                 none -> get_range(Type);
                                 _ -> get_range(Arg)
                             end,
                  case Fields of
                      [] -> E11 = extend_backwards(Toks, E1, '}'),
                            Node1 =rewrite(Node, refac_syntax:record_expr(Arg, Type1, Fields)),
                            refac_syntax:add_ann({range, {S1, E11}}, Node1);
                      _ ->
                          {_S2, E2} = get_range(refac_util:glast("refac_util:do_add_range,record_expr", Fields)),
                          E21 = extend_backwards(Toks, E2, '}'),
                          Node1 =rewrite(Node, refac_syntax:record_expr(Arg, Type1, Fields)),
                          refac_syntax:add_ann({range, {S1, E21}}, Node1)
                  end;
  	record_access ->
  	    calc_and_add_range_to_node(Node, record_access_argument, record_access_field);
  	record_index_expr ->
  