@jorgsowa/php-parser 3.2.5-1

package/src/ast/identifier.js

@@ -0,0 +1,26 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Node = require("./node");
+const KIND = "identifier";
+
+/**
+ * Defines an identifier node
+ * @constructor Identifier
+ * @memberOf module:php-parser
+ * @extends {Node}
+ * @property {string} name
+ */
+const Identifier = Node.extends(
+  KIND,
+  function Identifier(name, docs, location) {
+    Node.apply(this, [KIND, docs, location]);
+    this.name = name;
+  },
+);
+
+module.exports = Identifier;

package/src/ast/if.js

@@ -0,0 +1,30 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Statement = require("./statement");
+const KIND = "if";
+
+/**
+ * Defines a if statement
+ * @constructor If
+ * @memberOf module:php-parser
+ * @extends {Statement}
+ * @property {Expression} test
+ * @property {Block} body
+ * @property {Block|If|null} alternate
+ * @property {boolean} shortForm
+ */
+module.exports = Statement.extends(
+  KIND,
+  function If(test, body, alternate, shortForm, docs, location) {
+    Statement.apply(this, [KIND, docs, location]);
+    this.test = test;
+    this.body = body;
+    this.alternate = alternate;
+    this.shortForm = shortForm;
+  },
+);

package/src/ast/include.js

@@ -0,0 +1,28 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Expression = require("./expression");
+const KIND = "include";
+
+/**
+ * Defines system include call
+ * @constructor Include
+ * @memberOf module:php-parser
+ * @extends {Expression}
+ * @property {Node} target
+ * @property {boolean} once
+ * @property {boolean} require
+ */
+module.exports = Expression.extends(
+  KIND,
+  function Include(once, require, target, docs, location) {
+    Expression.apply(this, [KIND, docs, location]);
+    this.once = once;
+    this.require = require;
+    this.target = target;
+  },
+);

package/src/ast/inline.js

@@ -0,0 +1,23 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Literal = require("./literal");
+const KIND = "inline";
+
+/**
+ * Defines inline html output (treated as echo output)
+ * @constructor Inline
+ * @memberOf module:php-parser
+ * @extends {Literal}
+ * @property {string} value
+ */
+module.exports = Literal.extends(
+  KIND,
+  function Inline(value, raw, docs, location) {
+    Literal.apply(this, [KIND, value, raw, docs, location]);
+  },
+);

package/src/ast/interface.js

@@ -0,0 +1,28 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Declaration = require("./declaration");
+const KIND = "interface";
+
+/**
+ * An interface definition
+ * @constructor Interface
+ * @memberOf module:php-parser
+ * @extends {Declaration}
+ * @property {Identifier[]} extends
+ * @property {Declaration[]} body
+ * @property {AttrGroup[]} attrGroups
+ */
+module.exports = Declaration.extends(
+  KIND,
+  function Interface(name, ext, body, attrGroups, docs, location) {
+    Declaration.apply(this, [KIND, name, docs, location]);
+    this.extends = ext;
+    this.body = body;
+    this.attrGroups = attrGroups;
+  },
+);

package/src/ast/intersectiontype.js

@@ -0,0 +1,24 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Declaration = require("./declaration");
+const KIND = "intersectiontype";
+
+/**
+ * A union of types
+ * @memberOf module:php-parser
+ * @constructor IntersectionType
+ * @extends {Declaration}
+ * @property {TypeReference[]} types
+ */
+module.exports = Declaration.extends(
+  KIND,
+  function IntersectionType(types, docs, location) {
+    Declaration.apply(this, [KIND, null, docs, location]);
+    this.types = types;
+  },
+);

package/src/ast/isset.js

@@ -0,0 +1,23 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Expression = require("./expression");
+const KIND = "isset";
+
+/**
+ * Defines an isset call
+ * @constructor Isset
+ * @memberOf module:php-parser
+ * @extends {Expression}
+ */
+module.exports = Expression.extends(
+  KIND,
+  function Isset(variables, docs, location) {
+    Expression.apply(this, [KIND, docs, location]);
+    this.variables = variables;
+  },
+);

