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

package/dist/phpdoc-parser/ast/type/invalid-type-node.js

@@ -27,4 +27,3 @@ class InvalidTypeNode extends type_node_1.TypeNode {
     }
 }
 exports.InvalidTypeNode = InvalidTypeNode;
-//# sourceMappingURL=invalid-type-node.js.map

package/dist/phpdoc-parser/ast/type/nullable-type-node.js

@@ -8,11 +8,10 @@ class NullableTypeNode extends type_node_1.TypeNode {
         this.type = type;
     }
     toString() {
-        return `?${this.type}`;
+        return `?${this.type.toString()}`;
     }
     getNodeType() {
         return 'NullableTypeNode';
     }
 }
 exports.NullableTypeNode = NullableTypeNode;
-//# sourceMappingURL=nullable-type-node.js.map

package/dist/phpdoc-parser/ast/type/object-shape-item-node.js

@@ -11,7 +11,7 @@ class ObjectShapeItemNode extends type_node_1.TypeNode {
     }
     toString() {
         if (this.keyName !== null) {
-            return `${this.keyName}${this.optional ? '?' : ''}: ${this.valueType}`;
+            return `${this.keyName.toString()}${this.optional ? '?' : ''}: ${this.valueType.toString()}`;
         }
         return this.valueType.toString();
     }
@@ -20,4 +20,3 @@ class ObjectShapeItemNode extends type_node_1.TypeNode {
     }
 }
 exports.ObjectShapeItemNode = ObjectShapeItemNode;
-//# sourceMappingURL=object-shape-item-node.js.map

package/dist/phpdoc-parser/ast/type/object-shape-node.js

@@ -15,4 +15,3 @@ class ObjectShapeNode extends type_node_1.TypeNode {
     }
 }
 exports.ObjectShapeNode = ObjectShapeNode;
-//# sourceMappingURL=object-shape-node.js.map

package/dist/phpdoc-parser/ast/type/offset-access-type-node.js

@@ -15,13 +15,12 @@ class OffsetAccessTypeNode extends type_node_1.TypeNode {
         if (this.type instanceof callable_type_node_1.CallableTypeNode ||
             this.type instanceof const_type_node_1.ConstTypeNode ||
             this.type instanceof nullable_type_node_1.NullableTypeNode) {
-            return `(${this.type})[${this.offset}]`;
+            return `(${this.type.toString()})[${this.offset.toString()}]`;
         }
-        return `${this.type}[${this.offset}]`;
+        return `${this.type.toString()}[${this.offset.toString()}]`;
     }
     getNodeType() {
         return 'OffsetAccessTypeNode';
     }
 }
 exports.OffsetAccessTypeNode = OffsetAccessTypeNode;
-//# sourceMappingURL=offset-access-type-node.js.map

package/dist/phpdoc-parser/ast/type/this-type-node.js

@@ -11,4 +11,3 @@ class ThisTypeNode extends type_node_1.TypeNode {
     }
 }
 exports.ThisTypeNode = ThisTypeNode;
-//# sourceMappingURL=this-type-node.js.map

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

@@ -62,4 +62,3 @@ class TypeNode extends base_node_1.BaseNode {
     }
 }
 exports.TypeNode = TypeNode;
-//# sourceMappingURL=type-node.js.map

package/dist/phpdoc-parser/ast/type/union-type-node.js

@@ -23,4 +23,3 @@ class UnionTypeNode extends type_node_1.TypeNode {
     }
 }
 exports.UnionTypeNode = UnionTypeNode;
-//# sourceMappingURL=union-type-node.js.map

package/dist/phpdoc-parser/ast/types.js

@@ -16,4 +16,3 @@ var Attribute;
     Attribute["END_INDEX"] = "endIndex";
     Attribute["ORIGINAL_NODE"] = "originalNode";
 })(Attribute || (exports.Attribute = Attribute = {}));
-//# sourceMappingURL=types.js.map

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

@@ -141,4 +141,3 @@ Lexer.TOKEN_LABELS = {
 Lexer.VALUE_OFFSET = 0;
 Lexer.TYPE_OFFSET = 1;
 Lexer.LINE_OFFSET = 2;
-//# sourceMappingURL=lexer.js.map

package/dist/phpdoc-parser/parser/const-expr-parser.js

@@ -144,4 +144,3 @@ class ConstExprParser {
     }
 }
 exports.ConstExprParser = ConstExprParser;
-//# sourceMappingURL=const-expr-parser.js.map

package/dist/phpdoc-parser/parser/node-collecting-visitor.js

