stdlib: Introduce precedence for operators in types

Add new functions erl_parse:type_inop_prec() and
erl_parse:type_preop_prec().

Get rid of paren_type used for parentheses in types.

3 files changed, 111 insertions, 82 deletions

diff --git a/lib/stdlib/src/erl_parse.yrl b/lib/stdlib/src/erl_parse.yrl
index e328e065e3..274bb2a782 100644
--- a/lib/stdlib/src/erl_parse.yrl
+++ b/lib/stdlib/src/erl_parse.yrl
@@ -125,22 +125,19 @@ top_type_100 -> type_200                  : '$1'.
 top_type_100 -> type_200 '|' top_type_100 : lift_unions('$1','$3').
 
 type_200 -> type_300 '..' type_300        : {type, ?anno('$1'), range,
-                                             [skip_paren('$1'),
-                                              skip_paren('$3')]}.
+                                             ['$1', '$3']}.
 type_200 -> type_300                      : '$1'.
 
-type_300 -> type_300 add_op type_400      : ?mkop2(skip_paren('$1'),
-                                                   '$2', skip_paren('$3')).
+type_300 -> type_300 add_op type_400      : ?mkop2('$1', '$2', '$3').
 type_300 -> type_400                      : '$1'.
 
-type_400 -> type_400 mult_op type_500     : ?mkop2(skip_paren('$1'),
-                                                   '$2', skip_paren('$3')).
+type_400 -> type_400 mult_op type_500     : ?mkop2('$1', '$2', '$3').
 type_400 -> type_500                      : '$1'.
 
-type_500 -> prefix_op type                : ?mkop1('$1', skip_paren('$2')).
+type_500 -> prefix_op type                : ?mkop1('$1', '$2').
 type_500 -> type                          : '$1'.
 
-type -> '(' top_type ')'                  : {paren_type, ?anno('$2'), ['$2']}.
+type -> '(' top_type ')'                  : '$2'.
 type -> var                               : '$1'.
 type -> atom                              : '$1'.
 type -> atom '(' ')'                      : build_gen_type('$1').
@@ -524,6 +521,7 @@ Erlang code.
 -export([normalise/1,abstract/1,tokens/1,tokens/2]).
 -export([abstract/2]).
 -export([inop_prec/1,preop_prec/1,func_prec/0,max_prec/0]).
+-export([type_inop_prec/1,type_preop_prec/1]).
 -export([map_anno/2, fold_anno/3, mapfold_anno/3,
          new_anno/1, anno_to_term/1, anno_from_term/1]).
 -export([set_line/2,get_attribute/2,get_attributes/1]).
@@ -671,11 +669,6 @@ lift_unions(T1, {type, _Aa, union, List}) ->
 lift_unions(T1, T2) ->
     {type, ?anno(T1), union, [T1, T2]}.
 
-skip_paren({paren_type,_A,[Type]}) ->
-    skip_paren(Type);
-skip_paren(Type) ->
-    Type.
-
 build_gen_type({atom, Aa, tuple}) ->
     {type, Aa, tuple, any};
 build_gen_type({atom, Aa, map}) ->
@@ -687,7 +680,7 @@ build_gen_type({atom, Aa, Name}) ->
 build_bin_type([{var, _, '_'}|Left], Int) ->
     build_bin_type(Left, Int);
 build_bin_type([], Int) ->
-    skip_paren(Int);
+    Int;
 build_bin_type([{var, Aa, _}|_], _) ->
     ret_err(Aa, "Bad binary type").
 
@@ -807,8 +800,7 @@ record_fields([{typed,Expr,TypeInfo}|Fields]) ->
 	    {atom, Aa, _} ->
                 case has_undefined(TypeInfo) of
                     false ->
-                        TypeInfo2 = maybe_add_paren(TypeInfo),
-                        lift_unions(abstract2(undefined, Aa), TypeInfo2);
+                        lift_unions(abstract2(undefined, Aa), TypeInfo);
                     true ->
                         TypeInfo
                 end
@@ -822,18 +814,11 @@ has_undefined({atom,_,undefined}) ->
     true;
 has_undefined({ann_type,_,[_,T]}) ->
     has_undefined(T);
-has_undefined({paren_type,_,[T]}) ->
-    has_undefined(T);
 has_undefined({type,_,union,Ts}) ->
     lists:any(fun has_undefined/1, Ts);
 has_undefined(_) ->
     false.
 
