Skip to content

Commit 1135bef

Browse files
php-genericsphp-generics
committed
WIP
1 parent e87ccd9 commit 1135bef

47 files changed

Lines changed: 3153 additions & 219 deletions

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎Zend/Optimizer/compact_literals.c‎

Lines changed: 58 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -94,11 +94,28 @@ static zend_string *create_str_cache_key(zval *literal, uint8_t num_related)
9494
Z_STRVAL_P(literal), Z_STRLEN_P(literal),
9595
Z_STRVAL_P(literal + 1), Z_STRLEN_P(literal + 1));
9696
} else if (num_related == 3) {
97-
ZEND_ASSERT(Z_TYPE_P(literal + 1) == IS_STRING && Z_TYPE_P(literal + 2) == IS_STRING);
98-
key = zend_string_concat3(
99-
Z_STRVAL_P(literal), Z_STRLEN_P(literal),
100-
Z_STRVAL_P(literal + 1), Z_STRLEN_P(literal + 1),
101-
Z_STRVAL_P(literal + 2), Z_STRLEN_P(literal + 2));
97+
if (Z_TYPE_P(literal + 2) == IS_PTR || Z_TYPE_P(literal + 2) == IS_LONG) {
98+
/* Generic args literal (IS_PTR or IS_LONG pointer) — include pointer value
99+
* in key to prevent merging across different generic instantiations */
100+
char ptr_buf[32];
101+
uintptr_t ptr_val = (Z_TYPE_P(literal + 2) == IS_PTR)
102+
? (uintptr_t)Z_PTR_P(literal + 2)
103+
: (uintptr_t)Z_LVAL_P(literal + 2);
104+
int ptr_len = snprintf(ptr_buf, sizeof(ptr_buf), "G%lx", (unsigned long)ptr_val);
105+
ZEND_ASSERT(Z_TYPE_P(literal + 1) == IS_STRING);
106+
size_t len = Z_STRLEN_P(literal) + Z_STRLEN_P(literal + 1) + ptr_len;
107+
key = zend_string_alloc(len, 0);
108+
memcpy(ZSTR_VAL(key), Z_STRVAL_P(literal), Z_STRLEN_P(literal));
109+
memcpy(ZSTR_VAL(key) + Z_STRLEN_P(literal), Z_STRVAL_P(literal + 1), Z_STRLEN_P(literal + 1));
110+
memcpy(ZSTR_VAL(key) + Z_STRLEN_P(literal) + Z_STRLEN_P(literal + 1), ptr_buf, ptr_len);
111+
ZSTR_VAL(key)[len] = '\0';
112+
} else {
113+
ZEND_ASSERT(Z_TYPE_P(literal + 1) == IS_STRING && Z_TYPE_P(literal + 2) == IS_STRING);
114+
key = zend_string_concat3(
115+
Z_STRVAL_P(literal), Z_STRLEN_P(literal),
116+
Z_STRVAL_P(literal + 1), Z_STRLEN_P(literal + 1),
117+
Z_STRVAL_P(literal + 2), Z_STRLEN_P(literal + 2));
118+
}
102119
} else {
103120
ZEND_ASSERT(0 && "Currently not needed");
104121
}
@@ -150,7 +167,8 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
150167
break;
151168
case ZEND_INIT_STATIC_METHOD_CALL:
152169
if (opline->op1_type == IS_CONST) {
153-
LITERAL_INFO(opline->op1.constant, 2);
170+
LITERAL_INFO(opline->op1.constant,
171+
(opline->result.num & 0x80000000) ? 3 : 2);
154172
}
155173
if (opline->op2_type == IS_CONST) {
156174
LITERAL_INFO(opline->op2.constant, 2);
@@ -200,14 +218,20 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
200218
}
201219
break;
202220
case ZEND_FETCH_CLASS:
203-
case ZEND_INSTANCEOF:
204221
if (opline->op2_type == IS_CONST) {
205222
LITERAL_INFO(opline->op2.constant, 2);
206223
}
207224
break;
225+
case ZEND_INSTANCEOF:
226+
if (opline->op2_type == IS_CONST) {
227+
LITERAL_INFO(opline->op2.constant,
228+
(opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG) ? 3 : 2);
229+
}
230+
break;
208231
case ZEND_NEW:
209232
if (opline->op1_type == IS_CONST) {
210-
LITERAL_INFO(opline->op1.constant, 2);
233+
LITERAL_INFO(opline->op1.constant,
234+
(opline->op2.num & 0x80000000) ? 3 : 2);
211235
}
212236
break;
213237
case ZEND_DECLARE_CLASS:
@@ -568,30 +592,32 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
568592
}
569593
}
570594
break;
571-
case ZEND_INIT_STATIC_METHOD_CALL:
595+
case ZEND_INIT_STATIC_METHOD_CALL: {
596+
uint32_t generic_flag = opline->result.num & 0x80000000;
572597
if (opline->op2_type == IS_CONST) {
573598
// op2 static method
574599
if (opline->op1_type == IS_CONST) {
575600
opline->result.num = add_static_slot(&hash, op_array,
576601
opline->op1.constant,
577602
opline->op2.constant,
578603
LITERAL_STATIC_METHOD,
579-
&cache_size);
604+
&cache_size) | generic_flag;
580605
} else {
581-
opline->result.num = cache_size;
606+
opline->result.num = cache_size | generic_flag;
582607
cache_size += 2 * sizeof(void *);
583608
}
584609
} else if (opline->op1_type == IS_CONST) {
585610
// op1 class
586611
if (class_slot[opline->op1.constant] >= 0) {
587-
opline->result.num = class_slot[opline->op1.constant];
612+
opline->result.num = class_slot[opline->op1.constant] | generic_flag;
588613
} else {
589-
opline->result.num = cache_size;
614+
opline->result.num = cache_size | generic_flag;
590615
cache_size += sizeof(void *);
591-
class_slot[opline->op1.constant] = opline->result.num;
616+
class_slot[opline->op1.constant] = cache_size - sizeof(void *);
592617
}
593618
}
594619
break;
620+
}
595621
case ZEND_DEFINED:
596622
// op1 const
597623
if (const_slot[opline->op1.constant] >= 0) {
@@ -665,7 +691,6 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
665691
}
666692
break;
667693
case ZEND_FETCH_CLASS:
668-
case ZEND_INSTANCEOF:
669694
if (opline->op2_type == IS_CONST) {
670695
// op2 class
671696
if (class_slot[opline->op2.constant] >= 0) {
@@ -677,15 +702,29 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
677702
}
678703
}
679704
break;
705+
case ZEND_INSTANCEOF:
706+
if (opline->op2_type == IS_CONST) {
707+
// op2 class — preserve generic flag
708+
uint32_t generic_flag = opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG;
709+
if (class_slot[opline->op2.constant] >= 0) {
710+
opline->extended_value = class_slot[opline->op2.constant] | generic_flag;
711+
} else {
712+
opline->extended_value = cache_size | generic_flag;
713+
cache_size += sizeof(void *);
714+
class_slot[opline->op2.constant] = cache_size - sizeof(void *);
715+
}
716+
}
717+
break;
680718
case ZEND_NEW:
681719
if (opline->op1_type == IS_CONST) {
682-
// op1 class
720+
// op1 class — preserve generic flag
721+
uint32_t generic_flag = opline->op2.num & 0x80000000;
683722
if (class_slot[opline->op1.constant] >= 0) {
684-
opline->op2.num = class_slot[opline->op1.constant];
723+
opline->op2.num = class_slot[opline->op1.constant] | generic_flag;
685724
} else {
686-
opline->op2.num = cache_size;
725+
opline->op2.num = cache_size | generic_flag;
687726
cache_size += sizeof(void *);
688-
class_slot[opline->op1.constant] = opline->op2.num;
727+
class_slot[opline->op1.constant] = cache_size - sizeof(void *);
689728
}
690729
}
691730
break;

