Merge branch 'hasse/stdlib/erl_pp_newlines/OTP-15755'

* hasse/stdlib/erl_pp_newlines/OTP-15755:
  stdlib: Adjust test suites and docs due to erl_pp changes
  stdlib: Let the Pretty Printer output more on one line

5 files changed, 252 insertions, 108 deletions

diff --git a/lib/stdlib/doc/src/qlc.xml b/lib/stdlib/doc/src/qlc.xml
index fe60c2e9bb..34f7c5bab9 100644
--- a/lib/stdlib/doc/src/qlc.xml
+++ b/lib/stdlib/doc/src/qlc.xml
@@ -4,7 +4,7 @@
 <erlref>
   <header>
     <copyright>
-      <year>2004</year><year>2016</year>
+      <year>2004</year><year>2019</year>
       <holder>Ericsson AB. All Rights Reserved.</holder>
     </copyright>
     <legalnotice>
@@ -581,11 +581,13 @@ gb_iter(I0, N, EFun) ->
 <input>{K} &lt;- ets:table(E1),</input>
 <input>K == 2.71 orelse K == a]),</input>
 <input>io:format("~s~n", [qlc:info(Q1)]).</input>
-ets:match_spec_run(lists:flatmap(fun(V) ->
-                                        ets:lookup(20493, V)
-                                 end,
-                                 [a,2.71]),
-                   ets:match_spec_compile([{{'$1'},[],['$1']}]))</pre>
+ets:match_spec_run(
+       lists:flatmap(fun(V) ->
+			    ets:lookup(#Ref&lt;0.3098908599.2283929601.256025>,
+				       V)
+		     end,
+		     [a, 2.71]),
+       ets:match_spec_compile([{{'$1'}, [], ['$1']}]))</pre>
 
     <p>In the example, operator <c>==/2</c> has been handled
       exactly as <c>=:=/2</c> would have been handled. However,
@@ -607,9 +609,10 @@ ets:match_spec_run(lists:flatmap(fun(V) ->
 <input>end,</input>
 <input>Q2 = F2({2,2}),</input>
 <input>io:format("~s~n", [qlc:info(Q2)]).</input>
-ets:table(53264,
+ets:table(#Ref&lt;0.3098908599.2283929601.256125>,
           [{traverse,
-            {select,[{{'$1','$2'},[{'==','$1',{const,{2,2}}}],['$2']}]}}])
+            {select,
+             [{{'$1', '$2'}, [{'==', '$1', {const, {2, 2}}}], ['$2']}]}}])
 3> <input>lists:sort(qlc:e(Q2)).</input>
 [a,b,c]</pre>
 
@@ -629,8 +632,9 @@ ets:table(53264,
 <input>end,</input>
 <input>Q3 = F3({2,2}),</input>
 <input>io:format("~s~n", [qlc:info(Q3)]).</input>
-ets:match_spec_run(ets:lookup(86033, {2,2}),
-                   ets:match_spec_compile([{{'$1','$2'},[],['$2']}]))
+ets:match_spec_run(ets:lookup(#Ref&lt;0.3098908599.2283929601.256211>,
+                              {2, 2}),
+                   ets:match_spec_compile([{{'$1', '$2'}, [], ['$2']}]))
 5> <input>qlc:e(Q3).</input>
 [b]</pre>
 
@@ -892,21 +896,21 @@ begin
     V1 =
         qlc:q([
                SQV ||
-                   SQV &lt;- [x,y]
+                   SQV &lt;- [x, y]
               ],
-              [{unique,true}]),
+              [{unique, true}]),
     V2 =
         qlc:q([
                SQV ||
-                   SQV &lt;- [a,b]
+                   SQV &lt;- [a, b]
               ],
-              [{unique,true}]),
+              [{unique, true}]),
     qlc:q([
            {X,Y} ||
                X &lt;- V1,
                Y &lt;- V2
           ],
-          [{unique,true}])
+          [{unique, true}])
 end</pre>
         <p>In the following example QLC <c>V2</c> has
           been inserted to show the joined generators and the join
