ParserOutputAccess.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Page;
 
use InvalidArgumentException;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Parser\ParserCache;
use MediaWiki\Parser\ParserCacheFactory;
use MediaWiki\Parser\ParserOptions;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Parser\RevisionOutputCache;
use MediaWiki\PoolCounter\PoolCounterFactory;
use MediaWiki\PoolCounter\PoolCounterWork;
use MediaWiki\PoolCounter\PoolCounterWorkViaCallback;
use MediaWiki\Revision\RevisionLookup;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\RevisionRenderer;
use MediaWiki\Status\Status;
use MediaWiki\Title\TitleFormatter;
use MediaWiki\WikiMap\WikiMap;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use Wikimedia\Assert\Assert;
use Wikimedia\MapCacheLRU\MapCacheLRU;
use Wikimedia\Parsoid\Parsoid;
use Wikimedia\Rdbms\ChronologyProtector;
use Wikimedia\Stats\StatsFactory;
use Wikimedia\Telemetry\SpanInterface;
use Wikimedia\Telemetry\TracerInterface;
 
class ParserOutputAccess implements LoggerAwareInterface {
 
    public const PARSOID_PCACHE_NAME = 'parsoid-' . ParserCacheFactory::DEFAULT_NAME;
 
    public const PARSOID_RCACHE_NAME = 'parsoid-' . ParserCacheFactory::DEFAULT_RCACHE_NAME;
 
    public const POSTPROC_CACHE_PREFIX = 'postproc-';
 
    public const OPT_NO_CHECK_CACHE = 1;
 
    public const OPT_FORCE_PARSE = self::OPT_NO_CHECK_CACHE;
 
    public const OPT_NO_UPDATE_CACHE = 2;
 
    public const OPT_NO_AUDIENCE_CHECK = 4;
 
    public const OPT_NO_CACHE = self::OPT_NO_UPDATE_CACHE | self::OPT_NO_CHECK_CACHE;
 
    public const OPT_LINKS_UPDATE = 8;
 
    public const OPT_FOR_ARTICLE_VIEW = 16;
 
    public const OPT_IGNORE_PROFILE_VERSION = 128;
 
    public const OPT_NO_POSTPROC_CACHE = 256;
 
    public const OPT_POOL_COUNTER_FALLBACK = 'poolcounter-fallback';
 
    public const OPT_POOL_COUNTER = 'poolcounter-type';
 
    public const POOL_COUNTER_ARTICLE_VIEW = 'ArticleView';
 
    public const POOL_COUNTER_REST_API = 'HtmlRestApi';
 
    private const DEFAULT_OPTIONS = [
        self::OPT_POOL_COUNTER => null,
        self::OPT_POOL_COUNTER_FALLBACK => false
    ];
 
    private const CACHE_NONE = 'none';
 
    private const CACHE_PRIMARY = 'primary';
 
    private const CACHE_SECONDARY = 'secondary';
 
    private MapCacheLRU $localCache;
 
    private ParserCacheFactory $parserCacheFactory;
    private RevisionLookup $revisionLookup;
    private RevisionRenderer $revisionRenderer;
    private StatsFactory $statsFactory;
    private ChronologyProtector $chronologyProtector;
    private WikiPageFactory $wikiPageFactory;
    private TitleFormatter $titleFormatter;
    private TracerInterface $tracer;
    private PoolCounterFactory $poolCounterFactory;
    private LoggerInterface $logger;
 
    public function __construct(
        ParserCacheFactory $parserCacheFactory,
        RevisionLookup $revisionLookup,
        RevisionRenderer $revisionRenderer,
        StatsFactory $statsFactory,
        ChronologyProtector $chronologyProtector,
        WikiPageFactory $wikiPageFactory,
        TitleFormatter $titleFormatter,
        TracerInterface $tracer,
        PoolCounterFactory $poolCounterFactory
    ) {
        $this->parserCacheFactory = $parserCacheFactory;
        $this->revisionLookup = $revisionLookup;
        $this->revisionRenderer = $revisionRenderer;
        $this->statsFactory = $statsFactory;
        $this->chronologyProtector = $chronologyProtector;
        $this->wikiPageFactory = $wikiPageFactory;
        $this->titleFormatter = $titleFormatter;
        $this->tracer = $tracer;
        $this->poolCounterFactory = $poolCounterFactory;
 
        $this->localCache = new MapCacheLRU( 10 );
        $this->logger = new NullLogger();
    }
 
    public function setLogger( LoggerInterface $logger ): void {
        $this->logger = $logger;
    }
 
