Merge branch 'sa/dialyzer-types-arity/OTP-10861'

* sa/dialyzer-types-arity/OTP-10861:
  Minor refactoring
  Update Dialyzer's documentation
  Support for types with the same name and different arity

6 files changed, 53 insertions, 44 deletions

diff --git a/lib/dialyzer/doc/src/dialyzer.xml b/lib/dialyzer/doc/src/dialyzer.xml
index 5e0c9b51e3..0ac96e8ac9 100644
--- a/lib/dialyzer/doc/src/dialyzer.xml
+++ b/lib/dialyzer/doc/src/dialyzer.xml
@@ -158,6 +158,9 @@
       <item>Make Dialyzer a bit more quiet.</item>
       <tag><c><![CDATA[--verbose]]></c></tag>
       <item>Make Dialyzer a bit more verbose.</item>
+      <tag><c><![CDATA[--statistics]]></c></tag>
+      <item>Prints information about the progress of execution (analysis phases,
+      time spent in each and size of the relative input).</item>
       <tag><c><![CDATA[--build_plt]]></c></tag>
       <item>The analysis starts from an empty plt and creates a new one from
         the files specified with <c><![CDATA[-c]]></c> and
@@ -228,6 +231,9 @@
        match.</item>
       <tag><c><![CDATA[-Wno_opaque]]></c></tag>
       <item>Suppress warnings for violations of opaqueness of data types.</item>
+      <tag><c><![CDATA[-Wno_behaviours]]></c>***</tag>
+      <item>Suppress warnings about behaviour callbacks which drift from the
+       published recommended interfaces.</item>
       <tag><c><![CDATA[-Wunmatched_returns]]></c>***</tag>
       <item>Include warnings for function calls which ignore a structured return
         value or do not match against one of many possible return
@@ -237,9 +243,6 @@
        exception.</item>
       <tag><c><![CDATA[-Wrace_conditions]]></c>***</tag>
       <item>Include warnings for possible race conditions.</item>
-      <tag><c><![CDATA[-Wbehaviours]]></c>***</tag>
-      <item>Include warnings about behaviour callbacks which drift from the
-       published recommended interfaces.</item>
       <tag><c><![CDATA[-Wunderspecs]]></c>***</tag>
       <item>Warn about underspecified functions
       (the -spec is strictly more allowing than the success typing).</item>
diff --git a/lib/dialyzer/src/dialyzer_typesig.erl b/lib/dialyzer/src/dialyzer_typesig.erl
index 0df003a035..8c0e45c8da 100644
--- a/lib/dialyzer/src/dialyzer_typesig.erl
+++ b/lib/dialyzer/src/dialyzer_typesig.erl
@@ -2582,19 +2582,8 @@ enter_type(Key, Val, Map) when is_integer(Key) ->
       end
   end;
 enter_type(Key, Val, Map) ->
-  ?debug("Entering ~s :: ~s\n", [format_type(Key), format_type(Val)]),
   KeyName = t_var_name(Key),
-  case t_is_any(Val) of
-    true ->
-      erase_type(KeyName, Map);
-    false ->
-      LimitedVal = t_limit(Val, ?INTERNAL_TYPE_LIMIT),
-      case dict:find(KeyName, Map) of
-	{ok, LimitedVal} -> Map;
-	{ok, _} -> map_store(KeyName, LimitedVal, Map);
-	error -> map_store(KeyName, LimitedVal, Map)
-      end
-  end.
+  enter_type(KeyName, Val, Map).
 
 enter_type_lists([Key|KeyTail], [Val|ValTail], Map) ->
   Map1 = enter_type(Key, Val, Map),
diff --git a/lib/dialyzer/src/dialyzer_utils.erl b/lib/dialyzer/src/dialyzer_utils.erl
index 8046b48838..dc8e825199 100644
--- a/lib/dialyzer/src/dialyzer_utils.erl
+++ b/lib/dialyzer/src/dialyzer_utils.erl
@@ -219,15 +219,18 @@ get_record_and_type_info([], _Module, Records, RecDict) ->
   end.
 
 add_new_type(TypeOrOpaque, Name, TypeForm, ArgForms, Module, RecDict) ->
-  case erl_types:type_is_defined(TypeOrOpaque, Name, RecDict) of
+  Arity = length(ArgForms),
+  case erl_types:type_is_defined(TypeOrOpaque, Name, Arity, RecDict) of
     true ->
