Remove some unnecessary comments from tests

Author: SerafimArts

tests/Exception/SyntaxErrorExceptionTest.php

@@ -33,8 +33,6 @@ public function testExceptionPointsToTheUnexpectedToken(): void
     }
 
     /**
-     * Headers along with the way their failure is printed, up to the trace.
-     *
      * @return iterable<non-empty-string, array{string, string}>
      */
     public static function renderedExceptionsDataProvider(): iterable
@@ -117,10 +115,6 @@ public function testStringIsNotNamedInTheRenderedException(): void
         self::assertStringNotContainsString(' --> ', (string) self::catchSyntaxErrorException('int a'));
     }
 
-    /**
-     * A stream closed after the parsing is printed with the contents the
-     * parser has read.
-     */
     public function testExceptionOfClosedStreamIsRenderedWithTheSnippet(): void
     {
         $stream = \fopen('php://memory', 'w+b');

tests/Grammar/AttributesTest.php

@@ -13,13 +13,6 @@
 use PHPUnit\Framework\Attributes\CoversNothing;
 use PHPUnit\Framework\Attributes\DataProvider;
 
-/**
- * Checks the attributes of `resources/grammar/attributes.pp3` in every
- * syntax and in every position: a header is compared as the list of its
- * declarations printed as S-expressions, where an attribute is printed in
- * its own syntax, `[[gnu::aligned(8)]]`, and the attributes inside a
- * declarator wrap the type, `(attr _Nonnull (ptr int))`.
- */
 #[CoversNothing]
 final class AttributesTest extends TestCase
 {
@@ -28,7 +21,6 @@ final class AttributesTest extends TestCase
      */
     public static function syntaxesDataProvider(): iterable
     {
-        // C23
         yield 'standard attribute' => ['[[deprecated]];', '(attributes [[deprecated]])'];
         yield 'prefixed attribute' => ['[[gnu::packed]];', '(attributes [[gnu::packed]])'];
         yield 'several attributes' => ['[[a, b::c]];', '(attributes [[a]] [[b::c]])'];
@@ -44,7 +36,6 @@ public static function syntaxesDataProvider(): iterable
         yield 'keyword as a prefix' => ['[[int::x]];', '(attributes [[int::x]])'];
         yield 'reserved keyword as a name' => ['[[fallthrough, default]];', '(attributes [[fallthrough]] [[default]])'];
 
-        // GCC
         yield 'attribute of GCC' => ['__attribute__((packed));', '(attributes __attribute__((packed)))'];
         yield 'short spelling of GCC' => ['__attribute((packed));', '(attributes __attribute__((packed)))'];
         yield 'several attributes of GCC' => [
@@ -62,15 +53,13 @@ public static function syntaxesDataProvider(): iterable
             '(attributes __attribute__((const)) __attribute__((__const__)))',
         ];
 
-        // MSVC
         yield '__declspec' => ['__declspec(dllimport);', '(attributes __declspec(dllimport))'];
         yield '__declspec of several attributes' => [
             '__declspec(dllimport align(16) noreturn);',
             '(attributes __declspec(dllimport) __declspec(align(16)) __declspec(noreturn))',
         ];
         yield 'empty __declspec' => ['__declspec();', '(attributes )'];
 
-        // Keywords allowed among the specifiers
         foreach ([
             '__cdecl', '__stdcall', '__fastcall', '__thiscall', '__vectorcall', '__ptr32', '__ptr64', '__w64',
             '__forceinline',
@@ -151,7 +140,6 @@ public function testArgumentIsAnExpressionOrTheTokens(): void
      */
     public static function positionsDataProvider(): iterable
     {
-        // Among the specifiers
         yield 'before the specifiers' => ['[[a]] int x;', ['(variable [[a]] int x)']];
         yield 'after the specifiers' => ['int [[a]] x;', ['(variable [[a]] int x)']];
         yield 'among the specifiers' => [
@@ -197,7 +185,6 @@ public static function positionsDataProvider(): iterable
             '(variable int x = (sizeof {[[a]] int}))',
         ]];
 
-        // A declarator
         yield 'after the name' => ['int x [[a]];', ['(variable int x [[a]])']];
         yield 'after the name and before an array' => ['int x [[a]] [3];', ['(variable (array int 3) x [[a]])']];
         yield 'after the name of a function' => ['int f [[a]] (void);', ['(function (fn int (void)) f [[a]])']];
@@ -230,7 +217,6 @@ public static function positionsDataProvider(): iterable
             '(variable [[a]] int x [[b]] __attribute__((c)) = 1)',
         ]];
 
-        // Inside a declarator
         yield 'after a pointer' => ['int * [[a]] p;', ['(variable (ptr int [[a]]) p)']];
         yield 'after a pointer and its qualifiers' => ['int * [[a]] const _Nonnull p;', [
             '(variable [const (ptr int [[a]] _Nonnull)] p)',
@@ -248,8 +234,6 @@ public static function positionsDataProvider(): iterable
             'int (*f [[a]] (void) [[b]])(int) [[c]];',
             ['(function (fn (ptr (fn int (int) [[c]])) (void) [[b]]) f [[a]])'],
         ];
-        // A function wrapped into attributes is not told from an object, as
-        // a function of a typedef name is not
         yield 'at the start of a parenthesized function declarator' => ['void (__stdcall f)(int);', [
             '(variable (attr __stdcall (fn void (int))) f)',
         ]];
@@ -271,7 +255,6 @@ public static function positionsDataProvider(): iterable
             ['(typedef typedef (ptr (attr __cdecl (fn void (int)))) F)'],
         ];
 
-        // Parameters
         yield 'parameter' => ['void f([[a]] int x __attribute__((unused)), int y[2] [[b]]);', [
             '(function (fn void ([[a]] int x __attribute__((unused)), (array int 2 [[b]]) y)) f)',
         ]];
@@ -299,7 +282,6 @@ public static function positionsDataProvider(): iterable
             '(variable int x = (sizeof (ptr (attr __cdecl (fn void (void))))))',
         ]];
 
-        // Tags
         yield 'after struct' => ['struct [[a]] S;', ['(tag struct [[a]] S)']];
         yield 'after struct and before the body' => ['struct __attribute__((packed)) { int a; } s;', [
             '(variable struct __attribute__((packed)) _ { int a } s)',
@@ -320,7 +302,6 @@ public static function positionsDataProvider(): iterable
             '(tag enum E { A [[deprecated]]=1, B __attribute__((deprecated)), C })',
         ]];
 
-        // Members
         yield 'members' => ['struct S { [[a]] int x [[b]], y __attribute__((c)); };', [
             '(tag struct S { [[a]] int x [[b]]; [[a]] int y __attribute__((c)) })',
         ]];
@@ -398,10 +379,6 @@ public static function offsetsDataProvider(): iterable
     }
 
     /**
-     * Every attribute starts at its prefix or name, and a list of the
-     * attributes at its first attribute or, empty in an attribute
-     * declaration, where the declaration does.
-     *
      * @param list<non-empty-string> $expected
      */
     #[DataProvider('offsetsDataProvider')]