package/src/ast/label.js

@@ -0,0 +1,21 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Statement = require("./statement");
+const KIND = "label";
+
+/**
+ * A label statement (referenced by goto)
+ * @constructor Label
+ * @memberOf module:php-parser
+ * @extends {Statement}
+ * @property {String} name
+ */
+module.exports = Statement.extends(KIND, function Label(name, docs, location) {
+  Statement.apply(this, [KIND, docs, location]);
+  this.name = name;
+});

package/src/ast/list.js

@@ -0,0 +1,26 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Expression = require("./expression");
+const KIND = "list";
+
+/**
+ * Defines list assignment
+ * @constructor List
+ * @memberOf module:php-parser
+ * @extends {Expression}
+ * @property {boolean} shortForm
+ * @property {Entry[]} items
+ */
+module.exports = Expression.extends(
+  KIND,
+  function List(items, shortForm, docs, location) {
+    Expression.apply(this, [KIND, docs, location]);
+    this.items = items;
+    this.shortForm = shortForm;
+  },
+);

package/src/ast/literal.js

@@ -0,0 +1,28 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Expression = require("./expression");
+const KIND = "literal";
+
+/**
+ * Defines an array structure
+ * @constructor Literal
+ * @memberOf module:php-parser
+ * @extends {Expression}
+ * @property {string} raw
+ * @property {EncapsedPart[]|Node|string|number|boolean|null} value
+ */
+module.exports = Expression.extends(
+  KIND,
+  function Literal(kind, value, raw, docs, location) {
+    Expression.apply(this, [kind || KIND, docs, location]);
+    this.value = value;
+    if (raw) {
+      this.raw = raw;
+    }
+  },
+);

package/src/ast/location.js

@@ -0,0 +1,22 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+/**
+ * Defines the location of the node (with it's source contents as string)
+ * @constructor Location
+ * @memberOf module:php-parser
+ * @property {string|null} source
+ * @property {Position} start
+ * @property {Position} end
+ */
+const Location = function (source, start, end) {
+  this.source = source;
+  this.start = start;
+  this.end = end;
+};
+
+module.exports = Location;

package/src/ast/lookup.js

@@ -0,0 +1,26 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Expr = require("./expression");
+const KIND = "lookup";
+
+/**
+ * Lookup on an offset in the specified object
+ * @constructor Lookup
+ * @memberOf module:php-parser
+ * @extends {Expression}
+ * @property {Expression} what
+ * @property {Expression} offset
+ */
+module.exports = Expr.extends(
+  KIND,
+  function Lookup(kind, what, offset, docs, location) {
+    Expr.apply(this, [kind || KIND, docs, location]);
+    this.what = what;
+    this.offset = offset;
+  },
+);

package/src/ast/magic.js

@@ -0,0 +1,22 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Literal = require("./literal");
+const KIND = "magic";
+
+/**
+ * Defines magic constant
+ * @constructor Magic
+ * @memberOf module:php-parser
+ * @extends {Literal}
+ */
+module.exports = Literal.extends(
+  KIND,
+  function Magic(value, raw, docs, location) {
+    Literal.apply(this, [KIND, value, raw, docs, location]);
+  },
+);

package/src/ast/match.js

@@ -0,0 +1,26 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Expression = require("./expression");
+const KIND = "match";
+
+/**
+ * Defines a match expression
+ * @memberOf module:php-parser
+ * @constructor Match
+ * @extends {Expression}
+ * @property {Expression} cond Condition expression to match against
+ * @property {MatchArm[]} arms Arms for comparison
+ */
+module.exports = Expression.extends(
+  KIND,
+  function Match(cond, arms, docs, location) {
+    Expression.apply(this, [KIND, docs, location]);
+    this.cond = cond;
+    this.arms = arms;
+  },
+);

package/src/ast/matcharm.js

