@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/ast/node-traverser.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeTraverser = void 0;
+const base_node_1 = require("./base-node");
+const const_expr_node_1 = require("./const-expr/const-expr-node");
+const php_doc_child_node_1 = require("./php-doc/php-doc-child-node");
+const php_doc_tag_value_node_1 = require("./php-doc/php-doc-tag-value-node");
+const type_node_1 = require("./type/type-node");
+class NodeTraverser {
+    constructor(visitors) {
+        this.visitors = visitors;
+    }
+    traverse(nodes) {
+        this.stopTraversal = false;
+        for (const visitor of this.visitors) {
+            const returned = visitor.beforeTraverse(nodes);
+            if (returned !== null) {
+                nodes = returned;
+            }
+        }
+        nodes = this.traverseArray(nodes);
+        for (const visitor of this.visitors) {
+            const returned = visitor.afterTraverse(nodes);
+            if (returned !== null) {
+                nodes = returned;
+            }
+        }
+        return nodes;
+    }
+    traverseNode(node) {
+        const subNodeNames = Object.keys(node);
+        for (const name of subNodeNames) {
+            if (name === 'attributes') {
+                continue;
+            }
+            let subNode = node[name];
+            if (Array.isArray(subNode)) {
+                subNode = this.traverseArray(subNode);
+                if (this.stopTraversal) {
+                    break;
+                }
+            }
+            else if (subNode instanceof base_node_1.BaseNode) {
+                let traverseChildren = true;
+                let breakVisitorIndex = null;
+                for (let visitorIndex = 0; visitorIndex < this.visitors.length; ++visitorIndex) {
+                    const visitor = this.visitors[visitorIndex];
+                    const enterNodeResult = visitor.enterNode(subNode);
+                    if (enterNodeResult === null) {
+                        continue;
+                    }
+                    switch (enterNodeResult) {
+                        case 1:
+                            traverseChildren = false;
+                            break;
+                        case 4:
+                            traverseChildren = false;
+                            breakVisitorIndex = visitorIndex;
+                            break;
+                        case 2:
+                            this.stopTraversal = true;
+                            break;
+                        default:
+                            if (enterNodeResult instanceof base_node_1.BaseNode) {
+                                this.ensureReplacementReasonable(subNode, enterNodeResult);
+                                subNode = enterNodeResult;
+                            }
+                            else {
+                                throw new Error(`enterNode() returned invalid value of type ${typeof enterNodeResult}: value=${JSON.stringify(enterNodeResult, undefined, 2)}`);
+                            }
+                    }
+                    if (this.stopTraversal) {
+                        break;
+                    }
+                }
+                if (traverseChildren) {
+                    subNode = this.traverseNode(subNode);
+                    if (this.stopTraversal) {
+                        break;
+                    }
+                }
+                for (let visitorIndex = 0; visitorIndex < this.visitors.length; ++visitorIndex) {
+                    const visitor = this.visitors[visitorIndex];
+                    const leaveNodeResult = visitor.leaveNode(subNode);
+                    if (leaveNodeResult != null) {
+                        if (leaveNodeResult instanceof base_node_1.BaseNode) {
+                            this.ensureReplacementReasonable(subNode, leaveNodeResult);
+                            subNode = leaveNodeResult;
+                        }
+                        else if (leaveNodeResult === 2) {
+                            this.stopTraversal = true;
+                            break;
+                        }
+                        else if (Array.isArray(leaveNodeResult)) {
+                            throw new Error('leaveNode() may only return an array ' +
+                                'if the parent structure is an array');
+                        }
+                        else {
+                            throw new Error(`leaveNode() returned invalid value of type ${typeof leaveNodeResult}`);
+                        }
+                    }
+                    if (breakVisitorIndex === visitorIndex) {
+                        break;
+                    }
+                }
+            }
+            node[name] = subNode;
+        }
+        return node;
+    }
+    traverseArray(nodes) {
+        const doNodes = [];
+        for (let i = 0; i < nodes.length; i++) {
+            let node = nodes[i];
+            if (node instanceof base_node_1.BaseNode) {
+                let traverseChildren = true;
+                let breakVisitorIndex = null;
+                for (let visitorIndex = 0; visitorIndex < this.visitors.length; visitorIndex++) {
+                    const visitor = this.visitors[visitorIndex];
+                    const returnVal = visitor.enterNode(node);
+                    if (returnVal === null) {
+                        continue;
+                    }
+                    if (returnVal instanceof base_node_1.BaseNode) {
+                        this.ensureReplacementReasonable(node, returnVal);
+                        node = returnVal;
+                    }
+                    else if (Array.isArray(returnVal)) {
+                        doNodes.push([i, returnVal]);
+                        continue;
+                    }
+                    else if (returnVal === 3) {
+                        doNodes.push([i, []]);
+                        continue;
+                    }
+                    else if (returnVal === 1) {
+                        traverseChildren = false;
+                    }
+                    else if (returnVal === 4) {
+                        traverseChildren = false;
+                        breakVisitorIndex = visitorIndex;
+                        break;
+                    }
+                    else if (returnVal === 2) {
+                        this.stopTraversal = true;
+                        break;
+                    }
+                    else {
+                        throw new Error(`enterNode returned invalid value of type ${typeof returnVal}`);
+                    }
+                }
+                if (traverseChildren) {
+                    node = this.traverseNode(node);
+                    if (this.stopTraversal) {
+                        break;
+                    }
+                }
+                for (let visitorIndex = 0; visitorIndex < this.visitors.length; visitorIndex++) {
+                    const visitor = this.visitors[visitorIndex];
+                    const returnVal = visitor.leaveNode(node);
+                    if (returnVal !== null) {
+                        if (returnVal instanceof base_node_1.BaseNode) {
+                            this.ensureReplacementReasonable(node, returnVal);
+                            node = returnVal;
+                        }
+                        else if (Array.isArray(returnVal)) {
+                            doNodes.push([i, returnVal]);
+                            break;
+                        }
+                        else if (returnVal === 3) {
+                            doNodes.push([i, []]);
+                            break;
+                        }
+                        else if (returnVal === 2) {
+                            this.stopTraversal = true;
+                            break;
+                        }
+                        else {
+                            throw new Error(`leaveNode returned invalid value of type ${typeof returnVal}`);
+                        }
+                    }
+                    if (breakVisitorIndex === visitorIndex) {
+                        break;
+                    }
+                }
+            }
+            else if (Array.isArray(node)) {
+                throw new Error('Invalid node structure: Contains nested arrays');
+            }
+        }
+        if (doNodes.length > 0) {
+            while (doNodes.length > 0) {
+                const [i, replace] = doNodes.pop();
+                nodes = [...nodes.slice(0, i), ...replace, ...nodes.slice(i + 1)];
+            }
+        }
+        return nodes;
+    }
+    ensureReplacementReasonable(old, newNode) {
+        if (old instanceof type_node_1.TypeNode && !(newNode instanceof type_node_1.TypeNode)) {
+            throw new Error(`Trying to replace TypeNode with ${newNode.constructor.name}`);
+        }
+        if (old instanceof const_expr_node_1.ConstExprNode && !(newNode instanceof const_expr_node_1.ConstExprNode)) {
+            throw new Error(`Trying to replace ConstExprNode with ${newNode.constructor.name}`);
+        }
+        if (old instanceof php_doc_child_node_1.PhpDocChildNode &&
+            !(newNode instanceof php_doc_child_node_1.PhpDocChildNode)) {
+            throw new Error(`Trying to replace PhpDocChildNode with ${newNode.constructor.name}`);
+        }
+        if (old instanceof php_doc_tag_value_node_1.PhpDocTagValueNode &&
+            !(newNode instanceof php_doc_tag_value_node_1.PhpDocTagValueNode)) {
+            throw new Error(`Trying to replace PhpDocTagValueNode with ${newNode.constructor.name}`);
+        }
+    }
+}
+exports.NodeTraverser = NodeTraverser;