@@ -927,19 +931,21 @@ begin
     V1 =
         qlc:q([
                P0 ||
-                   P0 = {W,Y} &lt;- ets:table(17)
+                   P0 = {W, Y} &lt;-
+                       ets:table(#Ref&lt;0.3098908599.2283929601.256549>)
               ]),
     V2 =
         qlc:q([
-               [G1|G2] ||
+               [G1 | G2] ||
                    G2 &lt;- V1,
-                   G1 &lt;- ets:table(16),
+                   G1 &lt;-
+                       ets:table(#Ref&lt;0.3098908599.2283929601.256548>),
                    element(2, G1) =:= element(1, G2)
               ],
-              [{join,lookup}]),
+              [{join, lookup}]),
     qlc:q([
-           {X,Z,W} ||
-               [{X,Z}|{W,Y}] &lt;- V2
+           {X, Z, W} ||
+               [{X, Z} | {W, Y}] &lt;- V2
           ])
 end</pre>
       </desc>
@@ -1080,27 +1086,27 @@ begin
     V1 =
         qlc:q([
                P0 ||
-                   P0 = {X,Z} &lt;-
-                       qlc:keysort(1, [{a,1},{b,4},{c,6}], [])
+                   P0 = {X, Z} &lt;-
+                       qlc:keysort(1, [{a, 1}, {b, 4}, {c, 6}], [])
               ]),
     V2 =
         qlc:q([
                P0 ||
-                   P0 = {W,Y} &lt;-
-                       qlc:keysort(2, [{2,a},{3,b},{4,c}], [])
+                   P0 = {W, Y} &lt;-
+                       qlc:keysort(2, [{2, a}, {3, b}, {4, c}], [])
               ]),
     V3 =
         qlc:q([
-               [G1|G2] ||
+               [G1 | G2] ||
                    G1 &lt;- V1,
                    G2 &lt;- V2,
                    element(1, G1) == element(2, G2)
               ],
-              [{join,merge},{cache,list}]),
+              [{join, merge}, {cache, list}]),
     qlc:q([
-           {A,X,Z,W} ||
-               A &lt;- [a,b,c],
-               [{X,Z}|{W,Y}] &lt;- V3,
+           {A, X, Z, W} ||
+               A &lt;- [a, b, c],
+               [{X, Z} | {W, Y}] &lt;- V3,
                X =:= Y
           ])
 end</pre>
@@ -1141,14 +1147,21 @@ ets:match_spec_run(
                                 gb_trees:lookup(K,
                                                 gb_trees:from_orddict([]))
                             of
-                                {value,V} ->
-                                    [{K,V}];
+                                {value, V} ->
+                                    [{K, V}];
                                 none ->
                                     []
                             end
                      end,
-                     [{1,a},{1,b},{1,c},{2,a},{2,b},{2,c}]),
-       ets:match_spec_compile([{{{'$1','$2'},'_'},[],['$1']}]))</pre>
+                     [{1, a},
+                      {1, b},
+                      {1, c},
+                      {2, a},
+                      {2, b},
+                      {2, c}]),
+       ets:match_spec_compile([{{{'$1', '$2'}, '_'},
+                                [],
+                                ['$1']}]))</pre>
         <p>Options:</p>
         <list type="bulleted">
           <item>
diff --git a/lib/stdlib/src/erl_pp.erl b/lib/stdlib/src/erl_pp.erl
index 2630c60859..255c0ae81f 100644
--- a/lib/stdlib/src/erl_pp.erl
+++ b/lib/stdlib/src/erl_pp.erl
@@ -26,7 +26,7 @@
          attribute/1,attribute/2,function/1,function/2,
          guard/1,guard/2,exprs/1,exprs/2,exprs/3,expr/1,expr/2,expr/3,expr/4]).
 
--import(lists, [append/1,foldr/3,mapfoldl/3,reverse/1,reverse/2]).
+-import(lists, [append/1,foldr/3,map/2,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,
                     type_inop_prec/1, type_preop_prec/1]).
@@ -382,7 +382,12 @@ binary_type(I1, I2) ->
     P = max_prec(),
     E1 = [[leaf("_:"),lexpr(I1, P, options(none))] || B],
     E2 = [[leaf("_:_*"),lexpr(I2, P, options(none))] || U],
