ParserOptions.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Parser;
 
use BackedEnum;
use InvalidArgumentException;
use LogicException;
use MediaWiki\Content\Content;
use MediaWiki\Context\IContextSource;
use MediaWiki\Context\RequestContext;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Language\Language;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Page\PageIdentityValue;
use MediaWiki\Page\PageRecord;
use MediaWiki\Revision\MutableRevisionRecord;
use MediaWiki\Skin\Skin;
use MediaWiki\StubObject\StubObject;
use MediaWiki\Title\Title;
use MediaWiki\User\UserIdentity;
use MediaWiki\User\UserIdentityValue;
use MediaWiki\Utils\MWTimestamp;
use ReflectionClass;
use UnitEnum;
use Wikimedia\IPUtils;
use Wikimedia\Parsoid\Core\LinkTarget as ParsoidLinkTarget;
use Wikimedia\ScopedCallback;
use Wikimedia\Timestamp\TimestampFormat as TS;
 
class ParserOptions {
 
    private static $defaults = null;
 
    private static $lazyOptions = null;
 
    private static $initialLazyOptions = [
        'dateformat' => [ self::class, 'initDateFormat' ],
        'speculativeRevId' => [ self::class, 'initSpeculativeRevId' ],
        'speculativePageId' => [ self::class, 'initSpeculativePageId' ],
    ];
 
    private static $cacheVaryingOptionsHash = null;
 
    private static $initialCacheVaryingOptionsHash = [
        'dateformat' => true,
        'thumbsize' => true,
        'printable' => true,
        'userlang' => true,
        'useParsoid' => true,
        'collapsibleSections' => true,
        'postproc' => true,
        'skin' => true,
        'injectTOC' => true,
        'enableSectionEditLinks' => true,
        'variant' => true,
    ];
 
    public static array $postprocOptions = [
        'skin',
        'allowTOC',
        'injectTOC',
        'includeDebugInfo',
        'enableSectionEditLinks',
        'wrapperDivClass',
        'deduplicateStyles',
        'unwrap',
        'absoluteURLs',
        'variant',
    ];
 
    private static $callbacks = [
        'currentRevisionRecordCallback' => true,
        'templateCallback' => true,
        'speculativeRevIdCallback' => true,
        'speculativePageIdCallback' => true,
    ];
 
    private $options;
 
    private $mTimestamp;
 
    private $mUser;
 
    private $onAccessCallback = null;
 
    private $redirectTarget = null;
 
    private $mExtraKey = '';
 
    private $renderReason = 'unknown';
 
    public function getOption( $name ) {
        if ( !array_key_exists( $name, $this->options ) ) {
            throw new InvalidArgumentException( "Unknown parser option $name" );
        }
 
        $this->lazyLoadOption( $name );
        $this->optionUsed( $name );
        return $this->options[$name];
    }
 
    private function lazyLoadOption( $name ) {
        $lazyOptions = self::getLazyOptions();
        if ( isset( $lazyOptions[$name] ) && $this->options[$name] === null ) {
            $this->options[$name] = $lazyOptions[$name]( $this, $name );
        }
    }
 
    private function nullifyLazyOption( array $options ): array {
        return array_fill_keys( array_keys( self::getLazyOptions() ), null ) + $options;
    }
 
    public static function getLazyOptions(): array {
        // Trigger a call to the 'ParserOptionsRegister' hook if it hasn't
        // already been called.
        if ( self::$lazyOptions === null ) {
            self::getDefaults();
        }
        return self::$lazyOptions;
    }
 
    private static function getCacheVaryingOptionsHash(): array {
        // Trigger a call to the 'ParserOptionsRegister' hook if it hasn't
        // already been called.
        if ( self::$cacheVaryingOptionsHash === null ) {
            self::getDefaults();
        }
        return self::$cacheVaryingOptionsHash;
    }
 
    public function setOption( $name, $value ) {
        if ( !array_key_exists( $name, $this->options ) ) {
            throw new InvalidArgumentException( "Unknown parser option $name" );
        }
        $old = $this->options[$name];
        $this->options[$name] = $value;
        return $old;
    }
 
    protected function setOptionLegacy( $name, $value ) {
        if ( !array_key_exists( $name, $this->options ) ) {
            throw new InvalidArgumentException( "Unknown parser option $name" );
        }
        return wfSetVar( $this->options[$name], $value );
    }
 
    public function getInterwikiMagic() {
        return $this->getOption( 'interwikiMagic' );
    }
 
    public function setInterwikiMagic( $x ) {
        return $this->setOptionLegacy( 'interwikiMagic', $x );
    }
 
