Read a member macro with a body in a class body

A MEMBER WITH NO TYPE AND A BODY, WHOSE NAME IS NOT THE NAME OF ITS CLASS, READ
AS A FUNCTION DEFINITION. C++ gives a member with no decl-specifier-seq three
readings, a constructor, a destructor and a conversion function ([class.mem],
GCC `cp_parser_member_declaration`, Clang `ParseCXXClassMemberDeclaration`), and
a constructor takes the name of its class. `TEST_METHOD(TestReflow) { ... }` in
`class TextBufferTests` of terminal, `SERIALIZE_METHODS(AddrInfo, obj) { ... }`
of bitcoin, `DENC(bufferlist::const_iterator& p) { ... }` of ceph and
`BOOST_CONCEPT_USAGE(WritableIterator) { ... }` of boost are macro invocations
with a body, and each read as a function definition with a declarator and no
type. C++ cannot produce that tree. The member form before a `;` reads such a
name as a macro since a62d1cb, and this commit gives the same reading to the
form with a body.

THE POPULATION. A census of the class bodies of the corpus at 7c0d954 counts
2,417 members with no type, a body and a name that the class does not carry, in
611 files and 556 distinct trees. 1,878 of them stand in a file with no error,
and 1,680 have a name with no lowercase letter.

THE REPAIR. The branch that reads `NAME(args) { ... }` where a macro call
statement can start now reads it where a member starts as well. The two
positions share the test of the brace, and the member adds the guard of the
name: `member_macro_name` holds where a member starts, the name has the shape of
a macro name with two characters or more, and no class head of the file recorded
the name. That is the guard of the member form before a `;`.

THE NAME IS THE EVIDENCE, BECAUSE THE ARGUMENTS AND THE BRACE PROVE NOTHING
HERE. A constructor definition takes the same arguments and the same brace, so
only the name of the class tells the two apart. The class record holds that
name. The brace test of the call form stays: a brace that holds a list of
expressions with a `;` after it, or with a comma in it, is a declaration and not
a body, so `COUNTER(int, x){0};` and `LIST(int, y) { 1, 2 };` in a class body
keep the reading of the base.

WHAT THE SHAPE OF THE NAME LEAVES OUT, MEASURED WITH A DRAFT THAT DROPS IT. A
draft that takes every member name that the class record does not hold changes
1,706 sites in 407 files with no error at 7c0d954, 158 more than this commit.
At fd2e2db it changes the same 407 files with no error and 73 files with an
error, and its NEW ERROR is 0 as well. Every one of
the 158 is a constructor that C++ accepts: 148 in a class whose head ends with a
macro, `class MatOp_Identity CV_FINAL : public MatOp {` of opencv, which is the
population of tree-sitter#280, 8 whose return type a macro call gives on the line before or
which stand in a branch for the documentation only, and 2 of `class alignas(void
*) Stmt {` in `Stmt.h` of clang, where 97 class heads stand in one file and the
record of 32 names gave up `Stmt` before line 1496. The shape of the name leaves
each of them with its constructor.