-      throw({error, flat_format("Type ~s already defined\n", [Name])});
+      Msg = flat_format("Type ~s/~w already defined\n", [Name, Arity]),
+      throw({error, Msg});
     false ->
       ArgTypes = [erl_types:t_from_form(X) || X <- ArgForms],
       case lists:all(fun erl_types:t_is_var/1, ArgTypes) of
 	true ->
 	  ArgNames = [erl_types:t_var_name(X) || X <- ArgTypes],
-	  dict:store({TypeOrOpaque, Name}, {Module, TypeForm, ArgNames}, RecDict);
+	  dict:store({TypeOrOpaque, Name, Arity},
+                     {Module, TypeForm, ArgNames}, RecDict);
 	false ->
 	  throw({error, flat_format("Type declaration for ~w does not "
 				    "have variables as parameters", [Name])})
diff --git a/lib/dialyzer/test/small_SUITE_data/results/types_arity b/lib/dialyzer/test/small_SUITE_data/results/types_arity
new file mode 100644
index 0000000000..02641bd167
--- /dev/null
+++ b/lib/dialyzer/test/small_SUITE_data/results/types_arity
@@ -0,0 +1,2 @@
+
+types_arity.erl:16: Invalid type specification for function types_arity:test2/0. The success typing is () -> {'node','a','nil','nil'}
diff --git a/lib/dialyzer/test/small_SUITE_data/src/types_arity.erl b/lib/dialyzer/test/small_SUITE_data/src/types_arity.erl
new file mode 100644
index 0000000000..4ddc986ea8
--- /dev/null
+++ b/lib/dialyzer/test/small_SUITE_data/src/types_arity.erl
@@ -0,0 +1,20 @@
+-module(types_arity).
+
+-export([ test1/0
+        , test2/0
+        , test3/0
+        ]).
+
+-export_type([tree/0, tree/1]).
+
+-type tree(T) :: 'nil' | {'node', T, tree(T), tree(T)}.
+-type tree()  :: tree(integer()).
+
+-spec test1() -> tree().
+test1() -> {node, 7, nil, nil}.
+
+-spec test2() -> tree().
+test2() -> {node, a, nil, nil}.
+
+-spec test3() -> tree(atom()).
+test3() -> {node, a, nil, nil}.
diff --git a/lib/hipe/cerl/erl_types.erl b/lib/hipe/cerl/erl_types.erl
index b1a41cd816..d1243b2325 100644
--- a/lib/hipe/cerl/erl_types.erl
+++ b/lib/hipe/cerl/erl_types.erl
@@ -205,7 +205,7 @@
 	 t_var/1,
 	 t_var_name/1,
 	 %% t_assign_variables_to_subtype/2,
-	 type_is_defined/3,
+	 type_is_defined/4,
 	 record_field_diffs_to_string/2,
 	 subst_all_vars_to_any/1,
 	 lift_list_to_pos_empty/1,
@@ -544,12 +544,12 @@ t_opaque_from_records(RecDict) ->
   OpaqueRecDict =
     dict:filter(fun(Key, _Value) ->
 		    case Key of
-		      {opaque, _Name} -> true;
+		      {opaque, _Name, _Arity} -> true;
 		      _  -> false
 		    end
 		end, RecDict),
   OpaqueTypeDict =
