@rightcapital/phpdoc-parser 0.3.3-feature-add-basic-ci.7.0 → 0.3.3-feature-add-basic-ci.8.0

package/dist/phpdoc-parser/parser/string-unescaper.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringUnescaper = void 0;
+class StringUnescaper {
+    static unescapeString(input) {
+        const quote = input[0];
+        if (quote === "'") {
+            return input.slice(1, input.length - 1).replaceAll(/\\([\\\.])/g, '$1');
+        }
+        return this.parseEscapeSequences(input.slice(1, input.length - 1), '"');
+    }
+    static parseEscapeSequences(input, quote) {
+        input = input.replaceAll(new RegExp(`\\${quote}`, 'g'), quote);
+        return input.replaceAll(/\\([\\nrtfve]|[xX][0-9a-fA-F]{1,2}|[0-7]{1,3}|u\{([0-9a-fA-F]+)\})/g, (substring, ...matches) => {
+            const firstCaptureGroup = matches[0];
+            if (this.REPLACEMENTS[firstCaptureGroup]) {
+                return this.REPLACEMENTS[firstCaptureGroup];
+            }
+            if (firstCaptureGroup[0] === 'x' || firstCaptureGroup[0] === 'X') {
+                return String.fromCharCode(parseInt(firstCaptureGroup.slice(1), 16));
+            }
+            if (firstCaptureGroup[0] === 'u') {
+                return String.fromCharCode(parseInt(matches[1], 16));
+            }
+            return String.fromCharCode(parseInt(firstCaptureGroup, 8));
+        });
+    }
+    getType() {
+        return 'Scalar_String';
+    }
+}
+exports.StringUnescaper = StringUnescaper;
+StringUnescaper.REPLACEMENTS = {
+    '\\': '\\',
+    n: '\n',
+    r: '\r',
+    t: '\t',
+    f: '\f',
+    v: '\v',
+    e: '\x1B',
+};

package/dist/phpdoc-parser/parser/token-iterator.d.ts

@@ -0,0 +1,40 @@
+export declare class TokenIterator {
+    private tokens;
+    private index;
+    private savePoints;
+    private skippedTokenTypes;
+    private newline;
+    constructor(tokens: Array<[string, string, number]>, index?: number);
+    getTokens(): Array<[string, string, number]>;
+    getContentBetween(startPos: number, endPos: number): string;
+    getTokenCount(): number;
+    currentTokenValue(): string;
+    currentTokenType(): string;
+    currentTokenOffset(): number;
+    currentTokenLine(): number;
+    currentTokenIndex(): number;
+    endIndexOfLastRelevantToken(): number;
+    isCurrentTokenValue(tokenValue: string): boolean;
+    isCurrentTokenType(...tokenType: string[]): boolean;
+    isPrecededByHorizontalWhitespace(): boolean;
+    consumeTokenType(tokenType: string): void;
+    consumeTokenValue(tokenType: string, tokenValue: string): void;
+    tryConsumeTokenValue(tokenValue: string): boolean;
+    tryConsumeTokenType(tokenType: string): boolean;
+    private detectNewline;
+    getSkippedHorizontalWhiteSpaceIfAny(): string;
+    joinUntil(...tokenType: string[]): string;
+    next(): void;
+    private skipIrrelevantTokens;
+    addEndOfLineToSkippedTokens(): void;
+    removeEndOfLineFromSkippedTokens(): void;
+    forwardToTheEnd(): void;
+    pushSavePoint(): void;
+    dropSavePoint(): void;
+    rollback(): void;
+    throwError(expectedTokenType: string, expectedTokenValue?: string | null): void;
+    hasTokenImmediatelyBefore(pos: number, expectedTokenType: string): boolean;
+    hasTokenImmediatelyAfter(pos: number, expectedTokenType: string): boolean;
+    getDetectedNewline(): string | null;
+    hasParentheses(startPos: number, endPos: number): boolean;
+}

