Skip to content

Commit 5a44d9c

Browse files
GirgiasGirgias
committed
Resolve trait relative class types when added to a class
Also throw a compile error if trying to use a trait using the parent type in a class not having a parent
1 parent e98a5b4 commit 5a44d9c

12 files changed

+726
-0
lines changed

‎Zend/tests/bug80055.phpt renamed to ‎Zend/tests/traits/bug80055.phpt

File renamed without changes.

‎Zend/tests/traits/trait_parent_type_in_class_no_parent.phpt

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
--TEST--
2+
Cannot use a trait which references parent as a type in a class with no parent, single type
3+
--FILE--
4+
<?php
5+
trait TraitExample {
6+
public function bar(): parent { return parent::class; }
7+
}
8+
9+
class A {
10+
use TraitExample;
11+
}
12+
?>
13+
--EXPECTF--
14+
Fatal error: Cannot use trait which has "parent" as a type when current class scope has no parent in %s on line %d

‎Zend/tests/traits/trait_parent_type_in_class_no_parent_variation2.phpt

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
--TEST--
2+
Cannot use a trait which references parent as a type in a class with no parent, nullable type
3+
--FILE--
4+
<?php
5+
trait TraitExample {
6+
public function bar(): ?parent { return parent::class; }
7+
}
8+
9+
class A {
10+
use TraitExample;
11+
}
12+
?>
13+
--EXPECTF--
14+
Fatal error: Cannot use trait which has "parent" as a type when current class scope has no parent in %s on line %d

‎Zend/tests/traits/trait_parent_type_in_class_no_parent_variation3.phpt

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
--TEST--
2+
Cannot use a trait which references parent as a type in a class with no parent, union type
3+
--FILE--
4+
<?php
5+
trait TraitExample {
6+
public function bar(): int|parent { return parent::class; }
7+
}
8+
9+
class A {
10+
use TraitExample;
11+
}
12+
?>
13+
--EXPECTF--
14+
Fatal error: Cannot use trait which has "parent" as a type when current class scope has no parent in %s on line %d

‎Zend/tests/traits/trait_parent_type_in_class_no_parent_variation4.phpt

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
--TEST--
2+
Cannot use a trait which references parent as a type in a class with no parent, DNF type
3+
--FILE--
4+
<?php
5+
trait TraitExample {
6+
public function bar(): (X&Y)|parent { return parent::class; }
7+
}
8+
9+
class A {
10+
use TraitExample;
11+
}
12+
?>
13+
--EXPECTF--
14+
Fatal error: Cannot use trait which has "parent" as a type when current class scope has no parent in %s on line %d

‎Zend/zend_inheritance.c

Lines changed: 98 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1946,6 +1946,102 @@ static zend_class_entry *fixup_trait_scope(const zend_function *fn, zend_class_e
19461946
return fn->common.scope->ce_flags & ZEND_ACC_TRAIT ? ce : fn->common.scope;
19471947
}
19481948