@@ -0,0 +1,26 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Expression = require("./expression");
+const KIND = "matcharm";
+
+/**
+ * An array entry - see [Array](#array)
+ * @memberOf module:php-parser
+ * @constructor MatchArm
+ * @extends {Expression}
+ * @property {Expression[]|null} conds The match condition expression list - null indicates default arm
+ * @property {Expression} body The return value expression
+ */
+module.exports = Expression.extends(
+  KIND,
+  function MatchArm(conds, body, docs, location) {
+    Expression.apply(this, [KIND, docs, location]);
+    this.conds = conds;
+    this.body = body;
+  },
+);

package/src/ast/method.js

@@ -0,0 +1,24 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Function_ = require("./function");
+const KIND = "method";
+
+/**
+ * Defines a class/interface/trait method
+ * @constructor Method
+ * @memberOf module:php-parser
+ * @extends {Function}
+ * @property {boolean} isAbstract
+ * @property {boolean} isFinal
+ * @property {boolean} isStatic
+ * @property {string} visibility
+ */
+module.exports = Function_.extends(KIND, function Method() {
+  Function_.apply(this, arguments);
+  this.kind = KIND;
+});

package/src/ast/name.js

@@ -0,0 +1,55 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Reference = require("./reference");
+const KIND = "name";
+
+/**
+ * Defines a class reference node
+ * @constructor Name
+ * @memberOf module:php-parser
+ * @extends {Reference}
+ * @property {string} name
+ * @property {string} resolution
+ */
+const Name = Reference.extends(
+  KIND,
+  function Name(name, resolution, docs, location) {
+    Reference.apply(this, [KIND, docs, location]);
+    this.name = name.replace(/\\$/, "");
+    this.resolution = resolution;
+  },
+);
+
+/**
+ * This is an identifier without a namespace separator, such as Foo
+ * @constant {String} Name#UNQUALIFIED_NAME
+ * @memberOf module:php-parser
+ */
+Name.UNQUALIFIED_NAME = "uqn";
+/**
+ * This is an identifier with a namespace separator, such as Foo\Bar
+ * @constant {String} Name#QUALIFIED_NAME
+ * @memberOf module:php-parser
+ */
+Name.QUALIFIED_NAME = "qn";
+/**
+ * This is an identifier with a namespace separator that begins with
+ * a namespace separator, such as \Foo\Bar. The namespace \Foo is also
+ * a fully qualified name.
+ * @constant {String} Name#FULL_QUALIFIED_NAME
+ * @memberOf module:php-parser
+ */
+Name.FULL_QUALIFIED_NAME = "fqn";
+/**
+ * This is an identifier starting with namespace, such as namespace\Foo\Bar.
+ * @constant {String} Name#RELATIVE_NAME
+ * @memberOf module:php-parser
+ */
+Name.RELATIVE_NAME = "rn";
+
+module.exports = Name;

package/src/ast/namedargument.js

@@ -0,0 +1,27 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Expression = require("./expression");
+const KIND = "namedargument";
+
+/**
+ * Named arguments.
+ * @memberOf module:php-parser
+ * @constructor namedargument
+ * @extends {Expression}
+ * @property {String} name
+ * @property {Expression} value
+ * @see https://www.php.net/manual/en/functions.arguments.php#functions.named-arguments
+ */
+module.exports = Expression.extends(
+  KIND,
+  function namedargument(name, value, docs, location) {
+    Expression.apply(this, [KIND, docs, location]);
+    this.name = name;
+    this.value = value;
+  },
+);

package/src/ast/namespace.js

@@ -0,0 +1,26 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Block = require("./block");
+const KIND = "namespace";
+
+/**
+ * The main program node
+ * @constructor Namespace
+ * @memberOf module:php-parser
+ * @extends {Block}
+ * @property {string} name
+ * @property {boolean} withBrackets
+ */
+module.exports = Block.extends(
+  KIND,
+  function Namespace(name, children, withBrackets, docs, location) {
+    Block.apply(this, [KIND, children, docs, location]);
+    this.name = name;
+    this.withBrackets = withBrackets || false;
+  },
+);

