Adapt to AST type refactoring

See xp-framework/ast#39

Author: thekid

composer.json

@@ -7,7 +7,7 @@
   "keywords": ["module", "xp"],
   "require" : {
     "xp-framework/core": "^11.0 | ^10.0",
-    "xp-framework/ast": "^8.1",
+    "xp-framework/ast": "dev-refactor/types as 9.0.0",
     "php" : ">=7.0.0"
   },
   "require-dev" : {

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

@@ -28,7 +28,7 @@ public function name() { return ltrim($this->type->name, '\\'); }
   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) {
+    } else if ('class' === $this->type->kind && $this->type->parent && '\\lang\\Enum' === $this->type->parent->literal()) {
       return ($this->type->body['$'.$member] ?? null) instanceof Property;
     }
     return false;

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

@@ -70,11 +70,11 @@ public function lookup($type) {
     if ('self' === $type || 'static' === $type) {
       return new Declaration($this->type[0], $this);
     } else if ('parent' === $type) {
-      return $this->lookup($this->type[0]->parent);
+      return $this->lookup($this->type[0]->parent->literal());
     }
 
     foreach ($this->type as $enclosing) {
-      if ($type === $enclosing->name) return new Declaration($enclosing, $this);
+      if ($enclosing->name && $type === $enclosing->name->literal()) return new Declaration($enclosing, $this);
     }
 
     return new Reflection($type);

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

@@ -14,7 +14,7 @@
   UnpackExpression,
   Variable
 };