-    {seq,'<<','>>',[$,],E1++E2}.
+    case E1++E2 of
+        [] ->
+            leaf("<<>>");
+        Es ->
+            {seq,'<<','>>',[$,],Es}
+    end.
 
 map_type(Fs) ->
     {first,[$#],map_pair_types(Fs)}.
@@ -408,6 +413,8 @@ typed(B, Type) ->
     {_L,_P,R} = type_inop_prec('::'),
     {list,[{cstep,[B,' ::'],ltype(Type, R)}]}.
 
+tuple_type([], _) ->
+    leaf("{}");
 tuple_type(Ts, F) ->
     {seq,${,$},[$,],ltypes(Ts, F, 0)}.
 
@@ -476,7 +483,7 @@ pname(A) when is_atom(A) ->
     write(A).
 
 falist([]) ->
-    [leaf("[]")];
+    ['[]'];
 falist(Falist) ->
     L = [begin
              {Name,Arity} = Fa,
@@ -584,22 +591,22 @@ lexpr({map, _, Map, Fs}, Prec, Opts) ->
     El = {first,[Rl,$#],map_fields(Fs, Opts)},
     maybe_paren(P, Prec, El);
 lexpr({block,_,Es}, _, Opts) ->
-    {list,[{step,'begin',body(Es, Opts)},'end']};
+    {list,[{step,'begin',body(Es, Opts)},{reserved,'end'}]};
 lexpr({'if',_,Cs}, _, Opts) ->
-    {list,[{step,'if',if_clauses(Cs, Opts)},'end']};
+    {list,[{step,'if',if_clauses(Cs, Opts)},{reserved,'end'}]};
 lexpr({'case',_,Expr,Cs}, _, Opts) ->
-    {list,[{step,{list,[{step,'case',lexpr(Expr, Opts)},'of']},
+    {list,[{step,{list,[{step,'case',lexpr(Expr, Opts)},{reserved,'of'}]},
             cr_clauses(Cs, Opts)},
-           'end']};
+           {reserved,'end'}]};
 lexpr({'cond',_,Cs}, _, Opts) ->
-    {list,[{step,leaf("cond"),cond_clauses(Cs, Opts)},'end']};
+    {list,[{step,leaf("cond"),cond_clauses(Cs, Opts)},{reserved,'end'}]};
 lexpr({'receive',_,Cs}, _, Opts) ->
-    {list,[{step,'receive',cr_clauses(Cs, Opts)},'end']};
+    {list,[{step,'receive',cr_clauses(Cs, Opts)},{reserved,'end'}]};
 lexpr({'receive',_,Cs,To,ToOpt}, _, Opts) ->
     Al = {list,[{step,[lexpr(To, Opts),' ->'],body(ToOpt, Opts)}]},
     {list,[{step,'receive',cr_clauses(Cs, Opts)},
            {step,'after',Al},
-           'end']};
+           {reserved,'end'}]};
 lexpr({'fun',_,{function,F,A}}, _Prec, _Opts) ->
     [leaf("fun "),{atom,F},leaf(format("/~w", [A]))];
 lexpr({'fun',L,{function,_,_}=Func,Extra}, Prec, Opts) ->
@@ -618,15 +625,17 @@ lexpr({'fun',_,{function,M,F,A}}, _Prec, Opts) ->
     ArityItem = lexpr(A, Opts),
     ["fun ",NameItem,$:,CallItem,$/,ArityItem];
 lexpr({'fun',_,{clauses,Cs}}, _Prec, Opts) ->
-    {list,[{first,'fun',fun_clauses(Cs, Opts, unnamed)},'end']};
+    {list,[{first,'fun',fun_clauses(Cs, Opts, unnamed)},{reserved,'end'}]};
 lexpr({named_fun,_,Name,Cs}, _Prec, Opts) ->
-    {list,[{first,['fun', " "],fun_clauses(Cs, Opts, {named, Name})},'end']};
+    {list,[{first,['fun', " "],fun_clauses(Cs, Opts, {named, Name})},
+           {reserved,'end'}]};
 lexpr({'fun',_,{clauses,Cs},Extra}, _Prec, Opts) ->
     {force_nl,fun_info(Extra),
-     {list,[{first,'fun',fun_clauses(Cs, Opts, unnamed)},'end']}};
+     {list,[{first,'fun',fun_clauses(Cs, Opts, unnamed)},{reserved,'end'}]}};
 lexpr({named_fun,_,Name,Cs,Extra}, _Prec, Opts) ->
     {force_nl,fun_info(Extra),
-     {list,[{first,['fun', " "],fun_clauses(Cs, Opts, {named, Name})},'end']}};
+     {list,[{first,['fun', " "],fun_clauses(Cs, Opts, {named, Name})},
+            {reserved,'end'}]}};
 lexpr({call,_,{remote,_,{atom,_,M},{atom,_,F}=N}=Name,Args}, Prec, Opts) ->
     case erl_internal:bif(M, F, length(Args)) of
         true ->
@@ -641,7 +650,7 @@ lexpr({'try',_,Es,Scs,Ccs,As}, _, Opts) ->
                Scs =:= [] ->
                    {step,'try',body(Es, Opts)};
                true ->
-                   {step,{list,[{step,'try',body(Es, Opts)},'of']},
+                   {step,{list,[{step,'try',body(Es, Opts)},{reserved,'of'}]},
                     cr_clauses(Scs, Opts)}
            end,
            if
@@ -656,7 +665,7 @@ lexpr({'try',_,Es,Scs,Ccs,As}, _, Opts) ->
                true ->
                    {step,'after',body(As, Opts)}
            end,
-           'end']};
+           {reserved,'end'}]};
 lexpr({'catch',_,Expr}, Prec, Opts) ->
     {P,R} = preop_prec('catch'),
     El = {list,[{step,'catch',lexpr(Expr, R, Opts)}]},
@@ -669,7 +678,7 @@ lexpr({match,_,Lhs,Rhs}, Prec, Opts) ->
     maybe_paren(P, Prec, El);
 lexpr({op,_,Op,Arg}, Prec, Opts) ->
     {P,R} = preop_prec(Op),
-    Ol = leaf(format("~s ", [Op])),
+    Ol = {reserved, leaf(format("~s ", [Op]))},
     El = [Ol,lexpr(Arg, R, Opts)],
     maybe_paren(P, Prec, El);
 lexpr({op,_,Op,Larg,Rarg}, Prec, Opts)  when Op =:= 'orelse';
@@ -677,14 +686,14 @@ lexpr({op,_,Op,Larg,Rarg}, Prec, Opts)  when Op =:= 'orelse';
     %% Breaks lines since R12B.
     {L,P,R} = inop_prec(Op),
     Ll = lexpr(Larg, L, Opts),
-    Ol = leaf(format("~s", [Op])),
+    Ol = {reserved, leaf(format("~s", [Op]))},
     Lr = lexpr(Rarg, R, Opts),
     El = {prefer_nl,[[]],[Ll,Ol,Lr]},
     maybe_paren(P, Prec, El);
 lexpr({op,_,Op,Larg,Rarg}, Prec, Opts) ->
     {L,P,R} = inop_prec(Op),
     Ll = lexpr(Larg, L, Opts),