    private static function normalizeOptions( $options ): array {
        $bits = 0;
 
        // TODO: Starting in 1.46, emit deprecation warnings when getting an int.
 
        if ( is_array( $options ) ) {
            if ( $options['_normalized_'] ?? false ) {
                // already normalized.
                return $options;
            }
 
            // Collect all bits from array keys, in case one of the keys
            // sets multiple bits.
            foreach ( $options as $opt => $enabled ) {
                if ( is_int( $opt ) && $enabled === true ) {
                    $bits |= $opt;
                }
            }
        } else {
            $bits = $options;
            $options = [];
        }
 
        // From the (numerically) smallest to the largest option that can possibly exist
        for ( $b = self::OPT_NO_CHECK_CACHE; $b <= self::OPT_NO_POSTPROC_CACHE; $b <<= 1 ) {
            $options[$b] = (bool)( $bits & $b );
        }
 
        if ( $options[ self::OPT_FOR_ARTICLE_VIEW ] ) {
            $options[ self::OPT_POOL_COUNTER ] = self::POOL_COUNTER_ARTICLE_VIEW;
            $options[ self::OPT_POOL_COUNTER_FALLBACK ] = true;
        }
 
        $options += self::DEFAULT_OPTIONS;
 
        $options['_normalized_'] = true;
        return $options;
    }
 
    private function shouldUseCache(
        PageRecord $page,
        ?RevisionRecord $rev
    ) {
        if ( $rev && !$rev->getId() ) {
            // The revision isn't from the database, so the output can't safely be cached.
            return self::CACHE_NONE;
        }
 
        // NOTE: Keep in sync with ParserWikiPage::shouldCheckParserCache().
        // NOTE: when we allow caching of old revisions in the future,
        //       we must not allow caching of deleted revisions.
 
        $wikiPage = $this->wikiPageFactory->newFromTitle( $page );
        if ( !$page->exists() || !$wikiPage->getContentHandler()->isParserCacheSupported() ) {
            return self::CACHE_NONE;
        }
 
        $isOld = $rev && $rev->getId() !== $page->getLatest();
        if ( !$isOld ) {
            return self::CACHE_PRIMARY;
        }
 
        if ( !$rev->audienceCan( RevisionRecord::DELETED_TEXT, RevisionRecord::FOR_PUBLIC ) ) {
            // deleted/suppressed revision
            return self::CACHE_NONE;
        }
 
        return self::CACHE_SECONDARY;
    }
 
    public function getCachedParserOutput(
        PageRecord $page,
        ParserOptions $parserOptions,
        ?RevisionRecord $revision = null,
        $options = []
    ): ?ParserOutput {
        $options = self::normalizeOptions( $options );
 
        $span = $this->startOperationSpan( __FUNCTION__, $page, $revision );
        $isOld = $revision && $revision->getId() !== $page->getLatest();
        $useCache = $this->shouldUseCache( $page, $revision );
        $primaryCache = $this->getPrimaryCache( $parserOptions );
        $classCacheKey = $primaryCache->makeParserOutputKey( $page, $parserOptions );
 
        if ( $useCache === self::CACHE_PRIMARY ) {
            if ( !$isOld && $this->localCache->hasField( $classCacheKey, $page->getLatest() ) ) {
                return $this->localCache->getField( $classCacheKey, $page->getLatest() );
            }
            $output = $primaryCache->get( $page, $parserOptions );
        } elseif ( $useCache === self::CACHE_SECONDARY && $revision ) {
            $secondaryCache = $this->getSecondaryCache( $parserOptions );
            $output = $secondaryCache->get( $revision, $parserOptions );
        } else {
            $output = null;
        }
 
        $statType = $statReason = $output ? 'hit' : 'miss';
 
        if (
            $output && !$options[ self::OPT_IGNORE_PROFILE_VERSION ] &&
            $output->getContentHolder()->isParsoidContent()
        ) {
            $pageBundle = $output->getContentHolder()->getBasePageBundle();
            // T333606: Force a reparse if the version coming from cache is not the default
            $cachedVersion = $pageBundle->version ?? null;
            if (
                $cachedVersion !== null && // T325137: BadContentModel, no sense in reparsing
                $cachedVersion !== Parsoid::defaultHTMLVersion()
            ) {
                $statType = 'miss';
                $statReason = 'obsolete';
                $output = null;
            }
        }
 
        if ( $output && !$isOld && !$parserOptions->getPostproc() ) {
            $this->localCache->setField( $classCacheKey, $page->getLatest(), $output );
        }
 
        $this->statsFactory
            ->getCounter( 'parseroutputaccess_cache_total' )
            ->setLabel( 'cache', $useCache )
            ->setLabel( 'reason', $statReason )
            ->setLabel( 'type', $statType )
            ->setLabel( 'postproc', $parserOptions->getPostproc() ? 'true' : 'false' )
            ->increment();
 
        return $output ?: null; // convert false to null
    }
 
