anchor.diff:    IncMap = Inc#inc.map,
     FA = {F, A},
     Type = get_type_info(FA, Types, Analysis),
  -  case map__lookup(File, IncMap) of
  -    none -> %% File is not added. Add it
  -      Obj = {File,[{FA, {Line, Type}}]},
  -      NewMap = map__insert(Obj, IncMap),
  -      Inc#inc{map = NewMap};
  -    Val -> %% File is already in. Check.
  -      case lists:keyfind(FA, 1, Val) of
  -        false ->
  -          %% Function is not in; add it
  -          Obj = {File, Val ++ [{FA, {Line, Type}}]},
  -          NewMap = map__insert(Obj, IncMap),
  -          Inc#inc{map = NewMap};
  -        Type ->
  -          %% Function is in and with same type
  -          Inc;
  -        _ ->
  -          %% Function is in but with diff type
  -          inc_warning(FA, File, Analysis),
  -          Elem = lists:keydelete(FA, 1, Val),
  -          NewMap = case Elem of
  -                     [] -> map__remove(File, IncMap);
  -                     _  -> map__insert({File, Elem}, IncMap)
  -                   end,
  +  case IncMap of
  +      #{File := Val} -> %% File is already in. Check.
  +          case lists:keyfind(FA, 1, Val) of
  +              false ->
  +                  %% Function is not in; add it
  +                  Inc#inc{map = IncMap#{File => Val ++ [{FA, {Line, Type}}]}};
  +              {FA, {_, Type}} ->
  +                  %% Function is in and with same type
  +                  Inc;
  +              _ ->
  +                  %% Function is in but with diff type
  +                  inc_warning(FA, File, Analysis),
  +                  Elem = lists:keydelete(FA, 1, Val),
  +                  NewMap =
  +                      case Elem of
  +                          [] -> maps:remove(File, IncMap);
  +                          _  -> IncMap#{File => Elem}
  +                      end,
  +                  Inc#inc{map = NewMap}
  +          end;
  +      _ -> %% File is not added. Add it
  +          NewMap = IncMap#{File => [{FA, {Line, Type}}]},
             Inc#inc{map = NewMap}
  -      end
     end.
   
   inc_warning({F, A}, File, Analysis) ->
  
positive.code: %% Author(s)   : The first version of typer was written by Bingwen He
  %%               with guidance from Kostis Sagonas and Tobias Lindahl.
  %%               Since June 2008 typer is maintained by Kostis Sagonas.
  %%               On 2022, Brujo, Pablo, and Mackenzie from NextRoll
  %%               started working on the rebar3 plugin for typer and,
  %%               with that in mind, splitted typer and typer_core apart.
  %% Description : An Erlang/OTP module that shows type information
  %%               for Erlang modules to the user.  Additionally, it can
  %%               annotate the code of files with such type information.
  
negative.code:   normalize_obj(Inc1).
  
  remove_yecc_generated_file(#inc{filter = Filter} = Inc) ->
    Fun = fun(Key, #inc{map = Map} = I) -> I#inc{map = maps:remove(Key, Map)} end,
    lists:foldl(Fun, Inc, Filter).
  
  normalize_obj(TmpInc) ->
    Fun = fun (Key, Val, Inc) ->
              NewVal = [{{Line,F,A},Type} || {{F,A},{Line,Type}} <- Val],
              Inc#{Key => NewVal}
          end,
    TmpInc#inc{map = maps:fold(Fun, maps:new(), TmpInc#inc.map)}.
  
  get_records(File, Analysis) ->
    maps:get(File, Analysis#analysis.record, none).
  
  get_types(Module, Analysis, Records) ->
    TypeInfoPlt = Analysis#analysis.trust_plt,
  