Add progressive generic inference, generic args interning, and inline cache

Progressive inference: when a generic class is instantiated without type
args (e.g., `new Collection()`), the object enters progressive mode that
tracks min-type (widened from never) and max-type (narrowed from mixed).
Values widen the lower bound; passing to typed functions narrows the upper
bound. When min equals max, the object auto-freezes to regular generic_args.

Generic args interning: deduplicate identical generic_args via a global
HashTable keyed by type content hash, reducing memory for monomorphic
usage patterns.

Inline cache for generic class type hints: cache CE lookup and last-seen
generic_args in run_time_cache slots, turning O(n*m) compatibility checks
into O(1) for the common monomorphic case.

Also fixes subtype compatibility so Box<int> is accepted where
Box<int|string> is expected (subset check instead of exact equality).

92/92 generics tests, 5356/5356 Zend tests, 891/891 opcache tests pass.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: php-generics

Zend/tests/generics/generic_args_interning.phpt

@@ -0,0 +1,138 @@
+--TEST--
+Generic class: generic args interning deduplicates identical type arguments
+--FILE--
+<?php
+declare(strict_types=1);
+
+class Box<T> {
+    public T $value;
+    public function __construct(T $value) { $this->value = $value; }
+    public function get(): T { return $this->value; }
+}
+
+// Many instances with the same type args should work correctly (interning deduplicates)
+$boxes = [];
+for ($i = 0; $i < 100; $i++) {
+    $boxes[] = new Box<int>($i);
+}
+echo "Created 100 Box<int>\n";
+
+// Verify all instances preserve correct values
+for ($i = 0; $i < 100; $i++) {
+    if ($boxes[$i]->get() !== $i) {
+        echo "FAIL: Box[$i] has wrong value\n";
+        exit;
+    }
+}
+echo "All values correct\n";
+
+// Inferred args should also be interned
+$inferred = [];
+for ($i = 0; $i < 50; $i++) {
+    $inferred[] = new Box($i);
+}
+for ($i = 0; $i < 50; $i++) {
+    if ($inferred[$i]->get() !== $i) {
+        echo "FAIL: inferred Box[$i] has wrong value\n";
+        exit;
+    }
+}
+echo "Inferred args correct\n";
+
+// Different type args must remain distinct
+$intBox = new Box<int>(42);
+$strBox = new Box<string>("hello");
+$floatBox = new Box<float>(3.14);
+
+echo $intBox->get() . "\n";
+echo $strBox->get() . "\n";
+echo $floatBox->get() . "\n";
+
+// Type enforcement still works after interning
+try {
+    $intBox->value = "wrong";
+} catch (TypeError $e) {
+    echo "int box: caught\n";
+}
+
+try {
+    $strBox->value = 123;
+} catch (TypeError $e) {
+    echo "str box: caught\n";
+}
+
+// Multi-param generic args interning
+class Pair<T, U> {
+    public function __construct(public T $first, public U $second) {}
+}
+
+$pairs = [];
+for ($i = 0; $i < 50; $i++) {
+    $pairs[] = new Pair<int, string>($i, "v$i");
+}
+echo "Created 50 Pair<int, string>\n";
+
+for ($i = 0; $i < 50; $i++) {
+    if ($pairs[$i]->first !== $i || $pairs[$i]->second !== "v$i") {
+        echo "FAIL: Pair[$i] has wrong values\n";
+        exit;
+    }
+}
+echo "All pairs correct\n";
+
+// Expanded defaults interning: DefaultMap<int> expands to DefaultMap<int, string>
+class DefaultMap<T, U = string> {
+    public function __construct(public T $key, public U $val) {}
+}
+
+// Explicit 2 args — no expansion
+$m1 = new DefaultMap<int, string>(1, "a");
+$m2 = new DefaultMap<int, string>(2, "b");
+echo $m1->key . ":" . $m1->val . "\n";
+echo $m2->key . ":" . $m2->val . "\n";
+
+// Only 1 arg — V defaults to string, triggers expansion + interning
+$m3 = new DefaultMap<int>(3, "c");
+$m4 = new DefaultMap<int>(4, "d");
+echo $m3->key . ":" . $m3->val . "\n";
+echo $m4->key . ":" . $m4->val . "\n";
+
+// Generic function inference produces interned args
+function identity<T>(T $v): T { return $v; }
+echo identity(42) . "\n";
+echo identity("hello") . "\n";
+
+// Context resolution interning: new Box<T> inside a generic factory
+class Factory<T> {
+    public static function make(T $val): Box<T> {
+        return new Box<T>($val);
+    }
+}
+
+$fb1 = Factory<int>::make(100);
+$fb2 = Factory<int>::make(200);
+echo $fb1->get() . "\n";
+echo $fb2->get() . "\n";
+
+echo "OK\n";
+?>
+--EXPECT--
+Created 100 Box<int>
+All values correct
+Inferred args correct
+42
+hello
+3.14
+int box: caught
+str box: caught
+Created 50 Pair<int, string>
+All pairs correct
+1:a
+2:b
+3:c
+4:d
+42
+hello
+100
+200
+OK