    private function getFallbackOutputForLatest(
        PageRecord $page,
        ParserOptions $parserOptions,
        string $workKey,
        bool $fast
    ) {
        $parserOutput = $this->getPrimaryCache( $parserOptions )
            ->getDirty( $page, $parserOptions );
 
        if ( !$parserOutput ) {
            $this->logger->info( 'dirty missing' );
            return false;
        }
 
        if ( $fast ) {
            // If this user recently made DB changes, then don't eagerly serve stale output,
            // so that users generally see their own edits after page save.
            //
            // If PoolCounter is overloaded, we may end up here a second time (with fast=false),
            // in which case we will serve a stale fallback then.
            //
            // Note that CP reports anything in the last 10 seconds from the same client,
            // including to other pages and other databases, so we bias towards avoiding
            // fast-stale responses for several seconds after saving an edit.
            if ( $this->chronologyProtector->getTouched() ) {
                $this->logger->info(
                    'declining fast-fallback to stale output since ChronologyProtector ' .
                    'reports the client recently made changes',
                    [ 'workKey' => $workKey ]
                );
                // Forget this ParserOutput -- we will request it again if
                // necessary in slow mode. There might be a newer entry
                // available by that time.
                return false;
            }
        }
 
        $this->logger->info( $fast ? 'fast dirty output' : 'dirty output', [ 'workKey' => $workKey ] );
 
        $status = Status::newGood( $parserOutput );
        $status->warning( 'view-pool-dirty-output' );
        $status->warning( $fast ? 'view-pool-contention' : 'view-pool-overload' );
        return $status;
    }
 
    public function getParserOutput(
        PageRecord $page,
        ParserOptions $parserOptions,
        ?RevisionRecord $revision = null,
        $options = []
    ): Status {
        $options = self::normalizeOptions( $options );
 
        $span = $this->startOperationSpan( __FUNCTION__, $page, $revision );
        $error = $this->checkPreconditions( $page, $revision, $options );
        if ( $error ) {
            $this->statsFactory
                ->getCounter( 'parseroutputaccess_case' )
                ->setLabel( 'case', 'error' )
                ->setLabel( 'postproc', $parserOptions->getPostproc() ? 'true' : 'false' )
                ->increment();
            return $error;
        }
 
        $isOld = $revision && $revision->getId() !== $page->getLatest();
        if ( $isOld ) {
            $this->statsFactory
                ->getCounter( 'parseroutputaccess_case' )
                ->setLabel( 'case', 'old' )
                ->setLabel( 'postproc', $parserOptions->getPostproc() ? 'true' : 'false' )
                ->increment();
        } else {
            $this->statsFactory
                ->getCounter( 'parseroutputaccess_case' )
                ->setLabel( 'case', 'current' )
                ->setLabel( 'postproc', $parserOptions->getPostproc() ? 'true' : 'false' )
                ->increment();
        }
 
        if ( $this->shouldCheckCache( $parserOptions, $options ) ) {
            $output = $this->getCachedParserOutput( $page, $parserOptions, $revision );
            if ( $output ) {
                return Status::newGood( $output );
            }
        }
 
        if ( !$revision ) {
            $revId = $page->getLatest();
            $revision = $revId ? $this->revisionLookup->getRevisionById( $revId ) : null;
 
            if ( !$revision ) {
                $this->statsFactory
                    ->getCounter( 'parseroutputaccess_status' )
                    ->setLabel( 'status', 'norev' )
                    ->setLabel( 'postproc', $parserOptions->getPostproc() ? 'true' : 'false' )
                    ->increment();
                return Status::newFatal( 'missing-revision', $revId );
            }
        }
 
        if ( $options[ self::OPT_POOL_COUNTER ] ) {
            $work = $this->newPoolWork( $page, $parserOptions, $revision, $options );
            $status = $work->execute();
        } else {
            // XXX: we could try harder to reuse a cache lookup above to
            // provide the $previous argument here
            $this->statsFactory->getCounter( 'parseroutputaccess_render_total' )
                ->setLabel( 'pool', 'none' )
                ->setLabel( 'cache', self::CACHE_NONE )
                ->setLabel( 'postproc', $parserOptions->getPostproc() ? 'true' : 'false' )
                ->increment();
 
            $status = $this->renderRevision( $page, $parserOptions, $revision, $options, null );
        }
 
        $output = $status->getValue();
        Assert::postcondition( $output || !$status->isOK(), 'Inconsistent status' );
 
        // T301310: cache even uncacheable content locally
        // T348255: temporarily disable local cache of postprocessed
        // content out of an abundance of caution
        if ( $output && !$isOld && !$parserOptions->getPostproc() ) {
            $primaryCache = $this->getPrimaryCache( $parserOptions );
            $classCacheKey = $primaryCache->makeParserOutputKey( $page, $parserOptions );
            $this->localCache->setField( $classCacheKey, $page->getLatest(), $output );
        }
 
        $labels = [
            'postproc' => $parserOptions->getPostproc() ? 'true' : 'false',
            'status' => $status->isGood() ? 'good' : ( $status->isOK() ? 'ok' : 'error' ),
        ];
 
        $this->statsFactory->getCounter( 'parseroutputaccess_status' )
            ->setLabels( $labels )
            ->increment();
 
        return $status;
    }
 
