anchor.diff:                  {type, {{_Mod, _FileLine, Form, ArgNames}, _Type}} ->
                     case can_unfold_more(RemType, TypeNames) of
                       true ->
  +                      {ArgTypes, L1} =
  +                        list_from_form(Args, TypeNames, ET, S, MR, V, D, L),
                         List = lists:zip(ArgNames, ArgTypes),
                         TmpVarDict = dict:from_list(List),
                         NewTypeNames = [RemType|TypeNames],
  
positive.code: 
  type_from_form(Name, Args, TypeNames, ET, Site0, MR, V, D, L) ->
    ArgsLen = length(Args),
    {ArgTypes, L1} = list_from_form(Args, TypeNames, ET, Site0, MR, V, D, L),
    Module = site_module(Site0),
    {ok, R} = dict:find(Module, MR),
    TypeName = {type, {Module, Name, ArgsLen}},
  
negative.code:     {type, {{Module, _FileName, Form, ArgNames}, _Type}} ->
        case can_unfold_more(TypeName, TypeNames) of
          true ->
            {ArgTypes, L1} =
              list_from_form(Args, TypeNames, ET, Site0, MR, V, D, L),
            List = lists:zip(ArgNames, ArgTypes),
            TmpV = dict:from_list(List),
            Site = TypeName,
            t_from_form(Form, [TypeName|TypeNames], ET, Site, MR, TmpV, D, L1);
          false ->
            {t_any(), L}
        end;
      {opaque, {{Module, _FileName, Form, ArgNames}, Type}} ->
        case can_unfold_more(TypeName, TypeNames) of
          true ->
            {ArgTypes, L1} =
              list_from_form(Args, TypeNames, ET, Site0, MR, V, D, L),
            List = lists:zip(ArgNames, ArgTypes),
            TmpV = dict:from_list(List),
            Site = TypeName,
            {Rep, L2} =
              t_from_form(Form, [TypeName|TypeNames], ET, Site, MR,
                          TmpV, D, L1),
            Rep1 = choose_opaque_type(Rep, Type),
            Rep2 = case cannot_have_opaque(Rep1, TypeName, TypeNames) of
                     true -> Rep1;
                     false ->
                       ArgTypes2 = subst_all_vars_to_any_list(ArgTypes),
                       t_opaque(Module, Name, ArgTypes2, Rep1)
                   end,
            {Rep2, L2};
          false -> {t_any(), L}
          end;
      error ->
        Msg = io_lib:format("Unable to find type ~w/~w\n", [Name, ArgsLen]),
        throw({error, Msg})
    end.
  
  remote_from_form(RemMod, Name, Args, TypeNames, ET, S, MR, V, D, L) ->
    if
      ET =:= replace_by_none ->
        {t_none(), L};
      true ->
        ArgsLen = length(Args),
        MFA = {RemMod, Name, ArgsLen},
        case dict:find(RemMod, MR) of
          error ->
            self() ! {self(), ext_types, MFA},
            {t_any(), L};
          {ok, RemDict} ->
            RemType = {type, MFA},
            case sets:is_element(MFA, ET) of
  