anchor.diff:          true ->
               Usage = St0#lint.usage,
               Unused = ordsets:subtract(St0#lint.imports, Usage#usage.imported),
  -            Imports = [{{FA,list_to_atom(package_to_string(Mod))},L}
  -                       || {attribute,L,import,{Mod,Fs}} <- Forms,
  -                          FA <- lists:usort(Fs)],
  +            Imports = [{{FA,Mod},L} ||
  +		 {attribute,L,import,{Mod,Fs}} <- Forms,
  +		 FA <- lists:usort(Fs)],
               Bad = [{FM,L} || FM <- Unused, {FM2,L} <- Imports, FM =:= FM2],
               func_line_warning(unused_import, Bad, St0)
       end.
  
positive.code: control_type($i, Need) -> [term|Need];
  control_type(_C, _Need) -> error.
  
  %% In syntax trees, module/package names are atoms or lists of atoms.
  
  package_to_string(A) when is_atom(A) -> atom_to_list(A);
  package_to_string(L) when is_list(L) -> packages:concat(L).
  
  expand_package({atom,L,A} = M, St0) ->
      St1 = keyword_warning(L, A, St0),
      case dict:find(A, St1#lint.mod_imports) of
          {ok, A1} ->
              {{atom,L,A1}, St1};
          error ->
              Name = atom_to_list(A),
              case packages:is_valid(Name) of
                  true ->
                      case packages:is_segmented(Name) of
                          true ->
                              {M, St1};
                          false ->
                              M1 = packages:concat(St1#lint.package,
                                                   Name),
                              {{atom,L,list_to_atom(M1)}, St1}
                      end;
                  false ->
                      St2 = add_error(L, {bad_module_name, Name}, St1),
                      {error, St2}
              end
      end;
  expand_package(M, St0) ->
      L = element(2, M),
      case erl_parse:package_segments(M) of
          error ->
              {error, St0};
          M1 ->
              Name = package_to_string(M1),
              case packages:is_valid(Name) of
                  true ->
                      {{atom,L,list_to_atom(Name)}, St0};
                  false ->
                      St1 = add_error(L, {bad_module_name, Name}, St0),
                      {error, St1}
              end
      end.
  
  
  %% Prebuild set of local functions (to override auto-import)
  local_functions(Forms) ->
  
negative.code:                              pattern_field(Field, Name, Dfs, St1)
                       end),
      {Vt1,[],St1};
  pattern({record,Line,Name,Pfs}, Vt, Old, Bvt, St) ->
      case dict:find(Name, St#lint.records) of
          {ok,{_Line,Fields}} ->
  