    private function renderRevision(
        PageRecord $page,
        ParserOptions $parserOptions,
        RevisionRecord $revision,
        array $options,
        ?ParserOutput $previousOutput = null
    ): Status {
        $span = $this->startOperationSpan( __FUNCTION__, $page, $revision );
 
        $isCurrent = $revision->getId() === $page->getLatest();
 
        // T371713: Temporary statistics collection code to determine
        // feasibility of Parsoid selective update
        $sampleRate = MediaWikiServices::getInstance()->getMainConfig()->get(
            MainConfigNames::ParsoidSelectiveUpdateSampleRate
        );
        $doSample = ( $sampleRate && mt_rand( 1, $sampleRate ) === 1 );
 
        if ( $previousOutput === null && ( $doSample || $parserOptions->getUseParsoid() ) ) {
            // If $useCache === self::CACHE_SECONDARY we could potentially
            // try to reuse the parse of $revision-1 from the secondary cache,
            // but it is likely those template transclusions are out of date.
            // Try to reuse the template transclusions from the most recent
            // parse, which are more likely to reflect the current template.
            if ( $this->shouldCheckCache( $parserOptions, $options ) ) {
                $previousOutput = $this->getPrimaryCache( $parserOptions )->getDirty( $page, $parserOptions ) ?: null;
            }
        }
 
        $preStatus = null;
        if ( $parserOptions->getPostproc() ) {
            $preParserOptions = $parserOptions->clearPostproc();
            $preStatus = $this->getParserOutput( $page, $preParserOptions, $revision, $options );
            $output = $preStatus->getValue();
            if ( $output ) {
                $output = $this->postprocess( $output, $parserOptions );
            }
        } else {
            $renderedRev = $this->revisionRenderer->getRenderedRevision( $revision, $parserOptions, null, [
                    'audience' => RevisionRecord::RAW,
                    'previous-output' => $previousOutput,
                ] );
 
            $output = $renderedRev->getRevisionParserOutput();
        }
 
        if ( $doSample ) {
            $labels = [
                'source' => 'ParserOutputAccess',
                'type' => $previousOutput === null ? 'full' : 'selective',
                'reason' => $parserOptions->getRenderReason(),
                'parser' => $parserOptions->getUseParsoid() ? 'parsoid' : 'legacy',
                'opportunistic' => 'false',
                'wiki' => WikiMap::getCurrentWikiId(),
                'model' => $revision->getMainContentModel(),
                'postproc' => $parserOptions->getPostproc() ? 'true' : 'false',
            ];
            $this->statsFactory
                ->getCounter( 'ParserCache_selective_total' )
                ->setLabels( $labels )
                ->increment();
            $this->statsFactory
                ->getCounter( 'ParserCache_selective_cpu_seconds' )
                ->setLabels( $labels )
                ->incrementBy( $output->getTimeProfile( 'cpu' ) ?? 0 );
        }
 
        $res = Status::newGood( $output );
        if ( $preStatus ) {
            $res->merge( $preStatus );
        }
 
        if ( $output && $res->isGood() ) {
            // do not cache the result if the parsercache result wasn't good (e.g. stale)
            $this->saveToCache( $parserOptions, $output, $page, $revision, $options );
        }
 
        if ( $output && $options[ self::OPT_LINKS_UPDATE ] && !$parserOptions->getPostproc() ) {
            $this->wikiPageFactory->newFromTitle( $page )
                ->triggerOpportunisticLinksUpdate( $output );
        }
 
        return $res;
    }
 
