Message.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Message;
 
use InvalidArgumentException;
use MediaWiki\Content\Content;
use MediaWiki\Context\IContextSource;
use MediaWiki\Context\RequestContext;
use MediaWiki\HookContainer\ProtectedHookAccessorTrait;
use MediaWiki\Language\Language;
use MediaWiki\Language\MessageInfo;
use MediaWiki\Language\RawMessage;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\PageReference;
use MediaWiki\Page\PageReferenceValue;
use MediaWiki\Parser\Parser;
use MediaWiki\Parser\ParserOutput;
use MediaWiki\Parser\Sanitizer;
use MediaWiki\StubObject\StubUserLang;
use MediaWiki\Title\Title;
use RuntimeException;
use Serializable;
use Stringable;
use Wikimedia\Assert\Assert;
use Wikimedia\Bcp47Code\Bcp47Code;
use Wikimedia\Message\ListParam;
use Wikimedia\Message\ListType;
use Wikimedia\Message\MessageParam;
use Wikimedia\Message\MessageSpecifier;
use Wikimedia\Message\ParamType;
use Wikimedia\Message\ScalarParam;
 
class Message implements Stringable, MessageSpecifier, Serializable {
    use ProtectedHookAccessorTrait;
 
    public const FORMAT_PLAIN = 'plain';
    public const FORMAT_BLOCK_PARSE = 'block-parse';
    public const FORMAT_PARSE = 'parse';
    public const FORMAT_TEXT = 'text';
    public const FORMAT_ESCAPED = 'escaped';
 
    protected $isInterface = true;
 
    protected $language = null;
 
    protected $userLangCallback;
 
    protected $fetchedLangCode;
 
    protected $key;
 
    protected $keysToTry;
 
    protected $overriddenKey = null;
 
    protected $parameters = [];
 
    protected $useDatabase = true;
 
    protected $contextPage = null;
 
    protected $content = null;
 
    protected $message;
 
    public function __construct( $key, $params = [], ?Language $language = null ) {
        if ( $key instanceof MessageSpecifier ) {
            if ( $params ) {
                throw new InvalidArgumentException(
                    'Cannot set $params when $key is a MessageSpecifier'
                );
            }
            $params = $key->getParams();
            $key = $key->getKey();
        }
 
        if ( is_string( $key ) ) {
            $this->keysToTry = [ $key ];
            $this->key = $key;
        } elseif ( is_array( $key ) && $key ) {
            $this->keysToTry = $key;
            foreach ( $this->keysToTry as $key ) {
                if ( !is_string( $key ) ) {
                    throw new InvalidArgumentException( 'Message keys must be strings. ' .
                        'Did you accidentally pass message key and parameters in one array?' );
                }
            }
            $this->key = reset( $this->keysToTry );
        } else {
            throw new InvalidArgumentException( '$key must be a string or non-empty array' );
        }
 
        $this->params( ...$params );
        // User language is only resolved in getLanguage(). This helps preserve the
        // semantic intent of "user language" across serialize() and unserialize().
        $this->language = $language;
    }
 
    public function serialize(): string {
        return serialize( $this->__serialize() );
    }
 
    public function __serialize() {
        return [
            'interface' => $this->isInterface,
            'language' => $this->language instanceof Language ? $this->language->getCode() : $this->language,
            'key' => $this->key,
            'keysToTry' => $this->keysToTry,
            'parameters' => $this->parameters,
            'useDatabase' => $this->useDatabase,
            // Optimisation: Avoid cost of TitleFormatter on serialize,
            // and especially cost of TitleParser on retrieval.
            'titlevalue' => $this->contextPage
                ? [ $this->contextPage->getNamespace(), $this->contextPage->getDBkey() ]
                : null,
        ];
    }
 
    public function unserialize( $serialized ): void {
        $this->__unserialize( unserialize( $serialized ) );
    }
 