    public function getAllowExternalImages() {
        return $this->getOption( 'allowExternalImages' );
    }
 
    public function getAllowExternalImagesFrom() {
        return $this->getOption( 'allowExternalImagesFrom' );
    }
 
    public function getEnableImageWhitelist() {
        return $this->getOption( 'enableImageWhitelist' );
    }
 
    public function getAllowSpecialInclusion() {
        return $this->getOption( 'allowSpecialInclusion' );
    }
 
    public function setAllowSpecialInclusion( $x ) {
        return $this->setOptionLegacy( 'allowSpecialInclusion', $x );
    }
 
    public function getInterfaceMessage() {
        return $this->getOption( 'interfaceMessage' );
    }
 
    public function setInterfaceMessage( $x ) {
        return $this->setOptionLegacy( 'interfaceMessage', $x );
    }
 
    public function isMessage() {
        return $this->getOption( 'isMessage' );
    }
 
    public function setIsMessage( $x ) {
        return $this->setOption( 'isMessage', $x );
    }
 
    public function getTargetLanguage() {
        return $this->getOption( 'targetLanguage' );
    }
 
    public function setTargetLanguage( $x ) {
        return $this->setOption( 'targetLanguage', $x );
    }
 
    public function getMaxIncludeSize() {
        return $this->getOption( 'maxIncludeSize' );
    }
 
    public function setMaxIncludeSize( $x ) {
        return $this->setOptionLegacy( 'maxIncludeSize', $x );
    }
 
    public function getMaxPPNodeCount() {
        return $this->getOption( 'maxPPNodeCount' );
    }
 
    public function setMaxPPNodeCount( $x ) {
        return $this->setOptionLegacy( 'maxPPNodeCount', $x );
    }
 
    public function getMaxPPExpandDepth() {
        return $this->getOption( 'maxPPExpandDepth' );
    }
 
    public function getMaxTemplateDepth() {
        return $this->getOption( 'maxTemplateDepth' );
    }
 
    public function setMaxTemplateDepth( $x ) {
        return $this->setOptionLegacy( 'maxTemplateDepth', $x );
    }
 
    public function getExpensiveParserFunctionLimit() {
        return $this->getOption( 'expensiveParserFunctionLimit' );
    }
 
    public function setExpensiveParserFunctionLimit( $x ) {
        return $this->setOptionLegacy( 'expensiveParserFunctionLimit', $x );
    }
 
    public function getRemoveComments() {
        return $this->getOption( 'removeComments' );
    }
 
    public function setRemoveComments( $x ) {
        return $this->setOptionLegacy( 'removeComments', $x );
    }
 
    public function getEnableLimitReport() {
        return false;
    }
 
    public function enableLimitReport( $x = true ) {
        return false;
    }
 
    public function getCleanSignatures() {
        return $this->getOption( 'cleanSignatures' );
    }
 
    public function setCleanSignatures( $x ) {
        return $this->setOptionLegacy( 'cleanSignatures', $x );
    }
 
    public function getExternalLinkTarget() {
        return $this->getOption( 'externalLinkTarget' );
    }
 
    public function setExternalLinkTarget( $x ) {
        return $this->setOptionLegacy( 'externalLinkTarget', $x );
    }
 
    public function getDisableContentConversion() {
        return $this->getOption( 'disableContentConversion' );
    }
 
    public function disableContentConversion( $x = true ) {
        return $this->setOptionLegacy( 'disableContentConversion', $x );
    }
 
    public function getDisableTitleConversion() {
        return $this->getOption( 'disableTitleConversion' );
    }
 
    public function disableTitleConversion( $x = true ) {
        return $this->setOptionLegacy( 'disableTitleConversion', $x );
    }
 
    public function getThumbSize() {
        return $this->getOption( 'thumbsize' );
    }
 
    public function setThumbSize( $x ) {
        return $this->options['thumbsize'];
    }
 
    public function getIsPreview() {
        return $this->getOption( 'isPreview' ) || $this->getOption( 'isSectionPreview' );
    }
 
    public function setIsPreview( $x ) {
        if ( $x === false && ( $this->options['isSectionPreview'] ?? null ) === true ) {
            $this->setOption( 'isSectionPreview', false );
        }
        return $this->setOptionLegacy( 'isPreview', $x );
    }
 
    public function getIsSectionPreview() {
        return $this->getOption( 'isSectionPreview' );
    }
 
