Syntactic support for PHP enums

ChangeLog.md

@@ -3,6 +3,12 @@ XP AST ChangeLog
 
 ## ?.?.? / ????-??-??
 
+## 7.1.0 / ????-??-??
+
+* Merged PR #23: Add syntactic support for PHP 8.1 enums. Implementation
+  in the compiler is in pull request xp-framework/compiler#106
+  (@thekid)
+
 ## 7.0.4 / 2021-03-07
 
 * Fixed *Call to undefined method ::emitoperator()* caused by standalone

src/main/php/lang/ast/nodes/EnumCase.class.php

@@ -0,0 +1,26 @@
+<?php namespace lang\ast\nodes;
+
+class EnumCase extends Annotated implements Member {
+  public $kind= 'enumcase';
+  public $name, $expression;
+
+  public function __construct($name, $expression, $annotations, $line= -1) {
+    $this->name= $name;
+    $this->expression= $expression;
+    $this->annotations= $annotations;
+    $this->line= $line;
+  }
+
+  /** @return string */
+  public function lookup() { return $this->name; }
+
+  /**
+   * Checks whether this node is of a given kind
+   *
+   * @param  string $kind
+   * @return bool
+   */
+  public function is($kind) {
+    return $this->kind === $kind || '@member' === $kind || parent::is($kind);
+  }
+}

src/main/php/lang/ast/nodes/EnumDeclaration.class.php

@@ -0,0 +1,18 @@
+<?php namespace lang\ast\nodes;
+
+use lang\ast\nodes\TypeDeclaration;
+
+class EnumDeclaration extends TypeDeclaration {
+  public $kind= 'enum';
+  public $base, $implements;
+
+  public function __construct($modifiers, $name, $base, $implements= [], $body= [], $annotations= [], $comment= null, $line= -1) {
+    parent::__construct($modifiers, $name, $body, $annotations, $comment, $line);
+    $this->implements= $implements;
+    $this->base= $base;
+  }
+
+  public function interfaces() { return $this->implements; }
+
+  public function case($name) { return $this->body[$name] ?? null; }
+}

src/main/php/lang/ast/syntax/PHP.class.php

@@ -14,6 +14,8 @@
   ContinueStatement,
   DoLoop,
   EchoStatement,
+  EnumCase,
+  EnumDeclaration,
   ForLoop,
   ForeachLoop,
   FunctionDeclaration,
@@ -860,7 +862,74 @@ public function __construct() {
       return $decl;
     });
 
