Merge branch 'hb/dialyzer/deprecate_types/OTP-10342'

* hb/dialyzer/deprecate_types/OTP-10342:
  hipe: Add a few clauses for maps in erl_types
  stdlib: Add more types to epp and erl_lint

5 files changed, 87 insertions, 42 deletions

diff --git a/lib/hipe/cerl/erl_types.erl b/lib/hipe/cerl/erl_types.erl
index aa69b57fa2..2c6a1aa506 100644
--- a/lib/hipe/cerl/erl_types.erl
+++ b/lib/hipe/cerl/erl_types.erl
@@ -502,9 +502,10 @@ t_contains_opaque(?int_range(_From, _To), _Opaques) -> false;
 t_contains_opaque(?int_set(_Set), _Opaques) -> false;
 t_contains_opaque(?list(Type, Tail, _), Opaques) ->
   t_contains_opaque(Type, Opaques) orelse t_contains_opaque(Tail, Opaques);
-t_contains_opaque(?map(Pairs), Opaques) ->
-  list_contains_opaque([V||{_,V}<-Pairs], Opaques) orelse
-  list_contains_opaque([K||{K,_}<-Pairs], Opaques);
+t_contains_opaque(?map(_) = Map, Opaques) ->
+erlang:display({?LINE,map,contains,Map}),
+  list_contains_opaque(map_values(Map), Opaques) orelse
+  list_contains_opaque(map_keys(Map), Opaques);
 t_contains_opaque(?matchstate(_P, _Slots), _Opaques) -> false;
 t_contains_opaque(?nil, _Opaques) -> false;
 t_contains_opaque(?number(_Set, _Tag), _Opaques) -> false;
@@ -2093,6 +2094,9 @@ t_has_var(?tuple(Elements, _, _)) ->
   t_has_var_list(Elements);
 t_has_var(?tuple_set(_) = T) ->
   t_has_var_list(t_tuple_subtypes(T));