‎Zend/Optimizer/zend_inference.c‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2382,6 +2382,11 @@ static uint32_t zend_convert_type(const zend_script *script, zend_type type, zen
23822382
return MAY_BE_ANY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF|MAY_BE_RC1|MAY_BE_RCN;
23832383
}
23842384

2385+
/* Generic type parameters can resolve to any type at runtime */
2386+
if (ZEND_TYPE_IS_GENERIC_PARAM(type)) {
2387+
return MAY_BE_ANY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF|MAY_BE_RC1|MAY_BE_RCN;
2388+
}
2389+
23852390
uint32_t tmp = zend_convert_type_declaration_mask(ZEND_TYPE_PURE_MASK(type));
23862391
if (ZEND_TYPE_IS_COMPLEX(type)) {
23872392
tmp |= MAY_BE_OBJECT;

‎Zend/Optimizer/zend_optimizer.c‎

Lines changed: 14 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -301,22 +301,32 @@ bool zend_optimizer_update_op1_const(zend_op_array *op_array,
301301
opline->extended_value = alloc_cache_slots(op_array, 1);
302302
zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
303303
break;
304-
case ZEND_NEW:
304+
case ZEND_NEW: {
305+
uint32_t generic_flag = opline->op2.num & 0x80000000;
305306
REQUIRES_STRING(val);
306307
drop_leading_backslash(val);
307308
opline->op1.constant = zend_optimizer_add_literal(op_array, val);
308-
opline->op2.num = alloc_cache_slots(op_array, 1);
309+
opline->op2.num = alloc_cache_slots(op_array, 1) | generic_flag;
309310
zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
311+
if (generic_flag) {
312+
/* Copy the generic args IS_PTR literal (was at old op1.constant + 2) */
313+
/* Note: the generic args are already in the literal table from compilation,
314+
* but we need to add a placeholder since the optimizer rebuilds literals.
315+
* The actual IS_PTR will be re-added by the caller. */
316+
}
310317
break;
311-
case ZEND_INIT_STATIC_METHOD_CALL:
318+
}
319+
case ZEND_INIT_STATIC_METHOD_CALL: {
320+
uint32_t generic_flag = opline->result.num & 0x80000000;
312321
REQUIRES_STRING(val);
313322
drop_leading_backslash(val);
314323
opline->op1.constant = zend_optimizer_add_literal(op_array, val);
315324
if (opline->op2_type != IS_CONST) {
316-
opline->result.num = alloc_cache_slots(op_array, 1);
325+
opline->result.num = alloc_cache_slots(op_array, 1) | generic_flag;
317326
}
318327
zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val)));
319328
break;
329+
}
320330
case ZEND_FETCH_CLASS_CONSTANT:
321331
REQUIRES_STRING(val);
322332
drop_leading_backslash(val);

