Support per-post-type invalidates_query_cache behavior

Use get_post_type() in wp_cache_set_posts_last_changed to check the
exact subtype when deciding whether to skip cache invalidation.

Extract post types from the parent WP_Query context in WP_Meta_Query
so that a key registered as non-cacheable for one post type is still
allowed in queries targeting a different post type.

Adds tests for per-subtype behavior: matching post type, different
post type, array of post types, and cache invalidation with mismatched
post type.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Author: ellatrix

src/wp-includes/class-wp-meta-query.php

@@ -103,6 +103,14 @@ class WP_Meta_Query {
 	 */
 	protected $object_type = '';
 
+	/**
+	 * Object subtypes for the query (e.g. post types).
+	 *
+	 * @since 7.0.0
+	 * @var string[]
+	 */
+	protected $object_subtypes = array();
+
 	/**
 	 * Constructor.
 	 *
@@ -374,6 +382,17 @@ public function get_sql( $type, $primary_table, $primary_id_column, $context = n
 		$this->meta_id_column = sanitize_key( $type . '_id' );
 		$this->object_type    = $type;
 
+		// Extract object subtypes from the parent query context.
+		$this->object_subtypes = array();
+		if ( 'post' === $type && $context instanceof WP_Query && ! empty( $context->query_vars['post_type'] ) ) {
+			$post_type = $context->query_vars['post_type'];
+			if ( is_array( $post_type ) ) {
+				$this->object_subtypes = $post_type;
+			} elseif ( 'any' !== $post_type ) {
+				$this->object_subtypes = array( $post_type );
+			}
+		}
+
 		$this->primary_table     = $primary_table;
 		$this->primary_id_column = $primary_id_column;
 
@@ -546,7 +565,7 @@ public function get_sql_for_clause( &$clause, $parent_query, $clause_key = '' )
 		if ( $this->object_type
 			&& isset( $clause['key'] )
 			&& is_string( $clause['key'] )
-			&& ! wp_meta_key_invalidates_query_cache( $this->object_type, $clause['key'] )
+			&& $this->is_non_cacheable_meta_key( $clause['key'] )
 		) {
 			_doing_it_wrong(
 				__METHOD__,
@@ -838,6 +857,33 @@ public function get_clauses() {
 		return $this->clauses;
 	}
 
+	/**
+	 * Checks whether a meta key is registered as non-query-cacheable.
+	 *
+	 * When object subtypes are known (e.g. post types from the parent WP_Query),
+	 * checks each subtype individually. If any subtype has the key registered as
+	 * non-cacheable, returns true. Falls back to searching across all subtypes
+	 * when no subtypes are available.
+	 *
+	 * @since 7.0.0
+	 *
+	 * @param string $meta_key Meta key to check.
+	 * @return bool True if the meta key is non-cacheable, false otherwise.
+	 */
+	protected function is_non_cacheable_meta_key( $meta_key ) {
+		if ( ! empty( $this->object_subtypes ) ) {
+			foreach ( $this->object_subtypes as $subtype ) {
+				if ( ! wp_meta_key_invalidates_query_cache( $this->object_type, $meta_key, $subtype ) ) {
+					return true;
+				}
+			}
+			return false;
+		}
+
+		// No subtypes available — fall back to checking all subtypes.
+		return ! wp_meta_key_invalidates_query_cache( $this->object_type, $meta_key );
+	}
+
 	/**
 	 * Identifies an existing table alias that is compatible with the current
 	 * query clause.

src/wp-includes/post.php

@@ -8469,8 +8469,11 @@ function wp_add_trashed_suffix_to_post_name_for_post( $post ) {
  * @param string $meta_key  Optional. Meta key. Passed by meta action hooks.
  */
 function wp_cache_set_posts_last_changed( $meta_id = 0, $object_id = 0, $meta_key = '' ) {
-	if ( $meta_key && ! wp_meta_key_invalidates_query_cache( 'post', $meta_key ) ) {
-		return;
+	if ( $meta_key ) {
+		$post_type = $object_id ? get_post_type( $object_id ) : '';
+		if ( ! wp_meta_key_invalidates_query_cache( 'post', $meta_key, $post_type ? $post_type : '' ) ) {
+			return;
+		}
 	}
 	wp_cache_set_last_changed( 'posts' );
 }

tests/phpunit/tests/meta/invalidatesQueryCache.php

@@ -22,6 +22,7 @@ public static function wpTearDownAfterClass() {
 	public function tear_down() {
 		unregister_meta_key( 'post', 'nocache_meta' );
 		unregister_meta_key( 'post', 'nocache_meta', 'post' );
+		unregister_meta_key( 'post', 'nocache_meta', 'page' );
 		unregister_meta_key( 'post', 'normal_meta' );
 		parent::tear_down();
 	}
@@ -216,17 +217,21 @@ public function test_subtype_registration_skips_cache_invalidation() {
 	}
 
 	/**
-	 * A key registered for a specific post type should be refused in meta queries.
+	 * A key registered for a specific post type should be refused in meta queries
+	 * when the WP_Query targets that post type.
 	 *
 	 * @expectedIncorrectUsage WP_Meta_Query::get_sql_for_clause
 	 */
-	public function test_subtype_registration_refuses_meta_query() {
+	public function test_subtype_registration_refuses_meta_query_for_matching_post_type() {
 		register_post_meta(
 			'post',
 			'nocache_meta',
 			array( 'invalidates_query_cache' => false )
 		);
 
+		$query = new WP_Query();
+		$query->query_vars['post_type'] = 'post';
+
 		$meta_query = new WP_Meta_Query(
 			array(
 				array(
@@ -236,8 +241,88 @@ public function test_subtype_registration_refuses_meta_query() {
 			)
 		);
 
-		$sql = $meta_query->get_sql( 'post', 'wp_posts', 'ID' );
+		$sql = $meta_query->get_sql( 'post', 'wp_posts', 'ID', $query );
 
-		$this->assertStringNotContainsString( 'nocache_meta', $sql['where'], 'Non-cacheable meta key should not appear in WHERE clause.' );
+		$this->assertStringNotContainsString( 'nocache_meta', $sql['where'], 'Non-cacheable meta key should not appear in WHERE clause for matching post type.' );
+	}
+
+	/**
+	 * A key registered as non-cacheable for one post type should be allowed
+	 * in meta queries targeting a different post type.
+	 */
+	public function test_subtype_registration_allows_meta_query_for_different_post_type() {
+		register_post_meta(
+			'page',
+			'nocache_meta',
+			array( 'invalidates_query_cache' => false )
+		);
+
+		$query = new WP_Query();
+		$query->query_vars['post_type'] = 'post';
+
+		$meta_query = new WP_Meta_Query(
+			array(
+				array(
+					'key'   => 'nocache_meta',
+					'value' => 'test',
+				),
+			)
+		);
+
+		$sql = $meta_query->get_sql( 'post', 'wp_posts', 'ID', $query );
+
+		$this->assertStringContainsString( 'nocache_meta', $sql['where'], 'Meta key should be allowed for a post type where it is cacheable.' );
+	}
+
+	/**
+	 * When querying multiple post types, if the key is non-cacheable on any
+	 * of them, the clause should be refused.
+	 *
+	 * @expectedIncorrectUsage WP_Meta_Query::get_sql_for_clause
+	 */
+	public function test_subtype_registration_refuses_meta_query_for_array_with_matching_post_type() {
+		register_post_meta(
+			'page',
+			'nocache_meta',
+			array( 'invalidates_query_cache' => false )
+		);
+
+		$query = new WP_Query();
+		$query->query_vars['post_type'] = array( 'post', 'page' );
+
+		$meta_query = new WP_Meta_Query(
+			array(
+				array(
+					'key'   => 'nocache_meta',
+					'value' => 'test',
+				),
+			)
+		);
+
+		$sql = $meta_query->get_sql( 'post', 'wp_posts', 'ID', $query );
+
+		$this->assertStringNotContainsString( 'nocache_meta', $sql['where'], 'Non-cacheable meta key should be refused when any queried post type has it as non-cacheable.' );
+	}
+
+	/**
+	 * A key registered for a specific post type should not skip cache invalidation
+	 * when written to a different post type.
+	 */
+	public function test_subtype_registration_does_not_skip_cache_for_different_post_type() {
+		register_post_meta(
+			'page',
+			'nocache_meta',
+			array( 'invalidates_query_cache' => false )
+		);
+
+		// self::$post_id is a 'post', not a 'page'.
+		wp_cache_set_last_changed( 'posts' );
+		$before = wp_cache_get_last_changed( 'posts' );
+
+		usleep( 1000 );
+		add_post_meta( self::$post_id, 'nocache_meta', 'value1' );
+
+		$after = wp_cache_get_last_changed( 'posts' );
+		$this->assertNotSame( $before, $after, 'last_changed should still change when writing to a post type where the key is cacheable.' );
 	}
 }