@@ -13,4 +13,3 @@ class NodeCollectingVisitor extends abstract_node_visitor_1.AbstractNodeVisitor
     }
 }
 exports.NodeCollectingVisitor = NodeCollectingVisitor;
-//# sourceMappingURL=node-collecting-visitor.js.map

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

@@ -42,4 +42,3 @@ class ParserException extends Error {
     }
 }
 exports.ParserException = ParserException;
-//# sourceMappingURL=parser-exception.js.map

package/dist/phpdoc-parser/parser/php-doc-parser.d.ts

@@ -10,12 +10,14 @@ export declare class PhpDocParser {
     requireWhitespaceBeforeDescription: boolean;
     preserveTypeAliasesWithInvalidTypes: boolean;
     parseDoctrineAnnotations: boolean;
+    private textBetweenTagsBelongsToDescription;
     private useLinesAttributes;
     private useIndexAttributes;
+    private static readonly DISALLOWED_DESCRIPTION_START_TOKENS;
     constructor(typeParser: TypeParser, constantExprParser: ConstExprParser, requireWhitespaceBeforeDescription?: boolean, preserveTypeAliasesWithInvalidTypes?: boolean, usedAttributes?: {
         lines: boolean;
         indexes: boolean;
-    }, parseDoctrineAnnotations?: boolean);
+    }, parseDoctrineAnnotations?: boolean, textBetweenTagsBelongsToDescription?: boolean);
     parse(tokens: TokenIterator): PhpDocNode;
     private parseChild;
     private enrichWithAttributes;

package/dist/phpdoc-parser/parser/php-doc-parser.js

@@ -39,13 +39,14 @@ class PhpDocParser {
     constructor(typeParser, constantExprParser, requireWhitespaceBeforeDescription = false, preserveTypeAliasesWithInvalidTypes = false, usedAttributes = {
         lines: false,
         indexes: false,
-    }, parseDoctrineAnnotations = false) {
+    }, parseDoctrineAnnotations = false, textBetweenTagsBelongsToDescription = false) {
         var _a, _b;
         this.typeParser = typeParser;
         this.constantExprParser = constantExprParser;
         this.requireWhitespaceBeforeDescription = requireWhitespaceBeforeDescription;
         this.preserveTypeAliasesWithInvalidTypes = preserveTypeAliasesWithInvalidTypes;
         this.parseDoctrineAnnotations = parseDoctrineAnnotations;
+        this.textBetweenTagsBelongsToDescription = textBetweenTagsBelongsToDescription;
         this.useLinesAttributes = (_a = usedAttributes.lines) !== null && _a !== void 0 ? _a : false;
         this.useIndexAttributes = (_b = usedAttributes.indexes) !== null && _b !== void 0 ? _b : false;
     }
@@ -54,38 +55,45 @@ class PhpDocParser {
         tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
         const children = [];
         if (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_CLOSE_PHPDOC)) {
-            let lastChild = this.parseChild(tokens);
-            children.push(lastChild);
-            while (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_CLOSE_PHPDOC)) {
-                if (lastChild instanceof php_doc_tag_node_1.PhpDocTagNode &&
-                    lastChild.value instanceof generic_tag_value_node_1.GenericTagValueNode) {
-                    tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
-                    if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_CLOSE_PHPDOC)) {
-                        break;
-                    }
-                    lastChild = this.parseChild(tokens);
-                    children.push(lastChild);
-                    continue;
-                }
-                if (!tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL)) {
-                    break;
-                }
-                if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_CLOSE_PHPDOC)) {
-                    break;
+            children.push(this.parseChild(tokens));
+            while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL) &&
+                !tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_CLOSE_PHPDOC)) {
+                children.push(this.parseChild(tokens));
+            }
+        }
+        try {
+            tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_PHPDOC);
+        }
+        catch (error) {
+            let name = '';
+            let startLine = tokens.currentTokenLine();
+            let startIndex = tokens.currentTokenIndex();
+            if (children.length > 0) {
+                const lastChild = children[children.length - 1];
+                if (lastChild instanceof php_doc_tag_node_1.PhpDocTagNode) {
+                    name = lastChild.name;
+                    startLine = tokens.currentTokenLine();
+                    startIndex = tokens.currentTokenIndex();
                 }
-                lastChild = this.parseChild(tokens);
-                children.push(lastChild);
             }
+            const tag = new php_doc_tag_node_1.PhpDocTagNode(name, this.enrichWithAttributes(tokens, new invalid_tag_value_node_1.InvalidTagValueNode(`${error === null || error === void 0 ? void 0 : error.message}`, error), startLine, startIndex));
+            tokens.forwardToTheEnd();
+            return this.enrichWithAttributes(tokens, new php_doc_node_1.PhpDocNode([
+                this.enrichWithAttributes(tokens, tag, startLine, startIndex),
+            ]), 1, 0);
         }