-    Ol = leaf(format("~s", [Op])),
+    Ol = {reserved, leaf(format("~s", [Op]))},
     Lr = lexpr(Rarg, R, Opts),
     El = {list,[Ll,Ol,Lr]},
     maybe_paren(P, Prec, El);
@@ -830,6 +839,12 @@ cr_clause({clause,_,[T],G,B}, Opts) ->
 try_clauses(Cs, Opts) ->
     clauses(fun try_clause/2, Opts, Cs).
 
+try_clause({clause,_,[{tuple,_,[{atom,_,throw},V,S]}],G,B}, Opts) ->
+    El = lexpr(V, 0, Opts),
+    Sl = stack_backtrace(S, [El], Opts),
+    Gl = guard_when(Sl, G, Opts),
+    Bl = body(B, Opts),
+    {step,Gl,Bl};
 try_clause({clause,_,[{tuple,_,[C,V,S]}],G,B}, Opts) ->
     Cs = lexpr(C, 0, Opts),
     El = lexpr(V, 0, Opts),
@@ -898,16 +913,18 @@ lc_qual(Q, Opts) ->
     lexpr(Q, 0, Opts).
 
 proper_list(Es, Opts) ->
-    {seq,$[,$],$,,lexprs(Es, Opts)}.
+    {seq,$[,$],[$,],lexprs(Es, Opts)}.
 
 improper_list(Es, Opts) ->
-    {seq,$[,$],{$,,$|},lexprs(Es, Opts)}.
+    {seq,$[,$],[{$,,' |'}],lexprs(Es, Opts)}.
 
 tuple(L, Opts) ->
     tuple(L, fun lexpr/2, Opts).
 
+tuple([], _F, _Opts) ->
+    leaf("{}");
 tuple(Es, F, Opts) ->
-    {seq,${,$},$,,lexprs(Es, F, Opts)}.
+    {seq,${,$},[$,],lexprs(Es, F, Opts)}.
 
 args(As, Opts) ->
     {seq,$(,$),[$,],lexprs(As, Opts)}.
@@ -1000,8 +1017,10 @@ f({seq,Before,After,Sep,LItems}, I0, ST, WT, PP) ->
                     end,
             {BCharsL++Chars,Size};
         no ->
-            {BCharsL++insert_newlines(CharsSizeL, I, ST),
-             nsz(lists:last(Sizes), I0)}
+            CharsList = handle_step(CharsSizeL, I, ST),
+            {LChars, LSize} =
+                maybe_newlines(CharsList, LItems, I, NSepChars, ST),
+            {[BCharsL,LChars],nsz(LSize, I0)}
     end;
 f({force_nl,_ExtraInfoItem,Item}, I, ST, WT, PP) when I < 0 ->
     %% Extra info is a comment; cannot have that on the same line
@@ -1017,7 +1036,8 @@ f({prefer_nl,Sep,LItems}, I0, ST, WT, PP) ->
         Sizes =:= [] ->
             {[], 0};
         true ->
-            {insert_newlines(CharsSize2L, I0, ST),nsz(lists:last(Sizes), I0)}
+            {insert_newlines(CharsSize2L, I0, ST),
+             nsz(lists:last(Sizes), I0)}
     end;
 f({value,V}, I, ST, WT, PP) ->
     f(write_a_value(V, PP), I, ST, WT, PP);
@@ -1029,13 +1049,15 @@ f({char,C}, I, ST, WT, PP) ->
     f(write_a_char(C, PP), I, ST, WT, PP);
 f({string,S}, I, ST, WT, PP) ->
     f(write_a_string(S, I, PP), I, ST, WT, PP);
+f({reserved,R}, I, ST, WT, PP) ->
+    f(R, I, ST, WT, PP);
 f({hook,HookExpr,Precedence,Func,Options}, I, _ST, _WT, _PP) ->
     Chars = Func(HookExpr, I, Precedence, Options),
     {Chars,indentation(Chars, I)};
 f({ehook,HookExpr,Precedence,{Mod,Func,Eas}=ModFuncEas}, I, _ST, _WT, _PP) ->
     Chars = apply(Mod, Func, [HookExpr,I,Precedence,ModFuncEas|Eas]),
     {Chars,indentation(Chars, I)};
-f(WordName, _I, _ST, WT, _PP) -> % when is_atom(WordName)
+f(WordName, _I, _ST, WT, _PP) when is_atom(WordName) ->
     word(WordName, WT).
 
 -define(IND, 4).
@@ -1057,12 +1079,18 @@ fl(CItems, Sep0, I0, After, ST, WT, PP) ->
                     true ->
                         [CharSize1,f([Item2,S], incr(I0, ?IND), ST, WT, PP)]
                 end;
+           ({reserved,Word}, S) ->
+                [f([Word,S], I0, ST, WT, PP),{[],0}];
            (Item, S) ->
                 [f([Item,S], I0, ST, WT, PP),{[],0}]
         end,
-    {Sep,LastSep}  = case Sep0 of {_,_} -> Sep0; _ -> {Sep0,Sep0} end,
+    {Sep,LastSep} = sep(Sep0),
     fl1(CItems, F, Sep, LastSep, After).
 
