make new static::<> a compile time error

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

Author: withinboredom

Zend/tests/generics/errors/type_args_on_static_new.phpt

@@ -0,0 +1,18 @@
+--TEST--
+Type arguments on `new static::<...>` are a compile-time error (static is the runtime type)
+--FILE--
+<?php
+// `static` is the runtime type, which already carries its own type arguments
+// and whose parameter list is unknown at this lexical site (it may be a generic
+// subclass with a different list, or a non-generic subclass of a monomorph).
+// The written args name the *enclosing* class's parameters, so applying them to
+// `static` is a scoping error — rejected at compile time rather than crashing
+// or throwing ArgumentCountError at runtime.
+class C<TKey, T> {
+    public function __construct(private array $e = []) {}
+    public function dup(): static { return new static::<TKey, T>($this->e); }
+}
+(new C::<mixed, mixed>([1, 2]))->dup();
+?>
+--EXPECTF--
+Fatal error: Type arguments cannot be applied to "static": "static" is the runtime type and already carries its type arguments. Use "new static()" to construct the exact runtime type, or "new self::<...>" to apply type arguments to the enclosing class in %s on line %d

Zend/tests/generics/errors/type_args_on_static_new_subclass.phpt

@@ -0,0 +1,17 @@
+--TEST--
+`new static::<...>` is rejected even when the runtime type is a non-generic subclass of a monomorph
+--FILE--
+<?php
+// Here `static` would resolve to IntBox, which extends the monomorph Box<int>
+// but is itself non-generic — it has no type parameters to apply `<T>` to. The
+// rejection is the same compile-time scoping error: use `new static()`.
+class Box<T> {
+    public function __construct(private mixed $v = null) {}
+    public function make(): object { return new static::<T>($this->v); }
+}
+class IntBox extends Box<int> {}
+
+(new IntBox(5))->make();
+?>
+--EXPECTF--
+Fatal error: Type arguments cannot be applied to "static": "static" is the runtime type and already carries its type arguments. Use "new static()" to construct the exact runtime type, or "new self::<...>" to apply type arguments to the enclosing class in %s on line %d

Zend/tests/generics/reification/inference_scalar.phpt

@@ -0,0 +1,22 @@
+--TEST--
+Reification: T is inferred from scalar/array arguments, not just objects
+--FILE--
+<?php
+function tparams<T = mixed>(T $a): array { return func_get_type_args(); }
+
+var_dump(tparams(1)["T"]);
+var_dump(tparams("foo")["T"]);
+var_dump(tparams(1.5)["T"]);
+var_dump(tparams(true)["T"]);
+var_dump(tparams(false)["T"]);
+var_dump(tparams([1, 2])["T"]);
+var_dump(tparams(new stdClass())["T"]);
+?>
+--EXPECT--
+string(3) "int"
+string(6) "string"
+string(5) "float"
+string(4) "bool"
+string(4) "bool"
+string(5) "array"
+string(8) "stdClass"

Zend/tests/generics/reification/inference_scalar_return_enforced.phpt

@@ -0,0 +1,26 @@
+--TEST--
+Reification: a :T return type reified from an inferred scalar T is enforced
+--FILE--
+<?php
+// T is inferred from the argument. A method declared `: T` must therefore
+// enforce the inferred scalar type on its return value rather than silently
+// erasing T to mixed.
+function bad<T = mixed>(T $a): T { return "not the same type"; }
+
+echo "calling bad(1) — T inferred as int, returning a string must fail\n";
+try {
+    var_dump(bad(1));
+} catch (TypeError $e) {
+    echo "TypeError: ", $e->getMessage(), "\n";
+}
+
+// Returning a matching type is fine.
+function good<T = mixed>(T $a): T { return $a; }
+var_dump(good(42));
+var_dump(good("ok"));
+?>
+--EXPECT--
+calling bad(1) — T inferred as int, returning a string must fail
+TypeError: bad(): Return value must be of type int, string returned
+int(42)
+string(2) "ok"

Zend/tests/generics/reification/new_static_vs_self.phpt

@@ -0,0 +1,45 @@
+--TEST--
+Reification: `new static()` reproduces the exact runtime type; `new self::<...>` re-applies the lexical template
+--FILE--
+<?php
+// `new static()` (no turbofish) is the correct way to construct "another of
+// exactly me": the runtime type already carries its type arguments, so a
+// monomorph clones to the same monomorph and a subclass clones to itself.
+// `new self::<...>` remains the way to apply type arguments to the enclosing
+// (lexical) class — including re-binding to different args.
+class C<TKey, T> {
+    public function __construct(private array $e = []) {}
+
+    public function dupStatic(): static  { return new static($this->e); }
+    public function dupSelf(): static    { return new self::<TKey, T>($this->e); }
+    public function swapSelf(): object   { return new self::<T, TKey>($this->e); }
+    public function reSelf(): object     { return new self::<float, float>($this->e); }
+}
+
+$o = new C::<int, string>([1, 2]);
+echo "orig:      ", $o::class, "\n";
+echo "dupStatic: ", $o->dupStatic()::class, "\n";
+echo "dupSelf:   ", $o->dupSelf()::class, "\n";
+echo "swapSelf:  ", $o->swapSelf()::class, "\n";
+echo "reSelf:    ", $o->reSelf()::class, "\n";
+
+// `new static()` through a non-generic subclass of a monomorph reproduces the
+// subclass, exactly as plain LSB does.
+class Box<T> {
+    public function __construct(public mixed $v = null) {}
+    public function copy(): static { return new static($this->v); }
+}
+class IntBox extends Box<int> {}
+
+$b = new IntBox(5);
+echo "IntBox:      ", $b::class, "\n";
+echo "IntBox copy: ", $b->copy()::class, "\n";
+?>
+--EXPECT--
+orig:      C<int,string>
+dupStatic: C<int,string>
+dupSelf:   C<int,string>
+swapSelf:  C<string,int>
+reSelf:    C<float,float>
+IntBox:      IntBox
+IntBox copy: IntBox

Zend/zend_compile.c

@@ -8097,6 +8097,27 @@ static void zend_compile_new(znode *result, zend_ast *ast) /* {{{ */
 		}
 	}
 
+	/* `new static::<...>` is always rejected at compile time. The type
+	 * arguments are written in the lexical scope — they name the enclosing
+	 * class's (`self`'s) type parameters — but `static` is the *runtime* type,
+	 * whose parameter list is unknown here and need not match: it may be a
+	 * generic subclass with a different parameter list, or a non-generic
+	 * subclass of a monomorph (e.g. `class IntBox extends Box<int>`) with no
+	 * type parameters at all. `static` already carries its own bindings, so
+	 * `new static()` reproduces the exact runtime type; `new self::<...>`
+	 * re-applies the lexical template. */
+	if (opline->op1_type == IS_UNUSED && turbofish_ast
+			&& (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_STATIC) {
+		zend_ast_list *tf_list = zend_ast_get_list(turbofish_ast);
+		if (tf_list->children > 0) {
+			zend_error_noreturn(E_COMPILE_ERROR,
+				"Type arguments cannot be applied to \"static\": "
+				"\"static\" is the runtime type and already carries its type arguments. "
+				"Use \"new static()\" to construct the exact runtime type, "
+				"or \"new self::<...>\" to apply type arguments to the enclosing class");
+		}
+	}
+
 	/* Reject turbofish on a known non-generic class at compile time so the
 	 * error matches the type-position behavior (rather than waiting for
 	 * VERIFY_GENERIC_ARGUMENTS to throw ArgumentCountError at runtime). */