fix inheritance chaining

Signed-off-by: Robert Landers <landers.robert@gmail.com>

fix inheritance chaining

Signed-off-by: Robert Landers <landers.robert@gmail.com>

fix inheritance chaining

Signed-off-by: Robert Landers <landers.robert@gmail.com>

Author: withinboredom

Zend/tests/generics/errors/type_param_in_new_turbofish.phpt

@@ -0,0 +1,40 @@
+--TEST--
+Errors: a forwarded TYPE_PARAMETER ref in a `new C::<T>()` turbofish errors at the synth site when nothing pins T and its bound is not a class
+--FILE--
+<?php
+// Companion to type_param_in_new_expression.phpt (`new T()`). Same shape, but
+// the unresolvable T sits inside a turbofish on `new C::<T>(...)` instead of
+// being the class itself. Both must produce the same diagnostic, fired at the
+// `new` site — not silently produce a broken-refs monomorph that crashes far
+// from the cause when a method is later called on it.
+final readonly class Box<U = mixed> {
+    public function __construct(public array $items = []) {}
+}
+
+function makeBox<T>(): Box {
+    return new Box::<T>([]);
+}
+
+try {
+    makeBox();
+    echo "no error??\n";
+} catch (Error $e) {
+    echo "ok: " . $e->getMessage() . "\n";
+}
+
+// A class-bound on the outer T gives a fallback target.
+class Base {}
+function makeBoxFromBound<T : Base>(): Box {
+    return new Box::<T>([]);
+}
+$b = makeBoxFromBound();
+var_dump($b::class);
+
+// Turbofish supplied: no error, T resolves to the supplied type.
+$b = makeBox::<int>();
+var_dump($b::class);
+?>
+--EXPECT--
+ok: Cannot resolve generic type parameter T at runtime: no binding was supplied and its bound is not a class
+string(9) "Box<Base>"
+string(8) "Box<int>"

Zend/tests/generics/inheritance/lsp/impl_with_identity_type_param_binding.phpt

@@ -0,0 +1,24 @@
+--TEST--
+Parametric LSP: child implementing `I<TN>` with its own TN forwarded to parent's TN
+--FILE--
+<?php
+// Regression: when both parent and child bind the same parameter shape
+// (parent's TN, child's TN, both bare type-parameter refs), the
+// inheritance check needs to treat them as equivalent. The parent's
+// substituted return is itself a type-parameter ref so the substitute
+// helper falls back to the erased form; the child must follow the same
+// fall-back, or the check sees `mixed` vs `TN` and rejects what's
+// structurally an identity binding.
+
+interface GI<TN = mixed, TW = mixed> {
+    public function getEdgesFrom(TN $from): array;
+}
+
+class DG<TN = mixed, TW = mixed> implements GI<TN, TW> {
+    public function getEdgesFrom(TN $from): array { return []; }
+}
+
+echo "OK\n";
+?>
+--EXPECT--
+OK

Zend/tests/generics/inheritance/lsp/method_level_param_bound_subst.phpt

@@ -0,0 +1,31 @@
+--TEST--
+Parametric LSP: method-level type-parameter bound that references a class-scope T substitutes when the subclass binds T
+--FILE--
+<?php
+// Regression: `class A<T> { function set<U : T>(U $x) }` — the method's
+// own U has a bound that's a class-scope T-ref. When `class B extends A<string>`
+// supplies T = string, the inheritance check on the inherited (or overridden)
+// method must see U's bound substituted from T → string, otherwise the parent
+// renders as `set(mixed $x)` (T erased) and the child's `set<U:string>(U $x)`
+// gets rejected as narrower than mixed.
+
+class A<T> {
+    public function set<U : T>(U $x): void {}
+}
+
+class B extends A<string> {
+    public function set<U : string>(U $x): void {}
+}
+
+class C<Tl, Tr> {
+    public function set<U : Tl|Tr>(U $x): void {}
+}
+
+class D extends C<string, int> {
+    public function set<U : string|int>(U $x): void {}
+}
+
+echo "OK\n";
+?>
+--EXPECT--
+OK

Zend/tests/generics/inheritance/lsp/union_of_type_params_narrower_return.phpt

