ether-code 0.1.5 → 0.1.7

package/parsers/ast-php.js

@@ -1,957 +0,0 @@
-class ASTNode {
-    constructor(type, loc = null) {
-        this.type = type
-        this.loc = loc
-    }
-}
-
-class Program extends ASTNode {
-    constructor(body = [], loc = null) {
-        super('Program', loc)
-        this.body = body
-    }
-}
-
-class PHPBlock extends ASTNode {
-    constructor(body = [], loc = null) {
-        super('PHPBlock', loc)
-        this.body = body
-    }
-}
-
-class HTMLBlock extends ASTNode {
-    constructor(content, loc = null) {
-        super('HTMLBlock', loc)
-        this.content = content
-    }
-}
-
-class EchoStatement extends ASTNode {
-    constructor(expressions = [], loc = null) {
-        super('EchoStatement', loc)
-        this.expressions = expressions
-    }
-}
-
-class PrintStatement extends ASTNode {
-    constructor(expression, loc = null) {
-        super('PrintStatement', loc)
-        this.expression = expression
-    }
-}
-
-class Identifier extends ASTNode {
-    constructor(name, loc = null) {
-        super('Identifier', loc)
-        this.name = name
-    }
-}
-
-class Variable extends ASTNode {
-    constructor(name, loc = null) {
-        super('Variable', loc)
-        this.name = name
-    }
-}
-
-class VariableVariable extends ASTNode {
-    constructor(expr, loc = null) {
-        super('VariableVariable', loc)
-        this.expression = expr
-    }
-}
-
-class ConstantDeclaration extends ASTNode {
-    constructor(name, value, loc = null) {
-        super('ConstantDeclaration', loc)
-        this.name = name
-        this.value = value
-    }
-}
-
-class DefineCall extends ASTNode {
-    constructor(name, value, caseInsensitive = false, loc = null) {
-        super('DefineCall', loc)
-        this.name = name
-        this.value = value
-        this.caseInsensitive = caseInsensitive
-    }
-}
-
-class StringLiteral extends ASTNode {
-    constructor(value, raw = null, loc = null) {
-        super('StringLiteral', loc)
-        this.value = value
-        this.raw = raw || `"${value}"`
-    }
-}
-
-class NumericLiteral extends ASTNode {
-    constructor(value, raw = null, loc = null) {
-        super('NumericLiteral', loc)
-        this.value = value
-        this.raw = raw || String(value)
-    }
-}
-
-class BooleanLiteral extends ASTNode {
-    constructor(value, loc = null) {
-        super('BooleanLiteral', loc)
-        this.value = value
-    }
-}
-
-class NullLiteral extends ASTNode {
-    constructor(loc = null) {
-        super('NullLiteral', loc)
-        this.value = null
-    }
-}
-
-class ArrayExpression extends ASTNode {
-    constructor(elements = [], shortSyntax = true, loc = null) {
-        super('ArrayExpression', loc)
-        this.elements = elements
-        this.shortSyntax = shortSyntax
-    }
-}
-
-class ArrayElement extends ASTNode {
-    constructor(value, key = null, byRef = false, unpack = false, loc = null) {
-        super('ArrayElement', loc)
-        this.key = key
-        this.value = value
-        this.byRef = byRef
-        this.unpack = unpack
-    }
-}
-
-class HeredocLiteral extends ASTNode {
-    constructor(label, value, nowdoc = false, loc = null) {
-        super('HeredocLiteral', loc)
-        this.label = label
-        this.value = value
-        this.nowdoc = nowdoc
-    }
-}
-
-class InterpolatedString extends ASTNode {
-    constructor(parts = [], loc = null) {
-        super('InterpolatedString', loc)
-        this.parts = parts
-    }
-}
-
-class BinaryExpression extends ASTNode {
-    constructor(operator, left, right, loc = null) {
-        super('BinaryExpression', loc)
-        this.operator = operator
-        this.left = left
-        this.right = right
-    }
-}
-
-class UnaryExpression extends ASTNode {
-    constructor(operator, argument, prefix = true, loc = null) {
-        super('UnaryExpression', loc)
-        this.operator = operator
-        this.argument = argument
-        this.prefix = prefix
-    }
-}
-
-class UpdateExpression extends ASTNode {
-    constructor(operator, argument, prefix = true, loc = null) {
-        super('UpdateExpression', loc)
-        this.operator = operator
-        this.argument = argument
-        this.prefix = prefix
-    }
-}
-
-class AssignmentExpression extends ASTNode {
-    constructor(operator, left, right, loc = null) {
-        super('AssignmentExpression', loc)
-        this.operator = operator
-        this.left = left
-        this.right = right
-    }
-}
-
-class ConditionalExpression extends ASTNode {
-    constructor(test, consequent, alternate, loc = null) {
-        super('ConditionalExpression', loc)
-        this.test = test
-        this.consequent = consequent
-        this.alternate = alternate
-    }
-}
-
-class NullCoalescingExpression extends ASTNode {
-    constructor(left, right, loc = null) {
-        super('NullCoalescingExpression', loc)
-        this.left = left
-        this.right = right
-    }
-}
-
-class SpaceshipExpression extends ASTNode {
-    constructor(left, right, loc = null) {
-        super('SpaceshipExpression', loc)
-        this.left = left
-        this.right = right
-    }
-}
-
-class InstanceofExpression extends ASTNode {
-    constructor(left, right, loc = null) {
-        super('InstanceofExpression', loc)
-        this.left = left
-        this.right = right
-    }
-}
-
-class CastExpression extends ASTNode {
-    constructor(castType, expression, loc = null) {
-        super('CastExpression', loc)
-        this.castType = castType
-        this.expression = expression
-    }
-}
-
-class CloneExpression extends ASTNode {
-    constructor(expression, loc = null) {
-        super('CloneExpression', loc)
-        this.expression = expression
-    }
-}
-
-class ErrorSuppressExpression extends ASTNode {
-    constructor(expression, loc = null) {
-        super('ErrorSuppressExpression', loc)
-        this.expression = expression
-    }
-}
-
-class IfStatement extends ASTNode {
-    constructor(test, consequent, alternate = null, loc = null) {
-        super('IfStatement', loc)
-        this.test = test
-        this.consequent = consequent
-        this.alternate = alternate
-    }
-}
-
-class SwitchStatement extends ASTNode {
-    constructor(discriminant, cases = [], loc = null) {
-        super('SwitchStatement', loc)
-        this.discriminant = discriminant
-        this.cases = cases
-    }
-}
-
-class SwitchCase extends ASTNode {
-    constructor(test, consequent = [], loc = null) {
-        super('SwitchCase', loc)
-        this.test = test
-        this.consequent = consequent
-    }
-}
-
-class MatchExpression extends ASTNode {
-    constructor(condition, arms = [], loc = null) {
-        super('MatchExpression', loc)
-        this.condition = condition
-        this.arms = arms
-    }
-}
-
-class MatchArm extends ASTNode {
-    constructor(conditions, body, isDefault = false, loc = null) {
-        super('MatchArm', loc)
-        this.conditions = conditions
-        this.body = body
-        this.isDefault = isDefault
-    }
-}
-
-class ForStatement extends ASTNode {
-    constructor(init, test, update, body, loc = null) {
-        super('ForStatement', loc)
-        this.init = init
-        this.test = test
-        this.update = update
-        this.body = body
-    }
-}
-
-class ForeachStatement extends ASTNode {
-    constructor(source, key, value, body, byRef = false, loc = null) {
-        super('ForeachStatement', loc)
-        this.source = source
-        this.key = key
-        this.value = value
-        this.body = body
-        this.byRef = byRef
-    }
-}
-
-class WhileStatement extends ASTNode {
-    constructor(test, body, loc = null) {
-        super('WhileStatement', loc)
-        this.test = test
-        this.body = body
-    }
-}
-
-class DoWhileStatement extends ASTNode {
-    constructor(body, test, loc = null) {
-        super('DoWhileStatement', loc)
-        this.body = body
-        this.test = test
-    }
-}
-
-class BreakStatement extends ASTNode {
-    constructor(level = null, loc = null) {
-        super('BreakStatement', loc)
-        this.level = level
-    }
-}
-
-class ContinueStatement extends ASTNode {
-    constructor(level = null, loc = null) {
-        super('ContinueStatement', loc)
-        this.level = level
-    }
-}
-
-class ReturnStatement extends ASTNode {
-    constructor(argument = null, loc = null) {
-        super('ReturnStatement', loc)
-        this.argument = argument
-    }
-}
-
-class ThrowStatement extends ASTNode {
-    constructor(argument, loc = null) {
-        super('ThrowStatement', loc)
-        this.argument = argument
-    }
-}
-
-class TryStatement extends ASTNode {
-    constructor(block, catches = [], finalizer = null, loc = null) {
-        super('TryStatement', loc)
-        this.block = block
-        this.catches = catches
-        this.finalizer = finalizer
-    }
-}
-
-class CatchClause extends ASTNode {
-    constructor(types, param, body, loc = null) {
-        super('CatchClause', loc)
-        this.types = types
-        this.param = param
-        this.body = body
-    }
-}
-
-class FinallyClause extends ASTNode {
-    constructor(body, loc = null) {
-        super('FinallyClause', loc)
-        this.body = body
-    }
-}
-
-class FunctionDeclaration extends ASTNode {
-    constructor(name, params = [], body, returnType = null, byRef = false, loc = null) {
-        super('FunctionDeclaration', loc)
-        this.name = name
-        this.params = params
-        this.body = body
-        this.returnType = returnType
-        this.byRef = byRef
-    }
-}
-
-class ArrowFunction extends ASTNode {
-    constructor(params = [], body, returnType = null, isStatic = false, loc = null) {
-        super('ArrowFunction', loc)
-        this.params = params
-        this.body = body
-        this.returnType = returnType
-        this.static = isStatic
-    }
-}
-
-class ClosureExpression extends ASTNode {
-    constructor(params = [], uses = [], body, returnType = null, isStatic = false, loc = null) {
-        super('ClosureExpression', loc)
-        this.params = params
-        this.uses = uses
-        this.body = body
-        this.returnType = returnType
-        this.static = isStatic
-    }
-}
-
-class ClosureUse extends ASTNode {
-    constructor(variable, byRef = false, loc = null) {
-        super('ClosureUse', loc)
-        this.variable = variable
-        this.byRef = byRef
-    }
-}
-
-class Parameter extends ASTNode {
-    constructor(name, type = null, defaultValue = null, byRef = false, variadic = false, visibility = null, readonly = false, loc = null) {
-        super('Parameter', loc)
-        this.name = name
-        this.paramType = type
-        this.default = defaultValue
-        this.byRef = byRef
-        this.variadic = variadic
-        this.visibility = visibility
-        this.readonly = readonly
-    }
-}
-
-class TypeReference extends ASTNode {
-    constructor(name, nullable = false, loc = null) {
-        super('TypeReference', loc)
-        this.name = name
-        this.nullable = nullable
-    }
-}
-
-class UnionType extends ASTNode {
-    constructor(types = [], loc = null) {
-        super('UnionType', loc)
-        this.types = types
-    }
-}
-
-class IntersectionType extends ASTNode {
-    constructor(types = [], loc = null) {
-        super('IntersectionType', loc)
-        this.types = types
-    }
-}
-
-class CallExpression extends ASTNode {
-    constructor(callee, arguments_ = [], loc = null) {
-        super('CallExpression', loc)
-        this.callee = callee
-        this.arguments = arguments_
-    }
-}
-
-class NamedArgument extends ASTNode {
-    constructor(name, value, loc = null) {
-        super('NamedArgument', loc)
-        this.name = name
-        this.value = value
-    }
-}
-
-class NewExpression extends ASTNode {
-    constructor(callee, arguments_ = [], loc = null) {
-        super('NewExpression', loc)
-        this.callee = callee
-        this.arguments = arguments_
-    }
-}
-
-class MemberExpression extends ASTNode {
-    constructor(object, property, nullsafe = false, loc = null) {
-        super('MemberExpression', loc)
-        this.object = object
-        this.property = property
-        this.nullsafe = nullsafe
-    }
-}
-
-class StaticMemberExpression extends ASTNode {
-    constructor(object, property, loc = null) {
-        super('StaticMemberExpression', loc)
-        this.object = object
-        this.property = property
-    }
-}
-
-class ArrayAccess extends ASTNode {
-    constructor(array, index, loc = null) {
-        super('ArrayAccess', loc)
-        this.array = array
-        this.index = index
-    }
-}
-
-class ClassDeclaration extends ASTNode {
-    constructor(name, body, superClass = null, interfaces = [], modifiers = [], attributes = [], loc = null) {
-        super('ClassDeclaration', loc)
-        this.name = name
-        this.body = body
-        this.superClass = superClass
-        this.interfaces = interfaces
-        this.modifiers = modifiers
-        this.attributes = attributes
-    }
-}
-
-class ClassBody extends ASTNode {
-    constructor(members = [], loc = null) {
-        super('ClassBody', loc)
-        this.members = members
-    }
-}
-
-class MethodDefinition extends ASTNode {
-    constructor(name, params = [], body, returnType = null, modifiers = [], byRef = false, attributes = [], loc = null) {
-        super('MethodDefinition', loc)
-        this.name = name
-        this.params = params
-        this.body = body
-        this.returnType = returnType
-        this.modifiers = modifiers
-        this.byRef = byRef
-        this.attributes = attributes
-    }
-}
-
-class PropertyDeclaration extends ASTNode {
-    constructor(name, value = null, type = null, modifiers = [], attributes = [], loc = null) {
-        super('PropertyDeclaration', loc)
-        this.name = name
-        this.value = value
-        this.propertyType = type
-        this.modifiers = modifiers
-        this.attributes = attributes
-    }
-}
-
-class ClassConstant extends ASTNode {
-    constructor(name, value, modifiers = [], type = null, loc = null) {
-        super('ClassConstant', loc)
-        this.name = name
-        this.value = value
-        this.modifiers = modifiers
-        this.constType = type
-    }
-}
-
-class InterfaceDeclaration extends ASTNode {
-    constructor(name, body, extends_ = [], attributes = [], loc = null) {
-        super('InterfaceDeclaration', loc)
-        this.name = name
-        this.body = body
-        this.extends = extends_
-        this.attributes = attributes
-    }
-}
-
-class TraitDeclaration extends ASTNode {
-    constructor(name, body, attributes = [], loc = null) {
-        super('TraitDeclaration', loc)
-        this.name = name
-        this.body = body
-        this.attributes = attributes
-    }
-}
-
-class TraitUse extends ASTNode {
-    constructor(traits = [], adaptations = [], loc = null) {
-        super('TraitUse', loc)
-        this.traits = traits
-        this.adaptations = adaptations
-    }
-}
-
-class TraitAlias extends ASTNode {
-    constructor(trait, method, newName, visibility = null, loc = null) {
-        super('TraitAlias', loc)
-        this.trait = trait
-        this.method = method
-        this.newName = newName
-        this.visibility = visibility
-    }
-}
-
-class TraitInsteadof extends ASTNode {
-    constructor(trait, method, insteadof = [], loc = null) {
-        super('TraitInsteadof', loc)
-        this.trait = trait
-        this.method = method
-        this.insteadof = insteadof
-    }
-}
-
-class EnumDeclaration extends ASTNode {
-    constructor(name, body, backingType = null, interfaces = [], attributes = [], loc = null) {
-        super('EnumDeclaration', loc)
-        this.name = name
-        this.body = body
-        this.backingType = backingType
-        this.interfaces = interfaces
-        this.attributes = attributes
-    }
-}
-
-class EnumCase extends ASTNode {
-    constructor(name, value = null, attributes = [], loc = null) {
-        super('EnumCase', loc)
-        this.name = name
-        this.value = value
-        this.attributes = attributes
-    }
-}
-
-class Attribute extends ASTNode {
-    constructor(name, arguments_ = [], loc = null) {
-        super('Attribute', loc)
-        this.name = name
-        this.arguments = arguments_
-    }
-}
-
-class AttributeGroup extends ASTNode {
-    constructor(attributes = [], loc = null) {
-        super('AttributeGroup', loc)
-        this.attributes = attributes
-    }
-}
-
-class NamespaceDeclaration extends ASTNode {
-    constructor(name, body = null, loc = null) {
-        super('NamespaceDeclaration', loc)
-        this.name = name
-        this.body = body
-    }
-}
-
-class UseDeclaration extends ASTNode {
-    constructor(declarations = [], type = null, loc = null) {
-        super('UseDeclaration', loc)
-        this.declarations = declarations
-        this.useType = type
-    }
-}
-
-class UseClause extends ASTNode {
-    constructor(name, alias = null, loc = null) {
-        super('UseClause', loc)
-        this.name = name
-        this.alias = alias
-    }
-}
-
-class GroupUse extends ASTNode {
-    constructor(prefix, uses = [], type = null, loc = null) {
-        super('GroupUse', loc)
-        this.prefix = prefix
-        this.uses = uses
-        this.useType = type
-    }
-}
-
-class IncludeExpression extends ASTNode {
-    constructor(path, once = false, require = false, loc = null) {
-        super('IncludeExpression', loc)
-        this.path = path
-        this.once = once
-        this.require = require
-    }
-}
-
-class ExpressionStatement extends ASTNode {
-    constructor(expression, loc = null) {
-        super('ExpressionStatement', loc)
-        this.expression = expression
-    }
-}
-
-class BlockStatement extends ASTNode {
-    constructor(body = [], loc = null) {
-        super('BlockStatement', loc)
-        this.body = body
-    }
-}
-
-class EmptyStatement extends ASTNode {
-    constructor(loc = null) {
-        super('EmptyStatement', loc)
-    }
-}
-
-class GlobalStatement extends ASTNode {
-    constructor(variables = [], loc = null) {
-        super('GlobalStatement', loc)
-        this.variables = variables
-    }
-}
-
-class StaticStatement extends ASTNode {
-    constructor(declarations = [], loc = null) {
-        super('StaticStatement', loc)
-        this.declarations = declarations
-    }
-}
-
-class StaticVariable extends ASTNode {
-    constructor(name, value = null, loc = null) {
-        super('StaticVariable', loc)
-        this.name = name
-        this.value = value
-    }
-}
-
-class DeclareStatement extends ASTNode {
-    constructor(directives = [], body = null, loc = null) {
-        super('DeclareStatement', loc)
-        this.directives = directives
-        this.body = body
-    }
-}
-
-class DeclareDirective extends ASTNode {
-    constructor(name, value, loc = null) {
-        super('DeclareDirective', loc)
-        this.name = name
-        this.value = value
-    }
-}
-
-class ListExpression extends ASTNode {
-    constructor(elements = [], loc = null) {
-        super('ListExpression', loc)
-        this.elements = elements
-    }
-}
-
-class YieldExpression extends ASTNode {
-    constructor(key = null, value = null, loc = null) {
-        super('YieldExpression', loc)
-        this.key = key
-        this.value = value
-    }
-}
-
-class YieldFromExpression extends ASTNode {
-    constructor(expression, loc = null) {
-        super('YieldFromExpression', loc)
-        this.expression = expression
-    }
-}
-
-class ThrowExpression extends ASTNode {
-    constructor(argument, loc = null) {
-        super('ThrowExpression', loc)
-        this.argument = argument
-    }
-}
-
-class ExitExpression extends ASTNode {
-    constructor(argument = null, isDie = false, loc = null) {
-        super('ExitExpression', loc)
-        this.argument = argument
-        this.isDie = isDie
-    }
-}
-
-class EmptyExpression extends ASTNode {
-    constructor(argument, loc = null) {
-        super('EmptyExpression', loc)
-        this.argument = argument
-    }
-}
-
-class IssetExpression extends ASTNode {
-    constructor(arguments_ = [], loc = null) {
-        super('IssetExpression', loc)
-        this.arguments = arguments_
-    }
-}
-
-class UnsetStatement extends ASTNode {
-    constructor(arguments_ = [], loc = null) {
-        super('UnsetStatement', loc)
-        this.arguments = arguments_
-    }
-}
-
-class EvalExpression extends ASTNode {
-    constructor(code, loc = null) {
-        super('EvalExpression', loc)
-        this.code = code
-    }
-}
-
-class PrintExpression extends ASTNode {
-    constructor(argument, loc = null) {
-        super('PrintExpression', loc)
-        this.argument = argument
-    }
-}
-
-class ShellExecExpression extends ASTNode {
-    constructor(command, loc = null) {
-        super('ShellExecExpression', loc)
-        this.command = command
-    }
-}
-
-class AnonymousClass extends ASTNode {
-    constructor(arguments_ = [], superClass = null, interfaces = [], body, loc = null) {
-        super('AnonymousClass', loc)
-        this.arguments = arguments_
-        this.superClass = superClass
-        this.interfaces = interfaces
-        this.body = body
-    }
-}
-
-class NamespaceName extends ASTNode {
-    constructor(parts = [], absolute = false, loc = null) {
-        super('NamespaceName', loc)
-        this.parts = parts
-        this.absolute = absolute
-    }
-}
-
-class LabelStatement extends ASTNode {
-    constructor(name, loc = null) {
-        super('LabelStatement', loc)
-        this.name = name
-    }
-}
-
-class GotoStatement extends ASTNode {
-    constructor(label, loc = null) {
-        super('GotoStatement', loc)
-        this.label = label
-    }
-}
-
-class EtherNaturalExpression extends ASTNode {
-    constructor(description, loc = null) {
-        super('EtherNaturalExpression', loc)
-        this.description = description
-    }
-}
-
-class EtherPipeExpression extends ASTNode {
-    constructor(left, right, loc = null) {
-        super('EtherPipeExpression', loc)
-        this.left = left
-        this.right = right
-    }
-}
-
-module.exports = {
-    ASTNode,
-    Program,
-    PHPBlock,
-    HTMLBlock,
-    EchoStatement,
-    PrintStatement,
-    Identifier,
-    Variable,
-    VariableVariable,
-    ConstantDeclaration,
-    DefineCall,
-    StringLiteral,
-    NumericLiteral,
-    BooleanLiteral,
-    NullLiteral,
-    ArrayExpression,
-    ArrayElement,
-    HeredocLiteral,
-    InterpolatedString,
-    BinaryExpression,
-    UnaryExpression,
-    UpdateExpression,
-    AssignmentExpression,
-    ConditionalExpression,
-    NullCoalescingExpression,
-    SpaceshipExpression,
-    InstanceofExpression,
-    CastExpression,
-    CloneExpression,
-    ErrorSuppressExpression,
-    IfStatement,
-    SwitchStatement,
-    SwitchCase,
-    MatchExpression,
-    MatchArm,
-    ForStatement,
-    ForeachStatement,
-    WhileStatement,
-    DoWhileStatement,
-    BreakStatement,
-    ContinueStatement,
-    ReturnStatement,
-    ThrowStatement,
-    TryStatement,
-    CatchClause,
-    FinallyClause,
-    FunctionDeclaration,
-    ArrowFunction,
-    ClosureExpression,
-    ClosureUse,
-    Parameter,
-    TypeReference,
-    UnionType,
-    IntersectionType,
-    CallExpression,
-    NamedArgument,
-    NewExpression,
-    MemberExpression,
-    StaticMemberExpression,
-    ArrayAccess,
-    ClassDeclaration,
-    ClassBody,
-    MethodDefinition,
-    PropertyDeclaration,
-    ClassConstant,
-    InterfaceDeclaration,
-    TraitDeclaration,
-    TraitUse,
-    TraitAlias,
-    TraitInsteadof,
-    EnumDeclaration,
-    EnumCase,
-    Attribute,
-    AttributeGroup,
-    NamespaceDeclaration,
-    UseDeclaration,
-    UseClause,
-    GroupUse,
-    IncludeExpression,
-    ExpressionStatement,
-    BlockStatement,
-    EmptyStatement,
-    GlobalStatement,
-    StaticStatement,
-    StaticVariable,
-    DeclareStatement,
-    DeclareDirective,
-    ListExpression,
-    YieldExpression,
-    YieldFromExpression,
-    ThrowExpression,
-    ExitExpression,
-    EmptyExpression,
-    IssetExpression,
-    UnsetStatement,
-    EvalExpression,
-    PrintExpression,
-    ShellExecExpression,
-    AnonymousClass,
-    NamespaceName,
-    LabelStatement,
-    GotoStatement,
-    EtherNaturalExpression,
-    EtherPipeExpression
-}