Add emitter for PHP enums

See xp-framework/ast#23

Author: thekid

composer.json

@@ -7,7 +7,7 @@
   "keywords": ["module", "xp"],
   "require" : {
     "xp-framework/core": "^10.0 | ^9.0 | ^8.0 | ^7.0",
-    "xp-framework/ast": "^7.0",
+    "xp-framework/ast": "dev-feature/php-enums as 7.1.0",
     "php" : ">=7.0.0"
   },
   "require-dev" : {

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

@@ -40,21 +40,26 @@ protected function declaration($name) {
    * - Binary expression where left- and right hand side are literals
    *
    * @see    https://wiki.php.net/rfc/const_scalar_exprs
+   * @param  lang.ast.Result $result
    * @param  lang.ast.Node $node
    * @return bool
    */
-  protected function isConstant($node) {
+  protected function isConstant($result, $node) {
     if ($node instanceof Literal) {
       return true;
     } else if ($node instanceof ArrayLiteral) {
       foreach ($node->values as $node) {
-        if (!$this->isConstant($node)) return false;
+        if (!$this->isConstant($result, $node)) return false;
       }
       return true;
     } else if ($node instanceof ScopeExpression) {
-      return $node->member instanceof Literal;
+      return (
+        $node->member instanceof Literal &&
+        is_string($node->type) &&
+        'enum' !== $result->lookup($node->type)->kind()
+      );
     } else if ($node instanceof BinaryExpression) {
-      return $this->isConstant($node->left) && $this->isConstant($node->right);
+      return $this->isConstant($result, $node->left) && $this->isConstant($result, $node->right);
     }
     return false;
   }
@@ -188,7 +193,7 @@ protected function emitStatic($result, $static) {
     foreach ($static->initializations as $variable => $initial) {
       $result->out->write('static $'.$variable);
       if ($initial) {
-        if ($this->isConstant($initial)) {
+        if ($this->isConstant($result, $initial)) {
           $result->out->write('=');
           $this->emitOne($result, $initial);
         } else {
@@ -284,7 +289,7 @@ protected function emitParameter($result, $parameter) {
       $result->out->write(($parameter->reference ? '&' : '').'$'.$parameter->name);
     }
     if ($parameter->default) {
-      if ($this->isConstant($parameter->default)) {
+      if ($this->isConstant($result, $parameter->default)) {
         $result->out->write('=');
         $this->emitOne($result, $parameter->default);
       } else {
@@ -349,6 +354,46 @@ protected function emitLambda($result, $lambda) {
     $this->emitOne($result, $lambda->body);
   }
 
+  protected function emitEnumCase($result, $case) {
+    $result->out->write('public static $'.$case->name.';');
+  }
+
+  protected function emitEnum($result, $enum) {
+    array_unshift($result->type, $enum);
+    array_unshift($result->meta, []);
+    $result->locals= [[], []];
+
+    $result->out->write('final class '.$this->declaration($enum->name).' implements \UnitEnum');
+    $enum->implements && $result->out->write(', '.implode(', ', $enum->implements));
+    $result->out->write('{');
+
+    $cases= [];
+    foreach ($enum->body as $member) {
+      if ($member->is('enumcase')) $cases[]= $member;
+      $this->emitOne($result, $member);
+    }
+
+    // Name and constructor
+    $result->out->write('public $name; private function __construct($name) { $this->name= $name; }');
+
+    // Enum cases
+    $result->out->write('public static function cases() { return [');
+    foreach ($cases as $case) {
+      $result->out->write('self::$'.$case->name.', ');
+    }
+    $result->out->write(']; }');
+
+    // Initializations
+    $result->out->write('static function __init() {');
+    foreach ($cases as $case) {
+      $result->out->write('self::$'.$case->name.'= new self("'.$case->name.'");');
+    }
+    $this->emitInitializations($result, $result->locals[0]);
+    $this->emitMeta($result, $enum->name, $enum->annotations, $enum->comment);
+    $result->out->write('}} '.$enum->name.'::__init();');
+    array_shift($result->type);
+  }
+
   protected function emitClass($result, $class) {
     array_unshift($result->type, $class);
     array_unshift($result->meta, []);
@@ -518,7 +563,7 @@ protected function emitProperty($result, $property) {
 
     $result->out->write(implode(' ', $property->modifiers).' '.$this->propertyType($property->type).' $'.$property->name);
     if (isset($property->expression)) {
-      if ($this->isConstant($property->expression)) {
+      if ($this->isConstant($result, $property->expression)) {
         $result->out->write('=');
         $this->emitOne($result, $property->expression);
       } else if (in_array('static', $property->modifiers)) {
@@ -571,7 +616,7 @@ protected function emitMethod($result, $method) {
         ];
       }
 
-      if (isset($param->default) && !$this->isConstant($param->default)) {
+      if (isset($param->default) && !$this->isConstant($result, $param->default)) {
         $meta[DETAIL_TARGET_ANNO][$param->name]['default']= [$param->default];
       }
     }
@@ -911,7 +956,7 @@ protected function emitScope($result, $scope) {
       $result->out->write(')?'.$t.'::');
       $this->emitOne($result, $scope->member);
       $result->out->write(':null');
-    } else if ($scope->member instanceof Literal && '$enum' === $result->lookup($scope->type)->kind()) {
+    } else if ($scope->member instanceof Literal && 'enum' === $result->lookup($scope->type)->kind()) {
       $result->out->write($scope->type.'::$'.$scope->member->expression);
     } else {
       $result->out->write($scope->type.'::');

src/test/php/lang/ast/unittest/emit/EnumTest.class.php

@@ -0,0 +1,53 @@
+<?php namespace lang\ast\unittest\emit;
+
+use unittest\actions\VerifyThat;
+use unittest\{Assert, Action, Test};
+
+#[Action(eval: 'new VerifyThat(fn() => function_exists("enum_exists"))')]
+class EnumTest extends EmittingTest {
+
+  #[Test]
+  public function name_property() {
+    $t= $this->type('enum <T> {
+      case Hearts;
+      case Diamonds;
+      case Clubs;
+      case Spades;
+
+      public static function run() {
+        return self::Hearts->name;
+      }
+    }');
+
+    Assert::equals('Hearts', $t->getMethod('run')->invoke(null));
+  }
+
+  #[Test]
+  public function cases_method() {
+    $t= $this->type('enum <T> {
+      case Hearts;
+      case Diamonds;
+      case Clubs;
+      case Spades;
+    }');
+
+    Assert::equals(
+      ['Hearts', 'Diamonds', 'Clubs', 'Spades'],
+      array_map(function($suit) { return $suit->name; }, $t->getMethod('cases')->invoke(null))
+    );
+  }
+
+  #[Test]
+  public function used_as_parameter_default() {
+    $t= $this->type('enum <T> {
+      case ASC;
+      case DESC;
+
+      public static function run($order= self::ASC) {
+        return $order->name;
+      }
+    }');
+
+    Assert::equals('ASC', $t->getMethod('run')->invoke(null));
+  }
+}