@@ -0,0 +1,25 @@
+--TEST--
+Parametric LSP: child narrowing Tl|Tr return down to a single Tl is accepted
+--FILE--
+<?php
+// Companion to union_of_type_params_return_subst.phpt: a child that
+// returns a narrower subset of the parent's substituted Tl|Tr — covariant.
+
+abstract class Base<T> {
+    abstract public function get(): T;
+}
+
+class LeftOnly<Tl, Tr> extends Base<Tl|Tr> {
+    public function __construct(private Tl $value) {}
+    public function get(): Tl { return $this->value; }
+}
+
+$a = new LeftOnly::<string, int>("hi");
+var_dump($a->get());
+
+$b = new LeftOnly::<int, string>(42);
+var_dump($b->get());
+?>
+--EXPECT--
+string(2) "hi"
+int(42)

Zend/tests/generics/inheritance/lsp/union_of_type_params_return_subst.phpt

@@ -0,0 +1,49 @@
+--TEST--
+Parametric LSP: child returning union of two type parameters (Tl|Tr) satisfies parent's T when parent is bound to Tl|Tr
+--FILE--
+<?php
+// Regression for: child override declaring `: Tl|Tr` was reported as
+// `: mixed` against the parent's substituted `: T = Tl|Tr`, even though
+// the two are structurally identical.
+//
+// Triggered originally by Psl\Type\Internal\UnionType extending
+// Psl\Type\Type<Tl|Tr> with overrides returning Tl|Tr.
+
+abstract class Base<T> {
+    abstract public function get(): T;
+}
+
+class Pair<Tl, Tr> extends Base<Tl|Tr> {
+    public function __construct(private Tl|Tr $value) {}
+    public function get(): Tl|Tr { return $this->value; }
+}
+
+$p = new Pair::<string, int>("hi");
+var_dump($p->get());
+
+$q = new Pair::<string, int>(42);
+var_dump($q->get());
+
+// Also exercise the interface-implements path, which is what the Psl
+// failure actually hit (UnionType extends Type which implements TypeInterface).
+interface I<+T> {
+    public function read(mixed $v): T;
+}
+
+abstract class IBase<T> implements I<T> {
+    abstract public function read(mixed $v): T;
+}
+
+class Union<Tl, Tr> extends IBase<Tl|Tr> {
+    public function read(mixed $v): Tl|Tr {
+        if ($v instanceof Tl || $v instanceof Tr) return $v;
+        throw new TypeError("nope");
+    }
+}
+
+echo "loaded\n";
+?>
+--EXPECT--
+string(2) "hi"
+int(42)
+loaded

Zend/tests/generics/inheritance/lsp/violation_union_of_t_refs_widened.phpt

@@ -0,0 +1,17 @@
+--TEST--
+Parametric LSP: child returning Tl|Tr|string (a widening of the parent's substituted Tl|Tr) is rejected
+--FILE--
+<?php
+// After the pre-erasure mask aggregation, the covariant check sees that
+// the child returns a strictly wider set than the parent.
+
+abstract class Base<T> {
+    abstract public function get(): T;
+}
+
+class BadPair<Tl, Tr> extends Base<Tl|Tr> {
+    public function get(): Tl|Tr|string { throw new Exception(); }
+}
+?>
+--EXPECTF--
+Fatal error: Declaration of BadPair::get(): Tl|Tr|string must be compatible with Base::get(): Tl|Tr in %s on line %d

Zend/tests/generics/reification/forwarded_t_ref_value_check.phpt

@@ -81,7 +81,7 @@ object(Dog)#%d (0) {
 caught: id(): Argument #1 ($x) must be of type Dog, Cat given
 int(42)
 caught: id(): Argument #1 ($x) must be of type int, string given
-caught: id(): Argument #1 ($x) must be of type int|string, array given
+caught: id(): Argument #1 ($x) must be of type string|int, array given
 object(Both)#%d (0) {
 }
 caught: id(): Argument #1 ($x) must be of type Fooable&Barable, FooOnly given

Zend/tests/generics/reification/monomorph_implements_substitution.phpt

@@ -0,0 +1,41 @@
+--TEST--
+Reification: a monomorph of `B<T> implements I<T>` should report `is_a I<bound>` true
+--FILE--
+<?php
+// Regression: when `B<T> implements I<T>` is monomorphized as `B<string>`,
+// the implements binding has to be substituted so that `B<string>` is also
+// known to implement `I<string>`. Otherwise `instanceof I<string>` /
+// `is_a(..., 'I<string>')` returns false even though the type relationship
+// holds, and property writes typed `I<string>` reject `B<string>` values.
+
+interface I<+T> {}
+class B<T> implements I<T> {}
+
+// 1) Direct monomorph
+$b = new B::<string>();
+var_dump(is_a($b, 'I<string>'));
+var_dump(is_a($b, 'B<string>'));
+$mono = 'B<string>';
+var_dump($b instanceof $mono);
+
+// 2) Non-generic subclass of a monomorph
+class StrB extends B<string> {}
+$s = new StrB();
+var_dump(is_a($s, 'I<string>'));
+var_dump(is_a($s, 'B<string>'));
+
+// 3) Assignment to a property typed I<string> accepts a B<string>
+class Holder<T> {
+    public I<T> $val;
+}
+$h = new Holder::<string>();
+$h->val = new B::<string>();
+var_dump($h->val::class);
+?>
+--EXPECT--
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+bool(true)
+string(9) "B<string>"