    public function setIsSectionPreview( $x ) {
        if ( $x === true && ( $this->options['isPreview'] ?? null ) === false ) {
            $this->setOption( 'isPreview', true );
        }
        return $this->setOptionLegacy( 'isSectionPreview', $x );
    }
 
    public function getIsPrintable() {
        return $this->getOption( 'printable' );
    }
 
    public function setIsPrintable( $x ) {
        return $this->setOptionLegacy( 'printable', $x );
    }
 
    public function getPreSaveTransform() {
        return $this->getOption( 'preSaveTransform' );
    }
 
    public function setPreSaveTransform( $x ) {
        return $this->setOptionLegacy( 'preSaveTransform', $x );
    }
 
    public function getUseParsoid(): bool {
        return $this->getOption( 'useParsoid' );
    }
 
    public function setUseParsoid( bool $value = true ) {
        $this->setOption( 'useParsoid', $value );
    }
 
    public function getDateFormat() {
        return $this->getOption( 'dateformat' );
    }
 
    private static function initDateFormat( ParserOptions $popt ) {
        $userFactory = MediaWikiServices::getInstance()->getUserFactory();
        return $userFactory->newFromUserIdentity( $popt->getUserIdentity() )->getDatePreference();
    }
 
    public function setDateFormat( $x ) {
        return $this->setOptionLegacy( 'dateformat', $x );
    }
 
    public function getUserLangObj() {
        return $this->getOption( 'userlang' );
    }
 
    public function getUserLang() {
        return $this->getUserLangObj()->getCode();
    }
 
    public function setUserLang( $x ) {
        if ( is_string( $x ) ) {
            $x = MediaWikiServices::getInstance()->getLanguageFactory()->getLanguage( $x );
        }
 
        return $this->setOptionLegacy( 'userlang', $x );
    }
 
    public function getMagicISBNLinks() {
        return $this->getOption( 'magicISBNLinks' );
    }
 
    public function getMagicPMIDLinks() {
        return $this->getOption( 'magicPMIDLinks' );
    }
 
    public function getMagicRFCLinks() {
        return $this->getOption( 'magicRFCLinks' );
    }
 
    public function getSuppressTOC() {
        return $this->getOption( 'suppressTOC' );
    }
 
    public function setSuppressTOC() {
        wfDeprecated( __METHOD__, '1.42' );
        $this->setOption( 'suppressTOC', true );
    }
 
    public function getSuppressSectionEditLinks() {
        return !$this->getOption( 'enableSectionEditLinks' );
    }
 
    public function setSuppressSectionEditLinks() {
        $this->setOption( 'enableSectionEditLinks', false );
    }
 
    public function getCollapsibleSections(): bool {
        return $this->getOption( 'collapsibleSections' );
    }
 
    public function setCollapsibleSections(): void {
        $this->setOption( 'collapsibleSections', true );
    }
 
    public function setVariant( ?Language $variantLanguage ) {
        $this->setOption( 'variant', $variantLanguage );
    }
 
    public function getVariant(): ?Language {
        return $this->getOption( 'variant' );
    }
 
    public function getAllowUnsafeRawHtml() {
        return $this->getOption( 'allowUnsafeRawHtml' );
    }
 
    public function setAllowUnsafeRawHtml( $x ) {
        return $this->setOptionLegacy( 'allowUnsafeRawHtml', $x );
    }
 
    public function getWrapOutputClass() {
        return $this->getOption( 'wrapclass' );
    }
 
    public function setWrapOutputClass( $className ) {
        if ( $className === true ) { // DWIM, they probably want the default class name
            $className = 'mw-parser-output';
        }
        if ( $className === false ) {
            wfDeprecated( __METHOD__ . '( false )', '1.31' );
        }
        return $this->setOption( 'wrapclass', $className );
    }
 
    public function getCurrentRevisionRecordCallback() {
        return $this->getOption( 'currentRevisionRecordCallback' );
    }
 
    public function setCurrentRevisionRecordCallback( $x ) {
        return $this->setOption( 'currentRevisionRecordCallback', $x );
    }
 
    public function getTemplateCallback() {
        return $this->getOption( 'templateCallback' );
    }
 
    public function setTemplateCallback( $x ) {
        return $this->setOptionLegacy( 'templateCallback', $x );
    }
 
    public function getSpeculativeRevId() {
        return $this->getOption( 'speculativeRevId' );
    }
 
    public function getSpeculativePageId() {
        return $this->getOption( 'speculativePageId' );
    }
 
    private static function initSpeculativeRevId( ParserOptions $popt ) {
        $cb = $popt->getOption( 'speculativeRevIdCallback' );
        $id = $cb ? $cb() : null;
 
        // returning null would result in this being re-called every access
        return $id ?? false;
    }
 