‎Zend/tests/generics/generic_anonymous_class.phpt‎

Lines changed: 47 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,47 @@
1+
--TEST--
2+
Generic class: anonymous classes extending generic classes
3+
--FILE--
4+
<?php
5+
6+
class Box<T> {
7+
public function __construct(public T $value) {}
8+
public function get(): T { return $this->value; }
9+
}
10+
11+
// Anonymous class extending generic with bound args
12+
$obj = new class(42) extends Box<int> {};
13+
echo $obj->get() . "\n";
14+
15+
// Type enforcement works
16+
try {
17+
$obj->value = "not an int";
18+
} catch (TypeError $e) {
19+
echo "TypeError: type enforced\n";
20+
}
21+
22+
// Anonymous class can override methods
23+
$obj2 = new class("hello") extends Box<string> {
24+
public function get(): string {
25+
return strtoupper(parent::get());
26+
}
27+
};
28+
echo $obj2->get() . "\n";
29+
30+
// Anonymous class implementing generic interface
31+
interface Getter<T> {
32+
public function get(): T;
33+
}
34+
35+
$obj3 = new class implements Getter<int> {
36+
public function get(): int { return 99; }
37+
};
38+
echo $obj3->get() . "\n";
39+
40+
echo "OK\n";
41+
?>
42+
--EXPECTF--
43+
42
44+
TypeError: type enforced
45+
HELLO
46+
99
47+
OK