    public function __unserialize( $data ) {
        if ( !is_array( $data ) ) {
            throw new InvalidArgumentException( __METHOD__ . ': Invalid serialized data' );
        }
        $this->isInterface = $data['interface'];
        $this->key = $data['key'];
        $this->keysToTry = $data['keysToTry'];
        // Accept old serialization format for compatibility with pre-MessageParam stored values
        $this->parameters = array_map( static function ( $param ) {
            if ( is_array( $param ) ) {
                if ( isset( $param['type'] ) ) {
                    return ListParam::newFromJsonArray( $param );
                } else {
                    return ScalarParam::newFromJsonArray( $param );
                }
            } else {
                return $param;
            }
        }, $data['parameters'] );
        $this->useDatabase = $data['useDatabase'];
        // Until MW 1.39, we used 'false' instead of 'null' to indicate the user language (Idbe21afcea)
        $this->language = $data['language'] ?: null;
 
        // Since 1.35, the key 'titlevalue' is set, instead of 'titlestr'.
        if ( isset( $data['titlevalue'] ) ) {
            $this->contextPage = PageReferenceValue::localReference(
                $data['titlevalue'][0],
                $data['titlevalue'][1]
            );
        } elseif ( isset( $data['titlestr'] ) ) {
            $titleParser = MediaWikiServices::getInstance()->getTitleParser();
            $title = $titleParser->parseTitle( $data['titlestr'] );
            // The title should not have any fragment or interwiki parts
            $this->contextPage = PageReferenceValue::localReference(
                $title->getNamespace(),
                $title->getDBkey()
            );
        } else {
            $this->contextPage = null;
        }
    }
 
    public function isMultiKey() {
        return count( $this->keysToTry ) > 1;
    }
 
    public function getKeysToTry() {
        return $this->keysToTry;
    }
 
    public function getKey(): string {
        return $this->key;
    }
 
    public function getParams(): array {
        return $this->parameters;
    }
 
    public function getLanguage(): Language {
        // Defaults to null which means current user language
        if ( $this->language !== null ) {
            return MediaWikiServices::getInstance()->getLanguageFactory()->getLanguage( $this->language );
        } elseif ( $this->userLangCallback ) {
            return ( $this->userLangCallback )();
        } else {
            return RequestContext::getMain()->getLanguage();
        }
    }
 
    public function getLanguageCode(): string {
        if ( $this->language instanceof Language ) {
            return $this->language->getCode();
        } elseif ( is_string( $this->language ) ) {
            return $this->language;
        } elseif ( $this->userLangCallback ) {
            return ( $this->userLangCallback )()->getCode();
        } else {
            return RequestContext::getMain()->getLanguage()->getCode();
        }
    }
 
    protected function getFetchedLanguage(): Language {
        if ( $this->fetchedLangCode ) {
            return MediaWikiServices::getInstance()->getLanguageFactory()
                ->getLanguage( $this->fetchedLangCode );
        } else {
            return $this->getLanguage();
        }
    }
 
    public static function newFromKey( $key, ...$params ) {
        return new self( $key, $params );
    }
 
    public static function newFromSpecifier( $value ) {
        $params = [];
        if ( is_array( $value ) ) {
            $params = $value;
            $value = array_shift( $params );
        }
 
        if ( $value instanceof Message ) { // Message, RawMessage, ApiMessage, etc
            if ( $params ) {
                throw new InvalidArgumentException(
                    'Cannot have parameters when the key is already a Message instance'
                );
            }
            $message = clone $value;
        } elseif ( $value instanceof MessageSpecifier ) {
            if ( $params ) {
                throw new InvalidArgumentException(
                    'Cannot have parameters when the key is already a MessageSpecifier instance'
                );
            }
            $message = new Message( $value );
        } elseif ( is_string( $value ) ) {
            $message = new Message( $value, $params );
        } else {
            throw new InvalidArgumentException( 'Invalid argument type ' . get_debug_type( $value ) );
        }
 
        return $message;
    }
 
    public static function newFallbackSequence( ...$keys ) {
        if ( func_num_args() == 1 ) {
            if ( is_array( $keys[0] ) ) {
                // Allow an array to be passed as the first argument instead
                $keys = array_values( $keys[0] );
            } else {
                // Optimize a single string to not need special fallback handling
                $keys = $keys[0];
            }
        }
        return new self( $keys );
    }
 