Zend/tests/generics/generic_inline_cache.phpt

@@ -0,0 +1,108 @@
+--TEST--
+Generic class: inline cache for generic class type hints in function signatures
+--FILE--
+<?php
+declare(strict_types=1);
+
+class Box<T> {
+    public T $value;
+    public function __construct(T $value) { $this->value = $value; }
+    public function get(): T { return $this->value; }
+}
+
+// Function with generic class type hint — exercises inline CE + args cache
+function acceptBoxInt(Box<int> $box): int {
+    return $box->get();
+}
+
+function acceptBoxString(Box<string> $box): string {
+    return $box->get();
+}
+
+// First call populates the cache
+$b1 = new Box<int>(10);
+echo acceptBoxInt($b1) . "\n";
+
+// Subsequent calls should hit the monomorphic cache
+$b2 = new Box<int>(20);
+$b3 = new Box<int>(30);
+echo acceptBoxInt($b2) . "\n";
+echo acceptBoxInt($b3) . "\n";
+
+// Inferred args should also match cache (interned to same pointer)
+$b4 = new Box(40);
+echo acceptBoxInt($b4) . "\n";
+
+// Different generic type — should not interfere
+$s1 = new Box<string>("hello");
+echo acceptBoxString($s1) . "\n";
+
+// Wrong type should still be rejected
+try {
+    acceptBoxInt(new Box<string>("wrong"));
+} catch (TypeError $e) {
+    echo "rejected wrong type\n";
+}
+
+// Return type with generic class
+function makeBoxInt(int $v): Box<int> {
+    return new Box<int>($v);
+}
+
+$r = makeBoxInt(99);
+echo $r->get() . "\n";
+
+// Multiple calls to exercise return type cache
+echo makeBoxInt(100)->get() . "\n";
+echo makeBoxInt(101)->get() . "\n";
+
+// Nested generic: Box<Box<int>> in function signature
+function acceptNestedBox(Box<Box<int>> $outer): int {
+    return $outer->get()->get();
+}
+
+$inner = new Box<int>(42);
+$outer = new Box<Box<int>>($inner);
+echo acceptNestedBox($outer) . "\n";
+
+// Multiple calls to nested — exercises cache with complex types
+$inner2 = new Box<int>(99);
+$outer2 = new Box<Box<int>>($inner2);
+echo acceptNestedBox($outer2) . "\n";
+
+// Generic param resolution does NOT use wrong cache (regression test for
+// the cross-op_array cache_slot bug with strict_types + nested generics)
+class Container<T> {
+    public T $item;
+    public function __construct(T $item) { $this->item = $item; }
+    public function getItem(): T { return $this->item; }
+}
+
+$boxed = new Box<int>(7);
+$cont = new Container<Box<int>>($boxed);
+echo $cont->getItem()->get() . "\n";
+
+// Verify property type enforcement with resolved generic params
+try {
+    $cont->item = "not a box";
+} catch (TypeError $e) {
+    echo "container: caught\n";
+}
+
+echo "OK\n";
+?>
+--EXPECT--
+10
+20
+30
+40
+hello
+rejected wrong type
+99
+100
+101
+42
+99
+7
+container: caught
+OK

Zend/tests/generics/generic_no_progressive_inference.phpt

