DefinitionTree {
    definitions: [
        Namespace(
            NamespaceDefinition {
                namespace: 0,
                name: Identifier {
                    position: 10,
                    value: "where",
                },
                semicolon: 15,
                definitions: [
                    Constant(
                        ConstantDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            const: 18,
                            entries: CommaSeparated {
                                inner: [
                                    ConstantDefinitionEntry {
                                        name: Identifier {
                                            position: 24,
                                            value: "where",
                                        },
                                        equals: 30,
                                        value: Literal(
                                            Integer(
                                                LiteralInteger {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    value: "1",
                                                    position: 32,
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                commas: [],
                            },
                            semicolon: 33,
                        },
                    ),
                    Interface(
                        InterfaceDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            interface: 35,
                            name: Identifier {
                                position: 45,
                                value: "where",
                            },
                            templates: None,
                            extends: None,
                            body: InterfaceDefinitionBody {
                                left_brace: 51,
                                members: [],
                                right_brace: 52,
                            },
                        },
                    ),
                    Class(
                        ClassDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            modifiers: ClassModifierDefinitionGroup {
                                modifiers: [],
                            },
                            class: 54,
                            name: Identifier {
                                position: 60,
                                value: "where",
                            },
                            templates: None,
                            extends: None,
                            implements: None,
                            body: ClassDefinitionBody {
                                left_brace: 66,
                                members: [
                                    Constant(
                                        ClassishConstantDefinition {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            attributes: [],
                                            modifiers: ConstantModifierDefinitionGroup {
                                                modifiers: [
                                                    Public(
                                                        72,
                                                    ),
                                                ],
                                            },
                                            const: 79,
                                            entries: CommaSeparated {
                                                inner: [
                                                    ConstantDefinitionEntry {
                                                        name: Identifier {
                                                            position: 85,
                                                            value: "where",
                                                        },
                                                        equals: 91,
                                                        value: Literal(
                                                            Integer(
                                                                LiteralInteger {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    value: "1",
                                                                    position: 93,
                                                                },
                                                            ),
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            semicolon: 94,
                                        },
                                    ),
                                    ConcreteMethod(
                                        ConcreteMethodDefinition {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            attributes: [],
                                            modifiers: MethodModifierDefinitionGroup {
                                                modifiers: [
                                                    Public(
                                                        101,
                                                    ),
                                                ],
                                            },
                                            function: 108,
                                            name: Identifier {
                                                position: 117,
                                                value: "where",
                                            },
                                            templates: None,
                                            parameters: FunctionLikeParameterListDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left_parenthesis: 122,
                                                parameters: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_parenthesis: 123,
                                            },
                                            return_type: FunctionLikeReturnTypeDefinition {
                                                colon: 124,
                                                type_definition: Void(
                                                    126,
                                                ),
                                            },
                                            constraints: None,
                                            body: BlockStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left_brace: 131,
                                                statements: [],
                                                right_brace: 132,
                                            },
                                        },
                                    ),
                                ],
                                right_brace: 134,
                            },
                        },
                    ),
                    Function(
                        FunctionDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            function: 137,
                            name: Identifier {
                                position: 146,
                                value: "where",
                            },
                            templates: None,
                            parameters: FunctionLikeParameterListDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_parenthesis: 151,
                                parameters: CommaSeparated {
                                    inner: [],
                                    commas: [],
                                },
                                right_parenthesis: 152,
                            },
                            return_type: FunctionLikeReturnTypeDefinition {
                                colon: 153,
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 155,
                                            value: "where",
                                        },
                                        templates: None,
                                    },
                                ),
                            },
                            body: BlockStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_brace: 161,
                                statements: [
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 167,
                                                            name: "$where",
                                                        },
                                                    ),
                                                    equals: 174,
                                                    right: Identifier(
                                                        Identifier {
                                                            position: 176,
                                                            value: "where",
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 181,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 187,
                                                            name: "$where",
                                                        },
                                                    ),
                                                    equals: 194,
                                                    right: ClassOperation(
                                                        Initialization {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            new: 196,
                                                            class: Identifier {
                                                                position: 200,
                                                                value: "where",
                                                            },
                                                            generics: None,
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: 205,
                                                                arguments: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: 206,
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 207,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 213,
                                                            name: "$where",
                                                        },
                                                    ),
                                                    equals: 220,
                                                    right: ClassOperation(
                                                        ConstantFetch {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            class: Identifier(
                                                                Identifier {
                                                                    position: 222,
                                                                    value: "where",
                                                                },
                                                            ),
                                                            double_colon: 227,
                                                            constant: Identifier {
                                                                position: 229,
                                                                value: "where",
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 234,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 240,
                                                            name: "$where",
                                                        },
                                                    ),
                                                    equals: 247,
                                                    right: ClassOperation(
                                                        StaticMethodCall {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            class: Identifier(
                                                                Identifier {
                                                                    position: 249,
                                                                    value: "where",
                                                                },
                                                            ),
                                                            double_colon: 254,
                                                            method: Identifier {
                                                                position: 256,
                                                                value: "where",
                                                            },
                                                            generics: None,
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: 261,
                                                                arguments: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: 262,
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 263,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 269,
                                                            name: "$where",
                                                        },
                                                    ),
                                                    equals: 276,
                                                    right: ClassOperation(
                                                        ConstantFetch {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            class: ClassOperation(
                                                                ConstantFetch {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    class: Identifier(
                                                                        Identifier {
                                                                            position: 278,
                                                                            value: "where",
                                                                        },
                                                                    ),
                                                                    double_colon: 283,
                                                                    constant: Identifier {
                                                                        position: 285,
                                                                        value: "where",
                                                                    },
                                                                },
                                                            ),
                                                            double_colon: 290,
                                                            constant: Identifier {
                                                                position: 292,
                                                                value: "where",
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 297,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 303,
                                                            name: "$where",
                                                        },
                                                    ),
                                                    equals: 310,
                                                    right: ClassOperation(
                                                        StaticMethodCall {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            class: ClassOperation(
                                                                ConstantFetch {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    class: Identifier(
                                                                        Identifier {
                                                                            position: 312,
                                                                            value: "where",
                                                                        },
                                                                    ),
                                                                    double_colon: 317,
                                                                    constant: Identifier {
                                                                        position: 319,
                                                                        value: "where",
                                                                    },
                                                                },
                                                            ),
                                                            double_colon: 324,
                                                            method: Identifier {
                                                                position: 326,
                                                                value: "where",
                                                            },
                                                            generics: None,
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: 331,
                                                                arguments: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: 332,
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 333,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 339,
                                                            name: "$where",
                                                        },
                                                    ),
                                                    equals: 346,
                                                    right: ObjectOperation(
                                                        MethodCall {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            object: Variable(
                                                                Variable {
                                                                    position: 348,
                                                                    name: "$where",
                                                                },
                                                            ),
                                                            arrow: 354,
                                                            method: Identifier {
                                                                position: 356,
                                                                value: "where",
                                                            },
                                                            generics: None,
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: 361,
                                                                arguments: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: 362,
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 363,
                                        },
                                    ),
                                    Return(
                                        Implicit {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: Variable(
                                                Variable {
                                                    position: 370,
                                                    name: "$where",
                                                },
                                            ),
                                        },
                                    ),
                                ],
                                right_brace: 377,
                            },
                        },
                    ),
                    Function(
                        FunctionDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            function: 380,
                            name: Identifier {
                                position: 389,
                                value: "where",
                            },
                            templates: None,
                            parameters: FunctionLikeParameterListDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_parenthesis: 394,
                                parameters: CommaSeparated {
                                    inner: [],
                                    commas: [],
                                },
                                right_parenthesis: 395,
                            },
                            return_type: FunctionLikeReturnTypeDefinition {
                                colon: 396,
                                type_definition: Integer(
                                    398,
                                ),
                            },
                            body: BlockStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_brace: 402,
                                statements: [
                                    Return(
                                        Implicit {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: Identifier(
                                                Identifier {
                                                    position: 408,
                                                    value: "where",
                                                },
                                            ),
                                        },
                                    ),
                                ],
                                right_brace: 414,
                            },
                        },
                    ),
                ],
            },
        ),
        Namespace(
            NamespaceDefinition {
                namespace: 417,
                name: Identifier {
                    position: 427,
                    value: "type",
                },
                semicolon: 431,
                definitions: [
                    Constant(
                        ConstantDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            const: 434,
                            entries: CommaSeparated {
                                inner: [
                                    ConstantDefinitionEntry {
                                        name: Identifier {
                                            position: 440,
                                            value: "type",
                                        },
                                        equals: 445,
                                        value: Literal(
                                            Integer(
                                                LiteralInteger {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    value: "1",
                                                    position: 447,
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                commas: [],
                            },
                            semicolon: 448,
                        },
                    ),
                    Interface(
                        InterfaceDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            interface: 450,
                            name: Identifier {
                                position: 460,
                                value: "type",
                            },
                            templates: None,
                            extends: None,
                            body: InterfaceDefinitionBody {
                                left_brace: 465,
                                members: [],
                                right_brace: 466,
                            },
                        },
                    ),
                    Class(
                        ClassDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            modifiers: ClassModifierDefinitionGroup {
                                modifiers: [],
                            },
                            class: 468,
                            name: Identifier {
                                position: 474,
                                value: "type",
                            },
                            templates: None,
                            extends: None,
                            implements: None,
                            body: ClassDefinitionBody {
                                left_brace: 479,
                                members: [
                                    Constant(
                                        ClassishConstantDefinition {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            attributes: [],
                                            modifiers: ConstantModifierDefinitionGroup {
                                                modifiers: [
                                                    Public(
                                                        485,
                                                    ),
                                                ],
                                            },
                                            const: 492,
                                            entries: CommaSeparated {
                                                inner: [
                                                    ConstantDefinitionEntry {
                                                        name: Identifier {
                                                            position: 498,
                                                            value: "type",
                                                        },
                                                        equals: 503,
                                                        value: Literal(
                                                            Integer(
                                                                LiteralInteger {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    value: "1",
                                                                    position: 505,
                                                                },
                                                            ),
                                                        ),
                                                    },
                                                ],
                                                commas: [],
                                            },
                                            semicolon: 506,
                                        },
                                    ),
                                    ConcreteMethod(
                                        ConcreteMethodDefinition {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            attributes: [],
                                            modifiers: MethodModifierDefinitionGroup {
                                                modifiers: [
                                                    Public(
                                                        513,
                                                    ),
                                                ],
                                            },
                                            function: 520,
                                            name: Identifier {
                                                position: 529,
                                                value: "type",
                                            },
                                            templates: None,
                                            parameters: FunctionLikeParameterListDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left_parenthesis: 533,
                                                parameters: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_parenthesis: 534,
                                            },
                                            return_type: FunctionLikeReturnTypeDefinition {
                                                colon: 535,
                                                type_definition: Void(
                                                    537,
                                                ),
                                            },
                                            constraints: None,
                                            body: BlockStatement {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left_brace: 542,
                                                statements: [],
                                                right_brace: 543,
                                            },
                                        },
                                    ),
                                ],
                                right_brace: 545,
                            },
                        },
                    ),
                    Function(
                        FunctionDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            function: 548,
                            name: Identifier {
                                position: 557,
                                value: "type",
                            },
                            templates: None,
                            parameters: FunctionLikeParameterListDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_parenthesis: 561,
                                parameters: CommaSeparated {
                                    inner: [],
                                    commas: [],
                                },
                                right_parenthesis: 562,
                            },
                            return_type: FunctionLikeReturnTypeDefinition {
                                colon: 563,
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 565,
                                            value: "type",
                                        },
                                        templates: None,
                                    },
                                ),
                            },
                            body: BlockStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_brace: 570,
                                statements: [
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 576,
                                                            name: "$type",
                                                        },
                                                    ),
                                                    equals: 582,
                                                    right: Identifier(
                                                        Identifier {
                                                            position: 584,
                                                            value: "type",
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 588,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 594,
                                                            name: "$type",
                                                        },
                                                    ),
                                                    equals: 600,
                                                    right: ClassOperation(
                                                        Initialization {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            new: 602,
                                                            class: Identifier {
                                                                position: 606,
                                                                value: "type",
                                                            },
                                                            generics: None,
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: 610,
                                                                arguments: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: 611,
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 612,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 618,
                                                            name: "$type",
                                                        },
                                                    ),
                                                    equals: 624,
                                                    right: ClassOperation(
                                                        ConstantFetch {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            class: Identifier(
                                                                Identifier {
                                                                    position: 626,
                                                                    value: "type",
                                                                },
                                                            ),
                                                            double_colon: 630,
                                                            constant: Identifier {
                                                                position: 632,
                                                                value: "type",
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 636,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 642,
                                                            name: "$type",
                                                        },
                                                    ),
                                                    equals: 648,
                                                    right: ClassOperation(
                                                        StaticMethodCall {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            class: Identifier(
                                                                Identifier {
                                                                    position: 650,
                                                                    value: "type",
                                                                },
                                                            ),
                                                            double_colon: 654,
                                                            method: Identifier {
                                                                position: 656,
                                                                value: "type",
                                                            },
                                                            generics: None,
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: 660,
                                                                arguments: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: 661,
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 662,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 668,
                                                            name: "$type",
                                                        },
                                                    ),
                                                    equals: 674,
                                                    right: ClassOperation(
                                                        ConstantFetch {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            class: ClassOperation(
                                                                ConstantFetch {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    class: Identifier(
                                                                        Identifier {
                                                                            position: 676,
                                                                            value: "type",
                                                                        },
                                                                    ),
                                                                    double_colon: 680,
                                                                    constant: Identifier {
                                                                        position: 682,
                                                                        value: "type",
                                                                    },
                                                                },
                                                            ),
                                                            double_colon: 686,
                                                            constant: Identifier {
                                                                position: 688,
                                                                value: "type",
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 692,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 698,
                                                            name: "$type",
                                                        },
                                                    ),
                                                    equals: 704,
                                                    right: ClassOperation(
                                                        StaticMethodCall {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            class: ClassOperation(
                                                                ConstantFetch {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    class: Identifier(
                                                                        Identifier {
                                                                            position: 706,
                                                                            value: "type",
                                                                        },
                                                                    ),
                                                                    double_colon: 710,
                                                                    constant: Identifier {
                                                                        position: 712,
                                                                        value: "type",
                                                                    },
                                                                },
                                                            ),
                                                            double_colon: 716,
                                                            method: Identifier {
                                                                position: 718,
                                                                value: "type",
                                                            },
                                                            generics: None,
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: 722,
                                                                arguments: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: 723,
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 724,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 730,
                                                            name: "$type",
                                                        },
                                                    ),
                                                    equals: 736,
                                                    right: ObjectOperation(
                                                        MethodCall {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            object: Variable(
                                                                Variable {
                                                                    position: 738,
                                                                    name: "$type",
                                                                },
                                                            ),
                                                            arrow: 743,
                                                            method: Identifier {
                                                                position: 745,
                                                                value: "type",
                                                            },
                                                            generics: None,
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: 749,
                                                                arguments: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: 750,
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 751,
                                        },
                                    ),
                                    Return(
                                        Implicit {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: Variable(
                                                Variable {
                                                    position: 758,
                                                    name: "$type",
                                                },
                                            ),
                                        },
                                    ),
                                ],
                                right_brace: 764,
                            },
                        },
                    ),
                    Function(
                        FunctionDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            function: 767,
                            name: Identifier {
                                position: 776,
                                value: "type",
                            },
                            templates: None,
                            parameters: FunctionLikeParameterListDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_parenthesis: 780,
                                parameters: CommaSeparated {
                                    inner: [],
                                    commas: [],
                                },
                                right_parenthesis: 781,
                            },
                            return_type: FunctionLikeReturnTypeDefinition {
                                colon: 782,
                                type_definition: Integer(
                                    784,
                                ),
                            },
                            body: BlockStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_brace: 788,
                                statements: [
                                    Return(
                                        Implicit {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: Identifier(
                                                Identifier {
                                                    position: 794,
                                                    value: "type",
                                                },
                                            ),
                                        },
                                    ),
                                ],
                                right_brace: 799,
                            },
                        },
                    ),
                ],
            },
        ),
    ],
    eof: 801,
}