-        tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_PHPDOC);
-        return new php_doc_node_1.PhpDocNode(children);
+        return this.enrichWithAttributes(tokens, new php_doc_node_1.PhpDocNode(children), 1, 0);
     }
     parseChild(tokens) {
         if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_PHPDOC_TAG)) {
-            return this.parseTag(tokens);
+            const startLine = tokens.currentTokenLine();
+            const startIndex = tokens.currentTokenIndex();
+            return this.enrichWithAttributes(tokens, this.parseTag(tokens), startLine, startIndex);
         }
+        const startLine = tokens.currentTokenLine();
+        const startIndex = tokens.currentTokenIndex();
         const text = this.parseText(tokens);
-        return text;
+        return this.enrichWithAttributes(tokens, text, startLine, startIndex);
     }
     enrichWithAttributes(tokens, node, startLine, startIndex) {
         if (this.useLinesAttributes) {
@@ -99,23 +107,48 @@ class PhpDocParser {
         return node;
     }
     parseText(tokens) {
-        var _a;
+        var _a, _b;
         let text = '';
-        while (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL)) {
-            text += tokens.getSkippedHorizontalWhiteSpaceIfAny();
-            text += tokens.joinUntil(lexer_1.Lexer.TOKEN_PHPDOC_EOL, lexer_1.Lexer.TOKEN_CLOSE_PHPDOC, lexer_1.Lexer.TOKEN_END);
+        let endTokens = [
+            lexer_1.Lexer.TOKEN_PHPDOC_EOL,
+            lexer_1.Lexer.TOKEN_CLOSE_PHPDOC,
+            lexer_1.Lexer.TOKEN_END,
+        ];
+        if (this.textBetweenTagsBelongsToDescription) {
+            endTokens = [lexer_1.Lexer.TOKEN_CLOSE_PHPDOC, lexer_1.Lexer.TOKEN_END];
+        }
+        let savepoint = false;
+        while (this.textBetweenTagsBelongsToDescription ||
+            !tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL)) {
+            const tmpText = tokens.getSkippedHorizontalWhiteSpaceIfAny() +
+                tokens.joinUntil(lexer_1.Lexer.TOKEN_PHPDOC_EOL, ...endTokens);
+            text += tmpText;
             if (!tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL)) {
                 break;
             }
+            if (this.textBetweenTagsBelongsToDescription) {
+                if (!savepoint) {
+                    tokens.pushSavePoint();
+                    savepoint = true;
+                }
+                else if (tmpText !== '') {
+                    tokens.dropSavePoint();
+                    tokens.pushSavePoint();
+                }
+            }
             tokens.pushSavePoint();
             tokens.next();
-            if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_PHPDOC_TAG, lexer_1.Lexer.TOKEN_PHPDOC_EOL, lexer_1.Lexer.TOKEN_CLOSE_PHPDOC, lexer_1.Lexer.TOKEN_END)) {
+            if (tokens.isCurrentTokenType(lexer_1.Lexer.TOKEN_PHPDOC_TAG, ...endTokens)) {
                 tokens.rollback();
                 break;
             }
             tokens.dropSavePoint();
             text += (_a = tokens.getDetectedNewline()) !== null && _a !== void 0 ? _a : '\n';
         }
+        if (savepoint) {
+            tokens.rollback();
+            text = text.replace(new RegExp(`[${(_b = tokens.getDetectedNewline()) !== null && _b !== void 0 ? _b : '\n'}]+$`, 'g'), '');
+        }
         return new php_doc_text_node_1.PhpDocTextNode(text.trim());
     }
     parseTag(tokens) {
@@ -284,8 +317,8 @@ class PhpDocParser {
     }
     parseMethodTagValue(tokens) {
         let isStatic = tokens.tryConsumeTokenValue('static');
-        const startLine = tokens.currentTokenLine();
-        const startIndex = tokens.currentTokenIndex();
+        let startLine = tokens.currentTokenLine();
+        let startIndex = tokens.currentTokenIndex();
         const returnTypeOrName = this.typeParser.parse(tokens);
         let returnType;
         let name;
@@ -307,8 +340,8 @@ class PhpDocParser {
         const templateTypes = [];
         if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_OPEN_ANGLE_BRACKET)) {
             do {
-                const startLine = tokens.currentTokenLine();
-                const startIndex = tokens.currentTokenIndex();
+                startLine = tokens.currentTokenLine();
+                startIndex = tokens.currentTokenIndex();
                 const templateType = this.parseTemplateTagValue(tokens, false);
                 templateTypes.push(this.enrichWithAttributes(tokens, templateType, startLine, startIndex));
             } while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA));