1949+
/* We cannot modify the type in-place (e.g. via a pointer) as it is written to SHM */
1950+
static zend_type zend_resolve_single_type(zend_type type, const zend_class_entry *const ce)
1951+
{
1952+
/* Only built-in types + static */
1953+
if (!ZEND_TYPE_IS_COMPLEX(type)) {
1954+
return type;
1955+
}
1956+
1957+
ZEND_ASSERT(ZEND_TYPE_HAS_NAME(type) || (ZEND_TYPE_HAS_LIST(type)));
1958+
if (ZEND_TYPE_HAS_NAME(type)) {
1959+
if (ZEND_TYPE_IS_RELATIVE_SELF(type)) {
1960+
zend_type resolved_type = (zend_type) ZEND_TYPE_INIT_CLASS(zend_string_copy(ce->name), /* allows_null */ false, /* extra_flags */ ZEND_TYPE_FULL_MASK(type));
1961+
return resolved_type;
1962+
} else if (ZEND_TYPE_IS_RELATIVE_PARENT(type)) {
1963+
if (!ce->parent) {
1964+
zend_error_noreturn(E_COMPILE_ERROR,
1965+
"Cannot use trait which has \"parent\" as a type when current class scope has no parent");
1966+
return (zend_type) ZEND_TYPE_INIT_NONE(0);
1967+
}
1968+
zend_type resolved_type = (zend_type) ZEND_TYPE_INIT_CLASS(zend_string_copy(ce->parent->name), /* allows_null */ false, /* extra_flags */ ZEND_TYPE_FULL_MASK(type));
1969+
return resolved_type;
1970+
} else {
1971+
return type;
1972+
}
1973+
}
1974+
1975+
/* Intersection types cannot have relative class_types */
1976+
if (ZEND_TYPE_IS_INTERSECTION(type)) {
1977+
return type;
1978+
}
1979+
1980+
const zend_type_list *union_type_list = ZEND_TYPE_LIST(type);
1981+
zend_type *single_type;
1982+
1983+
/* TODO Only do allocation if need to resolve types, as type is stored in SHM */
1984+
zend_type_list *new_union_type_list = zend_arena_alloc(&CG(arena), ZEND_TYPE_LIST_SIZE(union_type_list->num_types));
1985+
memcpy(new_union_type_list, union_type_list, ZEND_TYPE_LIST_SIZE(union_type_list->num_types));
1986+
1987+
ZEND_TYPE_LIST_FOREACH(new_union_type_list, single_type) {
1988+
ZEND_ASSERT(ZEND_TYPE_HAS_NAME(*single_type) || (ZEND_TYPE_IS_INTERSECTION(*single_type)));
1989+
1990+
/* Intersections types cannot have self or parent */
1991+
if (ZEND_TYPE_IS_INTERSECTION(*single_type)) {
1992+
continue;
1993+
}
1994+
if (ZEND_TYPE_IS_RELATIVE_SELF(*single_type)) {
1995+
zend_type resolved_type = (zend_type) ZEND_TYPE_INIT_CLASS(zend_string_copy(ce->name), /* allows_null */ false, /* extra_flags */ ZEND_TYPE_FULL_MASK(*single_type));
1996+
memmove(single_type, &resolved_type, sizeof(zend_type));
1997+
}
1998+
if (ZEND_TYPE_IS_RELATIVE_PARENT(*single_type)) {
1999+
if (!ce->parent) {
2000+
zend_error_noreturn(E_COMPILE_ERROR,
2001+
"Cannot use trait which has \"parent\" as a type when current class scope has no parent");
2002+
return (zend_type) ZEND_TYPE_INIT_NONE(0);
2003+
}
2004+
zend_type resolved_type = (zend_type) ZEND_TYPE_INIT_CLASS(zend_string_copy(ce->parent->name), /* allows_null */ false, /* extra_flags */ ZEND_TYPE_FULL_MASK(*single_type));
2005+
memmove(single_type, &resolved_type, sizeof(zend_type));
2006+
}
2007+
} ZEND_TYPE_LIST_FOREACH_END();
2008+
2009+
zend_type new_type = (zend_type) ZEND_TYPE_INIT_NONE(0);
2010+
ZEND_TYPE_SET_LIST(new_type, new_union_type_list);
2011+
ZEND_TYPE_FULL_MASK(new_type) |= _ZEND_TYPE_ARENA_BIT;
2012+
/* Inform that the type list is a union type */
2013+
ZEND_TYPE_FULL_MASK(new_type) |= _ZEND_TYPE_UNION_BIT;
2014+
return new_type;
2015+
}
2016+
2017+
static void zend_resolve_trait_relative_class_types(zend_function *const fn, const zend_class_entry *const ce)
2018+
{
2019+
/* We are adding trait methods to another trait, delay resolution */
2020+
if (ce->ce_flags & ZEND_ACC_TRAIT) {
2021+
return;
2022+
}
2023+
/* No type info */
2024+
if (!fn->common.arg_info) {
2025+
return;
2026+
}
2027+
2028+
bool has_return_type = fn->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE;
2029+
/* Variadic parameters are not counted as part of the standard number of arguments */
2030+
bool has_variadic_type = fn->common.fn_flags & ZEND_ACC_VARIADIC;
2031+
uint32_t num_args = fn->common.num_args + has_variadic_type;
2032+
/* TODO Only do allocation if need to resolve types, as arg_info is stored in SHM */
2033+
size_t allocated_size = sizeof(zend_arg_info) * (has_return_type + num_args);
2034+
2035+
zend_arg_info *new_arg_infos = zend_arena_alloc(&CG(arena), allocated_size);
2036+
memcpy(new_arg_infos, fn->common.arg_info - has_return_type, allocated_size);
2037+
fn->common.arg_info = new_arg_infos + has_return_type;
2038+
2039+
for (uint32_t i = 0; i < num_args + has_return_type; i++) {
2040+
zend_type type = new_arg_infos[i].type;
2041+
new_arg_infos[i].type = zend_resolve_single_type(type, ce);
2042+
}
2043+
}
2044+
19492045
static void zend_add_trait_method(zend_class_entry *ce, zend_string *name, zend_string *key, zend_function *fn) /* {{{ */
19502046
{
19512047
zend_function *existing_fn = NULL;
@@ -1992,10 +2088,12 @@ static void zend_add_trait_method(zend_class_entry *ce, zend_string *name, zend_
19922088
if (UNEXPECTED(fn->type == ZEND_INTERNAL_FUNCTION)) {
19932089
new_fn = zend_arena_alloc(&CG(arena), sizeof(zend_internal_function));
19942090
memcpy(new_fn, fn, sizeof(zend_internal_function));
2091+
zend_resolve_trait_relative_class_types(new_fn, ce);
19952092
new_fn->common.fn_flags |= ZEND_ACC_ARENA_ALLOCATED;
19962093
} else {
19972094
new_fn = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
19982095
memcpy(new_fn, fn, sizeof(zend_op_array));
2096+
zend_resolve_trait_relative_class_types(new_fn, ce);
19992097
new_fn->op_array.fn_flags |= ZEND_ACC_TRAIT_CLONE;
20002098
new_fn->op_array.fn_flags &= ~ZEND_ACC_IMMUTABLE;
20012099
}

‎ext/reflection/tests/types/relative_class_types_in_classes_variadic_parameter1.phpt

Lines changed: 103 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,103 @@
1+
--TEST--
2+
ReflectionTypes of relative class types (self, parent) in classes, parameter types
3+
--FILE--
4+
<?php
5+
6+
class A {
7+
8+
}
9+
10+
class B extends A {
11+
public function foo(self ...$o) { return $o; }
12+
}
13+
14+
class C extends B {
15+
public function bar(parent ...$o) { return $o; }
16+
public function ping(self ...$o) { return $o; }
17+
}
18+
19+
class D extends C {}
20+
21+
$instances = [
22+
new A,
23+
new B,
24+
new C,
25+
new D,
26+
];
27+
28+
foreach ($instances as $instance) {
29+
echo 'Class: ', $instance::class, PHP_EOL;
30+
$rc = new ReflectionClass($instance);
31+
$methods = $rc->getMethods();
32+
foreach ($methods as $method) {
33+
echo "\tMethod: ", $method->name, PHP_EOL;
34+
$parameters = $method->getParameters();
35+
foreach ($parameters as $param) {
36+
$type = $param->getType();
37+
echo "\t\tType: ", $type, PHP_EOL;
38+
echo "\t\tInstance of: ", $type::class, PHP_EOL;
39+
$resolvedType = $type->resolveToNamedType();
40+
echo "\t\t\tResolved Type: ", $resolvedType, PHP_EOL;
41+
echo "\t\t\tInstance of: ", $resolvedType::class, PHP_EOL;
42+
43+
foreach ($instances as $arg) {
44+
try {
45+
$instance->{$method->name}($arg);
46+
} catch (\TypeError $e) {
47+
echo "\t\t\t\t", $e->getMessage(), PHP_EOL;
48+
}
49+
}
50+
}
51+
}
52+
}
53+
54+
?>
55+
--EXPECTF--
56+
Class: A
57+
Class: B
58+
Method: foo
59+
Type: self
60+
Instance of: ReflectionRelativeClassType
61+
Resolved Type: B
62+
Instance of: ReflectionNamedType
63+
B::foo(): Argument #1 must be of type B, A given, called in %s on line %d
64+
Class: C
65+
Method: bar
66+
Type: parent
67+
Instance of: ReflectionRelativeClassType
68+
Resolved Type: B
69+
Instance of: ReflectionNamedType
70+
C::bar(): Argument #1 must be of type B, A given, called in %s on line %d
71+
Method: ping
72+
Type: self
73+
Instance of: ReflectionRelativeClassType
74+
Resolved Type: C
75+
Instance of: ReflectionNamedType
76+
C::ping(): Argument #1 must be of type C, A given, called in %s on line %d
77+
C::ping(): Argument #1 must be of type C, B given, called in %s on line %d
78+
Method: foo
79+
Type: self
80+
Instance of: ReflectionRelativeClassType
81+
Resolved Type: B
82+
Instance of: ReflectionNamedType
83+
B::foo(): Argument #1 must be of type B, A given, called in %s on line %d
84+
Class: D
85+
Method: bar
86+
Type: parent
87+
Instance of: ReflectionRelativeClassType
88+
Resolved Type: B
89+
Instance of: ReflectionNamedType
90+
C::bar(): Argument #1 must be of type B, A given, called in %s on line %d
91+
Method: ping
92+
Type: self
93+
Instance of: ReflectionRelativeClassType
94+
Resolved Type: C
95+
Instance of: ReflectionNamedType
96+
C::ping(): Argument #1 must be of type C, A given, called in %s on line %d
97+
C::ping(): Argument #1 must be of type C, B given, called in %s on line %d
98+
Method: foo
99+
Type: self
100+
Instance of: ReflectionRelativeClassType
101+
Resolved Type: B
102+
Instance of: ReflectionNamedType
103+
B::foo(): Argument #1 must be of type B, A given, called in %s on line %d

‎ext/reflection/tests/types/relative_class_types_in_trait_used_in_classes.phpt

Lines changed: 101 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,101 @@
1+
--TEST--
2+
ReflectionTypes of relative class types (self, parent, static) from traits in classes, return types
3+
--FILE--
4+
<?php
5+
6+
trait TraitExample {
7+
public function bar(object $o): parent { return $o; }
8+
public function ping(object $o): self { return $o; }
9+
public function pong(object $o): static { return $o; }
10+
}
11+
12+
class A {
13+
14+
}
15+
16+
class B extends A {
17+
}
18+
19+
class C extends B {
20+
use TraitExample;
21+
}
22+
23+
class D extends C {}
24+
25+
$instances = [
26+
new A,
27+
new B,
28+
new C,
29+
new D,
30+
];
31+
32+
foreach ($instances as $instance) {
33+
echo 'Class: ', $instance::class, PHP_EOL;
34+
$rc = new ReflectionClass($instance);
35+
$methods = $rc->getMethods();
36+
foreach ($methods as $method) {
37+
echo "\tMethod: ", $method->name, PHP_EOL;
38+
$type = $method->getReturnType();
39+
echo "\t\tType: ", $type, PHP_EOL;
40+
echo "\t\tInstance of: ", $type::class, PHP_EOL;
41+
$resolvedType = $type->resolveToNamedType();
42+
echo "\t\t\tResolved Type: ", $resolvedType, PHP_EOL;
43+
echo "\t\t\tInstance of: ", $resolvedType::class, PHP_EOL;
44+
45+
foreach ($instances as $arg) {
46+
try {
47+
$instance->{$method->name}($arg);
48+
} catch (\TypeError $e) {
49+
echo "\t\t\t\t", $e->getMessage(), PHP_EOL;
50+
}
51+
}
52+
}
53+
}
54+
55+
?>
56+
--EXPECT--
57+
Class: A
58+
Class: B
59+
Class: C
60+
Method: bar
61+
Type: parent
62+
Instance of: ReflectionRelativeClassType
63+
Resolved Type: B
64+
Instance of: ReflectionNamedType
65+
C::bar(): Return value must be of type B, A returned
66+
Method: ping
67+
Type: self
68+
Instance of: ReflectionRelativeClassType
69+
Resolved Type: C
70+
Instance of: ReflectionNamedType
71+
C::ping(): Return value must be of type C, A returned
72+
C::ping(): Return value must be of type C, B returned
73+
Method: pong
74+
Type: static
75+
Instance of: ReflectionRelativeClassType
76+
Resolved Type: C
77+
Instance of: ReflectionNamedType
78+
C::pong(): Return value must be of type C, A returned
79+
C::pong(): Return value must be of type C, B returned
80+
Class: D
81+
Method: bar
82+
Type: parent
83+
Instance of: ReflectionRelativeClassType
84+
Resolved Type: B
85+
Instance of: ReflectionNamedType
86+
C::bar(): Return value must be of type B, A returned
87+
Method: ping
88+
Type: self
89+
Instance of: ReflectionRelativeClassType
90+
Resolved Type: C
91+
Instance of: ReflectionNamedType
92+
C::ping(): Return value must be of type C, A returned
93+
C::ping(): Return value must be of type C, B returned
94+
Method: pong
95+
Type: static
96+
Instance of: ReflectionRelativeClassType
97+
Resolved Type: D
98+
Instance of: ReflectionNamedType
99+
C::pong(): Return value must be of type D, A returned
100+
C::pong(): Return value must be of type D, B returned
101+
C::pong(): Return value must be of type D, C returned

0 commit comments

Comments
 (0)