    private static function initSpeculativePageId( ParserOptions $popt ) {
        $cb = $popt->getOption( 'speculativePageIdCallback' );
        $id = $cb ? $cb() : null;
 
        // returning null would result in this being re-called every access
        return $id ?? false;
    }
 
    public function setSpeculativeRevIdCallback( $x ) {
        $this->setOption( 'speculativeRevId', null ); // reset
        return $this->setOption( 'speculativeRevIdCallback', $x );
    }
 
    public function setSpeculativePageIdCallback( $x ) {
        $this->setOption( 'speculativePageId', null ); // reset
        return $this->setOption( 'speculativePageIdCallback', $x );
    }
 
    public function getTimestamp() {
        if ( $this->mTimestamp === null ) {
            $this->mTimestamp = wfTimestampNow();
        }
        return $this->mTimestamp;
    }
 
    public function setTimestamp( $x ) {
        return wfSetVar( $this->mTimestamp, $x );
    }
 
    public function setRedirectTarget( $title ) {
        $this->redirectTarget = $title;
    }
 
    public function getRedirectTarget() {
        return $this->redirectTarget;
    }
 
    public function addExtraKey( $key ) {
        $this->mExtraKey .= '!' . $key;
    }
 
    public function getUserIdentity(): UserIdentity {
        return $this->mUser;
    }
 
    public function __construct( UserIdentity $user, $lang = null ) {
        $lang ??= RequestContext::getMain()->getLanguage();
        $this->initialiseFromUser( $user, $lang );
    }
 
    public static function newFromAnon() {
        return new ParserOptions( MediaWikiServices::getInstance()->getUserFactory()->newAnonymous(),
            MediaWikiServices::getInstance()->getContentLanguage() );
    }
 
    public static function newFromUser( $user ) {
        return new ParserOptions( $user );
    }
 
    public static function newFromUserAndLang( UserIdentity $user, Language $lang ) {
        return new ParserOptions( $user, $lang );
    }
 
    public static function newFromContext( IContextSource $context ) {
        $contextUser = $context->getUser();
 
        // Use the stashed temporary account name instead of an IP address as the user for the ParserOptions
        // (if a stashed name is set). This is so that magic words like {{REVISIONUSER}} show the temporary account
        // name instead of IP address.
        $tempUserCreator = MediaWikiServices::getInstance()->getTempUserCreator();
        if ( $tempUserCreator->isEnabled() && IPUtils::isIPAddress( $contextUser->getName() ) ) {
            // We do not attempt to acquire a temporary account name if no name is stashed, as this may be called in
            // contexts (such as the parse API) where the user will not be performing an edit on their next action
            // and therefore would be increasing the rate limit unnecessarily.
            $tempName = $tempUserCreator->getStashedName( $context->getRequest()->getSession() );
            if ( $tempName !== null ) {
                $contextUser = UserIdentityValue::newAnonymous( $tempName );
            }
        }
 
        return new ParserOptions( $contextUser, $context->getLanguage() );
    }
 
    public static function newCanonical( $context, $userLang = null ) {
        if ( $context instanceof IContextSource ) {
            $ret = self::newFromContext( $context );
        } elseif ( $context === 'canonical' ) {
            $ret = self::newFromAnon();
        } elseif ( $context instanceof UserIdentity ) {
            $ret = new self( $context, $userLang );
        } else {
            throw new InvalidArgumentException(
                '$context must be an IContextSource, the string "canonical", or a UserIdentity'
            );
        }
        return $ret;
    }
 
