mirrors/php-src
0
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-11-24 18:34:21 +08:00
Code Issues Packages Projects Releases Wiki Activity
5e57f37247
php-src/Zend/zend_inheritance.c

2572 lines
88 KiB
C
Raw Normal View History

Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/*
+----------------------------------------------------------------------+
| Zend Engine |
+----------------------------------------------------------------------+
Adios, yearly copyright ranges
2019-01-30 17:23:29 +08:00
| Copyright (c) Zend Technologies Ltd. (http://www.zend.com) |
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
+----------------------------------------------------------------------+
| This source file is subject to version 2.00 of the Zend license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.zend.com/license/2_00.txt. |
| If you did not receive a copy of the Zend license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@zend.com so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
Update email addresses. We're still @Zend, but future proofing it...
2018-11-01 23:20:07 +08:00
| Authors: Andi Gutmans <andi@php.net> |
| Zeev Suraski <zeev@php.net> |
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
+----------------------------------------------------------------------+
*/
#include "zend.h"
#include "zend_API.h"
#include "zend_compile.h"
#include "zend_execute.h"
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
#include "zend_inheritance.h"
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
#include "zend_interfaces.h"
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
#include "zend_smart_str.h"
Fixed bug #74269: Strict comparison of initial trait property values
2017-04-11 04:04:18 +08:00
#include "zend_operators.h"
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
#include "zend_exceptions.h"
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
static void add_dependency_obligation(zend_class_entry *ce, zend_class_entry *dependency_ce);
static void add_compatibility_obligation(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
zend_class_entry *ce, const zend_function *child_fn, zend_class_entry *child_scope,
const zend_function *parent_fn, zend_class_entry *parent_scope);
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
static void add_property_compatibility_obligation(
zend_class_entry *ce, const zend_property_info *child_prop,
const zend_property_info *parent_prop);
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
static void zend_type_copy_ctor(zend_type *type, zend_bool persistent) {
if (ZEND_TYPE_HAS_LIST(*type)) {
zend_type_list *old_list = ZEND_TYPE_LIST(*type);
size_t size = ZEND_TYPE_LIST_SIZE(old_list->num_types);
zend_type_list *new_list = ZEND_TYPE_USES_ARENA(*type)
? zend_arena_alloc(&CG(arena), size) : pemalloc(size, persistent);
memcpy(new_list, old_list, ZEND_TYPE_LIST_SIZE(old_list->num_types));
ZEND_TYPE_SET_PTR(*type, new_list);
Use zend_type inside type lists Instead of having a completely independent encoding for type list entries. This is going to use more memory, but I'm not particularly concerned about that, as type unions that contain multiple classes should be uncommon. On the other hand, this allows us to treat top-level types and types inside lists mostly the same. A new ZEND_TYPE_FOREACH macros allows to transparently treat list and non-list types the same way. I'm not using it everywhere it could be used for now, just the places that seemed most obvious. Of course, this will make any future type system changes much simpler, as it will not be necessary to duplicate all logic two times.
2020-01-17 00:04:11 +08:00
zend_type *list_type;
ZEND_TYPE_LIST_FOREACH(new_list, list_type) {
ZEND_ASSERT(ZEND_TYPE_HAS_NAME(*list_type));
zend_string_addref(ZEND_TYPE_NAME(*list_type));
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
} ZEND_TYPE_LIST_FOREACH_END();
} else if (ZEND_TYPE_HAS_NAME(*type)) {
zend_string_addref(ZEND_TYPE_NAME(*type));
}
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
static zend_property_info *zend_duplicate_property_info_internal(zend_property_info *property_info) /* {{{ */
{
zend_property_info* new_property_info = pemalloc(sizeof(zend_property_info), 1);
memcpy(new_property_info, property_info, sizeof(zend_property_info));
zend_string_addref(new_property_info->name);
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
zend_type_copy_ctor(&new_property_info->type, /* persistent */ 1);
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
return new_property_info;
}
/* }}} */
Inline hot path
2019-06-27 16:27:53 +08:00
static zend_function *zend_duplicate_internal_function(zend_function *func, zend_class_entry *ce) /* {{{ */
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
{
zend_function *new_function;
Inline hot path
2019-06-27 16:27:53 +08:00
if (UNEXPECTED(ce->type & ZEND_INTERNAL_CLASS)) {
new_function = pemalloc(sizeof(zend_internal_function), 1);
memcpy(new_function, func, sizeof(zend_internal_function));
} else {
new_function = zend_arena_alloc(&CG(arena), sizeof(zend_internal_function));
memcpy(new_function, func, sizeof(zend_internal_function));
new_function->common.fn_flags |= ZEND_ACC_ARENA_ALLOCATED;
}
if (EXPECTED(new_function->common.function_name)) {
zend_string_addref(new_function->common.function_name);
}
return new_function;
}
/* }}} */
static zend_function *zend_duplicate_user_function(zend_function *func) /* {{{ */
{
zend_function *new_function;
new_function = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
memcpy(new_function, func, sizeof(zend_op_array));
Fixed bug #79548 When duplicating user functions with static variables, make sure that we init a new map ptr slot for the static variables.
2020-05-04 22:27:45 +08:00
if (CG(compiler_options) & ZEND_COMPILE_PRELOAD) {
ZEND_ASSERT(new_function->op_array.fn_flags & ZEND_ACC_PRELOADED);
ZEND_MAP_PTR_NEW(new_function->op_array.static_variables_ptr);
} else {
ZEND_MAP_PTR_INIT(new_function->op_array.static_variables_ptr, &new_function->op_array.static_variables);
}
Fix static variable in methods inheritance during preloading This is now "bug compatible" with the normal behavior, and more imporantly, does not crash :)
2020-11-04 22:33:11 +08:00
HashTable *static_properties_ptr = ZEND_MAP_PTR_GET(func->op_array.static_variables_ptr);
if (static_properties_ptr) {
/* See: Zend/tests/method_static_var.phpt */
ZEND_MAP_PTR_SET(new_function->op_array.static_variables_ptr, static_properties_ptr);
GC_TRY_ADDREF(static_properties_ptr);
} else {
GC_TRY_ADDREF(new_function->op_array.static_variables);
}
Inline hot path
2019-06-27 16:27:53 +08:00
return new_function;
}
/* }}} */
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
static zend_always_inline zend_function *zend_duplicate_function(zend_function *func, zend_class_entry *ce, zend_bool is_interface) /* {{{ */
Inline hot path
2019-06-27 16:27:53 +08:00
{
Make fast path linear
2015-03-06 22:07:36 +08:00
if (UNEXPECTED(func->type == ZEND_INTERNAL_FUNCTION)) {
Inline hot path
2019-06-27 16:27:53 +08:00
return zend_duplicate_internal_function(func, ce);
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
} else {
if (func->op_array.refcount) {
(*func->op_array.refcount)++;
}
Store aliased name of trait method Currently, trait methods are aliased will continue to use the original function name. In a few places in the codebase, we will try to look up the actual method name instead. However, this does not work if an aliased method is used indirectly (https://bugs.php.net/bug.php?id=69180). I think it would be better to instead actually change the method name to the alias. This is in principle easy: We have to allow function_name to be changed even if op array is otherwise shared (similar to static_variables). This means we need to addref/release the function_name separately, but I don't think there is a performance concern here (especially as everything is usually interned). There is a bit of complication in opcache, where we need to make sure that the function name is released the correct number of times (interning may overwrite the name in the original op_array, but we need to release it as many times as the op_array is shared). Fixes bug #69180. Fixes bug #74939. Closes GH-5226.
2020-03-02 18:07:57 +08:00
if (EXPECTED(func->op_array.function_name)) {
zend_string_addref(func->op_array.function_name);
}
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
if (is_interface
Addref static vars when not copying private method While we don't need to give this method separate static vars, we do still need to perform an addref, as there will be a corresponding delref in the dtor.
2019-08-29 20:33:31 +08:00
|| EXPECTED(!func->op_array.static_variables)) {
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
/* reuse the same op_array structure */
return func;
}
Inline hot path
2019-06-27 16:27:53 +08:00
return zend_duplicate_user_function(func);
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
}
}
/* }}} */
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
static void do_inherit_parent_constructor(zend_class_entry *ce) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
zend_class_entry *parent = ce->parent;
ZEND_ASSERT(parent != NULL);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* You cannot change create_object */
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->create_object = parent->create_object;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* Inherit special functions if needed */
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->get_iterator)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->get_iterator = parent->get_iterator;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->__get)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->__get = parent->__get;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->__set)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->__set = parent->__set;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->__unset)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->__unset = parent->__unset;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->__isset)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->__isset = parent->__isset;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->__call)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->__call = parent->__call;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->__callstatic)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->__callstatic = parent->__callstatic;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->__tostring)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->__tostring = parent->__tostring;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->clone)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->clone = parent->clone;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Cache __unserialize() instead of unserialize() We should use these cache slots for the new object serialization mechanism rather than the old one.
2020-06-26 16:54:40 +08:00
if (EXPECTED(!ce->__serialize)) {
ce->__serialize = parent->__serialize;
}
if (EXPECTED(!ce->__unserialize)) {
ce->__unserialize = parent->__unserialize;
Assign (un)serialize_func during compilation This avoids writing this cache at runtime, which is illegal if preloading is used. Not every serialize/unserialize function actually belongs to the Serializable interface, but I think it's not a problem to assign these anyway -- whether they are used ultimately depends on whether Serializable is implemented. Alternatively it might make sense to just drop these entirely. I don't think this is performance critical functionality.
2019-02-15 18:20:28 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->serialize)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->serialize = parent->serialize;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->unserialize)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->unserialize = parent->unserialize;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
if (!ce->destructor) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->destructor = parent->destructor;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->__debugInfo)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->__debugInfo = parent->__debugInfo;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if (ce->constructor) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
if (parent->constructor && UNEXPECTED(parent->constructor->common.fn_flags & ZEND_ACC_FINAL)) {
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
zend_error_noreturn(E_ERROR, "Cannot override final %s::%s() with %s::%s()",
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ZSTR_VAL(parent->name), ZSTR_VAL(parent->constructor->common.function_name),
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
ZSTR_VAL(ce->name), ZSTR_VAL(ce->constructor->common.function_name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
return;
}
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->constructor = parent->constructor;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
char *zend_visibility_string(uint32_t fn_flags) /* {{{ */
{
if (fn_flags & ZEND_ACC_PUBLIC) {
return "public";
Squashed commit of the following: commit 2d3cac9e005d6bef9aa73ab57cc674aa53125954 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 11:54:47 2018 +0300 Fixed static property access commit 31786ee27282f319f3ef2a07635b1f325cbd67c6 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 11:05:29 2018 +0300 Avoid duplicate checks commit 5ae502b979ea33d058d01a9421eec5afd0084e8d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 10:39:17 2018 +0300 Optimization commit 82c17f0e8af02c9cf7d1bbdae4e3158330148203 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 09:26:50 2018 +0300 Removed unused zend_duplicate_property_info() commit ba53d1d0dd91d5530328a11cac93ff9e75c462b5 Merge: eacc11b8fd c4b14370cf Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 09:24:13 2018 +0300 Merge branch 'master' into shadow * master: 7.0.33 next Sync NEWS [ci skip] add NEWS for 76582 Enforce ordering of property compare in object comparisons Fixed wrong assertion Skip test on unsuitable env commit eacc11b8fdeb002ee6a149defd8b5a8c3412896a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Sep 10 13:12:39 2018 +0300 Fixed failure of ext/spl/tests/array_017.phpt commit 62d1871430a1b81c84b790460afff0682648689a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Sep 10 11:55:07 2018 +0300 Fixed issues commit 1d37e3a40e4d07c4b933ed6f9d2e649dd01180f0 Merge: d6c3f098b6 1e550e6f7e Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Sep 10 10:21:20 2018 +0300 Merge branch 'master' into shadow * master: Update NEWS Fix for bug #76582 Fix ssl stream reneg limit test to print only after first renegotiation Make a copy unconditionally Fix memory leak in pcre cache Remove not needed checking for <errno.h> Remove HAVE_ASSERT_H Add test for bug #76850 Fixed bug #76850 Exit code mangled by set locale/preg_match Remove empty PHP tags from test Fix #75273: php_zlib_inflate_filter() may not update bytes_consumed Fix PCRE2 exclusion and remove dead libs in Makefile.gcov Report mem leaks to stderr if no Win debugger is present Use combined assignment contanation operator Fixed bug #76796 Support fixed address mmap without replacement commit d6c3f098b6015e76d042691de0af2e1426c66829 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Sep 7 13:56:30 2018 +0300 Get rid of ZEND_ACC_SHADOW
2018-09-11 16:56:45 +08:00
} else if (fn_flags & ZEND_ACC_PRIVATE) {
return "private";
} else {
ZEND_ASSERT(fn_flags & ZEND_ACC_PROTECTED);
return "protected";
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
/* }}} */
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
static zend_string *resolve_class_name(zend_class_entry *scope, zend_string *name) {
ZEND_ASSERT(scope);
if (zend_string_equals_literal_ci(name, "parent") && scope->parent) {
if (scope->ce_flags & ZEND_ACC_RESOLVED_PARENT) {
return scope->parent->name;
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
} else {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
return scope->parent_name;
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
}
Refactor inheritance type check implementation Extract the self/parent name resolution code and drop unnecessary string copies/releases. Store the fe/proto types in local variables.
2019-05-08 18:11:12 +08:00
} else if (zend_string_equals_literal_ci(name, "self")) {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
return scope->name;
Refactor inheritance type check implementation Extract the self/parent name resolution code and drop unnecessary string copies/releases. Store the fe/proto types in local variables.
2019-05-08 18:11:12 +08:00
} else {
return name;
Covariance on inheriting classes with iterable
2016-06-04 22:44:49 +08:00
}
}
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
static zend_bool class_visible(zend_class_entry *ce) {
if (ce->type == ZEND_INTERNAL_CLASS) {
return !(CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES);
} else {
ZEND_ASSERT(ce->type == ZEND_USER_CLASS);
return !(CG(compiler_options) & ZEND_COMPILE_IGNORE_OTHER_FILES)
|| ce->info.user.filename == CG(compiled_filename);
}
}
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
static zend_class_entry *lookup_class(
zend_class_entry *scope, zend_string *name, zend_bool register_unresolved) {
Allow unlinked classes when performing in_compilation variance check As preloading runs in in_compilation mode, we also need to allow use of unlinked classes in lookup_class().
2020-11-03 21:49:10 +08:00
uint32_t flags = ZEND_FETCH_CLASS_ALLOW_UNLINKED | ZEND_FETCH_CLASS_NO_AUTOLOAD;
zend_class_entry *ce = zend_lookup_class_ex(name, NULL, flags);
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
if (!CG(in_compilation)) {
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
if (ce) {
return ce;
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
if (register_unresolved) {
/* We'll autoload this class and process delayed variance obligations later. */
if (!CG(delayed_autoloads)) {
ALLOC_HASHTABLE(CG(delayed_autoloads));
zend_hash_init(CG(delayed_autoloads), 0, NULL, NULL, 0);
}
zend_hash_add_empty_element(CG(delayed_autoloads), name);
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
}
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
} else {
if (ce && class_visible(ce)) {
return ce;
}
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
/* The current class may not be registered yet, so check for it explicitly. */
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
if (zend_string_equals_ci(scope->name, name)) {
return scope;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
}
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
}
return NULL;
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
/* Instanceof that's safe to use on unlinked classes. */
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
static zend_bool unlinked_instanceof(zend_class_entry *ce1, zend_class_entry *ce2) {
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
if (ce1 == ce2) {
return 1;
}
Remove recursive check from instanceof_interface Parent interfaces are copied into the interface list during inheritance, so there's no need to perform a recursive check. Only exception are instanceof checks performed during inheritance itself. However, we already have unlinked_instanceof for this purpose, it just needs to be taught to handle this case. Closes GH-4857.
2019-10-25 00:11:41 +08:00
if (ce1->ce_flags & ZEND_ACC_LINKED) {
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
return instanceof_function(ce1, ce2);
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
Fix bug #80126 When performing an unlinked instanceof, we also need to consider interfaces of parent classes, as they may not have been inherited yet.
2020-10-06 22:30:58 +08:00
if (ce1->parent) {
zend_class_entry *parent_ce;
if (ce1->ce_flags & ZEND_ACC_RESOLVED_PARENT) {
parent_ce = ce1->parent;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
} else {
Fix bug #80126 When performing an unlinked instanceof, we also need to consider interfaces of parent classes, as they may not have been inherited yet.
2020-10-06 22:30:58 +08:00
parent_ce = zend_lookup_class_ex(ce1->parent_name, NULL,
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
ZEND_FETCH_CLASS_ALLOW_UNLINKED | ZEND_FETCH_CLASS_NO_AUTOLOAD);
}
Fix bug #80126 When performing an unlinked instanceof, we also need to consider interfaces of parent classes, as they may not have been inherited yet.
2020-10-06 22:30:58 +08:00
/* It's not sufficient to only check the parent chain itself, as need to do a full
* recursive instanceof in case the parent interfaces haven't been copied yet. */
if (parent_ce && unlinked_instanceof(parent_ce, ce2)) {
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
return 1;
}
}
if (ce1->num_interfaces) {
uint32_t i;
Remove recursive check from instanceof_interface Parent interfaces are copied into the interface list during inheritance, so there's no need to perform a recursive check. Only exception are instanceof checks performed during inheritance itself. However, we already have unlinked_instanceof for this purpose, it just needs to be taught to handle this case. Closes GH-4857.
2019-10-25 00:11:41 +08:00
if (ce1->ce_flags & ZEND_ACC_RESOLVED_INTERFACES) {
/* Unlike the normal instanceof_function(), we have to perform a recursive
* check here, as the parent interfaces might not have been fully copied yet. */
for (i = 0; i < ce1->num_interfaces; i++) {
if (unlinked_instanceof(ce1->interfaces[i], ce2)) {
return 1;
}
}
} else {
for (i = 0; i < ce1->num_interfaces; i++) {
Fix bug #80126 When performing an unlinked instanceof, we also need to consider interfaces of parent classes, as they may not have been inherited yet.
2020-10-06 22:30:58 +08:00
zend_class_entry *ce = zend_lookup_class_ex(
Remove recursive check from instanceof_interface Parent interfaces are copied into the interface list during inheritance, so there's no need to perform a recursive check. Only exception are instanceof checks performed during inheritance itself. However, we already have unlinked_instanceof for this purpose, it just needs to be taught to handle this case. Closes GH-4857.
2019-10-25 00:11:41 +08:00
ce1->interface_names[i].name, ce1->interface_names[i].lc_name,
ZEND_FETCH_CLASS_ALLOW_UNLINKED | ZEND_FETCH_CLASS_NO_AUTOLOAD);
if (ce && unlinked_instanceof(ce, ce2)) {
return 1;
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
}
}
}
return 0;
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
}
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
static zend_bool zend_type_contains_traversable(zend_type type) {
Use zend_type inside type lists Instead of having a completely independent encoding for type list entries. This is going to use more memory, but I'm not particularly concerned about that, as type unions that contain multiple classes should be uncommon. On the other hand, this allows us to treat top-level types and types inside lists mostly the same. A new ZEND_TYPE_FOREACH macros allows to transparently treat list and non-list types the same way. I'm not using it everywhere it could be used for now, just the places that seemed most obvious. Of course, this will make any future type system changes much simpler, as it will not be necessary to duplicate all logic two times.
2020-01-17 00:04:11 +08:00
zend_type *single_type;
Fixed bug #80391 Iterable was not considered a subtype of array|object, and thus also not a subtype of mixed.
2020-11-24 17:09:28 +08:00
if (ZEND_TYPE_FULL_MASK(type) & MAY_BE_OBJECT) {
return 1;
}
Use zend_type inside type lists Instead of having a completely independent encoding for type list entries. This is going to use more memory, but I'm not particularly concerned about that, as type unions that contain multiple classes should be uncommon. On the other hand, this allows us to treat top-level types and types inside lists mostly the same. A new ZEND_TYPE_FOREACH macros allows to transparently treat list and non-list types the same way. I'm not using it everywhere it could be used for now, just the places that seemed most obvious. Of course, this will make any future type system changes much simpler, as it will not be necessary to duplicate all logic two times.
2020-01-17 00:04:11 +08:00
ZEND_TYPE_FOREACH(type, single_type) {
if (ZEND_TYPE_HAS_NAME(*single_type)
&& zend_string_equals_literal_ci(ZEND_TYPE_NAME(*single_type), "Traversable")) {
return 1;
}
} ZEND_TYPE_FOREACH_END();
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
return 0;
}
Add static return type RFC: https://wiki.php.net/rfc/static_return_type The "static" type is represented as MAY_BE_STATIC, rather than a class type like "self" and "parent", as it has special resolution semantics, and cannot be cached in the runtime cache. Closes GH-5062.
2020-01-07 22:06:36 +08:00
static zend_bool zend_type_permits_self(
zend_type type, zend_class_entry *scope, zend_class_entry *self) {
if (ZEND_TYPE_FULL_MASK(type) & MAY_BE_OBJECT) {
return 1;
}
/* Any types that may satisfy self must have already been loaded at this point
* (as a parent or interface), so we never need to register delayed variance obligations
* for this case. */
zend_type *single_type;
ZEND_TYPE_FOREACH(type, single_type) {
if (ZEND_TYPE_HAS_NAME(*single_type)) {
zend_string *name = resolve_class_name(scope, ZEND_TYPE_NAME(*single_type));
zend_class_entry *ce = lookup_class(self, name, /* register_unresolved */ 0);
if (ce && unlinked_instanceof(self, ce)) {
return 1;
}
}
} ZEND_TYPE_FOREACH_END();
return 0;
}
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
/* Unresolved means that class declarations that are currently not available are needed to
* determine whether the inheritance is valid or not. At runtime UNRESOLVED should be treated
* as an ERROR. */
typedef enum {
INHERITANCE_UNRESOLVED = -1,
INHERITANCE_ERROR = 0,
INHERITANCE_SUCCESS = 1,
} inheritance_status;
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
static inheritance_status zend_perform_covariant_class_type_check(
Fix variance checks on resolved union types This is a bit annoying: When preloading is used, types might be resolved during inheritance checks, so we need to deal with CE types rather than just NAME types everywhere.
2020-11-03 21:15:05 +08:00
zend_class_entry *fe_scope, zend_string *fe_class_name, zend_class_entry *fe_ce,
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
zend_class_entry *proto_scope, zend_type proto_type,
zend_bool register_unresolved) {
zend_bool have_unresolved = 0;
if (ZEND_TYPE_FULL_MASK(proto_type) & MAY_BE_OBJECT) {
/* Currently, any class name would be allowed here. We still perform a class lookup
* for forward-compatibility reasons, as we may have named types in the future that
* are not classes (such as enums or typedefs). */
if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name, register_unresolved);
if (!fe_ce) {
have_unresolved = 1;
} else {
return INHERITANCE_SUCCESS;
}
Deduplicate inheritance type check implementation Make the check covariant (insofar as it is allowed now, i.e. nullability and iterable) and call it with appropriate argument order for both parameter and return types. This makes it simpler to extend to full variance support.
2019-05-08 17:24:08 +08:00
}
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
if (ZEND_TYPE_FULL_MASK(proto_type) & MAY_BE_ITERABLE) {
if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name, register_unresolved);
if (!fe_ce) {
have_unresolved = 1;
} else if (unlinked_instanceof(fe_ce, zend_ce_traversable)) {
return INHERITANCE_SUCCESS;
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
}
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
}
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
Use zend_type inside type lists Instead of having a completely independent encoding for type list entries. This is going to use more memory, but I'm not particularly concerned about that, as type unions that contain multiple classes should be uncommon. On the other hand, this allows us to treat top-level types and types inside lists mostly the same. A new ZEND_TYPE_FOREACH macros allows to transparently treat list and non-list types the same way. I'm not using it everywhere it could be used for now, just the places that seemed most obvious. Of course, this will make any future type system changes much simpler, as it will not be necessary to duplicate all logic two times.
2020-01-17 00:04:11 +08:00
zend_type *single_type;
ZEND_TYPE_FOREACH(proto_type, single_type) {
Fix variance checks on resolved union types This is a bit annoying: When preloading is used, types might be resolved during inheritance checks, so we need to deal with CE types rather than just NAME types everywhere.
2020-11-03 21:15:05 +08:00
zend_class_entry *proto_ce;
Use zend_type inside type lists Instead of having a completely independent encoding for type list entries. This is going to use more memory, but I'm not particularly concerned about that, as type unions that contain multiple classes should be uncommon. On the other hand, this allows us to treat top-level types and types inside lists mostly the same. A new ZEND_TYPE_FOREACH macros allows to transparently treat list and non-list types the same way. I'm not using it everywhere it could be used for now, just the places that seemed most obvious. Of course, this will make any future type system changes much simpler, as it will not be necessary to duplicate all logic two times.
2020-01-17 00:04:11 +08:00
if (ZEND_TYPE_HAS_NAME(*single_type)) {
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
zend_string *proto_class_name =
Use zend_type inside type lists Instead of having a completely independent encoding for type list entries. This is going to use more memory, but I'm not particularly concerned about that, as type unions that contain multiple classes should be uncommon. On the other hand, this allows us to treat top-level types and types inside lists mostly the same. A new ZEND_TYPE_FOREACH macros allows to transparently treat list and non-list types the same way. I'm not using it everywhere it could be used for now, just the places that seemed most obvious. Of course, this will make any future type system changes much simpler, as it will not be necessary to duplicate all logic two times.
2020-01-17 00:04:11 +08:00
resolve_class_name(proto_scope, ZEND_TYPE_NAME(*single_type));
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
if (zend_string_equals_ci(fe_class_name, proto_class_name)) {
return INHERITANCE_SUCCESS;
}
Refactor inheritance type check implementation Extract the self/parent name resolution code and drop unnecessary string copies/releases. Store the fe/proto types in local variables.
2019-05-08 18:11:12 +08:00
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name, register_unresolved);
Fix variance checks on resolved union types This is a bit annoying: When preloading is used, types might be resolved during inheritance checks, so we need to deal with CE types rather than just NAME types everywhere.
2020-11-03 21:15:05 +08:00
proto_ce =
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
lookup_class(proto_scope, proto_class_name, register_unresolved);
Fix variance checks on resolved union types This is a bit annoying: When preloading is used, types might be resolved during inheritance checks, so we need to deal with CE types rather than just NAME types everywhere.
2020-11-03 21:15:05 +08:00
} else if (ZEND_TYPE_HAS_CE(*single_type)) {
if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name, register_unresolved);
proto_ce = ZEND_TYPE_CE(*single_type);
} else {
continue;
}
if (!fe_ce || !proto_ce) {
have_unresolved = 1;
} else if (unlinked_instanceof(fe_ce, proto_ce)) {
return INHERITANCE_SUCCESS;
Use zend_type inside type lists Instead of having a completely independent encoding for type list entries. This is going to use more memory, but I'm not particularly concerned about that, as type unions that contain multiple classes should be uncommon. On the other hand, this allows us to treat top-level types and types inside lists mostly the same. A new ZEND_TYPE_FOREACH macros allows to transparently treat list and non-list types the same way. I'm not using it everywhere it could be used for now, just the places that seemed most obvious. Of course, this will make any future type system changes much simpler, as it will not be necessary to duplicate all logic two times.
2020-01-17 00:04:11 +08:00
}
} ZEND_TYPE_FOREACH_END();
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
return have_unresolved ? INHERITANCE_UNRESOLVED : INHERITANCE_ERROR;
}
static inheritance_status zend_perform_covariant_type_check(
zend_class_entry *fe_scope, zend_type fe_type,
zend_class_entry *proto_scope, zend_type proto_type) /* {{{ */
{
ZEND_ASSERT(ZEND_TYPE_IS_SET(fe_type) && ZEND_TYPE_IS_SET(proto_type));
/* Builtin types may be removed, but not added */
uint32_t fe_type_mask = ZEND_TYPE_PURE_MASK(fe_type);
uint32_t proto_type_mask = ZEND_TYPE_PURE_MASK(proto_type);
uint32_t added_types = fe_type_mask & ~proto_type_mask;
if (added_types) {
// TODO: Make "iterable" an alias of "array|Traversable" instead,
// so these special cases will be handled automatically.
Add static return type RFC: https://wiki.php.net/rfc/static_return_type The "static" type is represented as MAY_BE_STATIC, rather than a class type like "self" and "parent", as it has special resolution semantics, and cannot be cached in the runtime cache. Closes GH-5062.
2020-01-07 22:06:36 +08:00
if ((added_types & MAY_BE_ITERABLE)
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
&& (proto_type_mask & MAY_BE_ARRAY)
&& zend_type_contains_traversable(proto_type)) {
/* Replacing array|Traversable with iterable is okay */
Add static return type RFC: https://wiki.php.net/rfc/static_return_type The "static" type is represented as MAY_BE_STATIC, rather than a class type like "self" and "parent", as it has special resolution semantics, and cannot be cached in the runtime cache. Closes GH-5062.
2020-01-07 22:06:36 +08:00
added_types &= ~MAY_BE_ITERABLE;
}
if ((added_types & MAY_BE_ARRAY) && (proto_type_mask & MAY_BE_ITERABLE)) {
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
/* Replacing iterable with array is okay */
Add static return type RFC: https://wiki.php.net/rfc/static_return_type The "static" type is represented as MAY_BE_STATIC, rather than a class type like "self" and "parent", as it has special resolution semantics, and cannot be cached in the runtime cache. Closes GH-5062.
2020-01-07 22:06:36 +08:00
added_types &= ~MAY_BE_ARRAY;
}
if ((added_types & MAY_BE_STATIC)
&& zend_type_permits_self(proto_type, proto_scope, fe_scope)) {
/* Replacing type that accepts self with static is okay */
added_types &= ~MAY_BE_STATIC;
}
if (added_types) {
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
/* Otherwise adding new types is illegal */
return INHERITANCE_ERROR;
}
}
Fix variance checks on resolved union types This is a bit annoying: When preloading is used, types might be resolved during inheritance checks, so we need to deal with CE types rather than just NAME types everywhere.
2020-11-03 21:15:05 +08:00
zend_type *single_type;
zend_bool all_success = 1;
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
Fix variance checks on resolved union types This is a bit annoying: When preloading is used, types might be resolved during inheritance checks, so we need to deal with CE types rather than just NAME types everywhere.
2020-11-03 21:15:05 +08:00
/* First try to check whether we can succeed without resolving anything */
ZEND_TYPE_FOREACH(fe_type, single_type) {
inheritance_status status;
if (ZEND_TYPE_HAS_NAME(*single_type)) {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
zend_string *fe_class_name =
Fix variance checks on resolved union types This is a bit annoying: When preloading is used, types might be resolved during inheritance checks, so we need to deal with CE types rather than just NAME types everywhere.
2020-11-03 21:15:05 +08:00
resolve_class_name(fe_scope, ZEND_TYPE_NAME(*single_type));
status = zend_perform_covariant_class_type_check(
fe_scope, fe_class_name, NULL,
proto_scope, proto_type, /* register_unresolved */ 0);
} else if (ZEND_TYPE_HAS_CE(*single_type)) {
zend_class_entry *fe_ce = ZEND_TYPE_CE(*single_type);
status = zend_perform_covariant_class_type_check(
fe_scope, fe_ce->name, fe_ce,
proto_scope, proto_type, /* register_unresolved */ 0);
} else {
continue;
}
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
Fix variance checks on resolved union types This is a bit annoying: When preloading is used, types might be resolved during inheritance checks, so we need to deal with CE types rather than just NAME types everywhere.
2020-11-03 21:15:05 +08:00
if (status == INHERITANCE_ERROR) {
return INHERITANCE_ERROR;
Deduplicate inheritance type check implementation Make the check covariant (insofar as it is allowed now, i.e. nullability and iterable) and call it with appropriate argument order for both parameter and return types. This makes it simpler to extend to full variance support.
2019-05-08 17:24:08 +08:00
}
Fix variance checks on resolved union types This is a bit annoying: When preloading is used, types might be resolved during inheritance checks, so we need to deal with CE types rather than just NAME types everywhere.
2020-11-03 21:15:05 +08:00
if (status != INHERITANCE_SUCCESS) {
all_success = 0;
}
} ZEND_TYPE_FOREACH_END();
Deduplicate inheritance type check implementation Make the check covariant (insofar as it is allowed now, i.e. nullability and iterable) and call it with appropriate argument order for both parameter and return types. This makes it simpler to extend to full variance support.
2019-05-08 17:24:08 +08:00
Fix variance checks on resolved union types This is a bit annoying: When preloading is used, types might be resolved during inheritance checks, so we need to deal with CE types rather than just NAME types everywhere.
2020-11-03 21:15:05 +08:00
/* All individual checks succeeded, overall success */
if (all_success) {
return INHERITANCE_SUCCESS;
work on #71428
2016-03-28 18:54:25 +08:00
}
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
Fix variance checks on resolved union types This is a bit annoying: When preloading is used, types might be resolved during inheritance checks, so we need to deal with CE types rather than just NAME types everywhere.
2020-11-03 21:15:05 +08:00
/* Register all classes that may have to be resolved */
ZEND_TYPE_FOREACH(fe_type, single_type) {
if (ZEND_TYPE_HAS_NAME(*single_type)) {
zend_string *fe_class_name =
resolve_class_name(fe_scope, ZEND_TYPE_NAME(*single_type));
zend_perform_covariant_class_type_check(
fe_scope, fe_class_name, NULL,
proto_scope, proto_type, /* register_unresolved */ 1);
} else if (ZEND_TYPE_HAS_CE(*single_type)) {
zend_class_entry *fe_ce = ZEND_TYPE_CE(*single_type);
zend_perform_covariant_class_type_check(
fe_scope, fe_ce->name, fe_ce,
proto_scope, proto_type, /* register_unresolved */ 1);
}
} ZEND_TYPE_FOREACH_END();
return INHERITANCE_UNRESOLVED;
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
}
/* }}} */
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
static inheritance_status zend_do_perform_arg_type_hint_check(
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
zend_class_entry *fe_scope, zend_arg_info *fe_arg_info,
zend_class_entry *proto_scope, zend_arg_info *proto_arg_info) /* {{{ */
Implement Parameter Type Widening RFC
2017-01-01 22:53:24 +08:00
{
Add support for the mixed type RFC: https://wiki.php.net/rfc/mixed_type_v2 Closes GH-5313 Co-authored-by: Dan Ackroyd <danack@basereality.com>
2020-03-28 06:39:49 +08:00
if (!ZEND_TYPE_IS_SET(fe_arg_info->type) || ZEND_TYPE_PURE_MASK(fe_arg_info->type) == MAY_BE_ANY) {
/* Child with no type or mixed type is always compatible */
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
return INHERITANCE_SUCCESS;
Implement Parameter Type Widening RFC
2017-01-01 22:53:24 +08:00
}
if (!ZEND_TYPE_IS_SET(proto_arg_info->type)) {
/* Child defines a type, but parent doesn't, violates LSP */
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
return INHERITANCE_ERROR;
Implement Parameter Type Widening RFC
2017-01-01 22:53:24 +08:00
}
Deduplicate inheritance type check implementation Make the check covariant (insofar as it is allowed now, i.e. nullability and iterable) and call it with appropriate argument order for both parameter and return types. This makes it simpler to extend to full variance support.
2019-05-08 17:24:08 +08:00
/* Contravariant type check is performed as a covariant type check with swapped
* argument order. */
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
return zend_perform_covariant_type_check(
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
proto_scope, proto_arg_info->type, fe_scope, fe_arg_info->type);
Implement Parameter Type Widening RFC
2017-01-01 22:53:24 +08:00
}
/* }}} */
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
/* For trait methods, fe_scope/proto_scope may differ from fe/proto->common.scope,
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
* as self will refer to the self of the class the trait is used in, not the trait
* the method was declared in. */
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
static inheritance_status zend_do_perform_implementation_check(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
const zend_function *fe, zend_class_entry *fe_scope,
const zend_function *proto, zend_class_entry *proto_scope) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Allow variadic arguments to replace non-variadic ones Any number of arguments can be replaced by a variadic one, so long as the variadic argument is compatible (in the sense of contravariance) with the subsumed arguments. In particular this means that function(...$args) becomes a near-universal signature: It is compatible with any function signature that does not accept parameters by-reference. This also fixes bug #70839, which describes a special case. Closes GH-5059.
2020-01-06 19:06:51 +08:00
uint32_t i, num_args, proto_num_args, fe_num_args;
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
inheritance_status status, local_status;
Allow variadic arguments to replace non-variadic ones Any number of arguments can be replaced by a variadic one, so long as the variadic argument is compatible (in the sense of contravariance) with the subsumed arguments. In particular this means that function(...$args) becomes a near-universal signature: It is compatible with any function signature that does not accept parameters by-reference. This also fixes bug #70839, which describes a special case. Closes GH-5059.
2020-01-06 19:06:51 +08:00
zend_bool proto_is_variadic, fe_is_variadic;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* Checks for constructors only if they are declared in an interface,
* or explicitly marked as abstract
*/
Replace previosly checked conditions by ZEND_ASSERT()
2019-06-25 23:26:56 +08:00
ZEND_ASSERT(!((fe->common.fn_flags & ZEND_ACC_CTOR)
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
&& ((proto->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0
Replace previosly checked conditions by ZEND_ASSERT()
2019-06-25 23:26:56 +08:00
&& (proto->common.fn_flags & ZEND_ACC_ABSTRACT) == 0)));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
/* If the prototype method is private and not abstract, we do not enforce a signature.
* private abstract methods can only occur in traits. */
ZEND_ASSERT(!(proto->common.fn_flags & ZEND_ACC_PRIVATE)
|| (proto->common.fn_flags & ZEND_ACC_ABSTRACT));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Allow variadic arguments to replace non-variadic ones Any number of arguments can be replaced by a variadic one, so long as the variadic argument is compatible (in the sense of contravariance) with the subsumed arguments. In particular this means that function(...$args) becomes a near-universal signature: It is compatible with any function signature that does not accept parameters by-reference. This also fixes bug #70839, which describes a special case. Closes GH-5059.
2020-01-06 19:06:51 +08:00
/* The number of required arguments cannot increase. */
if (proto->common.required_num_args < fe->common.required_num_args) {
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
return INHERITANCE_ERROR;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* by-ref constraints on return values are covariant */
if ((proto->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
&& !(fe->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
return INHERITANCE_ERROR;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Allow variadic arguments to replace non-variadic ones Any number of arguments can be replaced by a variadic one, so long as the variadic argument is compatible (in the sense of contravariance) with the subsumed arguments. In particular this means that function(...$args) becomes a near-universal signature: It is compatible with any function signature that does not accept parameters by-reference. This also fixes bug #70839, which describes a special case. Closes GH-5059.
2020-01-06 19:06:51 +08:00
proto_is_variadic = (proto->common.fn_flags & ZEND_ACC_VARIADIC) != 0;
fe_is_variadic = (fe->common.fn_flags & ZEND_ACC_VARIADIC) != 0;
/* A variadic function cannot become non-variadic */
if (proto_is_variadic && !fe_is_variadic) {
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
return INHERITANCE_ERROR;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Allow variadic arguments to replace non-variadic ones Any number of arguments can be replaced by a variadic one, so long as the variadic argument is compatible (in the sense of contravariance) with the subsumed arguments. In particular this means that function(...$args) becomes a near-universal signature: It is compatible with any function signature that does not accept parameters by-reference. This also fixes bug #70839, which describes a special case. Closes GH-5059.
2020-01-06 19:06:51 +08:00
/* The variadic argument is not included in the stored argument count. */
proto_num_args = proto->common.num_args + proto_is_variadic;
fe_num_args = fe->common.num_args + fe_is_variadic;
num_args = MAX(proto_num_args, fe_num_args);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
status = INHERITANCE_SUCCESS;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
for (i = 0; i < num_args; i++) {
Allow variadic arguments to replace non-variadic ones Any number of arguments can be replaced by a variadic one, so long as the variadic argument is compatible (in the sense of contravariance) with the subsumed arguments. In particular this means that function(...$args) becomes a near-universal signature: It is compatible with any function signature that does not accept parameters by-reference. This also fixes bug #70839, which describes a special case. Closes GH-5059.
2020-01-06 19:06:51 +08:00
zend_arg_info *proto_arg_info =
i < proto_num_args ? &proto->common.arg_info[i] :
proto_is_variadic ? &proto->common.arg_info[proto_num_args - 1] : NULL;
zend_arg_info *fe_arg_info =
i < fe_num_args ? &fe->common.arg_info[i] :
fe_is_variadic ? &fe->common.arg_info[fe_num_args - 1] : NULL;
if (!proto_arg_info) {
/* A new (optional) argument has been added, which is fine. */
continue;
}
if (!fe_arg_info) {
/* An argument has been removed. This is considered illegal, because arity checks
* work based on a model where passing more than the declared number of parameters
* to a function is an error. */
return INHERITANCE_ERROR;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Implement Parameter Type Widening RFC
2017-01-01 22:53:24 +08:00
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
local_status = zend_do_perform_arg_type_hint_check(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
fe_scope, fe_arg_info, proto_scope, proto_arg_info);
Reorder conditions to minimize number of checks on fast path
2019-06-26 06:00:31 +08:00
if (UNEXPECTED(local_status != INHERITANCE_SUCCESS)) {
if (UNEXPECTED(local_status == INHERITANCE_ERROR)) {
return INHERITANCE_ERROR;
}
ZEND_ASSERT(local_status == INHERITANCE_UNRESOLVED);
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
status = INHERITANCE_UNRESOLVED;
Fixed bug #71978 (Existence of return type hint affects other compatibility rules)
2016-04-06 22:17:10 +08:00
}
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
/* by-ref constraints on arguments are invariant */
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
if (ZEND_ARG_SEND_MODE(fe_arg_info) != ZEND_ARG_SEND_MODE(proto_arg_info)) {
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
return INHERITANCE_ERROR;
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
}
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Allow adding return type during inheritance This is allowed as per the return types RFC. The test for this behavior happened to use an internal class without arginfo, which is why this was not properly implemented.
2015-03-23 01:50:36 +08:00
/* Check return type compatibility, but only if the prototype already specifies
* a return type. Adding a new return type is always valid. */
if (proto->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) {
/* Removing a return type is not valid. */
if (!(fe->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE)) {
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
return INHERITANCE_ERROR;
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
}
Implement Parameter Type Widening RFC
2017-01-01 22:53:24 +08:00
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
local_status = zend_perform_covariant_type_check(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
fe_scope, fe->common.arg_info[-1].type,
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
proto_scope, proto->common.arg_info[-1].type);
Reorder conditions to minimize number of checks on fast path
2019-06-26 06:00:31 +08:00
if (UNEXPECTED(local_status != INHERITANCE_SUCCESS)) {
if (UNEXPECTED(local_status == INHERITANCE_ERROR)) {
return INHERITANCE_ERROR;
}
ZEND_ASSERT(local_status == INHERITANCE_UNRESOLVED);
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
status = INHERITANCE_UNRESOLVED;
Implement nullable return types.
2016-04-06 23:24:34 +08:00
}
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
}
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
return status;
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
}
/* }}} */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
static ZEND_COLD void zend_append_type_hint(
Improve type declarations for Zend APIs Voidification of Zend API which always succeeded Use bool argument types instead of int for boolean arguments Use bool return type for functions which return true/false (1/0) Use zend_result return type for functions which return SUCCESS/FAILURE as they don't follow normal boolean semantics Closes GH-6002
2020-08-28 21:41:27 +08:00
smart_str *str, zend_class_entry *scope, zend_arg_info *arg_info, bool return_hint) /* {{{ */
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
{
Change representation of zend_type from type code to MAY_BE_* mask This switches zend_type from storing a single IS_* type code to storing a MAY_BE_* type mask. Right now most code still assumes that there is only a single type in the mask (or two together with MAY_BE_NULL). But this will make it a lot simpler to introduce union types. An additional advantage (and why I'm doing this separately), is that a number of special cases no longer need to be handled separately: We can do a single mask & (1 << type) check to handle all simple types, booleans (true|false) and null.
2019-09-19 18:11:29 +08:00
if (ZEND_TYPE_IS_SET(arg_info->type)) {
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
zend_string *type_str = zend_type_to_string_resolved(arg_info->type, scope);
Change representation of zend_type from type code to MAY_BE_* mask This switches zend_type from storing a single IS_* type code to storing a MAY_BE_* type mask. Right now most code still assumes that there is only a single type in the mask (or two together with MAY_BE_NULL). But this will make it a lot simpler to introduce union types. An additional advantage (and why I'm doing this separately), is that a number of special cases no longer need to be handled separately: We can do a single mask & (1 << type) check to handle all simple types, booleans (true|false) and null.
2019-09-19 18:11:29 +08:00
smart_str_append(str, type_str);
zend_string_release(type_str);
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
if (!return_hint) {
smart_str_appendc(str, ' ');
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
}
/* }}} */
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
static ZEND_COLD zend_string *zend_get_function_declaration(
const zend_function *fptr, zend_class_entry *scope) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str str = {0};
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if (fptr->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appends(&str, "& ");
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
if (fptr->common.scope) {
Show full signature upon inheritance mismatch
2015-06-29 06:28:52 +08:00
/* cut off on NULL byte ... class@anonymous */
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
smart_str_appendl(&str, ZSTR_VAL(fptr->common.scope->name), strlen(ZSTR_VAL(fptr->common.scope->name)));
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appends(&str, "::");
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Add smart_str_append for appending zend_strings Also replaces usages in Zend/ and ext/standard
2014-09-22 02:47:07 +08:00
smart_str_append(&str, fptr->common.function_name);
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appendc(&str, '(');
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if (fptr->common.arg_info) {
Don't count variadic argument in zend_func.common.num_args. This allows faster CALL/RETURN code.
2014-12-22 21:44:39 +08:00
uint32_t i, num_args, required;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
zend_arg_info *arg_info = fptr->common.arg_info;
required = fptr->common.required_num_args;
Don't count variadic argument in zend_func.common.num_args. This allows faster CALL/RETURN code.
2014-12-22 21:44:39 +08:00
num_args = fptr->common.num_args;
if (fptr->common.fn_flags & ZEND_ACC_VARIADIC) {
num_args++;
}
for (i = 0; i < num_args;) {
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
zend_append_type_hint(&str, scope, arg_info, 0);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
if (ZEND_ARG_SEND_MODE(arg_info)) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appendc(&str, '&');
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
if (ZEND_ARG_IS_VARIADIC(arg_info)) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appends(&str, "...");
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appendc(&str, '$');
Assert that arginfo parameter name is present
2020-04-07 22:05:33 +08:00
if (fptr->type == ZEND_INTERNAL_FUNCTION) {
smart_str_appends(&str, ((zend_internal_arg_info*)arg_info)->name);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else {
Assert that arginfo parameter name is present
2020-04-07 22:05:33 +08:00
smart_str_appendl(&str, ZSTR_VAL(arg_info->name), ZSTR_LEN(arg_info->name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
if (i >= required && !ZEND_ARG_IS_VARIADIC(arg_info)) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appends(&str, " = ");
Store default parameter values of internal functions in arg info Closes GH-5353. From now on, PHP will have reflection information about default values of parameters of internal functions. Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2020-04-06 17:02:13 +08:00
if (fptr->type == ZEND_INTERNAL_FUNCTION) {
if (((zend_internal_arg_info*)arg_info)->default_value) {
smart_str_appends(&str, ((zend_internal_arg_info*)arg_info)->default_value);
} else {
smart_str_appends(&str, "<default>");
}
} else {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
zend_op *precv = NULL;
{
uint32_t idx = i;
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
zend_op *op = fptr->op_array.opcodes;
zend_op *end = op + fptr->op_array.last;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
++idx;
while (op < end) {
if ((op->opcode == ZEND_RECV || op->opcode == ZEND_RECV_INIT)
&& op->op1.num == (zend_ulong)idx)
{
precv = op;
}
++op;
}
}
if (precv && precv->opcode == ZEND_RECV_INIT && precv->op2_type != IS_UNUSED) {
Changed the way VM accesses constant operands in 64-bit builds.
2017-10-04 21:53:01 +08:00
zval *zv = RT_CONSTANT(precv, precv->op2);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Always use IS_CONSTANT_AST (IS_CONSTANT is removed).
2017-10-10 15:11:05 +08:00
if (Z_TYPE_P(zv) == IS_FALSE) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appends(&str, "false");
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else if (Z_TYPE_P(zv) == IS_TRUE) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appends(&str, "true");
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else if (Z_TYPE_P(zv) == IS_NULL) {
Improve the default value format in incompatible signature error messages Closes GH-5361
2020-04-09 15:46:44 +08:00
smart_str_appends(&str, "null");
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else if (Z_TYPE_P(zv) == IS_STRING) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appendc(&str, '\'');
smart_str_appendl(&str, Z_STRVAL_P(zv), MIN(Z_STRLEN_P(zv), 10));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if (Z_STRLEN_P(zv) > 10) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appends(&str, "...");
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appendc(&str, '\'');
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else if (Z_TYPE_P(zv) == IS_ARRAY) {
Improve the default value format in incompatible signature error messages Closes GH-5361
2020-04-09 15:46:44 +08:00
if (zend_hash_num_elements(Z_ARRVAL_P(zv)) == 0) {
smart_str_appends(&str, "[]");
} else {
smart_str_appends(&str, "[...]");
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else if (Z_TYPE_P(zv) == IS_CONSTANT_AST) {
Always use IS_CONSTANT_AST (IS_CONSTANT is removed).
2017-10-10 15:11:05 +08:00
zend_ast *ast = Z_ASTVAL_P(zv);
if (ast->kind == ZEND_AST_CONSTANT) {
smart_str_append(&str, zend_ast_get_constant_name(ast));
} else {
smart_str_appends(&str, "<expression>");
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else {
Avoid unnecessary reference-counting on strings.
2017-11-16 22:09:32 +08:00
zend_string *tmp_zv_str;
zend_string *zv_str = zval_get_tmp_string(zv, &tmp_zv_str);
Add smart_str_append for appending zend_strings Also replaces usages in Zend/ and ext/standard
2014-09-22 02:47:07 +08:00
smart_str_append(&str, zv_str);
Avoid unnecessary reference-counting on strings.
2017-11-16 22:09:32 +08:00
zend_tmp_string_release(tmp_zv_str);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
}
}
Don't count variadic argument in zend_func.common.num_args. This allows faster CALL/RETURN code.
2014-12-22 21:44:39 +08:00
if (++i < num_args) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appends(&str, ", ");
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
arg_info++;
}
}
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appendc(&str, ')');
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
if (fptr->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) {
smart_str_appends(&str, ": ");
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
zend_append_type_hint(&str, scope, fptr->common.arg_info - 1, 1);
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
}
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_0(&str);
return str.s;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
static zend_always_inline uint32_t func_lineno(const zend_function *fn) {
Fix lineno for more inheritance errors And also include explicit linenos in tests.
2019-03-27 20:02:28 +08:00
return fn->common.type == ZEND_USER_FUNCTION ? fn->op_array.line_start : 0;
}
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
static void ZEND_COLD emit_incompatible_method_error(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
const zend_function *child, zend_class_entry *child_scope,
const zend_function *parent, zend_class_entry *parent_scope,
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
inheritance_status status) {
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
zend_string *parent_prototype = zend_get_function_declaration(parent, parent_scope);
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
zend_string *child_prototype = zend_get_function_declaration(child, child_scope);
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
if (status == INHERITANCE_UNRESOLVED) {
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
/* Fetch the first unresolved class from registered autoloads */
zend_string *unresolved_class = NULL;
ZEND_HASH_FOREACH_STR_KEY(CG(delayed_autoloads), unresolved_class) {
break;
} ZEND_HASH_FOREACH_END();
ZEND_ASSERT(unresolved_class);
Merge branch 'PHP-7.4'
2019-05-24 15:33:58 +08:00
zend_error_at(E_COMPILE_ERROR, NULL, func_lineno(child),
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
"Could not check compatibility between %s and %s, because class %s is not available",
ZSTR_VAL(child_prototype), ZSTR_VAL(parent_prototype), ZSTR_VAL(unresolved_class));
} else {
Merge branch 'PHP-7.4'
2019-05-24 15:33:58 +08:00
zend_error_at(E_COMPILE_ERROR, NULL, func_lineno(child),
"Declaration of %s must be compatible with %s",
ZSTR_VAL(child_prototype), ZSTR_VAL(parent_prototype));
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
}
zend_string_efree(child_prototype);
zend_string_efree(parent_prototype);
}
Cleanup
2019-06-25 21:37:42 +08:00
static void perform_delayable_implementation_check(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
zend_class_entry *ce,
const zend_function *fe, zend_class_entry *fe_scope,
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
const zend_function *proto, zend_class_entry *proto_scope)
Cleanup
2019-06-25 21:37:42 +08:00
{
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
inheritance_status status =
zend_do_perform_implementation_check(fe, fe_scope, proto, proto_scope);
Cleanup
2019-06-25 21:37:42 +08:00
if (UNEXPECTED(status != INHERITANCE_SUCCESS)) {
if (EXPECTED(status == INHERITANCE_UNRESOLVED)) {
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
add_compatibility_obligation(ce, fe, fe_scope, proto, proto_scope);
Reorder conditions to minimize number of checks on fast path
2019-06-26 06:00:31 +08:00
} else {
ZEND_ASSERT(status == INHERITANCE_ERROR);
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
emit_incompatible_method_error(fe, fe_scope, proto, proto_scope, status);
Cleanup
2019-06-25 21:37:42 +08:00
}
}
}
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
static zend_always_inline inheritance_status do_inheritance_check_on_method_ex(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
zend_function *child, zend_class_entry *child_scope,
zend_function *parent, zend_class_entry *parent_scope,
zend_class_entry *ce, zval *child_zv,
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
zend_bool check_visibility, zend_bool check_only, zend_bool checked) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
uint32_t child_flags;
uint32_t parent_flags = parent->common.fn_flags;
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
zend_function *proto;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Ignore inheritance rules on private methods Closes GH-5401
2020-04-17 01:53:13 +08:00
if (UNEXPECTED((parent_flags & ZEND_ACC_PRIVATE) && !(parent_flags & ZEND_ACC_ABSTRACT) && !(parent_flags & ZEND_ACC_CTOR))) {
if (!check_only) {
child->common.fn_flags |= ZEND_ACC_CHANGED;
}
/* The parent method is private and not an abstract so we don't need to check any inheritance rules */
return INHERITANCE_SUCCESS;
}
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (!checked && UNEXPECTED(parent_flags & ZEND_ACC_FINAL)) {
if (check_only) {
return INHERITANCE_ERROR;
}
Fix lineno for more inheritance errors And also include explicit linenos in tests.
2019-03-27 20:02:28 +08:00
zend_error_at_noreturn(E_COMPILE_ERROR, NULL, func_lineno(child),
"Cannot override final method %s::%s()",
ZEND_FN_SCOPE_NAME(parent), ZSTR_VAL(child->common.function_name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
child_flags = child->common.fn_flags;
/* You cannot change from static to non static and vice versa.
*/
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (!checked && UNEXPECTED((child_flags & ZEND_ACC_STATIC) != (parent_flags & ZEND_ACC_STATIC))) {
if (check_only) {
return INHERITANCE_ERROR;
}
Avoid reloading
2018-07-09 21:28:13 +08:00
if (child_flags & ZEND_ACC_STATIC) {
Fix lineno for more inheritance errors And also include explicit linenos in tests.
2019-03-27 20:02:28 +08:00
zend_error_at_noreturn(E_COMPILE_ERROR, NULL, func_lineno(child),
"Cannot make non static method %s::%s() static in class %s",
ZEND_FN_SCOPE_NAME(parent), ZSTR_VAL(child->common.function_name), ZEND_FN_SCOPE_NAME(child));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else {
Fix lineno for more inheritance errors And also include explicit linenos in tests.
2019-03-27 20:02:28 +08:00
zend_error_at_noreturn(E_COMPILE_ERROR, NULL, func_lineno(child),
"Cannot make static method %s::%s() non static in class %s",
ZEND_FN_SCOPE_NAME(parent), ZSTR_VAL(child->common.function_name), ZEND_FN_SCOPE_NAME(child));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
/* Disallow making an inherited method abstract. */
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (!checked && UNEXPECTED((child_flags & ZEND_ACC_ABSTRACT) > (parent_flags & ZEND_ACC_ABSTRACT))) {
if (check_only) {
return INHERITANCE_ERROR;
}
Fix lineno for more inheritance errors And also include explicit linenos in tests.
2019-03-27 20:02:28 +08:00
zend_error_at_noreturn(E_COMPILE_ERROR, NULL, func_lineno(child),
"Cannot make non abstract method %s::%s() abstract in class %s",
ZEND_FN_SCOPE_NAME(parent), ZSTR_VAL(child->common.function_name), ZEND_FN_SCOPE_NAME(child));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (!check_only && (parent_flags & (ZEND_ACC_PRIVATE|ZEND_ACC_CHANGED))) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
child->common.fn_flags |= ZEND_ACC_CHANGED;
}
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
proto = parent->common.prototype ?
parent->common.prototype : parent;
if (parent_flags & ZEND_ACC_CTOR) {
/* ctors only have a prototype if is abstract (or comes from an interface) */
/* and if that is the case, we want to check inheritance against it */
if (!(proto->common.fn_flags & ZEND_ACC_ABSTRACT)) {
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
return INHERITANCE_SUCCESS;
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
}
parent = proto;
}
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
if (!check_only && child->common.prototype != proto && child_zv) {
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
do {
if (child->common.scope != ce
&& child->type == ZEND_USER_FUNCTION
&& !child->op_array.static_variables) {
if (ce->ce_flags & ZEND_ACC_INTERFACE) {
/* Few parent interfaces contain the same method */
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
break;
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
} else {
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
/* op_array wasn't duplicated yet */
zend_function *new_function = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
memcpy(new_function, child, sizeof(zend_op_array));
Z_PTR_P(child_zv) = child = new_function;
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
}
}
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
child->common.prototype = proto;
} while (0);
}
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
/* Prevent derived classes from restricting access that was available in parent classes (except deriving from non-abstract ctors) */
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
if (!checked && check_visibility
&& (child_flags & ZEND_ACC_PPP_MASK) > (parent_flags & ZEND_ACC_PPP_MASK)) {
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (check_only) {
return INHERITANCE_ERROR;
}
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
zend_error_at_noreturn(E_COMPILE_ERROR, NULL, func_lineno(child),
"Access level to %s::%s() must be %s (as in class %s)%s",
ZEND_FN_SCOPE_NAME(child), ZSTR_VAL(child->common.function_name), zend_visibility_string(parent_flags), ZEND_FN_SCOPE_NAME(parent), (parent_flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
}
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (!checked) {
if (check_only) {
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
return zend_do_perform_implementation_check(child, child_scope, parent, parent_scope);
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
}
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
perform_delayable_implementation_check(ce, child, child_scope, parent, parent_scope);
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
}
return INHERITANCE_SUCCESS;
}
/* }}} */
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
static zend_never_inline void do_inheritance_check_on_method(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
zend_function *child, zend_class_entry *child_scope,
zend_function *parent, zend_class_entry *parent_scope,
zend_class_entry *ce, zval *child_zv, zend_bool check_visibility)
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
{
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
do_inheritance_check_on_method_ex(child, child_scope, parent, parent_scope, ce, child_zv, check_visibility, 0, 0);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
static zend_always_inline void do_inherit_method(zend_string *key, zend_function *parent, zend_class_entry *ce, zend_bool is_interface, zend_bool checked) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Introduced zend_hash_find_ex() that may avoid unnecessary hash value check.
2017-11-24 19:01:19 +08:00
zval *child = zend_hash_find_ex(&ce->function_table, key, 1);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (child) {
Fixed bug #71248 (Wrong interface is enforced)
2016-01-13 16:41:57 +08:00
zend_function *func = (zend_function*)Z_PTR_P(child);
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
if (is_interface && UNEXPECTED(func == parent)) {
typo
2018-10-03 19:35:36 +08:00
/* The same method in interface may be inherited few times */
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
return;
Avoid method compatibility check with itself
2018-10-03 17:32:33 +08:00
}
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
if (checked) {
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
do_inheritance_check_on_method_ex(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
func, func->common.scope, parent, parent->common.scope, ce, child,
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
/* check_visibility */ 1, 0, checked);
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
} else {
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
do_inheritance_check_on_method(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
func, func->common.scope, parent, parent->common.scope, ce, child,
/* check_visibility */ 1);
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
}
} else {
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
if (is_interface || (parent->common.fn_flags & (ZEND_ACC_ABSTRACT))) {
ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
}
parent = zend_duplicate_function(parent, ce, is_interface);
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
if (!is_interface) {
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
_zend_hash_append_ptr(&ce->function_table, key, parent);
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
} else {
zend_hash_add_new_ptr(&ce->function_table, key, parent);
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
}
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
}
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
}
/* }}} */
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
inheritance_status property_types_compatible(
const zend_property_info *parent_info, const zend_property_info *child_info) {
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
if (ZEND_TYPE_PURE_MASK(parent_info->type) == ZEND_TYPE_PURE_MASK(child_info->type)
&& ZEND_TYPE_NAME(parent_info->type) == ZEND_TYPE_NAME(child_info->type)) {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
return INHERITANCE_SUCCESS;
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
}
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
if (ZEND_TYPE_IS_SET(parent_info->type) != ZEND_TYPE_IS_SET(child_info->type)) {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
return INHERITANCE_ERROR;
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
}
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
/* Perform a covariant type check in both directions to determined invariance. */
inheritance_status status1 = zend_perform_covariant_type_check(
child_info->ce, child_info->type, parent_info->ce, parent_info->type);
inheritance_status status2 = zend_perform_covariant_type_check(
parent_info->ce, parent_info->type, child_info->ce, child_info->type);
if (status1 == INHERITANCE_SUCCESS && status2 == INHERITANCE_SUCCESS) {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
return INHERITANCE_SUCCESS;
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
}
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
if (status1 == INHERITANCE_ERROR || status2 == INHERITANCE_ERROR) {
return INHERITANCE_ERROR;
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
}
Fix incorrect assertion in property type variance check Only one of the status has to be UNRESOLVED, the other could also be SUCCESS. Fixes oss-fuzz #19108 and oss-fuzz #19111.
2019-12-04 18:07:22 +08:00
ZEND_ASSERT(status1 == INHERITANCE_UNRESOLVED || status2 == INHERITANCE_UNRESOLVED);
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
return INHERITANCE_UNRESOLVED;
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
}
static void emit_incompatible_property_error(
const zend_property_info *child, const zend_property_info *parent) {
Merge branch 'PHP-7.4' * PHP-7.4: Integrate property types with variance system
2019-10-17 19:42:47 +08:00
zend_string *type_str = zend_type_to_string_resolved(parent->type, parent->ce);
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
zend_error_noreturn(E_COMPILE_ERROR,
Merge branch 'PHP-7.4' * PHP-7.4: Integrate property types with variance system
2019-10-17 19:42:47 +08:00
"Type of %s::$%s must be %s (as in class %s)",
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
ZSTR_VAL(child->ce->name),
Use unmangled named in property type inheritance error
2019-12-09 15:48:33 +08:00
zend_get_unmangled_property_name(child->name),
Merge branch 'PHP-7.4' * PHP-7.4: Integrate property types with variance system
2019-10-17 19:42:47 +08:00
ZSTR_VAL(type_str),
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
ZSTR_VAL(parent->ce->name));
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
}
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
static void do_inherit_property(zend_property_info *parent_info, zend_string *key, zend_class_entry *ce) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Introduced zend_hash_find_ex() that may avoid unnecessary hash value check.
2017-11-24 19:01:19 +08:00
zval *child = zend_hash_find_ex(&ce->properties_info, key, 1);
Improved ineritance code
2015-03-05 04:06:07 +08:00
zend_property_info *child_info;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Improved ineritance code
2015-03-05 04:06:07 +08:00
if (UNEXPECTED(child)) {
child_info = Z_PTR_P(child);
Better ZEND_ACC_CHANGED handling
2018-09-12 16:43:15 +08:00
if (parent_info->flags & (ZEND_ACC_PRIVATE|ZEND_ACC_CHANGED)) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
child_info->flags |= ZEND_ACC_CHANGED;
Better ZEND_ACC_CHANGED handling
2018-09-12 16:43:15 +08:00
}
if (!(parent_info->flags & ZEND_ACC_PRIVATE)) {
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (UNEXPECTED((parent_info->flags & ZEND_ACC_STATIC) != (child_info->flags & ZEND_ACC_STATIC))) {
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s%s::$%s as %s%s::$%s",
Prefer using declaring class rather than direct parent in error Point to the class that actually declares the property, which is not necessarily the same as the direct parent class.
2020-01-22 00:19:07 +08:00
(parent_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ZSTR_VAL(parent_info->ce->name), ZSTR_VAL(key),
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
(child_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ZSTR_VAL(ce->name), ZSTR_VAL(key));
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (UNEXPECTED((child_info->flags & ZEND_ACC_PPP_MASK) > (parent_info->flags & ZEND_ACC_PPP_MASK))) {
Prefer using declaring class rather than direct parent in error Point to the class that actually declares the property, which is not necessarily the same as the direct parent class.
2020-01-22 00:19:07 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::$%s must be %s (as in class %s)%s", ZSTR_VAL(ce->name), ZSTR_VAL(key), zend_visibility_string(parent_info->flags), ZSTR_VAL(parent_info->ce->name), (parent_info->flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
} else if ((child_info->flags & ZEND_ACC_STATIC) == 0) {
int parent_num = OBJ_PROP_TO_NUM(parent_info->offset);
int child_num = OBJ_PROP_TO_NUM(child_info->offset);
Fixed typo
2016-05-06 14:48:58 +08:00
/* Don't keep default properties in GC (they may be freed by opcache) */
Merge branch 'PHP-5.6' into PHP-7.0 * PHP-5.6: Prevent usage in GC after free.
2016-04-19 06:37:24 +08:00
zval_ptr_dtor_nogc(&(ce->default_properties_table[parent_num]));
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
ce->default_properties_table[parent_num] = ce->default_properties_table[child_num];
ZVAL_UNDEF(&ce->default_properties_table[child_num]);
child_info->offset = parent_info->offset;
}
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
if (UNEXPECTED(ZEND_TYPE_IS_SET(parent_info->type))) {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
inheritance_status status = property_types_compatible(parent_info, child_info);
if (status == INHERITANCE_ERROR) {
emit_incompatible_property_error(child_info, parent_info);
}
if (status == INHERITANCE_UNRESOLVED) {
add_property_compatibility_obligation(ce, child_info, parent_info);
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
}
} else if (UNEXPECTED(ZEND_TYPE_IS_SET(child_info->type) && !ZEND_TYPE_IS_SET(parent_info->type))) {
zend_error_noreturn(E_COMPILE_ERROR,
"Type of %s::$%s must not be defined (as in class %s)",
ZSTR_VAL(ce->name),
ZSTR_VAL(key),
Prefer using declaring class rather than direct parent in error Point to the class that actually declares the property, which is not necessarily the same as the direct parent class.
2020-01-22 00:19:07 +08:00
ZSTR_VAL(parent_info->ce->name));
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
}
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
}
} else {
Squashed commit of the following: commit 2d3cac9e005d6bef9aa73ab57cc674aa53125954 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 11:54:47 2018 +0300 Fixed static property access commit 31786ee27282f319f3ef2a07635b1f325cbd67c6 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 11:05:29 2018 +0300 Avoid duplicate checks commit 5ae502b979ea33d058d01a9421eec5afd0084e8d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 10:39:17 2018 +0300 Optimization commit 82c17f0e8af02c9cf7d1bbdae4e3158330148203 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 09:26:50 2018 +0300 Removed unused zend_duplicate_property_info() commit ba53d1d0dd91d5530328a11cac93ff9e75c462b5 Merge: eacc11b8fd c4b14370cf Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 09:24:13 2018 +0300 Merge branch 'master' into shadow * master: 7.0.33 next Sync NEWS [ci skip] add NEWS for 76582 Enforce ordering of property compare in object comparisons Fixed wrong assertion Skip test on unsuitable env commit eacc11b8fdeb002ee6a149defd8b5a8c3412896a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Sep 10 13:12:39 2018 +0300 Fixed failure of ext/spl/tests/array_017.phpt commit 62d1871430a1b81c84b790460afff0682648689a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Sep 10 11:55:07 2018 +0300 Fixed issues commit 1d37e3a40e4d07c4b933ed6f9d2e649dd01180f0 Merge: d6c3f098b6 1e550e6f7e Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Sep 10 10:21:20 2018 +0300 Merge branch 'master' into shadow * master: Update NEWS Fix for bug #76582 Fix ssl stream reneg limit test to print only after first renegotiation Make a copy unconditionally Fix memory leak in pcre cache Remove not needed checking for <errno.h> Remove HAVE_ASSERT_H Add test for bug #76850 Fixed bug #76850 Exit code mangled by set locale/preg_match Remove empty PHP tags from test Fix #75273: php_zlib_inflate_filter() may not update bytes_consumed Fix PCRE2 exclusion and remove dead libs in Makefile.gcov Report mem leaks to stderr if no Win debugger is present Use combined assignment contanation operator Fixed bug #76796 Support fixed address mmap without replacement commit d6c3f098b6015e76d042691de0af2e1426c66829 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Sep 7 13:56:30 2018 +0300 Get rid of ZEND_ACC_SHADOW
2018-09-11 16:56:45 +08:00
if (UNEXPECTED(ce->type & ZEND_INTERNAL_CLASS)) {
child_info = zend_duplicate_property_info_internal(parent_info);
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
} else {
Squashed commit of the following: commit 2d3cac9e005d6bef9aa73ab57cc674aa53125954 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 11:54:47 2018 +0300 Fixed static property access commit 31786ee27282f319f3ef2a07635b1f325cbd67c6 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 11:05:29 2018 +0300 Avoid duplicate checks commit 5ae502b979ea33d058d01a9421eec5afd0084e8d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 10:39:17 2018 +0300 Optimization commit 82c17f0e8af02c9cf7d1bbdae4e3158330148203 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 09:26:50 2018 +0300 Removed unused zend_duplicate_property_info() commit ba53d1d0dd91d5530328a11cac93ff9e75c462b5 Merge: eacc11b8fd c4b14370cf Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 09:24:13 2018 +0300 Merge branch 'master' into shadow * master: 7.0.33 next Sync NEWS [ci skip] add NEWS for 76582 Enforce ordering of property compare in object comparisons Fixed wrong assertion Skip test on unsuitable env commit eacc11b8fdeb002ee6a149defd8b5a8c3412896a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Sep 10 13:12:39 2018 +0300 Fixed failure of ext/spl/tests/array_017.phpt commit 62d1871430a1b81c84b790460afff0682648689a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Sep 10 11:55:07 2018 +0300 Fixed issues commit 1d37e3a40e4d07c4b933ed6f9d2e649dd01180f0 Merge: d6c3f098b6 1e550e6f7e Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Sep 10 10:21:20 2018 +0300 Merge branch 'master' into shadow * master: Update NEWS Fix for bug #76582 Fix ssl stream reneg limit test to print only after first renegotiation Make a copy unconditionally Fix memory leak in pcre cache Remove not needed checking for <errno.h> Remove HAVE_ASSERT_H Add test for bug #76850 Fixed bug #76850 Exit code mangled by set locale/preg_match Remove empty PHP tags from test Fix #75273: php_zlib_inflate_filter() may not update bytes_consumed Fix PCRE2 exclusion and remove dead libs in Makefile.gcov Report mem leaks to stderr if no Win debugger is present Use combined assignment contanation operator Fixed bug #76796 Support fixed address mmap without replacement commit d6c3f098b6015e76d042691de0af2e1426c66829 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Sep 7 13:56:30 2018 +0300 Get rid of ZEND_ACC_SHADOW
2018-09-11 16:56:45 +08:00
child_info = parent_info;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
_zend_hash_append_ptr(&ce->properties_info, key, child_info);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
/* }}} */
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
static inline void do_implement_interface(zend_class_entry *ce, zend_class_entry *iface) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
if (!(ce->ce_flags & ZEND_ACC_INTERFACE) && iface->interface_gets_implemented && iface->interface_gets_implemented(iface, ce) == FAILURE) {
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
zend_error_noreturn(E_CORE_ERROR, "Class %s could not implement interface %s", ZSTR_VAL(ce->name), ZSTR_VAL(iface->name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Only allow "nearly linked" classes for parent/interface The requirements for parent/interface are difference than for the variance checks in type declarations. The latter can work on fully unlinked classes, but the former need inheritance to be essentially finished, only variance checks may still be outstanding. Adding a new flag for this because we have lots of space, but we could also represent these "inheritance states" more compactly in the future.
2019-09-11 22:27:28 +08:00
/* This should be prevented by the class lookup logic. */
ZEND_ASSERT(ce != iface);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
static void zend_do_inherit_interfaces(zend_class_entry *ce, const zend_class_entry *iface) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
/* expects interface to be contained in ce's interface list already */
uint32_t i, ce_num, if_num = iface->num_interfaces;
zend_class_entry *entry;
ce_num = ce->num_interfaces;
if (ce->type == ZEND_INTERNAL_CLASS) {
ce->interfaces = (zend_class_entry **) realloc(ce->interfaces, sizeof(zend_class_entry *) * (ce_num + if_num));
} else {
ce->interfaces = (zend_class_entry **) erealloc(ce->interfaces, sizeof(zend_class_entry *) * (ce_num + if_num));
}
/* Inherit the interfaces, only if they're not already inherited by the class */
while (if_num--) {
entry = iface->interfaces[if_num];
for (i = 0; i < ce_num; i++) {
if (ce->interfaces[i] == entry) {
break;
}
}
if (i == ce_num) {
ce->interfaces[ce->num_interfaces++] = entry;
}
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
ce->ce_flags |= ZEND_ACC_RESOLVED_INTERFACES;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* and now call the implementing handlers */
while (ce_num < ce->num_interfaces) {
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
do_implement_interface(ce, ce->interfaces[ce_num++]);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
/* }}} */
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
static void do_inherit_class_constant(zend_string *name, zend_class_constant *parent_const, zend_class_entry *ce) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Introduced zend_hash_find_ex() that may avoid unnecessary hash value check.
2017-11-24 19:01:19 +08:00
zval *zv = zend_hash_find_ex(&ce->constants_table, name, 1);
zend_class_constant *c;
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
Introduced zend_hash_find_ex() that may avoid unnecessary hash value check.
2017-11-24 19:01:19 +08:00
if (zv != NULL) {
c = (zend_class_constant*)Z_PTR_P(zv);
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
if (UNEXPECTED((Z_ACCESS_FLAGS(c->value) & ZEND_ACC_PPP_MASK) > (Z_ACCESS_FLAGS(parent_const->value) & ZEND_ACC_PPP_MASK))) {
zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::%s must be %s (as in class %s)%s",
Prefer using declaring class rather than direct parent in error Point to the class that actually declares the property, which is not necessarily the same as the direct parent class.
2020-01-22 00:19:07 +08:00
ZSTR_VAL(ce->name), ZSTR_VAL(name), zend_visibility_string(Z_ACCESS_FLAGS(parent_const->value)), ZSTR_VAL(parent_const->ce->name), (Z_ACCESS_FLAGS(parent_const->value) & ZEND_ACC_PUBLIC) ? "" : " or weaker");
Improved ineritance code
2015-03-05 04:06:07 +08:00
}
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
} else if (!(Z_ACCESS_FLAGS(parent_const->value) & ZEND_ACC_PRIVATE)) {
Always use IS_CONSTANT_AST (IS_CONSTANT is removed).
2017-10-10 15:11:05 +08:00
if (Z_TYPE(parent_const->value) == IS_CONSTANT_AST) {
Improved ineritance code
2015-03-05 04:06:07 +08:00
ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Fixed use-after free introduced in fcc08ce19f39f7ab1381ecc8a010037d41819329
2017-10-31 06:20:38 +08:00
if (ce->type & ZEND_INTERNAL_CLASS) {
c = pemalloc(sizeof(zend_class_constant), 1);
memcpy(c, parent_const, sizeof(zend_class_constant));
parent_const = c;
}
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
_zend_hash_append_ptr(&ce->constants_table, name, parent_const);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
/* }}} */
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
void zend_build_properties_info_table(zend_class_entry *ce)
{
zend_property_info **table, *prop;
Avoid uninitialized entries in properties_info_table Also don't place it into xlat, there's only ever one user.
2019-02-15 20:42:37 +08:00
size_t size;
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
if (ce->default_properties_count == 0) {
return;
}
ZEND_ASSERT(ce->properties_info_table == NULL);
Avoid uninitialized entries in properties_info_table Also don't place it into xlat, there's only ever one user.
2019-02-15 20:42:37 +08:00
size = sizeof(zend_property_info *) * ce->default_properties_count;
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
if (ce->type == ZEND_USER_CLASS) {
Avoid uninitialized entries in properties_info_table Also don't place it into xlat, there's only ever one user.
2019-02-15 20:42:37 +08:00
ce->properties_info_table = table = zend_arena_alloc(&CG(arena), size);
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
} else {
Avoid uninitialized entries in properties_info_table Also don't place it into xlat, there's only ever one user.
2019-02-15 20:42:37 +08:00
ce->properties_info_table = table = pemalloc(size, 1);
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
}
Avoid uninitialized entries in properties_info_table Also don't place it into xlat, there's only ever one user.
2019-02-15 20:42:37 +08:00
/* Dead slots may be left behind during inheritance. Make sure these are NULLed out. */
memset(table, 0, size);
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
if (ce->parent && ce->parent->default_properties_count != 0) {
zend_property_info **parent_table = ce->parent->properties_info_table;
memcpy(
table, parent_table,
sizeof(zend_property_info *) * ce->parent->default_properties_count
);
/* Child did not add any new properties, we are done */
if (ce->default_properties_count == ce->parent->default_properties_count) {
return;
}
}
ZEND_HASH_FOREACH_PTR(&ce->properties_info, prop) {
if (prop->ce == ce && (prop->flags & ZEND_ACC_STATIC) == 0) {
table[OBJ_PROP_TO_NUM(prop->offset)] = prop;
}
} ZEND_HASH_FOREACH_END();
}
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
ZEND_API void zend_do_inheritance_ex(zend_class_entry *ce, zend_class_entry *parent_ce, zend_bool checked) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
zend_property_info *property_info;
zend_function *func;
zend_string *key;
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (UNEXPECTED(ce->ce_flags & ZEND_ACC_INTERFACE)) {
Check interface/trait extension for internal classes Removed possibility to have extensions to declare classes extending interfaces or traits. It was checked in user classes, not extensions or internal.
2014-12-06 12:42:52 +08:00
/* Interface can only inherit other interfaces */
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (UNEXPECTED(!(parent_ce->ce_flags & ZEND_ACC_INTERFACE))) {
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Interface %s may not inherit from class (%s)", ZSTR_VAL(ce->name), ZSTR_VAL(parent_ce->name));
Check interface/trait extension for internal classes Removed possibility to have extensions to declare classes extending interfaces or traits. It was checked in user classes, not extensions or internal.
2014-12-06 12:42:52 +08:00
}
Improved ineritance code
2015-03-05 04:06:07 +08:00
} else if (UNEXPECTED(parent_ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_FINAL))) {
Check interface/trait extension for internal classes Removed possibility to have extensions to declare classes extending interfaces or traits. It was checked in user classes, not extensions or internal.
2014-12-06 12:42:52 +08:00
/* Class declaration must not extend traits or interfaces */
if (parent_ce->ce_flags & ZEND_ACC_INTERFACE) {
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend from interface %s", ZSTR_VAL(ce->name), ZSTR_VAL(parent_ce->name));
Check interface/trait extension for internal classes Removed possibility to have extensions to declare classes extending interfaces or traits. It was checked in user classes, not extensions or internal.
2014-12-06 12:42:52 +08:00
} else if (parent_ce->ce_flags & ZEND_ACC_TRAIT) {
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend from trait %s", ZSTR_VAL(ce->name), ZSTR_VAL(parent_ce->name));
Check interface/trait extension for internal classes Removed possibility to have extensions to declare classes extending interfaces or traits. It was checked in user classes, not extensions or internal.
2014-12-06 12:42:52 +08:00
}
/* Class must not extend a final class */
if (parent_ce->ce_flags & ZEND_ACC_FINAL) {
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Class %s may not inherit from final class (%s)", ZSTR_VAL(ce->name), ZSTR_VAL(parent_ce->name));
Check interface/trait extension for internal classes Removed possibility to have extensions to declare classes extending interfaces or traits. It was checked in user classes, not extensions or internal.
2014-12-06 12:42:52 +08:00
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Replace ZEND_ACC_ANON_BOUND, ZEND_ACC_UNRESOLVED_PARENT and ZEND_ACC_UNRESOLVED_INTERFACES with single ZEND_ACC_LINKED.
2018-09-18 16:41:40 +08:00
if (ce->parent_name) {
Keep information about unresolved parent class in zend_class_entry->parent_name
2018-08-24 05:20:57 +08:00
zend_string_release_ex(ce->parent_name, 0);
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
ce->parent = parent_ce;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
ce->ce_flags |= ZEND_ACC_RESOLVED_PARENT;
Check interface/trait extension for internal classes Removed possibility to have extensions to declare classes extending interfaces or traits. It was checked in user classes, not extensions or internal.
2014-12-06 12:42:52 +08:00
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* Inherit properties */
if (parent_ce->default_properties_count) {
Improved property inheritance code
2015-04-22 17:53:54 +08:00
zval *src, *dst, *end;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if (ce->default_properties_count) {
Improved property inheritance code
2015-04-22 17:53:54 +08:00
zval *table = pemalloc(sizeof(zval) * (ce->default_properties_count + parent_ce->default_properties_count), ce->type == ZEND_INTERNAL_CLASS);
src = ce->default_properties_table + ce->default_properties_count;
end = table + parent_ce->default_properties_count;
dst = end + ce->default_properties_count;
ce->default_properties_table = table;
do {
dst--;
src--;
Fix bug #78226: Don't call __set() on uninitialized typed properties Assigning to an uninitialized typed property will no longer trigger a call to __set(). However, calls to __set() are still triggered if the property is explicitly unset(). This gives us both the behavior people generally expect, and still allows ORMs to do lazy initialization by unsetting properties. For PHP 8, we should fine a way to forbid unsetting of declared properties entirely, and provide a different way to achieve lazy initialization.
2019-10-24 22:36:25 +08:00
ZVAL_COPY_VALUE_PROP(dst, src);
Improved property inheritance code
2015-04-22 17:53:54 +08:00
} while (dst != end);
pefree(src, ce->type == ZEND_INTERNAL_CLASS);
end = ce->default_properties_table;
} else {
end = pemalloc(sizeof(zval) * parent_ce->default_properties_count, ce->type == ZEND_INTERNAL_CLASS);
dst = end + parent_ce->default_properties_count;
ce->default_properties_table = end;
}
src = parent_ce->default_properties_table + parent_ce->default_properties_count;
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
if (UNEXPECTED(parent_ce->type != ce->type)) {
/* User class extends internal */
do {
dst--;
src--;
Fix bug #78226: Don't call __set() on uninitialized typed properties Assigning to an uninitialized typed property will no longer trigger a call to __set(). However, calls to __set() are still triggered if the property is explicitly unset(). This gives us both the behavior people generally expect, and still allows ORMs to do lazy initialization by unsetting properties. For PHP 8, we should fine a way to forbid unsetting of declared properties entirely, and provide a different way to achieve lazy initialization.
2019-10-24 22:36:25 +08:00
ZVAL_COPY_OR_DUP_PROP(dst, src);
Always use IS_CONSTANT_AST (IS_CONSTANT is removed).
2017-10-10 15:11:05 +08:00
if (Z_OPT_TYPE_P(dst) == IS_CONSTANT_AST) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
}
continue;
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
} while (dst != end);
} else {
do {
dst--;
src--;
Fix bug #78226: Don't call __set() on uninitialized typed properties Assigning to an uninitialized typed property will no longer trigger a call to __set(). However, calls to __set() are still triggered if the property is explicitly unset(). This gives us both the behavior people generally expect, and still allows ORMs to do lazy initialization by unsetting properties. For PHP 8, we should fine a way to forbid unsetting of declared properties entirely, and provide a different way to achieve lazy initialization.
2019-10-24 22:36:25 +08:00
ZVAL_COPY_PROP(dst, src);
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
if (Z_OPT_TYPE_P(dst) == IS_CONSTANT_AST) {
ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
}
continue;
} while (dst != end);
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
ce->default_properties_count += parent_ce->default_properties_count;
}
Improved property inheritance code
2015-04-22 17:53:54 +08:00
if (parent_ce->default_static_members_count) {
zval *src, *dst, *end;
if (ce->default_static_members_count) {
zval *table = pemalloc(sizeof(zval) * (ce->default_static_members_count + parent_ce->default_static_members_count), ce->type == ZEND_INTERNAL_CLASS);
src = ce->default_static_members_table + ce->default_static_members_count;
end = table + parent_ce->default_static_members_count;
dst = end + ce->default_static_members_count;
ce->default_static_members_table = table;
do {
dst--;
src--;
ZVAL_COPY_VALUE(dst, src);
} while (dst != end);
pefree(src, ce->type == ZEND_INTERNAL_CLASS);
end = ce->default_static_members_table;
} else {
end = pemalloc(sizeof(zval) * parent_ce->default_static_members_count, ce->type == ZEND_INTERNAL_CLASS);
dst = end + parent_ce->default_static_members_count;
ce->default_static_members_table = end;
}
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
if (UNEXPECTED(parent_ce->type != ce->type)) {
/* User class extends internal */
Don't initialize static_member_tables during start-up, when inherit internal classes.
2018-10-19 18:21:31 +08:00
if (CE_STATIC_MEMBERS(parent_ce) == NULL) {
zend_class_init_statics(parent_ce);
}
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
if (UNEXPECTED(zend_update_class_constants(parent_ce) != SUCCESS)) {
Use ZEND_UNREACHABLE() instead of ZEND_ASSERT(0) Instead of marking unreachable code with `ZEND_ASSERT(0)`, we introduce `ZEND_UNREACHABLE()`, so that MSVC which does not consider `assert(0)` to mark unreachable code does no longer trigger C4715[1] warnings in debug builds. This may be useful for other compilers as well. [1] <https://docs.microsoft.com/de-de/cpp/error-messages/compiler-warnings/compiler-warning-level-1-c4715?view=vs-2019>
2020-06-16 22:29:05 +08:00
ZEND_UNREACHABLE();
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
}
src = CE_STATIC_MEMBERS(parent_ce) + parent_ce->default_static_members_count;
do {
dst--;
src--;
Fixed bug #76509 In PHP static properties are shared between inheriting classes, unless they are explicitly overwritten. However, because this functionality was implemented using reference, it was possible to break the implementation by reassigning the static property reference. This is fixed by switching the implementation from using references to using INDIRECTs, which cannot be affected by userland code.
2018-06-22 18:58:48 +08:00
if (Z_TYPE_P(src) == IS_INDIRECT) {
ZVAL_INDIRECT(dst, Z_INDIRECT_P(src));
Cheaper reference construction
2017-12-26 18:30:25 +08:00
} else {
Fixed bug #76509 In PHP static properties are shared between inheriting classes, unless they are explicitly overwritten. However, because this functionality was implemented using reference, it was possible to break the implementation by reassigning the static property reference. This is fixed by switching the implementation from using references to using INDIRECTs, which cannot be affected by userland code.
2018-06-22 18:58:48 +08:00
ZVAL_INDIRECT(dst, src);
Cheaper reference construction
2017-12-26 18:30:25 +08:00
}
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
} while (dst != end);
} else if (ce->type == ZEND_USER_CLASS) {
Don't initialize static_member_tables during start-up, when inherit internal classes.
2018-10-19 18:21:31 +08:00
if (CE_STATIC_MEMBERS(parent_ce) == NULL) {
Fixed bug 78175 (Preloading must store default values of static variables and properties)
2019-06-25 01:32:27 +08:00
ZEND_ASSERT(parent_ce->ce_flags & (ZEND_ACC_IMMUTABLE|ZEND_ACC_PRELOADED));
Don't initialize static_member_tables during start-up, when inherit internal classes.
2018-10-19 18:21:31 +08:00
zend_class_init_statics(parent_ce);
}
Immutable clases and op_arrays. Squashed commit of the following: commit cd0c36c3f943849e5b97a8dbe2dd029fbeab3df9 Merge: 4740dabb84 ad6738e886 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 14:43:38 2018 +0300 Merge branch 'master' into immutable * master: Remove the "auto" encoding Fixed bug #77025 Add vtbls for EUC-TW encoding commit 4740dabb843c6d4f7f866b4a2456073c9eaf4c77 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 14:12:28 2018 +0300 Reverted back ce->iterator_funcs_ptr. Initialize ce->iterator_funcs_ptr fields in immutable classes. commit ad7a78b253be970db70c2251e66f9297d8e7f829 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:46:30 2018 +0300 Added comment commit 0276ea51875bab37be01a4dc5e5a047c5698c571 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:42:43 2018 +0300 Added type cast commit c63fc5d5f19c58498108d1698055b2b442227eb3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:36:51 2018 +0300 Moved static class members initialization into the proper place. commit b945548e9306b1826c881918858b5e5aa3eb3002 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:21:03 2018 +0300 Removed redundand assertion commit d5a41088401814c829847db212488f8aae39bcd2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:19:13 2018 +0300 Removed duplicate code commit 8dadca8864e66de70a24bdf1181bcf7dd8fb27d7 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:05:43 2018 +0300 Hide offset encoding magic in ZEND_MAP_PTR_IS_OFFSET(), ZEND_MAP_PTR_OFFSET2PTR() and ZEND_MAP_PTR_PTR2OFFSET() macros. commit 9ef07c88bd76801e2d4fbfeab3ebfd6e6a67ac5f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 10:48:29 2018 +0300 typo commit a06f0f3d3aba53e766046221ee44fb9720389ecc Merge: 94099586ec 3412345ffe Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 10:47:07 2018 +0300 Merge branch 'master' into immutable * master: Remove unused variable makefile_am_files Classify object handlers are required/optional Add support for getting SKIP_TAGSTART and SKIP_WHITE options Remove some obsolete config_vars.mk occurrences Remove bsd_converted from .gitignore Remove configuration parser and scanners ignores Remove obsolete buildconf.stamp from .gitignore [ci skip] Add magicdata.patch exception to .gitignore Remove outdated ext/spl/examples items from .gitignore Remove unused test.inc in ext/iconv/tests commit 94099586ec599117581ca01c15b1f6c5f749e23a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Oct 15 23:34:01 2018 +0300 Immutable clases and op_arrays
2018-10-17 20:52:50 +08:00
src = CE_STATIC_MEMBERS(parent_ce) + parent_ce->default_static_members_count;
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
do {
dst--;
src--;
Fixed bug #76509 In PHP static properties are shared between inheriting classes, unless they are explicitly overwritten. However, because this functionality was implemented using reference, it was possible to break the implementation by reassigning the static property reference. This is fixed by switching the implementation from using references to using INDIRECTs, which cannot be affected by userland code.
2018-06-22 18:58:48 +08:00
if (Z_TYPE_P(src) == IS_INDIRECT) {
ZVAL_INDIRECT(dst, Z_INDIRECT_P(src));
Cheaper reference construction
2017-12-26 18:30:25 +08:00
} else {
Fixed bug #76509 In PHP static properties are shared between inheriting classes, unless they are explicitly overwritten. However, because this functionality was implemented using reference, it was possible to break the implementation by reassigning the static property reference. This is fixed by switching the implementation from using references to using INDIRECTs, which cannot be affected by userland code.
2018-06-22 18:58:48 +08:00
ZVAL_INDIRECT(dst, src);
Cheaper reference construction
2017-12-26 18:30:25 +08:00
}
Fixed bug #76509 In PHP static properties are shared between inheriting classes, unless they are explicitly overwritten. However, because this functionality was implemented using reference, it was possible to break the implementation by reassigning the static property reference. This is fixed by switching the implementation from using references to using INDIRECTs, which cannot be affected by userland code.
2018-06-22 18:58:48 +08:00
if (Z_TYPE_P(Z_INDIRECT_P(dst)) == IS_CONSTANT_AST) {
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
}
} while (dst != end);
} else {
src = parent_ce->default_static_members_table + parent_ce->default_static_members_count;
do {
dst--;
src--;
Fixed bug #76509 In PHP static properties are shared between inheriting classes, unless they are explicitly overwritten. However, because this functionality was implemented using reference, it was possible to break the implementation by reassigning the static property reference. This is fixed by switching the implementation from using references to using INDIRECTs, which cannot be affected by userland code.
2018-06-22 18:58:48 +08:00
if (Z_TYPE_P(src) == IS_INDIRECT) {
ZVAL_INDIRECT(dst, Z_INDIRECT_P(src));
} else {
ZVAL_INDIRECT(dst, src);
Fixed Issue #1400 (double free static property)
2015-07-10 15:27:06 +08:00
}
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
} while (dst != end);
}
Improved property inheritance code
2015-04-22 17:53:54 +08:00
ce->default_static_members_count += parent_ce->default_static_members_count;
Immutable clases and op_arrays. Squashed commit of the following: commit cd0c36c3f943849e5b97a8dbe2dd029fbeab3df9 Merge: 4740dabb84 ad6738e886 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 14:43:38 2018 +0300 Merge branch 'master' into immutable * master: Remove the "auto" encoding Fixed bug #77025 Add vtbls for EUC-TW encoding commit 4740dabb843c6d4f7f866b4a2456073c9eaf4c77 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 14:12:28 2018 +0300 Reverted back ce->iterator_funcs_ptr. Initialize ce->iterator_funcs_ptr fields in immutable classes. commit ad7a78b253be970db70c2251e66f9297d8e7f829 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:46:30 2018 +0300 Added comment commit 0276ea51875bab37be01a4dc5e5a047c5698c571 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:42:43 2018 +0300 Added type cast commit c63fc5d5f19c58498108d1698055b2b442227eb3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:36:51 2018 +0300 Moved static class members initialization into the proper place. commit b945548e9306b1826c881918858b5e5aa3eb3002 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:21:03 2018 +0300 Removed redundand assertion commit d5a41088401814c829847db212488f8aae39bcd2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:19:13 2018 +0300 Removed duplicate code commit 8dadca8864e66de70a24bdf1181bcf7dd8fb27d7 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:05:43 2018 +0300 Hide offset encoding magic in ZEND_MAP_PTR_IS_OFFSET(), ZEND_MAP_PTR_OFFSET2PTR() and ZEND_MAP_PTR_PTR2OFFSET() macros. commit 9ef07c88bd76801e2d4fbfeab3ebfd6e6a67ac5f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 10:48:29 2018 +0300 typo commit a06f0f3d3aba53e766046221ee44fb9720389ecc Merge: 94099586ec 3412345ffe Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 10:47:07 2018 +0300 Merge branch 'master' into immutable * master: Remove unused variable makefile_am_files Classify object handlers are required/optional Add support for getting SKIP_TAGSTART and SKIP_WHITE options Remove some obsolete config_vars.mk occurrences Remove bsd_converted from .gitignore Remove configuration parser and scanners ignores Remove obsolete buildconf.stamp from .gitignore [ci skip] Add magicdata.patch exception to .gitignore Remove outdated ext/spl/examples items from .gitignore Remove unused test.inc in ext/iconv/tests commit 94099586ec599117581ca01c15b1f6c5f749e23a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Oct 15 23:34:01 2018 +0300 Immutable clases and op_arrays
2018-10-17 20:52:50 +08:00
if (!ZEND_MAP_PTR(ce->static_members_table)) {
ZEND_ASSERT(ce->type == ZEND_INTERNAL_CLASS);
if (!EG(current_execute_data)) {
ZEND_MAP_PTR_NEW(ce->static_members_table);
} else {
/* internal class loaded by dl() */
ZEND_MAP_PTR_INIT(ce->static_members_table, &ce->default_static_members_table);
Allocate only necessary space for static properties of internal classes in ZTS mode.
2018-10-02 00:05:31 +08:00
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
ZEND_HASH_FOREACH_PTR(&ce->properties_info, property_info) {
if (property_info->ce == ce) {
if (property_info->flags & ZEND_ACC_STATIC) {
property_info->offset += parent_ce->default_static_members_count;
} else {
Improved object property access.
2014-11-06 19:50:03 +08:00
property_info->offset += parent_ce->default_properties_count * sizeof(zval);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
} ZEND_HASH_FOREACH_END();
Improved ineritance code
2015-03-05 04:06:07 +08:00
if (zend_hash_num_elements(&parent_ce->properties_info)) {
zend_hash_extend(&ce->properties_info,
zend_hash_num_elements(&ce->properties_info) +
zend_hash_num_elements(&parent_ce->properties_info), 0);
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
Improved ineritance code
2015-03-05 04:06:07 +08:00
ZEND_HASH_FOREACH_STR_KEY_PTR(&parent_ce->properties_info, key, property_info) {
do_inherit_property(property_info, key, ce);
} ZEND_HASH_FOREACH_END();
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Improved ineritance code
2015-03-05 04:06:07 +08:00
if (zend_hash_num_elements(&parent_ce->constants_table)) {
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
zend_class_constant *c;
Improved ineritance code
2015-03-05 04:06:07 +08:00
zend_hash_extend(&ce->constants_table,
zend_hash_num_elements(&ce->constants_table) +
zend_hash_num_elements(&parent_ce->constants_table), 0);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
ZEND_HASH_FOREACH_STR_KEY_PTR(&parent_ce->constants_table, key, c) {
do_inherit_class_constant(key, c, ce);
Improved ineritance code
2015-03-05 04:06:07 +08:00
} ZEND_HASH_FOREACH_END();
}
if (zend_hash_num_elements(&parent_ce->function_table)) {
zend_hash_extend(&ce->function_table,
zend_hash_num_elements(&ce->function_table) +
zend_hash_num_elements(&parent_ce->function_table), 0);
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (checked) {
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
ZEND_HASH_FOREACH_STR_KEY_PTR(&parent_ce->function_table, key, func) {
do_inherit_method(key, func, ce, 0, 1);
} ZEND_HASH_FOREACH_END();
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
} else {
ZEND_HASH_FOREACH_STR_KEY_PTR(&parent_ce->function_table, key, func) {
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
do_inherit_method(key, func, ce, 0, 0);
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
} ZEND_HASH_FOREACH_END();
}
Improved ineritance code
2015-03-05 04:06:07 +08:00
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
do_inherit_parent_constructor(ce);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Cleanup class linking
2018-08-27 21:40:25 +08:00
if (ce->type == ZEND_INTERNAL_CLASS) {
Implement interfaces after all methods available The place where interface implementation handlers is called is currently ill-defined: If the class implements interfaces itself, the handlers for both the parent interfaces and the new interfaces will be called after all methods are registered (post trait use). If the class does not implement interfaces, then the parent interface handlers are called early during inheritance (before methods are inherited). This commit moves the calls to always occur after all methods are available. For userland classes this will be post trait import, at the time where interfaces get implemented (whether the class itself defines additional interfaces or not). For internal classes it will be at the end of inheritance, as internal class declarations do not have proper finalization. This allows us to simplify the logic for implementing the magic Iterator / IteratorAggregate interfaces. In particularly we can now also automatically detect whether an extension of IteratorAggregate can safely reuse a custom get_iterator handler, or whether it needs to switch to the userland mechanism. The Iterator case continues to rely on ZEND_ACC_REUSE_GET_ITERATOR for this purpose, as a wholesale replacement is not possible there.
2020-03-04 17:10:36 +08:00
if (parent_ce->num_interfaces) {
zend_do_inherit_interfaces(ce, parent_ce);
}
Cleanup class linking
2018-08-27 21:40:25 +08:00
if (ce->ce_flags & ZEND_ACC_IMPLICIT_ABSTRACT_CLASS) {
ce->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
ce->ce_flags |= parent_ce->ce_flags & (ZEND_HAS_STATIC_IN_METHODS | ZEND_ACC_HAS_TYPE_HINTS | ZEND_ACC_USE_GUARDS);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
static zend_bool do_inherit_constant_check(HashTable *child_constants_table, zend_class_constant *parent_constant, zend_string *name, const zend_class_entry *iface) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Introduced zend_hash_find_ex() that may avoid unnecessary hash value check.
2017-11-24 19:01:19 +08:00
zval *zv = zend_hash_find_ex(child_constants_table, name, 1);
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
zend_class_constant *old_constant;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Introduced zend_hash_find_ex() that may avoid unnecessary hash value check.
2017-11-24 19:01:19 +08:00
if (zv != NULL) {
old_constant = (zend_class_constant*)Z_PTR_P(zv);
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
if (old_constant->ce != parent_constant->ce) {
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Cannot inherit previously-inherited or override constant %s from interface %s", ZSTR_VAL(name), ZSTR_VAL(iface->name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
return 0;
}
return 1;
}
/* }}} */
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
static void do_inherit_iface_constant(zend_string *name, zend_class_constant *c, zend_class_entry *ce, zend_class_entry *iface) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
if (do_inherit_constant_check(&ce->constants_table, c, name, iface)) {
Fixed bug #71413 (Crash with constants on internal interfaces)
2016-01-21 13:30:41 +08:00
zend_class_constant *ct;
Always use IS_CONSTANT_AST (IS_CONSTANT is removed).
2017-10-10 15:11:05 +08:00
if (Z_TYPE(c->value) == IS_CONSTANT_AST) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
}
Fixed use-after free introduced in fcc08ce19f39f7ab1381ecc8a010037d41819329
2017-10-31 06:20:38 +08:00
if (ce->type & ZEND_INTERNAL_CLASS) {
ct = pemalloc(sizeof(zend_class_constant), 1);
memcpy(ct, c, sizeof(zend_class_constant));
c = ct;
}
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
zend_hash_update_ptr(&ce->constants_table, name, c);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
/* }}} */
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
static void do_interface_implementation(zend_class_entry *ce, zend_class_entry *iface) /* {{{ */
{
zend_function *func;
zend_string *key;
zend_class_constant *c;
ZEND_HASH_FOREACH_STR_KEY_PTR(&iface->constants_table, key, c) {
do_inherit_iface_constant(key, c, ce, iface);
} ZEND_HASH_FOREACH_END();
ZEND_HASH_FOREACH_STR_KEY_PTR(&iface->function_table, key, func) {
do_inherit_method(key, func, ce, 1, 0);
} ZEND_HASH_FOREACH_END();
do_implement_interface(ce, iface);
if (iface->num_interfaces) {
zend_do_inherit_interfaces(ce, iface);
}
}
/* }}} */
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry *iface) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
uint32_t i, ignore = 0;
uint32_t current_iface_num = ce->num_interfaces;
uint32_t parent_iface_num = ce->parent ? ce->parent->num_interfaces : 0;
zend_string *key;
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
zend_class_constant *c;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Replace ZEND_ACC_ANON_BOUND, ZEND_ACC_UNRESOLVED_PARENT and ZEND_ACC_UNRESOLVED_INTERFACES with single ZEND_ACC_LINKED.
2018-09-18 16:41:40 +08:00
ZEND_ASSERT(ce->ce_flags & ZEND_ACC_LINKED);
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
for (i = 0; i < ce->num_interfaces; i++) {
if (ce->interfaces[i] == NULL) {
memmove(ce->interfaces + i, ce->interfaces + i + 1, sizeof(zend_class_entry*) * (--ce->num_interfaces - i));
i--;
} else if (ce->interfaces[i] == iface) {
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(i < parent_iface_num)) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
ignore = 1;
} else {
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot implement previously implemented interface %s", ZSTR_VAL(ce->name), ZSTR_VAL(iface->name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
}
if (ignore) {
/* Check for attempt to redeclare interface constants */
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->constants_table, key, c) {
do_inherit_constant_check(&iface->constants_table, c, key, iface);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} ZEND_HASH_FOREACH_END();
} else {
if (ce->num_interfaces >= current_iface_num) {
if (ce->type == ZEND_INTERNAL_CLASS) {
ce->interfaces = (zend_class_entry **) realloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num));
} else {
ce->interfaces = (zend_class_entry **) erealloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num));
}
}
ce->interfaces[ce->num_interfaces++] = iface;
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
do_interface_implementation(ce, iface);
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
}
}
/* }}} */
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
static void zend_do_implement_interfaces(zend_class_entry *ce, zend_class_entry **interfaces) /* {{{ */
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
{
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
zend_class_entry *iface;
uint32_t num_parent_interfaces = ce->parent ? ce->parent->num_interfaces : 0;
uint32_t num_interfaces = num_parent_interfaces;
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
zend_string *key;
zend_class_constant *c;
uint32_t i, j;
for (i = 0; i < ce->num_interfaces; i++) {
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
iface = interfaces[num_parent_interfaces + i];
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
if (!(iface->ce_flags & ZEND_ACC_LINKED)) {
add_dependency_obligation(ce, iface);
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
}
if (UNEXPECTED(!(iface->ce_flags & ZEND_ACC_INTERFACE))) {
efree(interfaces);
zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ZSTR_VAL(ce->name), ZSTR_VAL(iface->name));
return;
}
for (j = 0; j < num_interfaces; j++) {
if (interfaces[j] == iface) {
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
if (j >= num_parent_interfaces) {
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
efree(interfaces);
zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot implement previously implemented interface %s", ZSTR_VAL(ce->name), ZSTR_VAL(iface->name));
return;
}
/* skip duplications */
ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->constants_table, key, c) {
do_inherit_constant_check(&iface->constants_table, c, key, iface);
} ZEND_HASH_FOREACH_END();
iface = NULL;
break;
}
}
if (iface) {
interfaces[num_interfaces] = iface;
num_interfaces++;
}
}
for (i = 0; i < ce->num_interfaces; i++) {
zend_string_release_ex(ce->interface_names[i].name, 0);
zend_string_release_ex(ce->interface_names[i].lc_name, 0);
}
efree(ce->interface_names);
ce->num_interfaces = num_interfaces;
ce->interfaces = interfaces;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
ce->ce_flags |= ZEND_ACC_RESOLVED_INTERFACES;
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
Implement interfaces after all methods available The place where interface implementation handlers is called is currently ill-defined: If the class implements interfaces itself, the handlers for both the parent interfaces and the new interfaces will be called after all methods are registered (post trait use). If the class does not implement interfaces, then the parent interface handlers are called early during inheritance (before methods are inherited). This commit moves the calls to always occur after all methods are available. For userland classes this will be post trait import, at the time where interfaces get implemented (whether the class itself defines additional interfaces or not). For internal classes it will be at the end of inheritance, as internal class declarations do not have proper finalization. This allows us to simplify the logic for implementing the magic Iterator / IteratorAggregate interfaces. In particularly we can now also automatically detect whether an extension of IteratorAggregate can safely reuse a custom get_iterator handler, or whether it needs to switch to the userland mechanism. The Iterator case continues to rely on ZEND_ACC_REUSE_GET_ITERATOR for this purpose, as a wholesale replacement is not possible there.
2020-03-04 17:10:36 +08:00
for (i = 0; i < num_parent_interfaces; i++) {
do_implement_interface(ce, ce->interfaces[i]);
}
Avoid duplicate calls to interface implementation handler
2020-02-28 19:16:41 +08:00
/* Note that new interfaces can be added during this loop due to interface inheritance.
* Use num_interfaces rather than ce->num_interfaces to not re-process the new ones. */
for (; i < num_interfaces; i++) {
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
do_interface_implementation(ce, ce->interfaces[i]);
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
static zend_class_entry *fixup_trait_scope(const zend_function *fn, zend_class_entry *ce)
{
/* self in trait methods should be resolved to the using class, not the trait. */
return fn->common.scope->ce_flags & ZEND_ACC_TRAIT ? ce : fn->common.scope;
}
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
static void zend_add_trait_method(zend_class_entry *ce, zend_string *name, zend_string *key, zend_function *fn) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
zend_function *existing_fn = NULL;
zend_function *new_fn;
if ((existing_fn = zend_hash_find_ptr(&ce->function_table, key)) != NULL) {
Fix #76773 - Methods with a concrete scope need to be added again
2018-08-22 00:40:06 +08:00
/* if it is the same function with the same visibility and has not been assigned a class scope yet, regardless
* of where it is coming from there is no conflict and we do not need to add it again */
Fix #76700 - Methods with altered visibility need to be added again
2018-08-04 00:30:03 +08:00
if (existing_fn->op_array.opcodes == fn->op_array.opcodes &&
Fix #76773 - Methods with a concrete scope need to be added again
2018-08-22 00:40:06 +08:00
(existing_fn->common.fn_flags & ZEND_ACC_PPP_MASK) == (fn->common.fn_flags & ZEND_ACC_PPP_MASK) &&
(existing_fn->common.scope->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
63911: Compare opcodes of the op_array to determine different functions
2017-10-01 04:24:38 +08:00
return;
}
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
/* Abstract method signatures from the trait must be satisfied. */
if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
/* "abstract private" methods in traits were not available prior to PHP 8.
* As such, "abstract protected" was sometimes used to indicate trait requirements,
* even though the "implementing" method was private. Do not check visibility
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
* requirements to maintain backwards-compatibility with such usage.
*/
do_inheritance_check_on_method(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
existing_fn, fixup_trait_scope(existing_fn, ce), fn, fixup_trait_scope(fn, ce),
ce, NULL, /* check_visibility */ 0);
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
return;
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if (existing_fn->common.scope == ce) {
/* members from the current class override trait methods */
return;
Fixed bug #78776 By using the normal inheritance check if the parent is abstract as well.
2019-12-18 22:53:09 +08:00
} else if (UNEXPECTED((existing_fn->common.scope->ce_flags & ZEND_ACC_TRAIT)
&& !(existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT))) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* two traits can't define the same non-abstract method */
zend_error_noreturn(E_COMPILE_ERROR, "Trait method %s::%s has not been applied as %s::%s, because of collision with %s::%s",
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
ZSTR_VAL(fn->common.scope->name), ZSTR_VAL(fn->common.function_name),
Store aliased name of trait method Currently, trait methods are aliased will continue to use the original function name. In a few places in the codebase, we will try to look up the actual method name instead. However, this does not work if an aliased method is used indirectly (https://bugs.php.net/bug.php?id=69180). I think it would be better to instead actually change the method name to the alias. This is in principle easy: We have to allow function_name to be changed even if op array is otherwise shared (similar to static_variables). This means we need to addref/release the function_name separately, but I don't think there is a performance concern here (especially as everything is usually interned). There is a bit of complication in opcache, where we need to make sure that the function name is released the correct number of times (interning may overwrite the name in the original op_array, but we need to release it as many times as the op_array is shared). Fixes bug #69180. Fixes bug #74939. Closes GH-5226.
2020-03-02 18:07:57 +08:00
ZSTR_VAL(ce->name), ZSTR_VAL(name),
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
ZSTR_VAL(existing_fn->common.scope->name), ZSTR_VAL(existing_fn->common.function_name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else {
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
/* Inherited members are overridden by members inserted by traits.
* Check whether the trait method fulfills the inheritance requirements. */
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
do_inheritance_check_on_method(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
fn, fixup_trait_scope(fn, ce), existing_fn, fixup_trait_scope(existing_fn, ce),
ce, NULL, /* check_visibility */ 1);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
Fixed incorrect ZEND_ACC_ARENA_ALLOCATED usage (it must be used only for internal functions).
2018-08-30 04:40:17 +08:00
if (UNEXPECTED(fn->type == ZEND_INTERNAL_FUNCTION)) {
new_fn = zend_arena_alloc(&CG(arena), sizeof(zend_internal_function));
memcpy(new_fn, fn, sizeof(zend_internal_function));
new_fn->common.fn_flags |= ZEND_ACC_ARENA_ALLOCATED;
} else {
new_fn = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
memcpy(new_fn, fn, sizeof(zend_op_array));
Fixed issues related to optimization and persitence of classes linked with interfaces, traits or internal classes.
2018-11-14 21:32:07 +08:00
new_fn->op_array.fn_flags |= ZEND_ACC_TRAIT_CLONE;
Immutable clases and op_arrays. Squashed commit of the following: commit cd0c36c3f943849e5b97a8dbe2dd029fbeab3df9 Merge: 4740dabb84 ad6738e886 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 14:43:38 2018 +0300 Merge branch 'master' into immutable * master: Remove the "auto" encoding Fixed bug #77025 Add vtbls for EUC-TW encoding commit 4740dabb843c6d4f7f866b4a2456073c9eaf4c77 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 14:12:28 2018 +0300 Reverted back ce->iterator_funcs_ptr. Initialize ce->iterator_funcs_ptr fields in immutable classes. commit ad7a78b253be970db70c2251e66f9297d8e7f829 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:46:30 2018 +0300 Added comment commit 0276ea51875bab37be01a4dc5e5a047c5698c571 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:42:43 2018 +0300 Added type cast commit c63fc5d5f19c58498108d1698055b2b442227eb3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:36:51 2018 +0300 Moved static class members initialization into the proper place. commit b945548e9306b1826c881918858b5e5aa3eb3002 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:21:03 2018 +0300 Removed redundand assertion commit d5a41088401814c829847db212488f8aae39bcd2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:19:13 2018 +0300 Removed duplicate code commit 8dadca8864e66de70a24bdf1181bcf7dd8fb27d7 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:05:43 2018 +0300 Hide offset encoding magic in ZEND_MAP_PTR_IS_OFFSET(), ZEND_MAP_PTR_OFFSET2PTR() and ZEND_MAP_PTR_PTR2OFFSET() macros. commit 9ef07c88bd76801e2d4fbfeab3ebfd6e6a67ac5f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 10:48:29 2018 +0300 typo commit a06f0f3d3aba53e766046221ee44fb9720389ecc Merge: 94099586ec 3412345ffe Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 10:47:07 2018 +0300 Merge branch 'master' into immutable * master: Remove unused variable makefile_am_files Classify object handlers are required/optional Add support for getting SKIP_TAGSTART and SKIP_WHITE options Remove some obsolete config_vars.mk occurrences Remove bsd_converted from .gitignore Remove configuration parser and scanners ignores Remove obsolete buildconf.stamp from .gitignore [ci skip] Add magicdata.patch exception to .gitignore Remove outdated ext/spl/examples items from .gitignore Remove unused test.inc in ext/iconv/tests commit 94099586ec599117581ca01c15b1f6c5f749e23a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Oct 15 23:34:01 2018 +0300 Immutable clases and op_arrays
2018-10-17 20:52:50 +08:00
new_fn->op_array.fn_flags &= ~ZEND_ACC_IMMUTABLE;
Fixed incorrect ZEND_ACC_ARENA_ALLOCATED usage (it must be used only for internal functions).
2018-08-30 04:40:17 +08:00
}
Store aliased name of trait method Currently, trait methods are aliased will continue to use the original function name. In a few places in the codebase, we will try to look up the actual method name instead. However, this does not work if an aliased method is used indirectly (https://bugs.php.net/bug.php?id=69180). I think it would be better to instead actually change the method name to the alias. This is in principle easy: We have to allow function_name to be changed even if op array is otherwise shared (similar to static_variables). This means we need to addref/release the function_name separately, but I don't think there is a performance concern here (especially as everything is usually interned). There is a bit of complication in opcache, where we need to make sure that the function name is released the correct number of times (interning may overwrite the name in the original op_array, but we need to release it as many times as the op_array is shared). Fixes bug #69180. Fixes bug #74939. Closes GH-5226.
2020-03-02 18:07:57 +08:00
/* Reassign method name, in case it is an alias. */
new_fn->common.function_name = name;
Call function_add_ref() in proper place
2018-10-30 20:08:45 +08:00
function_add_ref(new_fn);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
fn = zend_hash_update_ptr(&ce->function_table, key, new_fn);
Add common code for magic method assignment This was repeated three times.
2020-07-20 20:56:48 +08:00
zend_add_magic_method(ce, fn, key);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
static void zend_fixup_trait_method(zend_function *fn, zend_class_entry *ce) /* {{{ */
{
if ((fn->common.scope->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
fn->common.scope = ce;
if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
}
Fixed #69566 in master
2015-05-04 10:35:55 +08:00
if (fn->type == ZEND_USER_FUNCTION && fn->op_array.static_variables) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
ce->ce_flags |= ZEND_HAS_STATIC_IN_METHODS;
}
}
}
/* }}} */
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
static void zend_traits_copy_functions(zend_string *fnname, zend_function *fn, zend_class_entry *ce, HashTable *exclude_table, zend_class_entry **aliases) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
zend_trait_alias *alias, **alias_ptr;
zend_string *lcname;
zend_function fn_copy;
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
int i;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* apply aliases which are qualified with a class name, there should not be any ambiguity */
if (ce->trait_aliases) {
alias_ptr = ce->trait_aliases;
alias = *alias_ptr;
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
i = 0;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
while (alias) {
/* Scope unset or equal to the function we compare to, and the alias applies to fn */
if (alias->alias != NULL
Resolve trait alias refers to earlier Make sure all trait method references are converted to absolute method references in advance. This regresses one error message that I don't think is particularly valuable.
2020-03-03 21:21:33 +08:00
&& fn->common.scope == aliases[i]
&& zend_string_equals_ci(alias->trait_method.method_name, fnname)
) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
fn_copy = *fn;
/* if it is 0, no modifieres has been changed */
if (alias->modifiers) {
Small code cleanup I found what the modifier code does with XOR pretty confusing. It's just removing the PPP bits... Also remove an outdated reference to OVERLOADED_FUNCTION.
2020-03-03 22:00:15 +08:00
fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags & ~ZEND_ACC_PPP_MASK);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Added new API function 'zend_string* zend_string_tolower(zend_string*)'. It simplifies code and avoids unnecessary allocation and copying if string is already in lower case.
2014-12-24 20:04:51 +08:00
lcname = zend_string_tolower(alias->alias);
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
zend_add_trait_method(ce, alias->alias, lcname, &fn_copy);
Use zend_string_release_ex() instread of zend_string_release() in places, where we sure about string persistence.
2018-05-28 21:27:12 +08:00
zend_string_release_ex(lcname, 0);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
alias_ptr++;
alias = *alias_ptr;
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
i++;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
if (exclude_table == NULL || zend_hash_find(exclude_table, fnname) == NULL) {
/* is not in hashtable, thus, function is not to be excluded */
Small code cleanup I found what the modifier code does with XOR pretty confusing. It's just removing the PPP bits... Also remove an outdated reference to OVERLOADED_FUNCTION.
2020-03-03 22:00:15 +08:00
memcpy(&fn_copy, fn, fn->type == ZEND_USER_FUNCTION ? sizeof(zend_op_array) : sizeof(zend_internal_function));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* apply aliases which have not alias name, just setting visibility */
if (ce->trait_aliases) {
alias_ptr = ce->trait_aliases;
alias = *alias_ptr;
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
i = 0;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
while (alias) {
/* Scope unset or equal to the function we compare to, and the alias applies to fn */
if (alias->alias == NULL && alias->modifiers != 0
Resolve trait alias refers to earlier Make sure all trait method references are converted to absolute method references in advance. This regresses one error message that I don't think is particularly valuable.
2020-03-03 21:21:33 +08:00
&& fn->common.scope == aliases[i]
&& zend_string_equals_ci(alias->trait_method.method_name, fnname)
) {
Small code cleanup I found what the modifier code does with XOR pretty confusing. It's just removing the PPP bits... Also remove an outdated reference to OVERLOADED_FUNCTION.
2020-03-03 22:00:15 +08:00
fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags & ~ZEND_ACC_PPP_MASK);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
alias_ptr++;
alias = *alias_ptr;
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
i++;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
zend_add_trait_method(ce, fn->common.function_name, fnname, &fn_copy);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
/* }}} */
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
static uint32_t zend_check_trait_usage(zend_class_entry *ce, zend_class_entry *trait, zend_class_entry **traits) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
uint32_t i;
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (UNEXPECTED((trait->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT)) {
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Class %s is not a trait, Only traits may be used in 'as' and 'insteadof' statements", ZSTR_VAL(trait->name));
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
return 0;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
for (i = 0; i < ce->num_traits; i++) {
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
if (traits[i] == trait) {
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
return i;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Required Trait %s wasn't added to %s", ZSTR_VAL(trait->name), ZSTR_VAL(ce->name));
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
return 0;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
static void zend_traits_init_trait_structures(zend_class_entry *ce, zend_class_entry **traits, HashTable ***exclude_tables_ptr, zend_class_entry ***aliases_ptr) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
size_t i, j = 0;
Merge branch 'PHP-5.6'
2015-03-05 21:06:59 +08:00
zend_trait_precedence **precedences;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
zend_trait_precedence *cur_precedence;
zend_trait_method_reference *cur_method_ref;
zend_string *lcname;
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
HashTable **exclude_tables = NULL;
zend_class_entry **aliases = NULL;
zend_class_entry *trait;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* resolve class references */
if (ce->trait_precedences) {
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
exclude_tables = ecalloc(ce->num_traits, sizeof(HashTable*));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
i = 0;
Merge branch 'PHP-5.6'
2015-03-05 21:06:59 +08:00
precedences = ce->trait_precedences;
ce->trait_precedences = NULL;
while ((cur_precedence = precedences[i])) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/** Resolve classes for all precedence operations. */
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
cur_method_ref = &cur_precedence->trait_method;
trait = zend_fetch_class(cur_method_ref->class_name,
ZEND_FETCH_CLASS_TRAIT|ZEND_FETCH_CLASS_NO_AUTOLOAD);
if (!trait) {
zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", ZSTR_VAL(cur_method_ref->class_name));
}
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
zend_check_trait_usage(ce, trait, traits);
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
/** Ensure that the preferred method is actually available. */
lcname = zend_string_tolower(cur_method_ref->method_name);
Micro-optimization
2018-09-19 18:54:37 +08:00
if (!zend_hash_exists(&trait->function_table, lcname)) {
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
zend_error_noreturn(E_COMPILE_ERROR,
"A precedence rule was defined for %s::%s but this method does not exist",
ZSTR_VAL(trait->name),
ZSTR_VAL(cur_method_ref->method_name));
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
/** With the other traits, we are more permissive.
We do not give errors for those. This allows to be more
defensive in such definitions.
However, we want to make sure that the insteadof declaration
is consistent in itself.
*/
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
for (j = 0; j < cur_precedence->num_excludes; j++) {
zend_string* class_name = cur_precedence->exclude_class_names[j];
zend_class_entry *exclude_ce = zend_fetch_class(class_name, ZEND_FETCH_CLASS_TRAIT |ZEND_FETCH_CLASS_NO_AUTOLOAD);
uint32_t trait_num;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
if (!exclude_ce) {
zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", ZSTR_VAL(class_name));
}
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
trait_num = zend_check_trait_usage(ce, exclude_ce, traits);
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
if (!exclude_tables[trait_num]) {
ALLOC_HASHTABLE(exclude_tables[trait_num]);
zend_hash_init(exclude_tables[trait_num], 0, NULL, NULL, 0);
}
if (zend_hash_add_empty_element(exclude_tables[trait_num], lcname) == NULL) {
zend_error_noreturn(E_COMPILE_ERROR, "Failed to evaluate a trait precedence (%s). Method of trait %s was defined to be excluded multiple times", ZSTR_VAL(precedences[i]->trait_method.method_name), ZSTR_VAL(exclude_ce->name));
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
/* make sure that the trait method is not from a class mentioned in
exclude_from_classes, for consistency */
if (trait == exclude_ce) {
zend_error_noreturn(E_COMPILE_ERROR,
"Inconsistent insteadof definition. "
"The method %s is to be used from %s, but %s is also on the exclude list",
ZSTR_VAL(cur_method_ref->method_name),
ZSTR_VAL(trait->name),
ZSTR_VAL(trait->name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
zend_string_release_ex(lcname, 0);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
i++;
}
Merge branch 'PHP-5.6'
2015-03-05 21:06:59 +08:00
ce->trait_precedences = precedences;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
if (ce->trait_aliases) {
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
i = 0;
while (ce->trait_aliases[i]) {
i++;
}
aliases = ecalloc(i, sizeof(zend_class_entry*));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
i = 0;
while (ce->trait_aliases[i]) {
Resolve trait alias refers to earlier Make sure all trait method references are converted to absolute method references in advance. This regresses one error message that I don't think is particularly valuable.
2020-03-03 21:21:33 +08:00
zend_trait_alias *cur_alias = ce->trait_aliases[i];
cur_method_ref = &ce->trait_aliases[i]->trait_method;
lcname = zend_string_tolower(cur_method_ref->method_name);
if (cur_method_ref->class_name) {
/* For all aliases with an explicit class name, resolve the class now. */
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
trait = zend_fetch_class(cur_method_ref->class_name, ZEND_FETCH_CLASS_TRAIT|ZEND_FETCH_CLASS_NO_AUTOLOAD);
if (!trait) {
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", ZSTR_VAL(cur_method_ref->class_name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
zend_check_trait_usage(ce, trait, traits);
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
aliases[i] = trait;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Resolve trait alias refers to earlier Make sure all trait method references are converted to absolute method references in advance. This regresses one error message that I don't think is particularly valuable.
2020-03-03 21:21:33 +08:00
/* And, ensure that the referenced method is resolvable, too. */
Micro-optimization
2018-09-19 18:54:37 +08:00
if (!zend_hash_exists(&trait->function_table, lcname)) {
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "An alias was defined for %s::%s but this method does not exist", ZSTR_VAL(trait->name), ZSTR_VAL(cur_method_ref->method_name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Resolve trait alias refers to earlier Make sure all trait method references are converted to absolute method references in advance. This regresses one error message that I don't think is particularly valuable.
2020-03-03 21:21:33 +08:00
} else {
/* Find out which trait this method refers to. */
trait = NULL;
for (j = 0; j < ce->num_traits; j++) {
if (traits[j]) {
if (zend_hash_exists(&traits[j]->function_table, lcname)) {
if (!trait) {
trait = traits[j];
continue;
}
Require non-absolute trait method refs to be unambiguous Currently, when writing something like class X { use T1, T2 { func as otherFunc; } function func() {} } where both T1::func() and T2::func() exist, we will simply assume that func refers to T1::func(). This is surprising, and it doesn't really make sense that this particular method gets picked. This commit validates that non-absolute method references are unambiguous, i.e. refer to exactly one method. If there is ambiguity, it is required to write T1::func as otherFunc or similar. Closes GH-5232.
2020-03-03 21:31:09 +08:00
zend_error_noreturn(E_COMPILE_ERROR,
"An alias was defined for method %s(), which exists in both %s and %s. Use %s::%s or %s::%s to resolve the ambiguity",
ZSTR_VAL(cur_method_ref->method_name),
ZSTR_VAL(trait->name), ZSTR_VAL(traits[j]->name),
ZSTR_VAL(trait->name), ZSTR_VAL(cur_method_ref->method_name),
ZSTR_VAL(traits[j]->name), ZSTR_VAL(cur_method_ref->method_name));
Resolve trait alias refers to earlier Make sure all trait method references are converted to absolute method references in advance. This regresses one error message that I don't think is particularly valuable.
2020-03-03 21:21:33 +08:00
}
}
}
/* Non-absolute method reference refers to method that does not exist. */
if (!trait) {
if (cur_alias->alias) {
zend_error_noreturn(E_COMPILE_ERROR,
"An alias (%s) was defined for method %s(), but this method does not exist",
ZSTR_VAL(cur_alias->alias),
ZSTR_VAL(cur_alias->trait_method.method_name));
} else {
zend_error_noreturn(E_COMPILE_ERROR,
"The modifiers of the trait method %s() are changed, but this method does not exist. Error",
ZSTR_VAL(cur_alias->trait_method.method_name));
}
}
aliases[i] = trait;
/* TODO: try to avoid this assignment (it's necessary only for reflection) */
cur_method_ref->class_name = zend_string_copy(trait->name);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Resolve trait alias refers to earlier Make sure all trait method references are converted to absolute method references in advance. This regresses one error message that I don't think is particularly valuable.
2020-03-03 21:21:33 +08:00
zend_string_release_ex(lcname, 0);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
i++;
}
}
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
*exclude_tables_ptr = exclude_tables;
*aliases_ptr = aliases;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
static void zend_do_traits_method_binding(zend_class_entry *ce, zend_class_entry **traits, HashTable **exclude_tables, zend_class_entry **aliases) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
uint32_t i;
zend_string *key;
zend_function *fn;
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
if (exclude_tables) {
for (i = 0; i < ce->num_traits; i++) {
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
if (traits[i]) {
/* copies functions, applies defined aliasing, and excludes unused trait methods */
ZEND_HASH_FOREACH_STR_KEY_PTR(&traits[i]->function_table, key, fn) {
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
zend_traits_copy_functions(key, fn, ce, exclude_tables[i], aliases);
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
} ZEND_HASH_FOREACH_END();
if (exclude_tables[i]) {
zend_hash_destroy(exclude_tables[i]);
FREE_HASHTABLE(exclude_tables[i]);
exclude_tables[i] = NULL;
}
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
}
}
} else {
for (i = 0; i < ce->num_traits; i++) {
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
if (traits[i]) {
ZEND_HASH_FOREACH_STR_KEY_PTR(&traits[i]->function_table, key, fn) {
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
zend_traits_copy_functions(key, fn, ce, NULL, aliases);
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
} ZEND_HASH_FOREACH_END();
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
ZEND_HASH_FOREACH_PTR(&ce->function_table, fn) {
zend_fixup_trait_method(fn, ce);
} ZEND_HASH_FOREACH_END();
}
/* }}} */
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
static zend_class_entry* find_first_definition(zend_class_entry *ce, zend_class_entry **traits, size_t current_trait, zend_string *prop_name, zend_class_entry *coliding_ce) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
size_t i;
if (coliding_ce == ce) {
for (i = 0; i < current_trait; i++) {
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
if (traits[i]
&& zend_hash_exists(&traits[i]->properties_info, prop_name)) {
return traits[i];
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
}
return coliding_ce;
}
/* }}} */
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
static void zend_do_traits_property_binding(zend_class_entry *ce, zend_class_entry **traits) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
size_t i;
zend_property_info *property_info;
zend_property_info *coliding_prop;
Add Attributes Co-authored-by: Martin Schröder <m.schroeder2007@gmail.com>
2020-05-25 02:57:00 +08:00
zend_property_info *new_prop;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
zend_string* prop_name;
const char* class_name_unused;
zend_bool not_compatible;
zval* prop_value;
uint32_t flags;
zend_string *doc_comment;
/* In the following steps the properties are inserted into the property table
* for that, a very strict approach is applied:
* - check for compatibility, if not compatible with any property in class -> fatal
* - if compatible, then strict notice
*/
for (i = 0; i < ce->num_traits; i++) {
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
if (!traits[i]) {
continue;
}
ZEND_HASH_FOREACH_PTR(&traits[i]->properties_info, property_info) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* first get the unmangeld name if necessary,
* then check whether the property is already there
*/
flags = property_info->flags;
micro-optimization
2015-06-03 18:43:05 +08:00
if (flags & ZEND_ACC_PUBLIC) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
prop_name = zend_string_copy(property_info->name);
} else {
const char *pname;
size_t pname_len;
/* for private and protected we need to unmangle the names */
zend_unmangle_property_name_ex(property_info->name,
&class_name_unused, &pname, &pname_len);
prop_name = zend_string_init(pname, pname_len, 0);
}
/* next: check for conflicts with current class */
if ((coliding_prop = zend_hash_find_ptr(&ce->properties_info, prop_name)) != NULL) {
Squashed commit of the following: commit 2d3cac9e005d6bef9aa73ab57cc674aa53125954 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 11:54:47 2018 +0300 Fixed static property access commit 31786ee27282f319f3ef2a07635b1f325cbd67c6 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 11:05:29 2018 +0300 Avoid duplicate checks commit 5ae502b979ea33d058d01a9421eec5afd0084e8d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 10:39:17 2018 +0300 Optimization commit 82c17f0e8af02c9cf7d1bbdae4e3158330148203 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 09:26:50 2018 +0300 Removed unused zend_duplicate_property_info() commit ba53d1d0dd91d5530328a11cac93ff9e75c462b5 Merge: eacc11b8fd c4b14370cf Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 09:24:13 2018 +0300 Merge branch 'master' into shadow * master: 7.0.33 next Sync NEWS [ci skip] add NEWS for 76582 Enforce ordering of property compare in object comparisons Fixed wrong assertion Skip test on unsuitable env commit eacc11b8fdeb002ee6a149defd8b5a8c3412896a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Sep 10 13:12:39 2018 +0300 Fixed failure of ext/spl/tests/array_017.phpt commit 62d1871430a1b81c84b790460afff0682648689a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Sep 10 11:55:07 2018 +0300 Fixed issues commit 1d37e3a40e4d07c4b933ed6f9d2e649dd01180f0 Merge: d6c3f098b6 1e550e6f7e Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Sep 10 10:21:20 2018 +0300 Merge branch 'master' into shadow * master: Update NEWS Fix for bug #76582 Fix ssl stream reneg limit test to print only after first renegotiation Make a copy unconditionally Fix memory leak in pcre cache Remove not needed checking for <errno.h> Remove HAVE_ASSERT_H Add test for bug #76850 Fixed bug #76850 Exit code mangled by set locale/preg_match Remove empty PHP tags from test Fix #75273: php_zlib_inflate_filter() may not update bytes_consumed Fix PCRE2 exclusion and remove dead libs in Makefile.gcov Report mem leaks to stderr if no Win debugger is present Use combined assignment contanation operator Fixed bug #76796 Support fixed address mmap without replacement commit d6c3f098b6015e76d042691de0af2e1426c66829 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Sep 7 13:56:30 2018 +0300 Get rid of ZEND_ACC_SHADOW
2018-09-11 16:56:45 +08:00
if ((coliding_prop->flags & ZEND_ACC_PRIVATE) && coliding_prop->ce != ce) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
zend_hash_del(&ce->properties_info, prop_name);
flags |= ZEND_ACC_CHANGED;
} else {
Fix #74922 - Try to resolve constants when importing trait properties
2017-09-27 08:31:03 +08:00
not_compatible = 1;
Trailing whitespaces Signed-off-by: Gabriel Caruso <carusogabriel34@gmail.com>
2017-12-31 12:35:25 +08:00
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if ((coliding_prop->flags & (ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC))
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
== (flags & (ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC)) &&
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
property_types_compatible(property_info, coliding_prop) == INHERITANCE_SUCCESS
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
) {
Fix #74922 - Try to resolve constants when importing trait properties
2017-09-27 08:31:03 +08:00
/* the flags are identical, thus, the properties may be compatible */
Fix #75607 - Check if existing static trait property is a ref before comparing
2017-12-02 00:08:11 +08:00
zval *op1, *op2;
Merge branch 'PHP-7.2'
2017-12-17 00:10:09 +08:00
zval op1_tmp, op2_tmp;
Fix #74922 - Try to resolve constants when importing trait properties
2017-09-27 08:31:03 +08:00
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if (flags & ZEND_ACC_STATIC) {
Fix #75607 - Check if existing static trait property is a ref before comparing
2017-12-02 00:08:11 +08:00
op1 = &ce->default_static_members_table[coliding_prop->offset];
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
op2 = &traits[i]->default_static_members_table[property_info->offset];
Fixed bug #76509 In PHP static properties are shared between inheriting classes, unless they are explicitly overwritten. However, because this functionality was implemented using reference, it was possible to break the implementation by reassigning the static property reference. This is fixed by switching the implementation from using references to using INDIRECTs, which cannot be affected by userland code.
2018-06-22 18:58:48 +08:00
ZVAL_DEINDIRECT(op1);
ZVAL_DEINDIRECT(op2);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else {
Fix #75607 - Check if existing static trait property is a ref before comparing
2017-12-02 00:08:11 +08:00
op1 = &ce->default_properties_table[OBJ_PROP_TO_NUM(coliding_prop->offset)];
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
op2 = &traits[i]->default_properties_table[OBJ_PROP_TO_NUM(property_info->offset)];
Fix #74922 - Try to resolve constants when importing trait properties
2017-09-27 08:31:03 +08:00
}
/* if any of the values is a constant, we try to resolve it */
Merge branch 'PHP-7.2'
2017-12-17 00:10:09 +08:00
if (UNEXPECTED(Z_TYPE_P(op1) == IS_CONSTANT_AST)) {
ZVAL_COPY_OR_DUP(&op1_tmp, op1);
zval_update_constant_ex(&op1_tmp, ce);
op1 = &op1_tmp;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Merge branch 'PHP-7.2'
2017-12-17 00:10:09 +08:00
if (UNEXPECTED(Z_TYPE_P(op2) == IS_CONSTANT_AST)) {
ZVAL_COPY_OR_DUP(&op2_tmp, op2);
zval_update_constant_ex(&op2_tmp, ce);
op2 = &op2_tmp;
Fix #74922 - Try to resolve constants when importing trait properties
2017-09-27 08:31:03 +08:00
}
Fix #75607 - Check if existing static trait property is a ref before comparing
2017-12-02 00:08:11 +08:00
not_compatible = fast_is_not_identical_function(op1, op2);
Merge branch 'PHP-7.2'
2017-12-17 00:10:09 +08:00
if (op1 == &op1_tmp) {
zval_ptr_dtor_nogc(&op1_tmp);
}
if (op2 == &op2_tmp) {
zval_ptr_dtor_nogc(&op2_tmp);
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
if (not_compatible) {
zend_error_noreturn(E_COMPILE_ERROR,
"%s and %s define the same property ($%s) in the composition of %s. However, the definition differs and is considered incompatible. Class was composed",
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
ZSTR_VAL(find_first_definition(ce, traits, i, prop_name, coliding_prop->ce)->name),
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
ZSTR_VAL(property_info->ce->name),
ZSTR_VAL(prop_name),
ZSTR_VAL(ce->name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Reclassify E_STRICT notices Per RFC https://wiki.php.net/rfc/reclassify_e_strict While reviewing this, found that there are still three E_STRICTs left in libraries - need to discuss those.
2015-03-15 16:47:25 +08:00
Use zend_string_release_ex() instread of zend_string_release() in places, where we sure about string persistence.
2018-05-28 21:27:12 +08:00
zend_string_release_ex(prop_name, 0);
Reclassify E_STRICT notices Per RFC https://wiki.php.net/rfc/reclassify_e_strict While reviewing this, found that there are still three E_STRICTs left in libraries - need to discuss those.
2015-03-15 16:47:25 +08:00
continue;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
/* property not found, so lets add it */
if (flags & ZEND_ACC_STATIC) {
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
prop_value = &traits[i]->default_static_members_table[property_info->offset];
Fixed bug #76509 In PHP static properties are shared between inheriting classes, unless they are explicitly overwritten. However, because this functionality was implemented using reference, it was possible to break the implementation by reassigning the static property reference. This is fixed by switching the implementation from using references to using INDIRECTs, which cannot be affected by userland code.
2018-06-22 18:58:48 +08:00
ZEND_ASSERT(Z_TYPE_P(prop_value) != IS_INDIRECT);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else {
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
prop_value = &traits[i]->default_properties_table[OBJ_PROP_TO_NUM(property_info->offset)];
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
RC manipulation cleanup
2017-11-01 10:25:10 +08:00
Z_TRY_ADDREF_P(prop_value);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
doc_comment = property_info->doc_comment ? zend_string_copy(property_info->doc_comment) : NULL;
Add Attributes Co-authored-by: Martin Schröder <m.schroeder2007@gmail.com>
2020-05-25 02:57:00 +08:00
Fix use of type copy ctor when importing trait properties We shouldn't call the copy constructor inside the original type, duh.
2020-11-03 22:29:18 +08:00
zend_type type = property_info->type;
zend_type_copy_ctor(&type, /* persistent */ 0);
new_prop = zend_declare_typed_property(ce, prop_name, prop_value, flags, doc_comment, type);
Add Attributes Co-authored-by: Martin Schröder <m.schroeder2007@gmail.com>
2020-05-25 02:57:00 +08:00
if (property_info->attributes) {
new_prop->attributes = property_info->attributes;
if (!(GC_FLAGS(new_prop->attributes) & IS_ARRAY_IMMUTABLE)) {
GC_ADDREF(new_prop->attributes);
}
}
Use zend_string_release_ex() instread of zend_string_release() in places, where we sure about string persistence.
2018-05-28 21:27:12 +08:00
zend_string_release_ex(prop_name, 0);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} ZEND_HASH_FOREACH_END();
}
}
/* }}} */
Cleanup class linking
2018-08-27 21:40:25 +08:00
static void zend_do_bind_traits(zend_class_entry *ce) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
HashTable **exclude_tables;
zend_class_entry **aliases;
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
zend_class_entry **traits, *trait;
uint32_t i, j;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
ZEND_ASSERT(ce->num_traits > 0);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
traits = emalloc(sizeof(zend_class_entry*) * ce->num_traits);
for (i = 0; i < ce->num_traits; i++) {
trait = zend_fetch_class_by_name(ce->trait_names[i].name,
ce->trait_names[i].lc_name, ZEND_FETCH_CLASS_TRAIT);
if (UNEXPECTED(trait == NULL)) {
return;
}
if (UNEXPECTED(!(trait->ce_flags & ZEND_ACC_TRAIT))) {
zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ZSTR_VAL(ce->name), ZSTR_VAL(trait->name));
return;
}
for (j = 0; j < i; j++) {
if (traits[j] == trait) {
/* skip duplications */
trait = NULL;
break;
}
}
traits[i] = trait;
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* complete initialization of trait strutures in ce */
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
zend_traits_init_trait_structures(ce, traits, &exclude_tables, &aliases);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* first care about all methods to be flattened into the class */
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
zend_do_traits_method_binding(ce, traits, exclude_tables, aliases);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
if (aliases) {
efree(aliases);
}
if (exclude_tables) {
efree(exclude_tables);
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* then flatten the properties into it, to, mostly to notfiy developer about problems */
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
zend_do_traits_property_binding(ce, traits);
efree(traits);
Deprecate PHP 4 constructors
2015-03-31 22:10:22 +08:00
}
/* }}} */
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 17:56:17 +08:00
#define MAX_ABSTRACT_INFO_CNT 3
#define MAX_ABSTRACT_INFO_FMT "%s%s%s%s"
#define DISPLAY_ABSTRACT_FN(idx) \
ai.afn[idx] ? ZEND_FN_SCOPE_NAME(ai.afn[idx]) : "", \
ai.afn[idx] ? "::" : "", \
ai.afn[idx] ? ZSTR_VAL(ai.afn[idx]->common.function_name) : "", \
ai.afn[idx] && ai.afn[idx + 1] ? ", " : (ai.afn[idx] && ai.cnt > MAX_ABSTRACT_INFO_CNT ? ", ..." : "")
typedef struct _zend_abstract_info {
zend_function *afn[MAX_ABSTRACT_INFO_CNT + 1];
int cnt;
int ctor;
} zend_abstract_info;
static void zend_verify_abstract_class_function(zend_function *fn, zend_abstract_info *ai) /* {{{ */
{
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
if (ai->cnt < MAX_ABSTRACT_INFO_CNT) {
ai->afn[ai->cnt] = fn;
}
if (fn->common.fn_flags & ZEND_ACC_CTOR) {
if (!ai->ctor) {
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 17:56:17 +08:00
ai->cnt++;
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
ai->ctor = 1;
} else {
ai->afn[ai->cnt] = NULL;
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 17:56:17 +08:00
}
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
} else {
ai->cnt++;
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 17:56:17 +08:00
}
}
/* }}} */
void zend_verify_abstract_class(zend_class_entry *ce) /* {{{ */
{
zend_function *func;
zend_abstract_info ai;
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
zend_bool is_explicit_abstract = (ce->ce_flags & ZEND_ACC_EXPLICIT_ABSTRACT_CLASS) != 0;
Cleanup class linking
2018-08-27 21:40:25 +08:00
memset(&ai, 0, sizeof(ai));
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 17:56:17 +08:00
Cleanup class linking
2018-08-27 21:40:25 +08:00
ZEND_HASH_FOREACH_PTR(&ce->function_table, func) {
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
if (func->common.fn_flags & ZEND_ACC_ABSTRACT) {
/* If the class is explicitly abstract, we only check private abstract methods,
* because only they must be declared in the same class. */
if (!is_explicit_abstract || (func->common.fn_flags & ZEND_ACC_PRIVATE)) {
zend_verify_abstract_class_function(func, &ai);
}
}
Cleanup class linking
2018-08-27 21:40:25 +08:00
} ZEND_HASH_FOREACH_END();
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 17:56:17 +08:00
Cleanup class linking
2018-08-27 21:40:25 +08:00
if (ai.cnt) {
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
zend_error_noreturn(E_ERROR, !is_explicit_abstract
? "Class %s contains %d abstract method%s and must therefore be declared abstract or implement the remaining methods (" MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT ")"
: "Class %s must implement %d abstract private method%s (" MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT ")",
Cleanup class linking
2018-08-27 21:40:25 +08:00
ZSTR_VAL(ce->name), ai.cnt,
ai.cnt > 1 ? "s" : "",
DISPLAY_ABSTRACT_FN(0),
DISPLAY_ABSTRACT_FN(1),
DISPLAY_ABSTRACT_FN(2)
);
} else {
/* now everything should be fine and an added ZEND_ACC_IMPLICIT_ABSTRACT_CLASS should be removed */
ce->ce_flags &= ~ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
}
}
/* }}} */
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
typedef struct {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
enum {
OBLIGATION_DEPENDENCY,
OBLIGATION_COMPATIBILITY,
OBLIGATION_PROPERTY_COMPATIBILITY
} type;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
union {
zend_class_entry *dependency_ce;
struct {
Fixed bug #78989 Always operate on copies of the functions, so we don't reference temporary trait methods that have gone out of scope. This could be more efficient, but doing an allocated copy only when strictly necessary turned out to be somewhat tricky.
2020-01-28 17:41:11 +08:00
/* Traits may use temporary on-stack functions during inheritance checks,
* so use copies of functions here as well. */
zend_function parent_fn;
zend_function child_fn;
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
zend_class_entry *child_scope;
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
zend_class_entry *parent_scope;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
};
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
struct {
const zend_property_info *parent_prop;
const zend_property_info *child_prop;
};
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
};
} variance_obligation;
static void variance_obligation_dtor(zval *zv) {
efree(Z_PTR_P(zv));
}
static void variance_obligation_ht_dtor(zval *zv) {
zend_hash_destroy(Z_PTR_P(zv));
FREE_HASHTABLE(Z_PTR_P(zv));
}
static HashTable *get_or_init_obligations_for_class(zend_class_entry *ce) {
HashTable *ht;
zend_ulong key;
if (!CG(delayed_variance_obligations)) {
ALLOC_HASHTABLE(CG(delayed_variance_obligations));
zend_hash_init(CG(delayed_variance_obligations), 0, NULL, variance_obligation_ht_dtor, 0);
}
key = (zend_ulong) (uintptr_t) ce;
ht = zend_hash_index_find_ptr(CG(delayed_variance_obligations), key);
if (ht) {
return ht;
}
ALLOC_HASHTABLE(ht);
zend_hash_init(ht, 0, NULL, variance_obligation_dtor, 0);
zend_hash_index_add_new_ptr(CG(delayed_variance_obligations), key, ht);
ce->ce_flags |= ZEND_ACC_UNRESOLVED_VARIANCE;
return ht;
}
static void add_dependency_obligation(zend_class_entry *ce, zend_class_entry *dependency_ce) {
HashTable *obligations = get_or_init_obligations_for_class(ce);
variance_obligation *obligation = emalloc(sizeof(variance_obligation));
obligation->type = OBLIGATION_DEPENDENCY;
obligation->dependency_ce = dependency_ce;
zend_hash_next_index_insert_ptr(obligations, obligation);
}
static void add_compatibility_obligation(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
zend_class_entry *ce,
const zend_function *child_fn, zend_class_entry *child_scope,
const zend_function *parent_fn, zend_class_entry *parent_scope) {
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
HashTable *obligations = get_or_init_obligations_for_class(ce);
variance_obligation *obligation = emalloc(sizeof(variance_obligation));
obligation->type = OBLIGATION_COMPATIBILITY;
Fix copying of functions in variance obligations Only copy sizeof(zend_internal_function) for internal functions.
2020-01-30 18:55:38 +08:00
/* Copy functions, because they may be stack-allocated in the case of traits. */
if (child_fn->common.type == ZEND_INTERNAL_FUNCTION) {
memcpy(&obligation->child_fn, child_fn, sizeof(zend_internal_function));
} else {
memcpy(&obligation->child_fn, child_fn, sizeof(zend_op_array));
}
if (parent_fn->common.type == ZEND_INTERNAL_FUNCTION) {
memcpy(&obligation->parent_fn, parent_fn, sizeof(zend_internal_function));
} else {
memcpy(&obligation->parent_fn, parent_fn, sizeof(zend_op_array));
}
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
obligation->child_scope = child_scope;
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
obligation->parent_scope = parent_scope;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
zend_hash_next_index_insert_ptr(obligations, obligation);
}
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
static void add_property_compatibility_obligation(
zend_class_entry *ce, const zend_property_info *child_prop,
const zend_property_info *parent_prop) {
HashTable *obligations = get_or_init_obligations_for_class(ce);
variance_obligation *obligation = emalloc(sizeof(variance_obligation));
obligation->type = OBLIGATION_PROPERTY_COMPATIBILITY;
obligation->child_prop = child_prop;
obligation->parent_prop = parent_prop;
zend_hash_next_index_insert_ptr(obligations, obligation);
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
static void resolve_delayed_variance_obligations(zend_class_entry *ce);
static int check_variance_obligation(zval *zv) {
variance_obligation *obligation = Z_PTR_P(zv);
if (obligation->type == OBLIGATION_DEPENDENCY) {
zend_class_entry *dependency_ce = obligation->dependency_ce;
if (dependency_ce->ce_flags & ZEND_ACC_UNRESOLVED_VARIANCE) {
resolve_delayed_variance_obligations(dependency_ce);
}
if (!(dependency_ce->ce_flags & ZEND_ACC_LINKED)) {
return ZEND_HASH_APPLY_KEEP;
}
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
} else if (obligation->type == OBLIGATION_COMPATIBILITY) {
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
inheritance_status status = zend_do_perform_implementation_check(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
&obligation->child_fn, obligation->child_scope,
&obligation->parent_fn, obligation->parent_scope);
Reorder conditions to minimize number of checks on fast path
2019-06-26 06:00:31 +08:00
if (UNEXPECTED(status != INHERITANCE_SUCCESS)) {
if (EXPECTED(status == INHERITANCE_UNRESOLVED)) {
return ZEND_HASH_APPLY_KEEP;
}
ZEND_ASSERT(status == INHERITANCE_ERROR);
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
emit_incompatible_method_error(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
&obligation->child_fn, obligation->child_scope,
&obligation->parent_fn, obligation->parent_scope, status);
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
}
/* Either the compatibility check was successful or only threw a warning. */
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
} else {
ZEND_ASSERT(obligation->type == OBLIGATION_PROPERTY_COMPATIBILITY);
inheritance_status status =
property_types_compatible(obligation->parent_prop, obligation->child_prop);
if (status != INHERITANCE_SUCCESS) {
if (status == INHERITANCE_UNRESOLVED) {
return ZEND_HASH_APPLY_KEEP;
}
ZEND_ASSERT(status == INHERITANCE_ERROR);
emit_incompatible_property_error(obligation->child_prop, obligation->parent_prop);
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
}
return ZEND_HASH_APPLY_REMOVE;
}
static void load_delayed_classes() {
HashTable *delayed_autoloads = CG(delayed_autoloads);
zend_string *name;
if (!delayed_autoloads) {
return;
}
/* Take ownership of this HT, to avoid concurrent modification during autoloading. */
CG(delayed_autoloads) = NULL;
ZEND_HASH_FOREACH_STR_KEY(delayed_autoloads, name) {
zend_lookup_class(name);
} ZEND_HASH_FOREACH_END();
zend_hash_destroy(delayed_autoloads);
FREE_HASHTABLE(delayed_autoloads);
}
static void resolve_delayed_variance_obligations(zend_class_entry *ce) {
HashTable *all_obligations = CG(delayed_variance_obligations), *obligations;
zend_ulong num_key = (zend_ulong) (uintptr_t) ce;
ZEND_ASSERT(all_obligations != NULL);
obligations = zend_hash_index_find_ptr(all_obligations, num_key);
ZEND_ASSERT(obligations != NULL);
zend_hash_apply(obligations, check_variance_obligation);
if (zend_hash_num_elements(obligations) == 0) {
ce->ce_flags &= ~ZEND_ACC_UNRESOLVED_VARIANCE;
ce->ce_flags |= ZEND_ACC_LINKED;
zend_hash_index_del(all_obligations, num_key);
}
}
static void report_variance_errors(zend_class_entry *ce) {
HashTable *all_obligations = CG(delayed_variance_obligations), *obligations;
variance_obligation *obligation;
zend_ulong num_key = (zend_ulong) (uintptr_t) ce;
ZEND_ASSERT(all_obligations != NULL);
obligations = zend_hash_index_find_ptr(all_obligations, num_key);
ZEND_ASSERT(obligations != NULL);
ZEND_HASH_FOREACH_PTR(obligations, obligation) {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
if (obligation->type == OBLIGATION_COMPATIBILITY) {
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
/* Just used to populate the delayed_autoloads table,
* which will be used when printing the "unresolved" error. */
inheritance_status status = zend_do_perform_implementation_check(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
&obligation->child_fn, obligation->child_scope,
&obligation->parent_fn, obligation->parent_scope);
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
ZEND_ASSERT(status == INHERITANCE_UNRESOLVED);
Merge branch 'PHP-7.4' * PHP-7.4: Integrate property types with variance system
2019-10-17 19:42:47 +08:00
emit_incompatible_method_error(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
&obligation->child_fn, obligation->child_scope,
&obligation->parent_fn, obligation->parent_scope, status);
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
} else if (obligation->type == OBLIGATION_PROPERTY_COMPATIBILITY) {
emit_incompatible_property_error(obligation->child_prop, obligation->parent_prop);
} else {
zend_error_noreturn(E_CORE_ERROR, "Bug #78647");
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
} ZEND_HASH_FOREACH_END();
/* Only warnings were thrown above -- that means that there are incompatibilities, but only
* ones that we permit. Mark all classes with open obligations as fully linked. */
ce->ce_flags &= ~ZEND_ACC_UNRESOLVED_VARIANCE;
ce->ce_flags |= ZEND_ACC_LINKED;
zend_hash_index_del(all_obligations, num_key);
}
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
static void check_unrecoverable_load_failure(zend_class_entry *ce) {
/* If this class has been used while unlinked through a variance obligation, it is not legal
* to remove the class from the class table and throw an exception, because there is already
* a dependence on the inheritance hierarchy of this specific class. Instead we fall back to
* a fatal error, as would happen if we did not allow exceptions in the first place. */
if (ce->ce_flags & ZEND_ACC_HAS_UNLINKED_USES) {
zend_string *exception_str;
zval exception_zv;
ZEND_ASSERT(EG(exception) && "Exception must have been thrown");
Add ZVAL_OBJ_COPY macro For the common ZVAL_OBJ + GC_ADDREF pattern. This mirrors the existing ZVAL_STR_COPY API.
2020-06-17 18:34:04 +08:00
ZVAL_OBJ_COPY(&exception_zv, EG(exception));
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
zend_clear_exception();
exception_str = zval_get_string(&exception_zv);
zend_error_noreturn(E_ERROR,
"During inheritance of %s with variance dependencies: Uncaught %s", ZSTR_VAL(ce->name), ZSTR_VAL(exception_str));
}
}
Improve type declarations for Zend APIs Voidification of Zend API which always succeeded Use bool argument types instead of int for boolean arguments Use bool return type for functions which return true/false (1/0) Use zend_result return type for functions which return SUCCESS/FAILURE as they don't follow normal boolean semantics Closes GH-6002
2020-08-28 21:41:27 +08:00
ZEND_API zend_result zend_do_link_class(zend_class_entry *ce, zend_string *lc_parent_name) /* {{{ */
Cleanup class linking
2018-08-27 21:40:25 +08:00
{
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
/* Load parent/interface dependencies first, so we can still gracefully abort linking
* with an exception and remove the class from the class table. This is only possible
* if no variance obligations on the current class have been added during autoloading. */
zend_class_entry *parent = NULL;
zend_class_entry **interfaces = NULL;
Register class before fetching parent We want the class declaration to be available while compiling the parent class.
2019-05-24 20:28:44 +08:00
if (ce->parent_name) {
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
parent = zend_fetch_class_by_name(
ce->parent_name, lc_parent_name,
ZEND_FETCH_CLASS_ALLOW_NEARLY_LINKED | ZEND_FETCH_CLASS_EXCEPTION);
if (!parent) {
check_unrecoverable_load_failure(ce);
return FAILURE;
}
}
if (ce->num_interfaces) {
/* Also copy the parent interfaces here, so we don't need to reallocate later. */
uint32_t i, num_parent_interfaces = parent ? parent->num_interfaces : 0;
interfaces = emalloc(
sizeof(zend_class_entry *) * (ce->num_interfaces + num_parent_interfaces));
if (num_parent_interfaces) {
memcpy(interfaces, parent->interfaces,
sizeof(zend_class_entry *) * num_parent_interfaces);
}
for (i = 0; i < ce->num_interfaces; i++) {
zend_class_entry *iface = zend_fetch_class_by_name(
ce->interface_names[i].name, ce->interface_names[i].lc_name,
ZEND_FETCH_CLASS_INTERFACE |
ZEND_FETCH_CLASS_ALLOW_NEARLY_LINKED | ZEND_FETCH_CLASS_EXCEPTION);
if (!iface) {
check_unrecoverable_load_failure(ce);
efree(interfaces);
return FAILURE;
}
interfaces[num_parent_interfaces + i] = iface;
}
}
if (parent) {
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
if (!(parent->ce_flags & ZEND_ACC_LINKED)) {
add_dependency_obligation(ce, parent);
}
Cleanup class linking
2018-08-27 21:40:25 +08:00
zend_do_inheritance(ce, parent);
}
Remove ZEND_ACC_IMPLEMENTS_TRAITS flag This is equivalent to checking ce->num_traits.
2020-02-06 17:45:49 +08:00
if (ce->num_traits) {
Cleanup class linking
2018-08-27 21:40:25 +08:00
zend_do_bind_traits(ce);
}
Remove ZEND_ACC_IMPLEMENT_INTERFACES flag This is equivalent to checking ce->num_interfaces. The only subtle moment is during inheritance, where num_interface may change when parent interfaces are inherited. The check in zend_do_link_class thus uses "interfaces", not "ce->num_interfaces".
2020-02-06 17:51:45 +08:00
if (interfaces) {
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
zend_do_implement_interfaces(ce, interfaces);
Implement interfaces after all methods available The place where interface implementation handlers is called is currently ill-defined: If the class implements interfaces itself, the handlers for both the parent interfaces and the new interfaces will be called after all methods are registered (post trait use). If the class does not implement interfaces, then the parent interface handlers are called early during inheritance (before methods are inherited). This commit moves the calls to always occur after all methods are available. For userland classes this will be post trait import, at the time where interfaces get implemented (whether the class itself defines additional interfaces or not). For internal classes it will be at the end of inheritance, as internal class declarations do not have proper finalization. This allows us to simplify the logic for implementing the magic Iterator / IteratorAggregate interfaces. In particularly we can now also automatically detect whether an extension of IteratorAggregate can safely reuse a custom get_iterator handler, or whether it needs to switch to the userland mechanism. The Iterator case continues to rely on ZEND_ACC_REUSE_GET_ITERATOR for this purpose, as a wholesale replacement is not possible there.
2020-03-04 17:10:36 +08:00
} else if (parent && parent->num_interfaces) {
zend_do_inherit_interfaces(ce, parent);
Cleanup class linking
2018-08-27 21:40:25 +08:00
}
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT))
&& (ce->ce_flags & (ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))
) {
Cleanup class linking
2018-08-27 21:40:25 +08:00
zend_verify_abstract_class(ce);
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 17:56:17 +08:00
}
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
zend_build_properties_info_table(ce);
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
if (!(ce->ce_flags & ZEND_ACC_UNRESOLVED_VARIANCE)) {
ce->ce_flags |= ZEND_ACC_LINKED;
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
return SUCCESS;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
}
Only allow "nearly linked" classes for parent/interface The requirements for parent/interface are difference than for the variance checks in type declarations. The latter can work on fully unlinked classes, but the former need inheritance to be essentially finished, only variance checks may still be outstanding. Adding a new flag for this because we have lots of space, but we could also represent these "inheritance states" more compactly in the future.
2019-09-11 22:27:28 +08:00
ce->ce_flags |= ZEND_ACC_NEARLY_LINKED;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
load_delayed_classes();
if (ce->ce_flags & ZEND_ACC_UNRESOLVED_VARIANCE) {
resolve_delayed_variance_obligations(ce);
if (!(ce->ce_flags & ZEND_ACC_LINKED)) {
report_variance_errors(ce);
}
}
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
return SUCCESS;
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 17:56:17 +08:00
}
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
/* }}} */
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
/* Check whether early binding is prevented due to unresolved types in inheritance checks. */
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
static inheritance_status zend_can_early_bind(zend_class_entry *ce, zend_class_entry *parent_ce) /* {{{ */
{
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
zend_string *key;
zend_function *parent_func;
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
zend_property_info *parent_info;
Prevent useless hash lookups
2019-06-25 17:41:06 +08:00
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
ZEND_HASH_FOREACH_STR_KEY_PTR(&parent_ce->function_table, key, parent_func) {
zval *zv = zend_hash_find_ex(&ce->function_table, key, 1);
if (zv) {
zend_function *child_func = Z_FUNC_P(zv);
inheritance_status status =
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
do_inheritance_check_on_method_ex(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
child_func, child_func->common.scope,
parent_func, parent_func->common.scope,
ce, NULL, /* check_visibility */ 1, 1, 0);
Fixed variance check for abstract constructor during erlay binding
2019-06-25 22:43:46 +08:00
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (UNEXPECTED(status != INHERITANCE_SUCCESS)) {
Merge branch 'PHP-7.4' * PHP-7.4: Avoid double checks on early binding
2019-06-27 07:25:57 +08:00
return status;
Fixed variance check for abstract constructor during erlay binding
2019-06-25 22:43:46 +08:00
}
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
}
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
} ZEND_HASH_FOREACH_END();
Prevent useless hash lookups
2019-06-25 17:41:06 +08:00
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
ZEND_HASH_FOREACH_STR_KEY_PTR(&parent_ce->properties_info, key, parent_info) {
zval *zv;
if ((parent_info->flags & ZEND_ACC_PRIVATE) || !ZEND_TYPE_IS_SET(parent_info->type)) {
continue;
}
zv = zend_hash_find_ex(&ce->properties_info, key, 1);
if (zv) {
zend_property_info *child_info = Z_PTR_P(zv);
if (ZEND_TYPE_IS_SET(child_info->type)) {
inheritance_status status = property_types_compatible(parent_info, child_info);
if (UNEXPECTED(status != INHERITANCE_SUCCESS)) {
Merge branch 'PHP-7.4' * PHP-7.4: Integrate property types with variance system
2019-10-17 19:42:47 +08:00
return status;
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
}
}
}
} ZEND_HASH_FOREACH_END();
Merge branch 'PHP-7.4' * PHP-7.4: Avoid double checks on early binding
2019-06-27 07:25:57 +08:00
return INHERITANCE_SUCCESS;
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
}
/* }}} */
Reorder conditions to minimize number of checks on fast path
2019-06-26 06:00:31 +08:00
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
zend_bool zend_try_early_bind(zend_class_entry *ce, zend_class_entry *parent_ce, zend_string *lcname, zval *delayed_early_binding) /* {{{ */
{
inheritance_status status = zend_can_early_bind(ce, parent_ce);
Reorder conditions to minimize number of checks on fast path
2019-06-26 06:00:31 +08:00
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (EXPECTED(status != INHERITANCE_UNRESOLVED)) {
if (delayed_early_binding) {
if (UNEXPECTED(zend_hash_set_bucket_key(EG(class_table), (Bucket*)delayed_early_binding, lcname) == NULL)) {
zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare %s %s, because the name is already in use", zend_get_object_type(ce), ZSTR_VAL(ce->name));
return 0;
}
} else {
if (UNEXPECTED(zend_hash_add_ptr(CG(class_table), lcname, ce) == NULL)) {
Reorder conditions to minimize number of checks on fast path
2019-06-26 06:00:31 +08:00
return 0;
}
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
}
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
zend_do_inheritance_ex(ce, parent_ce, status == INHERITANCE_SUCCESS);
Implement interfaces after all methods available The place where interface implementation handlers is called is currently ill-defined: If the class implements interfaces itself, the handlers for both the parent interfaces and the new interfaces will be called after all methods are registered (post trait use). If the class does not implement interfaces, then the parent interface handlers are called early during inheritance (before methods are inherited). This commit moves the calls to always occur after all methods are available. For userland classes this will be post trait import, at the time where interfaces get implemented (whether the class itself defines additional interfaces or not). For internal classes it will be at the end of inheritance, as internal class declarations do not have proper finalization. This allows us to simplify the logic for implementing the magic Iterator / IteratorAggregate interfaces. In particularly we can now also automatically detect whether an extension of IteratorAggregate can safely reuse a custom get_iterator handler, or whether it needs to switch to the userland mechanism. The Iterator case continues to rely on ZEND_ACC_REUSE_GET_ITERATOR for this purpose, as a wholesale replacement is not possible there.
2020-03-04 17:10:36 +08:00
if (parent_ce && parent_ce->num_interfaces) {
zend_do_inherit_interfaces(ce, parent_ce);
}
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
zend_build_properties_info_table(ce);
if ((ce->ce_flags & (ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) == ZEND_ACC_IMPLICIT_ABSTRACT_CLASS) {
zend_verify_abstract_class(ce);
}
ZEND_ASSERT(!(ce->ce_flags & ZEND_ACC_UNRESOLVED_VARIANCE));
ce->ce_flags |= ZEND_ACC_LINKED;
return 1;
}
return 0;
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
}
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 17:56:17 +08:00
/* }}} */
Reference in New Issue Copy Permalink