@@ -431,14 +408,11 @@ public static function invalidAttributesDataProvider(): iterable
         yield 'assembler label of a member' => ['struct S { int a __asm__("a"); };', 17, '__asm__'];
         yield 'two assembler labels' => ['int f(void) __asm__("a") __asm__("b");', 25, '__asm__'];
         yield 'attributes after struct alone' => ['struct [[a]];', 12, ';'];
-        // GCC allows its attributes in a parenthesized declarator only at
-        // the start of it
         yield 'attribute of GCC after an array in a parenthesized declarator' => [
             'int (*a[3] __attribute__((x)));',
             11,
             '__attribute__',
         ];
-        // Positions C23 has no attributes in
         yield 'attribute in the brackets of an array' => ['int a[[[x]] 3];', 7, '['];
         yield 'attribute after a parenthesized declarator' => ['int (*f) [[x]] (int);', 15, '('];
         yield 'attribute in a subscript' => ['int x = y[[z]];', 9, '[['];

tests/Grammar/DeclarationsTest.php

@@ -11,11 +11,6 @@
 use PHPUnit\Framework\Attributes\CoversNothing;
 use PHPUnit\Framework\Attributes\DataProvider;
 
-/**
- * Checks the external declarations of `resources/grammar/declarations.pp3`:
- * a header is compared as the list of its declarations printed as
- * S-expressions, `(variable static (ptr int) p = 0)`.
- */
 #[CoversNothing]
 final class DeclarationsTest extends TestCase
 {
@@ -63,7 +58,6 @@ public function testDeclarationsAreParsed(string $code, array $expected): void
      */
     public static function declaratorDeclarationsDataProvider(): iterable
     {
-        // The kind of the declaration
         yield 'variable' => ['extern const char *const names[16];', [
             '(variable extern (array [const (ptr [const char])] 16) names)',
         ]];
@@ -94,7 +88,6 @@ public static function declaratorDeclarationsDataProvider(): iterable
             '(variable typeof((fn int (void))) f)',
         ]];
 
-        // Several declarators
         yield 'several declarators' => ['int a, *b, c[3];', [
             '(variable int a)',
             '(variable (ptr int) b)',
@@ -115,7 +108,6 @@ public static function declaratorDeclarationsDataProvider(): iterable
             '(typedef typedef (ptr void) G)',
         ]];
 
