Allow reserved words as record names w/out quotes

This motivation for this comes from the Nitrogen Web Frameworks's heavy
use of records, and a clash between HTML <div> element and the Erlang
div operator.

In Nitrogen, HTML elements are represented by Erlang records. For
example: the HTML `<span>` element is `#span{}` in Nitrogen.

Logically, the heavily-used HTML `<div>` element would be represented
by `#div{}` in Nitrogen, however, that specific syntax is illegal due to
`div`'s reserved word status, and must instead be represented with
`#'div'`. This syntax, however, is awkward, and has led to a workaround
that *works*, but is itself awkward (using the term `#panel{}` instead
of `#div{}` - but this in itself leads to a semantic clash, as some
frontend HTML frameworks have their own 'panel' elements that might
ideally be abstracted into a `#panel{}` element.

But, As far as I understand, there is no potential syntax clash in
allowing the syntax `#div` ito be acceptable, and have the parser
recognize that the `div` (or any reserved word) in that `context` can
only be an atom, and would never be an operator.

So this change tweaks the grammar to recognize the circumstances of:
`#reserved_word{}`.

Further, this change does not change the way the records are defined (so
the definition must still be defined with the atom properly wrapped in
quotes (e.g. `-record('div', {a,b}).`).

This PR also adds the appropriate tests in `erl_expand_records_SUITE`,
which I wasn't sure if that was appropriate place, but it seemed the
most relevant.

Author: choptastic

lib/stdlib/src/erl_parse.yrl

@@ -34,7 +34,7 @@ list_comprehension lc_expr lc_exprs
 map_comprehension
 binary_comprehension
 tuple
-record_expr record_tuple record_field record_fields
+record_expr record_tuple record_field record_fields res_rec
 map_expr map_tuple map_field map_field_assoc map_field_exact map_fields map_key
 if_expr if_clause if_clauses case_expr cr_clause cr_clauses receive_expr
 fun_expr fun_clause fun_clauses atom_or_var integer_or_var
@@ -192,6 +192,11 @@ type -> '{' top_types '}'                 : {type, ?anno('$1'), tuple, '$2'}.
 type -> '#' atom '{' '}'                  : {type, ?anno('$1'), record, ['$2']}.
 type -> '#' atom '{' field_types '}'      : {type, ?anno('$1'),
                                              record, ['$2'|'$4']}.
+type -> '#' res_rec '{' '}'               : {type, ?anno('$1'),
+                                             record, [build_atom('$2')]}.
+type -> '#' res_rec '{' field_types '}'   : {type, ?anno('$1'),
+                                             record, [build_atom('$2')|'$4']}.
+
 type -> binary_type                       : '$1'.
 type -> integer                           : '$1'.
 type -> char                              : '$1'.
@@ -315,6 +320,10 @@ record_pat_expr -> '#' atom '.' atom :
 	{record_index,?anno('$1'),element(3, '$2'),'$4'}.
 record_pat_expr -> '#' atom record_tuple :
 	{record,?anno('$1'),element(3, '$2'),'$3'}.
+record_pat_expr -> '#' res_rec'.' atom :
+	{record_index,?anno('$1'),element(1, '$2'),'$4'}.
+record_pat_expr -> '#' res_rec record_tuple :
+	{record,?anno('$1'),element(1, '$2'),'$3'}.
 
 list -> '[' ']' : {nil,?anno('$1')}.
 list -> '[' expr tail : {cons,?anno('$1'),'$2','$3'}.
@@ -413,6 +422,19 @@ record_expr -> record_expr '#' atom '.' atom :
 record_expr -> record_expr '#' atom record_tuple :
 	{record,?anno('$2'),'$1',element(3, '$3'),'$4'}.
 
+record_expr -> '#' res_rec '.' atom :
+	{record_index,?anno('$1'),element(1, '$2'),'$4'}.
+record_expr -> '#' res_rec record_tuple :
+	{record, ?anno('$1'), element(1, '$2'), '$3'}.
+record_expr -> expr_max '#' res_rec '.' atom :
+	{record_field,?anno('$2'),'$1',element(1, '$3'),'$5'}.
+record_expr -> expr_max '#' res_rec record_tuple :
+	{record,?anno('$2'),'$1',element(1, '$3'),'$4'}.
+record_expr -> record_expr '#' res_rec '.' atom :
+	{record_field,?anno('$2'),'$1',element(1, '$3'),'$5'}.
+record_expr -> record_expr '#' res_rec record_tuple :
+	{record,?anno('$2'),'$1',element(1, '$3'),'$4'}.
+
 record_tuple -> '{' '}' : [].
 record_tuple -> '{' record_fields '}' : '$2'.
 
@@ -587,6 +609,34 @@ comp_op -> '>' : '$1'.
 comp_op -> '=:=' : '$1'.
 comp_op -> '=/=' : '$1'.
 
+res_rec -> 'after' : '$1'.
+res_rec -> 'begin' : '$1'.
+res_rec -> 'case' : '$1'.
+res_rec -> 'try' : '$1'.
+res_rec -> 'catch' : '$1'.
+res_rec -> 'end' : '$1'.
+res_rec -> 'fun' : '$1'.
+res_rec -> 'if' : '$1'.
+res_rec -> 'of' : '$1'.
+res_rec -> 'receive' : '$1'.
+res_rec -> 'when' : '$1'.
+res_rec -> 'maybe' : '$1'.
+res_rec -> 'else' : '$1'.
+res_rec -> 'andalso' : '$1'.
+res_rec -> 'orelse' : '$1'.
+res_rec -> 'bnot' : '$1'.
+res_rec -> 'not' : '$1'.
+res_rec -> 'div' : '$1'.
+res_rec -> 'rem' : '$1'.
+res_rec -> 'band' : '$1'.
+res_rec -> 'and' : '$1'.
+res_rec -> 'bor' : '$1'.
+res_rec -> 'bxor' : '$1'.
+res_rec -> 'bsl' : '$1'.
+res_rec -> 'bsr' : '$1'.
+res_rec -> 'or' : '$1'.
+res_rec -> 'xor' : '$1'.
+
 ssa_check_when_clauses -> ssa_check_when_clause : ['$1'].
 ssa_check_when_clauses -> ssa_check_when_clause ssa_check_when_clauses :
     ['$1'|'$2'].
@@ -1364,6 +1414,13 @@ build_bin_type([], Int) ->
 build_bin_type([{var, Aa, _}|_], _) ->
     ret_err(Aa, "Bad binary type").
 
+build_atom({Atom, Aa}) ->
+    {atom, Aa, Atom}.
+
+%print(X) ->
+%    io:format("Details: ~p~n",[X]),
+%    X.
+
 build_type({atom, A, Name}, Types) ->
     Tag = type_tag(Name, length(Types)),
     {Tag, A, Name, Types}.

lib/stdlib/test/erl_expand_records_SUITE.erl

@@ -39,7 +39,7 @@
 -export([attributes/1, expr/1, guard/1,
          init/1, pattern/1, strict/1, update/1,
 	 otp_5915/1, otp_7931/1, otp_5990/1,
-	 otp_7078/1, maps/1,
+	 otp_7078/1, pr_7873/1, maps/1,
          side_effects/1]).
 
 init_per_testcase(_Case, Config) ->
@@ -59,7 +59,7 @@ all() ->
 
 groups() -> 
     [{tickets, [],
-      [otp_5915, otp_7931, otp_5990, otp_7078]}].
+      [otp_5915, otp_7931, otp_5990, otp_7078, pr_7873]}].
 
 init_per_suite(Config) ->
     Config.
