function ConstExprParser::parse

1 call to ConstExprParser::parse()

ConstExprParser::parseArrayItem in vendor/phpstan/phpdoc-parser/src/Parser/ConstExprParser.php

File

vendor/phpstan/phpdoc-parser/src/Parser/ConstExprParser.php, line 62

Class

ConstExprParser

Namespace

PHPStan\PhpDocParser\Parser

Code

public function parse(TokenIterator $tokens, bool $trimStrings = false) : Ast\ConstExpr\ConstExprNode {
    $startLine = $tokens->currentTokenLine();
    $startIndex = $tokens->currentTokenIndex();
    if ($tokens->isCurrentTokenType(Lexer::TOKEN_FLOAT)) {
        $value = $tokens->currentTokenValue();
        $tokens->next();
        return $this->enrichWithAttributes($tokens, new Ast\ConstExpr\ConstExprFloatNode(str_replace('_', '', $value)), $startLine, $startIndex);
    }
    if ($tokens->isCurrentTokenType(Lexer::TOKEN_INTEGER)) {
        $value = $tokens->currentTokenValue();
        $tokens->next();
        return $this->enrichWithAttributes($tokens, new Ast\ConstExpr\ConstExprIntegerNode(str_replace('_', '', $value)), $startLine, $startIndex);
    }
    if ($this->parseDoctrineStrings && $tokens->isCurrentTokenType(Lexer::TOKEN_DOCTRINE_ANNOTATION_STRING)) {
        $value = $tokens->currentTokenValue();
        $tokens->next();
        return $this->enrichWithAttributes($tokens, new Ast\ConstExpr\DoctrineConstExprStringNode(Ast\ConstExpr\DoctrineConstExprStringNode::unescape($value)), $startLine, $startIndex);
    }
    if ($tokens->isCurrentTokenType(Lexer::TOKEN_SINGLE_QUOTED_STRING, Lexer::TOKEN_DOUBLE_QUOTED_STRING)) {
        if ($this->parseDoctrineStrings) {
            if ($tokens->isCurrentTokenType(Lexer::TOKEN_SINGLE_QUOTED_STRING)) {
                throw new ParserException($tokens->currentTokenValue(), $tokens->currentTokenType(), $tokens->currentTokenOffset(), Lexer::TOKEN_DOUBLE_QUOTED_STRING, null, $tokens->currentTokenLine());
            }
            $value = $tokens->currentTokenValue();
            $tokens->next();
            return $this->enrichWithAttributes($tokens, $this->parseDoctrineString($value, $tokens), $startLine, $startIndex);
        }
        $value = $tokens->currentTokenValue();
        $type = $tokens->currentTokenType();
        if ($trimStrings) {
            if ($this->unescapeStrings) {
                $value = StringUnescaper::unescapeString($value);
            }
            else {
                $value = substr($value, 1, -1);
            }
        }
        $tokens->next();
        if ($this->quoteAwareConstExprString) {
            return $this->enrichWithAttributes($tokens, new Ast\ConstExpr\QuoteAwareConstExprStringNode($value, $type === Lexer::TOKEN_SINGLE_QUOTED_STRING ? Ast\ConstExpr\QuoteAwareConstExprStringNode::SINGLE_QUOTED : Ast\ConstExpr\QuoteAwareConstExprStringNode::DOUBLE_QUOTED), $startLine, $startIndex);
        }
        return $this->enrichWithAttributes($tokens, new Ast\ConstExpr\ConstExprStringNode($value), $startLine, $startIndex);
    }
    elseif ($tokens->isCurrentTokenType(Lexer::TOKEN_IDENTIFIER)) {
        $identifier = $tokens->currentTokenValue();
        $tokens->next();
        switch (strtolower($identifier)) {
            case 'true':
                return $this->enrichWithAttributes($tokens, new Ast\ConstExpr\ConstExprTrueNode(), $startLine, $startIndex);
            case 'false':
                return $this->enrichWithAttributes($tokens, new Ast\ConstExpr\ConstExprFalseNode(), $startLine, $startIndex);
            case 'null':
                return $this->enrichWithAttributes($tokens, new Ast\ConstExpr\ConstExprNullNode(), $startLine, $startIndex);
            case 'array':
                $tokens->consumeTokenType(Lexer::TOKEN_OPEN_PARENTHESES);
                return $this->parseArray($tokens, Lexer::TOKEN_CLOSE_PARENTHESES, $startIndex);
        }
        if ($tokens->tryConsumeTokenType(Lexer::TOKEN_DOUBLE_COLON)) {
            $classConstantName = '';
            $lastType = null;
            while (true) {
                if ($lastType !== Lexer::TOKEN_IDENTIFIER && $tokens->currentTokenType() === Lexer::TOKEN_IDENTIFIER) {
                    $classConstantName .= $tokens->currentTokenValue();
                    $tokens->consumeTokenType(Lexer::TOKEN_IDENTIFIER);
                    $lastType = Lexer::TOKEN_IDENTIFIER;
                    continue;
                }
                if ($lastType !== Lexer::TOKEN_WILDCARD && $tokens->tryConsumeTokenType(Lexer::TOKEN_WILDCARD)) {
                    $classConstantName .= '*';
                    $lastType = Lexer::TOKEN_WILDCARD;
                    if ($tokens->getSkippedHorizontalWhiteSpaceIfAny() !== '') {
                        break;
                    }
                    continue;
                }
                if ($lastType === null) {
                    // trigger parse error if nothing valid was consumed
                    $tokens->consumeTokenType(Lexer::TOKEN_WILDCARD);
                }
                break;
            }
            return $this->enrichWithAttributes($tokens, new Ast\ConstExpr\ConstFetchNode($identifier, $classConstantName), $startLine, $startIndex);
        }
        return $this->enrichWithAttributes($tokens, new Ast\ConstExpr\ConstFetchNode('', $identifier), $startLine, $startIndex);
    }
    elseif ($tokens->tryConsumeTokenType(Lexer::TOKEN_OPEN_SQUARE_BRACKET)) {
        return $this->parseArray($tokens, Lexer::TOKEN_CLOSE_SQUARE_BRACKET, $startIndex);
    }
    throw new ParserException($tokens->currentTokenValue(), $tokens->currentTokenType(), $tokens->currentTokenOffset(), Lexer::TOKEN_IDENTIFIER, null, $tokens->currentTokenLine());
}