clones/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-09-21 18:07:23 +00:00
Code Issues Packages Projects Releases Wiki Activity
b0c920f94b
php-src/Zend/zend_inheritance.c

2550 lines
87 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-18 22:01:05 +00:00
/*
+----------------------------------------------------------------------+
| Zend Engine |
+----------------------------------------------------------------------+
Adios, yearly copyright ranges
2019-01-30 09:23:29 +00: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-18 22:01:05 +00: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 15:20:07 +00: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-18 22:01:05 +00: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-08 20:40:36 +00: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 10:30:16 +00:00
#include "zend_interfaces.h"
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00:00
#include "zend_smart_str.h"
Fixed bug #74269: Strict comparison of initial trait property values
2017-04-10 20:04:18 +00: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 13:31:04 +00: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-18 22:01:05 +00: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 09:39:56 +00:00
static void add_dependency_obligation(zend_class_entry *ce, zend_class_entry *dependency_ce);
static void add_compatibility_obligation(
Merge branch 'PHP-7.4'
2019-06-11 11:15:03 +00:00
zend_class_entry *ce, const zend_function *child_fn, const zend_function *parent_fn);
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 11:01:02 +00: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 09:39:56 +00:00
Fix some misspellings
2018-08-10 02:19:55 +00:00
static void overridden_ptr_dtor(zval *zv) /* {{{ */
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-18 22:01:05 +00:00
{
use efree_size here
2015-08-12 03:15:09 +00:00
efree_size(Z_PTR_P(zv), sizeof(zend_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-18 22:01:05 +00: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 11:21:13 +00: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-16 16:04:11 +00: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 11:21:13 +00: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-18 22:01:05 +00: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 11:21:13 +00: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 11:28:51 +00: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-18 22:01:05 +00:00
return new_property_info;
}
/* }}} */
Inline hot path
2019-06-27 08:27:53 +00:00
static zend_function *zend_duplicate_internal_function(zend_function *func, zend_class_entry *ce) /* {{{ */
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
{
zend_function *new_function;
Inline hot path
2019-06-27 08:27:53 +00: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));
if (ZEND_MAP_PTR_GET(func->op_array.static_variables_ptr)) {
/* See: Zend/tests/method_static_var.phpt */
new_function->op_array.static_variables = ZEND_MAP_PTR_GET(func->op_array.static_variables_ptr);
}
if (!(GC_FLAGS(new_function->op_array.static_variables) & IS_ARRAY_IMMUTABLE)) {
GC_ADDREF(new_function->op_array.static_variables);
}
ZEND_MAP_PTR_INIT(new_function->op_array.static_variables_ptr, &new_function->op_array.static_variables);
return new_function;
}
/* }}} */
Separate common code abd eliminate useless checks
2019-06-27 10:11:08 +00: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 08:27:53 +00:00
{
Make fast path linear
2015-03-06 14:07:36 +00:00
if (UNEXPECTED(func->type == ZEND_INTERNAL_FUNCTION)) {
Inline hot path
2019-06-27 08:27:53 +00:00
return zend_duplicate_internal_function(func, ce);
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
} else {
if (func->op_array.refcount) {
(*func->op_array.refcount)++;
}
Separate common code abd eliminate useless checks
2019-06-27 10:11:08 +00: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 12:33:31 +00:00
|| EXPECTED(!func->op_array.static_variables)) {
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
/* reuse the same op_array structure */
return func;
}
Inline hot path
2019-06-27 08:27:53 +00:00
return zend_duplicate_user_function(func);
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
}
}
/* }}} */
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00: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-18 22:01:05 +00:00
{
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00: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-18 22:01:05 +00:00
/* You cannot change create_object */
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00: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-18 22:01:05 +00:00
/* Inherit special functions if needed */
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
if (EXPECTED(!ce->get_iterator)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00: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-18 22:01:05 +00:00
}
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 12:52:50 +00:00
if (parent->iterator_funcs_ptr) {
/* Must be initialized through iface->interface_gets_implemented() */
ZEND_ASSERT(ce->iterator_funcs_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-18 22:01:05 +00:00
}
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
if (EXPECTED(!ce->__get)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00: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-18 22:01:05 +00:00
}
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
if (EXPECTED(!ce->__set)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00: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-18 22:01:05 +00:00
}
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
if (EXPECTED(!ce->__unset)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00: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-18 22:01:05 +00:00
}
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
if (EXPECTED(!ce->__isset)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00: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-18 22:01:05 +00:00
}
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
if (EXPECTED(!ce->__call)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00: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-18 22:01:05 +00:00
}
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
if (EXPECTED(!ce->__callstatic)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00: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-18 22:01:05 +00:00
}
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
if (EXPECTED(!ce->__tostring)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00: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-18 22:01:05 +00:00
}
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
if (EXPECTED(!ce->clone)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00: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-18 22:01:05 +00:00
}
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 10:20:28 +00:00
if (EXPECTED(!ce->serialize_func)) {
ce->serialize_func = parent->serialize_func;
}
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
if (EXPECTED(!ce->serialize)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00: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-18 22:01:05 +00:00
}
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 10:20:28 +00:00
if (EXPECTED(!ce->unserialize_func)) {
ce->unserialize_func = parent->unserialize_func;
}
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
if (EXPECTED(!ce->unserialize)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00: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-18 22:01:05 +00:00
}
if (!ce->destructor) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00: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-18 22:01:05 +00:00
}
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
if (EXPECTED(!ce->__debugInfo)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00: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-18 22:01:05 +00:00
}
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00: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-18 22:01:05 +00:00
if (ce->constructor) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00:00
if (parent->constructor && UNEXPECTED(parent->constructor->common.fn_flags & ZEND_ACC_FINAL)) {
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00: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 10:16:10 +00: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 10:59:27 +00: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-18 22:01:05 +00:00
}
return;
}
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00: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-18 22:01:05 +00: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 08:56:45 +00: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-18 22:01:05 +00: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 11:01:02 +00: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 08:41:06 +00: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 11:01:02 +00: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 08:41:06 +00: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 10:11:12 +00: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 11:01:02 +00: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 10:11:12 +00:00
} else {
return name;
Covariance on inheriting classes with iterable
2016-06-04 14:44:49 +00: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 08:41:06 +00: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 11:21:13 +00:00
static zend_class_entry *lookup_class(
zend_class_entry *scope, zend_string *name, zend_bool register_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 08:41:06 +00:00
zend_class_entry *ce;
if (!CG(in_compilation)) {
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 09:39:56 +00:00
uint32_t flags = ZEND_FETCH_CLASS_ALLOW_UNLINKED | ZEND_FETCH_CLASS_NO_AUTOLOAD;
ce = zend_lookup_class_ex(name, NULL, flags);
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 10:30:16 +00: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 09:39:56 +00: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 11:21:13 +00: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 09:39:56 +00: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 10:30:16 +00:00
} else {
Accept flags argument in zend_lookup_class_ex() Instead of a single boolean, so we have space for extension here.
2019-05-24 12:41:38 +00:00
ce = zend_lookup_class_ex(name, NULL, ZEND_FETCH_CLASS_NO_AUTOLOAD);
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 10:30:16 +00:00
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 08:41:06 +00: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 09:39:56 +00: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 11:01:02 +00: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 09:39:56 +00: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 08:41:06 +00: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 09:39:56 +00: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 10:30:16 +00: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 09:39:56 +00:00
zend_class_entry *ce;
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-24 16:11:41 +00: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 10:30:16 +00: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 09:39:56 +00:00
ce = ce1;
while (ce->parent) {
if (ce->ce_flags & ZEND_ACC_RESOLVED_PARENT) {
ce = ce->parent;
} else {
ce = zend_lookup_class_ex(ce->parent_name, NULL,
ZEND_FETCH_CLASS_ALLOW_UNLINKED | ZEND_FETCH_CLASS_NO_AUTOLOAD);
if (!ce) {
break;
}
}
if (ce == ce2) {
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-24 16:11:41 +00: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++) {
ce = zend_lookup_class_ex(
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 09:39:56 +00: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 10:30:16 +00: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 11:21:13 +00: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-16 16:04:11 +00:00
zend_type *single_type;
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 11:21:13 +00: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 08:41:06 +00: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 11:21:13 +00:00
static inheritance_status zend_perform_covariant_class_type_check(
zend_class_entry *fe_scope, zend_string *fe_class_name,
zend_class_entry *proto_scope, zend_type proto_type,
zend_bool register_unresolved) {
zend_bool have_unresolved = 0;
zend_class_entry *fe_ce = NULL;
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 09:24:08 +00: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 11:21:13 +00: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 10:30:16 +00: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 11:21:13 +00:00
}
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-08 20:40:36 +00: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-16 16:04:11 +00:00
zend_type *single_type;
ZEND_TYPE_FOREACH(proto_type, single_type) {
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 11:21:13 +00: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-16 16:04:11 +00: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 11:21:13 +00: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 10:11:12 +00: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-16 16:04:11 +00:00
/* Make sure to always load both classes, to avoid only registering one of them as
* a delayed autoload. */
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 11:21:13 +00:00
if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name, register_unresolved);
zend_class_entry *proto_ce =
lookup_class(proto_scope, proto_class_name, register_unresolved);
if (!fe_ce || !proto_ce) {
have_unresolved = 1;
} else if (unlinked_instanceof(fe_ce, proto_ce)) {
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 10:30:16 +00: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-16 16:04:11 +00: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 11:21:13 +00: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.
if (added_types == MAY_BE_ITERABLE
&& (proto_type_mask & MAY_BE_ARRAY)
&& zend_type_contains_traversable(proto_type)) {
/* Replacing array|Traversable with iterable is okay */
} else if (added_types == MAY_BE_ARRAY && (proto_type_mask & MAY_BE_ITERABLE)) {
/* Replacing iterable with array is okay */
} else {
/* Otherwise adding new types is illegal */
return INHERITANCE_ERROR;
}
}
if (ZEND_TYPE_HAS_NAME(fe_type)) {
zend_string *fe_class_name = resolve_class_name(fe_scope, ZEND_TYPE_NAME(fe_type));
inheritance_status status = zend_perform_covariant_class_type_check(
fe_scope, fe_class_name, proto_scope, proto_type, /* register_unresolved */ 0);
if (status != INHERITANCE_UNRESOLVED) {
return status;
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 10:30:16 +00: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 11:21:13 +00:00
zend_perform_covariant_class_type_check(
fe_scope, fe_class_name, proto_scope, proto_type, /* register_unresolved */ 1);
return INHERITANCE_UNRESOLVED;
}
if (ZEND_TYPE_HAS_LIST(fe_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-16 16:04:11 +00:00
zend_type *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 11:21:13 +00:00
zend_bool all_success = 1;
/* First try to check whether we can succeed without resolving anything */
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-16 16:04:11 +00:00
ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(fe_type), list_type) {
ZEND_ASSERT(ZEND_TYPE_HAS_NAME(*list_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 11:01:02 +00:00
zend_string *fe_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-16 16:04:11 +00:00
resolve_class_name(fe_scope, 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 11:21:13 +00:00
inheritance_status status = zend_perform_covariant_class_type_check(
fe_scope, fe_class_name, proto_scope, proto_type, /* register_unresolved */ 0);
if (status == INHERITANCE_ERROR) {
return INHERITANCE_ERROR;
}
if (status != INHERITANCE_SUCCESS) {
all_success = 0;
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 10:11:12 +00: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 11:21:13 +00:00
} ZEND_TYPE_LIST_FOREACH_END();
Fix #78880 Another round
2020-01-19 07:50:48 +00:00
/* All individual checks succeeded, overall success */
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 11:21:13 +00:00
if (all_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 10:30:16 +00:00
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 09:24:08 +00: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 11:21:13 +00:00
/* Register all classes that may have to be resolved */
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-16 16:04:11 +00:00
ZEND_TYPE_LIST_FOREACH(ZEND_TYPE_LIST(fe_type), list_type) {
ZEND_ASSERT(ZEND_TYPE_HAS_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 11:21:13 +00:00
zend_string *fe_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-16 16:04:11 +00:00
resolve_class_name(fe_scope, 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 11:21:13 +00:00
zend_perform_covariant_class_type_check(
fe_scope, fe_class_name, proto_scope, proto_type, /* register_unresolved */ 1);
} ZEND_TYPE_LIST_FOREACH_END();
return INHERITANCE_UNRESOLVED;
work on #71428
2016-03-28 10:54:25 +00: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 11:21:13 +00:00
return INHERITANCE_SUCCESS;
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-08 20:40:36 +00: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 10:30:16 +00:00
static inheritance_status zend_do_perform_arg_type_hint_check(
const zend_function *fe, zend_arg_info *fe_arg_info,
const zend_function *proto, zend_arg_info *proto_arg_info) /* {{{ */
Implement Parameter Type Widening RFC
2017-01-01 14:53:24 +00:00
{
if (!ZEND_TYPE_IS_SET(fe_arg_info->type)) {
/* Child with no 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 08:41:06 +00:00
return INHERITANCE_SUCCESS;
Implement Parameter Type Widening RFC
2017-01-01 14:53:24 +00: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 08:41:06 +00:00
return INHERITANCE_ERROR;
Implement Parameter Type Widening RFC
2017-01-01 14:53:24 +00: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 09:24:08 +00: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 10:30:16 +00:00
return zend_perform_covariant_type_check(
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 11:21:13 +00:00
proto->common.scope, proto_arg_info->type, fe->common.scope, fe_arg_info->type);
Implement Parameter Type Widening RFC
2017-01-01 14:53:24 +00: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 10:30:16 +00:00
static inheritance_status zend_do_perform_implementation_check(
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 11:21:13 +00:00
const zend_function *fe, const 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-18 22:01:05 +00:00
{
uint32_t i, 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 08:41:06 +00:00
inheritance_status status, local_status;
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-18 22:01:05 +00:00
/* If it's a user function then arg_info == NULL means we don't have any parameters but
* we still need to do the arg number checks. We are only willing to ignore this for internal
* functions because extensions don't always define arg_info.
*/
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00:00
if (!proto->common.arg_info && proto->common.type != ZEND_USER_FUNCTION) {
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 08:41:06 +00:00
return 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-18 22:01:05 +00: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 15:26:56 +00: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-18 22:01:05 +00:00
&& ((proto->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0
Replace previosly checked conditions by ZEND_ASSERT()
2019-06-25 15:26:56 +00: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-18 22:01:05 +00:00
Merge branch 'PHP-5.6' into PHP-7.0 Conflicts: Zend/zend_compile.c
2016-07-05 12:31:32 +00:00
/* If the prototype method is private do not enforce a signature */
Replace previosly checked conditions by ZEND_ASSERT()
2019-06-25 15:26:56 +00:00
ZEND_ASSERT(!(proto->common.fn_flags & ZEND_ACC_PRIVATE));
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-18 22:01:05 +00:00
/* check number of arguments */
if (proto->common.required_num_args < fe->common.required_num_args
|| proto->common.num_args > fe->common.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 08:41:06 +00: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-18 22:01:05 +00: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 08:41:06 +00: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-18 22:01:05 +00:00
}
if ((proto->common.fn_flags & ZEND_ACC_VARIADIC)
&& !(fe->common.fn_flags & ZEND_ACC_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 08:41:06 +00: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-18 22:01:05 +00:00
}
/* For variadic functions any additional (optional) arguments that were added must be
* checked against the signature of the variadic argument, so in this case we have to
* go through all the parameters of the function and not just those present in the
* prototype. */
num_args = proto->common.num_args;
Don't count variadic argument in zend_func.common.num_args. This allows faster CALL/RETURN code.
2014-12-22 13:44:39 +00:00
if (proto->common.fn_flags & ZEND_ACC_VARIADIC) {
num_args++;
if (fe->common.num_args >= proto->common.num_args) {
num_args = fe->common.num_args;
if (fe->common.fn_flags & ZEND_ACC_VARIADIC) {
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-18 22:01:05 +00: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 08:41:06 +00: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-18 22:01:05 +00:00
for (i = 0; i < num_args; i++) {
zend_arg_info *fe_arg_info = &fe->common.arg_info[i];
zend_arg_info *proto_arg_info;
if (i < proto->common.num_args) {
proto_arg_info = &proto->common.arg_info[i];
} else {
Don't count variadic argument in zend_func.common.num_args. This allows faster CALL/RETURN code.
2014-12-22 13:44:39 +00:00
proto_arg_info = &proto->common.arg_info[proto->common.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-18 22:01:05 +00:00
}
Implement Parameter Type Widening RFC
2017-01-01 14:53:24 +00: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 11:21:13 +00:00
local_status = zend_do_perform_arg_type_hint_check(fe, fe_arg_info, proto, proto_arg_info);
Reorder conditions to minimize number of checks on fast path
2019-06-25 22:00:31 +00: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 08:41:06 +00:00
status = INHERITANCE_UNRESOLVED;
Fixed bug #71978 (Existence of return type hint affects other compatibility rules)
2016-04-06 14:17:10 +00:00
}
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-08 20:40:36 +00: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 15:01:19 +00: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 08:41:06 +00:00
return INHERITANCE_ERROR;
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-08 20:40:36 +00: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-18 22:01:05 +00: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-22 17:50:36 +00: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 08:41:06 +00:00
return INHERITANCE_ERROR;
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-08 20:40:36 +00:00
}
Implement Parameter Type Widening RFC
2017-01-01 14:53:24 +00: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 10:30:16 +00:00
local_status = zend_perform_covariant_type_check(
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 11:21:13 +00:00
fe->common.scope, fe->common.arg_info[-1].type,
proto->common.scope, proto->common.arg_info[-1].type);
Reorder conditions to minimize number of checks on fast path
2019-06-25 22:00:31 +00: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 08:41:06 +00:00
status = INHERITANCE_UNRESOLVED;
Implement nullable return types.
2016-04-06 15:24:34 +00:00
}
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-08 20:40:36 +00: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 08:41:06 +00:00
return status;
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-08 20:40:36 +00: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-18 22:01:05 +00:00
Mark error and exception functions as "cold" (Matt's idea)
2015-08-19 11:40:56 +00:00
static ZEND_COLD void zend_append_type_hint(smart_str *str, const zend_function *fptr, zend_arg_info *arg_info, int return_hint) /* {{{ */
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-08 20:40:36 +00: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 10:11:29 +00:00
if (ZEND_TYPE_IS_SET(arg_info->type)) {
zend_string *type_str = zend_type_to_string_resolved(arg_info->type, fptr->common.scope);
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-08 20:40:36 +00: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-18 22:01:05 +00:00
}
}
}
/* }}} */
Mark error and exception functions as "cold" (Matt's idea)
2015-08-19 11:40:56 +00:00
static ZEND_COLD zend_string *zend_get_function_declaration(const zend_function *fptr) /* {{{ */
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-18 22:01:05 +00:00
{
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00: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-18 22:01:05 +00: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-20 21:27:10 +00: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-18 22:01:05 +00:00
}
if (fptr->common.scope) {
Show full signature upon inheritance mismatch
2015-06-28 22:28:52 +00: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 10:59:27 +00: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-20 21:27:10 +00: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-18 22:01:05 +00:00
}
Add smart_str_append for appending zend_strings Also replaces usages in Zend/ and ext/standard
2014-09-21 18:47:07 +00:00
smart_str_append(&str, fptr->common.function_name);
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00: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-18 22:01:05 +00: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 13:44:39 +00: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-18 22:01:05 +00: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 13:44:39 +00:00
num_args = fptr->common.num_args;
if (fptr->common.fn_flags & ZEND_ACC_VARIADIC) {
num_args++;
}
for (i = 0; i < num_args;) {
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-08 20:40:36 +00:00
zend_append_type_hint(&str, fptr, 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-18 22:01:05 +00: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 15:01:19 +00:00
if (ZEND_ARG_SEND_MODE(arg_info)) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00: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-18 22:01:05 +00: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 15:01:19 +00:00
if (ZEND_ARG_IS_VARIADIC(arg_info)) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00: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-18 22:01:05 +00:00
}
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00: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-18 22:01:05 +00:00
if (arg_info->name) {
Use zend_string* for op_array->arg_info[]->name and op_array->arg_info[]->class_name. For internal functions we still use char*.
2014-12-03 13:56:09 +00:00
if (fptr->type == ZEND_INTERNAL_FUNCTION) {
smart_str_appends(&str, ((zend_internal_arg_info*)arg_info)->name);
} else {
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 10:59:27 +00:00
smart_str_appendl(&str, ZSTR_VAL(arg_info->name), ZSTR_LEN(arg_info->name));
Use zend_string* for op_array->arg_info[]->name and op_array->arg_info[]->class_name. For internal functions we still use char*.
2014-12-03 13:56:09 +00: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-18 22:01:05 +00:00
} else {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00:00
smart_str_appends(&str, "param");
smart_str_append_unsigned(&str, 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-18 22:01:05 +00:00
}
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00: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 15:01:19 +00: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-20 21:27:10 +00: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-18 22:01:05 +00:00
if (fptr->type == ZEND_USER_FUNCTION) {
zend_op *precv = NULL;
{
uint32_t idx = i;
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00: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-18 22:01:05 +00: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 13:53:01 +00: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-18 22:01:05 +00:00
Always use IS_CONSTANT_AST (IS_CONSTANT is removed).
2017-10-10 07:11:05 +00:00
if (Z_TYPE_P(zv) == IS_FALSE) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00: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-18 22:01:05 +00:00
} else if (Z_TYPE_P(zv) == IS_TRUE) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00: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-18 22:01:05 +00:00
} else if (Z_TYPE_P(zv) == IS_NULL) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00: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-18 22:01:05 +00:00
} else if (Z_TYPE_P(zv) == IS_STRING) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00: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-18 22:01:05 +00:00
if (Z_STRLEN_P(zv) > 10) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00: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-18 22:01:05 +00:00
}
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00: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-18 22:01:05 +00:00
} else if (Z_TYPE_P(zv) == IS_ARRAY) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00:00
smart_str_appends(&str, "Array");
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-18 22:01:05 +00:00
} else if (Z_TYPE_P(zv) == IS_CONSTANT_AST) {
Always use IS_CONSTANT_AST (IS_CONSTANT is removed).
2017-10-10 07:11:05 +00: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-18 22:01:05 +00:00
} else {
Avoid unnecessary reference-counting on strings.
2017-11-16 14:09:32 +00: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-21 18:47:07 +00:00
smart_str_append(&str, zv_str);
Avoid unnecessary reference-counting on strings.
2017-11-16 14:09:32 +00: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-18 22:01:05 +00:00
}
}
} else {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00: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-18 22:01:05 +00:00
}
}
Don't count variadic argument in zend_func.common.num_args. This allows faster CALL/RETURN code.
2014-12-22 13:44:39 +00:00
if (++i < num_args) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00: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-18 22:01:05 +00:00
}
arg_info++;
}
}
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00:00
smart_str_appendc(&str, ')');
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-08 20:40:36 +00:00
if (fptr->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) {
smart_str_appends(&str, ": ");
zend_append_type_hint(&str, fptr, fptr->common.arg_info - 1, 1);
}
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-20 21:27:10 +00: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-18 22:01:05 +00: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 09:39:56 +00: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 12:02:28 +00: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 10:30:16 +00:00
static void ZEND_COLD emit_incompatible_method_error(
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 09:39:56 +00:00
const zend_function *child, const zend_function *parent,
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 11:21:13 +00:00
inheritance_status status) {
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 10:30:16 +00:00
zend_string *parent_prototype = zend_get_function_declaration(parent);
zend_string *child_prototype = zend_get_function_declaration(child);
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 11:21:13 +00: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 07:33:58 +00: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 10:30:16 +00: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 07:33:58 +00: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 10:30:16 +00:00
}
zend_string_efree(child_prototype);
zend_string_efree(parent_prototype);
}
Cleanup
2019-06-25 13:37:42 +00:00
static void perform_delayable_implementation_check(
zend_class_entry *ce, const zend_function *fe,
Merge branch 'PHP-7.4' * PHP-7.4: Cleanup
2019-06-25 13:53:46 +00:00
const zend_function *proto)
Cleanup
2019-06-25 13:37:42 +00: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 11:21:13 +00:00
inheritance_status status = zend_do_perform_implementation_check(fe, proto);
Cleanup
2019-06-25 13:37:42 +00:00
if (UNEXPECTED(status != INHERITANCE_SUCCESS)) {
if (EXPECTED(status == INHERITANCE_UNRESOLVED)) {
Merge branch 'PHP-7.4' * PHP-7.4: Cleanup
2019-06-25 13:53:46 +00:00
add_compatibility_obligation(ce, fe, proto);
Reorder conditions to minimize number of checks on fast path
2019-06-25 22:00:31 +00:00
} else {
ZEND_ASSERT(status == INHERITANCE_ERROR);
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 11:21:13 +00:00
emit_incompatible_method_error(fe, proto, status);
Cleanup
2019-06-25 13:37:42 +00:00
}
}
}
Avoid double checks on early binding
2019-06-26 23:13:06 +00:00
static zend_always_inline inheritance_status do_inheritance_check_on_method_ex(zend_function *child, zend_function *parent, zend_class_entry *ce, zval *child_zv, 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-18 22:01:05 +00: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-25 21:32:22 +00: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-18 22:01:05 +00:00
Avoid double checks on early binding
2019-06-26 23:13:06 +00: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 12:02:28 +00: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-18 22:01:05 +00: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-26 23:13:06 +00: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 13:28:13 +00:00
if (child_flags & ZEND_ACC_STATIC) {
Fix lineno for more inheritance errors And also include explicit linenos in tests.
2019-03-27 12:02:28 +00: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-18 22:01:05 +00:00
} else {
Fix lineno for more inheritance errors And also include explicit linenos in tests.
2019-03-27 12:02:28 +00: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-18 22:01:05 +00:00
}
}
/* Disallow making an inherited method abstract. */
Avoid double checks on early binding
2019-06-26 23:13:06 +00: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 12:02:28 +00: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-18 22:01:05 +00:00
}
Avoid double checks on early binding
2019-06-26 23:13:06 +00: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-18 22:01:05 +00:00
child->common.fn_flags |= ZEND_ACC_CHANGED;
}
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-25 21:32:22 +00:00
if (parent_flags & ZEND_ACC_PRIVATE) {
Avoid double checks on early binding
2019-06-26 23:13:06 +00:00
return INHERITANCE_SUCCESS;
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-25 21:32:22 +00:00
}
More careful handling of function prototypes
2018-10-03 15:32:25 +00:00
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-25 21:32:22 +00: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-26 23:13:06 +00:00
return INHERITANCE_SUCCESS;
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-25 21:32:22 +00:00
}
parent = proto;
}
Fixed bug #78776 By using the normal inheritance check if the parent is abstract as well.
2019-12-18 14:53:09 +00:00
if (!check_only && child->common.prototype != proto) {
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-25 21:32:22 +00: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 10:16:10 +00:00
break;
Fixed bug #78776 By using the normal inheritance check if the parent is abstract as well.
2019-12-18 14:53:09 +00:00
} else if (child_zv) {
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-25 21:32:22 +00: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 10:16:10 +00:00
}
}
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-25 21:32:22 +00:00
child->common.prototype = proto;
} while (0);
}
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00:00
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-25 21:32:22 +00:00
/* Prevent derived classes from restricting access that was available in parent classes (except deriving from non-abstract ctors) */
Avoid double checks on early binding
2019-06-26 23:13:06 +00:00
if (!checked && (child_flags & ZEND_ACC_PPP_MASK) > (parent_flags & ZEND_ACC_PPP_MASK)) {
if (check_only) {
return INHERITANCE_ERROR;
}
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-25 21:32:22 +00: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-26 23:13:06 +00:00
if (!checked) {
if (check_only) {
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 11:21:13 +00:00
return zend_do_perform_implementation_check(child, parent);
Avoid double checks on early binding
2019-06-26 23:13:06 +00:00
}
Merge branch 'PHP-7.4' * PHP-7.4: Avoid double checks on early binding
2019-06-26 23:25:57 +00:00
perform_delayable_implementation_check(ce, child, parent);
Avoid double checks on early binding
2019-06-26 23:13:06 +00:00
}
return INHERITANCE_SUCCESS;
}
/* }}} */
Separate common code abd eliminate useless checks
2019-06-27 10:11:08 +00:00
static zend_never_inline void do_inheritance_check_on_method(zend_function *child, zend_function *parent, zend_class_entry *ce, zval *child_zv) /* {{{ */
Avoid double checks on early binding
2019-06-26 23:13:06 +00:00
{
do_inheritance_check_on_method_ex(child, parent, ce, child_zv, 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-18 22:01:05 +00:00
}
/* }}} */
Separate common code abd eliminate useless checks
2019-06-27 10:11:08 +00: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-18 22:01:05 +00:00
{
Introduced zend_hash_find_ex() that may avoid unnecessary hash value check.
2017-11-24 11:01:19 +00: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-18 22:01:05 +00:00
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
if (child) {
Fixed bug #71248 (Wrong interface is enforced)
2016-01-13 08:41:57 +00:00
zend_function *func = (zend_function*)Z_PTR_P(child);
Separate common code abd eliminate useless checks
2019-06-27 10:11:08 +00:00
if (is_interface && UNEXPECTED(func == parent)) {
typo
2018-10-03 11:35:36 +00:00
/* The same method in interface may be inherited few times */
Separate common code abd eliminate useless checks
2019-06-27 10:11:08 +00:00
return;
Avoid method compatibility check with itself
2018-10-03 09:32:33 +00:00
}
Separate common code abd eliminate useless checks
2019-06-27 10:11:08 +00:00
if (checked) {
do_inheritance_check_on_method_ex(func, parent, ce, child, 0, checked);
Avoid double checks on early binding
2019-06-26 23:13:06 +00:00
} else {
Separate common code abd eliminate useless checks
2019-06-27 10:11:08 +00:00
do_inheritance_check_on_method(func, parent, ce, child);
}
} else {
Avoid double checks on early binding
2019-06-26 23:13:06 +00:00
Separate common code abd eliminate useless checks
2019-06-27 10:11:08 +00: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-26 23:13:06 +00:00
Separate common code abd eliminate useless checks
2019-06-27 10:11:08 +00:00
if (!is_interface) {
Avoid double checks on early binding
2019-06-26 23:13:06 +00:00
_zend_hash_append_ptr(&ce->function_table, key, parent);
Separate common code abd eliminate useless checks
2019-06-27 10:11:08 +00:00
} else {
zend_hash_add_new_ptr(&ce->function_table, key, parent);
Avoid double checks on early binding
2019-06-26 23:13:06 +00:00
}
Separate common code abd eliminate useless checks
2019-06-27 10:11:08 +00:00
}
Avoid double checks on early binding
2019-06-26 23:13:06 +00: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 11:01:02 +00: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 15:01:19 +00: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 11:01:02 +00: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 11:28:51 +00: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 11:21:13 +00: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 11:01:02 +00: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 11:28:51 +00: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 11:21:13 +00: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 11:01:02 +00: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 11:28:51 +00: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 11:21:13 +00: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 11:01:02 +00: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 10:07:22 +00: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 11:21:13 +00: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 11:01:02 +00: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 11:42:47 +00: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 11:01:02 +00:00
zend_error_noreturn(E_COMPILE_ERROR,
Merge branch 'PHP-7.4' * PHP-7.4: Integrate property types with variance system
2019-10-17 11:42:47 +00: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 11:01:02 +00:00
ZSTR_VAL(child->ce->name),
Use unmangled named in property type inheritance error
2019-12-09 07:48:33 +00: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 11:42:47 +00: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 11:01:02 +00: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 11:28:51 +00:00
}
Improved code for class property inheritance
2015-03-04 14:41:01 +00: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-18 22:01:05 +00:00
{
Introduced zend_hash_find_ex() that may avoid unnecessary hash value check.
2017-11-24 11:01:19 +00:00
zval *child = zend_hash_find_ex(&ce->properties_info, key, 1);
Improved ineritance code
2015-03-04 20:06:07 +00: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-18 22:01:05 +00:00
Improved ineritance code
2015-03-04 20:06:07 +00:00
if (UNEXPECTED(child)) {
child_info = Z_PTR_P(child);
Better ZEND_ACC_CHANGED handling
2018-09-12 08:43:15 +00: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-18 22:01:05 +00:00
child_info->flags |= ZEND_ACC_CHANGED;
Better ZEND_ACC_CHANGED handling
2018-09-12 08:43:15 +00:00
}
if (!(parent_info->flags & ZEND_ACC_PRIVATE)) {
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
if (UNEXPECTED((parent_info->flags & ZEND_ACC_STATIC) != (child_info->flags & ZEND_ACC_STATIC))) {
Improved code for class property inheritance
2015-03-04 14:41:01 +00:00
zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s%s::$%s as %s%s::$%s",
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 10:59:27 +00:00
(parent_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ZSTR_VAL(ce->parent->name), ZSTR_VAL(key),
(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 14:41:01 +00:00
}
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00:00
if (UNEXPECTED((child_info->flags & ZEND_ACC_PPP_MASK) > (parent_info->flags & ZEND_ACC_PPP_MASK))) {
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 10:59:27 +00: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(ce->parent->name), (parent_info->flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
Improved code for class property inheritance
2015-03-04 14:41:01 +00: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 06:48:58 +00: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-18 22:37:24 +00:00
zval_ptr_dtor_nogc(&(ce->default_properties_table[parent_num]));
Improved code for class property inheritance
2015-03-04 14:41:01 +00: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 11:28:51 +00: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 11:01:02 +00: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 11:28:51 +00: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),
ZSTR_VAL(ce->parent->name));
}
Improved code for class property inheritance
2015-03-04 14:41:01 +00: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 08:56:45 +00: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 14:41:01 +00: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 08:56:45 +00: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-18 22:01:05 +00:00
}
Improved code for class property inheritance
2015-03-04 14:41:01 +00: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-18 22:01:05 +00:00
}
}
/* }}} */
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00: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-18 22:01:05 +00:00
{
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00: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 10:59:27 +00: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-18 22:01:05 +00: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 14:27:28 +00: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-18 22:01:05 +00: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 14:16:28 +00: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-18 22:01:05 +00: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 09:39:56 +00: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-18 22:01:05 +00:00
/* and now call the implementing handlers */
while (ce_num < ce->num_interfaces) {
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00: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-18 22:01:05 +00: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 09:40:42 +00: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-18 22:01:05 +00:00
{
Introduced zend_hash_find_ex() that may avoid unnecessary hash value check.
2017-11-24 11:01:19 +00: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 09:40:42 +00:00
Introduced zend_hash_find_ex() that may avoid unnecessary hash value check.
2017-11-24 11:01:19 +00: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 09:40:42 +00: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",
ZSTR_VAL(ce->name), ZSTR_VAL(name), zend_visibility_string(Z_ACCESS_FLAGS(parent_const->value)), ZSTR_VAL(ce->parent->name), (Z_ACCESS_FLAGS(parent_const->value) & ZEND_ACC_PUBLIC) ? "" : " or weaker");
Improved ineritance code
2015-03-04 20:06:07 +00: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 09:40:42 +00:00
} else if (!(Z_ACCESS_FLAGS(parent_const->value) & ZEND_ACC_PRIVATE)) {
Always use IS_CONSTANT_AST (IS_CONSTANT is removed).
2017-10-10 07:11:05 +00:00
if (Z_TYPE(parent_const->value) == IS_CONSTANT_AST) {
Improved ineritance code
2015-03-04 20:06:07 +00: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-18 22:01:05 +00:00
}
Fixed use-after free introduced in fcc08ce19f39f7ab1381ecc8a010037d41819329
2017-10-30 22:20:38 +00: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-30 20:13:10 +00: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-18 22:01:05 +00: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 11:28:51 +00: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 12:42:37 +00: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 11:28:51 +00: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 12:42:37 +00: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 11:28:51 +00: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 12:42:37 +00: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 11:28:51 +00: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 12:42:37 +00: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 11:28:51 +00:00
}
Avoid uninitialized entries in properties_info_table Also don't place it into xlat, there's only ever one user.
2019-02-15 12:42:37 +00: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 11:28:51 +00: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-26 23:13:06 +00: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-18 22:01:05 +00:00
{
zend_property_info *property_info;
zend_function *func;
zend_string *key;
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00: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 04:42:52 +00:00
/* Interface can only inherit other interfaces */
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00: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 10:59:27 +00: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 04:42:52 +00:00
}
Improved ineritance code
2015-03-04 20:06:07 +00: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 04:42:52 +00: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 10:59:27 +00: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 04:42:52 +00: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 10:59:27 +00: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 04:42:52 +00: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 10:59:27 +00: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 04:42:52 +00: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-18 22:01:05 +00:00
}
Replace ZEND_ACC_ANON_BOUND, ZEND_ACC_UNRESOLVED_PARENT and ZEND_ACC_UNRESOLVED_INTERFACES with single ZEND_ACC_LINKED.
2018-09-18 08:41:40 +00:00
if (ce->parent_name) {
Keep information about unresolved parent class in zend_class_entry->parent_name
2018-08-23 21:20:57 +00: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-18 22:01:05 +00: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 09:39:56 +00: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 04:42:52 +00: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-18 22:01:05 +00:00
/* Inherit 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 14:16:28 +00:00
if (parent_ce->num_interfaces) {
if (!(ce->ce_flags & ZEND_ACC_IMPLEMENT_INTERFACES)) {
zend_do_inherit_interfaces(ce, parent_ce);
} else {
uint32_t i;
for (i = 0; i < parent_ce->num_interfaces; i++) {
do_implement_interface(ce, parent_ce->interfaces[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-18 22:01:05 +00:00
/* Inherit properties */
if (parent_ce->default_properties_count) {
Improved property inheritance code
2015-04-22 09:53:54 +00: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-18 22:01:05 +00:00
if (ce->default_properties_count) {
Improved property inheritance code
2015-04-22 09:53:54 +00: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 14:36:25 +00:00
ZVAL_COPY_VALUE_PROP(dst, src);
Improved property inheritance code
2015-04-22 09:53:54 +00: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-30 20:13:10 +00: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 14:36:25 +00:00
ZVAL_COPY_OR_DUP_PROP(dst, src);
Always use IS_CONSTANT_AST (IS_CONSTANT is removed).
2017-10-10 07:11:05 +00: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-18 22:01:05 +00: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-30 20:13:10 +00: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 14:36:25 +00: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-30 20:13:10 +00: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-18 22:01:05 +00:00
ce->default_properties_count += parent_ce->default_properties_count;
}
Improved property inheritance code
2015-04-22 09:53:54 +00: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-30 20:13:10 +00: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 10:21:31 +00: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-30 20:13:10 +00:00
if (UNEXPECTED(zend_update_class_constants(parent_ce) != SUCCESS)) {
ZEND_ASSERT(0);
}
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 10:58:48 +00:00
if (Z_TYPE_P(src) == IS_INDIRECT) {
ZVAL_INDIRECT(dst, Z_INDIRECT_P(src));
Cheaper reference construction
2017-12-26 10:30:25 +00: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 10:58:48 +00:00
ZVAL_INDIRECT(dst, src);
Cheaper reference construction
2017-12-26 10:30:25 +00: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-30 20:13:10 +00: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 10:21:31 +00:00
if (CE_STATIC_MEMBERS(parent_ce) == NULL) {
Fixed bug 78175 (Preloading must store default values of static variables and properties)
2019-06-24 17:32:27 +00: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 10:21:31 +00: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 12:52:50 +00: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-30 20:13:10 +00: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 10:58:48 +00:00
if (Z_TYPE_P(src) == IS_INDIRECT) {
ZVAL_INDIRECT(dst, Z_INDIRECT_P(src));
Cheaper reference construction
2017-12-26 10:30:25 +00: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 10:58:48 +00:00
ZVAL_INDIRECT(dst, src);
Cheaper reference construction
2017-12-26 10:30:25 +00: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 10:58:48 +00: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-30 20:13:10 +00: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 10:58:48 +00: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 07:27:06 +00: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-30 20:13:10 +00:00
} while (dst != end);
}
Improved property inheritance code
2015-04-22 09:53:54 +00: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 12:52:50 +00: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-01 16:05:31 +00: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-18 22:01:05 +00: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 11:50:03 +00: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-18 22:01:05 +00:00
}
}
} ZEND_HASH_FOREACH_END();
Improved ineritance code
2015-03-04 20:06:07 +00: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 14:41:01 +00:00
Improved ineritance code
2015-03-04 20:06:07 +00: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-18 22:01:05 +00:00
Improved ineritance code
2015-03-04 20:06:07 +00: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 09:40:42 +00:00
zend_class_constant *c;
Improved ineritance code
2015-03-04 20:06:07 +00: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-18 22:01:05 +00: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 09:40:42 +00: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-04 20:06:07 +00: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-26 23:13:06 +00:00
if (checked) {
Separate common code abd eliminate useless checks
2019-06-27 10:11:08 +00: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-26 23:13:06 +00:00
} else {
ZEND_HASH_FOREACH_STR_KEY_PTR(&parent_ce->function_table, key, func) {
Separate common code abd eliminate useless checks
2019-06-27 10:11:08 +00:00
do_inherit_method(key, func, ce, 0, 0);
Avoid double checks on early binding
2019-06-26 23:13:06 +00:00
} ZEND_HASH_FOREACH_END();
}
Improved ineritance code
2015-03-04 20:06:07 +00: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-18 22:01:05 +00:00
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00: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-18 22:01:05 +00:00
Cleanup class linking
2018-08-27 13:40:25 +00:00
if (ce->type == ZEND_INTERNAL_CLASS) {
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-18 22:01:05 +00: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 11:28:51 +00: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-18 22:01:05 +00: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 09:40:42 +00: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-18 22:01:05 +00:00
{
Introduced zend_hash_find_ex() that may avoid unnecessary hash value check.
2017-11-24 11:01:19 +00: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 09:40:42 +00: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-18 22:01:05 +00:00
Introduced zend_hash_find_ex() that may avoid unnecessary hash value check.
2017-11-24 11:01:19 +00: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 09:40:42 +00: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 10:59:27 +00: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-18 22:01:05 +00: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 09:40:42 +00: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-18 22:01:05 +00: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 09:40:42 +00:00
if (do_inherit_constant_check(&ce->constants_table, c, name, iface)) {
Fixed bug #71413 (Crash with constants on internal interfaces)
2016-01-21 05:30:41 +00:00
zend_class_constant *ct;
Always use IS_CONSTANT_AST (IS_CONSTANT is removed).
2017-10-10 07:11:05 +00: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-18 22:01:05 +00:00
ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
}
Fixed use-after free introduced in fcc08ce19f39f7ab1381ecc8a010037d41819329
2017-10-30 22:20:38 +00: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-30 20:13:10 +00: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-18 22:01:05 +00:00
}
}
/* }}} */
Separate common code abd eliminate useless checks
2019-06-27 10:11:08 +00: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-13 22:06:14 +00: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-18 22:01:05 +00: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 09:40:42 +00: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-18 22:01:05 +00:00
Replace ZEND_ACC_ANON_BOUND, ZEND_ACC_UNRESOLVED_PARENT and ZEND_ACC_UNRESOLVED_INTERFACES with single ZEND_ACC_LINKED.
2018-09-18 08:41:40 +00: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 14:16:28 +00: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-18 22:01:05 +00: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-04 23:10:38 +00: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-18 22:01:05 +00:00
ignore = 1;
} else {
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 10:59:27 +00: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-18 22:01:05 +00: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 09:40:42 +00: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-18 22:01:05 +00: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 10:11:08 +00: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 14:16:28 +00: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 13:31:04 +00: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 14:16:28 +00: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 13:31:04 +00: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 14:16:28 +00: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 13:31:04 +00: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 09:39:56 +00: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 14:16:28 +00: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 13:31:04 +00: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 14:16:28 +00: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 09:39:56 +00: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 14:16:28 +00: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 13:31:04 +00:00
i = 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 14:16:28 +00:00
for (; i < ce->num_interfaces; i++) {
Separate common code abd eliminate useless checks
2019-06-27 10:11:08 +00: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 14:16:28 +00: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-18 22:01:05 +00:00
}
/* }}} */
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
static void zend_add_magic_methods(zend_class_entry* ce, zend_string* mname, zend_function* fe) /* {{{ */
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-18 22:01:05 +00:00
{
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 10:20:28 +00:00
if (zend_string_equals_literal(mname, "serialize")) {
ce->serialize_func = fe;
} else if (zend_string_equals_literal(mname, "unserialize")) {
ce->unserialize_func = fe;
Merge branch 'PHP-7.4'
2019-02-15 10:28:14 +00:00
} else if (ZSTR_VAL(mname)[0] != '_' || ZSTR_VAL(mname)[1] != '_') {
Avoid string comparisons for magic methods (all magic methods start with "__")
2018-07-02 14:03:02 +00:00
/* pass */
} else if (zend_string_equals_literal(mname, ZEND_CLONE_FUNC_NAME)) {
Remove the ZEND_ACC_CLONE flag This one is completely unused
2017-04-22 13:44:24 +00:00
ce->clone = fe;
Fixed bug #71275 (Bad method called on cloning an object having a trait)
2016-01-05 15:27:18 +00:00
} else if (zend_string_equals_literal(mname, ZEND_CONSTRUCTOR_FUNC_NAME)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00:00
ce->constructor = fe;
Fixed bug #71275 (Bad method called on cloning an object having a trait)
2016-01-05 15:27:18 +00:00
} else if (zend_string_equals_literal(mname, ZEND_DESTRUCTOR_FUNC_NAME)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 10:16:10 +00:00
ce->destructor = fe;
Fixed bug #71275 (Bad method called on cloning an object having a trait)
2016-01-05 15:27:18 +00:00
} else if (zend_string_equals_literal(mname, ZEND_GET_FUNC_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-18 22:01:05 +00:00
ce->__get = fe;
Move zend_object->guards into additional slot of zend_object->properties_table[]. As result size of objects without __get/__set/__unset/__isset magic methods is reduced.
2015-02-04 12:24:13 +00:00
ce->ce_flags |= ZEND_ACC_USE_GUARDS;
Fixed bug #71275 (Bad method called on cloning an object having a trait)
2016-01-05 15:27:18 +00:00
} else if (zend_string_equals_literal(mname, ZEND_SET_FUNC_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-18 22:01:05 +00:00
ce->__set = fe;
Move zend_object->guards into additional slot of zend_object->properties_table[]. As result size of objects without __get/__set/__unset/__isset magic methods is reduced.
2015-02-04 12:24:13 +00:00
ce->ce_flags |= ZEND_ACC_USE_GUARDS;
Fixed bug #71275 (Bad method called on cloning an object having a trait)
2016-01-05 15:27:18 +00:00
} else if (zend_string_equals_literal(mname, ZEND_CALL_FUNC_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-18 22:01:05 +00:00
ce->__call = fe;
Fixed bug #71275 (Bad method called on cloning an object having a trait)
2016-01-05 15:27:18 +00:00
} else if (zend_string_equals_literal(mname, ZEND_UNSET_FUNC_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-18 22:01:05 +00:00
ce->__unset = fe;
Move zend_object->guards into additional slot of zend_object->properties_table[]. As result size of objects without __get/__set/__unset/__isset magic methods is reduced.
2015-02-04 12:24:13 +00:00
ce->ce_flags |= ZEND_ACC_USE_GUARDS;
Fixed bug #71275 (Bad method called on cloning an object having a trait)
2016-01-05 15:27:18 +00:00
} else if (zend_string_equals_literal(mname, ZEND_ISSET_FUNC_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-18 22:01:05 +00:00
ce->__isset = fe;
Move zend_object->guards into additional slot of zend_object->properties_table[]. As result size of objects without __get/__set/__unset/__isset magic methods is reduced.
2015-02-04 12:24:13 +00:00
ce->ce_flags |= ZEND_ACC_USE_GUARDS;
Fixed bug #71275 (Bad method called on cloning an object having a trait)
2016-01-05 15:27:18 +00:00
} else if (zend_string_equals_literal(mname, ZEND_CALLSTATIC_FUNC_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-18 22:01:05 +00:00
ce->__callstatic = fe;
Fixed bug #71275 (Bad method called on cloning an object having a trait)
2016-01-05 15:27:18 +00:00
} else if (zend_string_equals_literal(mname, ZEND_TOSTRING_FUNC_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-18 22:01:05 +00:00
ce->__tostring = fe;
Fixed bug #71275 (Bad method called on cloning an object having a trait)
2016-01-05 15:27:18 +00:00
} else if (zend_string_equals_literal(mname, ZEND_DEBUGINFO_FUNC_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-18 22:01:05 +00:00
ce->__debugInfo = fe;
}
}
/* }}} */
Fix some misspellings
2018-08-10 02:19:55 +00:00
static void zend_add_trait_method(zend_class_entry *ce, const char *name, zend_string *key, zend_function *fn, HashTable **overridden) /* {{{ */
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-18 22:01:05 +00: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-21 16:40:06 +00: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-03 16:30:03 +00: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-21 16:40:06 +00: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-09-30 20:24:38 +00: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-18 22:01:05 +00:00
if (existing_fn->common.scope == ce) {
/* members from the current class override trait methods */
Fix some misspellings
2018-08-10 02:19:55 +00:00
/* use temporary *overridden HashTable to detect hidden conflict */
if (*overridden) {
if ((existing_fn = zend_hash_find_ptr(*overridden, key)) != 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-18 22:01:05 +00:00
if (existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
/* Make sure the trait method is compatible with previosly declared abstract method */
Merge branch 'PHP-7.4' * PHP-7.4: Cleanup
2019-06-25 13:53:46 +00:00
perform_delayable_implementation_check(ce, fn, existing_fn);
Fix bug #74607: Don't check for bi-directional compatibility in traits
2017-05-21 12:41:55 +00:00
}
if (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-18 22:01:05 +00:00
/* Make sure the abstract declaration is compatible with previous declaration */
Merge branch 'PHP-7.4' * PHP-7.4: Cleanup
2019-06-25 13:53:46 +00:00
perform_delayable_implementation_check(ce, existing_fn, 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-18 22:01:05 +00:00
return;
}
}
} else {
Fix some misspellings
2018-08-10 02:19:55 +00:00
ALLOC_HASHTABLE(*overridden);
zend_hash_init_ex(*overridden, 8, NULL, overridden_ptr_dtor, 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-18 22:01:05 +00:00
}
Fix some misspellings
2018-08-10 02:19:55 +00:00
zend_hash_update_mem(*overridden, key, fn, sizeof(zend_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-18 22:01:05 +00:00
return;
Fixed bug #78776 By using the normal inheritance check if the parent is abstract as well.
2019-12-18 14:53:09 +00:00
} else if ((fn->common.fn_flags & ZEND_ACC_ABSTRACT)
&& !(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-18 22:01:05 +00:00
/* Make sure the abstract declaration is compatible with previous declaration */
Merge branch 'PHP-7.4' * PHP-7.4: Cleanup
2019-06-25 13:53:46 +00:00
perform_delayable_implementation_check(ce, existing_fn, 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-18 22:01:05 +00:00
return;
Fixed bug #78776 By using the normal inheritance check if the parent is abstract as well.
2019-12-18 14:53:09 +00: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-18 22:01:05 +00:00
/* two traits can't define the same non-abstract method */
#if 1
zend_error_noreturn(E_COMPILE_ERROR, "Trait method %s has not been applied, because there are collisions with other trait methods on %s",
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 10:59:27 +00:00
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-18 22:01:05 +00:00
#else /* TODO: better error message */
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 10:59:27 +00:00
ZSTR_VAL(fn->common.scope->name), ZSTR_VAL(fn->common.function_name),
ZSTR_VAL(ce->name), name,
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-18 22:01:05 +00:00
#endif
} else {
/* inherited members are overridden by members inserted by traits */
/* check whether the trait method fulfills the inheritance requirements */
More careful handling of function prototypes
2018-10-03 15:32:25 +00:00
do_inheritance_check_on_method(fn, existing_fn, ce, NULL);
Merge branch 'PHP-5.6' Conflicts: Zend/zend_compile.c
2015-04-10 14:50:15 +00:00
fn->common.prototype = 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-18 22:01:05 +00:00
}
}
Fixed incorrect ZEND_ACC_ARENA_ALLOCATED usage (it must be used only for internal functions).
2018-08-29 20:40:17 +00: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 13:32:07 +00: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 12:52:50 +00: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-29 20:40:17 +00:00
}
Call function_add_ref() in proper place
2018-10-30 12:08:45 +00: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-18 22:01:05 +00:00
fn = zend_hash_update_ptr(&ce->function_table, key, new_fn);
first shot remove TSRMLS_* things
2014-12-13 22:06:14 +00:00
zend_add_magic_methods(ce, key, 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-18 22:01:05 +00: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 02:35:55 +00: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-18 22:01:05 +00:00
ce->ce_flags |= ZEND_HAS_STATIC_IN_METHODS;
}
}
}
/* }}} */
Replace zend_hash_apply... with ZEND_HASH_FOREACH...
2018-12-18 23:49:56 +00:00
static void zend_traits_copy_functions(zend_string *fnname, zend_function *fn, zend_class_entry *ce, HashTable **overridden, 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-18 22:01:05 +00: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 15:56:10 +00: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-18 22:01:05 +00: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 15:56:10 +00: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-18 22:01:05 +00:00
while (alias) {
/* Scope unset or equal to the function we compare to, and the alias applies to fn */
if (alias->alias != 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 15:56:10 +00:00
&& (!aliases[i] || fn->common.scope == aliases[i])
&& ZSTR_LEN(alias->trait_method.method_name) == ZSTR_LEN(fnname)
&& (zend_binary_strcasecmp(ZSTR_VAL(alias->trait_method.method_name), ZSTR_LEN(alias->trait_method.method_name), ZSTR_VAL(fnname), ZSTR_LEN(fnname)) == 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-18 22:01:05 +00:00
fn_copy = *fn;
/* if it is 0, no modifieres has been changed */
if (alias->modifiers) {
fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags ^ (fn->common.fn_flags & ZEND_ACC_PPP_MASK));
}
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 12:04:51 +00:00
lcname = zend_string_tolower(alias->alias);
Fix some misspellings
2018-08-10 02:19:55 +00:00
zend_add_trait_method(ce, ZSTR_VAL(alias->alias), lcname, &fn_copy, overridden);
Use zend_string_release_ex() instread of zend_string_release() in places, where we sure about string persistence.
2018-05-28 13:27:12 +00: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-18 22:01:05 +00:00
/* Record the trait from which this alias was resolved. */
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 15:56:10 +00:00
if (!aliases[i]) {
aliases[i] = fn->common.scope;
}
if (!alias->trait_method.class_name) {
/* TODO: try to avoid this assignment (it's necessary only for reflection) */
alias->trait_method.class_name = zend_string_copy(fn->common.scope->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-18 22:01:05 +00: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 15:56:10 +00: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-18 22:01:05 +00:00
}
}
if (exclude_table == NULL || zend_hash_find(exclude_table, fnname) == NULL) {
/* is not in hashtable, thus, function is not to be excluded */
Fixed invalid read (Part issue of #69579)
2015-07-10 14:26:53 +00:00
/* And how about ZEND_OVERLOADED_FUNCTION? */
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-18 22:01:05 +00: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 15:56:10 +00: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-18 22:01:05 +00: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
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 15:56:10 +00:00
&& (!aliases[i] || fn->common.scope == aliases[i])
&& (ZSTR_LEN(alias->trait_method.method_name) == ZSTR_LEN(fnname))
&& (zend_binary_strcasecmp(ZSTR_VAL(alias->trait_method.method_name), ZSTR_LEN(alias->trait_method.method_name), ZSTR_VAL(fnname), ZSTR_LEN(fnname)) == 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-18 22:01:05 +00:00
fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags ^ (fn->common.fn_flags & ZEND_ACC_PPP_MASK));
/** Record the trait from which this alias was resolved. */
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 15:56:10 +00:00
if (!aliases[i]) {
aliases[i] = fn->common.scope;
}
if (!alias->trait_method.class_name) {
/* TODO: try to avoid this assignment (it's necessary only for reflection) */
alias->trait_method.class_name = zend_string_copy(fn->common.scope->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-18 22:01:05 +00: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 15:56:10 +00: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-18 22:01:05 +00:00
}
}
Fix some misspellings
2018-08-10 02:19:55 +00:00
zend_add_trait_method(ce, ZSTR_VAL(fn->common.function_name), fnname, &fn_copy, overridden);
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-18 22:01:05 +00: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-22 23:02:26 +00: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-18 22:01:05 +00:00
{
uint32_t i;
Improved method inhereitance code and cleanup
2015-03-04 23:10:38 +00: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 10:59:27 +00: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 15:56:10 +00: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-18 22:01:05 +00: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-22 23:02:26 +00: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 15:56:10 +00: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-18 22:01:05 +00:00
}
}
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 10:59:27 +00: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 15:56:10 +00: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-18 22:01:05 +00: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-22 23:02:26 +00: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-18 22:01:05 +00:00
{
size_t i, j = 0;
Merge branch 'PHP-5.6'
2015-03-05 13:06:59 +00: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-18 22:01:05 +00: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 15:56:10 +00: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-18 22:01:05 +00: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 15:56:10 +00: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-18 22:01:05 +00:00
i = 0;
Merge branch 'PHP-5.6'
2015-03-05 13:06:59 +00: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-18 22:01:05 +00: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 15:56:10 +00: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-22 23:02:26 +00: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 15:56:10 +00:00
/** Ensure that the preferred method is actually available. */
lcname = zend_string_tolower(cur_method_ref->method_name);
Micro-optimization
2018-09-19 10:54:37 +00: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 15:56:10 +00: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-18 22:01:05 +00: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 15:56:10 +00: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-18 22:01:05 +00: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 15:56:10 +00: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-18 22:01:05 +00: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 15:56:10 +00: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-22 23:02:26 +00: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 15:56:10 +00: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-18 22:01:05 +00: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 15:56:10 +00: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-18 22:01:05 +00: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 15:56:10 +00: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-18 22:01:05 +00:00
i++;
}
Merge branch 'PHP-5.6'
2015-03-05 13:06:59 +00: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-18 22:01:05 +00: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 15:56:10 +00: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-18 22:01:05 +00:00
i = 0;
while (ce->trait_aliases[i]) {
/** 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 15:56:10 +00:00
if (ce->trait_aliases[i]->trait_method.class_name) {
cur_method_ref = &ce->trait_aliases[i]->trait_method;
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 10:59:27 +00: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-18 22:01:05 +00: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-22 23:02:26 +00: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 15:56:10 +00: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-18 22:01:05 +00:00
/** And, ensure that the referenced method is resolvable, too. */
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 12:04:51 +00:00
lcname = zend_string_tolower(cur_method_ref->method_name);
Micro-optimization
2018-09-19 10:54:37 +00: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 15:56:10 +00: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-18 22:01:05 +00:00
}
Micro-optimization
2018-09-19 10:54:37 +00: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-18 22:01:05 +00: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 15:56:10 +00: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-18 22:01:05 +00: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-22 23:02:26 +00: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-18 22:01:05 +00:00
{
uint32_t i;
Fix some misspellings
2018-08-10 02:19:55 +00:00
HashTable *overridden = 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-18 22:01:05 +00:00
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 15:56:10 +00: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-22 23:02:26 +00: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) {
zend_traits_copy_functions(key, fn, ce, &overridden, exclude_tables[i], aliases);
} 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 15:56:10 +00: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-22 23:02:26 +00:00
if (traits[i]) {
ZEND_HASH_FOREACH_STR_KEY_PTR(&traits[i]->function_table, key, fn) {
zend_traits_copy_functions(key, fn, ce, &overridden, NULL, aliases);
} 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-18 22:01:05 +00:00
}
}
ZEND_HASH_FOREACH_PTR(&ce->function_table, fn) {
zend_fixup_trait_method(fn, ce);
} ZEND_HASH_FOREACH_END();
Fix some misspellings
2018-08-10 02:19:55 +00:00
if (overridden) {
zend_hash_destroy(overridden);
FREE_HASHTABLE(overridden);
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-18 22:01:05 +00: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-22 23:02:26 +00: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-18 22:01:05 +00: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-22 23:02:26 +00: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-18 22:01:05 +00: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-22 23:02:26 +00: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-18 22:01:05 +00:00
{
size_t i;
zend_property_info *property_info;
zend_property_info *coliding_prop;
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-22 23:02:26 +00: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-18 22:01:05 +00: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 10:43:05 +00: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-18 22:01:05 +00: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 08:56:45 +00: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-18 22:01:05 +00: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 00:31:03 +00:00
not_compatible = 1;
Trailing whitespaces Signed-off-by: Gabriel Caruso <carusogabriel34@gmail.com>
2017-12-31 04:35:25 +00: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-18 22:01:05 +00: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 11:28:51 +00: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 11:01:02 +00: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 11:28:51 +00:00
) {
Fix #74922 - Try to resolve constants when importing trait properties
2017-09-27 00:31:03 +00: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-01 16:08:11 +00:00
zval *op1, *op2;
Merge branch 'PHP-7.2'
2017-12-16 16:10:09 +00:00
zval op1_tmp, op2_tmp;
Fix #74922 - Try to resolve constants when importing trait properties
2017-09-27 00:31:03 +00: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-18 22:01:05 +00:00
if (flags & ZEND_ACC_STATIC) {
Fix #75607 - Check if existing static trait property is a ref before comparing
2017-12-01 16:08:11 +00: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-22 23:02:26 +00: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 10:58:48 +00: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-18 22:01:05 +00:00
} else {
Fix #75607 - Check if existing static trait property is a ref before comparing
2017-12-01 16:08:11 +00: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-22 23:02:26 +00: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 00:31:03 +00:00
}
/* if any of the values is a constant, we try to resolve it */
Merge branch 'PHP-7.2'
2017-12-16 16:10:09 +00: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-18 22:01:05 +00:00
}
Merge branch 'PHP-7.2'
2017-12-16 16:10:09 +00: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 00:31:03 +00:00
}
Fix #75607 - Check if existing static trait property is a ref before comparing
2017-12-01 16:08:11 +00:00
not_compatible = fast_is_not_identical_function(op1, op2);
Merge branch 'PHP-7.2'
2017-12-16 16:10:09 +00: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-18 22:01:05 +00: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-22 23:02:26 +00: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 10:59:27 +00: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-18 22:01:05 +00: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 08:47:25 +00:00
Use zend_string_release_ex() instread of zend_string_release() in places, where we sure about string persistence.
2018-05-28 13:27:12 +00: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 08:47:25 +00: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-18 22:01:05 +00: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-22 23:02:26 +00: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 10:58:48 +00: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-18 22:01:05 +00: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-22 23:02:26 +00: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-18 22:01:05 +00:00
}
RC manipulation cleanup
2017-11-01 02:25:10 +00: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-18 22:01:05 +00:00
doc_comment = property_info->doc_comment ? zend_string_copy(property_info->doc_comment) : NULL;
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 11:21:13 +00:00
zend_type_copy_ctor(&property_info->type, /* persistent */ 0);
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 11:28:51 +00:00
zend_declare_typed_property(ce, prop_name, prop_value, flags, doc_comment, property_info->type);
Use zend_string_release_ex() instread of zend_string_release() in places, where we sure about string persistence.
2018-05-28 13:27:12 +00: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-18 22:01:05 +00:00
} ZEND_HASH_FOREACH_END();
}
}
/* }}} */
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 15:56:10 +00:00
static void zend_do_check_for_inconsistent_traits_aliasing(zend_class_entry *ce, 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-18 22:01:05 +00:00
{
int i = 0;
zend_trait_alias* cur_alias;
zend_string* lc_method_name;
if (ce->trait_aliases) {
while (ce->trait_aliases[i]) {
cur_alias = ce->trait_aliases[i];
/** The trait for this alias has not been resolved, this means, this
alias was not applied. Abort with an error. */
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 15:56:10 +00:00
if (!aliases[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-18 22:01:05 +00:00
if (cur_alias->alias) {
/** Plain old inconsistency/typo/bug */
zend_error_noreturn(E_COMPILE_ERROR,
"An alias (%s) was defined for method %s(), but this method does not exist",
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 10:59:27 +00:00
ZSTR_VAL(cur_alias->alias),
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 15:56:10 +00:00
ZSTR_VAL(cur_alias->trait_method.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-18 22:01:05 +00:00
} else {
/** Here are two possible cases:
Fix typos in code comments in Zend/ [skip ci]
2019-02-18 16:35:35 +00:00
1) this is an attempt to modify the visibility
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-18 22:01:05 +00:00
of a method introduce as part of another alias.
Since that seems to violate the DRY principle,
we check against it and abort.
2) it is just a plain old inconsitency/typo/bug
as in the case where alias is set. */
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 12:04:51 +00:00
lc_method_name = zend_string_tolower(
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 15:56:10 +00:00
cur_alias->trait_method.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-18 22:01:05 +00:00
if (zend_hash_exists(&ce->function_table,
lc_method_name)) {
Use zend_string_release_ex() instread of zend_string_release() in places, where we sure about string persistence.
2018-05-28 13:27:12 +00:00
zend_string_release_ex(lc_method_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-18 22:01:05 +00:00
zend_error_noreturn(E_COMPILE_ERROR,
typo fixes - https://github.com/vlajos/misspell_fixer
2014-11-19 19:59:31 +00:00
"The modifiers for the trait alias %s() need to be changed in the same statement in which the alias is defined. Error",
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 15:56:10 +00:00
ZSTR_VAL(cur_alias->trait_method.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-18 22:01:05 +00:00
} else {
Use zend_string_release_ex() instread of zend_string_release() in places, where we sure about string persistence.
2018-05-28 13:27:12 +00:00
zend_string_release_ex(lc_method_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-18 22:01:05 +00:00
zend_error_noreturn(E_COMPILE_ERROR,
"The modifiers of the trait method %s() are changed, but this method does not exist. Error",
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 15:56:10 +00:00
ZSTR_VAL(cur_alias->trait_method.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-18 22:01:05 +00:00
}
}
}
i++;
}
}
}
/* }}} */
Cleanup class linking
2018-08-27 13:40:25 +00: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-18 22:01:05 +00: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 15:56:10 +00: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-22 23:02:26 +00: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-18 22:01:05 +00: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 14:16:28 +00: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-18 22:01:05 +00: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-22 23:02:26 +00: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-18 22:01:05 +00: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-22 23:02:26 +00: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-18 22:01:05 +00: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-22 23:02:26 +00: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-18 22:01:05 +00:00
/* Aliases which have not been applied indicate typos/bugs. */
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 15:56:10 +00:00
zend_do_check_for_inconsistent_traits_aliasing(ce, aliases);
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-18 22:01:05 +00: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-22 23:02:26 +00:00
zend_do_traits_property_binding(ce, traits);
efree(traits);
Deprecate PHP 4 constructors
2015-03-31 14:10:22 +00:00
}
/* }}} */
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 09:56:17 +00: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) /* {{{ */
{
if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
if (ai->cnt < MAX_ABSTRACT_INFO_CNT) {
ai->afn[ai->cnt] = fn;
}
Fixed bug #77613 (method visibility change) (reverted ZEND_ACC_CTOR and ZEND_ACC_DTOR flags removal)
2019-02-14 10:12:50 +00:00
if (fn->common.fn_flags & ZEND_ACC_CTOR) {
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 09:56:17 +00:00
if (!ai->ctor) {
ai->cnt++;
ai->ctor = 1;
} else {
ai->afn[ai->cnt] = NULL;
}
} else {
ai->cnt++;
}
}
}
/* }}} */
void zend_verify_abstract_class(zend_class_entry *ce) /* {{{ */
{
zend_function *func;
zend_abstract_info ai;
Cleanup class linking
2018-08-27 13:40:25 +00:00
ZEND_ASSERT((ce->ce_flags & (ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) == ZEND_ACC_IMPLICIT_ABSTRACT_CLASS);
memset(&ai, 0, sizeof(ai));
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 09:56:17 +00:00
Cleanup class linking
2018-08-27 13:40:25 +00:00
ZEND_HASH_FOREACH_PTR(&ce->function_table, func) {
zend_verify_abstract_class_function(func, &ai);
} ZEND_HASH_FOREACH_END();
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 09:56:17 +00:00
Cleanup class linking
2018-08-27 13:40:25 +00:00
if (ai.cnt) {
zend_error_noreturn(E_ERROR, "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 ")",
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 09:39:56 +00: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 11:01:02 +00: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 09:39:56 +00:00
union {
zend_class_entry *dependency_ce;
struct {
const zend_function *parent_fn;
const zend_function *child_fn;
};
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 11:01:02 +00: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 09:39:56 +00: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(
Merge branch 'PHP-7.4'
2019-06-11 11:15:03 +00:00
zend_class_entry *ce, const zend_function *child_fn, const zend_function *parent_fn) {
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 09:39:56 +00:00
HashTable *obligations = get_or_init_obligations_for_class(ce);
variance_obligation *obligation = emalloc(sizeof(variance_obligation));
obligation->type = OBLIGATION_COMPATIBILITY;
obligation->child_fn = child_fn;
obligation->parent_fn = parent_fn;
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 11:01:02 +00: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 09:39:56 +00: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 11:01:02 +00: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 09:39:56 +00:00
inheritance_status status = zend_do_perform_implementation_check(
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 11:21:13 +00:00
obligation->child_fn, obligation->parent_fn);
Reorder conditions to minimize number of checks on fast path
2019-06-25 22:00:31 +00:00
if (UNEXPECTED(status != INHERITANCE_SUCCESS)) {
if (EXPECTED(status == INHERITANCE_UNRESOLVED)) {
return ZEND_HASH_APPLY_KEEP;
}
ZEND_ASSERT(status == INHERITANCE_ERROR);
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 11:21:13 +00:00
emit_incompatible_method_error(obligation->child_fn, obligation->parent_fn, 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 09:39:56 +00: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 11:01:02 +00: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 09:39:56 +00: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 11:01:02 +00: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 11:21:13 +00: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(
obligation->child_fn, obligation->parent_fn);
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 11:01:02 +00:00
ZEND_ASSERT(status == INHERITANCE_UNRESOLVED);
Merge branch 'PHP-7.4' * PHP-7.4: Integrate property types with variance system
2019-10-17 11:42:47 +00:00
emit_incompatible_method_error(
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 11:21:13 +00:00
obligation->child_fn, obligation->parent_fn, 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 11:01:02 +00: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 09:39:56 +00: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 13:31:04 +00: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");
ZVAL_OBJ(&exception_zv, EG(exception));
Z_ADDREF(exception_zv);
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));
}
}
ZEND_API int zend_do_link_class(zend_class_entry *ce, zend_string *lc_parent_name) /* {{{ */
Cleanup class linking
2018-08-27 13:40:25 +00: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 13:31:04 +00: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 12:28:44 +00: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 13:31:04 +00: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 09:39:56 +00:00
if (!(parent->ce_flags & ZEND_ACC_LINKED)) {
add_dependency_obligation(ce, parent);
}
Cleanup class linking
2018-08-27 13:40:25 +00:00
zend_do_inheritance(ce, parent);
}
if (ce->ce_flags & ZEND_ACC_IMPLEMENT_TRAITS) {
zend_do_bind_traits(ce);
}
if (ce->ce_flags & ZEND_ACC_IMPLEMENT_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 13:31:04 +00:00
zend_do_implement_interfaces(ce, interfaces);
Cleanup class linking
2018-08-27 13:40:25 +00:00
}
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);
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 09:56:17 +00: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 11:28:51 +00: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 09:39:56 +00: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 13:31:04 +00: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 09:39:56 +00: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 14:27:28 +00: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 09:39:56 +00: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 13:31:04 +00:00
return SUCCESS;
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 09:56:17 +00:00
}
Avoid double checks on early binding
2019-06-26 23:13:06 +00: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 08:41:06 +00:00
/* Check whether early binding is prevented due to unresolved types in inheritance checks. */
Avoid double checks on early binding
2019-06-26 23:13:06 +00: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 08:41:06 +00: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 11:01:02 +00:00
zend_property_info *parent_info;
Prevent useless hash lookups
2019-06-25 09:41:06 +00:00
Avoid double checks on early binding
2019-06-26 23:13:06 +00: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 =
do_inheritance_check_on_method_ex(child_func, parent_func, ce, NULL, 1, 0);
Fixed variance check for abstract constructor during erlay binding
2019-06-25 14:43:46 +00:00
Avoid double checks on early binding
2019-06-26 23:13:06 +00:00
if (UNEXPECTED(status != INHERITANCE_SUCCESS)) {
Merge branch 'PHP-7.4' * PHP-7.4: Avoid double checks on early binding
2019-06-26 23:25:57 +00:00
return status;
Fixed variance check for abstract constructor during erlay binding
2019-06-25 14:43:46 +00: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 08:41:06 +00:00
}
Avoid double checks on early binding
2019-06-26 23:13:06 +00:00
} ZEND_HASH_FOREACH_END();
Prevent useless hash lookups
2019-06-25 09:41:06 +00: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 11:01:02 +00: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 11:42:47 +00: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 11:01:02 +00:00
}
}
}
} ZEND_HASH_FOREACH_END();
Merge branch 'PHP-7.4' * PHP-7.4: Avoid double checks on early binding
2019-06-26 23:25:57 +00:00
return INHERITANCE_SUCCESS;
Avoid double checks on early binding
2019-06-26 23:13:06 +00:00
}
/* }}} */
Reorder conditions to minimize number of checks on fast path
2019-06-25 22:00:31 +00:00
Avoid double checks on early binding
2019-06-26 23:13:06 +00: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-25 22:00:31 +00:00
Avoid double checks on early binding
2019-06-26 23:13:06 +00: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-25 22:00:31 +00: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 08:41:06 +00:00
}
Avoid double checks on early binding
2019-06-26 23:13:06 +00:00
zend_do_inheritance_ex(ce, parent_ce, status == INHERITANCE_SUCCESS);
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 08:41:06 +00:00
}
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 09:56:17 +00:00
/* }}} */
Reference in New Issue Copy Permalink