OTP-8562 Closing right parenthesis in macro definitions is mandatory.

When defining macros the closing right parenthesis before the dot is now
mandatory.

3 files changed, 67 insertions, 34 deletions

diff --git a/lib/hipe/cerl/erl_types.erl b/lib/hipe/cerl/erl_types.erl
index b4d80d359a..f3b91b3953 100644
--- a/lib/hipe/cerl/erl_types.erl
+++ b/lib/hipe/cerl/erl_types.erl
@@ -322,7 +322,7 @@
 -define(nil,                       #c{tag=?nil_tag}).
 -define(nonempty_list(Types, Term),?list(Types, Term, ?nonempty_qual)).
 -define(number(Set, Qualifier),    #c{tag=?number_tag, elements=Set, 
-				      qualifier=Qualifier}.
+				      qualifier=Qualifier}).
 -define(opaque(Optypes),           #c{tag=?opaque_tag, elements=Optypes}).
 -define(product(Types),            #c{tag=?product_tag, elements=Types}).
 -define(remote(RemTypes),          #c{tag=?remote_tag, elements=RemTypes}).
diff --git a/lib/stdlib/src/epp.erl b/lib/stdlib/src/epp.erl
index e1b569d389..f144cbb938 100644
--- a/lib/stdlib/src/epp.erl
+++ b/lib/stdlib/src/epp.erl
@@ -109,6 +109,8 @@ format_error(cannot_parse) ->
     io_lib:format("cannot parse file, giving up", []);
 format_error({bad,W}) ->
     io_lib:format("badly formed '~s'", [W]);
+format_error(missing_parenthesis) ->
+    io_lib:format("badly formed define: missing closing right parenthesis",[]);
 format_error({call,What}) ->
     io_lib:format("illegal macro call '~s'",[What]);
 format_error({undefined,M,none}) ->
@@ -415,7 +417,7 @@ scan_toks(From, St) ->
 	    leave_file(From, St#epp{location=Cl});
 	{error,_E} ->
             epp_reply(From, {error,{St#epp.location,epp,cannot_parse}}),
-	    leave_file(From, St)		%This serious, just exit!
+	    leave_file(wait_request(St), St)	%This serious, just exit!
     end.
 
 scan_toks([{'-',_Lh},{atom,_Ld,define}=Define|Toks], From, St) ->
@@ -491,26 +493,32 @@ scan_extends(_Ts, _As, Ms) -> Ms.
 
 scan_define([{'(',_Lp},{Type,_Lm,M}=Mac,{',',_Lc}|Toks], _Def, From, St)
   when Type =:= atom; Type =:= var ->
-    case dict:find({atom,M}, St#epp.macs) of
-        {ok, Defs} when is_list(Defs) ->
-            %% User defined macros: can be overloaded
-            case proplists:is_defined(none, Defs) of
-                true ->
-                    epp_reply(From, {error,{loc(Mac),epp,{redefine,M}}}),
+    case catch macro_expansion(Toks) of
+        Expansion when is_list(Expansion) ->
+            case dict:find({atom,M}, St#epp.macs) of
+                {ok, Defs} when is_list(Defs) ->
+                    %% User defined macros: can be overloaded
+                    case proplists:is_defined(none, Defs) of
+                        true ->
+                            epp_reply(From, {error,{loc(Mac),epp,{redefine,M}}}),
+                            wait_req_scan(St);
+                        false ->
+                            scan_define_cont(From, St,
+                                             {atom, M},
+                                             {none, {none,Expansion}})
+                    end;
+                {ok, _PreDef} ->
+                    %% Predefined macros: cannot be overloaded
+                    epp_reply(From, {error,{loc(Mac),epp,{redefine_predef,M}}}),
                     wait_req_scan(St);
-                false ->
+                error ->
                     scan_define_cont(From, St,
                                      {atom, M},
-                                     {none, {none,macro_expansion(Toks)}})
+                                     {none, {none,Expansion}})
             end;
-        {ok, _PreDef} ->
-            %% Predefined macros: cannot be overloaded
-            epp_reply(From, {error,{loc(Mac),epp,{redefine_predef,M}}}),
-            wait_req_scan(St);
-        error ->
-            scan_define_cont(From, St,
-                             {atom, M},
-                             {none, {none,macro_expansion(Toks)}})
+        {error,ErrL,What} ->
+            epp_reply(From, {error,{ErrL,epp,What}}),
+            wait_req_scan(St)
     end;
 scan_define([{'(',_Lp},{Type,_Lm,M}=Mac,{'(',_Lc}|Toks], Def, From, St)
   when Type =:= atom; Type =:= var ->
@@ -536,6 +544,9 @@ scan_define([{'(',_Lp},{Type,_Lm,M}=Mac,{'(',_Lc}|Toks], Def, From, St)
                 error ->
                     scan_define_cont(From, St, {atom, M}, {Len, {As, Me}})
             end;
+	{error,ErrL,What} ->
+            epp_reply(From, {error,{ErrL,epp,What}}),
+            wait_req_scan(St);
         _ ->
             epp_reply(From, {error,{loc(Def),epp,{bad,define}}}),
             wait_req_scan(St)
@@ -789,7 +800,7 @@ skip_toks(From, St, [I|Sis]) ->
 	    leave_file(From, St#epp{location=Cl,istk=[I|Sis]});
 	{error,_E} ->
             epp_reply(From, {error,{St#epp.location,epp,cannot_parse}}),
-	    leave_file(From, St)		%This serious, just exit!
+	    leave_file(wait_request(St), St)	%This serious, just exit!
     end;
 skip_toks(From, St, []) ->
     scan_toks(From, St).
@@ -816,7 +827,7 @@ macro_pars([{var,_L,Name}, {',',_}|Ts], Args) ->
     macro_pars(Ts, [Name|Args]).
 
 macro_expansion([{')',_Lp},{dot,_Ld}]) -> [];
-macro_expansion([{dot,_Ld}]) -> [];		%Be nice, allow no right paren!
+macro_expansion([{dot,Ld}]) -> throw({error,Ld,missing_parenthesis});
 macro_expansion([T|Ts]) ->
     [T|macro_expansion(Ts)].
 
diff --git a/lib/stdlib/test/epp_SUITE.erl b/lib/stdlib/test/epp_SUITE.erl
index 3342e8f1ff..4806b5d361 100644
--- a/lib/stdlib/test/epp_SUITE.erl
+++ b/lib/stdlib/test/epp_SUITE.erl
@@ -23,7 +23,8 @@
 	 upcase_mac/1, upcase_mac_1/1, upcase_mac_2/1,
 	 variable/1, variable_1/1, otp_4870/1, otp_4871/1, otp_5362/1,
          pmod/1, not_circular/1, skip_header/1, otp_6277/1, otp_7702/1,
-         otp_8130/1, overload_mac/1, otp_8388/1, otp_8470/1, otp_8503/1]).
+         otp_8130/1, overload_mac/1, otp_8388/1, otp_8470/1, otp_8503/1,
+         otp_8562/1]).
 
 -export([epp_parse_erl_form/2]).
 
@@ -63,7 +64,7 @@ all(doc) ->
 all(suite) ->
     [rec_1, upcase_mac, predef_mac, variable, otp_4870, otp_4871, otp_5362,
      pmod, not_circular, skip_header, otp_6277, otp_7702, otp_8130,
-     overload_mac, otp_8388, otp_8470, otp_8503].
+     overload_mac, otp_8388, otp_8470, otp_8503, otp_8562].
 
 rec_1(doc) ->
     ["Recursive macros hang or crash epp (OTP-1398)."];
@@ -616,9 +617,9 @@ otp_8130(Config) when is_list(Config) ->
              "t() -> 14 = (#file_info{size = 14})#file_info.size, ok.\n">>,
            ok},
 
-          {otp_8130_7,
+          {otp_8130_7_new,
            <<"-record(b, {b}).\n"
-             "-define(A, {{a,#b.b.\n"
+             "-define(A, {{a,#b.b).\n"
              "t() -> {{a,2}} = ?A}}, ok.">>,
            ok},
 
@@ -750,7 +751,14 @@ otp_8130(Config) when is_list(Config) ->
 
           {otp_8130_c24,
            <<"\n-include(\"no such file.erl\").\n">>,
-           {errors,[{{2,2},epp,{include,file,"no such file.erl"}}],[]}}
+           {errors,[{{2,2},epp,{include,file,"no such file.erl"}}],[]}},
+
+          {otp_8130_7,
+           <<"-record(b, {b}).\n"
+             "-define(A, {{a,#b.b.\n"
+             "t() -> {{a,2}} = ?A}}, ok.">>,
+           {errors,[{{2,20},epp,missing_parenthesis},
+                    {{3,19},epp,{undefined,'A',none}}],[]}}
 
           ],
     ?line [] = compile(Config, Cs),
@@ -1047,13 +1055,13 @@ overload_mac(Config) when is_list(Config) ->
             "-undef(A).\n"
             "t1() -> ?A.\n",
             "t2() -> ?A(1).">>,
-           {errors,[{{4,9},epp,{undefined,'A', none}},
-                    {{5,9},epp,{undefined,'A', 1}}],[]}},
+           {errors,[{{4,10},epp,{undefined,'A', none}},
+                    {{5,10},epp,{undefined,'A', 1}}],[]}},
 
           %% cannot overload predefined macros
           {overload_mac_c2,
            <<"-define(MODULE(X), X).">>,
-           {errors,[{{1,9},epp,{redefine_predef,'MODULE'}}],[]}},
+           {errors,[{{1,50},epp,{redefine_predef,'MODULE'}}],[]}},
 
           %% cannot overload macros with same arity
           {overload_mac_c3,
@@ -1120,27 +1128,27 @@ otp_8388(Config) when is_list(Config) ->
           {macro_1,
            <<"-define(m(A), A).\n"
              "t() -> ?m(,).\n">>,
-           {errors,[{{2,11},epp,{arg_error,m}}],[]}},
+           {errors,[{{2,9},epp,{arg_error,m}}],[]}},
           {macro_2,
            <<"-define(m(A), A).\n"
              "t() -> ?m(a,).\n">>,
-           {errors,[{{2,12},epp,{arg_error,m}}],[]}},
+           {errors,[{{2,9},epp,{arg_error,m}}],[]}},
           {macro_3,
            <<"-define(LINE, a).\n">>,
-           {errors,[{{1,9},epp,{redefine_predef,'LINE'}}],[]}},
+           {errors,[{{1,50},epp,{redefine_predef,'LINE'}}],[]}},
           {macro_4,
            <<"-define(A(B, C, D), {B,C,D}).\n"
              "t() -> ?A(a,,3).\n">>,
-           {errors,[{{2,8},epp,{mismatch,'A'}}],[]}},
+           {errors,[{{2,9},epp,{mismatch,'A'}}],[]}},
           {macro_5,
            <<"-define(Q, {?F0(), ?F1(,,4)}).\n">>,
-           {errors,[{{1,24},epp,{arg_error,'F1'}}],[]}},
+           {errors,[{{1,62},epp,{arg_error,'F1'}}],[]}},
           {macro_6,
            <<"-define(FOO(X), ?BAR(X)).\n"
              "-define(BAR(X), ?FOO(X)).\n"
              "-undef(FOO).\n"
              "test() -> ?BAR(1).\n">>,
-           {errors,[{{4,11},epp,{undefined,'FOO',1}}],[]}}
+           {errors,[{{4,12},epp,{undefined,'FOO',1}}],[]}}
          ],
     ?line [] = compile(Config, Ts),
     ok.
@@ -1175,6 +1183,20 @@ otp_8503(Config) when is_list(Config) ->
     ?line receive _ -> fail() after 0 -> ok end,
     ok.
 
+otp_8562(doc) ->
+    ["OTP-8503. Record with no fields is considered typed."];
+otp_8562(suite) ->
+    [];
+otp_8562(Config) when is_list(Config) ->
+    Cs = [{otp_8562,
+           <<"-define(P(), {a,b}.\n"
+             "-define(P3, .\n">>,
+           {errors,[{{1,60},epp,missing_parenthesis},
+                    {{2,13},epp,missing_parenthesis}], []}}
+         ],
+    ?line [] = compile(Config, Cs),
+    ok.
+
 check(Config, Tests) ->
     eval_tests(Config, fun check_test/2, Tests).