package/src/ast/new.js

@@ -0,0 +1,26 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Expression = require("./expression");
+const KIND = "new";
+
+/**
+ * Creates a new instance of the specified class
+ * @constructor New
+ * @memberOf module:php-parser
+ * @extends {Expression}
+ * @property {Identifier|Variable|Class} what
+ * @property {Variable[]} arguments
+ */
+module.exports = Expression.extends(
+  KIND,
+  function New(what, args, docs, location) {
+    Expression.apply(this, [KIND, docs, location]);
+    this.what = what;
+    this.arguments = args;
+  },
+);

package/src/ast/node.js

@@ -0,0 +1,111 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+/**
+ * A generic AST node
+ * @constructor Node
+ * @memberOf module:php-parser
+ * @property {Location|null} loc
+ * @property {CommentBlock[]|Comment[]|null} leadingComments
+ * @property {CommentBlock[]|Comment[]|null} trailingComments
+ * @property {string} kind
+ */
+const Node = function Node(kind, docs, location) {
+  this.kind = kind;
+  if (docs) {
+    this.leadingComments = docs;
+  }
+  if (location) {
+    this.loc = location;
+  }
+};
+
+/**
+ * Attach comments to current node
+ * @function Node#setTrailingComments
+ * @memberOf module:php-parser
+ * @param {*} docs
+ */
+Node.prototype.setTrailingComments = function (docs) {
+  this.trailingComments = docs;
+};
+
+/**
+ * Destroying an unused node
+ * @function Node#destroy
+ * @memberOf module:php-parser
+ */
+Node.prototype.destroy = function (node) {
+  if (!node) {
+    /* istanbul ignore next */
+    throw new Error(
+      "Node already initialized, you must swap with another node",
+    );
+  }
+  if (this.leadingComments) {
+    if (node.leadingComments) {
+      node.leadingComments = Array.concat(
+        this.leadingComments,
+        node.leadingComments,
+      );
+    } else {
+      node.leadingComments = this.leadingComments;
+    }
+  }
+  if (this.trailingComments) {
+    if (node.trailingComments) {
+      node.trailingComments = Array.concat(
+        this.trailingComments,
+        node.trailingComments,
+      );
+    } else {
+      node.trailingComments = this.trailingComments;
+    }
+  }
+  return node;
+};
+
+/**
+ * Includes current token position of the parser
+ * @function Node#includeToken
+ * @memberOf module:php-parser
+ * @param {*} parser
+ */
+Node.prototype.includeToken = function (parser) {
+  if (this.loc) {
+    if (this.loc.end) {
+      this.loc.end.line = parser.lexer.yylloc.last_line;
+      this.loc.end.column = parser.lexer.yylloc.last_column;
+      this.loc.end.offset = parser.lexer.offset;
+    }
+    if (parser.ast.withSource) {
+      this.loc.source = parser.lexer._input.substring(
+        this.loc.start.offset,
+        parser.lexer.offset,
+      );
+    }
+  }
+  return this;
+};
+
+/**
+ * Helper for extending the Node class
+ * @function Node.extends
+ * @memberOf module:php-parser
+ * @param {string} type
+ * @param {Function} constructor
+ * @return {Function}
+ */
+Node.extends = function (type, constructor) {
+  constructor.prototype = Object.create(this.prototype);
+  constructor.extends = this.extends;
+  constructor.prototype.constructor = constructor;
+  constructor.kind = type;
+  return constructor;
+};
+
+module.exports = Node;

package/src/ast/noop.js

@@ -0,0 +1,20 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const Node = require("./node");
+const KIND = "noop";
+
+/**
+ * Ignore this node, it implies a no operation block, for example :
+ * [$foo, $bar, /* here a noop node * /]
+ * @constructor Noop
+ * @memberOf module:php-parser
+ * @extends {Node}
+ */
+module.exports = Node.extends(KIND, function Noop(docs, location) {
+  Node.apply(this, [KIND, docs, location]);
+});