+sep([{S,LS}]) -> {[S],[LS]};
+sep({_,_}=Sep) -> Sep;
+sep(S) -> {S, S}.
+
 fl1([CItem], F, _Sep, _LastSep, After) ->
     [F(CItem,After)];
 fl1([CItem1,CItem2], F, _Sep, LastSep, After) ->
@@ -1088,20 +1116,64 @@ unz1(CharSizes) ->
 nonzero(CharSizes) ->
     lists:filter(fun({_,Sz}) -> Sz =/= 0 end, CharSizes).
 
-insert_newlines(CharsSizesL, I, ST) when I >= 0 ->
-    insert_nl(foldr(fun([{_C1,0},{_C2,0}], A) ->
-                            A;
-                       ([{C1,_Sz1},{_C2,0}], A) ->
-                            [C1|A];
-                       ([{C1,_Sz1},{C2,Sz2}], A) when Sz2 > 0 ->
-                            [insert_nl([C1,C2], I+?IND, ST)|A]
-                    end, [], CharsSizesL), I, ST).
+maybe_newlines([{Chars,Size}], [], _I, _NSepChars, _ST) ->
+    {Chars,Size};
+maybe_newlines(CharsSizeList, Items, I, NSepChars, ST) when I >= 0 ->
+    maybe_sep(CharsSizeList, Items, I, NSepChars, nl_indent(I, ST)).
+
+maybe_sep([{Chars1,Size1}|CharsSizeL], [Item|Items], I0, NSepChars, Sep) ->
+    I1 = case classify_item(Item) of
+             atomic ->
+                 I0 + Size1;
+             _ ->
+                 ?MAXLINE+1
+         end,
+    maybe_sep1(CharsSizeL, Items, I0, I1, Sep, NSepChars, Size1, [Chars1]).
+
+maybe_sep1([{Chars,Size}|CharsSizeL], [Item|Items],
+           I0, I, Sep, NSepChars, Sz0, A) ->
+    case classify_item(Item) of
+        atomic when is_integer(Size) ->
+            Size1 = Size + 1,
+            I1 = I + Size1,
+            if
+                I1 =< ?MAXLINE ->
+                    A1 = if
+                             NSepChars > 0 -> [Chars,$\s|A];
+                             true -> [Chars|A]
+                         end,
+                    maybe_sep1(CharsSizeL, Items, I0, I1, Sep, NSepChars,
+                               Sz0 + Size1, A1);
+                true ->
+                    A1 = [Chars,Sep|A],
+                    maybe_sep1(CharsSizeL, Items, I0, I0 + Size, Sep,
+                               NSepChars, Size1, A1)
+            end;
+        _ ->
+            A1 = [Chars,Sep|A],
+            maybe_sep1(CharsSizeL, Items, I0, ?MAXLINE+1, Sep, NSepChars,
+                       0, A1)
+    end;
+maybe_sep1(_CharsSizeL, _Items, _Io, _I, _Sep, _NSepChars, Sz, A) ->
+    {lists:reverse(A), Sz}.
 
+insert_newlines(CharsSizesL, I, ST) when I >= 0 ->
+    {CharsL, _} = unz1(handle_step(CharsSizesL, I, ST)),
+    insert_nl(CharsL, I, ST).
+
+handle_step(CharsSizesL, I, ST) ->
+    map(fun([{_C1,0},{_C2,0}]) ->
+                {[], 0};
+           ([{C1,Sz1},{_C2,0}]) ->
+                {C1, Sz1};
+           ([{C1,Sz1},{C2,Sz2}]) when Sz2 > 0 ->
+                {insert_nl([C1,C2], I+?IND, ST),line_size([Sz1,Sz2])}
+        end, CharsSizesL).
 
 insert_nl(CharsL, I, ST) ->
     insert_sep(CharsL, nl_indent(I, ST)).
 
-insert_sep([Chars1 | CharsL], Sep) ->
+insert_sep([Chars1|CharsL], Sep) ->
     [Chars1 | [[Sep,Chars] || Chars <- CharsL]].
 
 nl_indent(0, _T) ->
@@ -1109,6 +1181,12 @@ nl_indent(0, _T) ->
 nl_indent(I, T) when I > 0 ->
     [$\n|spaces(I, T)].
 
+classify_item({atom, _}) -> atomic;
+classify_item({singleton_atom_type, _}) -> atomic;
+classify_item(Atom) when is_atom(Atom) -> atomic;
+classify_item({leaf, _, _}) -> atomic;
+classify_item(_) -> complex.
+
 same_line(I0, SizeL, NSepChars) ->
     try
         Size = lists:sum(SizeL) + NSepChars,
diff --git a/lib/stdlib/test/erl_pp_SUITE.erl b/lib/stdlib/test/erl_pp_SUITE.erl
index c79e29eb11..3eb1670806 100644
--- a/lib/stdlib/test/erl_pp_SUITE.erl
+++ b/lib/stdlib/test/erl_pp_SUITE.erl
@@ -52,7 +52,7 @@
 	  otp_6321/1, otp_6911/1, otp_6914/1, otp_8150/1, otp_8238/1,
 	  otp_8473/1, otp_8522/1, otp_8567/1, otp_8664/1, otp_9147/1,
           otp_10302/1, otp_10820/1, otp_11100/1, otp_11861/1, pr_1014/1,