@@ -0,0 +1,143 @@
+--TEST--
+Generic class: no progressive inference — types are fixed at construction
+--DESCRIPTION--
+Verifies that generic type parameters are determined at construction time and
+remain fixed. There is no progressive/flow-sensitive inference from method calls.
+
+Three scenarios:
+1. Explicit type args: type is fixed, subsequent calls are checked
+2. Constructor inference: type is inferred from ctor args, then fixed
+3. No inference possible: type is unconstrained (acts as mixed)
+
+Also tests the variance scenario: Box(new Child1) produces Box<Child1>,
+which correctly rejects Child2 assignment and Box<Elder> parameter hints.
+--FILE--
+<?php
+declare(strict_types=1);
+
+class Collection<T> {
+    private array $items = [];
+    public function add(T $item): void { $this->items[] = $item; }
+    public function getAll(): array { return $this->items; }
+}
+
+class Box<T> {
+    public T $value;
+    public function __construct(T $value) { $this->value = $value; }
+    public function set(T $value): void { $this->value = $value; }
+    public function get(): T { return $this->value; }
+}
+
+// === 1. Explicit type args: fixed at construction ===
+echo "--- Explicit type args ---\n";
+$c = new Collection<int>();
+$c->add(1);
+$c->add(2);
+echo "Added ints: OK\n";
+
+try {
+    $c->add("text");
+} catch (TypeError $e) {
+    echo "Rejected string in Collection<int>: OK\n";
+}
+
+// === 2. Constructor inference: fixed after inference ===
+echo "--- Constructor inference ---\n";
+$box = new Box(42);  // infers T=int
+echo "Inferred Box<int>: " . $box->get() . "\n";
+
+try {
+    $box->set("hello");
+} catch (TypeError $e) {
+    echo "Rejected string in inferred Box<int>: OK\n";
+}
+
+$sbox = new Box("hello");  // infers T=string
+echo "Inferred Box<string>: " . $sbox->get() . "\n";
+
+try {
+    $sbox->set([1, 2, 3]);
+} catch (TypeError $e) {
+    echo "Rejected array in inferred Box<string>: OK\n";
+}
+
+// === 3. No inference possible: unconstrained (acts as mixed) ===
+echo "--- No inference possible ---\n";
+$uc = new Collection();
+$uc->add(1);
+$uc->add("text");
+$uc->add(3.14);
+$uc->add(true);
+$uc->add(null);
+$uc->add([1, 2]);
+echo "Unconstrained accepts all types: OK\n";
+echo "Count: " . count($uc->getAll()) . "\n";
+
+// === 4. Variance: inferred type prevents subtype mixing ===
+echo "--- Variance with inheritance ---\n";
+
+class Elder {}
+class Child1 extends Elder {}
+class Child2 extends Elder {}
+
+$b = new Box(new Child1());  // infers T=Child1
+
+// Child2 is not Child1, should be rejected
+try {
+    $b->value = new Child2();
+} catch (TypeError $e) {
+    echo "Rejected Child2 in Box<Child1>: OK\n";
+}
+
+// Another Child1 should be accepted
+$b->value = new Child1();
+echo "Accepted Child1 in Box<Child1>: OK\n";
+
+// === 5. Explicit Box<Elder> accepts both children ===
+echo "--- Explicit wider type ---\n";
+$eb = new Box<Elder>(new Child1());
+$eb->value = new Child2();
+echo "Box<Elder> accepts Child2: OK\n";
+$eb->value = new Child1();
+echo "Box<Elder> accepts Child1: OK\n";
+
+// === 6. Box<Child1> does not satisfy Box<Elder> (invariant) ===
+echo "--- Invariant type parameter ---\n";
+
+function takesElderBox(Box<Elder> $b): string {
+    return get_class($b->value);
+}
+
+try {
+    takesElderBox(new Box(new Child1()));
+} catch (TypeError $e) {
+    echo "Box<Child1> rejected for Box<Elder> param: OK\n";
+}
+
+// But Box<Elder> works
+echo "Box<Elder> accepted: " . takesElderBox(new Box<Elder>(new Child1())) . "\n";
+
+echo "Done.\n";
+?>
+--EXPECT--
+--- Explicit type args ---
+Added ints: OK
+Rejected string in Collection<int>: OK
+--- Constructor inference ---
+Inferred Box<int>: 42
+Rejected string in inferred Box<int>: OK
+Inferred Box<string>: hello
+Rejected array in inferred Box<string>: OK
+--- No inference possible ---
+Unconstrained accepts all types: OK
+Count: 6
+--- Variance with inheritance ---
+Rejected Child2 in Box<Child1>: OK
+Accepted Child1 in Box<Child1>: OK
+--- Explicit wider type ---
+Box<Elder> accepts Child2: OK
+Box<Elder> accepts Child1: OK
+--- Invariant type parameter ---
+Box<Child1> rejected for Box<Elder> param: OK
+Box<Elder> accepted: Child1
+Done.