Support arbitrary expressions in property initializations and parameter defaults

See https://wiki.php.net/rfc/new_in_initializers

Author: thekid

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

@@ -1,6 +1,7 @@
 <?php namespace lang\ast\emit;
 
-use lang\ast\nodes\{InstanceExpression, ScopeExpression, Variable, Block};
+use lang\ast\Code;
+use lang\ast\nodes\{InstanceExpression, ScopeExpression, Variable, Literal, ArrayLiteral, Block};
 use lang\ast\types\{IsUnion, IsFunction, IsArray, IsMap};
 use lang\ast\{Emitter, Node, Type};
 
@@ -30,6 +31,31 @@ protected function declaration($name) {
     return substr($name, strrpos($name, '\\') + 1);
   }
 
+  /**
+   * Returns whether a given node is a so-called "static scalar" expression:
+   *
+   * - Any literal
+   * - Arrays where all members are literals
+   * - Scope expressions with literal members (self::class, T::const)
+   *
+   * @see    https://wiki.php.net/rfc/new_in_initializers
+   * @param  lang.ast.Node $node
+   * @return bool
+   */
+  protected function staticScalar($node) {
+    if ($node instanceof Literal) {
+      return true;
+    } else if ($node instanceof ArrayLiteral) {
+      foreach ($node->values as $node) {
+        if (!$this->staticScalar($node)) return false;
+      }
+      return true;
+    } else if ($node instanceof ScopeExpression) {
+      return $node->member instanceof Literal;
+    }
+    return false;
+  }
+
   /**
    * As of PHP 7.4: Property type declarations support all type declarations
    * supported by PHP with the exception of void and callable.
@@ -88,6 +114,21 @@ protected function enclose($result, $node, $signature, $emit) {
     $result->locals= array_pop($result->stack);
   }
 
+  /**
+   * Emits local initializations
+   *
+   * @param  lang.ast.Result $result
+   * @param  [:lang.ast.Node] $init
+   * @return void
+   */
+  protected function emitInitializations($result, $init) {
+    foreach ($init as $assign => $expression) {
+      $result->out->write($assign.'=');
+      $this->emitOne($result, $expression);
+      $result->out->write(';');
+    }
+  }
+
   /**
    * Convert blocks to IIFEs to allow a list of statements where PHP syntactically
    * doesn't, e.g. `fn`-style lambdas or match expressions.
@@ -235,8 +276,13 @@ protected function emitParameter($result, $parameter) {
       $result->out->write(($parameter->reference ? '&' : '').'$'.$parameter->name);
     }
     if ($parameter->default) {
-      $result->out->write('=');
-      $this->emitOne($result, $parameter->default);
+      if ($this->staticScalar($parameter->default)) {
+        $result->out->write('=');
+        $this->emitOne($result, $parameter->default);
+      } else {
+        $result->out->write('=null');
+        $result->locals['$']['null === $'.$parameter->name.' && $'.$parameter->name]= $parameter->default;
+      }
     }
     $result->locals[$parameter->name]= true;
   }
@@ -297,6 +343,7 @@ protected function emitLambda($result, $lambda) {
 
   protected function emitClass($result, $class) {
     array_unshift($result->meta, []);
+    $result->locals= ['$' => [], '@' => []];
 
     $result->out->write(implode(' ', $class->modifiers).' class '.$this->declaration($class->name));
     $class->parent && $result->out->write(' extends '.$class->parent);
@@ -306,7 +353,16 @@ protected function emitClass($result, $class) {
       $this->emitOne($result, $member);
     }
 
+    // Create constructor for property initializations to non-static scalars
+    // which have not already been emitted inside constructor
+    if ($result->locals['$']) {
+      $result->out->write('public function __construct() {');
+      $this->emitInitializations($result, $result->locals['$']);
+      $result->out->write('}');
+    }
+
     $result->out->write('static function __init() {');
+    $this->emitInitializations($result, $result->locals['@']);
     $this->emitMeta($result, $class->name, $class->annotations, $class->comment);
     $result->out->write('}} '.$class->name.'::__init();');
   }
@@ -452,15 +508,31 @@ protected function emitProperty($result, $property) {
 
     $result->out->write(implode(' ', $property->modifiers).' '.$this->propertyType($property->type).' $'.$property->name);
     if (isset($property->expression)) {
-      $result->out->write('=');
-      $this->emitOne($result, $property->expression);
+      if ($this->staticScalar($property->expression)) {
+        $result->out->write('=');
+        $this->emitOne($result, $property->expression);
+      } else if (in_array('static', $property->modifiers)) {
+        $result->locals['@']['self::$'.$property->name]= $property->expression;
+      } else {
+        $result->locals['$']['$this->'.$property->name]= $property->expression;
+      }
     }
     $result->out->write(';');
   }
 
   protected function emitMethod($result, $method) {
+
+    // Include non-static initializations for members in constructor, removing
+    // them to signal emitClass() no constructor needs to be generated.
+    if ('__construct' === $method->name && isset($result->locals['$'])) {
+      $locals= ['this' => true, '$' => $result->locals['$']];
+      $result->locals['$']= [];
+    } else {
+      $locals= ['this' => true, '$' => []];
+    }
     $result->stack[]= $result->locals;
-    $result->locals= ['this' => true];
+    $result->locals= $locals;
+
     $meta= [
       DETAIL_RETURNS     => $method->signature->returns ? $method->signature->returns->name() : 'var',
       DETAIL_ANNOTATIONS => $method->annotations,
@@ -469,11 +541,14 @@ protected function emitMethod($result, $method) {
       DETAIL_ARGUMENTS   => []
     ];
 
-    $declare= $promote= $params= '';
+    $result->out->write(implode(' ', $method->modifiers).' function '.$method->name);
+    $this->emitSignature($result, $method->signature);
+
+    $promoted= '';
     foreach ($method->signature->parameters as $param) {
       if (isset($param->promote)) {
-        $declare.= $param->promote.' $'.$param->name.';';
-        $promote.= '$this->'.$param->name.'= '.($param->reference ? '&$' : '$').$param->name.';';
+        $promoted.= $param->promote.' $'.$param->name.';';
+        $result->locals['$']['$this->'.$param->name]= new Code(($param->reference ? '&$' : '$').$param->name);
         $result->meta[0][self::PROPERTY][$param->name]= [
           DETAIL_RETURNS     => $param->type ? $param->type->name() : 'var',
           DETAIL_ANNOTATIONS => [],
@@ -485,18 +560,17 @@ protected function emitMethod($result, $method) {
       $meta[DETAIL_TARGET_ANNO][$param->name]= $param->annotations;
       $meta[DETAIL_ARGUMENTS][]= $param->type ? $param->type->name() : 'var';
     }
-    $result->out->write($declare);
-    $result->out->write(implode(' ', $method->modifiers).' function '.$method->name);
-    $this->emitSignature($result, $method->signature);
 
     if (null === $method->body) {
       $result->out->write(';');
     } else {
-      $result->out->write(' {'.$promote);
+      $result->out->write(' {');
+      $this->emitInitializations($result, $result->locals['$']);
       $this->emitAll($result, $method->body);
       $result->out->write('}');
     }
 
+    $result->out->write($promoted);
     $result->meta[0][self::METHOD][$method->name]= $meta;
     $result->locals= array_pop($result->stack);
   }

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

@@ -9,6 +9,10 @@ class Handle implements \IDisposable {
 
   public function __construct($id) { $this->id= $id; }
 
+  public function redirect($id) {
+    $this->id= $id;
+  }
+
   public function read($bytes= 8192) {
     self::$called[]= 'read@'.$this->id;
 

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

@@ -0,0 +1,84 @@
+<?php namespace lang\ast\unittest\emit;
+
+use lang\IllegalArgumentException;
+use unittest\{Assert, Expect, Test, Values};
+
+/**
+ * New in initializers
+ *
+ * @see  https://wiki.php.net/rfc/new_in_initializers
+ */
+class InitializeWithNewTest extends EmittingTest {
+
+  #[Test]
+  public function property() {
+    $r= $this->run('use lang\ast\unittest\emit\Handle; class <T> {
+      private $h= new Handle(0);
+
+      public function run() {
+        return $this->h;
+      }
+    }');
+    Assert::equals(new Handle(0), $r);
+  }
+
+  #[Test]
+  public function property_initialization_accessible_inside_constructor() {
+    $r= $this->run('use lang\ast\unittest\emit\Handle; class <T> {
+      private $h= new Handle(0);
+
+      public function __construct() {
+        $this->h->redirect(1);
+      }
+
+      public function run() {
+        return $this->h;
+      }
+    }');
+    Assert::equals(new Handle(1), $r);
+  }
+
+  #[Test]
+  public function promoted_property() {
+    $r= $this->run('use lang\ast\unittest\emit\Handle; class <T> {
+      public function __construct(private $h= new Handle(0)) { }
+
+      public function run() {
+        return $this->h;
+      }
+    }');
+    Assert::equals(new Handle(0), $r);
+  }
+
+  #[Test]
+  public function parameter_default_when_omitted() {
+    $r= $this->run('use lang\ast\unittest\emit\Handle; class <T> {
+      public function run($h= new Handle(0)) {
+        return $h;
+      }
+    }');
+    Assert::equals(new Handle(0), $r);
+  }
+
+  #[Test]
+  public function parameter_default_when_passed() {
+    $r= $this->run('use lang\ast\unittest\emit\Handle; class <T> {
+      public function run($h= new Handle(0)) {
+        return $h;
+      }
+    }', new Handle(1));
+    Assert::equals(new Handle(1), $r);
+  }
+
+  #[Test]
+  public function property_reference_as_parameter_default() {
+    $r= $this->run('use lang\ast\unittest\emit\Handle; class <T> {
+      private static $h= new Handle(0);
+
+      public function run($h= self::$h) {
+        return $h;
+      }
+    }');
+    Assert::equals(new Handle(0), $r);
+  }
+}