-          otp_13662/1, otp_14285/1, otp_15592/1, otp_15751/1]).
+          otp_13662/1, otp_14285/1, otp_15592/1, otp_15751/1, otp_15755/1]).
 
 %% Internal export.
 -export([ehook/6]).
@@ -82,7 +82,7 @@ groups() ->
       [otp_6321, otp_6911, otp_6914, otp_8150, otp_8238,
        otp_8473, otp_8522, otp_8567, otp_8664, otp_9147,
        otp_10302, otp_10820, otp_11100, otp_11861, pr_1014, otp_13662,
-       otp_14285, otp_15592, otp_15751]}].
+       otp_14285, otp_15592, otp_15751, otp_15755]}].
 
 init_per_suite(Config) ->
     Config.
@@ -474,10 +474,10 @@ cond1(Config) when is_list(Config) ->
                     [{tuple,5,[{atom,5,x},{atom,5,y}]}]}]},
     CChars = flat_expr1(C),
     "cond\n"
-          "    {foo,bar} ->\n"
-          "        [a,b];\n"
+          "    {foo, bar} ->\n"
+          "        [a, b];\n"
           "    true ->\n"
-          "        {x,y}\n"
+          "        {x, y}\n"
           "end" = CChars,
     ok.
 
@@ -712,7 +712,7 @@ otp_6321(Config) when is_list(Config) ->
     Str = "S = hopp, {hej, S}. ",
     {done, {ok, Tokens, _EndLine}, ""} = erl_scan:tokens("", Str, _L=1),
     {ok, Exprs} = erl_parse:parse_exprs(Tokens),
-    "S = hopp, {hej,S}" = lists:flatten(erl_pp:exprs(Exprs)),
+    "S = hopp, {hej, S}" = lists:flatten(erl_pp:exprs(Exprs)),
     ok.
 
 %% OTP_6911. More newlines.
@@ -1112,7 +1112,7 @@ otp_11861(Config) when is_list(Config) ->
     A3 = erl_anno:new(3),
     "-optional_callbacks([bar/0]).\n" =
         pf({attribute,A3,optional_callbacks,[{bar,0}]}),
-    "-optional_callbacks([{bar,1,bad}]).\n" =
+    "-optional_callbacks([{bar, 1, bad}]).\n" =
         pf({attribute,A3,optional_callbacks,[{bar,1,bad}]}),
     ok.
 
@@ -1221,6 +1221,46 @@ otp_15751(_Config) ->
                     end">>),
     ok.
 
+otp_15755(_Config) ->
+    "[{a, b}, c, {d, e} | t]" =
+        flat_parse_and_pp_expr("[{a, b}, c, {d, e} | t]", 0, []),
+    "[{a, b},\n c, d,\n {d, e},\n 1, 2.0,\n {d, e},\n <<>>, {},\n {d, e},\n"
+    " [], [],\n {d, e} |\n t]" =
+        flat_parse_and_pp_expr("[{a,b},c,d,{d,e},1,2.0,{d,e},<<>>,"
+                               "{},{d,e},[],[],{d,e}|t]", 0, []),
+    "[{a, b},\n c, d,\n {d, e},\n 1, 2.0,\n {d, e},\n <<>>, {},\n {d, e},\n"
+    " [], [], d, e | t]" =
+        flat_parse_and_pp_expr("[{a,b},c,d,{d,e},1,2.0,{d,e},<<>>,"
+                               "{},{d,e},[],[],d,e|t]", 0, []),
+
+    "-type t() ::
+          a | b | c | a | b | a | b | a | b | a | b | a | b | a | b |
+          a | b | a | b | a | b.\n" =
+        lists:flatten(parse_and_pp_forms(
+             "-type t() :: a | b | c| a | b | a | b | a | b | a |"
+             " b | a | b | a | b | a | b | a | b |a | b.", [])),
+
+    "-type t() ::
+          {dict, 0, 16, 16, 8, 80, 48,
+           {[], [], [], [], [], [], [], [], [], [], [], [], [], [], [],
+            []},
+           {{[], [], [], [], [], [], [], [], [], [], [], [], [], [], []}}}.\n" =
+        lists:flatten(parse_and_pp_forms(
+             "-type t() :: {dict,0,16,16,8,80,48,"
+             "{[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]},"
+             "{{[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]}}}.", [])),
+
+    "-type t() ::
+          {{a},
+           0, 16,
+           {16},
+           8, 80, 48, a, b, e, f, 'sf s sdf', [], {},
+           {[]}}.\n" =
+        lists:flatten(parse_and_pp_forms(
+             "-type t() :: {{a}, 0, 16, {16}, 8, 80, 48, a, b, e, f,"
+             " 'sf s sdf', [], {}, {[]}}.", [])),
+    ok.
+
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 compile(Config, Tests) ->
@@ -1352,6 +1392,9 @@ pp_expr(List, Options) when is_list(List) ->
             not_ok
     end.
 