-    dict:map(fun({opaque, Name}, {Module, Type, ArgNames}) ->
+    dict:map(fun({opaque, Name, _Arity}, {Module, Type, ArgNames}) ->
 		 case ArgNames of
 		   [] ->
 		     t_opaque(Module, Name, [], t_from_form(Type, RecDict));
@@ -707,8 +707,8 @@ t_solve_remote_type(#remote{mod = RemMod, name = Name, args = Args} = RemType,
       MFA = {RemMod, Name, ArgsLen},
       case sets:is_element(MFA, ET) of
         true ->
-          case lookup_type(Name, RemDict) of
-            {type, {_Mod, Type, ArgNames}} when ArgsLen =:= length(ArgNames) ->
+          case lookup_type(Name, ArgsLen, RemDict) of
+            {type, {_Mod, Type, ArgNames}} ->
               {NewType, NewCycle, NewRR} =
                 case can_unfold_more(RemType, C) of
                   true ->
@@ -726,7 +726,7 @@ t_solve_remote_type(#remote{mod = RemMod, name = Name, args = Args} = RemType,
                   false -> RT
                 end,
               {RT1, RetRR};
-            {opaque, {Mod, Type, ArgNames}} when ArgsLen =:= length(ArgNames) ->
+            {opaque, {Mod, Type, ArgNames}} ->
               List = lists:zip(ArgNames, Args),
               TmpVarDict = dict:from_list(List),
               {Rep, NewCycle, NewRR} =
@@ -746,12 +746,6 @@ t_solve_remote_type(#remote{mod = RemMod, name = Name, args = Args} = RemType,
               {t_from_form({opaque, -1, Name, {Mod, Args, RT1}},
                            RemDict, TmpVarDict),
                RetRR};
-            {type, _} ->
-              Msg = io_lib:format("Unknown remote type ~w\n", [Name]),
-              throw({error, Msg});
-            {opaque, _} ->
-              Msg = io_lib:format("Unknown remote opaque type ~w\n", [Name]),
-              throw({error, Msg});
             error ->
               Msg = io_lib:format("Unable to find remote type ~w:~w()\n",
                                   [RemMod, Name]),
@@ -3682,8 +3676,9 @@ t_from_form({type, _L, union, Args}, TypeNames, InOpaque, RecDict, VarDict) ->
   {L, R} = list_from_form(Args, TypeNames, InOpaque, RecDict, VarDict),
   {t_sup(L), R};
 t_from_form({type, _L, Name, Args}, TypeNames, InOpaque, RecDict, VarDict) ->
-  case lookup_type(Name, RecDict) of
-    {type, {_Module, Type, ArgNames}} when length(Args) =:= length(ArgNames) ->
+  ArgsLen = length(Args),
+  case lookup_type(Name, ArgsLen, RecDict) of
+    {type, {_Module, Type, ArgNames}} ->
       case can_unfold_more({type, Name}, TypeNames) of
         true ->
           List = lists:zipwith(
@@ -3703,7 +3698,7 @@ t_from_form({type, _L, Name, Args}, TypeNames, InOpaque, RecDict, VarDict) ->
           end;
         false -> {t_any(), [{type, Name}]}
       end;
-    {opaque, {Module, Type, ArgNames}} when length(Args) =:= length(ArgNames) ->
+    {opaque, {Module, Type, ArgNames}} ->
       {Rep, Rret} =
         case can_unfold_more({opaque, Name}, TypeNames) of
           true ->
@@ -3732,12 +3727,9 @@ t_from_form({type, _L, Name, Args}, TypeNames, InOpaque, RecDict, VarDict) ->
                         RecDict, VarDict)
           end,
       {Tret, Rret};
-    {type, _} ->
-      throw({error, io_lib:format("Unknown type ~w\n", [Name])});
-    {opaque, _} ->
-      throw({error, io_lib:format("Unknown opaque type ~w\n", [Name])});
     error ->
-      throw({error, io_lib:format("Unable to find type ~w\n", [Name])}) 
+      Msg = io_lib:format("Unable to find type ~w/~w\n", [Name, ArgsLen]),
+      throw({error, Msg})
   end;
 t_from_form({opaque, _L, Name, {Mod, Args, Rep}}, _TypeNames, _InOpaque,
             _RecDict, _VarDict) ->
@@ -3990,20 +3982,20 @@ lookup_record(Tag, Arity, RecDict) when is_atom(Tag) ->
     error -> error
   end.
 
-lookup_type(Name, RecDict) ->
-  case dict:find({type, Name}, RecDict) of
+lookup_type(Name, Arity, RecDict) ->
+  case dict:find({type, Name, Arity}, RecDict) of
     error ->
-      case dict:find({opaque, Name}, RecDict) of
+      case dict:find({opaque, Name, Arity}, RecDict) of
 	error -> error;
 	{ok, Found} -> {opaque, Found}
       end;
     {ok, Found} -> {type, Found}
   end.
 
--spec type_is_defined('type' | 'opaque', atom(), dict()) -> boolean().
+-spec type_is_defined('type' | 'opaque', atom(), arity(), dict()) -> boolean().
 
-type_is_defined(TypeOrOpaque, Name, RecDict) ->
-  dict:is_key({TypeOrOpaque, Name}, RecDict).
+type_is_defined(TypeOrOpaque, Name, Arity, RecDict) ->
+  dict:is_key({TypeOrOpaque, Name, Arity}, RecDict).
 
 can_unfold_more(TypeName, TypeNames) ->
   Fun = fun(E, Acc) -> case E of TypeName -> Acc + 1; _ -> Acc end end,