package/dist/phpdoc-parser/ast/node-visitor/cloning-visitor.d.ts

@@ -0,0 +1,5 @@
+import { AbstractNodeVisitor } from '../abstract-node-visitor';
+import { Node } from '../node';
+export declare class CloningVisitor extends AbstractNodeVisitor {
+    enterNode(originalNode: Node): Node;
+}

package/dist/phpdoc-parser/ast/node-visitor/cloning-visitor.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CloningVisitor = void 0;
+const lodash_1 = require("lodash");
+const abstract_node_visitor_1 = require("../abstract-node-visitor");
+const types_1 = require("../types");
+class CloningVisitor extends abstract_node_visitor_1.AbstractNodeVisitor {
+    enterNode(originalNode) {
+        const node = (0, lodash_1.cloneDeep)(originalNode);
+        node.setAttribute(types_1.Attribute.ORIGINAL_NODE, originalNode);
+        return node;
+    }
+}
+exports.CloningVisitor = CloningVisitor;

package/dist/phpdoc-parser/ast/node-visitor.d.ts

@@ -0,0 +1,11 @@
+import { Node } from './node';
+import { NodeTraverserState } from './types';
+export type NodeTraverserEnterReturn = Node | Node[] | null | NodeTraverserState;
+export type NodeTraverserLeaveReturn = Node | Node[] | null | NodeTraverserState.REMOVE_NODE | NodeTraverserState.STOP_TRAVERSAL;
+export type NodeTraverserBeforeAfterReturn = Node[] | null;
+export interface NodeVisitor {
+    beforeTraverse(nodes: Node[]): NodeTraverserBeforeAfterReturn;
+    enterNode(node: Node): NodeTraverserEnterReturn;
+    leaveNode(node: Node): NodeTraverserLeaveReturn;
+    afterTraverse(nodes: Node[]): NodeTraverserBeforeAfterReturn;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/phpdoc-parser/ast/node.d.ts

@@ -0,0 +1,6 @@
+export interface Node {
+    toString(): string;
+    setAttribute(key: string, value: unknown): void;
+    hasAttribute(key: string): boolean;
+    getAttribute(key: string): unknown;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/phpdoc-parser/ast/php-doc/assert-tag-method-value-node.d.ts

@@ -0,0 +1,13 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { TypeNode } from '../type/type-node';
+export declare class AssertTagMethodValueNode extends PhpDocTagValueNode {
+    type: TypeNode;
+    parameter: string;
+    method: string;
+    isNegated: boolean;
+    description: string;
+    isEquality: boolean;
+    constructor(type: TypeNode, parameter: string, method: string, isNegated: boolean, description: string, isEquality?: boolean);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/assert-tag-method-value-node.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertTagMethodValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class AssertTagMethodValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(type, parameter, method, isNegated, description, isEquality = false) {
+        super();
+        this.type = type;
+        this.parameter = parameter;
+        this.method = method;
+        this.isNegated = isNegated;
+        this.description = description;
+        this.isEquality = isEquality;
+    }
+    toString() {
+        const isNegated = this.isNegated ? '!' : '';
+        const isEquality = this.isEquality ? '=' : '';
+        return `${isNegated}${isEquality}${this.type.toString()} ${this.parameter}->${this.method}() ${this.description}`.trim();
+    }
+    getNodeType() {
+        return 'AssertTagMethodValueNode';
+    }
+}
+exports.AssertTagMethodValueNode = AssertTagMethodValueNode;

package/dist/phpdoc-parser/ast/php-doc/assert-tag-property-value-node.d.ts

@@ -0,0 +1,13 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { TypeNode } from '../type/type-node';
+export declare class AssertTagPropertyValueNode extends PhpDocTagValueNode {
+    type: TypeNode;
+    parameter: string;
+    property: string;
+    isNegated: boolean;
+    description: string;
+    isEquality: boolean;
+    constructor(type: TypeNode, parameter: string, property: string, isNegated: boolean, description: string, isEquality?: boolean);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/assert-tag-property-value-node.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertTagPropertyValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class AssertTagPropertyValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(type, parameter, property, isNegated, description, isEquality = false) {
+        super();
+        this.type = type;
+        this.parameter = parameter;
+        this.property = property;
+        this.isNegated = isNegated;
+        this.description = description;
+        this.isEquality = isEquality;
+    }
+    toString() {
+        const isNegated = this.isNegated ? '!' : '';
+        const isEquality = this.isEquality ? '=' : '';
+        return `${isNegated}${isEquality}${this.type.toString()} ${this.parameter}->${this.property} ${this.description}`.trim();
+    }
+    getNodeType() {
+        return 'AssertTagPropertyValueNode';
+    }
+}
+exports.AssertTagPropertyValueNode = AssertTagPropertyValueNode;

package/dist/phpdoc-parser/ast/php-doc/assert-tag-value-node.d.ts

@@ -0,0 +1,12 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { TypeNode } from '../type/type-node';
+export declare class AssertTagValueNode extends PhpDocTagValueNode {
+    type: TypeNode;
+    parameter: string;
+    isNegated: boolean;
+    isEquality: boolean;
+    description: string;
+    constructor(type: TypeNode, parameter: string, isNegated: boolean, description: string, isEquality?: boolean);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/assert-tag-value-node.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class AssertTagValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(type, parameter, isNegated, description, isEquality = false) {
+        super();
+        this.type = type;
+        this.parameter = parameter;
+        this.isNegated = isNegated;
+        this.isEquality = isEquality;
+        this.description = description;
+    }
+    toString() {
+        const isNegated = this.isNegated ? '!' : '';
+        const isEquality = this.isEquality ? '=' : '';
+        return `${isNegated}${isEquality}${this.type.toString()} ${this.parameter} ${this.description}`.trim();
+    }
+    getNodeType() {
+        return 'AssertTagValueNode';
+    }
+}
+exports.AssertTagValueNode = AssertTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/deprecated-tag-value-node.d.ts

@@ -0,0 +1,7 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+export declare class DeprecatedTagValueNode extends PhpDocTagValueNode {
+    description: string;
+    constructor(description: string);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/deprecated-tag-value-node.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeprecatedTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class DeprecatedTagValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(description) {
+        super();
+        this.description = description;
+    }
+    toString() {
+        return this.description.trim();
+    }
+    getNodeType() {
+        return 'DeprecatedTagValueNode';
+    }
+}
+exports.DeprecatedTagValueNode = DeprecatedTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/extends-tag-value-node.d.ts

@@ -0,0 +1,9 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { GenericTypeNode } from '../type/generic-type-node';
+export declare class ExtendsTagValueNode extends PhpDocTagValueNode {
+    type: GenericTypeNode;
+    description: string;
+    constructor(type: GenericTypeNode, description?: string);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/extends-tag-value-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendsTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class ExtendsTagValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(type, description = '') {
+        super();
+        this.type = type;
+        this.description = description;
+    }
+    toString() {
+        return `${this.type.toString()} ${this.description}`.trim();
+    }
+    getNodeType() {
+        return 'ExtendsTagValueNode';
+    }
+}
+exports.ExtendsTagValueNode = ExtendsTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/generic-tag-value-node.d.ts

@@ -0,0 +1,7 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+export declare class GenericTagValueNode extends PhpDocTagValueNode {
+    value: string;
+    constructor(value: string);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/generic-tag-value-node.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class GenericTagValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    toString() {
+        return this.value;
+    }
+    getNodeType() {
+        return 'GenericTagValueNode';
+    }
+}
+exports.GenericTagValueNode = GenericTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/implements-tag-value-node.d.ts

@@ -0,0 +1,9 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { GenericTypeNode } from '../type/generic-type-node';
+export declare class ImplementsTagValueNode extends PhpDocTagValueNode {
+    type: GenericTypeNode;
+    description: string;
+    constructor(type: GenericTypeNode, description: string);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/implements-tag-value-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImplementsTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class ImplementsTagValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(type, description) {
+        super();
+        this.type = type;
+        this.description = description;
+    }
+    toString() {
+        return `${this.type.toString()} ${this.description}`.trim();
+    }
+    getNodeType() {
+        return 'ImplementsTagValueNode';
+    }
+}
+exports.ImplementsTagValueNode = ImplementsTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/invalid-tag-value-node.d.ts

@@ -0,0 +1,10 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { ParserException } from '../../parser/parser-exception';
+export declare class InvalidTagValueNode extends PhpDocTagValueNode {
+    value: string;
+    private exceptionArgs;
+    constructor(value: string, exception: ParserException);
+    get(name: string): ParserException;
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/invalid-tag-value-node.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+const parser_exception_1 = require("../../parser/parser-exception");
+class InvalidTagValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(value, exception) {
+        super();
+        this.value = value;
+        this.exceptionArgs = [
+            exception.getCurrentTokenValue(),
+            exception.getCurrentTokenType(),
+            exception.getCurrentOffset(),
+            exception.getExpectedTokenType(),
+            exception.getExpectedTokenValue(),
+            exception.getCurrentTokenLine(),
+        ];
+    }
+    get(name) {
+        if (name !== 'exception') {
+            console.warn(`Undefined property: InvalidTagValueNode::$${name}`);
+            return null;
+        }
+        return new parser_exception_1.ParserException(...this.exceptionArgs);
+    }
+    toString() {
+        return this.value;
+    }
+    getNodeType() {
+        return 'InvalidTagValueNode';
+    }
+}
+exports.InvalidTagValueNode = InvalidTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/method-tag-value-node.d.ts

@@ -0,0 +1,15 @@
+import { MethodTagValueParameterNode } from './method-tag-value-parameter-node';
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { TemplateTagValueNode } from './template-tag-value-node';
+import { TypeNode } from '../type/type-node';
+export declare class MethodTagValueNode extends PhpDocTagValueNode {
+    isStatic: boolean;
+    returnType: TypeNode | null;
+    methodName: string;
+    parameters: MethodTagValueParameterNode[];
+    description: string;
+    templateTypes: TemplateTagValueNode[];
+    constructor(isStatic: boolean, returnType: TypeNode | null, methodName: string, parameters: MethodTagValueParameterNode[], description: string, templateTypes: TemplateTagValueNode[]);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/method-tag-value-node.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodTagValueNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class MethodTagValueNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(isStatic, returnType, methodName, parameters, description, templateTypes) {
+        super();
+        this.isStatic = isStatic;
+        this.returnType = returnType;
+        this.methodName = methodName;
+        this.parameters = parameters;
+        this.description = description;
+        this.templateTypes = templateTypes;
+    }
+    toString() {
+        const staticKeyword = this.isStatic ? 'static ' : '';
+        const returnTypeStr = this.returnType !== null ? `${this.returnType.toString()} ` : '';
+        const parametersStr = this.parameters.join(', ');
+        const descriptionStr = this.description !== '' ? ` ${this.description}` : '';
+        const templateTypesStr = this.templateTypes.length > 0 ? `<${this.templateTypes.join(', ')}>` : '';
+        return `${staticKeyword}${returnTypeStr}${this.methodName}${templateTypesStr}(${parametersStr})${descriptionStr}`;
+    }
+    getNodeType() {
+        return 'MethodTagValueNode';
+    }
+}
+exports.MethodTagValueNode = MethodTagValueNode;

package/dist/phpdoc-parser/ast/php-doc/method-tag-value-parameter-node.d.ts

@@ -0,0 +1,13 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { ConstExprNode } from '../const-expr/const-expr-node';
+import { TypeNode } from '../type/type-node';
+export declare class MethodTagValueParameterNode extends PhpDocTagValueNode {
+    type: TypeNode | null;
+    isReference: boolean;
+    isVariadic: boolean;
+    parameterName: string;
+    defaultValue?: ConstExprNode;
+    constructor(type: TypeNode | null, isReference: boolean, isVariadic: boolean, parameterName: string, defaultValue?: ConstExprNode);
+    toString(): string;
+    getNodeType(): string;
+}

package/dist/phpdoc-parser/ast/php-doc/method-tag-value-parameter-node.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodTagValueParameterNode = void 0;
+const php_doc_tag_value_node_1 = require("./php-doc-tag-value-node");
+class MethodTagValueParameterNode extends php_doc_tag_value_node_1.PhpDocTagValueNode {
+    constructor(type, isReference, isVariadic, parameterName, defaultValue) {
+        super();
+        this.type = type;
+        this.isReference = isReference;
+        this.isVariadic = isVariadic;
+        this.parameterName = parameterName;
+        this.defaultValue = defaultValue;
+    }
+    toString() {
+        const type = this.type ? `${this.type.toString()} ` : '';
+        const isReference = this.isReference ? '&' : '';
+        const isVariadic = this.isVariadic ? '...' : '';
+        const defaultVal = this.defaultValue !== undefined
+            ? ` = ${this.defaultValue.toString()}`
+            : '';
+        return `${type}${isReference}${isVariadic}${this.parameterName}${defaultVal}`;
+    }
+    getNodeType() {
+        return 'MethodTagValueParameterNode';
+    }
+}
+exports.MethodTagValueParameterNode = MethodTagValueParameterNode;

package/dist/phpdoc-parser/ast/php-doc/mixin-tag-value-node.d.ts

@@ -0,0 +1,9 @@
+import { PhpDocTagValueNode } from './php-doc-tag-value-node';
+import { TypeNode } from '../type/type-node';
+export declare class MixinTagValueNode extends PhpDocTagValueNode {
+    type: TypeNode;
+    description: string;
+    constructor(type: TypeNode, description: string);
+    toString(): string;
+    getNodeType(): string;
+}