@rightcapital/phpdoc-parser 0.6.2-renovate-lock-file-maintenance.2572.1.0 → 0.6.2

package/dist/phpdoc-parser/parser/type-parser.js

@@ -1,706 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypeParser = void 0;
-const const_expr_array_node_1 = require("../ast/const-expr/const-expr-array-node");
-const const_expr_integer_node_1 = require("../ast/const-expr/const-expr-integer-node");
-const const_expr_string_node_1 = require("../ast/const-expr/const-expr-string-node");
-const const_fetch_node_1 = require("../ast/const-expr/const-fetch-node");
-const template_tag_value_node_1 = require("../ast/php-doc/template-tag-value-node");
-const array_shape_item_node_1 = require("../ast/type/array-shape-item-node");
-const array_shape_node_1 = require("../ast/type/array-shape-node");
-const array_shape_unsealed_type_node_1 = require("../ast/type/array-shape-unsealed-type-node");
-const array_type_node_1 = require("../ast/type/array-type-node");
-const callable_type_node_1 = require("../ast/type/callable-type-node");
-const callable_type_parameter_node_1 = require("../ast/type/callable-type-parameter-node");
-const conditional_type_for_parameter_node_1 = require("../ast/type/conditional-type-for-parameter-node");
-const conditional_type_node_1 = require("../ast/type/conditional-type-node");
-const const_type_node_1 = require("../ast/type/const-type-node");
-const generic_type_node_1 = require("../ast/type/generic-type-node");
-const identifier_type_node_1 = require("../ast/type/identifier-type-node");
-const intersection_type_node_1 = require("../ast/type/intersection-type-node");
-const nullable_type_node_1 = require("../ast/type/nullable-type-node");
-const object_shape_item_node_1 = require("../ast/type/object-shape-item-node");
-const object_shape_node_1 = require("../ast/type/object-shape-node");
-const offset_access_type_node_1 = require("../ast/type/offset-access-type-node");
-const this_type_node_1 = require("../ast/type/this-type-node");
-const union_type_node_1 = require("../ast/type/union-type-node");
-const types_1 = require("../ast/types");
-const lexer_1 = require("../lexer/lexer");
-const parser_exception_1 = require("./parser-exception");
-const string_unescaper_1 = require("./string-unescaper");
-class TypeParser {
-    constructor(constExprParser = null, usedAttributes = {}) {
-        var _a, _b;
-        this.constExprParser = constExprParser;
-        this.useLinesAttributes = (_a = usedAttributes.lines) !== null && _a !== void 0 ? _a : false;
-        this.useIndexAttributes = (_b = usedAttributes.indexes) !== null && _b !== void 0 ? _b : false;
-    }
-    parse(tokens) {
-        var _a;
-        const startLine = tokens.currentTokenLine();
-        const startIndex = tokens.currentTokenIndex();
-        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_NULLABLE)) {
-            return this.parseNullable(tokens);
-        }
-        let type = this.parseAtomic(tokens);
-        tokens.pushSavePoint();
-        tokens.skipNewLineTokensAndConsumeComments();
-        let enrichedType = null;
-        try {
-            enrichedType = this.enrichTypeOnUnionOrIntersection(tokens, type);
-        }
-        catch (_b) {
-            enrichedType = null;
-        }
-        if (enrichedType !== null) {
-            type = enrichedType;
-            tokens.dropSavePoint();
-        }
-        else {
-            tokens.rollback();
-            type = (_a = this.enrichTypeOnUnionOrIntersection(tokens, type)) !== null && _a !== void 0 ? _a : type;
-        }
-        return this.enrichWithAttributes(tokens, type, startLine, startIndex);
-    }
-    enrichTypeOnUnionOrIntersection(tokens, type) {
-        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_UNION)) {
-            return this.parseUnion(tokens, type);
-        }
-        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_INTERSECTION)) {
-            return this.parseIntersection(tokens, type);
-        }
-        return null;
-    }
-    enrichWithAttributes(tokens, type, startLine, startIndex) {
-        if (this.useLinesAttributes) {
-            type.setAttribute(types_1.Attribute.START_LINE, startLine);
-            type.setAttribute(types_1.Attribute.END_LINE, tokens.currentTokenLine());
-        }
-        tokens.flushComments();
-        if (this.useIndexAttributes) {
-            type.setAttribute(types_1.Attribute.START_INDEX, startIndex);
-            type.setAttribute(types_1.Attribute.END_INDEX, tokens.endIndexOfLastRelevantToken());
-        }
-        return type;
-    }
-    parseTemplateTagValue(tokens, parseDescription) {
-        const name = tokens.currentTokenValue();
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER);
-        let upperBound = null;
-        let lowerBound = null;
-        if (tokens.tryConsumeTokenValue('of') ||
-            tokens.tryConsumeTokenValue('as')) {
-            upperBound = this.parse(tokens);
-        }
-        if (tokens.tryConsumeTokenValue('super')) {
-            lowerBound = this.parse(tokens);
-        }
-        let defaultValue = null;
-        if (tokens.tryConsumeTokenValue('=')) {
-            defaultValue = this.parse(tokens);
-        }
-        let description = '';
-        if (parseDescription) {
-            description = parseDescription(tokens);
-        }
-        if (name === '') {
-            throw new Error('Template tag name cannot be empty.');
-        }
-        return new template_tag_value_node_1.TemplateTagValueNode(name, upperBound, description, defaultValue, lowerBound);
-    }
-    subParse(tokens) {
-        const startLine = tokens.currentTokenLine();
-        const startIndex = tokens.currentTokenIndex();
-        let type;
-        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_NULLABLE)) {
-            type = this.parseNullable(tokens);
-        }
-        else {
-            type = this.parseAtomic(tokens);
-            if (tokens.isCurrentTokenValue('is')) {
-                type = this.parseConditional(tokens, type);
-            }
-            else {
-                tokens.skipNewLineTokensAndConsumeComments();
-                if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_UNION)) {
-                    type = this.subParseUnion(tokens, type);
-                }
-                else if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_INTERSECTION)) {
-                    type = this.subParseIntersection(tokens, type);
-                }
-            }
-        }
-        return this.enrichWithAttributes(tokens, type, startLine, startIndex);
-    }
-    parseAtomic(tokens) {
-        const startLine = tokens.currentTokenLine();
-        const startIndex = tokens.currentTokenIndex();
-        let type;
-        if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_OPEN_PARENTHESES)) {
-            tokens.skipNewLineTokensAndConsumeComments();
-            type = this.subParse(tokens);
-            tokens.skipNewLineTokensAndConsumeComments();
-            tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_PARENTHESES);
-            if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET)) {
-                type = this.tryParseArrayOrOffsetAccess(tokens, type);
-            }
-            return this.enrichWithAttributes(tokens, type, startLine, startIndex);
-        }
-        if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_THIS_VARIABLE)) {
-            type = new this_type_node_1.ThisTypeNode();
-            if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET)) {
-                type = this.tryParseArrayOrOffsetAccess(tokens, this.enrichWithAttributes(tokens, type, startLine, startIndex));
-            }
-            return this.enrichWithAttributes(tokens, type, startLine, startIndex);
-        }
-        const currentTokenValue = tokens.currentTokenValue();
-        tokens.pushSavePoint();
-        if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER)) {
-            const identifierTypeNode = new identifier_type_node_1.IdentifierTypeNode(currentTokenValue);
-            type = identifierTypeNode;
-            if (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_DOUBLE_COLON)) {
-                tokens.dropSavePoint();
-                if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_ANGLE_BRACKET)) {
-                    tokens.pushSavePoint();
-                    const isHtml = this.isHtml(tokens);
-                    tokens.rollback();
-                    if (isHtml) {
-                        return this.enrichWithAttributes(tokens, type, startLine, startIndex);
-                    }
-                    const origType = type;
-                    type = this.tryParseCallable(tokens, identifierTypeNode, true);
-                    if (type === origType) {
-                        type = this.parseGeneric(tokens, identifierTypeNode);
-                        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET)) {
-                            type = this.tryParseArrayOrOffsetAccess(tokens, type);
-                        }
-                    }
-                }
-                else if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_PARENTHESES)) {
-                    type = this.tryParseCallable(tokens, identifierTypeNode, false);
-                }
-                else if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET)) {
-                    type = this.tryParseArrayOrOffsetAccess(tokens, type);
-                }
-                else if ([
-                    'array',
-                    'list',
-                    'non-empty-array',
-                    'non-empty-list',
-                    'object',
-                ].includes(identifierTypeNode.name) &&
-                    tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_CURLY_BRACKET) &&
-                    !tokens.isPrecededByHorizontalWhitespace()) {
-                    if (identifierTypeNode.name === 'object') {
-                        type = this.parseObjectShape(tokens);
-                    }
-                    else {
-                        type = this.parseArrayShape(tokens, type, identifierTypeNode.name);
-                    }
-                    if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET)) {
-                        type = this.tryParseArrayOrOffsetAccess(tokens, this.enrichWithAttributes(tokens, type, startLine, startIndex));
-                    }
-                }
-                return this.enrichWithAttributes(tokens, type, startLine, startIndex);
-            }
-            tokens.rollback();
-        }
-        else {
-            tokens.dropSavePoint();
-        }
-        const exception = new parser_exception_1.ParserException(tokens.currentTokenValue(), tokens.currentTokenType(), tokens.currentTokenOffset(), lexer_1.Lexer.TOKEN_IDENTIFIER, null, tokens.currentTokenLine());
-        if (this.constExprParser === null) {
-            throw exception;
-        }
-        try {
-            const constExpr = this.constExprParser.parse(tokens);
-            if (constExpr instanceof const_expr_array_node_1.ConstExprArrayNode) {
-                throw exception;
-            }
-            return this.enrichWithAttributes(tokens, new const_type_node_1.ConstTypeNode(constExpr), startLine, startIndex);
-        }
-        catch (error) {
-            exception.cause = error;
-            throw exception;
-        }
-    }
-    parseUnion(tokens, type) {
-        const types = [type];
-        while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_UNION)) {
-            tokens.skipNewLineTokensAndConsumeComments();
-            types.push(this.parseAtomic(tokens));
-        }
-        return new union_type_node_1.UnionTypeNode(types);
-    }
-    subParseUnion(tokens, type) {
-        const types = [type];
-        while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_UNION)) {
-            tokens.skipNewLineTokensAndConsumeComments();
-            types.push(this.parseAtomic(tokens));
-            tokens.skipNewLineTokensAndConsumeComments();
-        }
-        return new union_type_node_1.UnionTypeNode(types);
-    }
-    parseIntersection(tokens, type) {
-        const types = [type];
-        while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_INTERSECTION)) {
-            tokens.skipNewLineTokensAndConsumeComments();
-            types.push(this.parseAtomic(tokens));
-        }
-        return new intersection_type_node_1.IntersectionTypeNode(types);
-    }
-    subParseIntersection(tokens, type) {
-        const types = [type];
-        while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_INTERSECTION)) {
-            tokens.skipNewLineTokensAndConsumeComments();
-            types.push(this.parseAtomic(tokens));
-            tokens.skipNewLineTokensAndConsumeComments();
-        }
-        return new intersection_type_node_1.IntersectionTypeNode(types);
-    }
-    parseConditional(tokens, subjectType) {
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER);
-        let negated = false;
-        if (tokens.isCurrentTokenValue('not')) {
-            negated = true;
-            tokens.consumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER);
-        }
-        const targetType = this.parse(tokens);
-        tokens.skipNewLineTokensAndConsumeComments();
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_NULLABLE);
-        tokens.skipNewLineTokensAndConsumeComments();
-        const ifType = this.parse(tokens);
-        tokens.skipNewLineTokensAndConsumeComments();
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_COLON);
-        tokens.skipNewLineTokensAndConsumeComments();
-        const elseType = this.subParse(tokens);
-        return new conditional_type_node_1.ConditionalTypeNode(subjectType, targetType, ifType, elseType, negated);
-    }
-    parseConditionalForParameter(tokens, parameterName) {
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_VARIABLE);
-        tokens.consumeTokenValue(lexer_1.Lexer.TOKEN_IDENTIFIER, 'is');
-        let negated = false;
-        if (tokens.isCurrentTokenValue('not')) {
-            negated = true;
-            tokens.consumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER);
-        }
-        const targetType = this.parse(tokens);
-        tokens.skipNewLineTokensAndConsumeComments();
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_NULLABLE);
-        tokens.skipNewLineTokensAndConsumeComments();
-        const ifType = this.parse(tokens);
-        tokens.skipNewLineTokensAndConsumeComments();
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_COLON);
-        tokens.skipNewLineTokensAndConsumeComments();
-        const elseType = this.subParse(tokens);
-        return new conditional_type_for_parameter_node_1.ConditionalTypeForParameterNode(parameterName, targetType, ifType, elseType, negated);
-    }
-    parseNullable(tokens) {
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_NULLABLE);
-        const type = this.parseAtomic(tokens);
-        return new nullable_type_node_1.NullableTypeNode(type);
-    }
-    isHtml(tokens) {
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_ANGLE_BRACKET);
-        if (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER)) {
-            return false;
-        }
-        const htmlTagName = tokens.currentTokenValue();
-        tokens.next();
-        if (!tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_ANGLE_BRACKET)) {
-            return false;
-        }
-        while (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_END)) {
-            if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_OPEN_ANGLE_BRACKET) &&
-                tokens.currentTokenValue().includes(`/${htmlTagName}>`)) {
-                return true;
-            }
-            tokens.next();
-        }
-        return false;
-    }
-    parseGeneric(tokens, baseType) {
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_ANGLE_BRACKET);
-        tokens.skipNewLineTokensAndConsumeComments();
-        const genericTypes = [];
-        const variances = [];
-        const [genericType, variance] = this.parseGenericTypeArgument(tokens);
-        genericTypes.push(genericType);
-        variances.push(variance);
-        tokens.skipNewLineTokensAndConsumeComments();
-        while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA)) {
-            tokens.skipNewLineTokensAndConsumeComments();
-            if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_ANGLE_BRACKET)) {
-                break;
-            }
-            const [genericTypeToAddInWhileLoop, varianceToAddInWhileLoop] = this.parseGenericTypeArgument(tokens);
-            genericTypes.push(genericTypeToAddInWhileLoop);
-            variances.push(varianceToAddInWhileLoop);
-            tokens.skipNewLineTokensAndConsumeComments();
-        }
-        tokens.skipNewLineTokensAndConsumeComments();
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_ANGLE_BRACKET);
-        const type = new generic_type_node_1.GenericTypeNode(baseType, genericTypes, variances);
-        const startLine = baseType.getAttribute(types_1.Attribute.START_LINE);
-        const startIndex = baseType.getAttribute(types_1.Attribute.START_INDEX);
-        if (startLine !== null && startIndex !== null) {
-            return this.enrichWithAttributes(tokens, type, baseType.getAttribute(types_1.Attribute.START_LINE), baseType.getAttribute(types_1.Attribute.START_INDEX));
-        }
-        return type;
-    }
-    parseGenericTypeArgument(tokens) {
-        const startLine = tokens.currentTokenLine();
-        const startIndex = tokens.currentTokenIndex();
-        if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_WILDCARD)) {
-            return [
-                this.enrichWithAttributes(tokens, new identifier_type_node_1.IdentifierTypeNode('mixed'), startLine, startIndex),
-                generic_type_node_1.GenericTypeNode.VARIANCE_BIVARIANT,
-            ];
-        }
-        let variance;
-        if (tokens.tryConsumeTokenValue('contravariant')) {
-            variance = generic_type_node_1.GenericTypeNode.VARIANCE_CONTRAVARIANT;
-        }
-        else if (tokens.tryConsumeTokenValue('covariant')) {
-            variance = generic_type_node_1.GenericTypeNode.VARIANCE_COVARIANT;
-        }
-        else {
-            variance = generic_type_node_1.GenericTypeNode.VARIANCE_INVARIANT;
-        }
-        const type = this.parse(tokens);
-        return [type, variance];
-    }
-    parseCallable(tokens, identifier, hasTemplate) {
-        const templates = hasTemplate ? this.parseCallableTemplates(tokens) : [];
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_PARENTHESES);
-        tokens.skipNewLineTokensAndConsumeComments();
-        const parameters = [];
-        if (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_CLOSE_PARENTHESES)) {
-            parameters.push(this.parseCallableParameter(tokens));
-            tokens.skipNewLineTokensAndConsumeComments();
-            while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA)) {
-                tokens.skipNewLineTokensAndConsumeComments();
-                if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_CLOSE_PARENTHESES)) {
-                    break;
-                }
-                parameters.push(this.parseCallableParameter(tokens));
-                tokens.skipNewLineTokensAndConsumeComments();
-            }
-        }
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_PARENTHESES);
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_COLON);
-        const startLine = tokens.currentTokenLine();
-        const startIndex = tokens.currentTokenIndex();
-        const returnType = this.enrichWithAttributes(tokens, this.parseCallableReturnType(tokens), startLine, startIndex);
-        return new callable_type_node_1.CallableTypeNode(identifier, parameters, returnType, templates);
-    }
-    parseCallableTemplates(tokens) {
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_ANGLE_BRACKET);
-        const templates = [];
-        let isFirst = true;
-        while (isFirst || tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA)) {
-            tokens.skipNewLineTokensAndConsumeComments();
-            if (!isFirst &&
-                tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_CLOSE_ANGLE_BRACKET)) {
-                break;
-            }
-            isFirst = false;
-            templates.push(this.parseCallableTemplateArgument(tokens));
-            tokens.skipNewLineTokensAndConsumeComments();
-        }
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_ANGLE_BRACKET);
-        return templates;
-    }
-    parseCallableTemplateArgument(tokens) {
-        const startLine = tokens.currentTokenLine();
-        const startIndex = tokens.currentTokenIndex();
-        return this.enrichWithAttributes(tokens, this.parseTemplateTagValue(tokens), startLine, startIndex);
-    }
-    parseCallableParameter(tokens) {
-        const startLine = tokens.currentTokenLine();
-        const startIndex = tokens.currentTokenIndex();
-        const type = this.parse(tokens);
-        const isReference = tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_REFERENCE);
-        const isVariadic = tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_VARIADIC);
-        let parameterName = '';
-        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_VARIABLE)) {
-            parameterName = tokens.currentTokenValue();
-            tokens.consumeTokenType(lexer_1.Lexer.TOKEN_VARIABLE);
-        }
-        const isOptional = tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_EQUAL);
-        return this.enrichWithAttributes(tokens, new callable_type_parameter_node_1.CallableTypeParameterNode(type, isReference, isVariadic, parameterName, isOptional), startLine, startIndex);
-    }
-    parseCallableReturnType(tokens) {
-        const startLine = tokens.currentTokenLine();
-        const startIndex = tokens.currentTokenIndex();
-        let type;
-        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_NULLABLE)) {
-            return this.parseNullable(tokens);
-        }
-        if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_OPEN_PARENTHESES)) {
-            type = this.parse(tokens);
-            tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_PARENTHESES);
-            if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET)) {
-                type = this.tryParseArrayOrOffsetAccess(tokens, type);
-            }
-            return type;
-        }
-        if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_THIS_VARIABLE)) {
-            type = new this_type_node_1.ThisTypeNode();
-            if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET)) {
-                type = this.tryParseArrayOrOffsetAccess(tokens, this.enrichWithAttributes(tokens, type, startLine, startIndex));
-            }
-            return type;
-        }
-        const currentTokenValue = tokens.currentTokenValue();
-        tokens.pushSavePoint();
-        if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER)) {
-            type = new identifier_type_node_1.IdentifierTypeNode(currentTokenValue);
-            if (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_DOUBLE_COLON)) {
-                if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_ANGLE_BRACKET)) {
-                    type = this.parseGeneric(tokens, this.enrichWithAttributes(tokens, type, startLine, startIndex));
-                }
-                else if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET)) {
-                    type = this.tryParseArrayOrOffsetAccess(tokens, this.enrichWithAttributes(tokens, type, startLine, startIndex));
-                }
-            }
-            else {
-                tokens.rollback();
-            }
-            return type;
-        }
-        tokens.dropSavePoint();
-        const exception = new parser_exception_1.ParserException(tokens.currentTokenValue(), tokens.currentTokenType(), tokens.currentTokenOffset(), lexer_1.Lexer.TOKEN_IDENTIFIER, null, tokens.currentTokenLine());
-        if (this.constExprParser === null) {
-            throw exception;
-        }
-        if (this.constExprParser === null) {
-            throw exception;
-        }
-        try {
-            const constExpr = this.constExprParser.parse(tokens);
-            if (constExpr instanceof const_expr_array_node_1.ConstExprArrayNode) {
-                throw exception;
-            }
-            type = new const_type_node_1.ConstTypeNode(constExpr);
-            if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET)) {
-                type = this.tryParseArrayOrOffsetAccess(tokens, this.enrichWithAttributes(tokens, type, startLine, startIndex));
-            }
-            return type;
-        }
-        catch (e) {
-            if (e instanceof Error) {
-                throw exception;
-            }
-            else {
-                throw e;
-            }
-        }
-    }
-    tryParseCallable(tokens, identifier, hasTemplate) {
-        try {
-            tokens.pushSavePoint();
-            const type = this.parseCallable(tokens, identifier, hasTemplate);
-            tokens.dropSavePoint();
-            return type;
-        }
-        catch (e) {
-            if (e instanceof parser_exception_1.ParserException) {
-                tokens.rollback();
-                return identifier;
-            }
-            throw e;
-        }
-    }
-    tryParseArrayOrOffsetAccess(tokens, type) {
-        try {
-            while (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET)) {
-                tokens.pushSavePoint();
-                const canBeOffsetAccessType = !tokens.isPrecededByHorizontalWhitespace();
-                tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_SQUARE_BRACKET);
-                if (canBeOffsetAccessType &&
-                    !tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_CLOSE_SQUARE_BRACKET)) {
-                    const offset = this.parse(tokens);
-                    tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_SQUARE_BRACKET);
-                    tokens.dropSavePoint();
-                    type = new offset_access_type_node_1.OffsetAccessTypeNode(type, offset);
-                }
-                else {
-                    tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_SQUARE_BRACKET);
-                    tokens.dropSavePoint();
-                    type = new array_type_node_1.ArrayTypeNode(type);
-                }
-            }
-        }
-        catch (e) {
-            if (e instanceof parser_exception_1.ParserException) {
-                tokens.rollback();
-            }
-            else {
-                throw e;
-            }
-        }
-        return type;
-    }
-    parseArrayShape(tokens, type, kind) {
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_CURLY_BRACKET);
-        const items = [];
-        let sealed = true;
-        let unsealedType = null;
-        let done = false;
-        do {
-            tokens.skipNewLineTokensAndConsumeComments();
-            if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_CURLY_BRACKET)) {
-                return new array_shape_node_1.ArrayShapeNode(items, true, kind);
-            }
-            if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_VARIADIC)) {
-                sealed = false;
-                tokens.skipNewLineTokensAndConsumeComments();
-                if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_OPEN_ANGLE_BRACKET)) {
-                    if (kind === array_shape_node_1.ArrayShapeNodeKind.ARRAY ||
-                        kind === array_shape_node_1.ArrayShapeNodeKind.NON_EMPTY_ARRAY) {
-                        unsealedType = this.parseArrayShapeUnsealedType(tokens);
-                    }
-                    else {
-                        unsealedType = this.parseListShapeUnsealedType(tokens);
-                    }
-                    tokens.skipNewLineTokensAndConsumeComments();
-                }
-                tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA);
-                break;
-            }
-            items.push(this.parseArrayShapeItem(tokens));
-            tokens.skipNewLineTokensAndConsumeComments();
-            if (!tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA)) {
-                done = true;
-            }
-        } while (!done);
-        tokens.skipNewLineTokensAndConsumeComments();
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_CURLY_BRACKET);
-        if (sealed) {
-            return new array_shape_node_1.ArrayShapeNode(items, true, kind);
-        }
-        return new array_shape_node_1.ArrayShapeNode(items, false, kind, unsealedType);
-    }
-    parseArrayShapeItem(tokens) {
-        const startLine = tokens.currentTokenLine();
-        const startIndex = tokens.currentTokenIndex();
-        try {
-            tokens.pushSavePoint();
-            const key = this.parseArrayShapeKey(tokens);
-            const optional = tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_NULLABLE);
-            tokens.consumeTokenType(lexer_1.Lexer.TOKEN_COLON);
-            const value = this.parse(tokens);
-            tokens.dropSavePoint();
-            return this.enrichWithAttributes(tokens, new array_shape_item_node_1.ArrayShapeItemNode(key, optional, value), startLine, startIndex);
-        }
-        catch (e) {
-            if (e instanceof parser_exception_1.ParserException) {
-                tokens.rollback();
-                const value = this.parse(tokens);
-                return this.enrichWithAttributes(tokens, new array_shape_item_node_1.ArrayShapeItemNode(null, false, value), startLine, startIndex);
-            }
-            throw e;
-        }
-    }
-    parseArrayShapeKey(tokens) {
-        const startLine = tokens.currentTokenLine();
-        const startIndex = tokens.currentTokenIndex();
-        let key;
-        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_INTEGER)) {
-            key = new const_expr_integer_node_1.ConstExprIntegerNode(tokens.currentTokenValue().replaceAll('_', ''));
-            tokens.next();
-        }
-        else if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_SINGLE_QUOTED_STRING)) {
-            key = new const_expr_string_node_1.ConstExprStringNode(string_unescaper_1.StringUnescaper.unescapeString(tokens.currentTokenValue()), const_expr_string_node_1.ConstExprStringNode.SINGLE_QUOTED);
-            tokens.next();
-        }
-        else if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_DOUBLE_QUOTED_STRING)) {
-            key = new const_expr_string_node_1.ConstExprStringNode(string_unescaper_1.StringUnescaper.unescapeString(tokens.currentTokenValue()), const_expr_string_node_1.ConstExprStringNode.DOUBLE_QUOTED);
-            tokens.next();
-        }
-        else {
-            const identifier = tokens.currentTokenValue();
-            tokens.consumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER);
-            if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_DOUBLE_COLON)) {
-                const classConstantName = tokens.currentTokenValue();
-                tokens.consumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER);
-                key = new const_fetch_node_1.ConstFetchNode(identifier, classConstantName);
-            }
-            else {
-                key = new identifier_type_node_1.IdentifierTypeNode(identifier);
-            }
-        }
-        return this.enrichWithAttributes(tokens, key, startLine, startIndex);
-    }
-    parseArrayShapeUnsealedType(tokens) {
-        const startLine = tokens.currentTokenLine();
-        const startIndex = tokens.currentTokenIndex();
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_ANGLE_BRACKET);
-        tokens.skipNewLineTokensAndConsumeComments();
-        let valueType = this.parse(tokens);
-        tokens.skipNewLineTokensAndConsumeComments();
-        let keyType = null;
-        if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA)) {
-            tokens.skipNewLineTokensAndConsumeComments();
-            keyType = valueType;
-            valueType = this.parse(tokens);
-            tokens.skipNewLineTokensAndConsumeComments();
-        }
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_ANGLE_BRACKET);
-        return this.enrichWithAttributes(tokens, new array_shape_unsealed_type_node_1.ArrayShapeUnsealedTypeNode(valueType, keyType), startLine, startIndex);
-    }
-    parseListShapeUnsealedType(tokens) {
-        const startLine = tokens.currentTokenLine();
-        const startIndex = tokens.currentTokenIndex();
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_ANGLE_BRACKET);
-        tokens.skipNewLineTokensAndConsumeComments();
-        const valueType = this.parse(tokens);
-        tokens.skipNewLineTokensAndConsumeComments();
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_ANGLE_BRACKET);
-        return this.enrichWithAttributes(tokens, new array_shape_unsealed_type_node_1.ArrayShapeUnsealedTypeNode(valueType, null), startLine, startIndex);
-    }
-    parseObjectShape(tokens) {
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_OPEN_CURLY_BRACKET);
-        const items = [];
-        do {
-            tokens.skipNewLineTokensAndConsumeComments();
-            if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_CURLY_BRACKET)) {
-                return new object_shape_node_1.ObjectShapeNode(items);
-            }
-            items.push(this.parseObjectShapeItem(tokens));
-            tokens.skipNewLineTokensAndConsumeComments();
-        } while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA));
-        tokens.skipNewLineTokensAndConsumeComments();
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_CURLY_BRACKET);
-        return new object_shape_node_1.ObjectShapeNode(items);
-    }
-    parseObjectShapeItem(tokens) {
-        const startLine = tokens.currentTokenLine();
-        const startIndex = tokens.currentTokenIndex();
-        const key = this.parseObjectShapeKey(tokens);
-        const optional = tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_NULLABLE);
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_COLON);
-        const value = this.parse(tokens);
-        return this.enrichWithAttributes(tokens, new object_shape_item_node_1.ObjectShapeItemNode(key, optional, value), startLine, startIndex);
-    }
-    parseObjectShapeKey(tokens) {
-        const startLine = tokens.currentTokenLine();
-        const startIndex = tokens.currentTokenIndex();
-        let key;
-        if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_SINGLE_QUOTED_STRING)) {
-            key = new const_expr_string_node_1.ConstExprStringNode(string_unescaper_1.StringUnescaper.unescapeString(tokens.currentTokenValue()), const_expr_string_node_1.ConstExprStringNode.SINGLE_QUOTED);
-            tokens.next();
-        }
-        else if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_DOUBLE_QUOTED_STRING)) {
-            key = new const_expr_string_node_1.ConstExprStringNode(string_unescaper_1.StringUnescaper.unescapeString(tokens.currentTokenValue()), const_expr_string_node_1.ConstExprStringNode.DOUBLE_QUOTED);
-            tokens.next();
-        }
-        else {
-            key = new identifier_type_node_1.IdentifierTypeNode(tokens.currentTokenValue());
-            tokens.consumeTokenType(lexer_1.Lexer.TOKEN_IDENTIFIER);
-        }
-        return this.enrichWithAttributes(tokens, key, startLine, startIndex);
-    }
-}
-exports.TypeParser = TypeParser;