-maybe_add_paren({ann_type,A,T}) ->
-    {paren_type,A,[{ann_type,A,T}]};
-maybe_add_paren(T) ->
-    T.
-
 term(Expr) ->
     try normalise(Expr)
     catch _:_R -> ret_err(?anno(Expr), "bad attribute")
@@ -1099,6 +1084,39 @@ func_prec() -> {800,700}.
 
 max_prec() -> 900.
 
+-type prec() :: non_neg_integer().
+
+-type type_inop() :: '::' | '|' | '..' | '+' | '-' | 'bor' | 'bxor'
+                   | 'bsl' | 'bsr' | '*' | '/' | 'div' | 'rem' | 'band'.
+
+-type type_preop() :: '+' | '-' | 'bnot' | '#'.
+
+-spec type_inop_prec(type_inop()) -> {prec(), prec(), prec()}.
+
+type_inop_prec('=') -> {150,100,100};
+type_inop_prec('::') -> {160,150,150};
+type_inop_prec('|') -> {180,170,170};
+type_inop_prec('..') -> {300,200,300};
+type_inop_prec('+') -> {400,400,500};
+type_inop_prec('-') -> {400,400,500};
+type_inop_prec('bor') -> {400,400,500};
+type_inop_prec('bxor') -> {400,400,500};
+type_inop_prec('bsl') -> {400,400,500};
+type_inop_prec('bsr') -> {400,400,500};
+type_inop_prec('*') -> {500,500,600};
+type_inop_prec('/') -> {500,500,600};
+type_inop_prec('div') -> {500,500,600};
+type_inop_prec('rem') -> {500,500,600};
+type_inop_prec('band') -> {500,500,600};
+type_inop_prec('#') -> {800,700,800}.
+
+-spec type_preop_prec(type_preop()) -> {prec(), prec()}.
+
+type_preop_prec('+') -> {600,700};
+type_preop_prec('-') -> {600,700};
+type_preop_prec('bnot') -> {600,700};
+type_preop_prec('#') -> {700,800}.
+
 %%% [Experimental]. The parser just copies the attributes of the
 %%% scanner tokens to the abstract format. This design decision has
 %%% been hidden to some extent: use set_line() and get_attribute() to
diff --git a/lib/stdlib/src/erl_pp.erl b/lib/stdlib/src/erl_pp.erl
index 623a29f923..6da585b72e 100644
--- a/lib/stdlib/src/erl_pp.erl
+++ b/lib/stdlib/src/erl_pp.erl
@@ -27,7 +27,8 @@
 
 -import(lists, [append/1,foldr/3,mapfoldl/3,reverse/1,reverse/2]).
 -import(io_lib, [write/1,format/2]).
--import(erl_parse, [inop_prec/1,preop_prec/1,func_prec/0,max_prec/0]).
+-import(erl_parse, [inop_prec/1,preop_prec/1,func_prec/0,max_prec/0,
+                    type_inop_prec/1, type_preop_prec/1]).
 
 -define(MAXLINE, 72).
 
@@ -271,49 +272,64 @@ typeattr(Tag, {TypeName,Type,Args}, _Opts) ->
     {first,leaf("-"++atom_to_list(Tag)++" "),
      typed(call({atom,a0(),TypeName}, Args, 0, options(none)), Type)}.
 
-ltype({ann_type,_Line,[V,T]}) ->
-    typed(lexpr(V, options(none)), T);
-ltype({paren_type,_Line,[T]}) ->
-    [$(,ltype(T),$)];
-ltype({type,_Line,union,Ts}) ->
-    {seq,[],[],[' |'],ltypes(Ts)};
-ltype({type,_Line,list,[T]}) ->
+ltype(T) ->
+    ltype(T, 0).
+
+ltype({ann_type,_Line,[V,T]}, Prec) ->
+    {_L,P,_R} = type_inop_prec('::'),
+    E = typed(lexpr(V, options(none)), T),
+    maybe_paren(P, Prec, E);
+ltype({paren_type,_Line,[T]}, P) ->
+    %% Generated before Erlang/OTP 18.
+    ltype(T, P);
+ltype({type,_Line,union,Ts}, Prec) ->
+    {_L,P,R} = type_inop_prec('|'),
+    E = {seq,[],[],[' |'],ltypes(Ts, R)},
+    maybe_paren(P, Prec, E);
+ltype({type,_Line,list,[T]}, _) ->
     {seq,$[,$],$,,[ltype(T)]};