-        // Tags with declarators are objects
         yield 'structure defined in a declaration' => ['struct S { int a; } a, *b;', [
             '(variable struct S { int a } a)',
             '(variable (ptr struct S { int a }) b)',
@@ -127,7 +119,6 @@ public static function declaratorDeclarationsDataProvider(): iterable
         yield 'enumeration with an underlying type' => ['enum E : int e;', ['(variable enum E : int e)']];
         yield 'atomic type' => ['_Atomic(int) x;', ['(variable _Atomic(int) x)']];
 
-        // The typedef name rule
         yield 'name after a modifier' => ['unsigned T;', ['(variable (unsigned _) T)']];
         yield 'typedef name after a modifier' => ['unsigned __int64 x;', ['(variable (unsigned __int64) x)']];
         yield 'typedef name after a modifier before a pointer' => ['unsigned T *p;', [
@@ -156,7 +147,6 @@ public static function declaratorDeclarationsDataProvider(): iterable
         yield 'name before an initializer without a type' => ['static x = 1;', ['(variable static _ x = 1)']];
         yield 'inferred type' => ['constexpr auto n = 1;', ['(variable constexpr auto _ n = 1)']];
 
-        // Initializers
         yield 'constant expression' => ['constexpr int N = 10;', ['(variable constexpr int N = 10)']];
         yield 'conditional expression' => ['int x = a ? b : c;', ['(variable int x = (? a b c))']];
         yield 'parenthesized comma expression' => ['int x = (1, 2);', ['(variable int x = (paren (, 1 2)))']];
@@ -182,7 +172,6 @@ public static function declaratorDeclarationsDataProvider(): iterable
             '(variable int c = {2})',
         ]];
 
-        // Compound literals
         yield 'compound literal of an array' => ['int *p = (int[]){1, 2};', [
             '(variable (ptr int) p = (compound (array int) {1, 2}))',
         ]];
@@ -211,7 +200,6 @@ public static function declaratorDeclarationsDataProvider(): iterable
             '(variable int x = (compound {static int} {1}))',
         ]];
 
-        // Function definitions, the body keeps its text
         yield 'function definition' => ['int f(void) { return 0; }', [
             '(definition (fn int (void)) f { return 0; })',
         ]];
@@ -234,7 +222,6 @@ public static function declaratorDeclarationsDataProvider(): iterable
         ]];
         yield 'body after a declarator of no function' => ['int x { 1 }', ['(definition int x { 1 })']];
 
-        // Extensions of GCC
         yield 'assembler label' => ['int f(void) __asm__("_f");', ['(function (fn int (void)) f asm("_f"))']];
         yield 'assembler label without underscores' => ['int f(void) asm("_f");', [
             '(function (fn int (void)) f asm("_f"))',
@@ -259,7 +246,6 @@ public static function declaratorDeclarationsDataProvider(): iterable
             '(typedef typedef (long long _) T)',
         ]];
 