    public function getTitle() {
        $forceUIMsgAsContentMsg = MediaWikiServices::getInstance()->getMainConfig()->get(
            MainConfigNames::ForceUIMsgAsContentMsg );
 
        $contLang = MediaWikiServices::getInstance()->getContentLanguage();
        $langCode = $this->getLanguageCode();
        $title = $this->key;
        if (
            $langCode !== $contLang->getCode()
            && in_array( $this->key, (array)$forceUIMsgAsContentMsg )
        ) {
            $title .= '/' . $langCode;
        }
 
        // Don't use $contLang->ucfirst() here. See T362654
        return Title::makeTitle( NS_MEDIAWIKI, ucfirst( $title ) );
    }
 
    public function params( ...$params ) {
        if ( count( $params ) === 1 && isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            if ( $param instanceof ScalarParam && $param->getType() === ParamType::TEXT ) {
                // Unwrap for compatibility with legacy code that inspects the parameters
                $param = $param->getValue();
            }
            if ( $param instanceof MessageSpecifier ) {
                $param = static::newFromSpecifier( $param );
            }
            $this->parameters[] = $param;
        }
        return $this;
    }
 
    public function rawParams( ...$params ) {
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::rawParam( $param );
        }
        return $this;
    }
 
    public function numParams( ...$params ) {
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::numParam( $param );
        }
        return $this;
    }
 
    public function durationParams( ...$params ) {
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::durationParam( $param );
        }
        return $this;
    }
 
    public function expiryParams( ...$params ) {
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::expiryParam( $param );
        }
        return $this;
    }
 
    public function dateTimeParams( ...$params ) {
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::dateTimeParam( $param );
        }
        return $this;
    }
 
    public function dateParams( ...$params ) {
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::dateParam( $param );
        }
        return $this;
    }
 
    public function userGroupParams( ...$params ) {
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::userGroupParam( $param );
        }
        return $this;
    }
 
    public function timeParams( ...$params ) {
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::timeParam( $param );
        }
        return $this;
    }
 
    public function timeperiodParams( ...$params ) {
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::timeperiodParam( $param );
        }
        return $this;
    }
 
    public function sizeParams( ...$params ) {
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::sizeParam( $param );
        }
        return $this;
    }
 
    public function bitrateParams( ...$params ) {
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::bitrateParam( $param );
        }
        return $this;
    }
 
    public function plaintextParams( ...$params ) {
        if ( isset( $params[0] ) && is_array( $params[0] ) ) {
            $params = $params[0];
        }
        foreach ( $params as $param ) {
            $this->parameters[] = self::plaintextParam( $param );
        }
        return $this;
    }
 
    public function setContext( IContextSource $context ) {
        $this->userLangCallback = static function () use ( $context ) {
            return $context->getLanguage();
        };
        $this->inUserLanguage();
        $this->page( $context->getTitle() );
 
        return $this;
    }
 
    public function inLanguage( $lang ) {
        $previousLanguage = $this->language;
 
        if ( $lang instanceof Language ) {
            $this->language = $lang;
        } elseif ( $lang instanceof StubUserLang ) {
            $this->language = null;
        } elseif ( $lang instanceof Bcp47Code ) {
            if ( !( $this->language instanceof Language && $this->language->isSameCodeAs( $lang ) ) ) {
                $this->language = MediaWikiServices::getInstance()->getLanguageFactory()
                    ->getLanguage( $lang );
            }
        } elseif ( is_string( $lang ) ) {
            if ( !( $this->language instanceof Language && $this->language->getCode() === $lang ) ) {
                $this->language = MediaWikiServices::getInstance()->getLanguageFactory()
                    ->getLanguageCode( $lang )->toString();
            }
        } else {
            // Always throws. Moved here as an optimization.
            Assert::parameterType( [ Bcp47Code::class, StubUserLang::class, 'string' ], $lang, '$lang' );
        }
 
        if ( $this->language !== $previousLanguage ) {
            // The language has changed. Clear the message cache.
            $this->message = null;
        }
        $this->isInterface = false;
        return $this;
    }
 
    public function inUserLanguage(): self {
        if ( $this->language ) {
            // The language has changed. Clear the message cache.
            $this->message = null;
        }
        $this->language = null;
        $this->isInterface = true;
        return $this;
    }
 
    public function inContentLanguage(): self {
        $forceUIMsgAsContentMsg = MediaWikiServices::getInstance()->getMainConfig()->get(
            MainConfigNames::ForceUIMsgAsContentMsg );
        if ( in_array( $this->key, (array)$forceUIMsgAsContentMsg ) ) {
            return $this;
        }
 
        $this->inLanguage( MediaWikiServices::getInstance()->getContentLanguage() );
        return $this;
    }
 
    public function setInterfaceMessageFlag( $interface ) {
        $this->isInterface = (bool)$interface;
        return $this;
    }
 
    public function useDatabase( $useDatabase ) {
        $this->useDatabase = (bool)$useDatabase;
        $this->message = null;
        return $this;
    }
 
    public function title( $title ) {
        return $this->page( $title );
    }
 
    public function page( ?PageReference $page ) {
        $this->contextPage = $page;
        return $this;
    }
 
    public function toString( string $format ): string {
        return $this->format( $format );
    }
 
    private function format( string $format ): string {
        $string = $this->fetchMessage();
 
        if ( $string === false ) {
            // Err on the side of safety, ensure that the output
            // is always html safe in the event the message key is
            // missing, since in that case its highly likely the
            // message key is user-controlled.
            // '⧼' is used instead of '<' to side-step any
            // double-escaping issues.
            // (Keep synchronised with mw.Message#toString in JS.)
            return '⧼' . Sanitizer::escapeCombiningChar( htmlspecialchars( $this->key ) ) . '⧽';
        }
 
        if ( in_array( $this->getLanguageCode(), [ 'qqx', 'x-xss' ] ) ) {
            # Insert a list of alternative message keys for &uselang=qqx.
            if ( $string === '($*)' ) {
                $keylist = implode( ' / ', $this->keysToTry );
                if ( $this->overriddenKey !== null ) {
                    $keylist .= ' = ' . $this->overriddenKey;
                }
                $string = "($keylist$*)";
            }
            # Replace $* with a list of parameters for &uselang=qqx.
            if ( str_contains( $string, '$*' ) ) {
                $paramlist = '';
                if ( $this->parameters !== [] ) {
                    $paramlist = ': $' . implode( ', $', range( 1, count( $this->parameters ) ) );
                }
                $string = str_replace( '$*', $paramlist, $string );
            }
        }
 
        # Replace parameters before text parsing
        $string = $this->replaceParameters( $string, 'before', $format );
 
        # Maybe transform using the full parser
        if ( $format === self::FORMAT_PARSE ) {
            $po = $this->parseText( $string );
            $string = Parser::stripOuterParagraph( $po->getContentHolderText() );
        } elseif ( $format === self::FORMAT_BLOCK_PARSE ) {
            $po = $this->parseText( $string );
            $string = $po->getContentHolderText();
        } elseif ( $format === self::FORMAT_TEXT ) {
            $string = $this->transformText( $string );
        } elseif ( $format === self::FORMAT_ESCAPED ) {
            $string = $this->transformText( $string );
            $string = htmlspecialchars( $string, ENT_QUOTES, 'UTF-8', false );
            $string = Sanitizer::escapeCombiningChar( $string );
        }
 
        # Raw parameter replacement
        $string = $this->replaceParameters( $string, 'after', $format );
 
        // XXX: Sometimes messages are created prior to MediaWikiServices being
        // constructed which causes problems when we try to run the hook.
        // Skip the hook for very early calls.
        if ( MediaWikiServices::hasInstance() ) {
            if ( $format === self::FORMAT_TEXT || $format === self::FORMAT_PLAIN ) {
                $this->getHookRunner()->onMessagePostProcessText( $string, $format, $this->key );
            } else {
                $this->getHookRunner()->onMessagePostProcessHtml( $string, $format, $this->key );
            }
        }
        return $string;
    }
 
    public function __toString() {
        return $this->format( self::FORMAT_PARSE );
    }
 
    public function parse() {
        return $this->format( self::FORMAT_PARSE );
    }
 
    public function text() {
        return $this->format( self::FORMAT_TEXT );
    }
 
    public function plain() {
        return $this->format( self::FORMAT_PLAIN );
    }
 
    public function parseAsBlock() {
        return $this->format( self::FORMAT_BLOCK_PARSE );
    }
 
    public function escaped() {
        return $this->format( self::FORMAT_ESCAPED );
    }
 
    public function exists() {
        return $this->fetchMessage() !== false;
    }
 
    public function isBlank() {
        $message = $this->fetchMessage();
        return $message === false || $message === '';
    }
 
    public function isDisabled() {
        $message = $this->fetchMessage();
        return $message === false || $message === '' || $message === '-';
    }
 
    public static function rawParam( $raw ): ScalarParam {
        return new ScalarParam( ParamType::RAW, $raw );
    }
 
    public static function numParam( $num ): ScalarParam {
        return new ScalarParam( ParamType::NUM, $num );
    }
 
    public static function durationParam( $duration ): ScalarParam {
        return new ScalarParam( ParamType::DURATION_LONG, $duration );
    }
 
    public static function expiryParam( $expiry ): ScalarParam {
        return new ScalarParam( ParamType::EXPIRY, $expiry );
    }
 
    public static function dateTimeParam( string $dateTime ): ScalarParam {
        return new ScalarParam( ParamType::DATETIME, $dateTime );
    }
 
    public static function dateParam( string $date ): ScalarParam {
        return new ScalarParam( ParamType::DATE, $date );
    }
 
    public static function timeParam( string $time ): ScalarParam {
        return new ScalarParam( ParamType::TIME, $time );
    }
 
    public static function userGroupParam( string $userGroup ): ScalarParam {
        return new ScalarParam( ParamType::GROUP, $userGroup );
    }
 
    public static function timeperiodParam( $period ): ScalarParam {
        return new ScalarParam( ParamType::DURATION_SHORT, $period );
    }
 
    public static function sizeParam( $size ): ScalarParam {
        return new ScalarParam( ParamType::SIZE, $size );
    }
 
    public static function bitrateParam( $bitrate ): ScalarParam {
        return new ScalarParam( ParamType::BITRATE, $bitrate );
    }
 
    public static function plaintextParam( $plaintext ): ScalarParam {
        return new ScalarParam( ParamType::PLAINTEXT, $plaintext );
    }
 
    public static function listParam( array $list, $type = ListType::AND ): ListParam {
        if ( is_string( $type ) ) {
            wfDeprecated( __METHOD__ . ' with string type', '1.45' );
            $type = ListType::from( $type );
        }
        return new ListParam( $type, $list );
    }
 
    protected function replaceParameters( $message, $type, $format ) {
        // A temporary marker for $1 parameters that is only valid
        // in non-attribute contexts. However if the entire message is escaped
        // then we don't want to use it because it will be mangled in all contexts
        // and its unnecessary as ->escaped() messages aren't html.
        $marker = $format === self::FORMAT_ESCAPED ? '$' : '$\'"';
        $replacementKeys = [];
        foreach ( $this->parameters as $n => $param ) {
            [ $paramType, $value ] = $this->extractParam( $param, $format );
            if ( $type === 'before' ) {
                if ( $paramType === 'before' ) {
                    $replacementKeys['$' . ( $n + 1 )] = $value;
                } else /* $paramType === 'after' */ {
                    // To protect against XSS from replacing parameters
                    // inside html attributes, we convert $1 to $'"1.
                    // In the event that one of the parameters ends up
                    // in an attribute, either the ' or the " will be
                    // escaped, breaking the replacement and avoiding XSS.
                    $replacementKeys['$' . ( $n + 1 )] = $marker . ( $n + 1 );
                }
            } elseif ( $paramType === 'after' ) {
                $replacementKeys[$marker . ( $n + 1 )] = $value;
            }
        }
        return strtr( $message, $replacementKeys );
    }
 
    protected function extractParam( $param, $format ) {
        if ( $param instanceof ScalarParam ) {
            return match ( $param->getType() ) {
                ParamType::RAW =>
                    [ 'after', $this->extractParam( $param->getValue(), self::FORMAT_PARSE )[1] ],
                ParamType::NUM =>
                    // Replace number params always in before step for now.
                    // No support for combined raw and num params
                    [ 'before', $this->getLanguage()->formatNum( $param->getValue() ) ],
                ParamType::DURATION_LONG =>
                    [ 'before', $this->getLanguage()->formatDuration( $param->getValue() ) ],
                ParamType::EXPIRY =>
                    [ 'before', $this->getLanguage()->formatExpiry( $param->getValue() ) ],
                ParamType::DATETIME =>
                    [ 'before', $this->getLanguage()->timeanddate( $param->getValue() ) ],
                ParamType::DATE =>
                    [ 'before', $this->getLanguage()->date( $param->getValue() ) ],
                ParamType::TIME =>
                    [ 'before', $this->getLanguage()->time( $param->getValue() ) ],
                ParamType::GROUP =>
                    [ 'before', $this->getLanguage()->getGroupName( $param->getValue() ) ],
                ParamType::DURATION_SHORT =>
                    [ 'before', $this->getLanguage()->formatTimePeriod( $param->getValue() ) ],
                ParamType::SIZE =>
                    [ 'before', $this->getLanguage()->formatSize( $param->getValue() ) ],
                ParamType::BITRATE =>
                    [ 'before', $this->getLanguage()->formatBitrate( $param->getValue() ) ],
                ParamType::PLAINTEXT =>
                    [ 'after', $this->formatPlaintext( $param->getValue(), $format ) ],
                // ParamType::TEXT is impossible because we unwrapped it in params()
                default =>
                    throw new \LogicException( "Invalid ScalarParam type: {$param->getType()->value}" ),
            };
        } elseif ( $param instanceof ListParam ) {
            return $this->formatListParam( $param->getValue(), $param->getListType(), $format );
        } elseif ( is_array( $param ) ) {
            LoggerFactory::getInstance( 'Bug58676' )->warning(
                'Invalid parameter for message "{msgkey}": {param}',
                [
                    'exception' => new RuntimeException,
                    'msgkey' => $this->key,
                    'param' => htmlspecialchars( serialize( $param ) ),
                ]
            );
            return [ 'before', '[INVALID]' ];
        } elseif ( $param instanceof MessageSpecifier ) {
            // Match language, flags, etc. to the current message.
            $msg = static::newFromSpecifier( $param );
            if ( $msg->language !== $this->language || $msg->useDatabase !== $this->useDatabase ) {
                // Cache depends on these parameters
                $msg->message = null;
            }
            $msg->isInterface = $this->isInterface;
            $msg->language = $this->language;
            $msg->useDatabase = $this->useDatabase;
            $msg->contextPage = $this->contextPage;
 
            // DWIM
            if ( $format === 'block-parse' ) {
                $format = 'parse';
            }
 
            // Message objects should not be before parameters because
            // then they'll get double escaped. If the message needs to be
            // escaped, it'll happen right here when we call toString().
            // (Using the public toString() to allow mocking / subclassing.)
            return [ 'after', $msg->toString( $format ) ];
        } else {
            return [ 'before', $param ];
        }
    }
 
    protected function parseText( string $string ): ParserOutput {
        $out = MediaWikiServices::getInstance()->getMessageParser()->parse(
            $string,
            $this->contextPage ?? PageReferenceValue::localReference( NS_SPECIAL, 'Badtitle/Message' ),
            /*linestart*/ true,
            $this->isInterface,
            $this->getFetchedLanguage()
        );
 
        return $out;
    }
 
    protected function transformText( $string ) {
        return MediaWikiServices::getInstance()->getMessageParser()->transform(
            $string,
            $this->isInterface,
            $this->getFetchedLanguage(),
            $this->contextPage
        );
    }
 
    protected function fetchMessage() {
        if ( $this->message === null ) {
            $cache = MediaWikiServices::getInstance()->getMessageCache();
 
            $info = new MessageInfo;
            $langCode = $this->getLanguageCode();
            foreach ( $this->keysToTry as $key ) {
                $message = $cache->get( $key, $this->useDatabase, $this->getLanguageCode(), $info );
                if ( $message !== false && $message !== '' ) {
                    if ( $info->usedKey && $info->usedKey !== $key ) {
                        $this->overriddenKey = $info->usedKey;
                    }
                    if ( $info->langCode && $info->langCode !== $langCode ) {
                        $this->fetchedLangCode = $info->langCode;
                    }
                    break;
                }
            }
 
            // NOTE: The constructor makes sure keysToTry isn't empty,
            //       so we know that $key and $message are initialized.
            // @phan-suppress-next-next-line PhanPossiblyUndeclaredVariable False positive
            // @phan-suppress-next-line PhanPossiblyNullTypeMismatchProperty False positive
            $this->key = $key;
            // @phan-suppress-next-line PhanPossiblyUndeclaredVariable False positive
            $this->message = $message;
        }
        return $this->message;
    }
 
    protected function formatPlaintext( $plaintext, $format ) {
        switch ( $format ) {
            case self::FORMAT_TEXT:
            case self::FORMAT_PLAIN:
                return $plaintext;
 
            case self::FORMAT_PARSE:
            case self::FORMAT_BLOCK_PARSE:
            case self::FORMAT_ESCAPED:
            default:
                return Sanitizer::escapeCombiningChar( htmlspecialchars( $plaintext, ENT_QUOTES ) );
        }
    }
 
    protected static function listTypeMap( Language $lang, ListType $listType ): callable {
        return match ( $listType ) {
            ListType::COMMA => $lang->commaList( ... ),
            ListType::SEMICOLON => $lang->semicolonList( ... ),
            ListType::PIPE => $lang->pipeList( ... ),
            ListType::AND => $lang->listToText( ... ),
        };
    }
 
    protected function formatListParam( array $params, $listType, $format ) {
        if ( is_string( $listType ) ) {
            $originalListType = $listType;
            $listType = ListType::tryFrom( $listType );
            if ( $listType === null ) {
                $warning = 'Invalid list type for message "' . $this->key . '": '
                    . htmlspecialchars( $originalListType )
                    . ' (params are ' . htmlspecialchars( serialize( $params ) ) . ')';
                trigger_error( $warning, E_USER_WARNING );
                $e = new InvalidArgumentException;
                wfDebugLog( 'Bug58676', $warning . "\n" . $e->getTraceAsString() );
                return [ 'before', '[INVALID]' ];
            }
        }
        $func = self::listTypeMap( $this->getLanguage(), $listType );
 
        // Handle an empty list sensibly
        if ( !$params ) {
            return [ 'before', $func( [] ) ];
        }
 
        // First, determine what kinds of list items we have
        $types = [];
        $vars = [];
        $list = [];
        foreach ( $params as $n => $p ) {
            if ( $p instanceof ScalarParam && $p->getType() === ParamType::TEXT ) {
                // Unwrap like in params()
                $p = $p->getValue();
            }
            [ $type, $value ] = $this->extractParam( $p, $format );
            $types[$type] = true;
            $list[] = $value;
            $vars[] = '$' . ( $n + 1 );
        }
 
        // Easy case: all are 'before' or 'after', so just join the
        // values and use the same type.
        if ( count( $types ) === 1 ) {
            return [ key( $types ), $func( $list ) ];
        }
 
        // Hard case: We need to process each value per its type, then
        // return the concatenated values as 'after'. We handle this by turning
        // the list into a RawMessage and processing that as a parameter.
        $vars = $func( $vars );
        return $this->extractParam( new RawMessage( $vars, $params ), $format );
    }
}
 
class_alias( Message::class, 'Message' );