-ltype({type,_Line,nonempty_list,[T]}) ->
+ltype({type,_Line,nonempty_list,[T]}, _) ->
     {seq,$[,$],[$,],[ltype(T),leaf("...")]};
-ltype({type,Line,nil,[]}) ->
-    lexpr({nil,Line}, 0, options(none));
-ltype({type,Line,map,any}) ->
+ltype({type,Line,nil,[]}, _) ->
+    lexpr({nil,Line}, options(none));
+ltype({type,Line,map,any}, _) ->
     simple_type({atom,Line,map}, []);
-ltype({type,_Line,map,Pairs}) ->
-    map_type(Pairs);
-ltype({type,Line,tuple,any}) ->
+ltype({type,_Line,map,Pairs}, Prec) ->
+    {P,_R} = type_preop_prec('#'),
+    E = map_type(Pairs),
+    maybe_paren(P, Prec, E);
+ltype({type,Line,tuple,any}, _) ->
     simple_type({atom,Line,tuple}, []);
-ltype({type,_Line,tuple,Ts}) ->
-    tuple_type(Ts, fun ltype/1);
-ltype({type,_Line,record,[{atom,_,N}|Fs]}) ->
-    record_type(N, Fs);
-ltype({type,_Line,range,[_I1,_I2]=Es}) ->
-    expr_list(Es, '..', fun lexpr/2, options(none));
-ltype({type,_Line,binary,[I1,I2]}) ->
+ltype({type,_Line,tuple,Ts}, _) ->
+    tuple_type(Ts, fun ltype/2);
+ltype({type,_Line,record,[{atom,_,N}|Fs]}, Prec) ->
+    {P,_R} = type_preop_prec('#'),
+    E = record_type(N, Fs),
+    maybe_paren(P, Prec, E);
+ltype({type,_Line,range,[_I1,_I2]=Es}, Prec) ->
+    {_L,P,R} = type_inop_prec('..'),
+    F = fun(E, Opts) -> lexpr(E, R, Opts) end,
+    E = expr_list(Es, '..', F, options(none)),
+    maybe_paren(P, Prec, E);
+ltype({type,_Line,binary,[I1,I2]}, _) ->
     binary_type(I1, I2); % except binary()
-ltype({type,_Line,'fun',[]}) ->
+ltype({type,_Line,'fun',[]}, _) ->
     leaf("fun()");
-ltype({type,_,'fun',[{type,_,any},_]}=FunType) ->
+ltype({type,_,'fun',[{type,_,any},_]}=FunType, _) ->
     [fun_type(['fun',$(], FunType),$)];
-ltype({type,_Line,'fun',[{type,_,product,_},_]}=FunType) ->
+ltype({type,_Line,'fun',[{type,_,product,_},_]}=FunType, _) ->
     [fun_type(['fun',$(], FunType),$)];
-ltype({type,Line,T,Ts}) ->
+ltype({type,Line,T,Ts}, _) ->
     %% Compatibility. Before 18.0.
     simple_type({atom,Line,T}, Ts);
-ltype({user_type,Line,T,Ts}) ->
+ltype({user_type,Line,T,Ts}, _) ->
     simple_type({atom,Line,T}, Ts);
-ltype({remote_type,Line,[M,F,Ts]}) ->
+ltype({remote_type,Line,[M,F,Ts]}, _) ->
     simple_type({remote,Line,M,F}, Ts);
-ltype({atom,_,T}) ->
+ltype({atom,_,T}, _) ->
     leaf(write(T));
-ltype(E) ->
-    lexpr(E, 0, options(none)).
+ltype(E, P) ->
+    lexpr(E, P, options(none)).
 
 binary_type(I1, I2) ->
     B = [[] || {integer,_,0} <- [I1]] =:= [],