    public static function clearStaticCache() {
        if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
            throw new LogicException( __METHOD__ . ' is just for testing' );
        }
        self::$defaults = null;
        self::$lazyOptions = null;
        self::$cacheVaryingOptionsHash = null;
    }
 
    private static function getDefaults() {
        $services = MediaWikiServices::getInstance();
 
        if ( self::$defaults === null ) {
            // *UPDATE* ParserOptions::matches() if any of this changes as needed
            // Options matching the defaults are not included in the
            // ParserCache key.  This is done to allow adding new parser
            // options without invalidating the entire ParserCache, as long
            // as those options are set to the default value specified here.
            // It also allows deliberately serving old data from the parser
            // cache when a default value is updated, which avoids the
            // performance hit of invalidating the entire cache at once, but
            // beware that changing the defaults here will *not* mean that
            // all entries fetched from the cache will have been generated
            // with the new default, at least until the current parser cache
            // expires.
            self::$defaults = [
                'dateformat' => null,
                'interfaceMessage' => false,
                'isMessage' => false,
                'targetLanguage' => null,
                'removeComments' => true,
                'suppressTOC' => false,
                'collapsibleSections' => false,
                'enableLimitReport' => false,
                'preSaveTransform' => true,
                'isPreview' => false,
                'isSectionPreview' => false,
                'printable' => false,
                'allowUnsafeRawHtml' => true,
                'wrapclass' => 'mw-parser-output',
                'currentRevisionRecordCallback' => self::getDefaultRevisionCallback(),
                'templateCallback' => self::getDefaultTemplateCallback(),
                'speculativeRevIdCallback' => null,
                'speculativeRevId' => null,
                'speculativePageIdCallback' => null,
                'speculativePageId' => null,
                'useParsoid' => false,
                'postproc' => false,
                // postproc options - if 'postproc' above is false, these are ignored
                'skin' => null,
                'allowTOC' => true,
                'injectTOC' => true,
                'includeDebugInfo' => true,
                'enableSectionEditLinks' => true,
                'wrapperDivClass' => 'mw-parser-output',
                'deduplicateStyles' => true,
                'unwrap' => false,
                'absoluteURLs' => false,
                'variant' => null,
            ];
 
            self::$cacheVaryingOptionsHash = self::$initialCacheVaryingOptionsHash;
            self::$lazyOptions = self::$initialLazyOptions;
 
            $hookRunner = new HookRunner( $services->getHookContainer() );
            $hookRunner->onParserOptionsRegister(
                self::$defaults,
                self::$cacheVaryingOptionsHash,
                self::$lazyOptions,
            );
            $hookRunner->onParserOptionsDefaults(
                self::$defaults,
                self::$cacheVaryingOptionsHash,
                self::$lazyOptions,
                self::$postprocOptions,
            );
 
            ksort( self::$cacheVaryingOptionsHash );
        }
 
        // Unit tests depend on being able to modify the globals at will
        $mainConfig = $services->getMainConfig();
        $interwikiMagic = $mainConfig->get( MainConfigNames::InterwikiMagic );
        $allowExternalImages = $mainConfig->get( MainConfigNames::AllowExternalImages );
        $allowExternalImagesFrom = $mainConfig->get( MainConfigNames::AllowExternalImagesFrom );
        $enableImageWhitelist = $mainConfig->get( MainConfigNames::EnableImageWhitelist );
        $allowSpecialInclusion = $mainConfig->get( MainConfigNames::AllowSpecialInclusion );
        $maxArticleSize = $mainConfig->get( MainConfigNames::MaxArticleSize );
        $maxPPNodeCount = $mainConfig->get( MainConfigNames::MaxPPNodeCount );
        $maxTemplateDepth = $mainConfig->get( MainConfigNames::MaxTemplateDepth );
        $maxPPExpandDepth = $mainConfig->get( MainConfigNames::MaxPPExpandDepth );
        $cleanSignatures = $mainConfig->get( MainConfigNames::CleanSignatures );
        $externalLinkTarget = $mainConfig->get( MainConfigNames::ExternalLinkTarget );
        $expensiveParserFunctionLimit = $mainConfig->get( MainConfigNames::ExpensiveParserFunctionLimit );
        $enableMagicLinks = $mainConfig->get( MainConfigNames::EnableMagicLinks );
        $languageConverterFactory = $services->getLanguageConverterFactory();
        $userOptionsLookup = $services->getUserOptionsLookup();
        $contentLanguage = $services->getContentLanguage();
        return self::$defaults + [
            'interwikiMagic' => $interwikiMagic,
            'allowExternalImages' => $allowExternalImages,
            'allowExternalImagesFrom' => $allowExternalImagesFrom,
            'enableImageWhitelist' => $enableImageWhitelist,
            'allowSpecialInclusion' => $allowSpecialInclusion,
            'maxIncludeSize' => $maxArticleSize * 1024,
            'maxPPNodeCount' => $maxPPNodeCount,
            'maxPPExpandDepth' => $maxPPExpandDepth,
            'maxTemplateDepth' => $maxTemplateDepth,
            'expensiveParserFunctionLimit' => $expensiveParserFunctionLimit,
            'externalLinkTarget' => $externalLinkTarget,
            'cleanSignatures' => $cleanSignatures,
            'disableContentConversion' => $languageConverterFactory->isConversionDisabled(),
            'disableTitleConversion' => $languageConverterFactory->isLinkConversionDisabled(),
            // FIXME: The fallback to false for enableMagicLinks is a band-aid to allow
            // the phpunit entrypoint patch (I82045c207738d152d5b0006f353637cfaa40bb66)
            // to be merged.
            // It is possible that a test somewhere is globally resetting $wgEnableMagicLinks
            // to null, or that ParserOptions is somehow similarly getting reset in such a way
            // that $enableMagicLinks ends up as null rather than an array. This workaround
            // seems harmless, but would be nice to eventually fix the underlying issue.
            'magicISBNLinks' => $enableMagicLinks['ISBN'] ?? false,
            'magicPMIDLinks' => $enableMagicLinks['PMID'] ?? false,
            'magicRFCLinks' => $enableMagicLinks['RFC'] ?? false,
            // FIXME: [[T417514]] this can be removed once we've shown users find
            // the CSS/JS thumbsize solution meets their needs.
            'thumbsize' => $userOptionsLookup->getDefaultOption( 'thumbsize' ),
            'userlang' => $contentLanguage,
        ];
    }
 
    private static function getDefaultTemplateCallback() {
        $services = MediaWikiServices::getInstance();
        $revisionLookup = $services->getRevisionLookup();
        $hookRunner = new HookRunner( $services->getHookContainer() );
        $linkCache = $services->getLinkCache();
        $shadowPageLoader = $services->getShadowPageLoader();
        return static fn ( $link, $parser ) => Parser::defaultFetchTemplate(
            $revisionLookup, $hookRunner, $linkCache, $shadowPageLoader, $link, $parser );
    }
 
    private static function getDefaultRevisionCallback() {
        $services = MediaWikiServices::getInstance();
        $revisionLookup = $services->getRevisionLookup();
        return static fn ( $link, $parser = null )
            => Parser::defaultFetchRevisionRecord( $revisionLookup, $link, $parser );
    }
 
    private function initialiseFromUser( UserIdentity $user, Language $lang ) {
        // Initially lazy loaded option defaults must not be taken into account,
        // otherwise lazy loading does not work. Setting a default for lazy option
        // is useful for matching with canonical options.
        $this->options = $this->nullifyLazyOption( self::getDefaults() );
 
        $this->mUser = $user;
        $services = MediaWikiServices::getInstance();
        $optionsLookup = $services->getUserOptionsLookup();
        $this->options['thumbsize'] = $optionsLookup->getDefaultOption( 'thumbsize' );
        $this->options['userlang'] = $lang;
    }
 
    public function matches( ParserOptions $other ) {
        // Compare most options
        $options = array_keys( $this->options );
        $options = array_diff( $options, [
            'enableLimitReport', // only affects HTML comments
            'tidy', // Has no effect since 1.35; removed in 1.36
        ] );
        foreach ( $options as $option ) {
            // Resolve any lazy options
            $this->lazyLoadOption( $option );
            $other->lazyLoadOption( $option );
 
            $o1 = $this->optionToString( $this->options[$option] );
            $o2 = $this->optionToString( $other->options[$option] );
            if ( $o1 !== $o2 ) {
                return false;
            }
        }
 
        // Compare most other fields
        foreach ( ( new ReflectionClass( $this ) )->getProperties() as $property ) {
            $field = $property->getName();
            if ( $property->isStatic() ) {
                continue;
            }
            if ( in_array( $field, [
                'options', // Already checked above
                'onAccessCallback', // only used for ParserOutput option tracking
            ] ) ) {
                continue;
            }
 
            if ( !is_object( $this->$field ) && $this->$field !== $other->$field ) {
                return false;
            }
        }
 
        return true;
    }
 
    public function matchesForCacheKey( ParserOptions $other ) {
        foreach ( self::allCacheVaryingOptions( $this->shouldIncludePostproc() ) as $option ) {
            // Populate any lazy options
            $this->lazyLoadOption( $option );
            $other->lazyLoadOption( $option );
 
            $o1 = $this->optionToString( $this->options[$option] );
            $o2 = $this->optionToString( $other->options[$option] );
            if ( $o1 !== $o2 ) {
                return false;
            }
        }
 
        return true;
    }
 
    public function registerWatcher( $callback ) {
        $oldCallback = $this->onAccessCallback;
        $this->onAccessCallback = $callback;
        return $oldCallback;
    }
 
    private function optionUsed( $optionName ) {
        if ( $this->onAccessCallback ) {
            ( $this->onAccessCallback )( $optionName );
        }
    }
 
    public static function allCacheVaryingOptions( bool $includePostproc = false ) {
        $result = array_keys( array_filter( self::getCacheVaryingOptionsHash() ) );
        if ( !$includePostproc ) {
            $result = array_diff( $result, self::$postprocOptions );
        }
        return $result;
    }
 
    public function allCacheVaryingOptionsWithPostproc() {
        return self::allCacheVaryingOptions( $this->shouldIncludePostproc() );
    }
 
    private function optionToString( $value ) {
        if ( $value === true ) {
            return '1';
        } elseif ( $value === false ) {
            return '0';
        } elseif ( $value === null ) {
            return '';
        } elseif ( $value instanceof Language ) {
            return $value->getCode();
        } elseif ( $value instanceof Skin ) {
            return $value->getSkinName();
        } elseif ( is_array( $value ) ) {
            return '[' . implode( ',', array_map( $this->optionToString( ... ), $value ) ) . ']';
        } elseif ( $value instanceof \Closure ) {
            return (string)new \ReflectionFunction( $value );
        } elseif ( $value instanceof BackedEnum ) {
            return $value->value;
        } elseif ( $value instanceof UnitEnum ) {
            return $value->name;
        } else {
            return (string)$value;
        }
    }
 
    public function optionsHash( $forOptions, $title = null ) {
        $renderHashAppend = MediaWikiServices::getInstance()->getMainConfig()->get( MainConfigNames::RenderHashAppend );
 
        $inCacheKey = self::allCacheVaryingOptions( $this->shouldIncludePostproc() );
 
        // Resolve any lazy options
        $lazyOpts = array_intersect( $forOptions,
            $inCacheKey, array_keys( self::getLazyOptions() ) );
        foreach ( $lazyOpts as $k ) {
            $this->lazyLoadOption( $k );
        }
 
        $options = $this->options;
        $defaults = self::getDefaults();
 
        // We only include used options with non-canonical values in the key
        // so adding a new option doesn't invalidate the entire parser cache.
        // The drawback to this is that changing the default value of an option
        // requires manual invalidation of existing cache entries, as mentioned
        // in the docs on the relevant methods and hooks.
        $values = [];
        foreach ( array_intersect( $inCacheKey, $forOptions ) as $option ) {
            $v = $this->optionToString( $options[$option] );
            $d = $this->optionToString( $defaults[$option] );
            if ( $v !== $d ) {
                $values[] = "$option=$v";
            }
        }
 
        $confstr = $values ? implode( '!', $values ) : 'canonical';
 
        // The legacy parser used a backdoor means of associating a language
        // variant with the parse (and thus with the cache key).  For Parsoid
        // variant is just an "ordinary" postprocessing option, and the
        // backdoor method isn't needed.
        $services = MediaWikiServices::getInstance();
        if ( !$this->options['useParsoid'] ) {
            // Legacy Parser: add in language specific options, if any
            // @todo FIXME: This is just a way of retrieving the url/user preferred variant
            $lang = $title ? $title->getPageLanguage() : $services->getContentLanguage();
            $converter = $services->getLanguageConverterFactory()->getLanguageConverter( $lang );
            $confstr .= $converter->getExtraHashOptions();
        }
 
        $confstr .= $renderHashAppend;
 
        if ( $this->mExtraKey != '' ) {
            $confstr .= $this->mExtraKey;
        }
 
        $user = $services->getUserFactory()->newFromUserIdentity( $this->getUserIdentity() );
        // Give a chance for extensions to modify the hash, if they have
        // extra options or other effects on the parser cache.
        ( new HookRunner( $services->getHookContainer() ) )->onPageRenderingHash(
            $confstr,
            $user,
            $forOptions
        );
 
        // Make it a valid memcached key fragment
        $confstr = str_replace( ' ', '_', $confstr );
 
        return $confstr;
    }
 
    public function isSafeToCache( ?array $usedOptions = null ) {
        $defaults = self::getDefaults();
        $inCacheKey = self::getCacheVaryingOptionsHash();
        $usedOptions ??= array_keys( $this->options );
        $config = MediaWikiServices::getInstance()->getMainConfig();
        if ( $this->getUseParsoid() ) {
            $usePostprocCache =
                $config->get( MainConfigNames::UsePostprocCacheParsoid );
        } else {
            $usePostprocCache =
                $config->get( MainConfigNames::UsePostprocCacheLegacy );
        }
        if ( !$usePostprocCache && $this->shouldIncludePostproc() ) {
            return false;
        }
 
        $shouldSample = false;
        $logger = null;
        if ( !$this->shouldIncludePostproc() ) {
            $usedOptions = array_diff( $usedOptions, self::$postprocOptions );
        } else {
            $shouldSample = true;
        }
 
        $safe = true;
        foreach ( $usedOptions as $option ) {
            if ( empty( $inCacheKey[$option] ) && empty( self::$callbacks[$option] ) ) {
                $v = $this->optionToString( $this->options[$option] ?? null );
                $d = $this->optionToString( $defaults[$option] ?? null );
                if ( $v !== $d ) {
                    if ( $shouldSample && $logger === null ) {
                        $sampleRate = MediaWikiServices::getInstance()->getMainConfig()->get(
                            MainConfigNames::ParserOptionsLogUnsafeSampleRate
                        );
                        if ( $sampleRate && mt_rand( 1, $sampleRate ) === 1 ) {
                            $logger = LoggerFactory::getInstance( 'ParserOptions' );
                        } else {
                            $shouldSample = false;
                        }
                    }
                    if ( $logger ) {
                        // if we're logging, let's not stop at the first problem (which has a high chance of
                        // always being the same?) but let's gather some more data instead
                        $logger->debug(
                            __METHOD__ . ': Unsafe option {parseroption_name}; safe would be' .
                                '{default_parseroption_value}, got {actual_parseroption_value}',
                            [
                                'parseroption_name' => $option,
                                'default_parseroption_value' => $d,
                                'actual_parseroption_value' => $v
                            ]
                        );
                        $safe = false;
                    } else {
                        // if we're not logging, we can stop here, no need to continue
                        return false;
                    }
                }
            }
        }
        return $safe;
    }
 
    #[\NoDiscard]
    public function setupFakeRevision( $page, $content, $user, $currentRevId = 0 ): ScopedCallback {
        $oldCallback = $this->setCurrentRevisionRecordCallback(
            function ( $titleToCheck, $parser = null )
            use ( $page, $content, $user, $currentRevId, &$oldCallback )
            {
                if ( $titleToCheck->isSamePageAs( $page ) ) {
                    if ( $page->exists() ) {
                        $pageId = $page->getId();
 
                        if ( $currentRevId ) {
                            $parentRevision = $currentRevId;
                        } elseif ( $page instanceof Title ) {
                            $parentRevision = $page->getLatestRevID();
                        } elseif ( $page instanceof PageRecord ) {
                            $parentRevision = $page->getLatest();
                        } else {
                            $parentRevision = 0;
                        }
                    } else {
                        $pageId = $this->getSpeculativePageId() ?: 0;
                        $parentRevision = 0;
                        $page = new PageIdentityValue(
                            $pageId,
                            $page->getNamespace(),
                            $page->getDBkey(),
                            $page->getWikiId()
                        );
                    }
 
                    $revRecord = MutableRevisionRecord::newFromContent( $page, $content )
                        ->setUser( $user )
                        ->setTimestamp( MWTimestamp::now( TS::MW ) )
                        ->setId( 0 )
                        ->setPageId( $pageId )
                        ->setParentId( $parentRevision );
                    return $revRecord;
                } else {
                    return $oldCallback( $titleToCheck, $parser );
                }
            }
        );
 
        $hookContainer = MediaWikiServices::getInstance()->getHookContainer();
        $hookScope = $hookContainer->scopedRegister(
            'TitleExists',
            static function ( Title $titleToCheck, &$exists ) use ( $page ) {
                if ( $titleToCheck->isSamePageAs( $page ) ) {
                    $exists = true;
                }
            }
        );
 
        $linkCache = MediaWikiServices::getInstance()->getLinkCache();
        $linkCache->clearBadLink( $page );
 
        return new ScopedCallback( function () use ( $page, $hookScope, $linkCache, $oldCallback ) {
            ScopedCallback::consume( $hookScope );
            $linkCache->clearLink( $page );
            $this->setCurrentRevisionRecordCallback( $oldCallback );
        } );
    }
 
    public function getRenderReason(): string {
        return $this->renderReason;
    }
 
    public function setRenderReason( string $renderReason ): void {
        $this->renderReason = $renderReason;
    }
 
    public function getPostproc(): bool {
        return $this->getOption( 'postproc' );
    }
 
    public function enablePostproc(): void {
        $this->setOption( 'postproc', true );
        // make the option part of the used options, explicitly
        $this->getOption( 'postproc' );
    }
 
    private function shouldIncludePostproc(): bool {
        return $this->options[ 'postproc' ];
    }
 
    public function clearPostproc(): ParserOptions {
        $res = clone $this;
        $res->setOption( 'postproc', false );
        return $res;
    }
}
 
class_alias( ParserOptions::class, 'ParserOptions' );