package/dist/phpdoc-parser/parser/token-iterator.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenIterator = void 0;
+const parser_exception_1 = require("./parser-exception");
+const lexer_1 = require("../lexer/lexer");
+class TokenIterator {
+    constructor(tokens, index = 0) {
+        this.savePoints = [];
+        this.skippedTokenTypes = [lexer_1.Lexer.TOKEN_HORIZONTAL_WS];
+        this.newline = null;
+        this.tokens = tokens;
+        this.index = index;
+        this.skipIrrelevantTokens();
+    }
+    getTokens() {
+        return this.tokens;
+    }
+    getContentBetween(startPos, endPos) {
+        if (startPos < 0 || endPos > this.tokens.length) {
+            throw new Error('LogicException');
+        }
+        let content = '';
+        for (let i = startPos; i < endPos; i++) {
+            content += this.tokens[i][lexer_1.Lexer.VALUE_OFFSET];
+        }
+        return content;
+    }
+    getTokenCount() {
+        return this.tokens.length;
+    }
+    currentTokenValue() {
+        return this.tokens[this.index][lexer_1.Lexer.VALUE_OFFSET];
+    }
+    currentTokenType() {
+        return this.tokens[this.index][lexer_1.Lexer.TYPE_OFFSET];
+    }
+    currentTokenOffset() {
+        let offset = 0;
+        for (let i = 0; i < this.index; i++) {
+            offset += this.tokens[i][lexer_1.Lexer.VALUE_OFFSET].length;
+        }
+        return offset;
+    }
+    currentTokenLine() {
+        return this.tokens[this.index][lexer_1.Lexer.LINE_OFFSET];
+    }
+    currentTokenIndex() {
+        return this.index;
+    }
+    endIndexOfLastRelevantToken() {
+        let endIndex = this.currentTokenIndex();
+        endIndex--;
+        while (this.skippedTokenTypes.includes(this.tokens[endIndex][lexer_1.Lexer.TYPE_OFFSET])) {
+            if (!this.tokens[endIndex - 1]) {
+                break;
+            }
+            endIndex--;
+        }
+        return endIndex;
+    }
+    isCurrentTokenValue(tokenValue) {
+        return this.tokens[this.index][lexer_1.Lexer.VALUE_OFFSET] === tokenValue;
+    }
+    isCurrentTokenType(...tokenType) {
+        return tokenType.includes(this.tokens[this.index][lexer_1.Lexer.TYPE_OFFSET]);
+    }
+    isPrecededByHorizontalWhitespace() {
+        var _a, _b;
+        return (((_b = (_a = this.tokens[this.index - 1]) === null || _a === void 0 ? void 0 : _a[lexer_1.Lexer.TYPE_OFFSET]) !== null && _b !== void 0 ? _b : -1) ===
+            lexer_1.Lexer.TOKEN_HORIZONTAL_WS);
+    }
+    consumeTokenType(tokenType) {
+        if (this.tokens[this.index][lexer_1.Lexer.TYPE_OFFSET] !== tokenType) {
+            this.throwError(tokenType);
+        }
+        if (tokenType === lexer_1.Lexer.TOKEN_PHPDOC_EOL) {
+            if (this.newline === null) {
+                this.detectNewline();
+            }
+        }
+        this.index++;
+        this.skipIrrelevantTokens();
+    }
+    consumeTokenValue(tokenType, tokenValue) {
+        if (this.tokens[this.index][lexer_1.Lexer.TYPE_OFFSET] !== tokenType ||
+            this.tokens[this.index][lexer_1.Lexer.VALUE_OFFSET] !== tokenValue) {
+            this.throwError(tokenType, tokenValue);
+        }
+        this.index++;
+        this.skipIrrelevantTokens();
+    }
+    tryConsumeTokenValue(tokenValue) {
+        if (this.tokens[this.index][lexer_1.Lexer.VALUE_OFFSET] !== tokenValue) {
+            return false;
+        }
+        this.index++;
+        this.skipIrrelevantTokens();
+        return true;
+    }
+    tryConsumeTokenType(tokenType) {
+        if (this.tokens[this.index][lexer_1.Lexer.TYPE_OFFSET] !== tokenType) {
+            return false;
+        }
+        if (tokenType === lexer_1.Lexer.TOKEN_PHPDOC_EOL) {
+            if (this.newline === null) {
+                this.detectNewline();
+            }
+        }
+        this.index++;
+        this.skipIrrelevantTokens();
+        return true;
+    }
+    detectNewline() {
+        const value = this.currentTokenValue();
+        if (value.substring(0, 2) === '\r\n') {
+            this.newline = '\r\n';
+        }
+        else if (value.substring(0, 1) === '\n') {
+            this.newline = '\n';
+        }
+    }
+    getSkippedHorizontalWhiteSpaceIfAny() {
+        if (this.index > 0 &&
+            this.tokens[this.index - 1][1] === lexer_1.Lexer.TOKEN_HORIZONTAL_WS) {
+            return this.tokens[this.index - 1][0];
+        }
+        return '';
+    }
+    joinUntil(...tokenType) {
+        let s = '';
+        while (!tokenType.includes(this.tokens[this.index][1])) {
+            s += this.tokens[this.index++][0];
+        }
+        return s;
+    }
+    next() {
+        this.index++;
+        this.skipIrrelevantTokens();
+    }
+    skipIrrelevantTokens() {
+        if (this.tokens[this.index] === undefined) {
+            return;
+        }
+        while (this.skippedTokenTypes.includes(this.tokens[this.index][lexer_1.Lexer.TYPE_OFFSET])) {
+            if (this.tokens[this.index + 1] === undefined) {
+                break;
+            }
+            this.index++;
+        }
+    }
+    addEndOfLineToSkippedTokens() {
+        this.skippedTokenTypes = [
+            lexer_1.Lexer.TOKEN_HORIZONTAL_WS,
+            lexer_1.Lexer.TOKEN_PHPDOC_EOL,
+        ];
+    }
+    removeEndOfLineFromSkippedTokens() {
+        this.skippedTokenTypes = [lexer_1.Lexer.TOKEN_HORIZONTAL_WS];
+    }
+    forwardToTheEnd() {
+        const lastToken = this.tokens.length - 1;
+        this.index = lastToken;
+    }
+    pushSavePoint() {
+        this.savePoints.push(this.index);
+    }
+    dropSavePoint() {
+        this.savePoints.pop();
+    }
+    rollback() {
+        const index = this.savePoints.pop();
+        this.index = index;
+    }
+    throwError(expectedTokenType, expectedTokenValue = null) {
+        throw new parser_exception_1.ParserException(this.currentTokenValue(), this.currentTokenType(), this.currentTokenOffset(), expectedTokenType, expectedTokenValue, this.currentTokenLine());
+    }
+    hasTokenImmediatelyBefore(pos, expectedTokenType) {
+        const { tokens } = this;
+        pos--;
+        for (; pos >= 0; pos--) {
+            const token = tokens[pos];
+            const type = token[1];
+            if (type === expectedTokenType) {
+                return true;
+            }
+            if (![lexer_1.Lexer.TOKEN_HORIZONTAL_WS, lexer_1.Lexer.TOKEN_PHPDOC_EOL].includes(type)) {
+                break;
+            }
+        }
+        return false;
+    }
+    hasTokenImmediatelyAfter(pos, expectedTokenType) {
+        const { tokens } = this;
+        pos++;
+        for (let c = tokens.length; pos < c; pos++) {
+            const token = tokens[pos];
+            const type = token[1];
+            if (type === expectedTokenType) {
+                return true;
+            }
+            if (![lexer_1.Lexer.TOKEN_HORIZONTAL_WS, lexer_1.Lexer.TOKEN_PHPDOC_EOL].includes(type)) {
+                break;
+            }
+        }
+        return false;
+    }
+    getDetectedNewline() {
+        return this.newline;
+    }
+    hasParentheses(startPos, endPos) {
+        return (this.hasTokenImmediatelyBefore(startPos, lexer_1.Lexer.TOKEN_OPEN_PARENTHESES) &&
+            this.hasTokenImmediatelyAfter(endPos, lexer_1.Lexer.TOKEN_CLOSE_PARENTHESES));
+    }
+}
+exports.TokenIterator = TokenIterator;

