enmi-conf.org: comparison wp/wp-includes/taxonomy.php

equal deleted inserted replaced

-:3d4e9c994f10
+:a86126ab1dd4
 * @package WordPress
 * @subpackage Taxonomy
 */
 //
-// Taxonomy Registration
+// Taxonomy registration.
 //
 /**
 * Creates the initial taxonomies.
 *
 * backward compatibility reasons), and again on the {@see 'init'} action. We must
 * avoid registering rewrite rules before the {@see 'init'} action.
 *
 * @since 2.8.0
 *
-* @global WP_Rewrite $wp_rewrite The WordPress rewrite class.
+* @global WP_Rewrite $wp_rewrite WordPress rewrite component.
 */
 function create_initial_taxonomies() {
 	global $wp_rewrite;
 	if ( ! did_action( 'init' ) ) {
 * @return string[]|WP_Taxonomy[] An array of taxonomy names or objects.
 */
 function get_taxonomies( $args = array(), $output = 'names', $operator = 'and' ) {
 	global $wp_taxonomies;
-	$field = ( 'names' == $output ) ? 'name' : false;
+	$field = ( 'names' === $output ) ? 'name' : false;
 	return wp_filter_object_list( $wp_taxonomies, $args, $operator, $field );
 }
 /**
 *
 * @since 2.3.0
 *
 * @global array $wp_taxonomies The registered taxonomies.
 *
-* @param array|string|WP_Post $object Name of the type of taxonomy object, or an object (row from posts)
+* @param string|string[]|WP_Post $object Name of the type of taxonomy object, or an object (row from posts)
-* @param string               $output Optional. The type of output to return in the array. Accepts either
+* @param string                  $output Optional. The type of output to return in the array. Accepts either
-*                                     taxonomy 'names' or 'objects'. Default 'names'.
+*                                        'names' or 'objects'. Default 'names'.
-* @return array The names of all taxonomy of $object_type.
+* @return string[]|WP_Taxonomy[] The names or objects of all taxonomies of `$object_type`.
 */
 function get_object_taxonomies( $object, $output = 'names' ) {
 	global $wp_taxonomies;
 	if ( is_object( $object ) ) {
-		if ( $object->post_type == 'attachment' ) {
+		if ( 'attachment' === $object->post_type ) {
 			return get_attachment_taxonomies( $object, $output );
 		}
 		$object = $object->post_type;
 	}
 	$object = (array) $object;
 	$taxonomies = array();
 	foreach ( (array) $wp_taxonomies as $tax_name => $tax_obj ) {
 		if ( array_intersect( $object, (array) $tax_obj->object_type ) ) {
-			if ( 'names' == $output ) {
+			if ( 'names' === $output ) {
 				$taxonomies[] = $tax_name;
 			} else {
 				$taxonomies[ $tax_name ] = $tax_obj;
 			}
 		}
 * @since 4.4.0 The `public` argument now controls whether the taxonomy can be queried on the front end.
 * @since 4.5.0 Introduced `publicly_queryable` argument.
 * @since 4.7.0 Introduced `show_in_rest`, 'rest_base' and 'rest_controller_class'
 *              arguments to register the Taxonomy in REST API.
 * @since 5.1.0 Introduced `meta_box_sanitize_cb` argument.
+* @since 5.4.0 Added the registered taxonomy object as a return value.
+* @since 5.5.0 Introduced `default_term` argument.
 *
 * @global array $wp_taxonomies Registered taxonomies.
 *
 * @param string       $taxonomy    Taxonomy key, must not exceed 32 characters.
 * @param array|string $object_type Object type or array of object types with which the taxonomy should be associated.
 *                                                shown as a submenu of the object type menu. If false, no menu is shown.
 *                                                `$show_ui` must be true. If not set, default is inherited from `$show_ui`
 *                                                (default true).
 *     @type bool          $show_in_nav_menus     Makes this taxonomy available for selection in navigation menus. If not
 *                                                set, the default is inherited from `$public` (default true).
-*     @type bool          $show_in_rest          Whether to include the taxonomy in the REST API.
+*     @type bool          $show_in_rest          Whether to include the taxonomy in the REST API. Set this to true
+*                                                for the taxonomy to be available in the block editor.
 *     @type string        $rest_base             To change the base url of REST API route. Default is $taxonomy.
 *     @type string        $rest_controller_class REST API Controller class name. Default is 'WP_REST_Terms_Controller'.
 *     @type bool          $show_tagcloud         Whether to list the taxonomy in the Tag Cloud Widget controls. If not set,
 *                                                the default is inherited from `$show_ui` (default true).
 *     @type bool          $show_in_quick_edit    Whether to show the taxonomy in the quick/bulk edit panel. It not set,
 *         @type string $slug         Customize the permastruct slug. Default `$taxonomy` key.
 *         @type bool   $with_front   Should the permastruct be prepended with WP_Rewrite::$front. Default true.
 *         @type bool   $hierarchical Either hierarchical rewrite tag or not. Default false.
 *         @type int    $ep_mask      Assign an endpoint mask. Default `EP_NONE`.
 *     }
-*     @type string        $query_var             Sets the query var key for this taxonomy. Default `$taxonomy` key. If
+*     @type string|bool   $query_var             Sets the query var key for this taxonomy. Default `$taxonomy` key. If
 *                                                false, a taxonomy cannot be loaded at `?{query_var}={term_slug}`. If a
 *                                                string, the query `?{query_var}={term_slug}` will be valid.
 *     @type callable      $update_count_callback Works much like a hook, in that it will be called when the count is
 *                                                updated. Default _update_post_term_count() for taxonomies attached
 *                                                to post types, which confirms that the objects are published before
 *                                                counting them. Default _update_generic_term_count() for taxonomies
 *                                                attached to other object types, such as users.
+*     @type string|array  $default_term {
+*         Default term to be used for the taxonomy.
+*
+*         @type string $name         Name of default term.
+*         @type string $slug         Slug for default term. Default empty.
+*         @type string $description  Description for default term. Default empty.
+*     }
 *     @type bool          $_builtin              This taxonomy is a "built-in" taxonomy. INTERNAL USE ONLY!
 *                                                Default false.
 * }
-* @return WP_Error|void WP_Error, if errors.
+* @return WP_Taxonomy|WP_Error The registered taxonomy object on success, WP_Error object on failure.
 */
 function register_taxonomy( $taxonomy, $object_type, $args = array() ) {
 	global $wp_taxonomies;
 	if ( ! is_array( $wp_taxonomies ) ) {
 	$wp_taxonomies[ $taxonomy ] = $taxonomy_object;
 	$taxonomy_object->add_hooks();
+	// Add default term.
+	if ( ! empty( $taxonomy_object->default_term ) ) {
+		$term = term_exists( $taxonomy_object->default_term['name'], $taxonomy );
+		if ( $term ) {
+			update_option( 'default_term_' . $taxonomy_object->name, $term['term_id'] );
+		} else {
+			$term = wp_insert_term(
+				$taxonomy_object->default_term['name'],
+				$taxonomy,
+				array(
+					'slug'        => sanitize_title( $taxonomy_object->default_term['slug'] ),
+					'description' => $taxonomy_object->default_term['description'],
+				)
+			);
+			// Update `term_id` in options.
+			if ( ! is_wp_error( $term ) ) {
+				update_option( 'default_term_' . $taxonomy_object->name, $term['term_id'] );
+			}
+		}
+	}
 	/**
 	 * Fires after a taxonomy is registered.
 	 *
 	 * @since 3.3.0
 	 *
 	 * @param string       $taxonomy    Taxonomy slug.
 	 * @param array|string $object_type Object type or array of object types.
 	 * @param array        $args        Array of taxonomy registration arguments.
 	 */
 	do_action( 'registered_taxonomy', $taxonomy, $object_type, (array) $taxonomy_object );
+	return $taxonomy_object;
 }
 /**
 * Unregisters a taxonomy.
 *
 	global $wp_taxonomies;
 	$taxonomy_object->remove_rewrite_rules();
 	$taxonomy_object->remove_hooks();
+	// Remove custom taxonomy default term option.
+	if ( ! empty( $taxonomy_object->default_term ) ) {
+		delete_option( 'default_term_' . $taxonomy_object->name );
+	}
 	// Remove the taxonomy.
 	unset( $wp_taxonomies[ $taxonomy ] );
 	/**
 		'choose_from_most_used'      => array( __( 'Choose from the most used tags' ), null ),
 		'not_found'                  => array( __( 'No tags found.' ), __( 'No categories found.' ) ),
 		'no_terms'                   => array( __( 'No tags' ), __( 'No categories' ) ),
 		'items_list_navigation'      => array( __( 'Tags list navigation' ), __( 'Categories list navigation' ) ),
 		'items_list'                 => array( __( 'Tags list' ), __( 'Categories list' ) ),
-		/* translators: Tab heading when selecting from the most used terms */
+		/* translators: Tab heading when selecting from the most used terms. */
 		'most_used'                  => array( _x( 'Most Used', 'tags' ), _x( 'Most Used', 'categories' ) ),
 		'back_to_items'              => array( __( '&larr; Back to Tags' ), __( '&larr; Back to Categories' ) ),
 	);
 	$nohier_vs_hier_defaults['menu_name'] = $nohier_vs_hier_defaults['name'];
 	if ( ! get_post_type_object( $object_type ) ) {
 		return false;
 	}
-	if ( ! in_array( $object_type, $wp_taxonomies[ $taxonomy ]->object_type ) ) {
+	if ( ! in_array( $object_type, $wp_taxonomies[ $taxonomy ]->object_type, true ) ) {
 		$wp_taxonomies[ $taxonomy ]->object_type[] = $object_type;
 	}
 	// Filter out empties.
 	$wp_taxonomies[ $taxonomy ]->object_type = array_filter( $wp_taxonomies[ $taxonomy ]->object_type );
 	return true;
 }
 //
-// Term API
+// Term API.
 //
 /**
 * Retrieve object_ids of valid taxonomy and term.
 *
 *
 * @since 2.3.0
 *
 * @global wpdb $wpdb WordPress database abstraction object.
 *
-* @param int|array    $term_ids   Term id or array of term ids of terms that will be used.
+* @param int|array    $term_ids   Term ID or array of term IDs of terms that will be used.
 * @param string|array $taxonomies String of taxonomy name or Array of string values of taxonomy names.
 * @param array|string $args       Change the order of the object_ids, either ASC or DESC.
 * @return WP_Error|array If the taxonomy does not exist, then WP_Error will be returned. On success.
 *  the array can be empty meaning that there are no $object_ids found or it will return the $object_ids found.
 */
 	}
 	$defaults = array( 'order' => 'ASC' );
 	$args     = wp_parse_args( $args, $defaults );
-	$order = ( 'desc' == strtolower( $args['order'] ) ) ? 'DESC' : 'ASC';
+	$order = ( 'desc' === strtolower( $args['order'] ) ) ? 'DESC' : 'ASC';
 	$term_ids = array_map( 'intval', $term_ids );
 	$taxonomies = "'" . implode( "', '", array_map( 'esc_sql', $taxonomies ) ) . "'";
 	$term_ids   = "'" . implode( "', '", $term_ids ) . "'";
 * @since 4.4.0 Converted to return a WP_Term object if `$output` is `OBJECT`.
 *              The `$taxonomy` parameter was made optional.
 *
 * @see sanitize_term_field() The $context param lists the available values for get_term_by() $filter param.
 *
-* @param int|WP_Term|object $term If integer, term data will be fetched from the database, or from the cache if
+* @param int|WP_Term|object $term     If integer, term data will be fetched from the database,
-*                                 available. If stdClass object (as in the results of a database query), will apply
+*                                     or from the cache if available.
-*                                 filters and return a `WP_Term` object corresponding to the `$term` data. If `WP_Term`,
+*                                     If stdClass object (as in the results of a database query),
-*                                 will return `$term`.
+*                                     will apply filters and return a `WP_Term` object with the `$term` data.
-* @param string     $taxonomy Optional. Taxonomy name that $term is part of.
+*                                     If `WP_Term`, will return `$term`.
-* @param string     $output   Optional. The required return type. One of OBJECT, ARRAY_A, or ARRAY_N, which correspond to
+* @param string             $taxonomy Optional. Taxonomy name that `$term` is part of.
-*                             a WP_Term object, an associative array, or a numeric array, respectively. Default OBJECT.
+* @param string             $output   Optional. The required return type. One of OBJECT, ARRAY_A, or ARRAY_N, which
-* @param string     $filter   Optional, default is raw or no WordPress defined filter will applied.
+*                                     correspond to a WP_Term object, an associative array, or a numeric array,
-* @return array|WP_Term|WP_Error|null Object of the type specified by `$output` on success. When `$output` is 'OBJECT',
+*                                     respectively. Default OBJECT.
-*                                     a WP_Term instance is returned. If taxonomy does not exist, a WP_Error is
+* @param string             $filter   Optional. How to sanitize term fields. Default 'raw'.
-*                                     returned. Returns null for miscellaneous failure.
+* @return WP_Term|array|WP_Error|null WP_Term instance (or array) on success, depending on the `$output` value.
+*                                     WP_Error if `$taxonomy` does not exist. Null for miscellaneous failure.
 */
 function get_term( $term, $taxonomy = '', $output = OBJECT, $filter = 'raw' ) {
 	if ( empty( $term ) ) {
 		return new WP_Error( 'invalid_term', __( 'Empty Term.' ) );
 	}
 	}
 	// Sanitize term, according to the specified filter.
 	$_term->filter( $filter );
-	if ( $output == ARRAY_A ) {
+	if ( ARRAY_A === $output ) {
 		return $_term->to_array();
-	} elseif ( $output == ARRAY_N ) {
+	} elseif ( ARRAY_N === $output ) {
 		return array_values( $_term->to_array() );
 	}
 	return $_term;
 }
 * @todo Better formatting for DocBlock.
 *
 * @since 2.3.0
 * @since 4.4.0 `$taxonomy` is optional if `$field` is 'term_taxonomy_id'. Converted to return
 *              a WP_Term object if `$output` is `OBJECT`.
+* @since 5.5.0 Added 'ID' as an alias of 'id' for the `$field` parameter.
 *
 * @see sanitize_term_field() The $context param lists the available values for get_term_by() $filter param.
 *
-* @param string     $field    Either 'slug', 'name', 'id' (term_id), or 'term_taxonomy_id'
+* @param string     $field    Either 'slug', 'name', 'id' or 'ID' (term_id), or 'term_taxonomy_id'.
-* @param string|int $value    Search for this term value
+* @param string|int $value    Search for this term value.
 * @param string     $taxonomy Taxonomy name. Optional, if `$field` is 'term_taxonomy_id'.
-* @param string     $output   Optional. The required return type. One of OBJECT, ARRAY_A, or ARRAY_N, which correspond to
+* @param string     $output   Optional. The required return type. One of OBJECT, ARRAY_A, or ARRAY_N, which
-*                             a WP_Term object, an associative array, or a numeric array, respectively. Default OBJECT.
+*                             correspond to a WP_Term object, an associative array, or a numeric array,
-* @param string     $filter   Optional, default is raw or no WordPress defined filter will applied.
+*                             respectively. Default OBJECT.
-* @return WP_Term|array|false WP_Term instance (or array) on success. Will return false if `$taxonomy` does not exist
+* @param string     $filter   Optional. How to sanitize term fields. Default 'raw'.
-*                             or `$term` was not found.
+* @return WP_Term|array|false WP_Term instance (or array) on success, depending on the `$output` value.
+*                             False if `$taxonomy` does not exist or `$term` was not found.
 */
 function get_term_by( $field, $value, $taxonomy = '', $output = OBJECT, $filter = 'raw' ) {
 	// 'term_taxonomy_id' lookups don't require taxonomy checks.
 	if ( 'term_taxonomy_id' !== $field && ! taxonomy_exists( $taxonomy ) ) {
 		if ( 0 === strlen( $value ) ) {
 			return false;
 		}
 	}
-	if ( 'id' === $field || 'term_id' === $field ) {
+	if ( 'id' === $field || 'ID' === $field || 'term_id' === $field ) {
 		$term = get_term( (int) $value, $taxonomy, $output, $filter );
 		if ( is_wp_error( $term ) || null === $term ) {
 			$term = false;
 		}
 		return $term;
 		return false;
 	}
 	$term = array_shift( $terms );
-	// In the case of 'term_taxonomy_id', override the provided `$taxonomy` with whatever we find in the db.
+	// In the case of 'term_taxonomy_id', override the provided `$taxonomy` with whatever we find in the DB.
 	if ( 'term_taxonomy_id' === $field ) {
 		$taxonomy = $term->taxonomy;
 	}
 	return get_term( $term, $taxonomy, $output, $filter );
 	}
 	$children = $terms[ $term_id ];
 	foreach ( (array) $terms[ $term_id ] as $child ) {
-		if ( $term_id == $child ) {
+		if ( $term_id === $child ) {
 			continue;
 		}
 		if ( isset( $terms[ $child ] ) ) {
 			$children = array_merge( $children, get_term_children( $child, $taxonomy ) );
 * @see sanitize_term_field()
 *
 * @param string      $field    Term field to fetch.
 * @param int|WP_Term $term     Term ID or object.
 * @param string      $taxonomy Optional. Taxonomy Name. Default empty.
-* @param string      $context  Optional, default is display. Look at sanitize_term_field() for available options.
+* @param string      $context  Optional. How to sanitize term fields. Look at sanitize_term_field() for available options.
+*                              Default 'display'.
 * @return string|int|null|WP_Error Will return an empty string if $term is not an object or if $field is not set in $term.
 */
 function get_term_field( $field, $term, $taxonomy = '', $context = 'display' ) {
 	$term = get_term( $term, $taxonomy );
 	if ( is_wp_error( $term ) ) {
 *              Introduced 'meta_key' and 'meta_value' parameters. Introduced the ability to order results by metadata.
 * @since 4.8.0 Introduced 'suppress_filter' parameter.
 *
 * @internal The `$deprecated` parameter is parsed for backward compatibility only.
 *
-* @param string|array $args       Optional. Array or string of arguments. See WP_Term_Query::__construct()
+* @param array|string $args       Optional. Array or string of arguments. See WP_Term_Query::__construct()
 *                                 for information on accepted arguments. Default empty.
-* @param array        $deprecated Argument array, when using the legacy function parameter format. If present, this
+* @param array|string $deprecated Argument array, when using the legacy function parameter format. If present,
-*                                 parameter will be interpreted as `$args`, and the first function parameter will
+*                                 this parameter will be interpreted as `$args`, and the first function parameter
-*                                 be parsed as a taxonomy or array of taxonomies.
+*                                 will be parsed as a taxonomy or array of taxonomies.
-* @return array|int|WP_Error List of WP_Term instances and their children. Will return WP_Error, if any of $taxonomies
+* @return WP_Term[]|int|WP_Error Array of WP_Term instances, a count thereof,
-*                            do not exist.
+*                                or WP_Error if any of the taxonomies do not exist.
 */
 function get_terms( $args = array(), $deprecated = '' ) {
 	$term_query = new WP_Term_Query();
 	$defaults = array(
 *
 * @since 4.4.0
 *
 * @param int    $term_id    Term ID.
 * @param string $meta_key   Metadata name.
-* @param mixed  $meta_value Metadata value.
+* @param mixed  $meta_value Metadata value. Must be serializable if non-scalar.
-* @param bool   $unique     Optional. Whether to bail if an entry with the same key is found for the term.
+* @param bool   $unique     Optional. Whether the same key should not be added.
 *                           Default false.
-* @return int|WP_Error|bool Meta ID on success. WP_Error when term_id is ambiguous between taxonomies.
+* @return int|false|WP_Error Meta ID on success, false on failure.
-*                           False on failure.
+*                            WP_Error when term_id is ambiguous between taxonomies.
 */
 function add_term_meta( $term_id, $meta_key, $meta_value, $unique = false ) {
 	if ( wp_term_is_shared( $term_id ) ) {
 		return new WP_Error( 'ambiguous_term_id', __( 'Term meta cannot be added to terms that are shared between taxonomies.' ), $term_id );
 	}
 *
 * @since 4.4.0
 *
 * @param int    $term_id    Term ID.
 * @param string $meta_key   Metadata name.
-* @param mixed  $meta_value Optional. Metadata value. If provided, rows will only be removed that match the value.
+* @param mixed  $meta_value Optional. Metadata value. If provided,
+*                           rows will only be removed that match the value.
+*                           Must be serializable if non-scalar. Default empty.
 * @return bool True on success, false on failure.
 */
 function delete_term_meta( $term_id, $meta_key, $meta_value = '' ) {
 	return delete_metadata( 'term', $term_id, $meta_key, $meta_value );
 }
 * Retrieves metadata for a term.
 *
 * @since 4.4.0
 *
 * @param int    $term_id Term ID.
-* @param string $key     Optional. The meta key to retrieve. If no key is provided, fetches all metadata for the term.
+* @param string $key     Optional. The meta key to retrieve. By default,
-* @param bool   $single  Whether to return a single value. If false, an array of all values matching the
+*                        returns data for all keys. Default empty.
-*                        `$term_id`/`$key` pair will be returned. Default: false.
+* @param bool   $single  Optional. Whether to return a single value.
-* @return mixed If `$single` is false, an array of metadata values. If `$single` is true, a single metadata value.
+*                        This parameter has no effect if $key is not specified.
+*                        Default false.
+* @return mixed An array if $single is false. The value of the meta field
+*               if $single is true. False for an invalid $term_id.
 */
 function get_term_meta( $term_id, $key = '', $single = false ) {
 	return get_metadata( 'term', $term_id, $key, $single );
 }
 *
 * @since 4.4.0
 *
 * @param int    $term_id    Term ID.
 * @param string $meta_key   Metadata key.
-* @param mixed  $meta_value Metadata value.
+* @param mixed  $meta_value Metadata value. Must be serializable if non-scalar.
-* @param mixed  $prev_value Optional. Previous value to check before removing.
+* @param mixed  $prev_value Optional. Previous value to check before updating.
-* @return int|WP_Error|bool Meta ID if the key didn't previously exist. True on successful update.
+*                           If specified, only update existing metadata entries with
-*                           WP_Error when term_id is ambiguous between taxonomies. False on failure.
+*                           this value. Otherwise, update all entries. Default empty.
+* @return int|bool|WP_Error Meta ID if the key didn't exist. true on successful update,
+*                           false on failure or if the value passed to the function
+*                           is the same as the one that is already in the database.
+*                           WP_Error when term_id is ambiguous between taxonomies.
 */
 function update_term_meta( $term_id, $meta_key, $meta_value, $prev_value = '' ) {
 	if ( wp_term_is_shared( $term_id ) ) {
 		return new WP_Error( 'ambiguous_term_id', __( 'Term meta cannot be added to terms that are shared between taxonomies.' ), $term_id );
 	}
 * Subsequent calls to `get_term_meta()` will not need to query the database.
 *
 * @since 4.4.0
 *
 * @param array $term_ids List of term IDs.
-* @return array|false Returns false if there is nothing to update. Returns an array of metadata on success.
+* @return array|false An array of metadata on success, false if there is nothing to update.
 */
 function update_termmeta_cache( $term_ids ) {
 	return update_meta_cache( 'term', $term_ids );
 }
 function unregister_term_meta( $taxonomy, $meta_key ) {
 	return unregister_meta_key( 'term', $meta_key, $taxonomy );
 }
 /**
-* Determines whether a term exists.
+* Determines whether a taxonomy term exists.
 *
 * Formerly is_term(), introduced in 2.3.0.
 *
 * For more information on this and similar theme functions, check out
 * the {@link https://developer.wordpress.org/themes/basics/conditional-tags/
 * @since 3.0.0
 *
 * @global wpdb $wpdb WordPress database abstraction object.
 *
 * @param int|string $term     The term to check. Accepts term ID, slug, or name.
-* @param string     $taxonomy The taxonomy name to use
+* @param string     $taxonomy Optional. The taxonomy name to use.
 * @param int        $parent   Optional. ID of parent term under which to confine the exists search.
-* @return mixed Returns null if the term does not exist. Returns the term ID
+* @return mixed Returns null if the term does not exist.
-*               if no taxonomy is specified and the term ID exists. Returns
+*               Returns the term ID if no taxonomy is specified and the term ID exists.
-*               an array of the term ID and the term taxonomy ID if the taxonomy
+*               Returns an array of the term ID and the term taxonomy ID if the taxonomy is specified and the pairing exists.
-*               is specified and the pairing exists.
+*               Returns 0 if term ID 0 is passed to the function.
 */
 function term_exists( $term, $taxonomy = '', $parent = null ) {
 	global $wpdb;
 	$select     = "SELECT term_id FROM $wpdb->terms as t WHERE ";
 	$tax_select = "SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE ";
 	if ( is_int( $term ) ) {
-		if ( 0 == $term ) {
+		if ( 0 === $term ) {
 			return 0;
 		}
 		$where = 't.term_id = %d';
 		if ( ! empty( $taxonomy ) ) {
+			// phpcs:ignore WordPress.DB.PreparedSQLPlaceholders.ReplacementsWrongNumber
 			return $wpdb->get_row( $wpdb->prepare( $tax_select . $where . ' AND tt.taxonomy = %s', $term, $taxonomy ), ARRAY_A );
 		} else {
 			return $wpdb->get_var( $wpdb->prepare( $select . $where, $term ) );
 		}
 	}
 		}
 		$where_fields[]      = $taxonomy;
 		$else_where_fields[] = $taxonomy;
-		if ( $result = $wpdb->get_row( $wpdb->prepare( "SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE $where AND tt.taxonomy = %s $orderby $limit", $where_fields ), ARRAY_A ) ) {
+		$result = $wpdb->get_row( $wpdb->prepare( "SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE $where AND tt.taxonomy = %s $orderby $limit", $where_fields ), ARRAY_A );
+		if ( $result ) {
 			return $result;
 		}
 		return $wpdb->get_row( $wpdb->prepare( "SELECT tt.term_id, tt.term_taxonomy_id FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy as tt ON tt.term_id = t.term_id WHERE $else_where AND tt.taxonomy = %s $orderby $limit", $else_where_fields ), ARRAY_A );
 	}
-	if ( $result = $wpdb->get_var( $wpdb->prepare( "SELECT term_id FROM $wpdb->terms as t WHERE $where $orderby $limit", $where_fields ) ) ) {
+	// phpcs:ignore WordPress.DB.PreparedSQLPlaceholders.UnfinishedPrepare
+	$result = $wpdb->get_var( $wpdb->prepare( "SELECT term_id FROM $wpdb->terms as t WHERE $where $orderby $limit", $where_fields ) );
+	if ( $result ) {
 		return $result;
 	}
+	// phpcs:ignore WordPress.DB.PreparedSQLPlaceholders.UnfinishedPrepare
 	return $wpdb->get_var( $wpdb->prepare( "SELECT term_id FROM $wpdb->terms as t WHERE $else_where $orderby $limit", $else_where_fields ) );
 }
 /**
 * Check if a term is an ancestor of another term.
 *
-* You can use either an id or the term object for both parameters.
+* You can use either an ID or the term object for both parameters.
 *
 * @since 3.4.0
 *
 * @param int|object $term1    ID or object to check if this is the parent term.
 * @param int|object $term2    The child term.
 	}
 	if ( empty( $term1->term_id ) || empty( $term2->parent ) ) {
 		return false;
 	}
-	if ( $term2->parent == $term1->term_id ) {
+	if ( $term2->parent === $term1->term_id ) {
 		return true;
 	}
 	return term_is_ancestor_of( $term1, get_term( $term2->parent, $taxonomy ), $taxonomy );
 }
 *                         'attribute', or 'js'.
 * @return mixed Sanitized field.
 */
 function sanitize_term_field( $field, $value, $term_id, $taxonomy, $context ) {
 	$int_fields = array( 'parent', 'term_id', 'count', 'term_group', 'term_taxonomy_id', 'object_id' );
-	if ( in_array( $field, $int_fields ) ) {
+	if ( in_array( $field, $int_fields, true ) ) {
 		$value = (int) $value;
 		if ( $value < 0 ) {
 			$value = 0;
 		}
 	}
-	if ( 'raw' == $context ) {
+	$context = strtolower( $context );
+	if ( 'raw' === $context ) {
 		return $value;
 	}
-	if ( 'edit' == $context ) {
+	if ( 'edit' === $context ) {
 		/**
 		 * Filters a term field to edit before it is sanitized.
 		 *
 		 * The dynamic portion of the filter name, `$field`, refers to the term field.
 		 * @param mixed $value   Value of the taxonomy field to edit.
 		 * @param int   $term_id Term ID.
 		 */
 		$value = apply_filters( "edit_{$taxonomy}_{$field}", $value, $term_id );
-		if ( 'description' == $field ) {
+		if ( 'description' === $field ) {
 			$value = esc_html( $value ); // textarea_escaped
 		} else {
 			$value = esc_attr( $value );
 		}
-	} elseif ( 'db' == $context ) {
+	} elseif ( 'db' === $context ) {
 		/**
 		 * Filters a term field value before it is sanitized.
 		 *
 		 * The dynamic portion of the filter name, `$field`, refers to the term field.
 		 *
 		 * @param mixed $value Value of the taxonomy field.
 		 */
 		$value = apply_filters( "pre_{$taxonomy}_{$field}", $value );
-		// Back compat filters
+		// Back compat filters.
-		if ( 'slug' == $field ) {
+		if ( 'slug' === $field ) {
 			/**
 			 * Filters the category nicename before it is sanitized.
 			 *
 			 * Use the {@see 'pre_$taxonomy_$field'} hook instead.
 			 *
 			 *
 			 * @param string $value The category nicename.
 			 */
 			$value = apply_filters( 'pre_category_nicename', $value );
 		}
-	} elseif ( 'rss' == $context ) {
+	} elseif ( 'rss' === $context ) {
 		/**
 		 * Filters the term field for use in RSS.
 		 *
 		 * The dynamic portion of the filter name, `$field`, refers to the term field.
 		 * @param string $context Context to retrieve the taxonomy field value.
 		 */
 		$value = apply_filters( "{$taxonomy}_{$field}", $value, $term_id, $context );
 	}
-	if ( 'attribute' == $context ) {
+	if ( 'attribute' === $context ) {
 		$value = esc_attr( $value );
-	} elseif ( 'js' == $context ) {
+	} elseif ( 'js' === $context ) {
 		$value = esc_js( $value );
 	}
 	return $value;
 }
 * @param array|string $args     Optional. Array of arguments that get passed to get_terms().
 *                               Default empty array.
 * @return array|int|WP_Error Number of terms in that taxonomy or WP_Error if the taxonomy does not exist.
 */
 function wp_count_terms( $taxonomy, $args = array() ) {
-	$defaults = array( 'hide_empty' => false );
+	$defaults = array(
+		'taxonomy'   => $taxonomy,
+		'hide_empty' => false,
+	);
 	$args     = wp_parse_args( $args, $defaults );
-	// backward compatibility
+	// Backward compatibility.
 	if ( isset( $args['ignore_empty'] ) ) {
 		$args['hide_empty'] = $args['ignore_empty'];
 		unset( $args['ignore_empty'] );
 	}
 	$args['fields'] = 'count';
-	return get_terms( $taxonomy, $args );
+	return get_terms( $args );
 }
 /**
 * Will unlink the object from the taxonomy or taxonomies.
 *
 function wp_delete_term( $term, $taxonomy, $args = array() ) {
 	global $wpdb;
 	$term = (int) $term;
-	if ( ! $ids = term_exists( $term, $taxonomy ) ) {
+	$ids = term_exists( $term, $taxonomy );
+	if ( ! $ids ) {
 		return false;
 	}
 	if ( is_wp_error( $ids ) ) {
 		return $ids;
 	}
 	$tt_id = $ids['term_taxonomy_id'];
 	$defaults = array();
-	if ( 'category' == $taxonomy ) {
+	if ( 'category' === $taxonomy ) {
-		$defaults['default'] = get_option( 'default_category' );
+		$defaults['default'] = (int) get_option( 'default_category' );
-		if ( $defaults['default'] == $term ) {
+		if ( $defaults['default'] === $term ) {
-			return 0; // Don't delete the default category
+			return 0; // Don't delete the default category.
+		}
+	}
+	// Don't delete the default custom taxonomy term.
+	$taxonomy_object = get_taxonomy( $taxonomy );
+	if ( ! empty( $taxonomy_object->default_term ) ) {
+		$defaults['default'] = (int) get_option( 'default_term_' . $taxonomy );
+		if ( $defaults['default'] === $term ) {
+			return 0;
 		}
 	}
 	$args = wp_parse_args( $args, $defaults );
 	 * @param int    $term     Term ID.
 	 * @param string $taxonomy Taxonomy Name.
 	 */
 	do_action( 'pre_delete_term', $term, $taxonomy );
-	// Update children to point to new parent
+	// Update children to point to new parent.
 	if ( is_taxonomy_hierarchical( $taxonomy ) ) {
 		$term_obj = get_term( $term, $taxonomy );
 		if ( is_wp_error( $term_obj ) ) {
 			return $term_obj;
 		}
 			array(
 				'fields'  => 'ids',
 				'orderby' => 'none',
 			)
 		);
-		if ( 1 == count( $terms ) && isset( $default ) ) {
+		if ( 1 === count( $terms ) && isset( $default ) ) {
 			$terms = array( $default );
 		} else {
 			$terms = array_diff( $terms, array( $term ) );
 			if ( isset( $default ) && isset( $force_default ) && $force_default ) {
 				$terms = array_merge( $terms, array( $default ) );
 	 * @since 2.9.0
 	 *
 	 * @param int $tt_id Term taxonomy ID.
 	 */
 	do_action( 'delete_term_taxonomy', $tt_id );
 	$wpdb->delete( $wpdb->term_taxonomy, array( 'term_taxonomy_id' => $tt_id ) );
 	/**
 	 * Fires immediately after a term taxonomy ID is deleted.
 	 *
 *              Introduced `$parent` argument.
 * @since 4.4.0 Introduced `$meta_query` and `$update_term_meta_cache` arguments. When `$fields` is 'all' or
 *              'all_with_object_id', an array of `WP_Term` objects will be returned.
 * @since 4.7.0 Refactored to use WP_Term_Query, and to support any WP_Term_Query arguments.
 *
-* @param int|array    $object_ids The ID(s) of the object(s) to retrieve.
+* @param int|int[]       $object_ids The ID(s) of the object(s) to retrieve.
-* @param string|array $taxonomies The taxonomies to retrieve terms from.
+* @param string|string[] $taxonomies The taxonomy names to retrieve terms from.
-* @param array|string $args       See WP_Term_Query::__construct() for supported arguments.
+* @param array|string    $args       See WP_Term_Query::__construct() for supported arguments.
 * @return array|WP_Error The requested term data or empty array if no terms found.
-*                        WP_Error if any of the $taxonomies don't exist.
+*                        WP_Error if any of the taxonomies don't exist.
 */
 function wp_get_object_terms( $object_ids, $taxonomies, $args = array() ) {
 	if ( empty( $object_ids ) || empty( $taxonomies ) ) {
 		return array();
 	}
 	/**
 	 * Filter arguments for retrieving object terms.
 	 *
 	 * @since 4.9.0
 	 *
-	 * @param array        $args       An array of arguments for retrieving terms for the given object(s).
+	 * @param array    $args       An array of arguments for retrieving terms for the given object(s).
-	 *                                 See {@see wp_get_object_terms()} for details.
+	 *                             See {@see wp_get_object_terms()} for details.
-	 * @param int|array    $object_ids Object ID or array of IDs.
+	 * @param int[]    $object_ids Array of object IDs.
-	 * @param string|array $taxonomies The taxonomies to retrieve terms from.
+	 * @param string[] $taxonomies Array of taxonomy names to retrieve terms from.
 	 */
 	$args = apply_filters( 'wp_get_object_terms_args', $args, $object_ids, $taxonomies );
 	/*
 	 * When one or more queried taxonomies is registered with an 'args' array,
 	 */
 	$terms = array();
 	if ( count( $taxonomies ) > 1 ) {
 		foreach ( $taxonomies as $index => $taxonomy ) {
 			$t = get_taxonomy( $taxonomy );
-			if ( isset( $t->args ) && is_array( $t->args ) && $args != array_merge( $args, $t->args ) ) {
+			if ( isset( $t->args ) && is_array( $t->args ) && array_merge( $args, $t->args ) != $args ) {
 				unset( $taxonomies[ $index ] );
 				$terms = array_merge( $terms, wp_get_object_terms( $object_ids, $taxonomy, array_merge( $args, $t->args ) ) );
 			}
 		}
 	} else {
 	/**
 	 * Filters the terms for a given object or objects.
 	 *
 	 * @since 4.2.0
 	 *
-	 * @param array $terms      An array of terms for the given object or objects.
+	 * @param array    $terms      Array of terms for the given object or objects.
-	 * @param array $object_ids Array of object IDs for which `$terms` were retrieved.
+	 * @param int[]    $object_ids Array of object IDs for which terms were retrieved.
-	 * @param array $taxonomies Array of taxonomies from which `$terms` were retrieved.
+	 * @param string[] $taxonomies Array of taxonomy names from which terms were retrieved.
-	 * @param array $args       An array of arguments for retrieving terms for the given
+	 * @param array    $args       Array of arguments for retrieving terms for the given
-	 *                          object(s). See wp_get_object_terms() for details.
+	 *                             object(s). See wp_get_object_terms() for details.
 	 */
 	$terms = apply_filters( 'get_object_terms', $terms, $object_ids, $taxonomies, $args );
 	$object_ids = implode( ',', $object_ids );
 	$taxonomies = "'" . implode( "', '", array_map( 'esc_sql', $taxonomies ) ) . "'";
 	 * The `$taxonomies` parameter passed to this filter is formatted as a SQL fragment. The
 	 * {@see 'get_object_terms'} filter is recommended as an alternative.
 	 *
 	 * @since 2.8.0
 	 *
-	 * @param array     $terms      An array of terms for the given object or objects.
+	 * @param array    $terms      Array of terms for the given object or objects.
-	 * @param int|array $object_ids Object ID or array of IDs.
+	 * @param int[]    $object_ids Array of object IDs for which terms were retrieved.
-	 * @param string    $taxonomies SQL-formatted (comma-separated and quoted) list of taxonomy names.
+	 * @param string[] $taxonomies Array of taxonomy names from which terms were retrieved.
-	 * @param array     $args       An array of arguments for retrieving terms for the given object(s).
+	 * @param array    $args       Array of arguments for retrieving terms for the given
-	 *                              See wp_get_object_terms() for details.
+	 *                             object(s). See wp_get_object_terms() for details.
 	 */
 	return apply_filters( 'wp_get_object_terms', $terms, $object_ids, $taxonomies, $args );
 }
 /**
 * 1. The term is added to the term table, then related to the taxonomy.
 * 2. If everything is correct, several actions are fired.
 * 3. The 'term_id_filter' is evaluated.
 * 4. The term cache is cleaned.
 * 5. Several more actions are fired.
-* 6. An array is returned containing the term_id and term_taxonomy_id.
+* 6. An array is returned containing the `term_id` and `term_taxonomy_id`.
 *
 * If the 'slug' argument is not empty, then it is checked to see if the term
 * is invalid. If it is not a valid, existing term, it is added and the term_id
 * is given.
 *
 * If the taxonomy is hierarchical, and the 'parent' argument is not empty,
 * the term is inserted and the term_id will be given.
 *
 * Error handling:
-* If $taxonomy does not exist or $term is empty,
+* If `$taxonomy` does not exist or `$term` is empty,
 * a WP_Error object will be returned.
 *
 * If the term already exists on the same hierarchical level,
 * or the term slug and name are not unique, a WP_Error object will be returned.
 *
 * @global wpdb $wpdb WordPress database abstraction object.
 *
 * @since 2.3.0
 *
-* @param string       $term     The term to add or update.
+* @param string       $term     The term name to add.
 * @param string       $taxonomy The taxonomy to which to add the term.
 * @param array|string $args {
 *     Optional. Array or string of arguments for inserting a term.
 *
 *     @type string $alias_of    Slug of the term to make this term an alias of.
 	global $wpdb;
 	if ( ! taxonomy_exists( $taxonomy ) ) {
 		return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
 	}
 	/**
 	 * Filters a term before it is sanitized and inserted into the database.
 	 *
 	 * @since 3.0.0
 	 *
-	 * @param string $term     The term to add or update.
+	 * @param string|WP_Error $term     The term name to add, or a WP_Error object if there's an error.
-	 * @param string $taxonomy Taxonomy slug.
+	 * @param string          $taxonomy Taxonomy slug.
 	 */
 	$term = apply_filters( 'pre_insert_term', $term, $taxonomy );
 	if ( is_wp_error( $term ) ) {
 		return $term;
 	}
-	if ( is_int( $term ) && 0 == $term ) {
+	if ( is_int( $term ) && 0 === $term ) {
 		return new WP_Error( 'invalid_term_id', __( 'Invalid term ID.' ) );
 	}
-	if ( '' == trim( $term ) ) {
+	if ( '' === trim( $term ) ) {
 		return new WP_Error( 'empty_term_name', __( 'A name is required for this term.' ) );
 	}
 	$defaults = array(
 		'alias_of'    => '',
 		'description' => '',
 		'parent'      => 0,
 		'slug'        => '',
 	/*
 	 * Prevent the creation of terms with duplicate names at the same level of a taxonomy hierarchy,
 	 * unless a unique slug has been explicitly provided.
 	 */
 	$name_matches = get_terms(
-		$taxonomy,
 		array(
+			'taxonomy'               => $taxonomy,
 			'name'                   => $name,
 			'hide_empty'             => false,
 			'parent'                 => $args['parent'],
 			'update_term_meta_cache' => false,
 		)
 	if ( $name_match ) {
 		$slug_match = get_term_by( 'slug', $slug, $taxonomy );
 		if ( ! $slug_provided || $name_match->slug === $slug || $slug_match ) {
 			if ( is_taxonomy_hierarchical( $taxonomy ) ) {
 				$siblings = get_terms(
-					$taxonomy,
 					array(
+						'taxonomy'               => $taxonomy,
 						'get'                    => 'all',
 						'parent'                 => $parent,
 						'update_term_meta_cache' => false,
 					)
 				);
 				$existing_term = null;
-				if ( ( ! $slug_provided || $name_match->slug === $slug ) && in_array( $name, wp_list_pluck( $siblings, 'name' ) ) ) {
+				$sibling_names = wp_list_pluck( $siblings, 'name' );
+				$sibling_slugs = wp_list_pluck( $siblings, 'slug' );
+				if ( ( ! $slug_provided || $name_match->slug === $slug ) && in_array( $name, $sibling_names, true ) ) {
 					$existing_term = $name_match;
-				} elseif ( $slug_match && in_array( $slug, wp_list_pluck( $siblings, 'slug' ) ) ) {
+				} elseif ( $slug_match && in_array( $slug, $sibling_slugs, true ) ) {
 					$existing_term = $slug_match;
 				}
 				if ( $existing_term ) {
 					return new WP_Error( 'term_exists', __( 'A term with the name provided already exists with this parent.' ), $existing_term->term_id );
 		return new WP_Error( 'db_insert_error', __( 'Could not insert term into the database.' ), $wpdb->last_error );
 	}
 	$term_id = (int) $wpdb->insert_id;
-	// Seems unreachable, However, Is used in the case that a term name is provided, which sanitizes to an empty string.
+	// Seems unreachable. However, is used in the case that a term name is provided, which sanitizes to an empty string.
 	if ( empty( $slug ) ) {
 		$slug = sanitize_title( $slug, $term_id );
 		/** This action is documented in wp-includes/taxonomy.php */
 		do_action( 'edit_terms', $term_id, $taxonomy );
 		return array(
 			'term_id'          => $term_id,
 			'term_taxonomy_id' => $tt_id,
 		);
 	}
-	$wpdb->insert( $wpdb->term_taxonomy, compact( 'term_id', 'taxonomy', 'description', 'parent' ) + array( 'count' => 0 ) );
+	if ( false === $wpdb->insert( $wpdb->term_taxonomy, compact( 'term_id', 'taxonomy', 'description', 'parent' ) + array( 'count' => 0 ) ) ) {
+		return new WP_Error( 'db_insert_error', __( 'Could not insert term taxonomy into the database.' ), $wpdb->last_error );
+	}
 	$tt_id = (int) $wpdb->insert_id;
 	/*
 	 * Sanity check: if we just created a term with the same parent + taxonomy + slug but a higher term_id than
 	 * an existing term, then we have unwittingly created a duplicate term. Delete the dupe, and use the term_id
 	 * Filters the term ID after a new term is created.
 	 *
 	 * @since 2.3.0
 	 *
 	 * @param int $term_id Term ID.
-	 * @param int $tt_id   Taxonomy term ID.
+	 * @param int $tt_id   Term taxonomy ID.
 	 */
 	$term_id = apply_filters( 'term_id_filter', $term_id, $tt_id );
 	clean_term_cache( $term_id, $taxonomy );
 	 *
 	 * @param int $term_id Term ID.
 	 * @param int $tt_id   Term taxonomy ID.
 	 */
 	do_action( "created_{$taxonomy}", $term_id, $tt_id );
+	/**
+	 * Fires after a term has been saved, and the term cache has been cleared.
+	 *
+	 * @since 5.5.0
+	 *
+	 * @param int    $term_id  Term ID.
+	 * @param int    $tt_id    Term taxonomy ID.
+	 * @param string $taxonomy Taxonomy slug.
+	 * @param bool   $update   Whether this is an existing term being updated.
+	 */
+	do_action( 'saved_term', $term_id, $tt_id, $taxonomy, false );
+	/**
+	 * Fires after a term in a specific taxonomy has been saved, and the term
+	 * cache has been cleared.
+	 *
+	 * The dynamic portion of the hook name, `$taxonomy`, refers to the taxonomy slug.
+	 *
+	 * @since 5.5.0
+	 *
+	 * @param int  $term_id Term ID.
+	 * @param int  $tt_id   Term taxonomy ID.
+	 * @param bool $update  Whether this is an existing term being updated.
+	 */
+	do_action( "saved_{$taxonomy}", $term_id, $tt_id, false );
 	return array(
 		'term_id'          => $term_id,
 		'term_taxonomy_id' => $tt_id,
 	);
 * A term has no meaning until it is given context by defining which taxonomy it
 * exists under.
 *
 * @since 2.3.0
 *
-* @global wpdb $wpdb The WordPress database abstraction object.
+* @global wpdb $wpdb WordPress database abstraction object.
 *
 * @param int              $object_id The object to relate to.
-* @param string|int|array $terms     A single term slug, single term id, or array of either term slugs or ids.
+* @param string|int|array $terms     A single term slug, single term ID, or array of either term slugs or IDs.
 *                                    Will replace all existing related terms in this taxonomy. Passing an
 *                                    empty value will remove all related terms.
 * @param string           $taxonomy  The context in which to relate the term to the object.
 * @param bool             $append    Optional. If false will delete difference of terms. Default false.
-* @return array|WP_Error Term taxonomy IDs of the affected terms.
+* @return array|WP_Error Term taxonomy IDs of the affected terms or WP_Error on failure.
 */
 function wp_set_object_terms( $object_id, $terms, $taxonomy, $append = false ) {
 	global $wpdb;
 	$object_id = (int) $object_id;
 	$tt_ids     = array();
 	$term_ids   = array();
 	$new_tt_ids = array();
 	foreach ( (array) $terms as $term ) {
-		if ( ! strlen( trim( $term ) ) ) {
+		if ( '' === trim( $term ) ) {
 			continue;
 		}
-		if ( ! $term_info = term_exists( $term, $taxonomy ) ) {
+		$term_info = term_exists( $term, $taxonomy );
+		if ( ! $term_info ) {
 			// Skip if a non-existent term ID is passed.
 			if ( is_int( $term ) ) {
 				continue;
 			}
 			$term_info = wp_insert_term( $term, $taxonomy );
 		}
 		if ( is_wp_error( $term_info ) ) {
 			return $term_info;
 		}
 		$term_ids[] = $term_info['term_id'];
 		$tt_id      = $term_info['term_taxonomy_id'];
 		$tt_ids[]   = $tt_id;
 		if ( $wpdb->get_var( $wpdb->prepare( "SELECT term_taxonomy_id FROM $wpdb->term_relationships WHERE object_id = %d AND term_taxonomy_id = %d", $object_id, $tt_id ) ) ) {
 		 * @param int    $object_id Object ID.
 		 * @param int    $tt_id     Term taxonomy ID.
 		 * @param string $taxonomy  Taxonomy slug.
 		 */
 		do_action( 'add_term_relationship', $object_id, $tt_id, $taxonomy );
 		$wpdb->insert(
 			$wpdb->term_relationships,
 			array(
 				'object_id'        => $object_id,
 				'term_taxonomy_id' => $tt_id,
 		 * @param int    $object_id Object ID.
 		 * @param int    $tt_id     Term taxonomy ID.
 		 * @param string $taxonomy  Taxonomy slug.
 		 */
 		do_action( 'added_term_relationship', $object_id, $tt_id, $taxonomy );
 		$new_tt_ids[] = $tt_id;
 	}
 	if ( $new_tt_ids ) {
 		wp_update_term_count( $new_tt_ids, $taxonomy );
 			}
 		}
 	}
 	$t = get_taxonomy( $taxonomy );
 	if ( ! $append && isset( $t->sort ) && $t->sort ) {
-		$values       = array();
+		$values     = array();
-		$term_order   = 0;
+		$term_order = 0;
 		$final_tt_ids = wp_get_object_terms(
 			$object_id,
 			$taxonomy,
 			array(
 				'fields'                 => 'tt_ids',
 				'update_term_meta_cache' => false,
 			)
 		);
 		foreach ( $tt_ids as $tt_id ) {
-			if ( in_array( $tt_id, $final_tt_ids ) ) {
+			if ( in_array( (int) $tt_id, $final_tt_ids, true ) ) {
 				$values[] = $wpdb->prepare( '(%d, %d, %d)', $object_id, $tt_id, ++$term_order );
 			}
 		}
 		if ( $values ) {
 			if ( false === $wpdb->query( "INSERT INTO $wpdb->term_relationships (object_id, term_taxonomy_id, term_order) VALUES " . join( ',', $values ) . ' ON DUPLICATE KEY UPDATE term_order = VALUES(term_order)' ) ) {
 				return new WP_Error( 'db_insert_error', __( 'Could not insert term relationship into the database.' ), $wpdb->last_error );
 			}
 		}
 	 * @param string $taxonomy   Taxonomy slug.
 	 * @param bool   $append     Whether to append new terms to the old terms.
 	 * @param array  $old_tt_ids Old array of term taxonomy IDs.
 	 */
 	do_action( 'set_object_terms', $object_id, $terms, $tt_ids, $taxonomy, $append, $old_tt_ids );
 	return $tt_ids;
 }
 /**
 * Add term(s) associated with a given object.
 	}
 	$tt_ids = array();
 	foreach ( (array) $terms as $term ) {
-		if ( ! strlen( trim( $term ) ) ) {
+		if ( '' === trim( $term ) ) {
 			continue;
 		}
-		if ( ! $term_info = term_exists( $term, $taxonomy ) ) {
+		$term_info = term_exists( $term, $taxonomy );
+		if ( ! $term_info ) {
 			// Skip if a non-existent term ID is passed.
 			if ( is_int( $term ) ) {
 				continue;
 			}
 		}
 		 * @param int   $object_id Object ID.
 		 * @param array $tt_ids    An array of term taxonomy IDs.
 		 * @param string $taxonomy  Taxonomy slug.
 		 */
 		do_action( 'delete_term_relationships', $object_id, $tt_ids, $taxonomy );
 		$deleted = $wpdb->query( $wpdb->prepare( "DELETE FROM $wpdb->term_relationships WHERE object_id = %d AND term_taxonomy_id IN ($in_tt_ids)", $object_id ) );
 		wp_cache_delete( $object_id, $taxonomy . '_relationships' );
 		wp_cache_delete( 'last_changed', 'terms' );
 	 * @param object $term         Term object.
 	 */
 	if ( apply_filters( 'wp_unique_term_slug_is_bad_slug', $needs_suffix, $slug, $term ) ) {
 		if ( $parent_suffix ) {
 			$slug .= $parent_suffix;
+		}
+		if ( ! empty( $term->term_id ) ) {
+			$query = $wpdb->prepare( "SELECT slug FROM $wpdb->terms WHERE slug = %s AND term_id != %d", $slug, $term->term_id );
 		} else {
-			if ( ! empty( $term->term_id ) ) {
+			$query = $wpdb->prepare( "SELECT slug FROM $wpdb->terms WHERE slug = %s", $slug );
-				$query = $wpdb->prepare( "SELECT slug FROM $wpdb->terms WHERE slug = %s AND term_id != %d", $slug, $term->term_id );
+		}
-			} else {
-				$query = $wpdb->prepare( "SELECT slug FROM $wpdb->terms WHERE slug = %s", $slug );
+		if ( $wpdb->get_var( $query ) ) { // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared
-			}
+			$num = 2;
+			do {
-			if ( $wpdb->get_var( $query ) ) {
+				$alt_slug = $slug . "-$num";
-				$num = 2;
+				$num++;
-				do {
+				$slug_check = $wpdb->get_var( $wpdb->prepare( "SELECT slug FROM $wpdb->terms WHERE slug = %s", $alt_slug ) );
-					$alt_slug = $slug . "-$num";
+			} while ( $slug_check );
-					$num++;
+			$slug = $alt_slug;
-					$slug_check = $wpdb->get_var( $wpdb->prepare( "SELECT slug FROM $wpdb->terms WHERE slug = %s", $alt_slug ) );
-				} while ( $slug_check );
-				$slug = $alt_slug;
-			}
 		}
 	}
 	/**
 	 * Filters the unique term slug.
 }
 /**
 * Update term based on arguments provided.
 *
-* The $args will indiscriminately override all values with the same field name.
+* The `$args` will indiscriminately override all values with the same field name.
 * Care must be taken to not override important information need to update or
 * update will fail (or perhaps create a new term, neither would be acceptable).
 *
 * Defaults will set 'alias_of', 'description', 'parent', and 'slug' if not
-* defined in $args already.
+* defined in `$args` already.
 *
-* 'alias_of' will create a term group, if it doesn't already exist, and update
+* 'alias_of' will create a term group, if it doesn't already exist, and
-* it for the $term.
+* update it for the `$term`.
 *
-* If the 'slug' argument in $args is missing, then the 'name' in $args will be
+* If the 'slug' argument in `$args` is missing, then the 'name' will be used.
-* used. It should also be noted that if you set 'slug' and it isn't unique then
+* If you set 'slug' and it isn't unique, then a WP_Error is returned.
-* a WP_Error will be passed back. If you don't pass any slug, then a unique one
+* If you don't pass any slug, then a unique one will be created.
-* will be created for you.
-*
-* For what can be overrode in `$args`, check the term scheme can contain and stay
-* away from the term keys.
 *
 * @since 2.3.0
 *
 * @global wpdb $wpdb WordPress database abstraction object.
 *
-* @param int          $term_id  The ID of the term
+* @param int          $term_id  The ID of the term.
-* @param string       $taxonomy The context in which to relate the term to the object.
+* @param string       $taxonomy The taxonomy of the term.
-* @param array|string $args     Optional. Array of get_terms() arguments. Default empty array.
+* @param array|string $args {
-* @return array|WP_Error Returns Term ID and Taxonomy Term ID
+*     Optional. Array or string of arguments for updating a term.
+*
+*     @type string $alias_of    Slug of the term to make this term an alias of.
+*                               Default empty string. Accepts a term slug.
+*     @type string $description The term description. Default empty string.
+*     @type int    $parent      The id of the parent term. Default 0.
+*     @type string $slug        The term slug to use. Default empty string.
+* }
+* @return array|WP_Error An array containing the `term_id` and `term_taxonomy_id`,
+*                        WP_Error otherwise.
 */
 function wp_update_term( $term_id, $taxonomy, $args = array() ) {
 	global $wpdb;
 	if ( ! taxonomy_exists( $taxonomy ) ) {
 		return new WP_Error( 'invalid_taxonomy', __( 'Invalid taxonomy.' ) );
 	}
 	$term_id = (int) $term_id;
-	// First, get all of the original args
+	// First, get all of the original args.
 	$term = get_term( $term_id, $taxonomy );
 	if ( is_wp_error( $term ) ) {
 		return $term;
 	}
 	$description = wp_unslash( $args['description'] );
 	$parsed_args['name']        = $name;
 	$parsed_args['description'] = $description;
-	if ( '' == trim( $name ) ) {
+	if ( '' === trim( $name ) ) {
 		return new WP_Error( 'empty_term_name', __( 'A name is required for this term.' ) );
 	}
 	if ( $parsed_args['parent'] > 0 && ! term_exists( (int) $parsed_args['parent'] ) ) {
 		return new WP_Error( 'missing_parent', __( 'Parent term does not exist.' ) );
 	 * @param int    $term_id     Term ID.
 	 * @param string $taxonomy    Taxonomy slug.
 	 * @param array  $parsed_args An array of potentially altered update arguments for the given term.
 	 * @param array  $args        An array of update arguments for the given term.
 	 */
-	$parent = apply_filters( 'wp_update_term_parent', $args['parent'], $term_id, $taxonomy, $parsed_args, $args );
+	$parent = (int) apply_filters( 'wp_update_term_parent', $args['parent'], $term_id, $taxonomy, $parsed_args, $args );
-	// Check for duplicate slug
+	// Check for duplicate slug.
 	$duplicate = get_term_by( 'slug', $slug, $taxonomy );
-	if ( $duplicate && $duplicate->term_id != $term_id ) {
+	if ( $duplicate && $duplicate->term_id !== $term_id ) {
 		// If an empty slug was passed or the parent changed, reset the slug to something unique.
 		// Otherwise, bail.
-		if ( $empty_slug || ( $parent != $term['parent'] ) ) {
+		if ( $empty_slug || ( $parent !== (int) $term['parent'] ) ) {
 			$slug = wp_unique_term_slug( $slug, (object) $args );
 		} else {
-			/* translators: %s: taxonomy term slug */
+			/* translators: %s: Taxonomy term slug. */
 			return new WP_Error( 'duplicate_term_slug', sprintf( __( 'The slug &#8220;%s&#8221; is already in use by another term.' ), $slug ) );
 		}
 	}
 	$tt_id = (int) $wpdb->get_var( $wpdb->prepare( "SELECT tt.term_taxonomy_id FROM $wpdb->term_taxonomy AS tt INNER JOIN $wpdb->terms AS t ON tt.term_id = t.term_id WHERE tt.taxonomy = %s AND t.term_id = %d", $taxonomy, $term_id ) );
 	 * @param array  $args     Arguments passed to wp_update_term().
 	 */
 	$data = apply_filters( 'wp_update_term_data', $data, $term_id, $taxonomy, $args );
 	$wpdb->update( $wpdb->terms, $data, compact( 'term_id' ) );
 	if ( empty( $slug ) ) {
 		$slug = sanitize_title( $name, $term_id );
 		$wpdb->update( $wpdb->terms, compact( 'slug' ), compact( 'term_id' ) );
 	}
 	 *
 	 * @param int $term_id Term ID.
 	 * @param int $tt_id   Term taxonomy ID.
 	 */
 	do_action( "edited_{$taxonomy}", $term_id, $tt_id );
+	/** This action is documented in wp-includes/taxonomy.php */
+	do_action( 'saved_term', $term_id, $tt_id, $taxonomy, true );
+	/** This action is documented in wp-includes/taxonomy.php */
+	do_action( "saved_{$taxonomy}", $term_id, $tt_id, true );
 	return array(
 		'term_id'          => $term_id,
 		'term_taxonomy_id' => $tt_id,
 	);
 /**
 * Enable or disable term counting.
 *
 * @since 2.5.0
 *
-* @staticvar bool $_defer
-*
 * @param bool $defer Optional. Enable if true, disable if false.
 * @return bool Whether term counting is enabled or disabled.
 */
 function wp_defer_term_counting( $defer = null ) {
 	static $_defer = false;
 	if ( is_bool( $defer ) ) {
 		$_defer = $defer;
-		// flush any deferred counts
+		// Flush any deferred counts.
 		if ( ! $defer ) {
 			wp_update_term_count( null, null, true );
 		}
 	}
 *
 * The default action is to count what the amount of terms have the relationship
 * of term ID. Once that is done, then update the database.
 *
 * @since 2.3.0
-*
-* @staticvar array $_deferred
 *
 * @param int|array $terms       The term_taxonomy_id of the terms.
 * @param string    $taxonomy    The context of the term.
 * @param bool      $do_deferred Whether to flush the deferred term counts too. Default false.
 * @return bool If no terms will return false, and if successful will return true.
 			if ( 0 === strpos( $object_type, 'attachment:' ) ) {
 				list( $object_type ) = explode( ':', $object_type );
 			}
 		}
-		if ( $object_types == array_filter( $object_types, 'post_type_exists' ) ) {
+		if ( array_filter( $object_types, 'post_type_exists' ) == $object_types ) {
-			// Only post types are attached to this taxonomy
+			// Only post types are attached to this taxonomy.
 			_update_post_term_count( $terms, $taxonomy );
 		} else {
-			// Default count updater
+			// Default count updater.
 			_update_generic_term_count( $terms, $taxonomy );
 		}
 	}
 	clean_term_cache( $terms, '', false );
 	return true;
 }
 //
-// Cache
+// Cache.
 //
 /**
 * Removes the taxonomy relationship to terms from the cache.
 *
 	 */
 	do_action( 'clean_object_term_cache', $object_ids, $object_type );
 }
 /**
-* Will remove all of the term ids from the cache.
+* Will remove all of the term IDs from the cache.
 *
 * @since 2.3.0
 *
-* @global wpdb $wpdb WordPress database abstraction object.
+* @global wpdb $wpdb                           WordPress database abstraction object.
 * @global bool $_wp_suspend_cache_invalidation
 *
-* @param int|array $ids            Single or list of Term IDs.
+* @param int|int[] $ids            Single or array of term IDs.
-* @param string    $taxonomy       Optional. Can be empty and will assume `tt_ids`, else will use for context.
+* @param string    $taxonomy       Optional. Taxonomy slug. Can be empty, in which case the taxonomies of the passed
-*                                  Default empty.
+*                                  term IDs will be used. Default empty.
 * @param bool      $clean_taxonomy Optional. Whether to clean taxonomy wide caches (true), or just individual
 *                                  term object caches (false). Default true.
 */
 function clean_term_cache( $ids, $taxonomy = '', $clean_taxonomy = true ) {
 	global $wpdb, $_wp_suspend_cache_invalidation;
 	if ( empty( $taxonomy ) ) {
 		$tt_ids = array_map( 'intval', $ids );
 		$tt_ids = implode( ', ', $tt_ids );
 		$terms  = $wpdb->get_results( "SELECT term_id, taxonomy FROM $wpdb->term_taxonomy WHERE term_taxonomy_id IN ($tt_ids)" );
 		$ids    = array();
 		foreach ( (array) $terms as $term ) {
 			$taxonomies[] = $term->taxonomy;
 			$ids[]        = $term->term_id;
 			wp_cache_delete( $term->term_id, 'terms' );
 		}
 		$taxonomies = array_unique( $taxonomies );
 	} else {
 		$taxonomies = array( $taxonomy );
 		foreach ( $taxonomies as $taxonomy ) {
 			foreach ( $ids as $id ) {
 				wp_cache_delete( $id, 'terms' );
 			}
 		}
 	 */
 	do_action( 'clean_taxonomy_cache', $taxonomy );
 }
 /**
-* Retrieves the taxonomy relationship to the term object id.
+* Retrieves the cached term objects for the given object ID.
 *
 * Upstream functions (like get_the_terms() and is_object_in_term()) are
 * responsible for populating the object-term relationship cache. The current
 * function only fetches relationship data that is already in the cache.
 *
 * @since 2.3.0
-* @since 4.7.0 Returns a `WP_Error` object if `get_term()` returns an error for
+* @since 4.7.0 Returns a `WP_Error` object if there's an error with
 *              any of the matched terms.
 *
-* @param int    $id       Term object ID.
+* @param int    $id       Term object ID, for example a post, comment, or user ID.
 * @param string $taxonomy Taxonomy name.
-* @return bool|array|WP_Error Array of `WP_Term` objects, if cached.
+* @return bool|WP_Term[]|WP_Error Array of `WP_Term` objects, if cached.
-*                             False if cache is empty for `$taxonomy` and `$id`.
+*                                 False if cache is empty for `$taxonomy` and `$id`.
-*                             WP_Error if get_term() returns an error object for any term.
+*                                 WP_Error if get_term() returns an error object for any term.
 */
 function get_object_term_cache( $id, $taxonomy ) {
 	$_term_ids = wp_cache_get( $id, "{$taxonomy}_relationships" );
 	// We leave the priming of relationship caches to upstream functions.
 *
 * Caches will only be updated for terms not already cached.
 *
 * @since 2.3.0
 *
-* @param string|array $object_ids  Comma-separated list or array of term object IDs.
+* @param string|int[]    $object_ids  Comma-separated list or array of term object IDs.
-* @param array|string $object_type The taxonomy object type.
+* @param string|string[] $object_type The taxonomy object type or array of the same.
 * @return void|false False if all of the terms in `$object_ids` are already cached.
 */
 function update_object_term_cache( $object_ids, $object_type ) {
 	if ( empty( $object_ids ) ) {
 		return;
 	if ( ! is_array( $object_ids ) ) {
 		$object_ids = explode( ',', $object_ids );
 	}
-	$object_ids = array_map( 'intval', $object_ids );
+	$object_ids     = array_map( 'intval', $object_ids );
+	$non_cached_ids = array();
 	$taxonomies = get_object_taxonomies( $object_type );
-	$ids = array();
+	foreach ( $taxonomies as $taxonomy ) {
-	foreach ( (array) $object_ids as $id ) {
+		$cache_values = wp_cache_get_multiple( (array) $object_ids, "{$taxonomy}_relationships" );
-		foreach ( $taxonomies as $taxonomy ) {
-			if ( false === wp_cache_get( $id, "{$taxonomy}_relationships" ) ) {
+		foreach ( $cache_values as $id => $value ) {
-				$ids[] = $id;
+			if ( false === $value ) {
-				break;
+				$non_cached_ids[] = $id;
 			}
 		}
 	}
-	if ( empty( $ids ) ) {
+	if ( empty( $non_cached_ids ) ) {
 		return false;
 	}
+	$non_cached_ids = array_unique( $non_cached_ids );
 	$terms = wp_get_object_terms(
-		$ids,
+		$non_cached_ids,
 		$taxonomies,
 		array(
 			'fields'                 => 'all_with_object_id',
 			'orderby'                => 'name',
 			'update_term_meta_cache' => false,
 	$object_terms = array();
 	foreach ( (array) $terms as $term ) {
 		$object_terms[ $term->object_id ][ $term->taxonomy ][] = $term->term_id;
 	}
-	foreach ( $ids as $id ) {
+	foreach ( $non_cached_ids as $id ) {
 		foreach ( $taxonomies as $taxonomy ) {
 			if ( ! isset( $object_terms[ $id ][ $taxonomy ] ) ) {
 				if ( ! isset( $object_terms[ $id ] ) ) {
 					$object_terms[ $id ] = array();
 				}
 /**
 * Updates Terms to Taxonomy in cache.
 *
 * @since 2.3.0
 *
-* @param array  $terms    List of term objects to change.
+* @param WP_Term[] $terms    Array of term objects to change.
-* @param string $taxonomy Optional. Update Term to this taxonomy in cache. Default empty.
+* @param string    $taxonomy Not used.
 */
 function update_term_cache( $terms, $taxonomy = '' ) {
 	foreach ( (array) $terms as $term ) {
 		// Create a copy in case the array was passed by reference.
 		$_term = clone $term;
 		wp_cache_add( $term->term_id, $_term, 'terms' );
 	}
 }
 //
-// Private
+// Private.
 //
 /**
 * Retrieves children of taxonomy as Term IDs.
 *
 	if ( is_array( $children ) ) {
 		return $children;
 	}
 	$children = array();
 	$terms    = get_terms(
-		$taxonomy,
 		array(
+			'taxonomy'               => $taxonomy,
 			'get'                    => 'all',
 			'orderby'                => 'id',
 			'fields'                 => 'id=>parent',
 			'update_term_meta_cache' => false,
 		)
 	$empty_array = array();
 	if ( empty( $terms ) ) {
 		return $empty_array;
 	}
+	$term_id      = (int) $term_id;
 	$term_list    = array();
 	$has_children = _get_term_hierarchy( $taxonomy );
-	if ( ( 0 != $term_id ) && ! isset( $has_children[ $term_id ] ) ) {
+	if ( $term_id && ! isset( $has_children[ $term_id ] ) ) {
 		return $empty_array;
 	}
 	// Include the term itself in the ancestors array, so we can properly detect when a loop has occurred.
 	if ( empty( $ancestors ) ) {
 		// Don't recurse if we've already identified the term as a child - this indicates a loop.
 		if ( isset( $ancestors[ $term->term_id ] ) ) {
 			continue;
 		}
-		if ( $term->parent == $term_id ) {
+		if ( (int) $term->parent === $term_id ) {
 			if ( $use_id ) {
 				$term_list[] = $term->term_id;
 			} else {
 				$term_list[] = $term;
 			}
 				continue;
 			}
 			$ancestors[ $term->term_id ] = 1;
-			if ( $children = _get_term_children( $term->term_id, $terms, $taxonomy, $ancestors ) ) {
+			$children = _get_term_children( $term->term_id, $terms, $taxonomy, $ancestors );
+			if ( $children ) {
 				$term_list = array_merge( $term_list, $children );
 			}
 		}
 	}
 	foreach ( (array) $terms as $key => $term ) {
 		$terms_by_id[ $term->term_id ]       = & $terms[ $key ];
 		$term_ids[ $term->term_taxonomy_id ] = $term->term_id;
 	}
-	// Get the object and term ids and stick them in a lookup table.
+	// Get the object and term IDs and stick them in a lookup table.
 	$tax_obj      = get_taxonomy( $taxonomy );
 	$object_types = esc_sql( $tax_obj->object_type );
 	$results      = $wpdb->get_results( "SELECT object_id, term_taxonomy_id FROM $wpdb->term_relationships INNER JOIN $wpdb->posts ON object_id = ID WHERE term_taxonomy_id IN (" . implode( ',', array_keys( $term_ids ) ) . ") AND post_type IN ('" . implode( "', '", $object_types ) . "') AND post_status = 'publish'" );
 	foreach ( $results as $row ) {
-		$id                                   = $term_ids[ $row->term_taxonomy_id ];
+		$id = $term_ids[ $row->term_taxonomy_id ];
 		$term_items[ $id ][ $row->object_id ] = isset( $term_items[ $id ][ $row->object_id ] ) ? ++$term_items[ $id ][ $row->object_id ] : 1;
 	}
 	// Touch every ancestor's lookup row for each post in each term.
 	foreach ( $term_ids as $term_id ) {
 		$child     = $term_id;
 		$ancestors = array();
 		while ( ! empty( $terms_by_id[ $child ] ) && $parent = $terms_by_id[ $child ]->parent ) {
 			$ancestors[] = $child;
 			if ( ! empty( $term_items[ $term_id ] ) ) {
 				foreach ( $term_items[ $term_id ] as $item_id => $touches ) {
 					$term_items[ $parent ][ $item_id ] = isset( $term_items[ $parent ][ $item_id ] ) ? ++$term_items[ $parent ][ $item_id ] : 1;
 				}
 			}
 			$child = $parent;
-			if ( in_array( $parent, $ancestors ) ) {
+			if ( in_array( $parent, $ancestors, true ) ) {
 				break;
 			}
 		}
 	}
 		}
 	}
 }
 //
-// Default callbacks
+// Default callbacks.
 //
 /**
 * Will update term count based on object types of the current taxonomy.
 *
 * @access private
 * @since 2.3.0
 *
 * @global wpdb $wpdb WordPress database abstraction object.
 *
-* @param array  $terms    List of Term taxonomy IDs.
+* @param int[]       $terms    List of Term taxonomy IDs.
-* @param object $taxonomy Current taxonomy object of terms.
+* @param WP_Taxonomy $taxonomy Current taxonomy object of terms.
 */
 function _update_post_term_count( $terms, $taxonomy ) {
 	global $wpdb;
 	$object_types = (array) $taxonomy->object_type;
 		list( $object_type ) = explode( ':', $object_type );
 	}
 	$object_types = array_unique( $object_types );
-	if ( false !== ( $check_attachments = array_search( 'attachment', $object_types ) ) ) {
+	$check_attachments = array_search( 'attachment', $object_types, true );
+	if ( false !== $check_attachments ) {
 		unset( $object_types[ $check_attachments ] );
 		$check_attachments = true;
 	}
 	if ( $object_types ) {
 		if ( $check_attachments ) {
 			$count += (int) $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_relationships, $wpdb->posts p1 WHERE p1.ID = $wpdb->term_relationships.object_id AND ( post_status = 'publish' OR ( post_status = 'inherit' AND post_parent > 0 AND ( SELECT post_status FROM $wpdb->posts WHERE ID = p1.post_parent ) = 'publish' ) ) AND post_type = 'attachment' AND term_taxonomy_id = %d", $term ) );
 		}
 		if ( $object_types ) {
+			// phpcs:ignore WordPress.DB.PreparedSQLPlaceholders.QuotedDynamicPlaceholderGeneration
 			$count += (int) $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_relationships, $wpdb->posts WHERE $wpdb->posts.ID = $wpdb->term_relationships.object_id AND post_status = 'publish' AND post_type IN ('" . implode( "', '", $object_types ) . "') AND term_taxonomy_id = %d", $term ) );
 		}
 		/** This action is documented in wp-includes/taxonomy.php */
 		do_action( 'edit_term_taxonomy', $term, $taxonomy->name );
 *
 * @since 3.3.0
 *
 * @global wpdb $wpdb WordPress database abstraction object.
 *
-* @param array  $terms    List of term taxonomy IDs.
+* @param int[]       $terms    List of term taxonomy IDs.
-* @param object $taxonomy Current taxonomy object of terms.
+* @param WP_Taxonomy $taxonomy Current taxonomy object of terms.
 */
 function _update_generic_term_count( $terms, $taxonomy ) {
 	global $wpdb;
 	foreach ( (array) $terms as $term ) {
 		$term_taxonomy    = $term_taxonomy_id;
 		$term_taxonomy_id = intval( $term_taxonomy->term_taxonomy_id );
 	}
 	// If there are no shared term_taxonomy rows, there's nothing to do here.
-	$shared_tt_count = $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_taxonomy tt WHERE tt.term_id = %d AND tt.term_taxonomy_id != %d", $term_id, $term_taxonomy_id ) );
+	$shared_tt_count = (int) $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->term_taxonomy tt WHERE tt.term_id = %d AND tt.term_taxonomy_id != %d", $term_id, $term_taxonomy_id ) );
 	if ( ! $shared_tt_count ) {
 		return $term_id;
 	}
 	/*
 	 * Verify that the term_taxonomy_id passed to the function is actually associated with the term_id.
 	 * If there's a mismatch, it may mean that the term is already split. Return the actual term_id from the db.
 	 */
-	$check_term_id = $wpdb->get_var( $wpdb->prepare( "SELECT term_id FROM $wpdb->term_taxonomy WHERE term_taxonomy_id = %d", $term_taxonomy_id ) );
+	$check_term_id = (int) $wpdb->get_var( $wpdb->prepare( "SELECT term_id FROM $wpdb->term_taxonomy WHERE term_taxonomy_id = %d", $term_taxonomy_id ) );
-	if ( $check_term_id != $term_id ) {
+	if ( $check_term_id !== $term_id ) {
 		return $check_term_id;
 	}
 	// Pull up data about the currently shared slug, which we'll use to populate the new one.
 	if ( empty( $shared_term ) ) {
 	$shared_term_ids = implode( ',', array_keys( $shared_terms ) );
 	$shared_tts      = $wpdb->get_results( "SELECT * FROM {$wpdb->term_taxonomy} WHERE `term_id` IN ({$shared_term_ids})" );
 	// Split term data recording is slow, so we do it just once, outside the loop.
 	$split_term_data    = get_option( '_split_terms', array() );
-	$skipped_first_term = $taxonomies = array();
+	$skipped_first_term = array();
+	$taxonomies         = array();
 	foreach ( $shared_tts as $shared_tt ) {
 		$term_id = intval( $shared_tt->term_id );
 		// Don't split the first tt belonging to a given term_id.
 		if ( ! isset( $skipped_first_term[ $term_id ] ) ) {
 * @param int    $new_term_id      ID of the new term created for the $term_taxonomy_id.
 * @param int    $term_taxonomy_id ID for the term_taxonomy row affected by the split.
 * @param string $taxonomy         Taxonomy for the split term.
 */
 function _wp_check_split_default_terms( $term_id, $new_term_id, $term_taxonomy_id, $taxonomy ) {
-	if ( 'category' != $taxonomy ) {
+	if ( 'category' !== $taxonomy ) {
 		return;
 	}
 	foreach ( array( 'default_category', 'default_link_category', 'default_email_category' ) as $option ) {
-		if ( $term_id == get_option( $option, -1 ) ) {
+		if ( (int) get_option( $option, -1 ) === $term_id ) {
 			update_option( $option, $new_term_id );
 		}
 	}
 }
 	}
 	// Update menu locations.
 	$locations = get_nav_menu_locations();
 	foreach ( $locations as $location => $menu_id ) {
-		if ( $term_id == $menu_id ) {
+		if ( $term_id === $menu_id ) {
 			$locations[ $location ] = $new_term_id;
 		}
 	}
 	set_theme_mod( 'nav_menu_locations', $locations );
 }
 /**
 * Generate a permalink for a taxonomy term archive.
 *
 * @since 2.5.0
 *
-* @global WP_Rewrite $wp_rewrite
+* @global WP_Rewrite $wp_rewrite WordPress rewrite component.
 *
-* @param object|int|string $term     The term object, ID, or slug whose link will be retrieved.
+* @param WP_Term|int|string $term     The term object, ID, or slug whose link will be retrieved.
-* @param string            $taxonomy Optional. Taxonomy. Default empty.
+* @param string             $taxonomy Optional. Taxonomy. Default empty.
-* @return string|WP_Error HTML link to taxonomy term archive on success, WP_Error if term does not exist.
+* @return string|WP_Error URL of the taxonomy term archive on success, WP_Error if term does not exist.
 */
 function get_term_link( $term, $taxonomy = '' ) {
 	global $wp_rewrite;
 	if ( ! is_object( $term ) ) {
 	$slug = $term->slug;
 	$t    = get_taxonomy( $taxonomy );
 	if ( empty( $termlink ) ) {
-		if ( 'category' == $taxonomy ) {
+		if ( 'category' === $taxonomy ) {
 			$termlink = '?cat=' . $term->term_id;
 		} elseif ( $t->query_var ) {
 			$termlink = "?$t->query_var=$slug";
 		} else {
 			$termlink = "?taxonomy=$taxonomy&term=$slug";
 		} else {
 			$termlink = str_replace( "%$taxonomy%", $slug, $termlink );
 		}
 		$termlink = home_url( user_trailingslashit( $termlink, 'category' ) );
 	}
-	// Back Compat filters.
-	if ( 'post_tag' == $taxonomy ) {
+	// Back compat filters.
+	if ( 'post_tag' === $taxonomy ) {
 		/**
 		 * Filters the tag link.
 		 *
 		 * @since 2.3.0
-		 * @deprecated 2.5.0 Use 'term_link' instead.
+		 * @since 2.5.0 Deprecated in favor of {@see 'term_link'} filter.
+		 * @since 5.4.1 Restored (un-deprecated).
 		 *
 		 * @param string $termlink Tag link URL.
 		 * @param int    $term_id  Term ID.
 		 */
 		$termlink = apply_filters( 'tag_link', $termlink, $term->term_id );
-	} elseif ( 'category' == $taxonomy ) {
+	} elseif ( 'category' === $taxonomy ) {
 		/**
 		 * Filters the category link.
 		 *
 		 * @since 1.5.0
-		 * @deprecated 2.5.0 Use 'term_link' instead.
+		 * @since 2.5.0 Deprecated in favor of {@see 'term_link'} filter.
+		 * @since 5.4.1 Restored (un-deprecated).
 		 *
 		 * @param string $termlink Category link URL.
 		 * @param int    $term_id  Term ID.
 		 */
 		$termlink = apply_filters( 'category_link', $termlink, $term->term_id );
 	/**
 	 * Filters the term link.
 	 *
 	 * @since 2.5.0
 	 *
-	 * @param string $termlink Term link URL.
+	 * @param string  $termlink Term link URL.
-	 * @param object $term     Term object.
+	 * @param WP_Term $term     Term object.
-	 * @param string $taxonomy Taxonomy slug.
+	 * @param string  $taxonomy Taxonomy slug.
 	 */
 	return apply_filters( 'term_link', $termlink, $term, $taxonomy );
 }
 /**
 		'before' => '',
 		'sep'    => ' ',
 		'after'  => '',
 	);
-	$r = wp_parse_args( $args, $defaults );
+	$parsed_args = wp_parse_args( $args, $defaults );
-	echo $r['before'] . join( $r['sep'], get_the_taxonomies( $r['post'], $r ) ) . $r['after'];
+	echo $parsed_args['before'] . join( $parsed_args['sep'], get_the_taxonomies( $parsed_args['post'], $parsed_args ) ) . $parsed_args['after'];
 }
 /**
 * Retrieve all taxonomies associated with a post.
 *
 * the taxonomies with links to the taxonomy and name.
 *
 * @since 2.5.0
 *
 * @param int|WP_Post $post Optional. Post ID or WP_Post object. Default is global $post.
-* @param array $args {
+* @param array       $args {
-*     Optional. Arguments about how to format the list of taxonomies. Default empty array.
+*           Optional. Arguments about how to format the list of taxonomies. Default empty array.
 *
 *     @type string $template      Template for displaying a taxonomy label and list of terms.
 *                                 Default is "Label: Terms."
 *     @type string $term_template Template for displaying a single term in the list. Default is the term name
 *                                 linked to its archive.
 	$post = get_post( $post );
 	$args = wp_parse_args(
 		$args,
 		array(
-			/* translators: %s: taxonomy label, %l: list of terms formatted as per $term_template */
+			/* translators: %s: Taxonomy label, %l: List of terms formatted as per $term_template. */
 			'template'      => __( '%s: %l.' ),
 			'term_template' => '<a href="%1$s">%2$s</a>',
 		)
 	);
 	}
 	return $taxonomies;
 }
 /**
-* Retrieve all taxonomies of a post with just the names.
+* Retrieve all taxonomy names for the given post.
 *
 * @since 2.5.0
 *
 * @param int|WP_Post $post Optional. Post ID or WP_Post object. Default is global $post.
-* @return array An array of all taxonomy names for the given post.
+* @return string[] An array of all taxonomy names for the given post.
 */
 function get_post_taxonomies( $post = 0 ) {
 	$post = get_post( $post );
 	return get_object_taxonomies( $post );
 * @param string           $taxonomy  Single taxonomy name.
 * @param int|string|array $terms     Optional. Term term_id, name, slug or array of said. Default null.
 * @return bool|WP_Error WP_Error on input error.
 */
 function is_object_in_term( $object_id, $taxonomy, $terms = null ) {
-	if ( ! $object_id = (int) $object_id ) {
+	$object_id = (int) $object_id;
+	if ( ! $object_id ) {
 		return new WP_Error( 'invalid_object', __( 'Invalid object ID.' ) );
 	}
 	$object_terms = get_object_term_cache( $object_id, $taxonomy );
 	if ( false === $object_terms ) {
 		return ( ! empty( $object_terms ) );
 	}
 	$terms = (array) $terms;
-	if ( $ints = array_filter( $terms, 'is_int' ) ) {
+	$ints = array_filter( $terms, 'is_int' );
+	if ( $ints ) {
 		$strs = array_diff( $terms, $ints );
 	} else {
 		$strs =& $terms;
 	}
 	foreach ( $object_terms as $object_term ) {
 		// If term is an int, check against term_ids only.
-		if ( $ints && in_array( $object_term->term_id, $ints ) ) {
+		if ( $ints && in_array( $object_term->term_id, $ints, true ) ) {
 			return true;
 		}
 		if ( $strs ) {
 			// Only check numeric strings against term_id, to avoid false matches due to type juggling.
 			$numeric_strs = array_map( 'intval', array_filter( $strs, 'is_numeric' ) );
 			if ( in_array( $object_term->term_id, $numeric_strs, true ) ) {
 				return true;
 			}
-			if ( in_array( $object_term->name, $strs ) ) {
+			if ( in_array( $object_term->name, $strs, true ) ) {
 				return true;
 			}
-			if ( in_array( $object_term->slug, $strs ) ) {
+			if ( in_array( $object_term->slug, $strs, true ) ) {
 				return true;
 			}
 		}
 	}
 function is_object_in_taxonomy( $object_type, $taxonomy ) {
 	$taxonomies = get_object_taxonomies( $object_type );
 	if ( empty( $taxonomies ) ) {
 		return false;
 	}
-	return in_array( $taxonomy, $taxonomies );
+	return in_array( $taxonomy, $taxonomies, true );
 }
 /**
 * Get an array of ancestor IDs for a given object.
 *
 * @param int    $object_id     Optional. The ID of the object. Default 0.
 * @param string $object_type   Optional. The type of object for which we'll be retrieving
 *                              ancestors. Accepts a post type or a taxonomy name. Default empty.
 * @param string $resource_type Optional. Type of resource $object_type is. Accepts 'post_type'
 *                              or 'taxonomy'. Default empty.
-* @return array An array of ancestors from lowest to highest in the hierarchy.
+* @return int[] An array of IDs of ancestors from lowest to highest in the hierarchy.
 */
 function get_ancestors( $object_id = 0, $object_type = '', $resource_type = '' ) {
 	$object_id = (int) $object_id;
 	$ancestors = array();
 		}
 	}
 	if ( 'taxonomy' === $resource_type ) {
 		$term = get_term( $object_id, $object_type );
-		while ( ! is_wp_error( $term ) && ! empty( $term->parent ) && ! in_array( $term->parent, $ancestors ) ) {
+		while ( ! is_wp_error( $term ) && ! empty( $term->parent ) && ! in_array( $term->parent, $ancestors, true ) ) {
 			$ancestors[] = (int) $term->parent;
 			$term        = get_term( $term->parent, $object_type );
 		}
 	} elseif ( 'post_type' === $resource_type ) {
 		$ancestors = get_post_ancestors( $object_id );
 	 * Filters a given object's ancestors.
 	 *
 	 * @since 3.1.0
 	 * @since 4.1.1 Introduced the `$resource_type` parameter.
 	 *
-	 * @param array  $ancestors     An array of object ancestors.
+	 * @param int[]  $ancestors     An array of IDs of object ancestors.
 	 * @param int    $object_id     Object ID.
 	 * @param string $object_type   Type of object.
 	 * @param string $resource_type Type of resource $object_type is.
 	 */
 	return apply_filters( 'get_ancestors', $ancestors, $object_id, $object_type, $resource_type );
 * @since 3.1.0
 *
 * @param int    $parent   `term_id` of the parent for the term we're checking.
 * @param int    $term_id  The term we're checking.
 * @param string $taxonomy The taxonomy of the term we're checking.
-*
 * @return int The new parent for the term.
 */
 function wp_check_term_hierarchy_for_loops( $parent, $term_id, $taxonomy ) {
-	// Nothing fancy here - bail
+	// Nothing fancy here - bail.
 	if ( ! $parent ) {
 		return 0;
 	}
 	// Can't be its own parent.
-	if ( $parent == $term_id ) {
+	if ( $parent === $term_id ) {
 		return 0;
 	}
 	// Now look for larger loops.
-	if ( ! $loop = wp_find_hierarchy_loop( 'wp_get_term_taxonomy_parent_id', $term_id, $parent, array( $taxonomy ) ) ) {
+	$loop = wp_find_hierarchy_loop( 'wp_get_term_taxonomy_parent_id', $term_id, $parent, array( $taxonomy ) );
-		return $parent; // No loop
+	if ( ! $loop ) {
+		return $parent; // No loop.
 	}
 	// Setting $parent to the given value causes a loop.
 	if ( isset( $loop[ $term_id ] ) ) {
 		return 0;

changeset 16	a86126ab1dd4
parent 9	177826044cd9
child 18	be944660c56a