Support generics

composer.json

@@ -6,8 +6,8 @@
   "description" : "Reflection",
   "keywords": ["module", "xp"],
   "require" : {
-    "xp-framework/core": "^12.0 | ^11.0 | ^10.13",
-    "xp-framework/ast": "^13.0 | ^12.0 | ^11.0 | ^10.0 | ^9.0 | ^8.0 | ^7.6",
+    "xp-framework/core": "^12.13",
+    "xp-framework/ast": "^13.0 | ^12.0",
     "php" : ">=7.4.0"
   },
   "require-dev" : {

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

@@ -1,20 +1,20 @@
 <?php namespace lang;
 
 use lang\meta\{MetaInformation, FromSyntaxTree, FromAttributes};
-use lang\reflection\{Type, Package};
+use lang\reflection\{Type, GenericType, Package};
 use lang\{ClassLoader, ClassNotFoundException, IllegalArgumentException};
 
 /**
  * Factory for reflection instances.
  *
  * ```php
  * // Types can be instantiated by names, instances or via lang.XPClass
- * $type= Reflection::of(Runnable::class);
- * $type= Reflection::of($instance);
- * $type= Reflection::of(XPClass::forName('lang.Value'));
+ * $type= Reflection::type(Runnable::class);
+ * $type= Reflection::type($instance);
+ * $type= Reflection::type(XPClass::forName('lang.Value'));
  *
  * // Packages can be instantiated via their name
- * $package= Reflection::of('lang.reflection');
+ * $package= Reflection::package('lang.reflection');
  * ```
  *
  * @test lang.reflection.unittest.ReflectionTest
@@ -40,20 +40,22 @@ public static function meta(): MetaInformation {
    */
   public static function type($arg) {
     if ($arg instanceof XPClass) {
-      return new Type($arg->reflect());
+      $reflect= $arg->reflect();
     } else if ($arg instanceof \ReflectionClass) {
-      return new Type($arg);
+      $reflect= $arg;
     } else if ($arg instanceof Type) {
       return $arg;
     } else if (is_object($arg)) {
-      return new Type(new \ReflectionObject($arg));
+      $reflect= new \ReflectionObject($arg);
     } else {
       try {
-        return new Type(new \ReflectionClass(strtr($arg, '.', '\\')));
+        $reflect= new \ReflectionClass(strtr($arg, '.', '\\'));
       } catch (\ReflectionException $e) {
         throw new ClassNotFoundException($arg, [ClassLoader::getDefault()]);
       }
     }
+
+    return strpos($reflect->name, "\xb7\xb7") ? new GenericType($reflect) : new Type($reflect);
   }
 
   /**
@@ -94,28 +96,30 @@ public static function package($arg) {
    * @throws lang.ClassNotFoundException
    */
   public static function of($arg) {
-    if ($arg instanceof XPClass) {
-      return new Type($arg->reflect());
-    } else if ($arg instanceof \ReflectionClass) {
-      return new Type($arg);
-    } else if ($arg instanceof Type) {
+    if ($arg instanceof Type) {
       return $arg;
+    } else if ($arg instanceof XPClass) {
+      $reflect= $arg->reflect();
+    } else if ($arg instanceof \ReflectionClass) {
+      $reflect= $arg;
     } else if (is_object($arg)) {
-      return new Type(new \ReflectionObject($arg));
+      $reflect= new \ReflectionObject($arg);
     } else {
       $cl= ClassLoader::getDefault();
       $name= strtr($arg, '\\', '.');
       if ($cl->providesClass($name)) {
-        return new Type(new \ReflectionClass($cl->loadClass0($name)));
+        $reflect= new \ReflectionClass($cl->loadClass0($name));
       } else if ($cl->providesPackage($name)) {
         return new Package($name);
-      }
-
-      try {
-        return new Type(new \ReflectionClass(strtr($arg, '.', '\\')));
-      } catch (\ReflectionException $e) {
-        throw new ClassNotFoundException($name, [$cl]);
+      } else {
+        try {
+          $reflect= new \ReflectionClass(strtr($arg, '.', '\\'));
+        } catch (\ReflectionException $e) {
+          throw new ClassNotFoundException($name, [$cl]);
+        }
       }
     }
+
+    return strpos($reflect->name, "\xb7\xb7") ? new GenericType($reflect) : new Type($reflect);
   }
 }

src/main/php/lang/meta/MetaInformation.class.php

@@ -25,9 +25,9 @@ public function evaluate($reflect, $code) {
    */
   private function annotations($meta) {
     $r= [];
-    foreach ($meta[DETAIL_ANNOTATIONS] as $name => $value) {
+    foreach ($meta[DETAIL_ANNOTATIONS] ?? [] as $name => $value) {
       $qname= $meta[DETAIL_TARGET_ANNO][$name] ?? $name;
-      $r[$qname]= isset($meta[DETAIL_TARGET_ANNO][$qname]) ? [$value] : (array)$value;
+      $r[strtr($qname, '.', '\\')]= isset($meta[DETAIL_TARGET_ANNO][$qname]) ? [$value] : (array)$value;
     }
     return $r;
   }
@@ -72,6 +72,16 @@ public function typeAnnotations($reflect) {
     }
   }
 
+  /**
+   * Returns type generics for a given type, if any
+   *
+   * @param  \ReflectionClass $reflect
+   * @return ?var[]
+   */
+  public function typeGenerics($reflect) {
+    return \xp::$meta[\xp::$cn[$reflect->name] ?? strtr($reflect->name, '\\', '.')]['class'][DETAIL_GENERIC] ?? null;
+  }
+
   /**
    * Returns API doc comment for a given type
    *
@@ -216,7 +226,8 @@ public function propertyModifiers($reflect) {
    * @return [:var[]]
    */
   public function methodAnnotations($reflect) {
-    $c= strtr($reflect->getDeclaringClass()->name, '\\', '.');
+    $name= $reflect->getDeclaringClass()->name;
+    $c= \xp::$cn[$name] ?? strtr($name, '\\', '.');
     if ($meta= \xp::$meta[$c][1][$reflect->name] ?? null) {
       return $this->annotations($meta);
     } else {

src/main/php/lang/reflection/Constant.class.php

@@ -34,7 +34,7 @@ public function constraint() {
 
     $t= Type::resolve(
       PHP_VERSION_ID >= 80300 ? $this->reflect->getType() : null,
-      Member::resolve($this->reflect),
+      $this->resolve(),
       $api
     );
     return new Constraint($t ?? Type::$VAR, $present);

src/main/php/lang/reflection/Constructor.class.php

@@ -1,7 +1,7 @@
 <?php namespace lang\reflection;
 
 use ArgumentCountError, ReflectionMethod, ReflectionClass, ReflectionException, TypeError, Error, Throwable;
-use lang\Reflection;
+use lang\{Reflection, Generic, Type};
 
 /**
  * Reflection for a type's constructor
@@ -20,9 +20,16 @@ public function __construct($reflect) {
 
   /** @return string */
   public function toString() {
+    $meta= Reflection::meta();
+    if ($generic= $meta->methodAnnotations($this->reflect)[Generic::class] ?? []) {
+      $params= [...Type::split($generic['params'] ?? '')];
+    } else {
+      $params= [];
+    }
+
     return
       Modifiers::namesOf($this->reflect->getModifiers() & ~0x1fb7f008).
-      ' function __construct('.$this->signature(Reflection::meta()).')'
+      ' function __construct('.$this->signature($meta, $params).')'
     ;
   }
 

src/main/php/lang/reflection/GenericMethod.class.php

@@ -0,0 +1,71 @@
+<?php namespace lang\reflection;
+
+use ReflectionClass;
+use lang\{Reflection, Generic, Type, XPClass};
+
+class GenericMethod extends Method {
+  private $arguments;
+
+  public function __construct($reflect, array $arguments) {
+    parent::__construct($reflect);
+    $this->arguments= $arguments;
+  }
+
+  /** Returns whether this method is generic */
+  public function generic() { return true; }
+
+  /** @return lang.reflection.Method */
+  public function definition() { return new Method($this->reflect); }
+
+  /** @return lang.Type[] */
+  public function arguments() { return $this->arguments; }
+
+  /**
+   * Returns context for `Type::resolve()`
+   *
+   * @return [:function(?string): Type]
+   */
+  public function resolve() {
+    $declared= $this->reflect->getDeclaringClass();
+    $resolve= [
+      'static' => fn() => new XPClass($this->definitionOf($this->reflect->class)),
+      'self'   => fn() => new XPClass($this->definitionOf($declared->name)),
+      'parent' => fn() => new XPClass(get_parent_class($this->definitionOf($declared->name))),
+      '*'      => function($type) use($declared) {
+        $imports= Reflection::meta()->scopeImports($declared);
+        return XPClass::forName($imports[$type] ?? $declared->getNamespaceName().'\\'.$type);
+      },
+    ];
+
+    // Add generic type parameters
+    $generic= Reflection::meta()->methodAnnotations($this->reflect)[Generic::class]['self'];
+    foreach (Type::split($generic) as $p => $arg) {
+      $resolve[$arg]= fn() => $this->arguments[$p];
+    }
+    return $resolve;
+  }
+
+  /**
+   * Returns a closure
+   *
+   * @param  ?object $instance
+   * @return Closure
+   * @throws lang.IllegalArgumentException for incorrect or missing instances
+   */
+  public function closure(?object $instance= null) {
+    return fn(... $args) => parent::closure($instance)($this->arguments, ...$args);
+  }
+
+  /**
+   * Invokes this method
+   *
+   * @param  ?object $instance
+   * @param  var[] $args
+   * @return var
+   * @throws lang.reflection.CannotInvoke if prerequisites to the invocation fail
+   * @throws lang.reflection.InvocationFailed if invocation raises an exception
+   */
+  public function invoke(?object $instance, $args= []) {
+    return parent::invoke($instance, [$this->arguments, ...$args]);
+  }
+}

src/main/php/lang/reflection/GenericType.class.php

@@ -0,0 +1,23 @@
+<?php namespace lang\reflection;
+
+use ReflectionClass;
+use lang\Reflection;
+
+class GenericType extends Type {
+  private $generics= null;
+
+  /** Returns whether this type is generic */
+  public function generic() { return true; }
+
+  /** Returns definition for this generic type */
+  public function definition(): parent {
+    $this->generics??= Reflection::meta()->typeGenerics($this->reflect);
+    return new parent(new ReflectionClass(strtr($this->generics[0], '.', '\\')));
+  }
+
+  /** @return lang.Type[] */
+  public function arguments(): array {
+    $this->generics??= Reflection::meta()->typeGenerics($this->reflect);
+    return $this->generics[1];
+  }
+}

src/main/php/lang/reflection/Member.class.php

@@ -18,23 +18,38 @@ public function __construct($reflect, $annotations= null) {
     $this->annotations= $annotations;
   }
 
+  /** Returns definition for a given generic class */
+  protected function definitionOf($class) {
+    return substr($class, 0, strpos($class, "\xb7\xb7"));
+  }
+
   /**
    * Returns context for `Type::resolve()`
    *
-   * @param  ReflectionMethod|ReflectionProperty|ReflectionClassConstant $reflect
    * @return [:function(?string): Type]
    */
-  public static function resolve($reflect) {
-    return [
-      'static' => fn() => new XPClass($reflect->class),
-      'self'   => fn() => new XPClass($reflect->getDeclaringClass()),
-      'parent' => fn() => new XPClass($reflect->getDeclaringClass()->getParentClass()),
-      '*'      => function($type) use($reflect) {
-        $declared= $reflect->getDeclaringClass();
-        $imports= Reflection::meta()->scopeImports($declared);
-        return XPClass::forName($imports[$type] ?? $declared->getNamespaceName().'\\'.$type);
-      },
-    ];
+  public function resolve() {
+    $declared= $this->reflect->getDeclaringClass();
+
+    // Inside `Type<string>`, `self` should resolve to the base type
+    if (strpos($this->reflect->class, "\xb7\xb7")) {
+      $resolve= [
+        'static' => fn() => new XPClass($this->definitionOf($this->reflect->class)),
+        'self'   => fn() => new XPClass($this->definitionOf($declared->name)),
+        'parent' => fn() => new XPClass(get_parent_class($this->definitionOf($declared->name))),
+      ];
+    } else {
+      $resolve= [
+        'static' => fn() => new XPClass($this->reflect->class),
+        'self'   => fn() => new XPClass($declared),
+        'parent' => fn() => new XPClass($declared->getParentClass()),
+      ];
+    }
+
+    return $resolve + ['*' => function($type) use($declared) {
+      $imports= Reflection::meta()->scopeImports($declared);
+      return XPClass::forName($imports[$type] ?? $declared->getNamespaceName().'\\'.$type);
+    }];
   }
 
   /** @return [:var] */