+flat_parse_and_pp_expr(String, Indent, Options) ->
+    lists:flatten(parse_and_pp_expr(String, Indent, Options)).
+
 parse_and_pp_expr(String, Indent, Options) ->
     StringDot = lists:flatten(String) ++ ".",
     erl_pp:expr(parse_expr(StringDot), Indent, Options).
diff --git a/lib/stdlib/test/qlc_SUITE.erl b/lib/stdlib/test/qlc_SUITE.erl
index 2354a08f78..8a43f15d2c 100644
--- a/lib/stdlib/test/qlc_SUITE.erl
+++ b/lib/stdlib/test/qlc_SUITE.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2004-2018. All Rights Reserved.
+%% Copyright Ericsson AB 2004-2019. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -2436,7 +2436,7 @@ info(Config) when is_list(Config) ->
        <<"{'EXIT', {badarg, _}} = 
                (catch qlc:info([X || {X} <- []], {n_elements, 0})),
           L = lists:seq(1, 1000),
-          \"[1,2,3,4,5,6,7,8,9,10|'...']\" = qlc:info(L, {n_elements, 10}),
+          \"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10 | '...']\" = qlc:info(L, {n_elements, 10}),
           {cons,A1,{integer,A2,1},{atom,A3,'...'}} =
             qlc:info(L, [{n_elements, 1},{format,abstract_code}]),
           1 = erl_anno:line(A1),
@@ -2447,8 +2447,8 @@ info(Config) when is_list(Config) ->
                                                             {atom,_,'...'}}}},
                      {call,_,_,_}]} = 
           qlc:info(Q, [{n_elements, 3},{format,abstract_code}]),
-          \"ets:match_spec_run([a,b,c,d,e,f],\n\"
-          \"                   ets:match_spec_compile([{'$1',[true],\"
+          \"ets:match_spec_run([a, b, c, d, e, f],\n\"
+          \"                   ets:match_spec_compile([{'$1', [true], \"
           \"[{{'$1'}}]}]))\" = 
              qlc:info(Q, [{n_elements, infinity}])">>,
 
@@ -6547,7 +6547,7 @@ otp_7114(Config) when is_list(Config) ->
 otp_7232(Config) when is_list(Config) ->
     Ts = [<<"L = [fun math:sqrt/1, list_to_pid(\"<0.4.1>\"),
                   erlang:make_ref()],