    private function checkPreconditions(
        PageRecord $page,
        ?RevisionRecord $revision = null,
        array $options = []
    ): ?Status {
        if ( !$page->exists() ) {
            return Status::newFatal( 'nopagetext' );
        }
 
        if ( !$options[ self::OPT_NO_UPDATE_CACHE ] && $revision && !$revision->getId() ) {
            throw new InvalidArgumentException(
                'The revision does not have a known ID. Use OPT_NO_CACHE.'
            );
        }
 
        if ( $revision && $revision->getPageId() !== $page->getId() ) {
            throw new InvalidArgumentException(
                'The revision does not belong to the given page.'
            );
        }
 
        if ( $revision && !$options[ self::OPT_NO_AUDIENCE_CHECK ] ) {
            // NOTE: If per-user checks are desired, the caller should perform them and
            //       then set OPT_NO_AUDIENCE_CHECK if they passed.
            if ( !$revision->audienceCan( RevisionRecord::DELETED_TEXT, RevisionRecord::FOR_PUBLIC ) ) {
                return Status::newFatal(
                    'missing-revision-permission',
                    $revision->getId(),
                    $revision->getTimestamp(),
                    $this->titleFormatter->getPrefixedURL( $page )
                );
            }
        }
 
        return null;
    }
 
    protected function newPoolWork(
        PageRecord $page,
        ParserOptions $parserOptions,
        RevisionRecord $revision,
        array $options
    ): PoolCounterWork {
        // Default behavior (no caching)
        $callbacks = [
            'doWork' => function () use ( $page, $parserOptions, $revision, $options ) {
                return $this->renderRevision(
                    $page,
                    $parserOptions,
                    $revision,
                    $options
                );
            },
            'doCachedWork' => static function () {
                // uncached
                return false;
            },
            'fallback' => static function ( $fast ) {
                // no fallback
                return false;
            },
            'error' => static function ( $status ) {
                return $status;
            }
        ];
 
        $useCache = $this->shouldUseCache( $page, $revision );
 
        $this->statsFactory->getCounter( 'parseroutputaccess_render_total' )
            ->setLabel( 'pool', 'articleview' )
            ->setLabel( 'cache', $useCache )
            ->setLabel( 'postproc', $parserOptions->getPostproc() ? 'true' : 'false' )
            ->increment();
 
        switch ( $useCache ) {
            case self::CACHE_PRIMARY:
                $primaryCache = $this->getPrimaryCache( $parserOptions );
                $parserCacheMetadata = $primaryCache->getMetadata( $page );
                $cacheKey = $primaryCache->makeParserOutputKey( $page, $parserOptions,
                    $parserCacheMetadata ? $parserCacheMetadata->getUsedOptions() : null
                );
 
                $workKey = $cacheKey . ':revid:' . $revision->getId();
 
                $callbacks['doCachedWork'] =
                    static function () use ( $primaryCache, $page, $parserOptions ) {
                        $parserOutput = $primaryCache->get( $page, $parserOptions );
                        return $parserOutput ? Status::newGood( $parserOutput ) : false;
                    };
 
                $callbacks['fallback'] =
                    function ( $fast ) use ( $page, $parserOptions, $workKey, $options ) {
                        if ( $options[ self::OPT_POOL_COUNTER_FALLBACK ] ) {
                            return $this->getFallbackOutputForLatest(
                                $page, $parserOptions, $workKey, $fast
                            );
                        } else {
                            return false;
                        }
                    };
 
                break;
 
            case self::CACHE_SECONDARY:
                $secondaryCache = $this->getSecondaryCache( $parserOptions );
                $workKey = $secondaryCache->makeParserOutputKey( $revision, $parserOptions );
 
                $callbacks['doCachedWork'] =
                    static function () use ( $secondaryCache, $revision, $parserOptions ) {
                        $parserOutput = $secondaryCache->get( $revision, $parserOptions );
 
                        return $parserOutput ? Status::newGood( $parserOutput ) : false;
                    };
 
                break;
 
            default:
                $secondaryCache = $this->getSecondaryCache( $parserOptions );
                $workKey = $secondaryCache->makeParserOutputKeyOptionalRevId( $revision, $parserOptions );
        }
 
        $profile = $options[ self::OPT_POOL_COUNTER ];
        $pool = $this->poolCounterFactory->create( $profile, $workKey );
        return new PoolCounterWorkViaCallback(
            $pool,
            $workKey,
            $callbacks
        );
    }
 
