parser/tests/fixtures/0012/ast.txt

[
    Expression {
        expr: Call {
            target: Identifier(
                Identifier {
                    start: (
                        3,
                        1,
                    ),
                    name: "define",
                    end: (
                        3,
                        7,
                    ),
                },
            ),
            args: [
                Arg {
                    name: None,
                    value: LiteralString {
                        value: "a",
                    },
                    unpack: false,
                },
                Arg {
                    name: None,
                    value: Infix {
                        lhs: Variable(
                            Variable {
                                start: (
                                    3,
                                    14,
                                ),
                                name: "a",
                                end: (
                                    3,
                                    17,
                                ),
                            },
                        ),
                        op: Equals,
                        rhs: Variable(
                            Variable {
                                start: (
                                    3,
                                    20,
                                ),
                                name: "b",
                                end: (
                                    3,
                                    22,
                                ),
                            },
                        ),
                    },
                    unpack: false,
                },
            ],
        },
    },
    Expression {
        expr: Call {
            target: Identifier(
                Identifier {
                    start: (
                        4,
                        1,
                    ),
                    name: "define",
                    end: (
                        4,
                        7,
                    ),
                },
            ),
            args: [
                Arg {
                    name: None,
                    value: LiteralString {
                        value: "a",
                    },
                    unpack: false,
                },
                Arg {
                    name: None,
                    value: Infix {
                        lhs: Variable(
                            Variable {
                                start: (
                                    4,
                                    14,
                                ),
                                name: "a",
                                end: (
                                    4,
                                    17,
                                ),
                            },
                        ),
                        op: Identical,
                        rhs: Variable(
                            Variable {
                                start: (
                                    4,
                                    21,
                                ),
                                name: "b",
                                end: (
                                    4,
                                    23,
                                ),
                            },
                        ),
                    },
                    unpack: false,
                },
            ],
        },
    },
    Expression {
        expr: Call {
            target: Identifier(
                Identifier {
                    start: (
                        5,
                        1,
                    ),
                    name: "define",
                    end: (
                        5,
                        7,
                    ),
                },
            ),
            args: [
                Arg {
                    name: None,
                    value: LiteralString {
                        value: "a",
                    },
                    unpack: false,
                },
                Arg {
                    name: None,
                    value: Infix {
                        lhs: Variable(
                            Variable {
                                start: (
                                    5,
                                    14,
                                ),
                                name: "a",
                                end: (
                                    5,
                                    17,
                                ),
                            },
                        ),
                        op: NotEquals,
                        rhs: Variable(
                            Variable {
                                start: (
                                    5,
                                    20,
                                ),
                                name: "b",
                                end: (
                                    5,
                                    22,
                                ),
                            },
                        ),
                    },
                    unpack: false,
                },
            ],
        },
    },
    Expression {
        expr: Call {
            target: Identifier(
                Identifier {
                    start: (
                        6,
                        1,
                    ),
                    name: "define",
                    end: (
                        6,
                        7,
                    ),
                },
            ),
            args: [
                Arg {
                    name: None,
                    value: LiteralString {
                        value: "a",
                    },
                    unpack: false,
                },
                Arg {
                    name: None,
                    value: Infix {
                        lhs: Variable(
                            Variable {
                                start: (
                                    6,
                                    14,
                                ),
                                name: "a",
                                end: (
                                    6,
                                    17,
                                ),
                            },
                        ),
                        op: NotIdentical,
                        rhs: Variable(
                            Variable {
                                start: (
                                    6,
                                    21,
                                ),
                                name: "b",
                                end: (
                                    6,
                                    23,
                                ),
                            },
                        ),
                    },
                    unpack: false,
                },
            ],
        },
    },
    Expression {
        expr: Call {
            target: Identifier(
                Identifier {
                    start: (
                        7,
                        1,
                    ),
                    name: "define",
                    end: (
                        7,
                        7,
                    ),
                },
            ),
            args: [
                Arg {
                    name: None,
                    value: LiteralString {
                        value: "a",
                    },
                    unpack: false,
                },
                Arg {
                    name: None,
                    value: Infix {
                        lhs: Variable(
                            Variable {
                                start: (
                                    7,
                                    14,
                                ),
                                name: "a",
                                end: (
                                    7,
                                    17,
                                ),
                            },
                        ),
                        op: Add,
                        rhs: Variable(
                            Variable {
                                start: (
                                    7,
                                    19,
                                ),
                                name: "b",
                                end: (
                                    7,
                                    21,
                                ),
                            },
                        ),
                    },
                    unpack: false,
                },
            ],
        },
    },
    Expression {
        expr: Call {
            target: Identifier(
                Identifier {
                    start: (
                        8,
                        1,
                    ),
                    name: "define",
                    end: (
                        8,
                        7,
                    ),
                },
            ),
            args: [
                Arg {
                    name: None,
                    value: LiteralString {
                        value: "a",
                    },
                    unpack: false,
                },
                Arg {
                    name: None,
                    value: Infix {
                        lhs: Variable(
                            Variable {
                                start: (
                                    8,
                                    14,
                                ),
                                name: "a",
                                end: (
                                    8,
                                    17,
                                ),
                            },
                        ),
                        op: Sub,
                        rhs: Variable(
                            Variable {
                                start: (
                                    8,
                                    19,
                                ),
                                name: "b",
                                end: (
                                    8,
                                    21,
                                ),
                            },
                        ),
                    },
                    unpack: false,
                },
            ],
        },
    },
    Expression {
        expr: Call {
            target: Identifier(
                Identifier {
                    start: (
                        9,
                        1,
                    ),
                    name: "define",
                    end: (
                        9,
                        7,
                    ),
                },
            ),
            args: [
                Arg {
                    name: None,
                    value: LiteralString {
                        value: "a",
                    },
                    unpack: false,
                },
                Arg {
                    name: None,
                    value: Infix {
                        lhs: Variable(
                            Variable {
                                start: (
                                    9,
                                    14,
                                ),
                                name: "a",
                                end: (
                                    9,
                                    17,
                                ),
                            },
                        ),
                        op: Div,
                        rhs: Variable(
                            Variable {
                                start: (
                                    9,
                                    19,
                                ),
                                name: "b",
                                end: (
                                    9,
                                    21,
                                ),
                            },
                        ),
                    },
                    unpack: false,
                },
            ],
        },
    },
    Expression {
        expr: Call {
            target: Identifier(
                Identifier {
                    start: (
                        10,
                        1,
                    ),
                    name: "define",
                    end: (
                        10,
                        7,
                    ),
                },
            ),
            args: [
                Arg {
                    name: None,
                    value: LiteralString {
                        value: "a",
                    },
                    unpack: false,
                },
                Arg {
                    name: None,
                    value: Infix {
                        lhs: Variable(
                            Variable {
                                start: (
                                    10,
                                    14,
                                ),
                                name: "a",
                                end: (
                                    10,
                                    17,
                                ),
                            },
                        ),
                        op: BitwiseXor,
                        rhs: Variable(
                            Variable {
                                start: (
                                    10,
                                    19,
                                ),
                                name: "b",
                                end: (
                                    10,
                                    21,
                                ),
                            },
                        ),
                    },
                    unpack: false,
                },
            ],
        },
    },
    Expression {
        expr: Call {
            target: Identifier(
                Identifier {
                    start: (
                        11,
                        1,
                    ),
                    name: "define",
                    end: (
                        11,
                        7,
                    ),
                },
            ),
            args: [
                Arg {
                    name: None,
                    value: LiteralString {
                        value: "a",
                    },
                    unpack: false,
                },
                Arg {
                    name: None,
                    value: Infix {
                        lhs: Variable(
                            Variable {
                                start: (
                                    11,
                                    14,
                                ),
                                name: "a",
                                end: (
                                    11,
                                    17,
                                ),
                            },
                        ),
                        op: Mul,
                        rhs: Variable(
                            Variable {
                                start: (
                                    11,
                                    19,
                                ),
                                name: "b",
                                end: (
                                    11,
                                    21,
                                ),
                            },
                        ),
                    },
                    unpack: false,
                },
            ],
        },
    },
    Expression {
        expr: Call {
            target: Identifier(
                Identifier {
                    start: (
                        12,
                        1,
                    ),
                    name: "define",
                    end: (
                        12,
                        7,
                    ),
                },
            ),
            args: [
                Arg {
                    name: None,
                    value: LiteralString {
                        value: "a",
                    },
                    unpack: false,
                },
                Arg {
                    name: None,
                    value: Infix {
                        lhs: Variable(
                            Variable {
                                start: (
                                    12,
                                    14,
                                ),
                                name: "a",
                                end: (
                                    12,
                                    17,
                                ),
                            },
                        ),
                        op: RightShift,
                        rhs: Variable(
                            Variable {
                                start: (
                                    12,
                                    20,
                                ),
                                name: "b",
                                end: (
                                    12,
                                    22,
                                ),
                            },
                        ),
                    },
                    unpack: false,
                },
            ],
        },
    },
    Expression {
        expr: Call {
            target: Identifier(
                Identifier {
                    start: (
                        13,
                        1,
                    ),
                    name: "define",
                    end: (
                        13,
                        7,
                    ),
                },
            ),
            args: [
                Arg {
                    name: None,
                    value: LiteralString {
                        value: "a",
                    },
                    unpack: false,
                },
                Arg {
                    name: None,
                    value: Infix {
                        lhs: Variable(
                            Variable {
                                start: (
                                    13,
                                    14,
                                ),
                                name: "a",
                                end: (
                                    13,
                                    17,
                                ),
                            },
                        ),
                        op: LeftShift,
                        rhs: Variable(
                            Variable {
                                start: (
                                    13,
                                    20,
                                ),
                                name: "b",
                                end: (
                                    13,
                                    22,
                                ),
                            },
                        ),
                    },
                    unpack: false,
                },
            ],
        },
    },
    Expression {
        expr: Call {
            target: Identifier(
                Identifier {
                    start: (
                        14,
                        1,
                    ),
                    name: "define",
                    end: (
                        14,
                        7,
                    ),
                },
            ),
            args: [
                Arg {
                    name: None,
                    value: LiteralString {
                        value: "a",
                    },
                    unpack: false,
                },
                Arg {
                    name: None,
                    value: Infix {
                        lhs: Variable(
                            Variable {
                                start: (
                                    14,
                                    14,
                                ),
                                name: "a",
                                end: (
                                    14,
                                    17,
                                ),
                            },
                        ),
                        op: BitwiseOr,
                        rhs: Variable(
                            Variable {
                                start: (
                                    14,
                                    19,
                                ),
                                name: "b",
                                end: (
                                    14,
                                    21,
                                ),
                            },
                        ),
                    },
                    unpack: false,
                },
            ],
        },
    },
    Expression {
        expr: Call {
            target: Identifier(
                Identifier {
                    start: (
                        15,
                        1,
                    ),
                    name: "define",
                    end: (
                        15,
                        7,
                    ),
                },
            ),
            args: [
                Arg {
                    name: None,
                    value: LiteralString {
                        value: "a",
                    },
                    unpack: false,
                },
                Arg {
                    name: None,
                    value: Infix {
                        lhs: Variable(
                            Variable {
                                start: (
                                    15,
                                    14,
                                ),
                                name: "a",
                                end: (
                                    15,
                                    17,
                                ),
                            },
                        ),
                        op: BitwiseAnd,
                        rhs: Variable(
                            Variable {
                                start: (
                                    15,
                                    19,
                                ),
                                name: "b",
                                end: (
                                    15,
                                    21,
                                ),
                            },
                        ),
                    },
                    unpack: false,
                },
            ],
        },
    },
    Echo {
        values: [
            Infix {
                lhs: Infix {
                    lhs: Variable(
                        Variable {
                            start: (
                                17,
                                7,
                            ),
                            name: "a",
                            end: (
                                17,
                                10,
                            ),
                        },
                    ),
                    op: Add,
                    rhs: Variable(
                        Variable {
                            start: (
                                17,
                                12,
                            ),
                            name: "b",
                            end: (
                                17,
                                14,
                            ),
                        },
                    ),
                },
                op: Mul,
                rhs: Infix {
                    lhs: Infix {
                        lhs: Variable(
                            Variable {
                                start: (
                                    17,
                                    19,
                                ),
                                name: "c",
                                end: (
                                    17,
                                    22,
                                ),
                            },
                        ),
                        op: Div,
                        rhs: Variable(
                            Variable {
                                start: (
                                    17,
                                    24,
                                ),
                                name: "d",
                                end: (
                                    17,
                                    27,
                                ),
                            },
                        ),
                    },
                    op: Sub,
                    rhs: DynamicVariable {
                        name: Ternary {
                            condition: Infix {
                                lhs: LiteralString {
                                    value: "foo",
                                },
                                op: Concat,
                                rhs: Variable(
                                    Variable {
                                        start: (
                                            17,
                                            39,
                                        ),
                                        name: "c",
                                        end: (
                                            17,
                                            42,
                                        ),
                                    },
                                ),
                            },
                            then: Some(
                                LiteralInteger {
                                    i: 4,
                                },
                            ),
                            else: LiteralInteger {
                                i: 3,
                            },
                        },
                    },
                },
            },
        ],
    },
]