Zend/tests/generics/reification/named_with_args_t_in_property.phpt

@@ -0,0 +1,56 @@
+--TEST--
+Reification: a property typed `I<T>` (T inside a generic class type arg) substitutes T → binding for the monomorph
+--FILE--
+<?php
+// Regression: `public I<T> $val` on a generic class. When the class is
+// monomorphized (e.g. `new Box::<string>()`), the property type should
+// substitute T → string and the runtime check should accept values that
+// satisfy `I<string>`. The bug was that `zend_substitute_leaf_type_param`
+// didn't recurse into NAMED_WITH_ARGS payloads, so the property stayed
+// typed as the unsubstituted `I<T>` and any assignment failed with
+// "Cannot assign ... of type I<T>".
+
+interface I<+T> {}
+
+class StrImpl implements I<string> {}
+class IntImpl implements I<int> {}
+
+class Box<T> {
+    public I<T> $val;
+}
+
+// Direct monomorph use.
+$b = new Box::<string>();
+$b->val = new StrImpl();
+var_dump($b->val::class);
+
+// Wrong-arg implementation rejected.
+try {
+    $b->val = new IntImpl();
+} catch (TypeError $e) {
+    echo "1: ", $e->getMessage(), "\n";
+}
+
+// Inherited subclass case: same substitution applies when the property is
+// touched on an instance of a non-generic child. Use `mixed` on the ctor
+// so the bad value reaches the property assignment site, exercising the
+// inherited property's substituted type rather than the ctor's own type.
+class StringBox extends Box<string> {
+    public function __construct(mixed $val) {
+        $this->val = $val;
+    }
+}
+$sb = new StringBox(new StrImpl());
+var_dump($sb->val::class);
+
+try {
+    new StringBox(new IntImpl());
+} catch (TypeError $e) {
+    echo "2: ", $e->getMessage(), "\n";
+}
+?>
+--EXPECTF--
+string(7) "StrImpl"
+1: Cannot assign IntImpl to property %s::$val of type I<string>
+string(7) "StrImpl"
+2: Cannot assign IntImpl to property %s::$val of type I<string>

Zend/tests/generics/reification/new_turbofish_with_class_t_ref.phpt

@@ -0,0 +1,48 @@
+--TEST--
+Reification: `new SelfClass::<T>(...)` inside a generic class method resolves T against the instance's monomorph args at synth time
+--FILE--
+<?php
+// Companion to new_turbofish_with_outer_t_ref.phpt — same fix but the T-ref
+// origin is CLASS_LIKE: a generic class's method does `new Self::<T>(...)`
+// using its own class-level T's. Runtime synth must walk the called scope
+// up to the lexical class's monomorph descendant to resolve the binding.
+
+final readonly class Bag<T = mixed> {
+    public function __construct(public array $items = []) {}
+
+    public function withItem(T $item): Bag {
+        $items = $this->items;
+        $items[] = $item;
+        // Forward T explicitly — must resolve against the current instance's
+        // monomorph (Bag<int> stays Bag<int>, not Bag<T>).
+        return new Bag::<T>($items);
+    }
+}
+
+$b = new Bag::<int>([1, 2, 3]);
+var_dump($b::class);
+$b = $b->withItem(4);
+var_dump($b::class);
+$b = $b->withItem(5);
+var_dump($b::class);
+
+$s = new Bag::<string>(['a']);
+var_dump($s::class);
+$s = $s->withItem('b');
+var_dump($s::class);
+
+// Calling withItem on a bare-default Bag<mixed> still works — forwarding
+// resolves T to its (default) mixed binding from the monomorph.
+$d = new Bag();
+var_dump($d::class);
+$d = $d->withItem(42);
+var_dump($d::class);
+?>
+--EXPECT--
+string(8) "Bag<int>"
+string(8) "Bag<int>"
+string(8) "Bag<int>"
+string(11) "Bag<string>"
+string(11) "Bag<string>"
+string(10) "Bag<mixed>"
+string(10) "Bag<mixed>"