@@ -320,8 +353,7 @@ class PhpDocParser {
             const parameter = this.parseMethodTagValueParameter(tokens);
             parameters.push(parameter);
             while (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_COMMA)) {
-                const parameter = this.parseMethodTagValueParameter(tokens);
-                parameters.push(parameter);
+                parameters.push(this.parseMethodTagValueParameter(tokens));
             }
         }
         tokens.consumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_PARENTHESES);
@@ -520,4 +552,7 @@ class PhpDocParser {
     }
 }
 exports.PhpDocParser = PhpDocParser;
-//# sourceMappingURL=php-doc-parser.js.map
+PhpDocParser.DISALLOWED_DESCRIPTION_START_TOKENS = [
+    lexer_1.Lexer.TOKEN_UNION,
+    lexer_1.Lexer.TOKEN_INTERSECTION,
+];

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

@@ -39,4 +39,3 @@ StringUnescaper.REPLACEMENTS = {
     v: '\v',
     e: '\x1B',
 };
-//# sourceMappingURL=string-unescaper.js.map

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

@@ -213,4 +213,3 @@ class TokenIterator {
     }
 }
 exports.TokenIterator = TokenIterator;
-//# sourceMappingURL=token-iterator.js.map

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

@@ -262,9 +262,9 @@ class TypeParser {
             if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_CLOSE_ANGLE_BRACKET)) {
                 break;
             }
-            const [genericType, variance] = this.parseGenericTypeArgument(tokens);
-            genericTypes.push(genericType);
-            variances.push(variance);
+            const [genericTypeToAddInWhileLoop, varianceToAddInWhileLoop] = this.parseGenericTypeArgument(tokens);
+            genericTypes.push(genericTypeToAddInWhileLoop);
+            variances.push(varianceToAddInWhileLoop);
             tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
         }
         tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_PHPDOC_EOL);
@@ -350,7 +350,7 @@ class TypeParser {
             return type;
         }
         if (tokens.tryConsumeTokenType(lexer_1.Lexer.TOKEN_THIS_VARIABLE)) {
-            let type = new this_type_node_1.ThisTypeNode();
+            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));
             }
@@ -574,4 +574,3 @@ class TypeParser {
     }
 }
 exports.TypeParser = TypeParser;
-//# sourceMappingURL=type-parser.js.map

package/dist/phpdoc-parser/printer/diff-elem.d.ts

@@ -0,0 +1,12 @@
+export declare class DiffElem<EleType> {
+    type: DiffElemType;
+    old: EleType;
+    new: EleType;
+    constructor(type: DiffElemType, oldEle: EleType, newEle: EleType);
+}
+export declare enum DiffElemType {
+    KEEP = 1,
+    REMOVE = 2,
+    ADD = 3,
+    REPLACE = 4
+}

package/dist/phpdoc-parser/printer/diff-elem.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffElemType = exports.DiffElem = void 0;
+class DiffElem {
+    constructor(type, oldEle, newEle) {
+        this.type = type;
+        this.type = type;
+        this.old = oldEle;
+        this.new = newEle;
+    }
+}
+exports.DiffElem = DiffElem;
+var DiffElemType;
+(function (DiffElemType) {
+    DiffElemType[DiffElemType["KEEP"] = 1] = "KEEP";
+    DiffElemType[DiffElemType["REMOVE"] = 2] = "REMOVE";
+    DiffElemType[DiffElemType["ADD"] = 3] = "ADD";
+    DiffElemType[DiffElemType["REPLACE"] = 4] = "REPLACE";
+})(DiffElemType || (exports.DiffElemType = DiffElemType = {}));

package/dist/phpdoc-parser/printer/differ.d.ts

@@ -0,0 +1,10 @@
+import { DiffElem } from './diff-elem';
+export declare class Differ<T> {
+    private isEqual;
+    constructor(isEqual: (a: T, b: T) => boolean);
+    diff(old: T[], newElements: T[]): DiffElem<T>[];
+    diffWithReplacements(old: T[], newElements: T[]): DiffElem<T>[];
+    private calculateTrace;
+    private extractDiff;
+    private coalesceReplacements;
+}