-        // Semantically invalid, but syntactically valid
         yield 'typedef with an initializer' => ['typedef int x = 1;', ['(typedef typedef int x = 1)']];
         yield 'typedef with another storage class' => ['typedef static int x = 1;', [
             '(typedef typedef static int x = 1)',
@@ -331,9 +317,6 @@ public static function offsetsDataProvider(): iterable
     }
 
     /**
-     * Every declaration starts at its first specifier, and every node of an
-     * initializer at its first token.
-     *
      * @param list<non-empty-string> $expected
      */
     #[DataProvider('offsetsDataProvider')]

tests/Grammar/DeclaratorsTest.php

@@ -15,13 +15,6 @@
 use PHPUnit\Framework\Attributes\CoversNothing;
 use PHPUnit\Framework\Attributes\DataProvider;
 
-/**
- * Checks the declarators and the type names of
- * `resources/grammar/declarators.pp3`. A declarator is checked as a member
- * of a structure, which needs no other node around it, and a type name as
- * the operand of `sizeof`. The declared type is compared as an S-expression:
- * `(ptr (fn int (int)))` is a pointer to a function.
- */
 #[CoversNothing]
 final class DeclaratorsTest extends TestCase
 {
@@ -43,7 +36,6 @@ public static function membersDataProvider(): iterable
         yield 'atomic pointer' => ['int *_Atomic p;', '[_Atomic (ptr int)] p'];
         yield 'pointer to a qualified type' => ['const int *p;', '(ptr [const int]) p'];
 
-        // Arrays
         yield 'array' => ['int a[3];', '(array int 3) a'];
         yield 'array of arrays' => ['int a[2][3];', '(array (array int 3) 2) a'];
         yield 'array of pointers' => ['int *a[3];', '(array (ptr int) 3) a'];
@@ -64,7 +56,6 @@ public static function membersDataProvider(): iterable
         yield 'restrict without a size' => ['int a[restrict];', '(array int restrict) a'];
         yield 'atomic unspecified size' => ['int a[_Atomic *];', '(array int _Atomic *) a'];
 
-        // Functions
         yield 'function without parameters' => ['int f();', '(fn int ()) f'];
         yield 'function with void' => ['int f(void);', '(fn int (void)) f'];
         yield 'variadic function without parameters' => ['int f(...);', '(fn int (...)) f'];
@@ -105,14 +96,12 @@ public static function membersDataProvider(): iterable
             "(fn int (\xC3\x84 a, (ptr char) \xC3\x96)) f",
         ];
 
-        // Bit-fields
         yield 'bit-field' => ['int a : 3;', 'int a:3'];
         yield 'unnamed bit-field' => ['int : 3;', 'int _:3'];
         yield 'pointer bit-field' => ['int *a : 3;', '(ptr int) a:3'];
         yield 'parenthesized bit-field name' => ['int (a) : 3;', 'int a:3'];
         yield 'unnamed bit-field after a pointer' => ['int *a, : 3;', '(ptr int) a int _:3'];
 
-        // Semantically invalid, but syntactically valid
         yield 'function returning an array' => ['int f()[3];', '(fn (array int 3) ()) f'];
         yield 'function returning a function' => ['int f()(int);', '(fn (fn int (int)) ()) f'];
         yield 'array of functions' => ['int a[3](int);', '(array (fn int (int)) 3) a'];
@@ -198,8 +187,6 @@ public static function specifiersWithTypeNamesDataProvider(): iterable
         yield 'atomic type specifier' => ['_Atomic(int (*)(void));', '(type _Atomic((ptr (fn int (void)))))'];
         yield 'typeof of an array without a size' => ['typeof(T[]);', '(type typeof((array T)))'];
 
-        // A type name that reads as an expression is the expression, where
-        // the expression is allowed too
         yield 'typeof of a subscript' => ['typeof(T[3]);', '(type typeof(([] T 3)))'];
         yield 'typeof of a product' => ['typeof(a * (b));', '(type typeof((* a (paren b))))'];
         yield 'typeof of a call without arguments' => ['typeof(f());', '(type typeof((call f)))'];
@@ -212,9 +199,6 @@ public static function specifiersWithTypeNamesDataProvider(): iterable
         yield 'atomic array of a typedef name' => ['_Atomic(T[3]);', '(type _Atomic((array T 3)))'];
     }
 
-    /**
-     * Every specifier with a type name accepts an abstract declarator.
-     */
     #[DataProvider('specifiersWithTypeNamesDataProvider')]
     public function testTypeNameOfSpecifierIsParsed(string $code, string $expected): void
     {
@@ -246,10 +230,6 @@ public static function typeNamesReadAsExpressionsDataProvider(): iterable
         yield 'alignof of an array of a typedef name' => ['alignof(T[3])', '(alignof (paren ([] T 3)))'];
     }
 
-    /**
-     * A type name that starts with an identifier and reads as an expression
-     * as well is read as the expression, where the expression is allowed.
-     */
     #[DataProvider('typeNamesReadAsExpressionsDataProvider')]
     public function testTypeNameThatReadsAsAnExpressionIsReadAsTheExpression(string $code, string $expected): void
     {
@@ -280,10 +260,6 @@ public static function typeNamesReadAsTypesDataProvider(): iterable
         yield 'atomic array of a typedef name' => ['sizeof(_Atomic(T[3]))', '(sizeof _Atomic((array T 3)))'];
     }
 
-    /**
-     * A type name that cannot be an expression stays a type name, and so
-     * does any type name where only a type name is allowed.
-     */
     #[DataProvider('typeNamesReadAsTypesDataProvider')]
     public function testTypeNameThatCannotBeAnExpressionIsReadAsTheType(string $code, string $expected): void
     {
@@ -335,9 +311,6 @@ public static function offsetsDataProvider(): iterable
     }
 
     /**
-     * A type built by a declarator starts at its own token: the asterisk,
-     * the bracket or the parenthesis.
-     *
      * @param list<non-empty-string> $expected
      */
     #[DataProvider('offsetsDataProvider')]
@@ -375,8 +348,6 @@ public static function invalidDeclaratorsDataProvider(): iterable
         yield 'abstract bit-field' => ['struct S { int * : 3; };', 17, ':'];
         yield 'name in a type name' => ['static_assert(sizeof(int x));', 25, 'x'];
 
-        // A type name that reads as an expression is the expression in a
-        // cast, and the cast to an array or a function is lost with it
         yield 'cast to an array of a typedef name' => ['static_assert((T[3])x);', 20, 'x'];
         yield 'cast to a function of a typedef name' => ['static_assert((T *(U))x);', 22, 'x'];
     }