Move native enum support detection to types

Author: thekid

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

@@ -1,7 +1,7 @@
 <?php namespace lang\ast\emit;
 
 use lang\ast\Node;
-use lang\ast\nodes\{Literal, Variable};
+use lang\ast\types\Type;
 use lang\ast\types\{IsUnion, IsFunction, IsArray, IsMap, IsNullable, IsValue, IsLiteral};
 
 /**
@@ -12,12 +12,6 @@
 class PHP81 extends PHP {
   use RewriteBlockLambdaExpressions;
 
-  private static $ENUMS;
-
-  static function __static() {
-    self::$ENUMS= class_exists(\ReflectionEnum::class, false); // TODO remove once enum PR is merged
-  }
-
   /** Sets up type => literal mappings */
   public function __construct() {
     $this->literals= [
@@ -38,39 +32,6 @@ public function __construct() {
     ];
   }
 
-  /**
-   * Returns whether a given node is a constant expression:
-   *
-   * - Any literal
-   * - Arrays where all members are literals
-   * - Scope expressions with literal members (self::class, T::const)
-   * - 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($result, $node) {
-    if ($node instanceof Literal) {
-      return true;
-    } else if ($node instanceof ArrayLiteral) {
-      foreach ($node->values as $node) {
-        if (!$this->isConstant($result, $node)) return false;
-      }
-      return true;
-    } else if ($node instanceof ScopeExpression) {
-      return (
-        $node->member instanceof Literal &&
-        is_string($node->type) &&
-        !$result->lookup($node->type)->rewriteEnumCase($node->member->expression, self::$ENUMS)
-      );
-    } else if ($node instanceof BinaryExpression) {
-      return $this->isConstant($result, $node->left) && $this->isConstant($result, $node->right);
-    }
-    return false;
-  }
-
   protected function emitArguments($result, $arguments) {
     $i= 0;
     foreach ($arguments as $name => $argument) {
@@ -80,28 +41,8 @@ protected function emitArguments($result, $arguments) {
     }
   }
 
-  protected function emitScope($result, $scope) {
-    if ($scope->type instanceof Variable) {
-      $this->emitOne($result, $scope->type);
-      $result->out->write('::');
-      $this->emitOne($result, $scope->member);
-    } else if ($scope->type instanceof Node) {
-      $t= $result->temp();
-      $result->out->write('('.$t.'=');
-      $this->emitOne($result, $scope->type);
-      $result->out->write(')?'.$t.'::');
-      $this->emitOne($result, $scope->member);
-      $result->out->write(':null');
-    } else if ($scope->member instanceof Literal && $result->lookup($scope->type)->rewriteEnumCase($scope->member->expression, self::$ENUMS)) {
-      $result->out->write($scope->type.'::$'.$scope->member->expression);
-    } else {
-      $result->out->write($scope->type.'::');
-      $this->emitOne($result, $scope->member);
-    }
-  }
-
   protected function emitEnumCase($result, $case) {
-    if (self::$ENUMS) {
+    if (Type::$ENUMS) {
       $result->out->write('case '.$case->name);
       if ($case->expression) {
         $result->out->write('=');
@@ -114,7 +55,7 @@ protected function emitEnumCase($result, $case) {
   }
 
   protected function emitEnum($result, $enum) {
-    if (self::$ENUMS) {
+    if (Type::$ENUMS) {
       array_unshift($result->type, $enum);
       array_unshift($result->meta, []);
       $result->locals= [[], []];

src/main/php/lang/ast/types/Declaration.class.php

@@ -2,9 +2,11 @@
 
 use lang\ast\nodes\{EnumCase, Property};
 
-class Declaration implements Type {
+class Declaration extends Type {
   private $type, $result;
 
+  static function __static() { }
+
   /**
    * @param  lang.ast.nodes.TypeDeclaration $type
    * @param  lang.ast.Result $result
@@ -21,11 +23,10 @@ public function name() { return ltrim($this->type->name, '\\'); }
    * Returns whether a given member is an enum case
    *
    * @param  string $member
-   * @param  bool $native Whether native enum support exists
    * @return bool
    */
-  public function rewriteEnumCase($member, $native= false) {
-    if (!$native && 'enum' === $this->type->kind) {
+  public function rewriteEnumCase($member) {
+    if (!self::$ENUMS && 'enum' === $this->type->kind) {
       return ($this->type->body[$member] ?? null) instanceof EnumCase;
     } else if ('class' === $this->type->kind && '\\lang\\Enum' === $this->type->parent) {
       return ($this->type->body['$'.$member] ?? null) instanceof Property;

src/main/php/lang/ast/types/Reflection.class.php

@@ -2,9 +2,11 @@
 
 use lang\{Enum, ClassNotFoundException};
 
-class Reflection implements Type {
+class Reflection extends Type {
   private $reflect;
 
+  static function __static() { }
+
   /** @param string $type */
   public function __construct($type) {
     try {
@@ -21,13 +23,12 @@ public function name() { return $this->reflect->name; }
    * Returns whether a given member is an enum case
    *
    * @param  string $member
-   * @param  bool $native Whether enums are natively supported
    * @return bool
    */
-  public function rewriteEnumCase($member, $native= false) {
+  public function rewriteEnumCase($member) {
     if ($this->reflect->isSubclassOf(Enum::class)) {
       return $this->reflect->getStaticPropertyValue($member, null) instanceof Enum;
-    } else if (!$native && $this->reflect->isSubclassOf(\UnitEnum::class)) {
+    } else if (!self::$ENUMS && $this->reflect->isSubclassOf(\UnitEnum::class)) {
       $value= $this->reflect->getConstant($member) ?: $this->reflect->getStaticPropertyValue($member, null);
       return $value instanceof \UnitEnum;
     }

src/main/php/lang/ast/types/Type.class.php

@@ -1,16 +1,20 @@
 <?php namespace lang\ast\types;
 
-interface Type {
+abstract class Type {
+  public static $ENUMS;
+
+  static function __static() {
+    self::$ENUMS= class_exists(\ReflectionEnum::class, false); // TODO remove once enum PR is merged
+  }
 
   /** @return string */
-  public function name();
+  public abstract function name();
 
   /**
    * Returns whether a given member is an enum case
    *
    * @param  string $member
-   * @param  bool $native Whether native enum support exists
    * @return bool
    */
-  public function rewriteEnumCase($member, $native= false);
+  public abstract function rewriteEnumCase($member);
 }

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

@@ -37,6 +37,23 @@ public function cases_method() {
     );
   }
 
+  #[Test]
+  public function cases_method_does_not_yield_constants() {
+    $t= $this->type('enum <T> {
+      case Hearts;
+      case Diamonds;
+      case Clubs;
+      case Spades;
+
+      const COLORS = ["red", "black"];
+    }');
+
+    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> {