parser/tests/fixtures/0269/ast.txt

[
    Constant(
        Constant {
            start: (
                3,
                1,
            ),
            end: (
                3,
                17,
            ),
            entries: [
                ConstantEntry {
                    name: Identifier {
                        start: (
                            3,
                            7,
                        ),
                        name: "\xe2\x86\xaa",
                        end: (
                            3,
                            11,
                        ),
                    },
                    value: LiteralString {
                        value: "\n",
                    },
                },
            ],
        },
    ),
    Interface(
        Interface {
            start: (
                5,
                1,
            ),
            end: (
                7,
                1,
            ),
            attributes: [],
            name: Identifier {
                start: (
                    5,
                    11,
                ),
                name: "\xf0\x9f\x94\x8a",
                end: (
                    5,
                    16,
                ),
            },
            extends: None,
            members: [
                Method(
                    Method {
                        start: (
                            6,
                            10,
                        ),
                        end: (
                            6,
                            43,
                        ),
                        name: Identifier {
                            start: (
                                6,
                                19,
                            ),
                            name: "\xf0\x9f\x93\x9d",
                            end: (
                                6,
                                23,
                            ),
                        },
                        attributes: [],
                        parameters: MethodParameterList {
                            start: (
                                6,
                                23,
                            ),
                            end: (
                                6,
                                37,
                            ),
                            members: [
                                MethodParameter {
                                    start: (
                                        6,
                                        24,
                                    ),
                                    end: (
                                        6,
                                        36,
                                    ),
                                    name: Variable {
                                        start: (
                                            6,
                                            31,
                                        ),
                                        name: "\xf0\x9f\x93\x83",
                                        end: (
                                            6,
                                            36,
                                        ),
                                    },
                                    attributes: [],
                                    type: Some(
                                        String,
                                    ),
                                    variadic: false,
                                    default: None,
                                    modifiers: PromotedPropertyModifierGroup {
                                        modifiers: [],
                                    },
                                    by_ref: false,
                                },
                            ],
                        },
                        body: None,
                        modifiers: MethodModifierGroup {
                            modifiers: [
                                Public {
                                    start: (
                                        6,
                                        3,
                                    ),
                                    end: (
                                        6,
                                        10,
                                    ),
                                },
                            ],
                        },
                        return_type: Some(
                            Void,
                        ),
                        by_ref: false,
                    },
                ),
            ],
        },
    ),
    Class(
        Class {
            start: (
                9,
                7,
            ),
            end: (
                13,
                1,
            ),
            name: Identifier {
                start: (
                    9,
                    13,
                ),
                name: "\xf0\x9f\x92\xbb",
                end: (
                    9,
                    18,
                ),
            },
            extends: None,
            implements: Some(
                ClassImplements {
                    span: (
                        9,
                        18,
                    ),
                    interfaces: [
                        Identifier {
                            start: (
                                9,
                                29,
                            ),
                            name: "\xf0\x9f\x94\x8a",
                            end: (
                                9,
                                34,
                            ),
                        },
                    ],
                },
            ),
            attributes: [],
            members: [
                Method(
                    Method {
                        start: (
                            10,
                            10,
                        ),
                        end: (
                            12,
                            3,
                        ),
                        name: Identifier {
                            start: (
                                10,
                                19,
                            ),
                            name: "\xf0\x9f\x93\x9d",
                            end: (
                                10,
                                23,
                            ),
                        },
                        attributes: [],
                        parameters: MethodParameterList {
                            start: (
                                10,
                                23,
                            ),
                            end: (
                                10,
                                37,
                            ),
                            members: [
                                MethodParameter {
                                    start: (
                                        10,
                                        24,
                                    ),
                                    end: (
                                        10,
                                        36,
                                    ),
                                    name: Variable {
                                        start: (
                                            10,
                                            31,
                                        ),
                                        name: "\xf0\x9f\x93\x83",
                                        end: (
                                            10,
                                            36,
                                        ),
                                    },
                                    attributes: [],
                                    type: Some(
                                        String,
                                    ),
                                    variadic: false,
                                    default: None,
                                    modifiers: PromotedPropertyModifierGroup {
                                        modifiers: [],
                                    },
                                    by_ref: false,
                                },
                            ],
                        },
                        body: Some(
                            [
                                Expression {
                                    expr: Print {
                                        span: (
                                            11,
                                            5,
                                        ),
                                        value: Parenthesized {
                                            start: (
                                                11,
                                                10,
                                            ),
                                            expr: Concat {
                                                left: Variable(
                                                    Variable {
                                                        start: (
                                                            11,
                                                            11,
                                                        ),
                                                        name: "\xf0\x9f\x93\x83",
                                                        end: (
                                                            11,
                                                            17,
                                                        ),
                                                    },
                                                ),
                                                span: (
                                                    11,
                                                    17,
                                                ),
                                                right: Identifier(
                                                    Identifier {
                                                        start: (
                                                            11,
                                                            19,
                                                        ),
                                                        name: "\xe2\x86\xaa",
                                                        end: (
                                                            11,
                                                            22,
                                                        ),
                                                    },
                                                ),
                                            },
                                            end: (
                                                11,
                                                22,
                                            ),
                                        },
                                    },
                                },
                            ],
                        ),
                        modifiers: MethodModifierGroup {
                            modifiers: [
                                Public {
                                    start: (
                                        10,
                                        3,
                                    ),
                                    end: (
                                        10,
                                        10,
                                    ),
                                },
                            ],
                        },
                        return_type: Some(
                            Void,
                        ),
                        by_ref: false,
                    },
                ),
            ],
        },
    ),
    Function(
        Function {
            start: (
                15,
                1,
            ),
            end: (
                19,
                1,
            ),
            name: Identifier {
                start: (
                    15,
                    10,
                ),
                name: "\xf0\x9f\x9a\xaa",
                end: (
                    15,
                    14,
                ),
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    15,
                    14,
                ),
                end: (
                    15,
                    16,
                ),
                members: [],
            },
            return_type: Some(
                Void,
            ),
            by_ref: false,
            body: [
                Expression {
                    expr: AssignmentOperation(
                        Assign {
                            left: Variable(
                                Variable {
                                    start: (
                                        16,
                                        3,
                                    ),
                                    name: "\xf0\x9f\x92\xbb",
                                    end: (
                                        16,
                                        9,
                                    ),
                                },
                            ),
                            span: (
                                16,
                                9,
                            ),
                            right: New {
                                target: Identifier(
                                    Identifier {
                                        start: (
                                            16,
                                            15,
                                        ),
                                        name: "\xf0\x9f\x92\xbb",
                                        end: (
                                            16,
                                            19,
                                        ),
                                    },
                                ),
                                span: (
                                    16,
                                    11,
                                ),
                                args: [],
                            },
                        },
                    ),
                },
                Expression {
                    expr: AssignmentOperation(
                        Assign {
                            left: Variable(
                                Variable {
                                    start: (
                                        17,
                                        3,
                                    ),
                                    name: "\xf0\x9f\x93\x84",
                                    end: (
                                        17,
                                        9,
                                    ),
                                },
                            ),
                            span: (
                                17,
                                9,
                            ),
                            right: LiteralString {
                                value: "hello, world",
                            },
                        },
                    ),
                },
                Expression {
                    expr: MethodCall {
                        target: Variable(
                            Variable {
                                start: (
                                    18,
                                    3,
                                ),
                                name: "\xf0\x9f\x92\xbb",
                                end: (
                                    18,
                                    8,
                                ),
                            },
                        ),
                        method: Identifier(
                            Identifier {
                                start: (
                                    18,
                                    10,
                                ),
                                name: "\xf0\x9f\x93\x9d",
                                end: (
                                    18,
                                    14,
                                ),
                            },
                        ),
                        args: [
                            Arg {
                                name: Some(
                                    Identifier {
                                        start: (
                                            18,
                                            15,
                                        ),
                                        name: "\xf0\x9f\x93\x83",
                                        end: (
                                            18,
                                            19,
                                        ),
                                    },
                                ),
                                value: Variable(
                                    Variable {
                                        start: (
                                            18,
                                            21,
                                        ),
                                        name: "\xf0\x9f\x93\x84",
                                        end: (
                                            18,
                                            26,
                                        ),
                                    },
                                ),
                                unpack: false,
                            },
                        ],
                    },
                },
            ],
        },
    ),
    Expression {
        expr: Call {
            target: Identifier(
                Identifier {
                    start: (
                        21,
                        1,
                    ),
                    name: "\xf0\x9f\x9a\xaa",
                    end: (
                        21,
                        5,
                    ),
                },
            ),
            args: [],
        },
    },
    Expression {
        expr: AssignmentOperation(
            Assign {
                left: Variable(
                    Variable {
                        start: (
                            23,
                            1,
                        ),
                        name: "var\xef\xbf\xbd",
                        end: (
                            23,
                            9,
                        ),
                    },
                ),
                span: (
                    23,
                    9,
                ),
                right: LiteralInteger {
                    i: "1",
                },
            },
        ),
    },
    Echo {
        values: [
            Variable(
                Variable {
                    start: (
                        23,
                        19,
                    ),
                    name: "var\xef\xbf\xbd",
                    end: (
                        23,
                        26,
                    ),
                },
            ),
        ],
    },
]