THE NUMBERS AT fd2e2db, measured with the command of each gate step. Changed
hash with no error in A: 278 corpus files and 0 compiler test files. With an
error in A: 35 files, each with one error before and one error after. NEW ERROR
0, FIXED 0, more error bytes 0. The regions read whole: 1,548 sites in the 278
clean files, each a `function_definition` that becomes a `macro_invocation`, and
no other root pair. The sites carry 32 names, and each name is a
function-like macro. 1,011 sites have the name in the seed of their own project.
534 sites of terminal use `TEST_METHOD`, `TEST_CLASS_SETUP`,
`TEST_CLASS_CLEANUP`, `TEST_METHOD_SETUP` and `TEST_METHOD_CLEANUP`, which the
TAEF header `WexTestClass.h` of the Windows test framework defines. The corpus
holds no copy of that header, so no seed of the corpus can hold those five
names, and the name shape is the only evidence there (tree-sitter#372). 3 sites of cgal use
`BOOST_CONCEPT_USAGE`, which boost defines and cgal only uses, so the name
stands in the seed of a different project of the corpus (tree-sitter#360, item 6). The 35 files with an error hold 94 more sites of the same shape, read
with both binaries: `BOOST_CATCH(...)`, `SFL_CATCH (...)`, `JSON_CATCH(...)` and
`STDEXEC_CATCH(...)` after a try macro, and the TAEF methods of terminal. Each
of them becomes a macro invocation with a body, and the one error of the file
stays.

THE SEEDED PASS AND THE BASELINES AT fd2e2db. Each side collects its own seeds,
1,239,343 names in 64 projects, and the two collections are byte-identical. The
seeded pass changes the same 278 clean files and the same 35 files with an
error, with the same 1,548 sites, NEW ERROR 0 and FIXED 0. Ties 3,110 and dedupe
2,818 did not rise and did not fall. The seed check agrees. The co-validity
inventory holds 12 rows on each side, added 0 and removed 0. The census of the
gate: 0 detectors rose, `inclass_notype` fell from 2,731 to 1,183 in the stable
population, which is the 1,548 sites, and `nested_fn` fell by 3, because the
body of a macro invocation is no longer the block of a nested function. The
differ: added 0, fell 0, agreement 99.110% on each side. Parse operations
0.99999 of the base, parse time 1.002.

THE BASE OF THESE NUMBERS. Each number above was measured at fd2e2db, and the
same command gave the same number at 7c0d954 before it, with four commits
between the two. The commit sits on 3a9ad80, whose own gate measured 0 changed
trees in the corpus, 0 in the compiler tests and 0 under the seeds, so its
changed-file list is empty and no file of it meets the 313 files of this
commit.

WHAT STAYS, AND WHY. Of the 1,878 population sites in a file with no error, 330
keep their tree.
  291 are constructors in a class whose head ends with a macro, `class
    MatOp_Identity CV_FINAL : public MatOp {` of opencv. The record takes the
    last name of the head, so it holds `CV_FINAL` and not the name of the class.
    That is the population of tree-sitter#280, and the decision on it belongs to the user.
    148 of them stand at a member start, and the draft with no shape guard turns
    each one into a macro. 143 stand behind a specifier, a macro or a template
    head, where no token of this scan can start.
  7 have an uppercase name and a word between the group and the brace:
    `BOOST_CNV_STRING_ENABLE(...) const { ... }` of boost,
    `NS_IMETHOD_(int32_t) ID() override { ... }` of firefox, and
    `timeout ASIO_PREVENT_MACRO_SUBSTITUTION()` of asio. The scan reads the
    brace after the group only.
  32 have a mixed-case name: a return type that a macro call gives on the line
    before, a constructor of the class that the other branch of a directive
    names, and other misses of the record.

One pin is new, with fields: the TAEF methods of a test class, the constructor
of that class, a field, and `DENC(int x) { }` in `class DENC`, where the record
holds the name and the constructor keeps its reading. With the macros defined,
GCC 16.2 and Clang 22.1 accept the text. Two syntax snippets are new, with the
terminal, bitcoin and ceph shapes.

Author: GrigoryEvko

src/scanner.c

@@ -4023,7 +4023,7 @@ static Invocation scan_macro_invocation(Reader *reader, const char *name, size_t
             // A call in an argument gives a body to the macro, and no function definition starts:
             // `MATCHER_P(IsNode, height, absl::StrCat("height ", height)) {`.
             block = lexer->lookahead == '{';
-        } else if (call && valid_symbols[MACRO_CALL_START] && lexer->lookahead == '{') {
+        } else if (call && (valid_symbols[MACRO_CALL_START] || member_macro_name) && lexer->lookahead == '{') {
             // A NAME WITH A GROUP AND A BODY IS A MACRO WHERE A CALL STATEMENT CAN START. The other
             // reading of that text is a constructor definition, which has no decl-specifier-seq. At
             // namespace scope C++ takes that definition only with a QUALIFIED name, and GCC gives
@@ -4035,6 +4035,18 @@ static Invocation scan_macro_invocation(Reader *reader, const char *name, size_t
             // unqualified constructor IS correct, the token is not valid, and `S(int x) { }` keeps
             // its reading.
             //
+            // IN A CLASS BODY THE NAME IS THE EVIDENCE, AS IT IS FOR THE MEMBER BEFORE A `;`. A
+            // member with no decl-specifier-seq has three readings, a constructor, a destructor and
+            // a conversion function ([class.mem]), and a constructor takes the name of its class. A
+            // member with a body whose name is not the name of its class is a macro:
+            // `TEST_METHOD(TestReflow) { ... }` of the TAEF header of terminal,
+            // `SERIALIZE_METHODS(AddrInfo, obj) { ... }` of bitcoin, and
+            // `DENC(bufferlist::const_iterator& p) { ... }` of ceph. `member_macro_name` holds the
+            // same guard as the member form before a `;`: a macro-shaped name of two characters or
+            // more that no class head of the file recorded. The record gives up the oldest name
+            // after MAX_CLASSES names and misses a head that holds an error, and a name with a
+            // lowercase letter keeps its constructor until the record is right.
+            //
             // THE ARGUMENTS GIVE NO EVIDENCE HERE, SO THE BRACE MUST. An enumerator list and a
             // braced initializer hold a list of expressions: no `;`, no statement keyword, and no
             // two words in sequence at the top level. Such a brace is a declaration when a `;` comes

test/corpus/macros.txt

@@ -148,6 +148,87 @@ struct S {
           (identifier)
           (number_literal))))))
 