-use lang\ast\types\{IsUnion, IsFunction, IsArray, IsMap, IsNullable};
+use lang\ast\types\{IsUnion, IsFunction, IsArray, IsMap, IsNullable, IsExpression};
 use lang\ast\{Emitter, Node, Type, Result};
 
 abstract class PHP extends Emitter {
@@ -373,9 +373,17 @@ protected function emitEnum($result, $enum) {
 
     $enum->comment && $this->emitOne($result, $enum->comment);
     $enum->annotations && $this->emitOne($result, $enum->annotations);
-    $result->at($enum->declared)->out->write('enum '.$this->declaration($enum->name));
+    $result->at($enum->declared)->out->write('enum '.$enum->declaration());
     $enum->base && $result->out->write(':'.$enum->base);
-    $enum->implements && $result->out->write(' implements '.implode(', ', $enum->implements));
+
+    if ($enum->implements) {
+      $list= '';
+      foreach ($enum->implements as $type) {
+        $list.= ', '.$type->literal();
+      }
+      $result->out->write(' implements '.substr($list, 2));
+    }
+
     $result->out->write('{');
 
     foreach ($enum->body as $member) {
@@ -386,7 +394,7 @@ protected function emitEnum($result, $enum) {
     $result->out->write('static function __init() {');
     $this->emitInitializations($result, $result->locals[0]);
     $this->emitMeta($result, $enum->name, $enum->annotations, $enum->comment);
-    $result->out->write('}} '.$enum->name.'::__init();');
+    $result->out->write('}} '.$enum->name->literal().'::__init();');
     array_shift($result->type);
   }
 
@@ -397,9 +405,17 @@ protected function emitClass($result, $class) {
 
     $class->comment && $this->emitOne($result, $class->comment);
     $class->annotations && $this->emitOne($result, $class->annotations);
-    $result->at($class->declared)->out->write(implode(' ', $class->modifiers).' class '.$this->declaration($class->name));
-    $class->parent && $result->out->write(' extends '.$class->parent);
-    $class->implements && $result->out->write(' implements '.implode(', ', $class->implements));
+    $result->at($class->declared)->out->write(implode(' ', $class->modifiers).' class '.$class->declaration());
+    $class->parent && $result->out->write(' extends '.$class->parent->literal());
+
+    if ($class->implements) {
+      $list= '';
+      foreach ($class->implements as $type) {
+        $list.= ', '.$type->literal();
+      }
+      $result->out->write(' implements '.substr($list, 2));
+    }
+
     $result->out->write('{');
     foreach ($class->body as $member) {
       $this->emitOne($result, $member);
@@ -444,7 +460,7 @@ protected function emitClass($result, $class) {
     $result->out->write('static function __init() {');
     $this->emitInitializations($result, $result->locals[0]);
     $this->emitMeta($result, $class->name, $class->annotations, $class->comment);
-    $result->out->write('}} '.$class->name.'::__init();');
+    $result->out->write('}} '.$class->name->literal().'::__init();');
     array_shift($result->type);
     $result->locals= [];
   }
@@ -507,7 +523,7 @@ protected function emitInterface($result, $interface) {
 
     $interface->comment && $this->emitOne($result, $interface->comment);
     $interface->annotations && $this->emitOne($result, $interface->annotations);
-    $result->at($interface->declared)->out->write('interface '.$this->declaration($interface->name));
+    $result->at($interface->declared)->out->write('interface '.$interface->declaration());
     $interface->parents && $result->out->write(' extends '.implode(', ', $interface->parents));
     $result->out->write('{');
     foreach ($interface->body as $member) {
@@ -523,7 +539,7 @@ protected function emitTrait($result, $trait) {
 
     $trait->comment && $this->emitOne($result, $trait->comment);
     $trait->annotations && $this->emitOne($result, $trait->annotations);
-    $result->at($trait->declared)->out->write('trait '.$this->declaration($trait->name));
+    $result->at($trait->declared)->out->write('trait '.$trait->declaration());
     $result->out->write('{');
     foreach ($trait->body as $member) {
       $this->emitOne($result, $member);
@@ -904,12 +920,12 @@ protected function emitArguments($result, $arguments) {
   }
 
   protected function emitNew($result, $new) {
-    if ($new->type instanceof Node) {
+    if ($new->type instanceof IsExpression) {
       $result->out->write('new (');
-      $this->emitOne($result, $new->type);
+      $this->emitOne($result, $new->type->expression);
       $result->out->write(')(');
     } else {
-      $result->out->write('new '.$new->type.'(');
+      $result->out->write('new '.$new->type->literal().'(');
     }
 
     $this->emitArguments($result, $new->arguments);
@@ -925,12 +941,19 @@ protected function emitNewClass($result, $new) {
 
     // Allow "extends self" to reference enclosing class (except if this
     // class is an anonymous class!)
-    if ('self' === $new->definition->parent && $result->type && $result->type[0]->name) {
-      $result->out->write(' extends '.$result->type[0]->name);
+    if ($result->type && $result->type[0]->name && $new->definition->parent && 'self' === $new->definition->parent->name()) {
+      $result->out->write(' extends '.$result->type[0]->name->literal());
     } else if ($new->definition->parent) {
-      $result->out->write(' extends '.$new->definition->parent);
+      $result->out->write(' extends '.$new->definition->parent->literal());
+    }
+
+    if ($new->definition->implements) {
+      $list= '';
+      foreach ($new->definition->implements as $type) {
+        $list.= ', '.$type->literal();
+      }
+      $result->out->write(' implements '.substr($list, 2));
     }
-    $new->definition->implements && $result->out->write(' implements '.implode(', ', $new->definition->implements));
 
     array_unshift($result->type, $new->definition);
     $result->out->write('{');

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

@@ -66,11 +66,11 @@ private function comment($comment) {
   }
 
   /** Emit xp::$meta */
-  protected function emitMeta($result, $name, $annotations, $comment) {
-    if (null === $name) {
+  protected function emitMeta($result, $type, $annotations, $comment) {
+    if (null === $type) {
       $result->out->write('\xp::$meta[strtr(self::class, "\\\\", ".")]= [');
     } else {
-      $result->out->write('\xp::$meta[\''.strtr(ltrim($name, '\\'), '\\', '.').'\']= [');
+      $result->out->write('\xp::$meta[\''.strtr($type->name(), '\\', '.').'\']= [');
     }
     $result->out->write('"class" => [');
     $this->attributes($result, $annotations, []);

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

@@ -2,14 +2,15 @@
 
 use lang\ast\emit\Declaration;
 use lang\ast\nodes\{ClassDeclaration, Property};
+use lang\ast\types\IsValue;
 use unittest\{Assert, Test, Expect};
 
 class DeclarationTest {
   private $type;
 
   #[Before]
   public function type() {
-    $this->type= new ClassDeclaration([], '\\T', '\\lang\\Enum', [], [
+    $this->type= new ClassDeclaration([], '\\T', new IsValue('\\lang\\Enum'), [], [
       '$ONE' => new Property(['public', 'static'], 'ONE', null, null, [], null, 1)
     ]);
   }

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

@@ -3,6 +3,7 @@
 use io\streams\MemoryOutputStream;
 use lang\ast\emit\{GeneratedCode, Declaration, Escaping, Reflection};
 use lang\ast\nodes\ClassDeclaration;
+use lang\ast\types\IsValue;
 use lang\{Value, ClassNotFoundException};
 use unittest\{Assert, Expect, Test};
 
@@ -46,23 +47,23 @@ public function writes_epilog_on_closing() {
   #[Test]
   public function lookup_self() {
     $r= new GeneratedCode(new MemoryOutputStream());
-    $r->type[0]= new ClassDeclaration([], '\\T', null, [], [], null, null, 1);
+    $r->type[0]= new ClassDeclaration([], new IsValue('\\T'), null, [], [], null, null, 1);
 
     Assert::equals(new Declaration($r->type[0], $r), $r->lookup('self'));
   }
 
   #[Test]
   public function lookup_parent() {
     $r= new GeneratedCode(new MemoryOutputStream());
-    $r->type[0]= new ClassDeclaration([], '\\T', '\\lang\\Value', [], [], null, null, 1);
+    $r->type[0]= new ClassDeclaration([], new IsValue('\\T'), new IsValue('\\lang\\Value'), [], [], null, null, 1);
 
     Assert::equals(new Reflection(Value::class), $r->lookup('parent'));
   }
 
   #[Test]
   public function lookup_named() {
     $r= new GeneratedCode(new MemoryOutputStream());
-    $r->type[0]= new ClassDeclaration([], '\\T', null, [], [], null, null, 1);
+    $r->type[0]= new ClassDeclaration([], new IsValue('\\T'), null, [], [], null, null, 1);
 
     Assert::equals(new Declaration($r->type[0], $r), $r->lookup('\\T'));
   }

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

@@ -2,6 +2,7 @@
 
 use lang\ast\emit\{PHP, RewriteClassOnObjects};
 use lang\ast\nodes\{ScopeExpression, Variable, Literal, ClassDeclaration};
+use lang\ast\types\IsValue;
 use unittest\{Assert, Test};
 
 class RewriteClassOnObjectsTest extends EmitterTraitTest {
@@ -24,7 +25,7 @@ public function rewrites_type_variable() {
   public function does_not_rewrite_type_literal() {
     Assert::equals('self::class', $this->emit(
       new ScopeExpression('self', new Literal('class')),
-      [new ClassDeclaration([], '\\T', null, [], [], null, null, 1)]
+      [new ClassDeclaration([], new IsValue('\\T'), null, [], [], null, null, 1)]
     ));
   }
 }

src/test/php/lang/ast/unittest/loader/CompilingClassLoaderTest.class.php

@@ -131,7 +131,7 @@ public function load_uri() {
     Assert::equals('Tests', $class->getSimpleName());
   }
 
-  #[Test, Expect(class: ClassFormatException::class, withMessage: 'Compiler error: Expected "{", have "(end)"')]
+  #[Test, Expect(class: ClassFormatException::class, withMessage: 'Compiler error: Expected "type name", have "(end)"')]
   public function load_class_with_syntax_errors() {
     $this->compile(['Errors' => "<?php\nclass"], function($loader, $types) {
       return $loader->loadClass($types['Errors']);