@@ -719,6 +719,76 @@ otp_7078(Config) when is_list(Config) ->
     run(Config, Ts, [strict_record_tests]),
     ok.
 
+%% PR-7873. Reserved words as record names.
+pr_7873(Config) when is_list(Config) ->
+    Words = [
+             <<"after">>,
+             <<"begin">>,
+             <<"case">>,
+             <<"try">>,
+             <<"catch">>,
+             <<"end">>,
+             <<"fun">>,
+             <<"if">>,
+             <<"of">>,
+             <<"receive">>,
+             <<"when">>,
+             <<"maybe">>,
+             <<"else">>,
+             <<"andalso">>,
+             <<"orelse">>,
+             <<"bnot">>,
+             <<"not">>,
+             <<"div">>,
+             <<"rem">>,
+             <<"band">>,
+             <<"and">>,
+             <<"bor">>,
+             <<"bxor">>,
+             <<"bsl">>,
+             <<"bsr">>,
+             <<"or">>,
+             <<"xor">>
+          ],
+
+    Code = <<"
+         -record('WORD', {a = 1}).
+
+         -type x() :: #WORD{}.
+
+         t() ->
+            'WORD' = element(1, #WORD{}),
+            2 = #WORD.a,
+            A = #WORD{},
+            _ = #WORD{a=5},
+            1 = A#WORD.a,
+            _ = A#WORD{},
+            C = A#WORD{a = 2},
+            2 = C#WORD.a,
+            #WORD{a = X} = C,
+            2 = X,
+            D = #WORD{a = 2}#WORD{a = 3},
+            4 = D#WORD{a = 4}#WORD.a,
+            3 = match1(D),
+            ok = match2(D, 3),
+            ok = match3(#WORD{a=#WORD{}}),
+            ok.
+
+         -spec match1(x()) -> any().
+         match1(#WORD{a = X}) -> X.
+
+         -spec match2(#WORD{}, any()) -> ok.
+         match2(Rec, V) when Rec#WORD.a == V -> ok.
+
+         match3(#WORD{a=#WORD{}}) -> ok.
+      ">>,
+    F = fun(Word) ->
+                binary:replace(Code, <<"WORD">>, Word, [global])
+        end,
+    Ts = lists:map(F, Words),
+    run(Config, Ts, [strict_record_tests]),
+    ok.
+
 id(I) -> I.
 
 -record(side_effects, {a,b,c}).