+================================================================================
+A member macro with a body in a class body
+================================================================================
+
+class TextBufferTests
+{
+    TEST_METHOD(TestReflow)
+    {
+        VERIFY(1);
+    }
+
+    TEST_CLASS_SETUP(ClassSetup)
+    {
+        return true;
+    }
+
+    TextBufferTests(int x) : _y(x)
+    {
+    }
+
+    int _y;
+};
+
+class DENC
+{
+    DENC(int x)
+    {
+    }
+};
+
+--------------------------------------------------------------------------------
+
+(translation_unit
+  (class_specifier
+    name: (type_identifier)
+    body: (field_declaration_list
+      (macro_invocation
+        name: (identifier)
+        arguments: (token_tree
+          (identifier))
+        body: (compound_statement
+          (expression_statement
+            (call_expression
+              function: (identifier)
+              arguments: (argument_list
+                (number_literal))))))
+      (macro_invocation
+        name: (identifier)
+        arguments: (token_tree
+          (identifier))
+        body: (compound_statement
+          (return_statement
+            (true))))
+      (function_definition
+        declarator: (function_declarator
+          declarator: (identifier)
+          parameters: (parameter_list
+            (parameter_declaration
+              type: (primitive_type)
+              declarator: (identifier))))
+        (field_initializer_list
+          (field_initializer
+            (field_identifier)
+            (argument_list
+              (identifier))))
+        body: (compound_statement))
+      (field_declaration
+        type: (primitive_type)
+        declarator: (field_identifier))))
+  (class_specifier
+    name: (type_identifier)
+    body: (field_declaration_list
+      (function_definition
+        declarator: (function_declarator
+          declarator: (identifier)
+          parameters: (parameter_list
+            (parameter_declaration
+              type: (primitive_type)
+              declarator: (identifier))))
+        body: (compound_statement)))))
+
 ================================================================================
 A constructor and a parenthesized declarator beside a member macro
 ================================================================================

test/syntax/macros.txt

@@ -26,6 +26,21 @@ class TApplication : public TObject {
    int x;
    ClassDefOverride(TApplication,0)  //GUI application singleton
 };
+### macro_member_with_a_body
+class TextBufferTests {
+    TEST_METHOD(TestReflow)
+    {
+        VERIFY(1);
+    }
+    TEST_CLASS_SETUP(ClassSetup) { return true; }
+    TextBufferTests(int x) : _y(x) { }
+    int _y;
+};
+### macro_member_with_a_body_and_two_arguments
+struct AddrInfo {
+    SERIALIZE_METHODS(AddrInfo, obj) { READWRITE(obj.source); }
+    DENC(bufferlist::const_iterator& p) { decode(v, p); }
+};
 ### macro_pointer_lowercase_name
 void f(char* absl_nonnull error, std::string* absl_nullable out);
 ### macro_call_top_level