‎Zend/tests/generics/generic_autoloading.phpt‎

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
--TEST--
2+
Generic class: autoloading triggers for base class name
3+
--FILE--
4+
<?php
5+
6+
$autoloaded = [];
7+
spl_autoload_register(function ($class) use (&$autoloaded) {
8+
$autoloaded[] = $class;
9+
if ($class === 'AutoBox') {
10+
eval('class AutoBox<T> { public function __construct(public T $value) {} public function get(): T { return $this->value; } }');
11+
}
12+
});
13+
14+
// new with generic args triggers autoload for base class
15+
$b = new AutoBox<int>(42);
16+
echo $b->get() . "\n";
17+
var_dump($b);
18+
19+
// Verify autoloader received the base class name (no generics)
20+
echo "Autoloaded: " . implode(", ", $autoloaded) . "\n";
21+
22+
echo "OK\n";
23+
?>
24+
--EXPECTF--
25+
42
26+
object(AutoBox<int>)#%d (1) {
27+
["value"]=>
28+
int(42)
29+
}
30+
Autoloaded: AutoBox
31+
OK

‎Zend/tests/generics/generic_class_alias.phpt‎

Lines changed: 44 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,44 @@
1+
--TEST--
2+
Generic class: class_alias works with generic classes
3+
--FILE--
4+
<?php
5+
6+
class Box<T> {
7+
public function __construct(public T $value) {}
8+
public function get(): T { return $this->value; }
9+
}
10+
11+
class_alias('Box', 'Container');
12+
13+
// Alias with generic args
14+
$c = new Container<int>(42);
15+
echo $c->get() . "\n";
16+
var_dump($c);
17+
18+
// get_class returns the original class name
19+
echo get_class($c) . "\n";
20+
21+
// instanceof works
22+
echo ($c instanceof Box) ? "instanceof Box: yes\n" : "instanceof Box: no\n";
23+
echo ($c instanceof Container) ? "instanceof Container: yes\n" : "instanceof Container: no\n";
24+
25+
// Type enforcement works through alias
26+
try {
27+
$c->value = "not an int";
28+
} catch (TypeError $e) {
29+
echo "TypeError: type enforced\n";
30+
}
31+
32+
echo "OK\n";
33+
?>
34+
--EXPECTF--
35+
42
36+
object(Box<int>)#1 (1) {
37+
["value"]=>
38+
int(42)
39+
}
40+
Box
41+
instanceof Box: yes
42+
instanceof Container: yes
43+
TypeError: type enforced
44+
OK

‎Zend/tests/generics/generic_debug_display.phpt‎

Lines changed: 67 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,67 @@
1+
--TEST--
2+
Generic class: debug display with var_dump, print_r, and stack traces
3+
--FILE--
4+
<?php
5+
6+
class Box<T> {
7+
public function __construct(public T $value) {}
8+
public function throwError(): void {
9+
throw new RuntimeException("test");
10+
}
11+
}
12+
13+
class Pair<A, B> {
14+
public function __construct(public A $first, public B $second) {}
15+
}
16+
17+
// var_dump shows generic args
18+
$b = new Box<int>(42);
19+
var_dump($b);
20+
21+
// print_r shows generic args
22+
echo "---\n";
23+
$p = new Pair<string, int>("hello", 99);
24+
print_r($p);
25+
26+
// get_class returns raw class name (no generic args)
27+
echo "---\n";
28+
echo get_class($b) . "\n";
29+
echo get_class($p) . "\n";
30+
31+
// Stack trace shows generic args
32+
echo "---\n";
33+
try {
34+
$b->throwError();
35+
} catch (Throwable $e) {
36+
echo $e->getTraceAsString() . "\n";
37+
}
38+
39+
// Inherited class with bound generic args
40+
class IntBox extends Box<int> {}
41+
$ib = new IntBox(100);
42+
var_dump($ib);
43+
44+
echo "OK\n";
45+
?>
46+
--EXPECTF--
47+
object(Box<int>)#1 (1) {
48+
["value"]=>
49+
int(42)
50+
}
51+
---
52+
Pair<string, int> Object
53+
(
54+
[first] => hello
55+
[second] => 99
56+
)
57+
---
58+
Box
59+
Pair
60+
---
61+
#0 %s(%d): Box<int>->throwError()
62+
#1 {main}
63+
object(IntBox<int>)#%d (1) {
64+
["value"]=>
65+
int(100)
66+
}
67+
OK

0 commit comments

Comments
 (0)