-    $this->body('use', function($parse, &$body, $annotations, $modifiers, $holder) {
+    $this->stmt('enum', function($parse, $token) {
+      $name= $parse->scope->resolve($parse->token->value);
+      $parse->forward();
+      $comment= $parse->comment;
+      $parse->comment= null;
+
+      $implements= [];
+      if ('implements' === $parse->token->value) {
+        $parse->forward();
+        do {
+          $implements[]= $parse->scope->resolve($parse->token->value);
+          $parse->forward();
+          if (',' === $parse->token->value) {
+            $parse->forward();
+            continue;
+          } else if ('{' === $parse->token->value) {
+            break;
+          } else {
+            $parse->expecting(', or {', 'interfaces list');
+          }
+        } while (null !== $parse->token->value);
+      }
+
+      // Backed enums vs. unit enums
+      if (':' === $parse->token->value) {
+        $parse->forward();
+        $base= $parse->token->value;
+        $parse->forward();
+      } else {
+        $base= null;
+      }
+
+      $decl= new EnumDeclaration([], $name, $base, $implements, [], [], $comment, $token->line);
+      $parse->expecting('{', 'enum');
+      $decl->body= $this->typeBody($parse, $decl->name);
+      $parse->expecting('}', 'enum');
+
+      return $decl;
+    });
+
+    $this->body('case', function($parse, &$body, $meta, $modifiers, $holder) {
+      $parse->forward();
+      do {
+        $line= $parse->token->line;
+        $name= $parse->token->value;
+
+        $parse->forward();
+        if ('=' === $parse->token->value) {
+          $parse->forward();
+          $expr= $this->expression($parse, 0);
+        } else {
+          $expr= null;
+        }
+
+        $body[$name]= new EnumCase($name, $expr, $meta[DETAIL_ANNOTATIONS] ?? [], $line);
+        $body[$name]->holder= $holder;
+
+        if (',' === $parse->token->value) {
+          $parse->forward();
+          continue;
+        } else {
+          $parse->expecting(';', 'case');
+          break;
+        }
+      } while ($parse->token->value);
+    });
+
+    $this->body('use', function($parse, &$body, $meta, $modifiers, $holder) {
       $line= $parse->token->line;
 
       $parse->forward();

src/test/php/lang/ast/unittest/parse/AttributesTest.class.php

@@ -199,6 +199,11 @@ public function on_interface($attributes, $expected) {
     $this->assertAnnotated($expected, $this->type($attributes.' interface T { }'));
   }
 
+  #[Test, Values('attributes')]
+  public function on_enum($attributes, $expected) {
+    $this->assertAnnotated($expected, $this->type($attributes.' enum T { }'));
+  }
+
   #[Test, Values('attributes')]
   public function on_constant($attributes, $expected) {
     $type= $this->type('class T { '.$attributes.' const FIXTURE = 1; }');
@@ -222,4 +227,10 @@ public function on_parameter($attributes, $expected) {
     $type= $this->type('class T { public function fixture('.$attributes.' $p) { } }');
     $this->assertAnnotated($expected, $type->method('fixture')->signature->parameters[0]);
   }
+
+  #[Test, Values('attributes')]
+  public function on_enum_case($attributes, $expected) {
+    $type= $this->type('enum T { '.$attributes.' case ONE; }');
+    $this->assertAnnotated($expected, $type->case('ONE'));
+  }
 }

src/test/php/lang/ast/unittest/parse/TypesTest.class.php

@@ -1,7 +1,16 @@
 <?php namespace lang\ast\unittest\parse;
 
 use lang\ast\Errors;
-use lang\ast\nodes\{ClassDeclaration, InterfaceDeclaration, NamespaceDeclaration, TraitDeclaration, UseExpression};
+use lang\ast\nodes\{
+  ClassDeclaration,
+  InterfaceDeclaration,
+  EnumDeclaration,
+  EnumCase,
+  NamespaceDeclaration,
+  TraitDeclaration,
+  UseExpression,
+  Literal
+};
 use unittest\{Assert, Expect, Test};
 
 class TypesTest extends ParseTest {
@@ -86,6 +95,46 @@ public function empty_trait() {
     );
   }
 
+  #[Test]
+  public function empty_unit_enum() {
+    $this->assertParsed(
+      [new EnumDeclaration([], '\\A', null, [], [], [], null, self::LINE)],
+      'enum A { }'
+    );
+  }
+
+  #[Test]
+  public function empty_backed_enum() {
+    $this->assertParsed(
+      [new EnumDeclaration([], '\\A', 'string', [], [], [], null, self::LINE)],
+      'enum A: string { }'
+    );
+  }
+
+  #[Test]
+  public function unit_enum_with_cases() {
+    $enum= new EnumDeclaration([], '\\A', null, [], [], [], null, self::LINE);
+    $enum->declare(new EnumCase('ONE', null, [], self::LINE));
+    $enum->declare(new EnumCase('TWO', null, [], self::LINE));
+    $this->assertParsed([$enum], 'enum A { case ONE; case TWO; }');
+  }
+
+  #[Test]
+  public function backed_enum_with_cases() {
+    $enum= new EnumDeclaration([], '\\A', 'int', [], [], [], null, self::LINE);
+    $enum->declare(new EnumCase('ONE', new Literal('1', self::LINE), [], self::LINE));
+    $enum->declare(new EnumCase('TWO', new Literal('2', self::LINE), [], self::LINE));
+    $this->assertParsed([$enum], 'enum A: int { case ONE = 1; case TWO = 2; }');
+  }
+
+  #[Test]
+  public function unit_enum_with_grouped_cases() {
+    $enum= new EnumDeclaration([], '\\A', null, [], [], [], null, self::LINE);
+    $enum->declare(new EnumCase('ONE', null, [], self::LINE));
+    $enum->declare(new EnumCase('TWO', null, [], self::LINE));
+    $this->assertParsed([$enum], 'enum A { case ONE, TWO; }');
+  }
+
   #[Test]
   public function class_with_trait() {
     $class= new ClassDeclaration([], '\\A', null, [], [], [], null, self::LINE);