Add generics support to PHP

Implement reified generics with type parameter declarations on classes,
interfaces, traits, and functions. Includes type constraint enforcement,
variance checking, type inference, reflection API support, and
comprehensive test suite.

Author: php-generics

Zend/tests/generics/generic_class_basic.phpt

@@ -0,0 +1,19 @@
+--TEST--
+Generic class: basic declaration and instantiation
+--FILE--
+<?php
+class Box<T> {
+    private $value;
+    public function __construct(T $value) { $this->value = $value; }
+    public function get(): T { return $this->value; }
+}
+
+$box = new Box(42);
+echo $box->get() . "\n";
+
+$box2 = new Box("hello");
+echo $box2->get() . "\n";
+?>
+--EXPECT--
+42
+hello

Zend/tests/generics/generic_class_constrained_param.phpt

@@ -0,0 +1,22 @@
+--TEST--
+Generic class: constrained type parameter with upper bound
+--FILE--
+<?php
+class TypedCollection<T: Countable> {
+    private array $items = [];
+    public function add(T $item): void {
+        $this->items[] = $item;
+    }
+    public function count(): int {
+        return count($this->items);
+    }
+}
+
+echo "TypedCollection declared\n";
+
+$c = new TypedCollection();
+echo "Instantiated\n";
+?>
+--EXPECT--
+TypedCollection declared
+Instantiated

Zend/tests/generics/generic_class_inheritance.phpt

@@ -0,0 +1,24 @@
+--TEST--
+Generic class: inheritance with bound type arguments
+--FILE--
+<?php
+class Box<T> {
+    private $value;
+    public function __construct(T $value) { $this->value = $value; }
+    public function get(): T { return $this->value; }
+}
+
+class IntBox extends Box<int> {}
+
+$ib = new IntBox(99);
+echo $ib->get() . "\n";
+
+try {
+    $bad = new IntBox("not an int");
+} catch (TypeError $e) {
+    echo "TypeError caught\n";
+}
+?>
+--EXPECT--
+99
+TypeError caught

Zend/tests/generics/generic_class_multiple_params.phpt

@@ -0,0 +1,22 @@
+--TEST--
+Generic class: multiple type parameters
+--FILE--
+<?php
+class Pair<A, B> {
+    private $first;
+    private $second;
+    public function __construct(A $first, B $second) {
+        $this->first = $first;
+        $this->second = $second;
+    }
+    public function getFirst(): A { return $this->first; }
+    public function getSecond(): B { return $this->second; }
+}
+
+$pair = new Pair<string, int>("hello", 42);
+echo $pair->getFirst() . "\n";
+echo $pair->getSecond() . "\n";
+?>
+--EXPECT--
+hello
+42

Zend/tests/generics/generic_class_new_with_type_args.phpt

@@ -0,0 +1,19 @@
+--TEST--
+Generic class: new with explicit type arguments
+--FILE--
+<?php
+class Box<T> {
+    private $value;
+    public function __construct(T $value) { $this->value = $value; }
+    public function get(): T { return $this->value; }
+}
+
+$intBox = new Box<int>(42);
+echo $intBox->get() . "\n";
+
+$strBox = new Box<string>("hello");
+echo $strBox->get() . "\n";
+?>
+--EXPECT--
+42
+hello

Zend/tests/generics/generic_class_type_enforcement.phpt

@@ -0,0 +1,18 @@
+--TEST--
+Generic class: type enforcement on constructor parameter
+--FILE--
+<?php
+class Box<T> {
+    private $value;
+    public function __construct(T $value) { $this->value = $value; }
+    public function get(): T { return $this->value; }
+}
+
+try {
+    $box = new Box<int>("not an int");
+} catch (TypeError $e) {
+    echo "TypeError: " . $e->getMessage() . "\n";
+}
+?>
+--EXPECTF--
+TypeError: Box::__construct(): Argument #1 ($value) must be of type int, string given, called in %s on line %d

Zend/tests/generics/generic_clone.phpt

