Merge branch 'maint'

* maint:
  dialyzer: Improve check of unknown types

5 files changed, 93 insertions, 32 deletions

diff --git a/lib/dialyzer/src/dialyzer_contracts.erl b/lib/dialyzer/src/dialyzer_contracts.erl
index b554ebc2cc..e72c1aecfc 100644
--- a/lib/dialyzer/src/dialyzer_contracts.erl
+++ b/lib/dialyzer/src/dialyzer_contracts.erl
@@ -555,6 +555,9 @@ from_form_with_check(Form, ExpTypes, MFA, RecordTable, VarTable, Cache) ->
   Site = {spec, MFA},
   C1 = erl_types:t_check_record_fields(Form, ExpTypes, Site, RecordTable,
                                        VarTable, Cache),
+  %% The check costs some time, and with the assumption that contracts
+  %% are not very deep, it does not add anything.
+  %% erl_types:t_from_form_check_remote(Form, ExpTypes, MFA, RecordTable),
   erl_types:t_from_form(Form, ExpTypes, Site, RecordTable, VarTable, C1).
 
 constraints_to_dict(Constrs, MFA, RecDict, ExpTypes, RecordTable,
@@ -840,7 +843,7 @@ is_remote_types_related(Contract, CSig, Sig, MFA, RecDict) ->
 
 t_from_forms_without_remote([{FType, []}], MFA, RecDict) ->
   Site = {spec, MFA},
-  {Type1, _} = erl_types:t_from_form_without_remote(FType, Site, RecDict),
+  Type1 = erl_types:t_from_form_without_remote(FType, Site, RecDict),
   {ok, erl_types:subst_all_vars_to_any(Type1)};
 t_from_forms_without_remote([{_FType, _Constrs}], _MFA, _RecDict) ->
   %% 'When' constraints
diff --git a/lib/dialyzer/src/dialyzer_utils.erl b/lib/dialyzer/src/dialyzer_utils.erl
index 6e501f32b2..abd89034f3 100644
--- a/lib/dialyzer/src/dialyzer_utils.erl
+++ b/lib/dialyzer/src/dialyzer_utils.erl
@@ -244,9 +244,12 @@ process_record_remote_types(CServer) ->
                 {record, Name} ->
                   FieldFun =
                     fun({Arity, Fields}, C4) ->
-                        Site = {record, {Module, Name, Arity}},
+                        MRA = {Module, Name, Arity},
+                        Site = {record, MRA},
                         {Fields1, C7} =
                           lists:mapfoldl(fun({FieldName, Field, _}, C5) ->
+                                             check_remote(Field, ExpTypes,
+                                                          MRA, RecordTable),
                                              {FieldT, C6} =
                                                erl_types:t_from_form
                                                  (Field, ExpTypes, Site,
@@ -260,18 +263,12 @@ process_record_remote_types(CServer) ->
                   {FieldsList, C3} =
                     lists:mapfoldl(FieldFun, C2, orddict:to_list(Fields)),
                   {{Key, {FileLine, orddict:from_list(FieldsList)}}, C3};
-                {type, Name, NArgs} ->
+                {_TypeOrOpaque, Name, NArgs} ->
                   %% Make sure warnings about unknown types are output
                   %% also for types unused by specs.
-                  Site = {type, {Module, Name, NArgs}},
-                  L = erl_anno:new(0),
-                  Args = lists:duplicate(NArgs, {var, L, '_'}),
-                  UserType = {user_type, L, Name, Args},
-                  {_NewType, C3} =
-                    erl_types:t_from_form(UserType, ExpTypes, Site,
-                                          RecordTable, VarTable, C2),
-                  {{Key, Value}, C3};
-                {opaque, _Name, _NArgs} ->
+                  MTA = {Module, Name, NArgs},
+                  {{_Module, _FileLine, Form, _ArgNames}, _Type} = Value,
+                  check_remote(Form, ExpTypes, MTA, RecordTable),
                   {{Key, Value}, C2}
               end
           end,
@@ -372,6 +369,9 @@ msg_with_position(Fun, FileLine) ->
       throw({error, NewMsg})
   end.
 
+check_remote(Form, ExpTypes, What, RecordTable) ->
+  erl_types:t_from_form_check_remote(Form, ExpTypes, What, RecordTable).
+
 -spec merge_types(codeserver(), dialyzer_plt:plt()) -> codeserver().
 
 merge_types(CServer, Plt) ->
diff --git a/lib/dialyzer/test/options2_SUITE_data/results/unused_unknown_type b/lib/dialyzer/test/options2_SUITE_data/results/unused_unknown_type
index 110d896c76..74d2ac33ad 100644
--- a/lib/dialyzer/test/options2_SUITE_data/results/unused_unknown_type
+++ b/lib/dialyzer/test/options2_SUITE_data/results/unused_unknown_type
@@ -1,2 +1,2 @@
 
-:0: Unknown type unknown:type1/0:0: Unknown type unknown:type2/0:0: Unknown type unknown:type3/0
\ No newline at end of file
+:0: Unknown type foo:bar/0:0: Unknown type ofoo:obar/0:0: Unknown type owww:y/0:0: Unknown type rfoo:rbar/0:0: Unknown type unknown:type1/0:0: Unknown type unknown:type2/0:0: Unknown type unknown:type3/0:0: Unknown type xxx:y/0:0: Unknown type yyy:x/0:0: Unknown type zzz:arg/1:0: Unknown type zzz:x/0
\ No newline at end of file
diff --git a/lib/dialyzer/test/options2_SUITE_data/src/unused_unknown_type.erl b/lib/dialyzer/test/options2_SUITE_data/src/unused_unknown_type.erl
index 90df7d528a..e6f9d2392c 100644
--- a/lib/dialyzer/test/options2_SUITE_data/src/unused_unknown_type.erl
+++ b/lib/dialyzer/test/options2_SUITE_data/src/unused_unknown_type.erl
@@ -1,10 +1,40 @@
 -module(unused_unknown_type).
 
+-export([t/0]).
+
 -export_type([unused/0]).
 
+-export_type([wide/0, deep/0]).
+-export_type([owide/0, odeep/0]).
+-export_type([arg/0, rargs1/0, rargs2/0]).
+
 -type unused() :: unknown:type1().
 
--record(unused_rec, {a :: unknown:type2()}).
+-record(unused_rec,
+        {a :: unknown:type2(),
+         b :: {{{{{{{{{{{{{{{{{{{{rfoo:rbar()}}}}}}}}}}}}}}}}}}}}}).
 
 -record(rec, {a}).
 -type unused_rec() :: #rec{a :: unknown:type3()}.
+
+-type wide() :: {a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,xxx:y()}.
+-type owide() :: {a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,owww:y()}.
+
+%% Deeper than the hardcoded limit in erl_types.erl of 16.
+-type deep() :: {{{{{{{{{{{{{{{{{{{{foo:bar()}}}}}}}}}}}}}}}}}}}}.
+-type odeep() :: {{{{{{{{{{{{{{{{{{{{ofoo:obar()}}}}}}}}}}}}}}}}}}}}.
+
+-type arg1(A) :: [A].
+-type arg() :: arg1({a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,yyy:x()}).
+
+%% No warning about www:x/0 because parameters are currently not
+%% handled if the parameterized type cannot be found.
+-type rargs1() :: zzz:arg({a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,www:x()}).
+
+-type rargs2() :: dict:dict({a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,zzz:x()},
+                            any()).
+
+%% No warning. The check is commented out as it takes too long.
+-spec t() -> 'a' | {{{{{{{{{{{{{{{{{{{{sfoo:sbar()}}}}}}}}}}}}}}}}}}}}.
+t() ->
+    a.
diff --git a/lib/hipe/cerl/erl_types.erl b/lib/hipe/cerl/erl_types.erl
index 0883a69918..f4746fc9d0 100644
--- a/lib/hipe/cerl/erl_types.erl
+++ b/lib/hipe/cerl/erl_types.erl
@@ -74,6 +74,7 @@
 	 t_form_to_string/1,
          t_from_form/6,
          t_from_form_without_remote/3,
+         t_from_form_check_remote/4,
          t_check_record_fields/6,
 	 t_from_range/2,
 	 t_from_range_unsafe/2,
@@ -4471,7 +4472,7 @@ t_from_form(Form, ExpTypes, Site, RecDict, VarTab, Cache) ->
 
 %% Replace external types with with none().
 -spec t_from_form_without_remote(parse_form(), site(), type_table()) ->
-                                    {erl_type(), cache()}.
+                                    erl_type().
 
 t_from_form_without_remote(Form, Site, TypeTable) ->
   Module = site_module(Site),
@@ -4480,38 +4481,57 @@ t_from_form_without_remote(Form, Site, TypeTable) ->
   VarTab = var_table__new(),
   Cache0 = cache__new(),
   Cache = Cache0#cache{mod_recs = {mrecs, ModRecs}},
-  t_from_form1(Form, ExpTypes, Site, undefined, VarTab, Cache).
-
-%% REC_TYPE_LIMIT is used for limiting the depth of recursive types.
-%% EXPAND_LIMIT is used for limiting the size of types by
-%% limiting the number of elements of lists within one type form.
-%% EXPAND_DEPTH is used in conjunction with EXPAND_LIMIT to make the
-%% types balanced (unions will otherwise collapse to any()) by limiting
-%% the depth the same way as t_limit/2 does.
+  {Type, _} = t_from_form1(Form, ExpTypes, Site, undefined, VarTab, Cache),
+  Type.
 
 -type expand_limit() :: integer().
 
 -type expand_depth() :: integer().
 
--record(from_form, {site   :: site(),
+-record(from_form, {site   :: site() | {'check', mta()},
                     xtypes :: sets:set(mfa()) | 'replace_by_none',
                     mrecs  :: 'undefined' | mod_type_table(),
                     vtab   :: var_table(),
                     tnames :: type_names()}).
 
+-spec t_from_form_check_remote(parse_form(), sets:set(mfa()), mta(),
+                               mod_type_table()) -> 'ok'.
+t_from_form_check_remote(Form, ExpTypes, MTA, RecDict) ->
+  State = #from_form{site   = {check, MTA},
+                     xtypes = ExpTypes,
+                     mrecs  = RecDict,
+                     vtab   = var_table__new(),
+                     tnames = []},
+  D = (1 bsl 25), % unlimited
+  L = (1 bsl 25),
+  Cache0 = cache__new(),
+  _ = t_from_form2(Form, State, D, L, Cache0),
+  ok.
+
+%% REC_TYPE_LIMIT is used for limiting the depth of recursive types.
+%% EXPAND_LIMIT is used for limiting the size of types by
+%% limiting the number of elements of lists within one type form.
+%% EXPAND_DEPTH is used in conjunction with EXPAND_LIMIT to make the
+%% types balanced (unions will otherwise collapse to any()) by limiting
+%% the depth the same way as t_limit/2 does.
+
 -spec t_from_form1(parse_form(), sets:set(mfa()) | 'replace_by_none',
                    site(), 'undefined' | mod_type_table(), var_table(),
                    cache()) -> {erl_type(), cache()}.
 
 t_from_form1(Form, ET, Site, MR, V, C) ->
   TypeNames = initial_typenames(Site),
+  D = ?EXPAND_DEPTH,
+  L = ?EXPAND_LIMIT,
   State = #from_form{site   = Site,
                      xtypes = ET,
                      mrecs  = MR,
                      vtab   = V,
                      tnames = TypeNames},
-  L = ?EXPAND_LIMIT,
-  {T0, L0, C0} = from_form(Form, State, ?EXPAND_DEPTH, L, C),
+  t_from_form2(Form, State, D, L, C).
+
+t_from_form2(Form, State, D, L, C) ->
+  {T0, L0, C0} = from_form(Form, State, D, L, C),
   if
     L0 =< 0 ->
       {T1, _, C1} = from_form(Form, State, 1, L, C0),
@@ -4767,14 +4787,18 @@ type_from_form(Name, Args, S, D, L, C) ->
   case can_unfold_more(TypeName, TypeNames) of
     true ->
       {R, C1} = lookup_module_types(Module, MR, C),
-      type_from_form1(Name, Args, ArgsLen, R, TypeName, TypeNames,
+      type_from_form1(Name, Args, ArgsLen, R, TypeName, TypeNames, Site,
                       S, D, L, C1);
     false ->
       {t_any(), L, C}
   end.
 
-type_from_form1(Name, Args, ArgsLen, R, TypeName, TypeNames, S, D, L, C) ->
+type_from_form1(Name, Args, ArgsLen, R, TypeName, TypeNames, Site,
+                S, D, L, C) ->
   case lookup_type(Name, ArgsLen, R) of
+    {_, {_, _}} when element(1, Site) =:= check ->
+      {_ArgTypes, L1, C1} = list_from_form(Args, S, D, L, C),
+      {t_any(), L1, C1};
     {Tag, {{Module, _FileName, Form, ArgNames}, Type}} ->
       NewTypeNames = [TypeName|TypeNames],
       S1 = S#from_form{tnames = NewTypeNames},
@@ -4813,7 +4837,7 @@ type_from_form1(Name, Args, ArgsLen, R, TypeName, TypeNames, S, D, L, C) ->
   end.
 
 remote_from_form(RemMod, Name, Args, S, D, L, C) ->
-  #from_form{xtypes = ET, mrecs = MR, tnames = TypeNames} = S,
+  #from_form{site = Site, xtypes = ET, mrecs = MR, tnames = TypeNames} = S,
   if
     ET =:= replace_by_none ->
       {t_none(), L, C};
@@ -4831,7 +4855,7 @@ remote_from_form(RemMod, Name, Args, S, D, L, C) ->
               case can_unfold_more(RemType, TypeNames) of
                 true ->
                   remote_from_form1(RemMod, Name, Args, ArgsLen, RemDict,
-                                    RemType, TypeNames, S, D, L, C1);
+                                    RemType, TypeNames, Site, S, D, L, C1);
                 false ->
                   {t_any(), L, C1}
               end;
@@ -4843,14 +4867,16 @@ remote_from_form(RemMod, Name, Args, S, D, L, C) ->
   end.
 
 remote_from_form1(RemMod, Name, Args, ArgsLen, RemDict, RemType, TypeNames,
-                  S, D, L, C) ->
+                  Site, S, D, L, C) ->
   case lookup_type(Name, ArgsLen, RemDict) of
+    {_, {_, _}} when element(1, Site) =:= check ->
+      {_ArgTypes, L1, C1} = list_from_form(Args, S, D, L, C),
+      {t_any(), L1, C1};
     {Tag, {{Mod, _FileLine, Form, ArgNames}, Type}} ->
       NewTypeNames = [RemType|TypeNames],
       S1 = S#from_form{tnames = NewTypeNames},
       {ArgTypes, L1, C1} = list_from_form(Args, S1, D, L, C),
       CKey = cache_key(RemMod, Name, ArgTypes, TypeNames, D),
-      %% case error of
       case cache_find(CKey, C) of
         {CachedType, DeltaL} ->
           {CachedType, L - DeltaL, C};
@@ -4914,6 +4940,8 @@ record_from_form({atom, _, Name}, ModFields, S, D0, L0, C) ->
       M = site_module(Site),
       {R, C1} = lookup_module_types(M, MR, C),
       case lookup_record(Name, R) of
+        {ok, _} when element(1, Site) =:= check ->
+          {t_any(), L0, C1};
         {ok, DeclFields} ->
           NewTypeNames = [RecordType|TypeNames],
           Site1 = {record, {M, Name, length(DeclFields)}},