+t_has_var(?map(_)= Map) ->
+erlang:display({?LINE,map,has_var,Map}),
+  t_has_var_list(map_keys(Map)) orelse t_has_var_list(map_values(Map));
 t_has_var(?opaque(Set)) ->
   %% Assume variables in 'args' are also present i 'struct'
   t_has_var_list([O#opaque.struct || O <- set_to_list(Set)]);
@@ -2120,21 +2124,29 @@ t_collect_vars(?function(Domain, Range), Acc) ->
 t_collect_vars(?list(Contents, Termination, _), Acc) ->
   ordsets:union(t_collect_vars(Contents, Acc), t_collect_vars(Termination, []));
 t_collect_vars(?product(Types), Acc) ->
-  lists:foldl(fun(T, TmpAcc) -> t_collect_vars(T, TmpAcc) end, Acc, Types);
+  t_collect_vars_list(Types, Acc);
 t_collect_vars(?tuple(?any, ?any, ?any), Acc) ->
   Acc;
 t_collect_vars(?tuple(Types, _, _), Acc) ->
-  lists:foldl(fun(T, TmpAcc) -> t_collect_vars(T, TmpAcc) end, Acc, Types);
+  t_collect_vars_list(Types, Acc);
 t_collect_vars(?tuple_set(_) = TS, Acc) ->
-  lists:foldl(fun(T, TmpAcc) -> t_collect_vars(T, TmpAcc) end, Acc, 
-	      t_tuple_subtypes(TS));
+  t_collect_vars_list(t_tuple_subtypes(TS), Acc);
+t_collect_vars(?map(_) = Map, Acc0) ->
+erlang:display({?LINE,map,collect_vars,Map}),
+  Acc = t_collect_vars_list(map_keys(Map), Acc0),
+  t_collect_vars_list(map_values(Map), Acc);
 t_collect_vars(?opaque(Set), Acc) ->
   %% Assume variables in 'args' are also present i 'struct'
-  lists:foldl(fun(T, TmpAcc) -> t_collect_vars(T, TmpAcc) end, Acc,
-	      [O#opaque.struct || O <- set_to_list(Set)]);
+  t_collect_vars_list([O#opaque.struct || O <- set_to_list(Set)], Acc);
+t_collect_vars(?union(List), Acc) ->
+  t_collect_vars_list(List, Acc);
 t_collect_vars(_, Acc) ->
   Acc.
 
+t_collect_vars_list([T|Ts], Acc0) ->
+  Acc = t_collect_vars(T, Acc0),
+  t_collect_vars_list(Ts, Acc);
+t_collect_vars_list([], Acc) -> Acc.
 
 %%=============================================================================
 %%
@@ -3081,6 +3093,10 @@ t_subst_dict(?tuple(Elements, _Arity, _Tag), Dict) ->
   t_tuple([t_subst_dict(E, Dict) || E <- Elements]);
 t_subst_dict(?tuple_set(_) = TS, Dict) ->
   t_sup([t_subst_dict(T, Dict) || T <- t_tuple_subtypes(TS)]);
+t_subst_dict(?map(Pairs), Dict) ->
+erlang:display({?LINE,map,subst_dict,Pairs}),
+  ?map([{t_subst_dict(K, Dict), t_subst_dict(V, Dict)} ||
+         {K, V} <- Pairs]);
 t_subst_dict(?opaque(Es), Dict) ->
   List = [Opaque#opaque{args = [t_subst_dict(Arg, Dict) || Arg <- Args],
                         struct = t_subst_dict(S, Dict)} ||
@@ -3130,6 +3146,10 @@ t_subst_aux(?tuple(Elements, _Arity, _Tag), VarMap) ->
   t_tuple([t_subst_aux(E, VarMap) || E <- Elements]);
 t_subst_aux(?tuple_set(_) = TS, VarMap) ->
   t_sup([t_subst_aux(T, VarMap) || T <- t_tuple_subtypes(TS)]);
+t_subst_aux(?map(Pairs), VarMap) ->
+erlang:display({?LINE,map,subst_aux,Pairs}),
+  ?map([{t_subst_aux(K, VarMap), t_subst_aux(V, VarMap)} ||
+         {K, V} <- Pairs]);
 t_subst_aux(?opaque(Es), VarMap) ->
    List = [Opaque#opaque{args = [t_subst_aux(Arg, VarMap) || Arg <- Args],
                          struct = t_subst_aux(S, VarMap)} ||
@@ -3705,7 +3725,7 @@ t_unopaque(T) ->
 t_unopaque(?opaque(_) = T, Opaques) ->
   case Opaques =:= 'universe' orelse is_opaque_type(T, Opaques) of
     true -> t_unopaque(t_opaque_structure(T), Opaques);
-    false -> T  % XXX: needs revision for parametric opaque data types
+    false -> T
   end;
 t_unopaque(?list(ElemT, Termination, Sz), Opaques) ->
   ?list(t_unopaque(ElemT, Opaques), t_unopaque(Termination, Opaques), Sz);
@@ -3725,11 +3745,12 @@ t_unopaque(?union([A,B,F,I,L,N,T,M,O,R,Map]), Opaques) ->
   UL = t_unopaque(L, Opaques),
   UT = t_unopaque(T, Opaques),
   UF = t_unopaque(F, Opaques),
+  UMap = t_unopaque(Map, Opaques),
   {OF,UO} = case t_unopaque(O, Opaques) of
               ?opaque(_) = O1 -> {O1, []};
               Type -> {?none, [Type]}
             end,
-  t_sup([?union([A,B,UF,I,UL,N,UT,M,OF,R,Map])|UO]);
+  t_sup([?union([A,B,UF,I,UL,N,UT,M,OF,R,UMap])|UO]);
 t_unopaque(T, _) ->
   T.
 
@@ -4700,6 +4721,12 @@ is_same_type_name2(gb_trees, gb_tree, [], gb_trees, tree, [_, _]) -> true;
 is_same_type_name2(gb_trees, tree, [_, _], gb_trees, gb_tree, []) -> true;
 is_same_type_name2(_, _, _, _, _, _) -> false.
 
+map_keys(?map(Pairs)) ->
+  [K || {K, _} <- Pairs].
+
+map_values(?map(Pairs)) ->
+  [V || {_, V} <- Pairs].
+
 %% -----------------------------------
 %% Set
 %%
diff --git a/lib/stdlib/src/dict.erl b/lib/stdlib/src/dict.erl
index 6088e1a2dd..cf8fb3114a 100644
--- a/lib/stdlib/src/dict.erl
+++ b/lib/stdlib/src/dict.erl
@@ -55,8 +55,7 @@
 -define(exp_size, (?seg_size * ?expand_load)).
 -define(con_size, (?seg_size * ?contract_load)).
 
--type segs(K, V) :: tuple()
-                  | {K, V}. % dummy
+-type segs(_Key, _Value) :: tuple().
 
 %% Define a hashtable.  The default values are the standard ones.
 -record(dict,
diff --git a/lib/stdlib/src/epp.erl b/lib/stdlib/src/epp.erl
index d212a55b47..9b506b0a44 100644
--- a/lib/stdlib/src/epp.erl
+++ b/lib/stdlib/src/epp.erl
@@ -33,23 +33,33 @@
 
 -export_type([source_encoding/0]).
 
--type macros() :: [{atom(), term()}].
+-type macros() :: [atom() | {atom(), term()}].
 -type epp_handle() :: pid().
 -type source_encoding() :: latin1 | utf8.
 
+-type ifdef() :: 'ifdef' | 'ifndef' | 'else'.
+
+-type name() :: {'atom', atom()}.
+-type argspec() :: 'none'                       %No arguments
+                 | non_neg_integer().           %Number of arguments
+-type tokens() :: [erl_scan:token()].
+-type used() :: {name(), argspec()}.
+
 -define(DEFAULT_ENCODING, utf8).
 
 %% Epp state record.
--record(epp, {file,				%Current file
+-record(epp, {file :: file:io_device(),         %Current file
 	      location=1,         		%Current location
-              delta,                            %Offset from Location (-file)
-	      name="",				%Current file name
-              name2="",                         %-"-, modified by -file
-	      istk=[],				%Ifdef stack
-	      sstk=[],				%State stack
-	      path=[],				%Include-path
-	      macs = dict:new()  :: dict:dict(),%Macros (don't care locations)
-	      uses = dict:new()  :: dict:dict(),%Macro use structure
+              delta=0 :: non_neg_integer(),     %Offset from Location (-file)
+              name="" :: file:name(),           %Current file name
+              name2="" :: file:name(),          %-"-, modified by -file
+              istk=[] :: [ifdef()],             %Ifdef stack
+              sstk=[] :: [#epp{}],              %State stack
+              path=[] :: [file:name()],         %Include-path
+              macs = dict:new()                 %Macros (don't care locations)
+                  :: dict:dict(name(), {argspec(), tokens()}),
+              uses = dict:new()                 %Macro use structure
+                  :: dict:dict(name(), [{argspec(), [used()]}]),
               default_encoding = ?DEFAULT_ENCODING :: source_encoding(),
 	      pre_opened = false :: boolean()
 	     }).
diff --git a/lib/stdlib/src/erl_lint.erl b/lib/stdlib/src/erl_lint.erl
index 4c0261a1ad..0d2092da50 100644
--- a/lib/stdlib/src/erl_lint.erl
+++ b/lib/stdlib/src/erl_lint.erl
@@ -80,13 +80,17 @@ value_option(Flag, Default, On, OnVal, Off, OffVal, Opts) ->
 -type fa()   :: {atom(), arity()}.   % function+arity
 -type ta()   :: {atom(), arity()}.   % type+arity
 
+-record(typeinfo, {attr, line}).
+
 %% Usage of records, functions, and imports. The variable table, which
 %% is passed on as an argument, holds the usage of variables.
 -record(usage, {
           calls = dict:new(),			%Who calls who
           imported = [],                        %Actually imported functions
-          used_records=sets:new() :: sets:set(),%Used record definitions
-	  used_types = dict:new() :: dict:dict()%Used type definitions
+          used_records = sets:new()             %Used record definitions
+              :: sets:set(atom()),
+	  used_types = dict:new()               %Used type definitions
+              :: dict:dict(ta(), line())
          }).
 
 %% Define the lint state record.
@@ -95,13 +99,17 @@ value_option(Flag, Default, On, OnVal, Off, OffVal, Opts) ->
 -record(lint, {state=start		:: 'start' | 'attribute' | 'function',
                module=[],                       %Module
                behaviour=[],                    %Behaviour
-               exports=gb_sets:empty()	:: gb_sets:set(),%Exports
-               imports=[],                      %Imports
+               exports=gb_sets:empty()	:: gb_sets:set(fa()),%Exports
+               imports=[] :: [fa()],            %Imports, an orddict()
                compile=[],                      %Compile flags
-               records=dict:new()	:: dict:dict(),	%Record definitions
-               locals=gb_sets:empty()	:: gb_sets:set(),%All defined functions (prescanned)
-	       no_auto=gb_sets:empty()	:: gb_sets:set() | 'all',%Functions explicitly not autoimported
-               defined=gb_sets:empty()	:: gb_sets:set(),%Defined fuctions
+               records=dict:new()               %Record definitions
+                   :: dict:dict(atom(), {line(),Fields :: term()}),
+               locals=gb_sets:empty()     %All defined functions (prescanned)
+                   :: gb_sets:set(fa()),
+               no_auto=gb_sets:empty() %Functions explicitly not autoimported
+                   :: gb_sets:set(fa()) | 'all',
+               defined=gb_sets:empty()          %Defined fuctions
+                   :: gb_sets:set(fa()),
 	       on_load=[] :: [fa()],		%On-load function
 	       on_load_line=0 :: line(),	%Line for on_load
 	       clashes=[],			%Exported functions named as BIFs
@@ -116,12 +124,16 @@ value_option(Flag, Default, On, OnVal, Off, OffVal, Opts) ->
 						%outside any fun or lc
                xqlc= false :: boolean(),	%true if qlc.hrl included
                new = false :: boolean(),	%Has user-defined 'new/N'
-               called= [] :: [{fa(),line()}],		%Called functions
+               called= [] :: [{fa(),line()}],   %Called functions
                usage = #usage{}		:: #usage{},
-	       specs = dict:new()	:: dict:dict(),	%Type specifications
-	       callbacks = dict:new()   :: dict:dict(), %Callback types
-	       types = dict:new()	:: dict:dict(),	%Type definitions
-	       exp_types=gb_sets:empty():: gb_sets:set()%Exported types
+               specs = dict:new()               %Type specifications
+                   :: dict:dict(mfa(), line()),
+               callbacks = dict:new()           %Callback types
+                   :: dict:dict(mfa(), line()),
+               types = dict:new()               %Type definitions
+                   :: dict:dict(ta(), #typeinfo{}),
+               exp_types=gb_sets:empty()        %Exported types
+                   :: gb_sets:set(ta())
               }).
 
 -type lint_state() :: #lint{}.
@@ -1170,7 +1182,7 @@ export_type(Line, ETs, #lint{usage = Usage, exp_types = ETs0} = St0) ->
 	    add_error(Line, {bad_export_type, ETs}, St0)
     end.
 
--spec exports(lint_state()) -> gb_sets:set().
+-spec exports(lint_state()) -> gb_sets:set(fa()).
 
 exports(#lint{compile = Opts, defined = Defs, exports = Es}) ->
     case lists:member(export_all, Opts) of
@@ -2574,8 +2586,6 @@ find_field(_F, []) -> error.
 %%    Attr :: 'type' | 'opaque'
 %% Checks that a type definition is valid.
 
--record(typeinfo, {attr, line}).
-
 type_def(_Attr, _Line, {record, _RecName}, Fields, [], St0) ->
     %% The record field names and such are checked in the record format.
     %% We only need to check the types.
diff --git a/lib/stdlib/src/sets.erl b/lib/stdlib/src/sets.erl
index be4b600f25..167a676281 100644
--- a/lib/stdlib/src/sets.erl
+++ b/lib/stdlib/src/sets.erl
@@ -55,9 +55,8 @@
 
 %%------------------------------------------------------------------------------
 
--type seg()  :: tuple().
--type segs(E) :: tuple()
-               | E. % dummy
+-type seg()          :: tuple().
+-type segs(_Element) :: tuple().
 
 %% Define a hash set.  The default values are the standard ones.
 -record(set,