package/dist/phpdoc-parser/parser/type-parser.d.ts

@@ -0,0 +1,41 @@
+import { ConstExprParser } from './const-expr-parser';
+import { TokenIterator } from './token-iterator';
+import { BaseNode } from '../ast/base-node';
+import { GenericTypeNode } from '../ast/type/generic-type-node';
+import { IdentifierTypeNode } from '../ast/type/identifier-type-node';
+import { TypeNode } from '../ast/type/type-node';
+export declare class TypeParser {
+    private constExprParser;
+    private quoteAwareConstExprString;
+    private useLinesAttributes;
+    private useIndexAttributes;
+    constructor(constExprParser?: ConstExprParser | null, quoteAwareConstExprString?: boolean, usedAttributes?: {
+        lines?: boolean;
+        indexes?: boolean;
+    });
+    parse(tokens: TokenIterator): TypeNode;
+    enrichWithAttributes<T extends BaseNode>(tokens: TokenIterator, type: T, startLine: number, startIndex: number): T;
+    private subParse;
+    private parseAtomic;
+    private parseUnion;
+    private subParseUnion;
+    private parseIntersection;
+    private subParseIntersection;
+    private parseConditional;
+    private parseConditionalForParameter;
+    private parseNullable;
+    isHtml(tokens: TokenIterator): boolean;
+    parseGeneric(tokens: TokenIterator, baseType: IdentifierTypeNode): GenericTypeNode;
+    private parseGenericTypeArgument;
+    private parseCallable;
+    private parseCallableParameter;
+    private parseCallableReturnType;
+    private tryParseCallable;
+    private tryParseArrayOrOffsetAccess;
+    private parseArrayShape;
+    private parseArrayShapeItem;
+    private parseArrayShapeKey;
+    private parseObjectShape;
+    private parseObjectShapeItem;
+    private parseObjectShapeKey;
+}