dialyzer: Generalize an argument of erl_types:t_from_form()

Add more information about the caller of t_from_form(). Instead of
just the module, also provide name of the type, spec, or record where
the type form resides.

1 files changed, 197 insertions, 180 deletions

diff --git a/lib/hipe/cerl/erl_types.erl b/lib/hipe/cerl/erl_types.erl
index cc4fee0853..f0b907f86c 100644
--- a/lib/hipe/cerl/erl_types.erl
+++ b/lib/hipe/cerl/erl_types.erl
@@ -82,7 +82,7 @@
 	 t_form_to_string/1,
          t_from_form/4,
          t_from_form/5,
-         t_from_form_without_remote/2,
+         t_from_form_without_remote/3,
          t_check_record_fields/4,
          t_check_record_fields/5,
 	 t_from_range/2,
@@ -3971,27 +3971,32 @@ mod_name(Mod, Name) ->
 
 -type type_names() :: [type_key() | record_key()].
 
+-type mta()  :: {module(), atom(), arity()}.
+-type mra()  :: {module(), atom(), arity()}.
+-type site() :: {'type', mta()} | {'spec', mfa()} | {'record', mra()}.
+
 -spec t_from_form(parse_form(), sets:set(mfa()),
-                  module(), mod_records()) -> erl_type().
+                  site(), mod_records()) -> erl_type().
 
-t_from_form(Form, ExpTypes, Module, RecDict) ->
-  t_from_form(Form, ExpTypes, Module, RecDict, dict:new()).
+t_from_form(Form, ExpTypes, Site, RecDict) ->
+  t_from_form(Form, ExpTypes, Site, RecDict, dict:new()).
 
 -spec t_from_form(parse_form(), sets:set(mfa()),
-                  module(), mod_records(), var_table()) -> erl_type().
+                  site(), mod_records(), var_table()) -> erl_type().
 
-t_from_form(Form, ExpTypes, Module, RecDict, VarDict) ->
-  {T, _} = t_from_form1(Form, [], ExpTypes, Module, RecDict, VarDict),
+t_from_form(Form, ExpTypes, Site, RecDict, VarDict) ->
+  {T, _} = t_from_form1(Form, ExpTypes, Site, RecDict, VarDict),
   T.
 
 %% Replace external types with with none().
--spec t_from_form_without_remote(parse_form(), type_table()) -> erl_type().
+-spec t_from_form_without_remote(parse_form(), site(), type_table()) ->
+                                    erl_type().
 
-t_from_form_without_remote(Form, TypeTable) ->
-  Module = mod,
+t_from_form_without_remote(Form, Site, TypeTable) ->
+  Module = site_module(Site),
   RecDict = dict:from_list([{Module, TypeTable}]),
   ExpTypes = replace_by_none,
-  {T, _} = t_from_form1(Form, [], ExpTypes, Module, RecDict, dict:new()),
+  {T, _} = t_from_form1(Form, ExpTypes, Site, RecDict, dict:new()),
   T.
 
 %% REC_TYPE_LIMIT is used for limiting the depth of recursive types.
@@ -4005,23 +4010,23 @@ t_from_form_without_remote(Form, TypeTable) ->
 
 -type expand_depth() :: integer().
 
-t_from_form1(Form, TypeNames, ET, M, MR, V) ->
-  t_from_form1(Form, TypeNames, ET, M, MR, V, ?EXPAND_DEPTH).
+t_from_form1(Form, ET, Site, MR, V) ->
+  t_from_form1(Form, ET, Site, MR, V, ?EXPAND_DEPTH).
 
-t_from_form1(Form, TypeNames, ET, M, MR, V, D) ->
+t_from_form1(Form, ET, Site, MR, V, D) ->
   L = ?EXPAND_LIMIT,
-  {T, L1} = t_from_form(Form, TypeNames, ET, M, MR, V, D, L),
+  {T, L1} = t_from_form(Form, [], ET, Site, MR, V, D, L),
   if
     L1 =< 0, D > 1 ->
       D1 = D div 2,
-      t_from_form1(Form, TypeNames, ET, M, MR, V, D1);
+      t_from_form1(Form, ET, Site, MR, V, D1);
     true ->
       {T, L1}
   end.
 
 -spec t_from_form(parse_form(), type_names(),
                   sets:set(mfa()) | 'replace_by_none',
-                  module(), mod_records(), var_table(),
+                  site(), mod_records(), var_table(),
                   expand_depth(), expand_limit())
                            -> {erl_type(), expand_limit()}.
 
@@ -4031,193 +4036,194 @@ t_from_form1(Form, TypeNames, ET, M, MR, V, D) ->
 %% self() ! {self(), ext_types, {RemMod, Name, ArgsLen}}
 %% is called, unless 'replace_by_none' is given.
 %%