package/dist/phpdoc-parser/printer/differ.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Differ = void 0;
+const diff_elem_1 = require("./diff-elem");
+class Differ {
+    constructor(isEqual) {
+        this.isEqual = isEqual;
+    }
+    diff(old, newElements) {
+        const [trace, x, y] = this.calculateTrace(old, newElements);
+        return this.extractDiff(trace, x, y, old, newElements);
+    }
+    diffWithReplacements(old, newElements) {
+        return this.coalesceReplacements(this.diff(old, newElements));
+    }
+    calculateTrace(old, newElements) {
+        const n = old.length;
+        const m = newElements.length;
+        const max = n + m;
+        const v = { 1: 0 };
+        const trace = [];
+        for (let d = 0; d <= max; d++) {
+            trace.push(Object.assign({}, v));
+            for (let k = -d; k <= d; k += 2) {
+                let x;
+                if (k === -d || (k !== d && v[k - 1] < v[k + 1])) {
+                    x = v[k + 1];
+                }
+                else {
+                    x = v[k - 1] + 1;
+                }
+                let y = x - k;
+                while (x < n && y < m && this.isEqual(old[x], newElements[y])) {
+                    x++;
+                    y++;
+                }
+                v[k] = x;
+                if (x >= n && y >= m) {
+                    return [trace, x, y];
+                }
+            }
+        }
+        throw new Error('Should not happen');
+    }
+    extractDiff(trace, x, y, old, newElements) {
+        const result = [];
+        for (let d = trace.length - 1; d >= 0; d--) {
+            const v = trace[d];
+            const k = x - y;
+            let prevK;
+            if (k === -d || (k !== d && v[k - 1] < v[k + 1])) {
+                prevK = k + 1;
+            }
+            else {
+                prevK = k - 1;
+            }
+            const prevX = v[prevK];
+            const prevY = prevX - prevK;
+            while (x > prevX && y > prevY) {
+                result.push(new diff_elem_1.DiffElem(diff_elem_1.DiffElemType.KEEP, old[x - 1], newElements[y - 1]));
+                x--;
+                y--;
+            }
+            if (d === 0) {
+                break;
+            }
+            while (x > prevX) {
+                result.push(new diff_elem_1.DiffElem(diff_elem_1.DiffElemType.REMOVE, old[x - 1], null));
+                x--;
+            }
+            while (y > prevY) {
+                result.push(new diff_elem_1.DiffElem(diff_elem_1.DiffElemType.ADD, null, newElements[y - 1]));
+                y--;
+            }
+        }
+        return result.reverse();
+    }
+    coalesceReplacements(diff) {
+        const newDiff = [];
+        const c = diff.length;
+        for (let i = 0; i < c; i++) {
+            const diffType = diff[i].type;
+            if (diffType !== diff_elem_1.DiffElemType.REMOVE) {
+                newDiff.push(diff[i]);
+                continue;
+            }
+            let j = i;
+            while (j < c && diff[j].type === diff_elem_1.DiffElemType.REMOVE) {
+                j++;
+            }
+            let k = j;
+            while (k < c && diff[k].type === diff_elem_1.DiffElemType.ADD) {
+                k++;
+            }
+            if (j - i === k - j) {
+                const len = j - i;
+                for (let n = 0; n < len; n++) {
+                    newDiff.push(new diff_elem_1.DiffElem(diff_elem_1.DiffElemType.REPLACE, diff[i + n].old, diff[j + n].new));
+                }
+            }
+            else {
+                for (; i < k; i++) {
+                    newDiff.push(diff[i]);
+                }
+            }
+            i = k - 1;
+        }
+        return newDiff;
+    }
+}
+exports.Differ = Differ;

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

@@ -0,0 +1,20 @@
+import { BaseNode } from '../ast/base-node';
+import { PhpDocNode } from '../ast/php-doc/php-doc-node';
+import { TokenIterator } from '../parser/token-iterator';
+export declare class Printer {
+    private differ;
+    private listInsertionMap;
+    private emptyListInsertionMap;
+    private parenthesesMap;
+    private parenthesesListMap;
+    printFormatPreserving(node: PhpDocNode, originalNode: PhpDocNode, originalTokens: TokenIterator): string;
+    print(node: BaseNode): string;
+    private printTagValue;
+    private printType;
+    private wrapInParentheses;
+    private printOffsetAccessType;
+    private printConstExpr;
+    private printArrayFormatPreserving;
+    private isMultiline;
+    private printNodeFormatPreserving;
+}