-             \"[fun math:sqrt/1,<0.4.1>,#Ref<\" ++ _  = qlc:info(L),
+             \"[fun math:sqrt/1, <0.4.1>, #Ref<\" ++ _  = qlc:info(L),
              {call,_,
                {remote,_,{atom,_,qlc},{atom,_,sort}},
                [{cons,_,
@@ -6563,7 +6563,7 @@ otp_7232(Config) when is_list(Config) ->
              \"qlc:sort([55296,56296],[{order,fun'-function/0-fun-2-'/2}])\" =
                 format_info(Q, true),
              AC = qlc:info(Q, {format, abstract_code}),
-             \"qlc:sort([55296,56296], [{order,fun '-function/0-fun-2-'/2}])\" =
+             \"qlc:sort([55296, 56296], [{order, fun '-function/0-fun-2-'/2}])\" =
                 binary_to_list(iolist_to_binary(erl_pp:expr(AC)))">>,
 
          %% OTP-7234. erl_parse:abstract() handles bit strings
@@ -7088,21 +7088,21 @@ manpage(Config) when is_list(Config) ->
               \"    V1 =\n\"
               \"        qlc:q([ \n\"
               \"               SQV ||\n\"
-              \"                   SQV <- [x,y]\n\"
+              \"                   SQV <- [x, y]\n\"
               \"              ],\n\"
-              \"              [{unique,true}]),\n\"
+              \"              [{unique, true}]),\n\"
               \"    V2 =\n\"
               \"        qlc:q([ \n\"
               \"               SQV ||\n\"
-              \"                   SQV <- [a,b]\n\"
+              \"                   SQV <- [a, b]\n\"
               \"              ],\n\"
-              \"              [{unique,true}]),\n\"
+              \"              [{unique, true}]),\n\"
               \"    qlc:q([ \n\"
-              \"           {X,Y} ||\n\"
+              \"           {X, Y} ||\n\"
               \"               X <- V1,\n\"
               \"               Y <- V2\n\"
               \"          ],\n\"
-              \"          [{unique,true}])\n\"
+              \"          [{unique, true}])\n\"
               \"end\",
           true = B =:= qlc:info(QH, unique_all)">>,
 
@@ -7118,19 +7118,19 @@ manpage(Config) when is_list(Config) ->
               \"    V1 =\n\"
               \"        qlc:q([ \n\"
               \"               P0 ||\n\"
-              \"                   P0 = {W,Y} <- ets:table(_)\n\"
+              \"                   P0 = {W, Y} <- ets:table(_)\n\"
               \"              ]),\n\"
               \"    V2 =\n\"
               \"        qlc:q([ \n\"
-              \"               [G1|G2] ||\n\"
+              \"               [G1 | G2] ||\n\"
               \"                   G2 <- V1,\n\"
               \"                   G1 <- ets:table(_),\n\"
               \"                   element(2, G1) =:= element(1, G2)\n\"
               \"              ],\n\"
-              \"              [{join,lookup}]),\n\"
+              \"              [{join, lookup}]),\n\"
               \"    qlc:q([ \n\"
-              \"           {X,Z,W} ||\n\"
-              \"               [{X,Z}|{W,Y}] <- V2\n\"
+              \"           {X, Z, W} ||\n\"
+              \"               [{X, Z} | {W, Y}] <- V2\n\"
               \"          ])\n\"
               \"end\",
           Info1 =
@@ -7155,25 +7155,28 @@ manpage(Config) when is_list(Config) ->
        \"    V1 =\n\"
        \"        qlc:q([ \n\"
        \"               P0 ||\n\"
-       \"                   P0 = {X,Z} <- qlc:keysort(1, [{a,1},{b,4},{c,6}], [])\n\"
+       \"                   P0 = {X, Z} <-\n\"
+       \"                       qlc:keysort(1, [{a, 1}, {b, 4}, {c, 6}], [])\n\"
        \"              ]),\n\"
        \"    V2 =\n\"
        \"        qlc:q([ \n\"
        \"               P0 ||\n\"
-       \"                   P0 = {W,Y} <- qlc:keysort(2, [{2,a},{3,b},{4,c}], [])\n\"
+       \"                   P0 = {W, Y} <-\n\"
+       \"                       qlc:keysort(2, [{2, a}, {3, b}, {4, c}], [])\n\"
+
        \"              ]),\n\"
        \"    V3 =\n\"
        \"        qlc:q([ \n\"
-       \"               [G1|G2] ||\n\"
+       \"               [G1 | G2] ||\n\"
        \"                   G1 <- V1,\n\"
        \"                   G2 <- V2,\n\"
        \"                   element(1, G1) == element(2, G2)\n\"
        \"              ],\n\"
-       \"              [{join,merge},{cache,list}]),\n\"
+       \"              [{join, merge}, {cache, list}]),\n\"
        \"    qlc:q([ \n\"
-       \"           {A,X,Z,W} ||\n\"
-       \"               A <- [a,b,c],\n\"
-       \"               [{X,Z}|{W,Y}] <- V3,\n\"
+       \"           {A, X, Z, W} ||\n\"
+       \"               A <- [a, b, c],\n\"
+       \"               [{X, Z} | {W, Y}] <- V3,\n\"
        \"               X =:= Y\n\"
        \"          ])\n\"
        \"end\",
@@ -7215,14 +7218,21 @@ manpage(Config) when is_list(Config) ->
                                             gb_trees:lookup(K,
                                                             gb_trees:from_orddict([]))
                                         of
-                                            {value,V} ->
-                                                [{K,V}];
+                                            {value, V} ->
+                                                [{K, V}];
                                             none ->
                                                 []
                                         end
                                  end,
-                                 [{1,a},{1,b},{1,c},{2,a},{2,b},{2,c}]),
-                   ets:match_spec_compile([{{{'$1','$2'},'_'},[],['$1']}]))\",
+                                 [{1, a},
+                                  {1, b},
+                                  {1, c},
+                                  {2, a},
+                                  {2, b},
+                                  {2, c}]),
+                   ets:match_spec_compile([{{{'$1', '$2'}, '_'},
+                                            [],
+                                            ['$1']}]))\",
           L = qlc:info(QH)">>
       ],
     run(Config, Ts),
diff --git a/lib/stdlib/test/shell_SUITE.erl b/lib/stdlib/test/shell_SUITE.erl
index 22136d687c..cdb6031b07 100644
--- a/lib/stdlib/test/shell_SUITE.erl
+++ b/lib/stdlib/test/shell_SUITE.erl
@@ -1,7 +1,7 @@
 %%
 %% %CopyrightBegin%
 %%
-%% Copyright Ericsson AB 2004-2018. All Rights Reserved.
+%% Copyright Ericsson AB 2004-2019. All Rights Reserved.
 %%
 %% Licensed under the Apache License, Version 2.0 (the "License");
 %% you may not use this file except in compliance with the License.
@@ -2591,7 +2591,7 @@ otp_7184(Config) when is_list(Config) ->
 otp_7232(Config) when is_list(Config) ->
     Info = <<"qlc:info(qlc:sort(qlc:q([X || X <- [55296,56296]]), "
              "{order, fun(A,B)-> A>B end})).">>,
-    "qlc:sort([55296,56296],\n"
+    "qlc:sort([55296, 56296],\n"
     "         [{order,\n"
     "           fun(A, B) ->\n"
     "                  A > B\n"
@@ -2752,7 +2752,7 @@ otp_10302(Config) when is_list(Config) ->
            h().">>,
 
     "ok.\n\"\x{400}\"\nA = \"\x{400}\".\nok.\n"
-    "1: io:setopts([{encoding,utf8}])\n-> ok.\n"
+    "1: io:setopts([{encoding, utf8}])\n-> ok.\n"
     "2: A = [1024] = \"\x{400}\"\n-> \"\x{400}\"\n"
     "3: b()\n-> ok.\nok.\n" = t({Node,Test4}),