Using "namespace" as a class constant name

Declaring a class constant named namespace is now deprecated. namespace is a semi-reserved keyword, and the name is being reserved for possible future syntax such as a ::namespace pseudo-constant analogous to ::class. Methods and static properties named namespace are not affected. Rename the constant, for example to NAMESPACE_NAME.

Returning from a finally block

Using the return statement inside a finally block is now deprecated, and emits a compile-time deprecation notice. Such a return silently discards an exception thrown by, or overwrites the value returned from, the associated try or catch block, so failures vanish without a trace. Move the return out of the finally block instead; the same result can always be expressed without it.

<?php
function getConfig(): array
{
    try {
        return loadConfig(); // throws if the file is missing
    } finally {
        return []; // Deprecated: the exception is gone, the caller just gets []
    }
}

Nullable return type for __debugInfo()

Declaring a return type of ?array for __debugInfo() is now deprecated. Returning null from this method was already deprecated in PHP 8.5, so the nullable return type no longer describes valid behaviour. Declare array instead.

Returning values from __construct() and __destruct()

Returning a value from __construct() or __destruct() is now deprecated, and emits a compile-time deprecation notice. These methods cannot declare a return type, and their return value can never be observed during normal use, which made returning a value confusing at best. Using return; without a value to skip the remaining logic is still allowed, as is calling these methods manually.

For the same reason, using yield to make __construct() or __destruct() a generator is now deprecated.

Naming a function readonly

Declaring a function named readonly is now deprecated. readonly is a reserved keyword; a lexer exception was added in PHP 8.1 solely to keep an existing WordPress function of that name working, and no other keyword in PHP receives such special treatment. Rename the function.

Using let, is, or _ as an identifier

Using let or is as the name of a class, interface, trait, enum, function, or constant (including via define()) is now deprecated, as is using either as the alias in a class_alias() call or in a use, use function, or use const declaration. The names are being reserved as keywords for potential future features: let for block scoping and is for pattern matching. Rename the affected symbols.

The deprecation of _ as a class name in PHP 8.4 is extended to constants: declaring a constant named _ with const or define(), and aliasing a class or constant to _ in a use declaration, are now deprecated. Functions named _, including the _() alias of gettext(), are not affected.

Third argument to define()

Passing the case_insensitive argument to define() is now deprecated. Case-insensitive constants were removed in PHP 8.0, since when the argument has been ignored. Explicitly passing false now emits a deprecation notice. Passing true continues to emit a warning, whose message now states that this will become an error in PHP 9.0. Omit the argument.

is_a() and is_subclass_of() with a string when allow_string is false

Calling is_a() or is_subclass_of() with a string as the first argument while allow_string is false is now deprecated. In that case the functions always return false, even when the class is already loaded, so such a call indicates a bug. To avoid triggering autoloading, check class_exists() with autoloading disabled first, and then call the function with allow_string set to true.

metaphone()

The metaphone() function is now deprecated. It implements the original 1990 Metaphone algorithm, which is limited to English pronunciation rules and has long been superseded by Double Metaphone and Metaphone 3. Phonetic algorithms are language-specific and frequently updated, so they are better served by a userland library; use one instead.

More than 16 filters in a php://filter URL

Using more than 16 filters in a php://filter URL without configuring the filter.max_filter_count stream context option now emits a deprecation notice. Long filter chains have no known legitimate use, but are the basis of a class of attacks that turn a local file inclusion or an arbitrary file read into remote code execution. When filter.max_filter_count is set explicitly, exceeding it is already an error: opening the stream fails with a warning.

Code that needs more filters should either add them with stream_filter_append() or stream_filter_prepend(), which are not limited, or raise the limit through the context option, for example globally with stream_context_set_default().

Passing objects to array_walk(), array_walk_recursive(), and http_build_query()

Passing an object as the array argument to array_walk() or array_walk_recursive() is now deprecated. A small number of functions silently interpret an object as the array of its visible properties. Modifying such properties through a by-reference callback violates readonly semantics and can corrupt enum cases, and array_walk_recursive() does not recurse into nested objects anyway. Call get_object_vars() on the object first and pass the resulting array.

Passing an object as the data argument to http_build_query() is now deprecated. Objects encountered as values within data now also emit a deprecation notice when they are interpreted as arrays. Treating objects as arrays has been a recurring source of confusion, in particular for Stringable objects, which users expect to be converted to a string instead. Convert objects to arrays with get_object_vars(), recursively if necessary, before calling the function.

is_double(), is_long(), is_integer(), and doubleval()

Following the deprecation of the non-canonical cast names in PHP 8.5, the function aliases that carry the same outdated type names are now deprecated. They behave identically to their canonical counterparts, which should be used instead:

• is_double() => is_float()
• is_long() => is_int()
• is_integer() => is_int()
• doubleval() => floatval()

strcoll() and SORT_LOCALE_STRING

The strcoll() function is now deprecated. It compares strings according to the LC_COLLATE setting of the current locale, which is global process state set via setlocale() that any library can change, it is not binary safe unlike every other string comparison function, and some locales do not implement correct collation rules. Use Collator::compare() from the intl extension instead, which is accurate and has up-to-date collation rules.

The SORT_LOCALE_STRING flag of the sort functions is now deprecated for the same reasons, as it sorts using strcoll(). Use one of the following methods of the Collator class instead:

• Collator::sort()
• Collator::asort()
• Collator::sortWithSortKeys()