-%% It is assumed that M can be found in MR.
+%% It is assumed that site_module(S) can be found in MR.
 
-t_from_form(_, _TypeNames, _ET, _M, _MR, _V, D, L) when D =< 0 ; L =< 0 ->
+t_from_form(_, _TypeNames, _ET, _S, _MR, _V, D, L) when D =< 0 ; L =< 0 ->
   {t_any(), L};
-t_from_form({var, _L, '_'}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({var, _L, '_'}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_any(), L};
-t_from_form({var, _L, Name}, _TypeNames, _ET, _M, _MR, V, _D, L) ->
+t_from_form({var, _L, Name}, _TypeNames, _ET, _S, _MR, V, _D, L) ->
   case dict:find(Name, V) of
     error -> {t_var(Name), L};
     {ok, Val} -> {Val, L}
   end;
-t_from_form({ann_type, _L, [_Var, Type]}, TypeNames, ET, M, MR, V, D, L) ->
-  t_from_form(Type, TypeNames, ET, M, MR, V, D, L);
-t_from_form({paren_type, _L, [Type]}, TypeNames, ET, M, MR, V, D, L) ->
-  t_from_form(Type, TypeNames, ET, M, MR, V, D, L);
+t_from_form({ann_type, _L, [_Var, Type]}, TypeNames, ET, S, MR, V, D, L) ->
+  t_from_form(Type, TypeNames, ET, S, MR, V, D, L);
+t_from_form({paren_type, _L, [Type]}, TypeNames, ET, S, MR, V, D, L) ->
+  t_from_form(Type, TypeNames, ET, S, MR, V, D, L);
 t_from_form({remote_type, _L, [{atom, _, Module}, {atom, _, Type}, Args]},
-	    TypeNames, ET, M, MR, V, D, L) ->
-  remote_from_form(Module, Type, Args, TypeNames, ET, M, MR, V, D, L);
-t_from_form({atom, _L, Atom}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+	    TypeNames, ET, S, MR, V, D, L) ->
+  remote_from_form(Module, Type, Args, TypeNames, ET, S, MR, V, D, L);
+t_from_form({atom, _L, Atom}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_atom(Atom), L};
-t_from_form({integer, _L, Int}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({integer, _L, Int}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_integer(Int), L};
-t_from_form({op, _L, _Op, _Arg} = Op, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({op, _L, _Op, _Arg} = Op, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   case erl_eval:partial_eval(Op) of
     {integer, _, Val} ->
       {t_integer(Val), L};
     _ -> throw({error, io_lib:format("Unable to evaluate type ~w\n", [Op])})
   end;
 t_from_form({op, _L, _Op, _Arg1, _Arg2} = Op, _TypeNames,
-            _ET, _M, _MR, _V, _D, L) ->
+            _ET, _S, _MR, _V, _D, L) ->
   case erl_eval:partial_eval(Op) of
     {integer, _, Val} ->
       {t_integer(Val), L};
     _ -> throw({error, io_lib:format("Unable to evaluate type ~w\n", [Op])})
   end;
-t_from_form({type, _L, any, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, any, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_any(), L};
-t_from_form({type, _L, arity, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, arity, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_arity(), L};
-t_from_form({type, _L, atom, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, atom, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_atom(), L};
-t_from_form({type, _L, binary, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, binary, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_binary(), L};
 t_from_form({type, _L, binary, [Base, Unit]} = Type,
-	    _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+	    _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   case {erl_eval:partial_eval(Base), erl_eval:partial_eval(Unit)} of
     {{integer, _, B}, {integer, _, U}} when B >= 0, U >= 0 ->
       {t_bitstr(U, B), L};
     _ -> throw({error, io_lib:format("Unable to evaluate type ~w\n", [Type])})
   end;
-t_from_form({type, _L, bitstring, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, bitstring, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_bitstr(), L};
-t_from_form({type, _L, bool, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, bool, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_boolean(), L};	% XXX: Temporarily
-t_from_form({type, _L, boolean, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, boolean, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_boolean(), L};
-t_from_form({type, _L, byte, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, byte, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_byte(), L};
-t_from_form({type, _L, char, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, char, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_char(), L};
-t_from_form({type, _L, float, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, float, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_float(), L};
-t_from_form({type, _L, function, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, function, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_fun(), L};
-t_from_form({type, _L, 'fun', []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, 'fun', []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_fun(), L};
 t_from_form({type, _L, 'fun', [{type, _, any}, Range]}, TypeNames,
-            ET, M, MR, V, D, L) ->
-  {T, L1} = t_from_form(Range, TypeNames, ET, M, MR, V, D - 1, L - 1),
+            ET, S, MR, V, D, L) ->
+  {T, L1} = t_from_form(Range, TypeNames, ET, S, MR, V, D - 1, L - 1),
   {t_fun(T), L1};
 t_from_form({type, _L, 'fun', [{type, _, product, Domain}, Range]},
-            TypeNames, ET, M, MR, V, D, L) ->
-  {Dom1, L1} = list_from_form(Domain, TypeNames, ET, M, MR, V, D, L),
-  {Ran1, L2} = t_from_form(Range, TypeNames, ET, M, MR, V, D - 1, L1),
+            TypeNames, ET, S, MR, V, D, L) ->
+  {Dom1, L1} = list_from_form(Domain, TypeNames, ET, S, MR, V, D, L),
+  {Ran1, L2} = t_from_form(Range, TypeNames, ET, S, MR, V, D - 1, L1),
   {t_fun(Dom1, Ran1), L2};
-t_from_form({type, _L, identifier, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, identifier, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_identifier(), L};
-t_from_form({type, _L, integer, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, integer, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_integer(), L};
-t_from_form({type, _L, iodata, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, iodata, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_iodata(), L};
-t_from_form({type, _L, iolist, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, iolist, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_iolist(), L};
-t_from_form({type, _L, list, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, list, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_list(), L};
-t_from_form({type, _L, list, [Type]}, TypeNames, ET, M, MR, V, D, L) ->
-  {T, L1} = t_from_form(Type, TypeNames, ET, M, MR, V, D - 1, L - 1),
+t_from_form({type, _L, list, [Type]}, TypeNames, ET, S, MR, V, D, L) ->
+  {T, L1} = t_from_form(Type, TypeNames, ET, S, MR, V, D - 1, L - 1),
   {t_list(T), L1};
-t_from_form({type, _L, map, _}, TypeNames, ET, M, MR, V, D, L) ->
-  builtin_type(map, t_map([]), TypeNames, ET, M, MR, V, D, L);
-t_from_form({type, _L, mfa, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, map, _}, TypeNames, ET, S, MR, V, D, L) ->
+  builtin_type(map, t_map([]), TypeNames, ET, S, MR, V, D, L);
+t_from_form({type, _L, mfa, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_mfa(), L};
-t_from_form({type, _L, module, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, module, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_module(), L};
-t_from_form({type, _L, nil, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, nil, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_nil(), L};
-t_from_form({type, _L, neg_integer, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, neg_integer, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_neg_integer(), L};
-t_from_form({type, _L, non_neg_integer, []}, _TypeNames, _ET, _M, _MR,
+t_from_form({type, _L, non_neg_integer, []}, _TypeNames, _ET, _S, _MR,
                _V, _D, L) ->
   {t_non_neg_integer(), L};
-t_from_form({type, _L, no_return, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, no_return, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_unit(), L};
-t_from_form({type, _L, node, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, node, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_node(), L};
-t_from_form({type, _L, none, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, none, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_none(), L};
-t_from_form({type, _L, nonempty_list, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, nonempty_list, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_nonempty_list(), L};
-t_from_form({type, _L, nonempty_list, [Type]}, TypeNames, ET, M, MR, V, D, L) ->
-  {T, L1} = t_from_form(Type, TypeNames, ET, M, MR, V, D, L - 1),
+t_from_form({type, _L, nonempty_list, [Type]}, TypeNames, ET, S, MR, V, D, L) ->
+  {T, L1} = t_from_form(Type, TypeNames, ET, S, MR, V, D, L - 1),
   {t_nonempty_list(T), L1};
 t_from_form({type, _L, nonempty_improper_list, [Cont, Term]}, TypeNames,
-            ET, M, MR, V, D, L) ->
-  {T1, L1} = t_from_form(Cont, TypeNames, ET, M, MR, V, D, L - 1),
-  {T2, L2} = t_from_form(Term, TypeNames, ET, M, MR, V, D, L1),
+            ET, S, MR, V, D, L) ->
+  {T1, L1} = t_from_form(Cont, TypeNames, ET, S, MR, V, D, L - 1),
+  {T2, L2} = t_from_form(Term, TypeNames, ET, S, MR, V, D, L1),
   {t_cons(T1, T2), L2};
 t_from_form({type, _L, nonempty_maybe_improper_list, []}, _TypeNames,
-            _ET, _M, _MR, _V, _D, L) ->
+            _ET, _S, _MR, _V, _D, L) ->
   {t_cons(?any, ?any), L};
 t_from_form({type, _L, nonempty_maybe_improper_list, [Cont, Term]},
-            TypeNames, ET, M, MR, V, D, L) ->
-  {T1, L1} = t_from_form(Cont, TypeNames, ET, M, MR, V, D, L - 1),
-  {T2, L2} = t_from_form(Term, TypeNames, ET, M, MR, V, D, L1),
+            TypeNames, ET, S, MR, V, D, L) ->
+  {T1, L1} = t_from_form(Cont, TypeNames, ET, S, MR, V, D, L - 1),
+  {T2, L2} = t_from_form(Term, TypeNames, ET, S, MR, V, D, L1),
   {t_cons(T1, T2), L2};
-t_from_form({type, _L, nonempty_string, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, nonempty_string, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_nonempty_string(), L};
-t_from_form({type, _L, number, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, number, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_number(), L};
-t_from_form({type, _L, pid, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, pid, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_pid(), L};
-t_from_form({type, _L, port, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, port, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_port(), L};
-t_from_form({type, _L, pos_integer, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, pos_integer, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_pos_integer(), L};
 t_from_form({type, _L, maybe_improper_list, []}, _TypeNames,
-            _ET, _M, _MR, _V, _D, L) ->
+            _ET, _S, _MR, _V, _D, L) ->
   {t_maybe_improper_list(), L};
 t_from_form({type, _L, maybe_improper_list, [Content, Termination]},
-            TypeNames, ET, M, MR, V, D, L) ->
-  {T1, L1} = t_from_form(Content, TypeNames, ET, M, MR, V, D, L - 1),
-  {T2, L2} = t_from_form(Termination, TypeNames, ET, M, MR, V, D, L1),
+            TypeNames, ET, S, MR, V, D, L) ->
+  {T1, L1} = t_from_form(Content, TypeNames, ET, S, MR, V, D, L - 1),
+  {T2, L2} = t_from_form(Termination, TypeNames, ET, S, MR, V, D, L1),
   {t_maybe_improper_list(T1, T2), L2};
-t_from_form({type, _L, product, Elements}, TypeNames, ET, M, MR, V, D, L) ->
-  {Lst, L1} = list_from_form(Elements, TypeNames, ET, M, MR, V, D - 1, L),
+t_from_form({type, _L, product, Elements}, TypeNames, ET, S, MR, V, D, L) ->
+  {Lst, L1} = list_from_form(Elements, TypeNames, ET, S, MR, V, D - 1, L),
   {t_product(Lst), L1};
 t_from_form({type, _L, range, [From, To]} = Type,
-	    _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+	    _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   case {erl_eval:partial_eval(From), erl_eval:partial_eval(To)} of
     {{integer, _, FromVal}, {integer, _, ToVal}} ->
       {t_from_range(FromVal, ToVal), L};
     _ -> throw({error, io_lib:format("Unable to evaluate type ~w\n", [Type])})
   end;
-t_from_form({type, _L, record, [Name|Fields]}, TypeNames, ET, M, MR, V, D, L) ->
-  record_from_form(Name, Fields, TypeNames, ET, M, MR, V, D, L);
-t_from_form({type, _L, reference, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, record, [Name|Fields]}, TypeNames, ET, S, MR, V, D, L) ->
+  record_from_form(Name, Fields, TypeNames, ET, S, MR, V, D, L);
+t_from_form({type, _L, reference, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_reference(), L};
-t_from_form({type, _L, string, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, string, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_string(), L};
-t_from_form({type, _L, term, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, term, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_any(), L};
-t_from_form({type, _L, timeout, []}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, timeout, []}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_timeout(), L};
-t_from_form({type, _L, tuple, any}, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+t_from_form({type, _L, tuple, any}, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {t_tuple(), L};
-t_from_form({type, _L, tuple, Args}, TypeNames, ET, M, MR, V, D, L) ->
-  {Lst, L1} = list_from_form(Args, TypeNames, ET, M, MR, V, D - 1, L),
+t_from_form({type, _L, tuple, Args}, TypeNames, ET, S, MR, V, D, L) ->
+  {Lst, L1} = list_from_form(Args, TypeNames, ET, S, MR, V, D - 1, L),
   {t_tuple(Lst), L1};
-t_from_form({type, _L, union, Args}, TypeNames, ET, M, MR, V, D, L) ->
-  {Lst, L1} = list_from_form(Args, TypeNames, ET, M, MR, V, D, L),
+t_from_form({type, _L, union, Args}, TypeNames, ET, S, MR, V, D, L) ->
+  {Lst, L1} = list_from_form(Args, TypeNames, ET, S, MR, V, D, L),
   {t_sup(Lst), L1};
-t_from_form({user_type, _L, Name, Args}, TypeNames, ET, M, MR, V, D, L) ->
-  type_from_form(Name, Args, TypeNames, ET, M, MR, V, D, L);
-t_from_form({type, _L, Name, Args}, TypeNames, ET, M, MR, V, D, L) ->
+t_from_form({user_type, _L, Name, Args}, TypeNames, ET, S, MR, V, D, L) ->
+  type_from_form(Name, Args, TypeNames, ET, S, MR, V, D, L);
+t_from_form({type, _L, Name, Args}, TypeNames, ET, S, MR, V, D, L) ->
   %% Compatibility: modules compiled before Erlang/OTP 18.0.
-  type_from_form(Name, Args, TypeNames, ET, M, MR, V, D, L);
+  type_from_form(Name, Args, TypeNames, ET, S, MR, V, D, L);
 t_from_form({opaque, _L, Name, {Mod, Args, Rep}}, _TypeNames,
-            _ET, _M, _MR, _V, _D, L) ->
+            _ET, _S, _MR, _V, _D, L) ->
   %% XXX. To be removed.
   {t_opaque(Mod, Name, Args, Rep), L}.
 
-builtin_type(Name, Type, TypeNames, ET, M, MR, V, D, L) ->
+builtin_type(Name, Type, TypeNames, ET, Site, MR, V, D, L) ->
+  M = site_module(Site),
   case dict:find(M, MR) of
     {ok, R} ->
       case lookup_type(Name, 0, R) of
         {_, {{_M, _FL, _F, _A}, _T}} ->
-          type_from_form(Name, [], TypeNames, ET, M, MR, V, D, L);
+          type_from_form(Name, [], TypeNames, ET, Site, MR, V, D, L);
         error ->
           {Type, L}
       end;
@@ -4225,29 +4231,31 @@ builtin_type(Name, Type, TypeNames, ET, M, MR, V, D, L) ->
       {Type, L}
   end.
 
-type_from_form(Name, Args, TypeNames, ET, M, MR, V, D, L) ->
+type_from_form(Name, Args, TypeNames, ET, Site0, MR, V, D, L) ->
   ArgsLen = length(Args),
-  {ArgTypes, L1} = list_from_form(Args, TypeNames, ET, M, MR, V, D, L),
-  {ok, R} = dict:find(M, MR),
+  {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}},
   case lookup_type(Name, ArgsLen, R) of
     {type, {{Module, _FileName, Form, ArgNames}, _Type}} ->
-      TypeName = {type, Module, Name, ArgsLen},
       case can_unfold_more(TypeName, TypeNames) of
         true ->
           List = lists:zip(ArgNames, ArgTypes),
           TmpV = dict:from_list(List),
-          t_from_form(Form, [TypeName|TypeNames], ET, M, MR, TmpV, D, L1);
+          Site = TypeName,
+          t_from_form(Form, [TypeName|TypeNames], ET, Site, MR, TmpV, D, L1);
         false ->
           {t_any(), L1}
       end;
     {opaque, {{Module, _FileName, Form, ArgNames}, Type}} ->
-      TypeName = {opaque, Module, Name, ArgsLen},
       {Rep, L2} =
         case can_unfold_more(TypeName, TypeNames) of
           true ->
             List = lists:zip(ArgNames, ArgTypes),
             TmpV = dict:from_list(List),
-            t_from_form(Form, [TypeName|TypeNames], ET, M, MR, TmpV, D, L1);
+            Site = TypeName,
+            t_from_form(Form, [TypeName|TypeNames], ET, Site, MR, TmpV, D, L1);
           false -> {t_any(), L1}
         end,
       Rep1 = choose_opaque_type(Rep, Type),
@@ -4263,36 +4271,36 @@ type_from_form(Name, Args, TypeNames, ET, M, MR, V, D, L) ->
       throw({error, Msg})
   end.
 
-remote_from_form(RemMod, Name, Args, TypeNames, ET, M, MR, V, D, L) ->
-  {ArgTypes, L1} = list_from_form(Args, TypeNames, ET, M, MR, V, D, L),
+remote_from_form(RemMod, Name, Args, TypeNames, ET, S, MR, V, D, L) ->
+  {ArgTypes, L1} = list_from_form(Args, TypeNames, ET, S, MR, V, D, L),
   if
     ET =:= replace_by_none ->
       {t_none(), L1};
     true ->
       ArgsLen = length(Args),
+      MFA = {RemMod, Name, ArgsLen},
       case dict:find(RemMod, MR) of
         error ->
-          self() ! {self(), ext_types, {RemMod, Name, ArgsLen}},
+          self() ! {self(), ext_types, MFA},
           {t_any(), L1};
         {ok, RemDict} ->
-          MFA = {RemMod, Name, ArgsLen},
+          RemType = {type, MFA},
           case sets:is_element(MFA, ET) of
             true ->
               case lookup_type(Name, ArgsLen, RemDict) of
                 {type, {{_Mod, _FileLine, Form, ArgNames}, _Type}} ->
-                  RemType = {type, RemMod, Name, ArgsLen},
                   case can_unfold_more(RemType, TypeNames) of
                     true ->
                       List = lists:zip(ArgNames, ArgTypes),
                       TmpVarDict = dict:from_list(List),
                       NewTypeNames = [RemType|TypeNames],
+                      Site = RemType,
                       t_from_form(Form, NewTypeNames, ET,
-                                  RemMod, MR, TmpVarDict, D, L1);
+                                  Site, MR, TmpVarDict, D, L1);
                     false ->
                       {t_any(), L1}
                   end;
                 {opaque, {{Mod, _FileLine, Form, ArgNames}, Type}} ->
-                  RemType = {opaque, RemMod, Name, ArgsLen},
                   List = lists:zip(ArgNames, ArgTypes),
                   TmpVarDict = dict:from_list(List),
                   {NewRep, L2} =
@@ -4346,22 +4354,24 @@ choose_opaque_type(Type, DeclType) ->
     false -> DeclType
   end.
 
-record_from_form({atom, _, Name}, ModFields, TypeNames, ET, M, MR, V, D, L) ->
+record_from_form({atom, _, Name}, ModFields, TypeNames, ET, S, MR, V, D, L) ->
   case can_unfold_more({record, Name}, TypeNames) of
     true ->
+      M = site_module(S),
       {ok, R} = dict:find(M, MR),
       case lookup_record(Name, R) of
         {ok, DeclFields} ->
           NewTypeNames = [{record, Name}|TypeNames],
+          S1 = {record, {M, Name, length(DeclFields)}},
           {GetModRec, L1} = get_mod_record(ModFields, DeclFields,
-                                           NewTypeNames, ET, M, MR, V, D, L),
+                                           NewTypeNames, ET, S1, MR, V, D, L),
           case GetModRec of
             {error, FieldName} ->
               throw({error, io_lib:format("Illegal declaration of #~w{~w}\n",
                                           [Name, FieldName])});
             {ok, NewFields} ->
               {NewFields1, L2} =
-                fields_from_form(NewFields, NewTypeNames, ET, M, MR,
+                fields_from_form(NewFields, NewTypeNames, ET, S1, MR,
                                  dict:new(), D, L1),
               Rec = t_tuple(
                       [t_atom(Name)|[Type
@@ -4375,12 +4385,12 @@ record_from_form({atom, _, Name}, ModFields, TypeNames, ET, M, MR, V, D, L) ->
        {t_any(), L}
   end.
 
-get_mod_record([], DeclFields, _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+get_mod_record([], DeclFields, _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {{ok, DeclFields}, L};
-get_mod_record(ModFields, DeclFields, TypeNames, ET, M, MR, V, D, L) ->
+get_mod_record(ModFields, DeclFields, TypeNames, ET, S, MR, V, D, L) ->
   DeclFieldsDict = lists:keysort(1, DeclFields),
   {ModFieldsDict, L1} =
-    build_field_dict(ModFields, TypeNames, ET, M, MR, V, D, L),
+    build_field_dict(ModFields, TypeNames, ET, S, MR, V, D, L),
   case get_mod_record_types(DeclFieldsDict, ModFieldsDict, []) of
     {error, _FieldName} = Error -> {Error, L1};
     {ok, FinalKeyDict} ->
@@ -4389,17 +4399,17 @@ get_mod_record(ModFields, DeclFields, TypeNames, ET, M, MR, V, D, L) ->
       {{ok, Fields}, L1}
   end.
 
-build_field_dict(FieldTypes, TypeNames, ET, M, MR, V, D, L) ->
-  build_field_dict(FieldTypes, TypeNames, ET, M, MR, V, D, L, []).
+build_field_dict(FieldTypes, TypeNames, ET, S, MR, V, D, L) ->
+  build_field_dict(FieldTypes, TypeNames, ET, S, MR, V, D, L, []).
 
 build_field_dict([{type, _, field_type, [{atom, _, Name}, Type]}|Left],
-		 TypeNames, ET, M, MR, V, D, L, Acc) ->
-  {T, L1} = t_from_form(Type, TypeNames, ET, M, MR, V, D, L - 1),
+		 TypeNames, ET, S, MR, V, D, L, Acc) ->
+  {T, L1} = t_from_form(Type, TypeNames, ET, S, MR, V, D, L - 1),
   NewAcc = [{Name, Type, T}|Acc],
   {Dict, L2} =
-    build_field_dict(Left, TypeNames, ET, M, MR, V, D, L1, NewAcc),
+    build_field_dict(Left, TypeNames, ET, S, MR, V, D, L1, NewAcc),
   {Dict, L2};
-build_field_dict([], _TypeNames, _ET, _M, _MR, _V, _D, L, Acc) ->
+build_field_dict([], _TypeNames, _ET, _S, _MR, _V, _D, L, Acc) ->
   {lists:keysort(1, Acc), L}.
 
 get_mod_record_types([{FieldName, _Abstr, _DeclType}|Left1],
@@ -4418,88 +4428,94 @@ get_mod_record_types(_, [{FieldName2, _FormType, _ModType}|_], _Acc) ->
 %% It is important to create a limited version of the record type
 %% since nested record types can otherwise easily result in huge
 %% terms.
-fields_from_form([], _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+fields_from_form([], _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {[], L};
-fields_from_form([{Name, Abstr, _Type}|Tail], TypeNames, ET, M, MR,
+fields_from_form([{Name, Abstr, _Type}|Tail], TypeNames, ET, S, MR,
                  V, D, L) ->
-  {T, L1} = t_from_form(Abstr, TypeNames, ET, M, MR, V, D, L),
-  {F, L2} = fields_from_form(Tail, TypeNames, ET, M, MR, V, D, L1),
+  {T, L1} = t_from_form(Abstr, TypeNames, ET, S, MR, V, D, L),
+  {F, L2} = fields_from_form(Tail, TypeNames, ET, S, MR, V, D, L1),
   {[{Name, T}|F], L2}.
 
-list_from_form([], _TypeNames, _ET, _M, _MR, _V, _D, L) ->
+list_from_form([], _TypeNames, _ET, _S, _MR, _V, _D, L) ->
   {[], L};
-list_from_form([H|Tail], TypeNames, ET, M, MR, V, D, L) ->
-  {H1, L1} = t_from_form(H, TypeNames, ET, M, MR, V, D, L - 1),
-  {T1, L2} = list_from_form(Tail, TypeNames, ET, M, MR, V, D, L1),
+list_from_form([H|Tail], TypeNames, ET, S, MR, V, D, L) ->
+  {H1, L1} = t_from_form(H, TypeNames, ET, S, MR, V, D, L - 1),
+  {T1, L2} = list_from_form(Tail, TypeNames, ET, S, MR, V, D, L1),
   {[H1|T1], L2}.
 
--spec t_check_record_fields(parse_form(), sets:set(mfa()), module(),
+-spec t_check_record_fields(parse_form(), sets:set(mfa()), site(),
                             mod_records()) -> ok.
 
-t_check_record_fields(Form, ExpTypes, Module, RecDict) ->
-  t_check_record_fields(Form, ExpTypes, Module, RecDict, dict:new()).
+t_check_record_fields(Form, ExpTypes, Site, RecDict) ->
+  t_check_record_fields(Form, ExpTypes, Site, RecDict, dict:new()).
 
--spec t_check_record_fields(parse_form(), sets:set(mfa()), module(),
+-spec t_check_record_fields(parse_form(), sets:set(mfa()), site(),
                             mod_records(), var_table()) -> ok.
 
 %% If there is something wrong with parse_form()
 %% throw({error, io_lib:chars()} is called.
 
-t_check_record_fields({var, _L, _}, _ET, _M, _MR, _V) -> ok;
-t_check_record_fields({ann_type, _L, [_Var, Type]}, ET, M, MR, V) ->
-  t_check_record_fields(Type, ET, M, MR, V);
-t_check_record_fields({paren_type, _L, [Type]}, ET, M, MR, V) ->
-  t_check_record_fields(Type, ET, M, MR, V);
+t_check_record_fields({var, _L, _}, _ET, _S, _MR, _V) -> ok;
+t_check_record_fields({ann_type, _L, [_Var, Type]}, ET, S, MR, V) ->
+  t_check_record_fields(Type, ET, S, MR, V);
+t_check_record_fields({paren_type, _L, [Type]}, ET, S, MR, V) ->
+  t_check_record_fields(Type, ET, S, MR, V);
 t_check_record_fields({remote_type, _L, [{atom, _, _}, {atom, _, _}, Args]},
-                    ET, M, MR, V) ->
-  list_check_record_fields(Args, ET, M, MR, V);
-t_check_record_fields({atom, _L, _}, _ET, _M, _MR, _V) -> ok;
-t_check_record_fields({integer, _L, _}, _ET, _M, _MR, _V) -> ok;
-t_check_record_fields({op, _L, _Op, _Arg}, _ET, _M, _MR, _V) -> ok;
-t_check_record_fields({op, _L, _Op, _Arg1, _Arg2}, _ET, _M, _MR, _V) -> ok;
-t_check_record_fields({type, _L, tuple, any}, _ET, _M, _MR, _V) -> ok;
-t_check_record_fields({type, _L, map, any}, _ET, _M, _MR, _V) -> ok;
-t_check_record_fields({type, _L, binary, [_Base, _Unit]}, _ET, _M, _MR, _V) ->
+                    ET, S, MR, V) ->
+  list_check_record_fields(Args, ET, S, MR, V);
+t_check_record_fields({atom, _L, _}, _ET, _S, _MR, _V) -> ok;
+t_check_record_fields({integer, _L, _}, _ET, _S, _MR, _V) -> ok;
+t_check_record_fields({op, _L, _Op, _Arg}, _ET, _S, _MR, _V) -> ok;
+t_check_record_fields({op, _L, _Op, _Arg1, _Arg2}, _ET, _S, _MR, _V) -> ok;
+t_check_record_fields({type, _L, tuple, any}, _ET, _S, _MR, _V) -> ok;
+t_check_record_fields({type, _L, map, any}, _ET, _S, _MR, _V) -> ok;
+t_check_record_fields({type, _L, binary, [_Base, _Unit]}, _ET, _S, _MR, _V) ->
   ok;
 t_check_record_fields({type, _L, 'fun', [{type, _, any}, Range]},
-                      ET, M, MR, V) ->
-  t_check_record_fields(Range, ET, M, MR, V);
-t_check_record_fields({type, _L, range, [_From, _To]}, _ET, _M, _MR, _V) ->
+                      ET, S, MR, V) ->
+  t_check_record_fields(Range, ET, S, MR, V);
+t_check_record_fields({type, _L, range, [_From, _To]}, _ET, _S, _MR, _V) ->
   ok;
-t_check_record_fields({type, _L, record, [Name|Fields]}, ET, M, MR, V) ->
-  check_record(Name, Fields, ET, M, MR, V);
-t_check_record_fields({type, _L, _, Args}, ET, M, MR, V) ->
-  list_check_record_fields(Args, ET, M, MR, V);
-t_check_record_fields({user_type, _L, _Name, Args}, ET, M, MR, V) ->
-  list_check_record_fields(Args, ET, M, MR, V).
-
-check_record({atom, _, Name}, ModFields, ET, M, MR, V) ->
+t_check_record_fields({type, _L, record, [Name|Fields]}, ET, S, MR, V) ->
+  check_record(Name, Fields, ET, S, MR, V);
+t_check_record_fields({type, _L, _, Args}, ET, S, MR, V) ->
+  list_check_record_fields(Args, ET, S, MR, V);
+t_check_record_fields({user_type, _L, _Name, Args}, ET, S, MR, V) ->
+  list_check_record_fields(Args, ET, S, MR, V).
+
+check_record({atom, _, Name}, ModFields, ET, Site, MR, V) ->
+  M = site_module(Site),
   {ok, R} = dict:find(M, MR),
   {ok, DeclFields} = lookup_record(Name, R),
-  case check_fields(ModFields, DeclFields, ET, M, MR, V) of
+  case check_fields(Name, ModFields, DeclFields, ET, Site, MR, V) of
     {error, FieldName} ->
        throw({error, io_lib:format("Illegal declaration of #~w{~w}\n",
                                    [Name, FieldName])});
     ok -> ok
   end.
 
-check_fields([{type, _, field_type, [{atom, _, Name}, Abstr]}|Left],
-             DeclFields, ET, M, MR, V) ->
-  Type = t_from_form(Abstr, ET, M, MR, V),
+check_fields(RecName, [{type, _, field_type, [{atom, _, Name}, Abstr]}|Left],
+             DeclFields, ET, Site0, MR, V) ->
+  M = site_module(Site0),
+  Site = {record, {M, RecName, length(DeclFields)}},
+  Type = t_from_form(Abstr, ET, Site, MR, V),
   {Name, _, DeclType} = lists:keyfind(Name, 1, DeclFields),
   TypeNoVars = subst_all_vars_to_any(Type),
   case t_is_subtype(TypeNoVars, DeclType) of
     false -> {error, Name};
-    true -> check_fields(Left, DeclFields, ET, M, MR, V)
+    true -> check_fields(RecName, Left, DeclFields, ET, Site0, MR, V)
   end;
-check_fields([], _Decl, _ET, _M, _MR, _V) ->
+check_fields(_RecName, [], _Decl, _ET, _Site, _MR, _V) ->
   ok.
 
-list_check_record_fields([], _ET, _M, _MR, _V) ->
+list_check_record_fields([], _ET, _S, _MR, _V) ->
   ok;
-list_check_record_fields([H|Tail], ET, M, MR, V) ->
-  ok = t_check_record_fields(H, ET, M, MR, V),
-  list_check_record_fields(Tail, ET, M, MR, V).
+list_check_record_fields([H|Tail], ET, S, MR, V) ->
+  ok = t_check_record_fields(H, ET, S, MR, V),
+  list_check_record_fields(Tail, ET, S, MR, V).
+
+site_module({_, {Module, _, _}}) ->
+  Module.
 
 -spec t_var_names([erl_type()]) -> [atom()].
 
@@ -4594,8 +4610,9 @@ t_form_to_string({type, _L, Name, []} = T) ->
      M = mod,
      D0 = dict:new(),
      MR = dict:from_list([{M, D0}]),
+     S = {type, {M,Name,0}},
      {T1, _} =
-       t_from_form(T, [], sets:new(), M, MR, D0, _Deep=1000, _ALot=100000),
+       t_from_form(T, [], sets:new(), S, MR, D0, _Deep=1000, _ALot=100000),
      t_to_string(T1)
   catch throw:{error, _} -> atom_to_string(Name) ++ "()"
   end;