    private function getPrimaryCache( ParserOptions $pOpts ): ParserCache {
        $name = $pOpts->getUseParsoid() ? self::PARSOID_PCACHE_NAME : ParserCacheFactory::DEFAULT_NAME;
        if ( $pOpts->getPostproc() ) {
            $name = self::POSTPROC_CACHE_PREFIX . $name;
        }
        return $this->parserCacheFactory->getParserCache( $name );
    }
 
    private function getSecondaryCache( ParserOptions $pOpts ): RevisionOutputCache {
        $name = $pOpts->getUseParsoid() ? self::PARSOID_RCACHE_NAME : ParserCacheFactory::DEFAULT_RCACHE_NAME;
        if ( $pOpts->getPostproc() ) {
            $name = self::POSTPROC_CACHE_PREFIX . $name;
        }
        return $this->parserCacheFactory->getRevisionOutputCache( $name );
    }
 
    private function startOperationSpan(
        string $opName,
        PageRecord $page,
        ?RevisionRecord $revision = null
    ): SpanInterface {
        $span = $this->tracer->createSpan( "ParserOutputAccess::$opName" );
        if ( $span->getContext()->isSampled() ) {
            $span->setAttributes( [
                'org.wikimedia.parser.page' => $page->__toString(),
                'org.wikimedia.parser.page.id' => $page->getId(),
                'org.wikimedia.parser.page.wiki' => $page->getWikiId(),
            ] );
            if ( $revision ) {
                $span->setAttributes( [
                    'org.wikimedia.parser.revision.id' => $revision->getId(),
                    'org.wikimedia.parser.revision.parent_id' => $revision->getParentId(),
                ] );
            }
        }
        return $span->start()->activate();
    }
 
    public function clearLocalCache() {
        $this->localCache->clear();
    }
 
    private function saveToCache(
        ParserOptions $parserOptions, ParserOutput $output, PageRecord $page, RevisionRecord $revision, array $options
    ): void {
        $useCache = $this->shouldUseCache( $page, $revision );
        if ( !$options[ self::OPT_NO_UPDATE_CACHE ] && $output->isCacheable() ) {
            if ( $useCache === self::CACHE_PRIMARY ) {
                $primaryCache = $this->getPrimaryCache( $parserOptions );
                $primaryCache->save( $output, $page, $parserOptions );
            } elseif ( $useCache === self::CACHE_SECONDARY ) {
                $secondaryCache = $this->getSecondaryCache( $parserOptions );
                $secondaryCache->save( $output, $revision, $parserOptions );
            }
        }
    }
 
    public function postprocess( ParserOutput $output, ParserOptions $parserOptions ): ParserOutput {
        // Kludgey workaround: extract $textOptions from the $parserOptions
        $textOptions = [];
        // Don't add these to the used options set of $output because we
        // don't want to mutate that, and the actual return value ParserOutput
        // doesn't yet exist.
        $parserOptions->registerWatcher( null );
        foreach ( ParserOptions::$postprocOptions as $key ) {
            $textOptions[$key] = $parserOptions->getOption( $key );
        }
        $textOptions = [
            'allowClone' => true,
        ] + $textOptions;
 
        $pipeline = MediaWikiServices::getInstance()->getDefaultOutputPipeline();
        $output = $pipeline->run( $output, $parserOptions, $textOptions );
        // Ensure this ParserOptions is watching the resulting ParserOutput,
        // now that it exists.
        $parserOptions->registerWatcher( $output->recordOption( ... ) );
        // Ensure "postproc" is in the set of used options
        // (Probably not necessary, but it doesn't hurt to be safe.)
        $parserOptions->getPostproc();
        // Ensure all postprocOptions are in the set of used options
        // (Since we can't detect accesses via $textOptions)
        foreach ( ParserOptions::$postprocOptions as $key ) {
            $parserOptions->getOption( $key );
        }
        return $output;
    }
 
    private function shouldCheckCache( ParserOptions $parserOptions, array $options ): bool {
        if ( $options[ self::OPT_NO_CHECK_CACHE ] ) {
            return false;
        }
        if ( $parserOptions->getPostproc() ) {
            return !$options[ self::OPT_NO_POSTPROC_CACHE ];
        }
        return true;
    }
}