@@ -0,0 +1,29 @@
+--TEST--
+Generic class: clone preserves generic type arguments
+--FILE--
+<?php
+declare(strict_types=1);
+
+class Box<T> {
+    public T $value;
+    public function __construct(T $value) { $this->value = $value; }
+}
+
+$a = new Box<int>(42);
+$b = clone $a;
+
+echo $b->value . "\n";
+
+// Clone should preserve generic args — assigning wrong type should fail
+try {
+    $b->value = "hello";
+} catch (TypeError $e) {
+    echo $e->getMessage() . "\n";
+}
+
+echo "OK\n";
+?>
+--EXPECTF--
+42
+Cannot assign string to property Box::$value of type int
+OK

Zend/tests/generics/generic_closure.phpt

@@ -0,0 +1,72 @@
+--TEST--
+Generic closures and arrow functions
+--FILE--
+<?php
+declare(strict_types=1);
+
+// Generic closure
+$identity = function<T>(T $value): T {
+    return $value;
+};
+
+echo $identity(42) . "\n";       // 42
+echo $identity("hello") . "\n";  // hello
+
+// Generic arrow function
+$wrap = fn<T>(T $x): array => [$x];
+var_dump($wrap(42));       // array(1) { [0]=> int(42) }
+var_dump($wrap("hello"));  // array(1) { [0]=> string(5) "hello" }
+
+// Generic closure with constraint
+$count = function<T: Countable>(T $item): int {
+    return count($item);
+};
+
+echo $count(new ArrayObject([1, 2, 3])) . "\n"; // 3
+
+// Multiple type params
+$pair = fn<A, B>(A $a, B $b): array => [$a, $b];
+var_dump($pair(1, "two"));  // array(2) { [0]=> int(1) [1]=> string(3) "two" }
+
+// Reflection on generic closures
+$rf = new ReflectionFunction($identity);
+var_dump($rf->isGeneric()); // true
+$params = $rf->getGenericParameters();
+echo "identity generic params: " . count($params) . "\n";
+echo "  T: " . $params[0]->getName() . "\n";
+
+// Reflection on generic arrow function
+$rf2 = new ReflectionFunction($wrap);
+var_dump($rf2->isGeneric()); // true
+
+// Non-generic closure for comparison
+$plain = function(int $x): int { return $x * 2; };
+$rf3 = new ReflectionFunction($plain);
+var_dump($rf3->isGeneric()); // false
+
+echo "OK\n";
+?>
+--EXPECT--
+42
+hello
+array(1) {
+  [0]=>
+  int(42)
+}
+array(1) {
+  [0]=>
+  string(5) "hello"
+}
+3
+array(2) {
+  [0]=>
+  int(1)
+  [1]=>
+  string(3) "two"
+}
+bool(true)
+identity generic params: 1
+  T: T
+bool(true)
+bool(false)
+OK

Zend/tests/generics/generic_constraint_enforcement.phpt

@@ -0,0 +1,23 @@
+--TEST--
+Generic class: constraint enforcement at instantiation
+--FILE--
+<?php
+class TypedCollection<T: Countable> {
+    private array $items = [];
+    public function add(T $item): void {
+        $this->items[] = $item;
+    }
+}
+
+// ArrayObject implements Countable — should work
+$c = new TypedCollection<ArrayObject>();
+echo "ArrayObject accepted\n";
+
+// string does NOT implement Countable — should fatal error
+$c2 = new TypedCollection<string>();
+echo "Should not reach here\n";
+?>
+--EXPECTF--
+ArrayObject accepted
+
+Fatal error: Generic type argument #1 must implement Countable, string given in %s on line %d

Zend/tests/generics/generic_contravariance_error.phpt

@@ -0,0 +1,11 @@
+--TEST--
+Generic class: contravariance (in) compile error when used in return position
+--FILE--
+<?php
+// in T should not be allowed in method return position
+class BadConsumer<in T> {
+    public function get(): T { return null; }
+}
+?>
+--EXPECTF--
+Fatal error: Contravariant type parameter T of class BadConsumer cannot be used in return type of method BadConsumer::get() (only parameter types allowed) in %s on line %d