@@ -327,42 +343,37 @@ map_type(Fs) ->
     {first,[$#],map_pair_types(Fs)}.
 
 map_pair_types(Fs) ->
-    tuple_type(Fs, fun map_pair_type/1).
+    tuple_type(Fs, fun map_pair_type/2).
 
-map_pair_type({type,_Line,map_field_assoc,[Ktype,Vtype]}) ->
-    map_assoc_typed(ltype(Ktype), Vtype).
+map_pair_type({type,_Line,map_field_assoc,[Ktype,Vtype]}, Prec) ->
+    map_assoc_typed(ltype(Ktype), Vtype, Prec).
 
-map_assoc_typed(B, {type,_,union,Ts}) ->
-    {first,[B,$\s],{seq,[],[],[],map_assoc_union_type(Ts)}};
-map_assoc_typed(B, Type) ->
-    {list,[{cstep,[B," =>"],ltype(Type)}]}.
+map_assoc_typed(B, {type,_,union,Ts}, Prec) ->
+    {first,[B,$\s],{seq,[],[],[],map_assoc_union_type(Ts, Prec)}};
+map_assoc_typed(B, Type, Prec) ->
+    {list,[{cstep,[B," =>"],ltype(Type, Prec)}]}.
 
-map_assoc_union_type([T|Ts]) ->
-    [[leaf("=> "),ltype(T)] | ltypes(Ts, fun union_elem/1)].
+map_assoc_union_type([T|Ts], Prec) ->
+    [[leaf("=> "),ltype(T)] | ltypes(Ts, fun union_elem/2, Prec)].
 
 record_type(Name, Fields) ->
     {first,[record_name(Name)],field_types(Fields)}.
 
 field_types(Fs) ->
-    tuple_type(Fs, fun field_type/1).
+    tuple_type(Fs, fun field_type/2).
 
-field_type({type,_Line,field_type,[Name,Type]}) ->
+field_type({type,_Line,field_type,[Name,Type]}, _Prec) ->
     typed(lexpr(Name, options(none)), Type).
 
-typed(B, {type,_,union,Ts}) ->
-    %% Special layout for :: followed by union.
-    {first,[B,$\s],{seq,[],[],[],union_type(Ts)}};
 typed(B, Type) ->
-    {list,[{cstep,[B,' ::'],ltype(Type)}]}.
+    {_L,_P,R} = type_inop_prec('::'),
+    {list,[{cstep,[B,' ::'],ltype(Type, R)}]}.
 
-union_type([T|Ts]) ->
-    [[leaf(":: "),ltype(T)] | ltypes(Ts, fun union_elem/1)].
-
-union_elem(T) ->
-    [leaf(" | "),ltype(T)].
+union_elem(T, Prec) ->
+    [leaf(" | "),ltype(T, Prec)].
 
 tuple_type(Ts, F) ->
-    {seq,${,$},[$,],ltypes(Ts, F)}.
+    {seq,${,$},[$,],ltypes(Ts, F, 0)}.
 
 specattr(SpecKind, {FuncSpec,TypeSpecs}) ->
     Func = case FuncSpec of
@@ -399,16 +410,16 @@ type_args({type,_line,product,Ts}) ->
     targs(Ts).
 
 simple_type(Tag, Types) ->
-    {first,lexpr(Tag, 0, options(none)),targs(Types)}.
+    {first,lexpr(Tag, options(none)),targs(Types)}.
 
 targs(Ts) ->
-    {seq,$(,$),[$,],ltypes(Ts)}.
+    {seq,$(,$),[$,],ltypes(Ts, 0)}.
 
-ltypes(Ts) ->
-    ltypes(Ts, fun ltype/1).
+ltypes(Ts, Prec) ->
+    ltypes(Ts, fun ltype/2, Prec).
 
-ltypes(Ts, F) ->
-    [F(T) || T <- Ts].
+ltypes(Ts, F, Prec) ->
+    [F(T, Prec) || T <- Ts].
 
 attr(Name, Args) ->
     call({var,a0(),format("-~s", [Name])}, Args, 0, options(none)).
diff --git a/lib/stdlib/test/erl_pp_SUITE.erl b/lib/stdlib/test/erl_pp_SUITE.erl
index 1d63c8e17e..afeeb5bfd4 100644
--- a/lib/stdlib/test/erl_pp_SUITE.erl
+++ b/lib/stdlib/test/erl_pp_SUITE.erl
@@ -1149,7 +1149,7 @@ otp_11100(Config) when is_list(Config) ->
         {a,{type,A1,range,[{integer,A1,1},{foo,bar}]},[]}}),
     "-type foo(INVALID-FORM:{foo,bar}:) :: A.\n" =
         pf({attribute,A1,type,{foo,{var,A1,'A'},[{foo,bar}]}}),
-    "-type foo() :: (INVALID-FORM:{foo,bar}: :: []).\n" =
+    "-type foo() :: INVALID-FORM:{foo,bar}: :: [].\n" =
         pf({attribute,A1,type,
             {foo,{paren_type,A1,
                   [{ann_type,A1,[{foo,bar},{type,A1,nil,[]}]}]},