[
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    3,
                    1,
                ),
                end: (
                    3,
                    45,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        3,
                        11,
                    ),
                    end: (
                        3,
                        23,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                3,
                                12,
                            ),
                            end: (
                                3,
                                22,
                            ),
                            name: SimpleVariable {
                                span: (
                                    3,
                                    20,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Identifier(
                                    SimpleIdentifier {
                                        span: (
                                            3,
                                            12,
                                        ),
                                        value: "Foo",
                                    },
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                3,
                                25,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    3,
                                    32,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        3,
                        35,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    3,
                                    37,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            3,
                            41,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                3,
                                                42,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            3,
                            44,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            3,
            45,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    4,
                    1,
                ),
                end: (
                    4,
                    44,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        4,
                        11,
                    ),
                    end: (
                        4,
                        22,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                4,
                                12,
                            ),
                            end: (
                                4,
                                21,
                            ),
                            name: SimpleVariable {
                                span: (
                                    4,
                                    19,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Identifier(
                                    SimpleIdentifier {
                                        span: (
                                            4,
                                            12,
                                        ),
                                        value: "Foo",
                                    },
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                4,
                                24,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    4,
                                    31,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        4,
                        34,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    4,
                                    36,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            4,
                            40,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                4,
                                                41,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            4,
                            43,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            4,
            44,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    5,
                    1,
                ),
                end: (
                    5,
                    42,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        5,
                        11,
                    ),
                    end: (
                        5,
                        20,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                5,
                                12,
                            ),
                            end: (
                                5,
                                19,
                            ),
                            name: SimpleVariable {
                                span: (
                                    5,
                                    17,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Identifier(
                                    SimpleIdentifier {
                                        span: (
                                            5,
                                            12,
                                        ),
                                        value: "Foo",
                                    },
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                5,
                                22,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    5,
                                    29,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        5,
                        32,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    5,
                                    34,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            5,
                            38,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                5,
                                                39,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            5,
                            41,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            5,
            42,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    6,
                    1,
                ),
                end: (
                    6,
                    41,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        6,
                        11,
                    ),
                    end: (
                        6,
                        19,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                6,
                                12,
                            ),
                            end: (
                                6,
                                18,
                            ),
                            name: SimpleVariable {
                                span: (
                                    6,
                                    16,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Identifier(
                                    SimpleIdentifier {
                                        span: (
                                            6,
                                            12,
                                        ),
                                        value: "Foo",
                                    },
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                6,
                                21,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    6,
                                    28,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        6,
                        31,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    6,
                                    33,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            6,
                            37,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                6,
                                                38,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            6,
                            40,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            6,
            41,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    7,
                    1,
                ),
                end: (
                    7,
                    59,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        7,
                        17,
                    ),
                    end: (
                        7,
                        29,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                7,
                                18,
                            ),
                            end: (
                                7,
                                28,
                            ),
                            name: SimpleVariable {
                                span: (
                                    7,
                                    26,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Identifier(
                                    SimpleIdentifier {
                                        span: (
                                            7,
                                            18,
                                        ),
                                        value: "Foo",
                                    },
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                7,
                                31,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                7,
                                                44,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    7,
                                    47,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                7,
                                                49,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        7,
                                        53,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            7,
                                                            54,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        7,
                                        56,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            7,
            60,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    8,
                    1,
                ),
                end: (
                    8,
                    58,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        8,
                        17,
                    ),
                    end: (
                        8,
                        28,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                8,
                                18,
                            ),
                            end: (
                                8,
                                27,
                            ),
                            name: SimpleVariable {
                                span: (
                                    8,
                                    25,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Identifier(
                                    SimpleIdentifier {
                                        span: (
                                            8,
                                            18,
                                        ),
                                        value: "Foo",
                                    },
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                8,
                                30,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                8,
                                                43,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    8,
                                    46,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                8,
                                                48,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        8,
                                        52,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            8,
                                                            53,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        8,
                                        55,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            8,
            59,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    9,
                    1,
                ),
                end: (
                    9,
                    56,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        9,
                        17,
                    ),
                    end: (
                        9,
                        26,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                9,
                                18,
                            ),
                            end: (
                                9,
                                25,
                            ),
                            name: SimpleVariable {
                                span: (
                                    9,
                                    23,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Identifier(
                                    SimpleIdentifier {
                                        span: (
                                            9,
                                            18,
                                        ),
                                        value: "Foo",
                                    },
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                9,
                                28,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                9,
                                                41,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    9,
                                    44,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                9,
                                                46,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        9,
                                        50,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            9,
                                                            51,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        9,
                                        53,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            9,
            57,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    10,
                    1,
                ),
                end: (
                    10,
                    55,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        10,
                        17,
                    ),
                    end: (
                        10,
                        25,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                10,
                                18,
                            ),
                            end: (
                                10,
                                24,
                            ),
                            name: SimpleVariable {
                                span: (
                                    10,
                                    22,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Identifier(
                                    SimpleIdentifier {
                                        span: (
                                            10,
                                            18,
                                        ),
                                        value: "Foo",
                                    },
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                10,
                                27,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                10,
                                                40,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    10,
                                    43,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                10,
                                                45,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        10,
                                        49,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            10,
                                                            50,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        10,
                                        52,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            10,
            56,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    11,
                    1,
                ),
                end: (
                    11,
                    53,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        11,
                        11,
                    ),
                    end: (
                        11,
                        31,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                11,
                                12,
                            ),
                            end: (
                                11,
                                30,
                            ),
                            name: SimpleVariable {
                                span: (
                                    11,
                                    28,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    11,
                                                    12,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    11,
                                                    16,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    11,
                                                    20,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                11,
                                33,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    11,
                                    40,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        11,
                        43,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    11,
                                    45,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            11,
                            49,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                11,
                                                50,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            11,
                            52,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            11,
            53,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    12,
                    1,
                ),
                end: (
                    12,
                    52,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        12,
                        11,
                    ),
                    end: (
                        12,
                        30,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                12,
                                12,
                            ),
                            end: (
                                12,
                                29,
                            ),
                            name: SimpleVariable {
                                span: (
                                    12,
                                    27,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    12,
                                                    12,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    12,
                                                    16,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    12,
                                                    20,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                12,
                                32,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    12,
                                    39,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        12,
                        42,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    12,
                                    44,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            12,
                            48,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                12,
                                                49,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            12,
                            51,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            12,
            52,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    13,
                    1,
                ),
                end: (
                    13,
                    50,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        13,
                        11,
                    ),
                    end: (
                        13,
                        28,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                13,
                                12,
                            ),
                            end: (
                                13,
                                27,
                            ),
                            name: SimpleVariable {
                                span: (
                                    13,
                                    25,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    13,
                                                    12,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    13,
                                                    16,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    13,
                                                    20,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                13,
                                30,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    13,
                                    37,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        13,
                        40,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    13,
                                    42,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            13,
                            46,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                13,
                                                47,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            13,
                            49,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            13,
            50,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    14,
                    1,
                ),
                end: (
                    14,
                    49,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        14,
                        11,
                    ),
                    end: (
                        14,
                        27,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                14,
                                12,
                            ),
                            end: (
                                14,
                                26,
                            ),
                            name: SimpleVariable {
                                span: (
                                    14,
                                    24,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    14,
                                                    12,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    14,
                                                    16,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    14,
                                                    20,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                14,
                                29,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    14,
                                    36,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        14,
                        39,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    14,
                                    41,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            14,
                            45,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                14,
                                                46,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            14,
                            48,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            14,
            49,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    15,
                    1,
                ),
                end: (
                    15,
                    67,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        15,
                        17,
                    ),
                    end: (
                        15,
                        37,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                15,
                                18,
                            ),
                            end: (
                                15,
                                36,
                            ),
                            name: SimpleVariable {
                                span: (
                                    15,
                                    34,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    15,
                                                    18,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    15,
                                                    22,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    15,
                                                    26,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                15,
                                39,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                15,
                                                52,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    15,
                                    55,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                15,
                                                57,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        15,
                                        61,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            15,
                                                            62,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        15,
                                        64,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            15,
            68,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    16,
                    1,
                ),
                end: (
                    16,
                    66,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        16,
                        17,
                    ),
                    end: (
                        16,
                        36,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                16,
                                18,
                            ),
                            end: (
                                16,
                                35,
                            ),
                            name: SimpleVariable {
                                span: (
                                    16,
                                    33,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    16,
                                                    18,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    16,
                                                    22,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    16,
                                                    26,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                16,
                                38,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                16,
                                                51,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    16,
                                    54,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                16,
                                                56,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        16,
                                        60,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            16,
                                                            61,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        16,
                                        63,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            16,
            67,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    17,
                    1,
                ),
                end: (
                    17,
                    64,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        17,
                        17,
                    ),
                    end: (
                        17,
                        34,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                17,
                                18,
                            ),
                            end: (
                                17,
                                33,
                            ),
                            name: SimpleVariable {
                                span: (
                                    17,
                                    31,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    17,
                                                    18,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    17,
                                                    22,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    17,
                                                    26,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                17,
                                36,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                17,
                                                49,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    17,
                                    52,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                17,
                                                54,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        17,
                                        58,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            17,
                                                            59,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        17,
                                        61,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            17,
            65,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    18,
                    1,
                ),
                end: (
                    18,
                    63,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        18,
                        17,
                    ),
                    end: (
                        18,
                        33,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                18,
                                18,
                            ),
                            end: (
                                18,
                                32,
                            ),
                            name: SimpleVariable {
                                span: (
                                    18,
                                    30,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    18,
                                                    18,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    18,
                                                    22,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    18,
                                                    26,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                18,
                                35,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                18,
                                                48,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    18,
                                    51,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                18,
                                                53,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        18,
                                        57,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            18,
                                                            58,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        18,
                                        60,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            18,
            64,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    19,
                    1,
                ),
                end: (
                    19,
                    53,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        19,
                        11,
                    ),
                    end: (
                        19,
                        31,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                19,
                                12,
                            ),
                            end: (
                                19,
                                30,
                            ),
                            name: SimpleVariable {
                                span: (
                                    19,
                                    28,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    19,
                                                    12,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    19,
                                                    16,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    19,
                                                    20,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                19,
                                33,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    19,
                                    40,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        19,
                        43,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    19,
                                    45,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            19,
                            49,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                19,
                                                50,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            19,
                            52,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            19,
            53,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    20,
                    1,
                ),
                end: (
                    20,
                    52,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        20,
                        11,
                    ),
                    end: (
                        20,
                        30,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                20,
                                12,
                            ),
                            end: (
                                20,
                                29,
                            ),
                            name: SimpleVariable {
                                span: (
                                    20,
                                    27,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    20,
                                                    12,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    20,
                                                    16,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    20,
                                                    20,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                20,
                                32,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    20,
                                    39,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        20,
                        42,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    20,
                                    44,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            20,
                            48,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                20,
                                                49,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            20,
                            51,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            20,
            52,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    21,
                    1,
                ),
                end: (
                    21,
                    50,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        21,
                        11,
                    ),
                    end: (
                        21,
                        28,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                21,
                                12,
                            ),
                            end: (
                                21,
                                27,
                            ),
                            name: SimpleVariable {
                                span: (
                                    21,
                                    25,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    21,
                                                    12,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    21,
                                                    16,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    21,
                                                    20,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                21,
                                30,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    21,
                                    37,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        21,
                        40,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    21,
                                    42,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            21,
                            46,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                21,
                                                47,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            21,
                            49,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            21,
            50,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    22,
                    1,
                ),
                end: (
                    22,
                    49,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        22,
                        11,
                    ),
                    end: (
                        22,
                        27,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                22,
                                12,
                            ),
                            end: (
                                22,
                                26,
                            ),
                            name: SimpleVariable {
                                span: (
                                    22,
                                    24,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    22,
                                                    12,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    22,
                                                    16,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    22,
                                                    20,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                22,
                                29,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    22,
                                    36,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        22,
                        39,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    22,
                                    41,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            22,
                            45,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                22,
                                                46,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            22,
                            48,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            22,
            49,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    23,
                    1,
                ),
                end: (
                    23,
                    67,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        23,
                        17,
                    ),
                    end: (
                        23,
                        37,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                23,
                                18,
                            ),
                            end: (
                                23,
                                36,
                            ),
                            name: SimpleVariable {
                                span: (
                                    23,
                                    34,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    23,
                                                    18,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    23,
                                                    22,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    23,
                                                    26,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                23,
                                39,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                23,
                                                52,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    23,
                                    55,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                23,
                                                57,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        23,
                                        61,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            23,
                                                            62,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        23,
                                        64,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            23,
            68,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    24,
                    1,
                ),
                end: (
                    24,
                    66,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        24,
                        17,
                    ),
                    end: (
                        24,
                        36,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                24,
                                18,
                            ),
                            end: (
                                24,
                                35,
                            ),
                            name: SimpleVariable {
                                span: (
                                    24,
                                    33,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    24,
                                                    18,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    24,
                                                    22,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    24,
                                                    26,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                24,
                                38,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                24,
                                                51,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    24,
                                    54,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                24,
                                                56,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        24,
                                        60,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            24,
                                                            61,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        24,
                                        63,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            24,
            67,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    25,
                    1,
                ),
                end: (
                    25,
                    64,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        25,
                        17,
                    ),
                    end: (
                        25,
                        34,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                25,
                                18,
                            ),
                            end: (
                                25,
                                33,
                            ),
                            name: SimpleVariable {
                                span: (
                                    25,
                                    31,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    25,
                                                    18,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    25,
                                                    22,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    25,
                                                    26,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                25,
                                36,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                25,
                                                49,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    25,
                                    52,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                25,
                                                54,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        25,
                                        58,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            25,
                                                            59,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        25,
                                        61,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            25,
            65,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    26,
                    1,
                ),
                end: (
                    26,
                    63,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        26,
                        17,
                    ),
                    end: (
                        26,
                        33,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                26,
                                18,
                            ),
                            end: (
                                26,
                                32,
                            ),
                            name: SimpleVariable {
                                span: (
                                    26,
                                    30,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    26,
                                                    18,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    26,
                                                    22,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    26,
                                                    26,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                26,
                                35,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                26,
                                                48,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    26,
                                    51,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                26,
                                                53,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        26,
                                        57,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            26,
                                                            58,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        26,
                                        60,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            26,
            64,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    27,
                    1,
                ),
                end: (
                    27,
                    55,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        27,
                        11,
                    ),
                    end: (
                        27,
                        33,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                27,
                                12,
                            ),
                            end: (
                                27,
                                32,
                            ),
                            name: SimpleVariable {
                                span: (
                                    27,
                                    30,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    27,
                                                    12,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Intersection(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            27,
                                                            17,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            27,
                                                            21,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                27,
                                35,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    27,
                                    42,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        27,
                        45,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    27,
                                    47,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            27,
                            51,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                27,
                                                52,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            27,
                            54,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            27,
            55,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    28,
                    1,
                ),
                end: (
                    28,
                    54,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        28,
                        11,
                    ),
                    end: (
                        28,
                        32,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                28,
                                12,
                            ),
                            end: (
                                28,
                                31,
                            ),
                            name: SimpleVariable {
                                span: (
                                    28,
                                    29,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    28,
                                                    12,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Intersection(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            28,
                                                            17,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            28,
                                                            21,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                28,
                                34,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    28,
                                    41,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        28,
                        44,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    28,
                                    46,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            28,
                            50,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                28,
                                                51,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            28,
                            53,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            28,
            54,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    29,
                    1,
                ),
                end: (
                    29,
                    52,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        29,
                        11,
                    ),
                    end: (
                        29,
                        30,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                29,
                                12,
                            ),
                            end: (
                                29,
                                29,
                            ),
                            name: SimpleVariable {
                                span: (
                                    29,
                                    27,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    29,
                                                    12,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Intersection(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            29,
                                                            17,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            29,
                                                            21,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                29,
                                32,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    29,
                                    39,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        29,
                        42,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    29,
                                    44,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            29,
                            48,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                29,
                                                49,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            29,
                            51,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            29,
            52,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    30,
                    1,
                ),
                end: (
                    30,
                    51,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        30,
                        11,
                    ),
                    end: (
                        30,
                        29,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                30,
                                12,
                            ),
                            end: (
                                30,
                                28,
                            ),
                            name: SimpleVariable {
                                span: (
                                    30,
                                    26,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    30,
                                                    12,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Intersection(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            30,
                                                            17,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            30,
                                                            21,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                30,
                                31,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    30,
                                    38,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        30,
                        41,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    30,
                                    43,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            30,
                            47,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                30,
                                                48,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            30,
                            50,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            30,
            51,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    31,
                    1,
                ),
                end: (
                    31,
                    69,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        31,
                        17,
                    ),
                    end: (
                        31,
                        39,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                31,
                                18,
                            ),
                            end: (
                                31,
                                38,
                            ),
                            name: SimpleVariable {
                                span: (
                                    31,
                                    36,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    31,
                                                    18,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Intersection(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            31,
                                                            23,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            31,
                                                            27,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                31,
                                41,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                31,
                                                54,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    31,
                                    57,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                31,
                                                59,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        31,
                                        63,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            31,
                                                            64,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        31,
                                        66,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            31,
            70,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    32,
                    1,
                ),
                end: (
                    32,
                    68,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        32,
                        17,
                    ),
                    end: (
                        32,
                        38,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                32,
                                18,
                            ),
                            end: (
                                32,
                                37,
                            ),
                            name: SimpleVariable {
                                span: (
                                    32,
                                    35,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    32,
                                                    18,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Intersection(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            32,
                                                            23,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            32,
                                                            27,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                32,
                                40,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                32,
                                                53,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    32,
                                    56,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                32,
                                                58,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        32,
                                        62,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            32,
                                                            63,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        32,
                                        65,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            32,
            69,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    33,
                    1,
                ),
                end: (
                    33,
                    66,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        33,
                        17,
                    ),
                    end: (
                        33,
                        36,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                33,
                                18,
                            ),
                            end: (
                                33,
                                35,
                            ),
                            name: SimpleVariable {
                                span: (
                                    33,
                                    33,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    33,
                                                    18,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Intersection(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            33,
                                                            23,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            33,
                                                            27,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                33,
                                38,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                33,
                                                51,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    33,
                                    54,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                33,
                                                56,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        33,
                                        60,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            33,
                                                            61,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        33,
                                        63,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            33,
            67,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    34,
                    1,
                ),
                end: (
                    34,
                    65,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        34,
                        17,
                    ),
                    end: (
                        34,
                        35,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                34,
                                18,
                            ),
                            end: (
                                34,
                                34,
                            ),
                            name: SimpleVariable {
                                span: (
                                    34,
                                    32,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    34,
                                                    18,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Intersection(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            34,
                                                            23,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            34,
                                                            27,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                34,
                                37,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                34,
                                                50,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    34,
                                    53,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                34,
                                                55,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        34,
                                        59,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            34,
                                                            60,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        34,
                                        62,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            34,
            66,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    35,
                    1,
                ),
                end: (
                    35,
                    55,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        35,
                        11,
                    ),
                    end: (
                        35,
                        33,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                35,
                                12,
                            ),
                            end: (
                                35,
                                32,
                            ),
                            name: SimpleVariable {
                                span: (
                                    35,
                                    30,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    35,
                                                    12,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Union(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            35,
                                                            17,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            35,
                                                            21,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                35,
                                35,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    35,
                                    42,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        35,
                        45,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    35,
                                    47,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            35,
                            51,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                35,
                                                52,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            35,
                            54,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            35,
            55,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    36,
                    1,
                ),
                end: (
                    36,
                    54,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        36,
                        11,
                    ),
                    end: (
                        36,
                        32,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                36,
                                12,
                            ),
                            end: (
                                36,
                                31,
                            ),
                            name: SimpleVariable {
                                span: (
                                    36,
                                    29,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    36,
                                                    12,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Union(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            36,
                                                            17,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            36,
                                                            21,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                36,
                                34,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    36,
                                    41,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        36,
                        44,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    36,
                                    46,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            36,
                            50,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                36,
                                                51,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            36,
                            53,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            36,
            54,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    37,
                    1,
                ),
                end: (
                    37,
                    52,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        37,
                        11,
                    ),
                    end: (
                        37,
                        30,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                37,
                                12,
                            ),
                            end: (
                                37,
                                29,
                            ),
                            name: SimpleVariable {
                                span: (
                                    37,
                                    27,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    37,
                                                    12,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Union(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            37,
                                                            17,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            37,
                                                            21,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                37,
                                32,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    37,
                                    39,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        37,
                        42,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    37,
                                    44,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            37,
                            48,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                37,
                                                49,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            37,
                            51,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            37,
            52,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    38,
                    1,
                ),
                end: (
                    38,
                    51,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        38,
                        11,
                    ),
                    end: (
                        38,
                        29,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                38,
                                12,
                            ),
                            end: (
                                38,
                                28,
                            ),
                            name: SimpleVariable {
                                span: (
                                    38,
                                    26,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    38,
                                                    12,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Union(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            38,
                                                            17,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            38,
                                                            21,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                38,
                                31,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    38,
                                    38,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        38,
                        41,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    38,
                                    43,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            38,
                            47,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                38,
                                                48,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            38,
                            50,
                        ),
                    },
                },
                static: true,
            },
        ),
        end: (
            38,
            51,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    39,
                    1,
                ),
                end: (
                    39,
                    69,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        39,
                        17,
                    ),
                    end: (
                        39,
                        39,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                39,
                                18,
                            ),
                            end: (
                                39,
                                38,
                            ),
                            name: SimpleVariable {
                                span: (
                                    39,
                                    36,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    39,
                                                    18,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Union(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            39,
                                                            23,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            39,
                                                            27,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                39,
                                41,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                39,
                                                54,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    39,
                                    57,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                39,
                                                59,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        39,
                                        63,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            39,
                                                            64,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        39,
                                        66,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            39,
            70,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    40,
                    1,
                ),
                end: (
                    40,
                    68,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        40,
                        17,
                    ),
                    end: (
                        40,
                        38,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                40,
                                18,
                            ),
                            end: (
                                40,
                                37,
                            ),
                            name: SimpleVariable {
                                span: (
                                    40,
                                    35,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    40,
                                                    18,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Union(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            40,
                                                            23,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            40,
                                                            27,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                40,
                                40,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                40,
                                                53,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    40,
                                    56,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                40,
                                                58,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        40,
                                        62,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            40,
                                                            63,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        40,
                                        65,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            40,
            69,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    41,
                    1,
                ),
                end: (
                    41,
                    66,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        41,
                        17,
                    ),
                    end: (
                        41,
                        36,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                41,
                                18,
                            ),
                            end: (
                                41,
                                35,
                            ),
                            name: SimpleVariable {
                                span: (
                                    41,
                                    33,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    41,
                                                    18,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Union(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            41,
                                                            23,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            41,
                                                            27,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                41,
                                38,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                41,
                                                51,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    41,
                                    54,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                41,
                                                56,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        41,
                                        60,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            41,
                                                            61,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        41,
                                        63,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            41,
            67,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    42,
                    1,
                ),
                end: (
                    42,
                    65,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        42,
                        17,
                    ),
                    end: (
                        42,
                        35,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                42,
                                18,
                            ),
                            end: (
                                42,
                                34,
                            ),
                            name: SimpleVariable {
                                span: (
                                    42,
                                    32,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    42,
                                                    18,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Union(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            42,
                                                            23,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            42,
                                                            27,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                42,
                                37,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                42,
                                                50,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    42,
                                    53,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                42,
                                                55,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        42,
                                        59,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            42,
                                                            60,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        42,
                                        62,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: true,
            },
        ),
        end: (
            42,
            66,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    44,
                    1,
                ),
                end: (
                    44,
                    38,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        44,
                        4,
                    ),
                    end: (
                        44,
                        16,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                44,
                                5,
                            ),
                            end: (
                                44,
                                15,
                            ),
                            name: SimpleVariable {
                                span: (
                                    44,
                                    13,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Identifier(
                                    SimpleIdentifier {
                                        span: (
                                            44,
                                            5,
                                        ),
                                        value: "Foo",
                                    },
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                44,
                                18,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    44,
                                    25,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        44,
                        28,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    44,
                                    30,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            44,
                            34,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                44,
                                                35,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            44,
                            37,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            44,
            38,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    45,
                    1,
                ),
                end: (
                    45,
                    37,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        45,
                        4,
                    ),
                    end: (
                        45,
                        15,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                45,
                                5,
                            ),
                            end: (
                                45,
                                14,
                            ),
                            name: SimpleVariable {
                                span: (
                                    45,
                                    12,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Identifier(
                                    SimpleIdentifier {
                                        span: (
                                            45,
                                            5,
                                        ),
                                        value: "Foo",
                                    },
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                45,
                                17,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    45,
                                    24,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        45,
                        27,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    45,
                                    29,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            45,
                            33,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                45,
                                                34,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            45,
                            36,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            45,
            37,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    46,
                    1,
                ),
                end: (
                    46,
                    35,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        46,
                        4,
                    ),
                    end: (
                        46,
                        13,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                46,
                                5,
                            ),
                            end: (
                                46,
                                12,
                            ),
                            name: SimpleVariable {
                                span: (
                                    46,
                                    10,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Identifier(
                                    SimpleIdentifier {
                                        span: (
                                            46,
                                            5,
                                        ),
                                        value: "Foo",
                                    },
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                46,
                                15,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    46,
                                    22,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        46,
                        25,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    46,
                                    27,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            46,
                            31,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                46,
                                                32,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            46,
                            34,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            46,
            35,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    47,
                    1,
                ),
                end: (
                    47,
                    34,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        47,
                        4,
                    ),
                    end: (
                        47,
                        12,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                47,
                                5,
                            ),
                            end: (
                                47,
                                11,
                            ),
                            name: SimpleVariable {
                                span: (
                                    47,
                                    9,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Identifier(
                                    SimpleIdentifier {
                                        span: (
                                            47,
                                            5,
                                        ),
                                        value: "Foo",
                                    },
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                47,
                                14,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    47,
                                    21,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        47,
                        24,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    47,
                                    26,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            47,
                            30,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                47,
                                                31,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            47,
                            33,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            47,
            34,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    48,
                    1,
                ),
                end: (
                    48,
                    52,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        48,
                        10,
                    ),
                    end: (
                        48,
                        22,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                48,
                                11,
                            ),
                            end: (
                                48,
                                21,
                            ),
                            name: SimpleVariable {
                                span: (
                                    48,
                                    19,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Identifier(
                                    SimpleIdentifier {
                                        span: (
                                            48,
                                            11,
                                        ),
                                        value: "Foo",
                                    },
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                48,
                                24,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                48,
                                                37,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    48,
                                    40,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                48,
                                                42,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        48,
                                        46,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            48,
                                                            47,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        48,
                                        49,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            48,
            53,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    49,
                    1,
                ),
                end: (
                    49,
                    51,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        49,
                        10,
                    ),
                    end: (
                        49,
                        21,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                49,
                                11,
                            ),
                            end: (
                                49,
                                20,
                            ),
                            name: SimpleVariable {
                                span: (
                                    49,
                                    18,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Identifier(
                                    SimpleIdentifier {
                                        span: (
                                            49,
                                            11,
                                        ),
                                        value: "Foo",
                                    },
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                49,
                                23,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                49,
                                                36,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    49,
                                    39,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                49,
                                                41,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        49,
                                        45,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            49,
                                                            46,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        49,
                                        48,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            49,
            52,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    50,
                    1,
                ),
                end: (
                    50,
                    49,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        50,
                        10,
                    ),
                    end: (
                        50,
                        19,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                50,
                                11,
                            ),
                            end: (
                                50,
                                18,
                            ),
                            name: SimpleVariable {
                                span: (
                                    50,
                                    16,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Identifier(
                                    SimpleIdentifier {
                                        span: (
                                            50,
                                            11,
                                        ),
                                        value: "Foo",
                                    },
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                50,
                                21,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                50,
                                                34,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    50,
                                    37,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                50,
                                                39,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        50,
                                        43,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            50,
                                                            44,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        50,
                                        46,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            50,
            50,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    51,
                    1,
                ),
                end: (
                    51,
                    48,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        51,
                        10,
                    ),
                    end: (
                        51,
                        18,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                51,
                                11,
                            ),
                            end: (
                                51,
                                17,
                            ),
                            name: SimpleVariable {
                                span: (
                                    51,
                                    15,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Identifier(
                                    SimpleIdentifier {
                                        span: (
                                            51,
                                            11,
                                        ),
                                        value: "Foo",
                                    },
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                51,
                                20,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                51,
                                                33,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    51,
                                    36,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                51,
                                                38,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        51,
                                        42,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            51,
                                                            43,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        51,
                                        45,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            51,
            49,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    52,
                    1,
                ),
                end: (
                    52,
                    46,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        52,
                        4,
                    ),
                    end: (
                        52,
                        24,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                52,
                                5,
                            ),
                            end: (
                                52,
                                23,
                            ),
                            name: SimpleVariable {
                                span: (
                                    52,
                                    21,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    52,
                                                    5,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    52,
                                                    9,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    52,
                                                    13,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                52,
                                26,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    52,
                                    33,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        52,
                        36,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    52,
                                    38,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            52,
                            42,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                52,
                                                43,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            52,
                            45,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            52,
            46,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    53,
                    1,
                ),
                end: (
                    53,
                    45,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        53,
                        4,
                    ),
                    end: (
                        53,
                        23,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                53,
                                5,
                            ),
                            end: (
                                53,
                                22,
                            ),
                            name: SimpleVariable {
                                span: (
                                    53,
                                    20,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    53,
                                                    5,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    53,
                                                    9,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    53,
                                                    13,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                53,
                                25,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    53,
                                    32,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        53,
                        35,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    53,
                                    37,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            53,
                            41,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                53,
                                                42,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            53,
                            44,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            53,
            45,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    54,
                    1,
                ),
                end: (
                    54,
                    43,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        54,
                        4,
                    ),
                    end: (
                        54,
                        21,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                54,
                                5,
                            ),
                            end: (
                                54,
                                20,
                            ),
                            name: SimpleVariable {
                                span: (
                                    54,
                                    18,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    54,
                                                    5,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    54,
                                                    9,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    54,
                                                    13,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                54,
                                23,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    54,
                                    30,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        54,
                        33,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    54,
                                    35,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            54,
                            39,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                54,
                                                40,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            54,
                            42,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            54,
            43,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    55,
                    1,
                ),
                end: (
                    55,
                    42,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        55,
                        4,
                    ),
                    end: (
                        55,
                        20,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                55,
                                5,
                            ),
                            end: (
                                55,
                                19,
                            ),
                            name: SimpleVariable {
                                span: (
                                    55,
                                    17,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    55,
                                                    5,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    55,
                                                    9,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    55,
                                                    13,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                55,
                                22,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    55,
                                    29,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        55,
                        32,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    55,
                                    34,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            55,
                            38,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                55,
                                                39,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            55,
                            41,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            55,
            42,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    56,
                    1,
                ),
                end: (
                    56,
                    60,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        56,
                        10,
                    ),
                    end: (
                        56,
                        30,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                56,
                                11,
                            ),
                            end: (
                                56,
                                29,
                            ),
                            name: SimpleVariable {
                                span: (
                                    56,
                                    27,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    56,
                                                    11,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    56,
                                                    15,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    56,
                                                    19,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                56,
                                32,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                56,
                                                45,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    56,
                                    48,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                56,
                                                50,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        56,
                                        54,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            56,
                                                            55,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        56,
                                        57,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            56,
            61,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    57,
                    1,
                ),
                end: (
                    57,
                    59,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        57,
                        10,
                    ),
                    end: (
                        57,
                        29,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                57,
                                11,
                            ),
                            end: (
                                57,
                                28,
                            ),
                            name: SimpleVariable {
                                span: (
                                    57,
                                    26,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    57,
                                                    11,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    57,
                                                    15,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    57,
                                                    19,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                57,
                                31,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                57,
                                                44,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    57,
                                    47,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                57,
                                                49,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        57,
                                        53,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            57,
                                                            54,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        57,
                                        56,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            57,
            60,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    58,
                    1,
                ),
                end: (
                    58,
                    57,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        58,
                        10,
                    ),
                    end: (
                        58,
                        27,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                58,
                                11,
                            ),
                            end: (
                                58,
                                26,
                            ),
                            name: SimpleVariable {
                                span: (
                                    58,
                                    24,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    58,
                                                    11,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    58,
                                                    15,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    58,
                                                    19,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                58,
                                29,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                58,
                                                42,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    58,
                                    45,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                58,
                                                47,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        58,
                                        51,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            58,
                                                            52,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        58,
                                        54,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            58,
            58,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    59,
                    1,
                ),
                end: (
                    59,
                    56,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        59,
                        10,
                    ),
                    end: (
                        59,
                        26,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                59,
                                11,
                            ),
                            end: (
                                59,
                                25,
                            ),
                            name: SimpleVariable {
                                span: (
                                    59,
                                    23,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    59,
                                                    11,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    59,
                                                    15,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    59,
                                                    19,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                59,
                                28,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                59,
                                                41,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    59,
                                    44,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                59,
                                                46,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        59,
                                        50,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            59,
                                                            51,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        59,
                                        53,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            59,
            57,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    60,
                    1,
                ),
                end: (
                    60,
                    46,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        60,
                        4,
                    ),
                    end: (
                        60,
                        24,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                60,
                                5,
                            ),
                            end: (
                                60,
                                23,
                            ),
                            name: SimpleVariable {
                                span: (
                                    60,
                                    21,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    60,
                                                    5,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    60,
                                                    9,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    60,
                                                    13,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                60,
                                26,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    60,
                                    33,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        60,
                        36,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    60,
                                    38,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            60,
                            42,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                60,
                                                43,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            60,
                            45,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            60,
            46,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    61,
                    1,
                ),
                end: (
                    61,
                    45,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        61,
                        4,
                    ),
                    end: (
                        61,
                        23,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                61,
                                5,
                            ),
                            end: (
                                61,
                                22,
                            ),
                            name: SimpleVariable {
                                span: (
                                    61,
                                    20,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    61,
                                                    5,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    61,
                                                    9,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    61,
                                                    13,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                61,
                                25,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    61,
                                    32,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        61,
                        35,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    61,
                                    37,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            61,
                            41,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                61,
                                                42,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            61,
                            44,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            61,
            45,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    62,
                    1,
                ),
                end: (
                    62,
                    43,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        62,
                        4,
                    ),
                    end: (
                        62,
                        21,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                62,
                                5,
                            ),
                            end: (
                                62,
                                20,
                            ),
                            name: SimpleVariable {
                                span: (
                                    62,
                                    18,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    62,
                                                    5,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    62,
                                                    9,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    62,
                                                    13,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                62,
                                23,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    62,
                                    30,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        62,
                        33,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    62,
                                    35,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            62,
                            39,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                62,
                                                40,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            62,
                            42,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            62,
            43,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    63,
                    1,
                ),
                end: (
                    63,
                    42,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        63,
                        4,
                    ),
                    end: (
                        63,
                        20,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                63,
                                5,
                            ),
                            end: (
                                63,
                                19,
                            ),
                            name: SimpleVariable {
                                span: (
                                    63,
                                    17,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    63,
                                                    5,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    63,
                                                    9,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    63,
                                                    13,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                63,
                                22,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    63,
                                    29,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        63,
                        32,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    63,
                                    34,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            63,
                            38,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                63,
                                                39,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            63,
                            41,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            63,
            42,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    64,
                    1,
                ),
                end: (
                    64,
                    60,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        64,
                        10,
                    ),
                    end: (
                        64,
                        30,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                64,
                                11,
                            ),
                            end: (
                                64,
                                29,
                            ),
                            name: SimpleVariable {
                                span: (
                                    64,
                                    27,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    64,
                                                    11,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    64,
                                                    15,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    64,
                                                    19,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                64,
                                32,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                64,
                                                45,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    64,
                                    48,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                64,
                                                50,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        64,
                                        54,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            64,
                                                            55,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        64,
                                        57,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            64,
            61,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    65,
                    1,
                ),
                end: (
                    65,
                    59,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        65,
                        10,
                    ),
                    end: (
                        65,
                        29,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                65,
                                11,
                            ),
                            end: (
                                65,
                                28,
                            ),
                            name: SimpleVariable {
                                span: (
                                    65,
                                    26,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    65,
                                                    11,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    65,
                                                    15,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    65,
                                                    19,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                65,
                                31,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                65,
                                                44,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    65,
                                    47,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                65,
                                                49,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        65,
                                        53,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            65,
                                                            54,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        65,
                                        56,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            65,
            60,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    66,
                    1,
                ),
                end: (
                    66,
                    57,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        66,
                        10,
                    ),
                    end: (
                        66,
                        27,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                66,
                                11,
                            ),
                            end: (
                                66,
                                26,
                            ),
                            name: SimpleVariable {
                                span: (
                                    66,
                                    24,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    66,
                                                    11,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    66,
                                                    15,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    66,
                                                    19,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                66,
                                29,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                66,
                                                42,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    66,
                                    45,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                66,
                                                47,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        66,
                                        51,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            66,
                                                            52,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        66,
                                        54,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            66,
            58,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    67,
                    1,
                ),
                end: (
                    67,
                    56,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        67,
                        10,
                    ),
                    end: (
                        67,
                        26,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                67,
                                11,
                            ),
                            end: (
                                67,
                                25,
                            ),
                            name: SimpleVariable {
                                span: (
                                    67,
                                    23,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    67,
                                                    11,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    67,
                                                    15,
                                                ),
                                                value: "Bar",
                                            },
                                        ),
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    67,
                                                    19,
                                                ),
                                                value: "Baz",
                                            },
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                67,
                                28,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                67,
                                                41,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    67,
                                    44,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                67,
                                                46,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        67,
                                        50,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            67,
                                                            51,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        67,
                                        53,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            67,
            57,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    68,
                    1,
                ),
                end: (
                    68,
                    48,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        68,
                        4,
                    ),
                    end: (
                        68,
                        26,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                68,
                                5,
                            ),
                            end: (
                                68,
                                25,
                            ),
                            name: SimpleVariable {
                                span: (
                                    68,
                                    23,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    68,
                                                    5,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Intersection(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            68,
                                                            10,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            68,
                                                            14,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                68,
                                28,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    68,
                                    35,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        68,
                        38,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    68,
                                    40,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            68,
                            44,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                68,
                                                45,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            68,
                            47,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            68,
            48,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    69,
                    1,
                ),
                end: (
                    69,
                    47,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        69,
                        4,
                    ),
                    end: (
                        69,
                        25,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                69,
                                5,
                            ),
                            end: (
                                69,
                                24,
                            ),
                            name: SimpleVariable {
                                span: (
                                    69,
                                    22,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    69,
                                                    5,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Intersection(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            69,
                                                            10,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            69,
                                                            14,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                69,
                                27,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    69,
                                    34,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        69,
                        37,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    69,
                                    39,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            69,
                            43,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                69,
                                                44,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            69,
                            46,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            69,
            47,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    70,
                    1,
                ),
                end: (
                    70,
                    45,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        70,
                        4,
                    ),
                    end: (
                        70,
                        23,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                70,
                                5,
                            ),
                            end: (
                                70,
                                22,
                            ),
                            name: SimpleVariable {
                                span: (
                                    70,
                                    20,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    70,
                                                    5,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Intersection(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            70,
                                                            10,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            70,
                                                            14,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                70,
                                25,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    70,
                                    32,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        70,
                        35,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    70,
                                    37,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            70,
                            41,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                70,
                                                42,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            70,
                            44,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            70,
            45,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    71,
                    1,
                ),
                end: (
                    71,
                    44,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        71,
                        4,
                    ),
                    end: (
                        71,
                        22,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                71,
                                5,
                            ),
                            end: (
                                71,
                                21,
                            ),
                            name: SimpleVariable {
                                span: (
                                    71,
                                    19,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    71,
                                                    5,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Intersection(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            71,
                                                            10,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            71,
                                                            14,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                71,
                                24,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    71,
                                    31,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        71,
                        34,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    71,
                                    36,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            71,
                            40,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                71,
                                                41,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            71,
                            43,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            71,
            44,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    72,
                    1,
                ),
                end: (
                    72,
                    62,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        72,
                        10,
                    ),
                    end: (
                        72,
                        32,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                72,
                                11,
                            ),
                            end: (
                                72,
                                31,
                            ),
                            name: SimpleVariable {
                                span: (
                                    72,
                                    29,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    72,
                                                    11,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Intersection(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            72,
                                                            16,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            72,
                                                            20,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                72,
                                34,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                72,
                                                47,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    72,
                                    50,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                72,
                                                52,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        72,
                                        56,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            72,
                                                            57,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        72,
                                        59,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            72,
            63,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    73,
                    1,
                ),
                end: (
                    73,
                    61,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        73,
                        10,
                    ),
                    end: (
                        73,
                        31,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                73,
                                11,
                            ),
                            end: (
                                73,
                                30,
                            ),
                            name: SimpleVariable {
                                span: (
                                    73,
                                    28,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    73,
                                                    11,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Intersection(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            73,
                                                            16,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            73,
                                                            20,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                73,
                                33,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                73,
                                                46,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    73,
                                    49,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                73,
                                                51,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        73,
                                        55,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            73,
                                                            56,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        73,
                                        58,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            73,
            62,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    74,
                    1,
                ),
                end: (
                    74,
                    59,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        74,
                        10,
                    ),
                    end: (
                        74,
                        29,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                74,
                                11,
                            ),
                            end: (
                                74,
                                28,
                            ),
                            name: SimpleVariable {
                                span: (
                                    74,
                                    26,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    74,
                                                    11,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Intersection(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            74,
                                                            16,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            74,
                                                            20,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                74,
                                31,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                74,
                                                44,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    74,
                                    47,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                74,
                                                49,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        74,
                                        53,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            74,
                                                            54,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        74,
                                        56,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            74,
            60,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    75,
                    1,
                ),
                end: (
                    75,
                    58,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        75,
                        10,
                    ),
                    end: (
                        75,
                        28,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                75,
                                11,
                            ),
                            end: (
                                75,
                                27,
                            ),
                            name: SimpleVariable {
                                span: (
                                    75,
                                    25,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Union(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    75,
                                                    11,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Intersection(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            75,
                                                            16,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            75,
                                                            20,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                75,
                                30,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                75,
                                                43,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    75,
                                    46,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                75,
                                                48,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        75,
                                        52,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            75,
                                                            53,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        75,
                                        55,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            75,
            59,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    76,
                    1,
                ),
                end: (
                    76,
                    48,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        76,
                        4,
                    ),
                    end: (
                        76,
                        26,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                76,
                                5,
                            ),
                            end: (
                                76,
                                25,
                            ),
                            name: SimpleVariable {
                                span: (
                                    76,
                                    23,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    76,
                                                    5,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Union(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            76,
                                                            10,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            76,
                                                            14,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                76,
                                28,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    76,
                                    35,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        76,
                        38,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    76,
                                    40,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            76,
                            44,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                76,
                                                45,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            76,
                            47,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            76,
            48,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    77,
                    1,
                ),
                end: (
                    77,
                    47,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        77,
                        4,
                    ),
                    end: (
                        77,
                        25,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                77,
                                5,
                            ),
                            end: (
                                77,
                                24,
                            ),
                            name: SimpleVariable {
                                span: (
                                    77,
                                    22,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    77,
                                                    5,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Union(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            77,
                                                            10,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            77,
                                                            14,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                77,
                                27,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    77,
                                    34,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        77,
                        37,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    77,
                                    39,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            77,
                            43,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                77,
                                                44,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            77,
                            46,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            77,
            47,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    78,
                    1,
                ),
                end: (
                    78,
                    45,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        78,
                        4,
                    ),
                    end: (
                        78,
                        23,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                78,
                                5,
                            ),
                            end: (
                                78,
                                22,
                            ),
                            name: SimpleVariable {
                                span: (
                                    78,
                                    20,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    78,
                                                    5,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Union(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            78,
                                                            10,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            78,
                                                            14,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                78,
                                25,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    78,
                                    32,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        78,
                        35,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    78,
                                    37,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            78,
                            41,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                78,
                                                42,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            78,
                            44,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            78,
            45,
        ),
    },
    Expression {
        expression: ArrowFunction(
            ArrowFunction {
                start: (
                    79,
                    1,
                ),
                end: (
                    79,
                    44,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        79,
                        4,
                    ),
                    end: (
                        79,
                        22,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                79,
                                5,
                            ),
                            end: (
                                79,
                                21,
                            ),
                            name: SimpleVariable {
                                span: (
                                    79,
                                    19,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    79,
                                                    5,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Union(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            79,
                                                            10,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            79,
                                                            14,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_type: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                79,
                                24,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                by_ref: false,
                body: StaticMethodCall {
                    target: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    79,
                                    31,
                                ),
                                value: "Bar",
                            },
                        ),
                    ),
                    span: (
                        79,
                        34,
                    ),
                    method: Identifier(
                        SimpleIdentifier(
                            SimpleIdentifier {
                                span: (
                                    79,
                                    36,
                                ),
                                value: "from",
                            },
                        ),
                    ),
                    arguments: ArgumentList {
                        start: (
                            79,
                            40,
                        ),
                        arguments: [
                            Positional {
                                ellipsis: None,
                                value: Variable(
                                    SimpleVariable(
                                        SimpleVariable {
                                            span: (
                                                79,
                                                41,
                                            ),
                                            name: "s",
                                        },
                                    ),
                                ),
                            },
                        ],
                        end: (
                            79,
                            43,
                        ),
                    },
                },
                static: false,
            },
        ),
        end: (
            79,
            44,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    80,
                    1,
                ),
                end: (
                    80,
                    62,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        80,
                        10,
                    ),
                    end: (
                        80,
                        32,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                80,
                                11,
                            ),
                            end: (
                                80,
                                31,
                            ),
                            name: SimpleVariable {
                                span: (
                                    80,
                                    29,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    80,
                                                    11,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Union(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            80,
                                                            16,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            80,
                                                            20,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                80,
                                34,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                80,
                                                47,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    80,
                                    50,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                80,
                                                52,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        80,
                                        56,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            80,
                                                            57,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        80,
                                        59,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            80,
            63,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    81,
                    1,
                ),
                end: (
                    81,
                    61,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        81,
                        10,
                    ),
                    end: (
                        81,
                        31,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                81,
                                11,
                            ),
                            end: (
                                81,
                                30,
                            ),
                            name: SimpleVariable {
                                span: (
                                    81,
                                    28,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    81,
                                                    11,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Union(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            81,
                                                            16,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            81,
                                                            20,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: true,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                81,
                                33,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                81,
                                                46,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    81,
                                    49,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                81,
                                                51,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        81,
                                        55,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            81,
                                                            56,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        81,
                                        58,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            81,
            62,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    82,
                    1,
                ),
                end: (
                    82,
                    59,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        82,
                        10,
                    ),
                    end: (
                        82,
                        29,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                82,
                                11,
                            ),
                            end: (
                                82,
                                28,
                            ),
                            name: SimpleVariable {
                                span: (
                                    82,
                                    26,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    82,
                                                    11,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Union(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            82,
                                                            16,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            82,
                                                            20,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: true,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                82,
                                31,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                82,
                                                44,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    82,
                                    47,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                82,
                                                49,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        82,
                                        53,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            82,
                                                            54,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        82,
                                        56,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            82,
            60,
        ),
    },
    Expression {
        expression: Closure(
            Closure {
                start: (
                    83,
                    1,
                ),
                end: (
                    83,
                    58,
                ),
                attributes: [],
                parameters: FunctionParameterList {
                    start: (
                        83,
                        10,
                    ),
                    end: (
                        83,
                        28,
                    ),
                    members: [
                        FunctionParameter {
                            start: (
                                83,
                                11,
                            ),
                            end: (
                                83,
                                27,
                            ),
                            name: SimpleVariable {
                                span: (
                                    83,
                                    25,
                                ),
                                name: "s",
                            },
                            attributes: [],
                            type: Some(
                                Intersection(
                                    [
                                        Identifier(
                                            SimpleIdentifier {
                                                span: (
                                                    83,
                                                    11,
                                                ),
                                                value: "Foo",
                                            },
                                        ),
                                        Union(
                                            [
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            83,
                                                            16,
                                                        ),
                                                        value: "Bar",
                                                    },
                                                ),
                                                Identifier(
                                                    SimpleIdentifier {
                                                        span: (
                                                            83,
                                                            20,
                                                        ),
                                                        value: "Baz",
                                                    },
                                                ),
                                            ],
                                        ),
                                    ],
                                ),
                            ),
                            variadic: false,
                            default: None,
                            by_ref: false,
                        },
                    ],
                },
                return_ty: Some(
                    Identifier(
                        SimpleIdentifier {
                            span: (
                                83,
                                30,
                            ),
                            value: "Bar",
                        },
                    ),
                ),
                uses: [],
                by_ref: false,
                body: [
                    Return {
                        value: Some(
                            StaticMethodCall {
                                target: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                83,
                                                43,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                ),
                                span: (
                                    83,
                                    46,
                                ),
                                method: Identifier(
                                    SimpleIdentifier(
                                        SimpleIdentifier {
                                            span: (
                                                83,
                                                48,
                                            ),
                                            value: "from",
                                        },
                                    ),
                                ),
                                arguments: ArgumentList {
                                    start: (
                                        83,
                                        52,
                                    ),
                                    arguments: [
                                        Positional {
                                            ellipsis: None,
                                            value: Variable(
                                                SimpleVariable(
                                                    SimpleVariable {
                                                        span: (
                                                            83,
                                                            53,
                                                        ),
                                                        name: "s",
                                                    },
                                                ),
                                            ),
                                        },
                                    ],
                                    end: (
                                        83,
                                        55,
                                    ),
                                },
                            },
                        ),
                    },
                ],
                static: false,
            },
        ),
        end: (
            83,
            59,
        ),
    },
    Function(
        Function {
            start: (
                85,
                1,
            ),
            end: (
                85,
                55,
            ),
            name: SimpleIdentifier {
                span: (
                    85,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    85,
                    13,
                ),
                end: (
                    85,
                    25,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            85,
                            14,
                        ),
                        end: (
                            85,
                            24,
                        ),
                        name: SimpleVariable {
                            span: (
                                85,
                                22,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Identifier(
                                SimpleIdentifier {
                                    span: (
                                        85,
                                        14,
                                    ),
                                    value: "Foo",
                                },
                            ),
                        ),
                        variadic: true,
                        default: None,
                        by_ref: true,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            85,
                            27,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            85,
                                            40,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                85,
                                43,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            85,
                                            45,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    85,
                                    49,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        85,
                                                        50,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    85,
                                    52,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                86,
                1,
            ),
            end: (
                86,
                54,
            ),
            name: SimpleIdentifier {
                span: (
                    86,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    86,
                    13,
                ),
                end: (
                    86,
                    24,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            86,
                            14,
                        ),
                        end: (
                            86,
                            23,
                        ),
                        name: SimpleVariable {
                            span: (
                                86,
                                21,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Identifier(
                                SimpleIdentifier {
                                    span: (
                                        86,
                                        14,
                                    ),
                                    value: "Foo",
                                },
                            ),
                        ),
                        variadic: true,
                        default: None,
                        by_ref: false,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            86,
                            26,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            86,
                                            39,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                86,
                                42,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            86,
                                            44,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    86,
                                    48,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        86,
                                                        49,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    86,
                                    51,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                87,
                1,
            ),
            end: (
                87,
                52,
            ),
            name: SimpleIdentifier {
                span: (
                    87,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    87,
                    13,
                ),
                end: (
                    87,
                    22,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            87,
                            14,
                        ),
                        end: (
                            87,
                            21,
                        ),
                        name: SimpleVariable {
                            span: (
                                87,
                                19,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Identifier(
                                SimpleIdentifier {
                                    span: (
                                        87,
                                        14,
                                    ),
                                    value: "Foo",
                                },
                            ),
                        ),
                        variadic: false,
                        default: None,
                        by_ref: true,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            87,
                            24,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            87,
                                            37,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                87,
                                40,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            87,
                                            42,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    87,
                                    46,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        87,
                                                        47,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    87,
                                    49,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                88,
                1,
            ),
            end: (
                88,
                51,
            ),
            name: SimpleIdentifier {
                span: (
                    88,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    88,
                    13,
                ),
                end: (
                    88,
                    21,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            88,
                            14,
                        ),
                        end: (
                            88,
                            20,
                        ),
                        name: SimpleVariable {
                            span: (
                                88,
                                18,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Identifier(
                                SimpleIdentifier {
                                    span: (
                                        88,
                                        14,
                                    ),
                                    value: "Foo",
                                },
                            ),
                        ),
                        variadic: false,
                        default: None,
                        by_ref: false,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            88,
                            23,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            88,
                                            36,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                88,
                                39,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            88,
                                            41,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    88,
                                    45,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        88,
                                                        46,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    88,
                                    48,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                89,
                1,
            ),
            end: (
                89,
                63,
            ),
            name: SimpleIdentifier {
                span: (
                    89,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    89,
                    13,
                ),
                end: (
                    89,
                    33,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            89,
                            14,
                        ),
                        end: (
                            89,
                            32,
                        ),
                        name: SimpleVariable {
                            span: (
                                89,
                                30,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Intersection(
                                [
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                89,
                                                14,
                                            ),
                                            value: "Foo",
                                        },
                                    ),
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                89,
                                                18,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                89,
                                                22,
                                            ),
                                            value: "Baz",
                                        },
                                    ),
                                ],
                            ),
                        ),
                        variadic: true,
                        default: None,
                        by_ref: true,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            89,
                            35,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            89,
                                            48,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                89,
                                51,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            89,
                                            53,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    89,
                                    57,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        89,
                                                        58,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    89,
                                    60,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                90,
                1,
            ),
            end: (
                90,
                62,
            ),
            name: SimpleIdentifier {
                span: (
                    90,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    90,
                    13,
                ),
                end: (
                    90,
                    32,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            90,
                            14,
                        ),
                        end: (
                            90,
                            31,
                        ),
                        name: SimpleVariable {
                            span: (
                                90,
                                29,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Intersection(
                                [
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                90,
                                                14,
                                            ),
                                            value: "Foo",
                                        },
                                    ),
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                90,
                                                18,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                90,
                                                22,
                                            ),
                                            value: "Baz",
                                        },
                                    ),
                                ],
                            ),
                        ),
                        variadic: true,
                        default: None,
                        by_ref: false,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            90,
                            34,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            90,
                                            47,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                90,
                                50,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            90,
                                            52,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    90,
                                    56,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        90,
                                                        57,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    90,
                                    59,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                91,
                1,
            ),
            end: (
                91,
                60,
            ),
            name: SimpleIdentifier {
                span: (
                    91,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    91,
                    13,
                ),
                end: (
                    91,
                    30,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            91,
                            14,
                        ),
                        end: (
                            91,
                            29,
                        ),
                        name: SimpleVariable {
                            span: (
                                91,
                                27,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Intersection(
                                [
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                91,
                                                14,
                                            ),
                                            value: "Foo",
                                        },
                                    ),
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                91,
                                                18,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                91,
                                                22,
                                            ),
                                            value: "Baz",
                                        },
                                    ),
                                ],
                            ),
                        ),
                        variadic: false,
                        default: None,
                        by_ref: true,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            91,
                            32,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            91,
                                            45,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                91,
                                48,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            91,
                                            50,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    91,
                                    54,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        91,
                                                        55,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    91,
                                    57,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                92,
                1,
            ),
            end: (
                92,
                59,
            ),
            name: SimpleIdentifier {
                span: (
                    92,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    92,
                    13,
                ),
                end: (
                    92,
                    29,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            92,
                            14,
                        ),
                        end: (
                            92,
                            28,
                        ),
                        name: SimpleVariable {
                            span: (
                                92,
                                26,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Intersection(
                                [
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                92,
                                                14,
                                            ),
                                            value: "Foo",
                                        },
                                    ),
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                92,
                                                18,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                92,
                                                22,
                                            ),
                                            value: "Baz",
                                        },
                                    ),
                                ],
                            ),
                        ),
                        variadic: false,
                        default: None,
                        by_ref: false,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            92,
                            31,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            92,
                                            44,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                92,
                                47,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            92,
                                            49,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    92,
                                    53,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        92,
                                                        54,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    92,
                                    56,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                93,
                1,
            ),
            end: (
                93,
                63,
            ),
            name: SimpleIdentifier {
                span: (
                    93,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    93,
                    13,
                ),
                end: (
                    93,
                    33,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            93,
                            14,
                        ),
                        end: (
                            93,
                            32,
                        ),
                        name: SimpleVariable {
                            span: (
                                93,
                                30,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Union(
                                [
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                93,
                                                14,
                                            ),
                                            value: "Foo",
                                        },
                                    ),
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                93,
                                                18,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                93,
                                                22,
                                            ),
                                            value: "Baz",
                                        },
                                    ),
                                ],
                            ),
                        ),
                        variadic: true,
                        default: None,
                        by_ref: true,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            93,
                            35,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            93,
                                            48,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                93,
                                51,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            93,
                                            53,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    93,
                                    57,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        93,
                                                        58,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    93,
                                    60,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                94,
                1,
            ),
            end: (
                94,
                62,
            ),
            name: SimpleIdentifier {
                span: (
                    94,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    94,
                    13,
                ),
                end: (
                    94,
                    32,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            94,
                            14,
                        ),
                        end: (
                            94,
                            31,
                        ),
                        name: SimpleVariable {
                            span: (
                                94,
                                29,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Union(
                                [
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                94,
                                                14,
                                            ),
                                            value: "Foo",
                                        },
                                    ),
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                94,
                                                18,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                94,
                                                22,
                                            ),
                                            value: "Baz",
                                        },
                                    ),
                                ],
                            ),
                        ),
                        variadic: true,
                        default: None,
                        by_ref: false,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            94,
                            34,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            94,
                                            47,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                94,
                                50,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            94,
                                            52,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    94,
                                    56,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        94,
                                                        57,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    94,
                                    59,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                95,
                1,
            ),
            end: (
                95,
                60,
            ),
            name: SimpleIdentifier {
                span: (
                    95,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    95,
                    13,
                ),
                end: (
                    95,
                    30,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            95,
                            14,
                        ),
                        end: (
                            95,
                            29,
                        ),
                        name: SimpleVariable {
                            span: (
                                95,
                                27,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Union(
                                [
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                95,
                                                14,
                                            ),
                                            value: "Foo",
                                        },
                                    ),
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                95,
                                                18,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                95,
                                                22,
                                            ),
                                            value: "Baz",
                                        },
                                    ),
                                ],
                            ),
                        ),
                        variadic: false,
                        default: None,
                        by_ref: true,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            95,
                            32,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            95,
                                            45,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                95,
                                48,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            95,
                                            50,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    95,
                                    54,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        95,
                                                        55,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    95,
                                    57,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                96,
                1,
            ),
            end: (
                96,
                59,
            ),
            name: SimpleIdentifier {
                span: (
                    96,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    96,
                    13,
                ),
                end: (
                    96,
                    29,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            96,
                            14,
                        ),
                        end: (
                            96,
                            28,
                        ),
                        name: SimpleVariable {
                            span: (
                                96,
                                26,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Union(
                                [
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                96,
                                                14,
                                            ),
                                            value: "Foo",
                                        },
                                    ),
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                96,
                                                18,
                                            ),
                                            value: "Bar",
                                        },
                                    ),
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                96,
                                                22,
                                            ),
                                            value: "Baz",
                                        },
                                    ),
                                ],
                            ),
                        ),
                        variadic: false,
                        default: None,
                        by_ref: false,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            96,
                            31,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            96,
                                            44,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                96,
                                47,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            96,
                                            49,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    96,
                                    53,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        96,
                                                        54,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    96,
                                    56,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                97,
                1,
            ),
            end: (
                97,
                65,
            ),
            name: SimpleIdentifier {
                span: (
                    97,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    97,
                    13,
                ),
                end: (
                    97,
                    35,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            97,
                            14,
                        ),
                        end: (
                            97,
                            34,
                        ),
                        name: SimpleVariable {
                            span: (
                                97,
                                32,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Union(
                                [
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                97,
                                                14,
                                            ),
                                            value: "Foo",
                                        },
                                    ),
                                    Intersection(
                                        [
                                            Identifier(
                                                SimpleIdentifier {
                                                    span: (
                                                        97,
                                                        19,
                                                    ),
                                                    value: "Bar",
                                                },
                                            ),
                                            Identifier(
                                                SimpleIdentifier {
                                                    span: (
                                                        97,
                                                        23,
                                                    ),
                                                    value: "Baz",
                                                },
                                            ),
                                        ],
                                    ),
                                ],
                            ),
                        ),
                        variadic: true,
                        default: None,
                        by_ref: true,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            97,
                            37,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            97,
                                            50,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                97,
                                53,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            97,
                                            55,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    97,
                                    59,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        97,
                                                        60,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    97,
                                    62,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                98,
                1,
            ),
            end: (
                98,
                64,
            ),
            name: SimpleIdentifier {
                span: (
                    98,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    98,
                    13,
                ),
                end: (
                    98,
                    34,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            98,
                            14,
                        ),
                        end: (
                            98,
                            33,
                        ),
                        name: SimpleVariable {
                            span: (
                                98,
                                31,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Union(
                                [
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                98,
                                                14,
                                            ),
                                            value: "Foo",
                                        },
                                    ),
                                    Intersection(
                                        [
                                            Identifier(
                                                SimpleIdentifier {
                                                    span: (
                                                        98,
                                                        19,
                                                    ),
                                                    value: "Bar",
                                                },
                                            ),
                                            Identifier(
                                                SimpleIdentifier {
                                                    span: (
                                                        98,
                                                        23,
                                                    ),
                                                    value: "Baz",
                                                },
                                            ),
                                        ],
                                    ),
                                ],
                            ),
                        ),
                        variadic: true,
                        default: None,
                        by_ref: false,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            98,
                            36,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            98,
                                            49,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                98,
                                52,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            98,
                                            54,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    98,
                                    58,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        98,
                                                        59,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    98,
                                    61,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                99,
                1,
            ),
            end: (
                99,
                62,
            ),
            name: SimpleIdentifier {
                span: (
                    99,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    99,
                    13,
                ),
                end: (
                    99,
                    32,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            99,
                            14,
                        ),
                        end: (
                            99,
                            31,
                        ),
                        name: SimpleVariable {
                            span: (
                                99,
                                29,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Union(
                                [
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                99,
                                                14,
                                            ),
                                            value: "Foo",
                                        },
                                    ),
                                    Intersection(
                                        [
                                            Identifier(
                                                SimpleIdentifier {
                                                    span: (
                                                        99,
                                                        19,
                                                    ),
                                                    value: "Bar",
                                                },
                                            ),
                                            Identifier(
                                                SimpleIdentifier {
                                                    span: (
                                                        99,
                                                        23,
                                                    ),
                                                    value: "Baz",
                                                },
                                            ),
                                        ],
                                    ),
                                ],
                            ),
                        ),
                        variadic: false,
                        default: None,
                        by_ref: true,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            99,
                            34,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            99,
                                            47,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                99,
                                50,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            99,
                                            52,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    99,
                                    56,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        99,
                                                        57,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    99,
                                    59,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                100,
                1,
            ),
            end: (
                100,
                61,
            ),
            name: SimpleIdentifier {
                span: (
                    100,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    100,
                    13,
                ),
                end: (
                    100,
                    31,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            100,
                            14,
                        ),
                        end: (
                            100,
                            30,
                        ),
                        name: SimpleVariable {
                            span: (
                                100,
                                28,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Union(
                                [
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                100,
                                                14,
                                            ),
                                            value: "Foo",
                                        },
                                    ),
                                    Intersection(
                                        [
                                            Identifier(
                                                SimpleIdentifier {
                                                    span: (
                                                        100,
                                                        19,
                                                    ),
                                                    value: "Bar",
                                                },
                                            ),
                                            Identifier(
                                                SimpleIdentifier {
                                                    span: (
                                                        100,
                                                        23,
                                                    ),
                                                    value: "Baz",
                                                },
                                            ),
                                        ],
                                    ),
                                ],
                            ),
                        ),
                        variadic: false,
                        default: None,
                        by_ref: false,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            100,
                            33,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            100,
                                            46,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                100,
                                49,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            100,
                                            51,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    100,
                                    55,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        100,
                                                        56,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    100,
                                    58,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                101,
                1,
            ),
            end: (
                101,
                65,
            ),
            name: SimpleIdentifier {
                span: (
                    101,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    101,
                    13,
                ),
                end: (
                    101,
                    35,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            101,
                            14,
                        ),
                        end: (
                            101,
                            34,
                        ),
                        name: SimpleVariable {
                            span: (
                                101,
                                32,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Intersection(
                                [
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                101,
                                                14,
                                            ),
                                            value: "Foo",
                                        },
                                    ),
                                    Union(
                                        [
                                            Identifier(
                                                SimpleIdentifier {
                                                    span: (
                                                        101,
                                                        19,
                                                    ),
                                                    value: "Bar",
                                                },
                                            ),
                                            Identifier(
                                                SimpleIdentifier {
                                                    span: (
                                                        101,
                                                        23,
                                                    ),
                                                    value: "Baz",
                                                },
                                            ),
                                        ],
                                    ),
                                ],
                            ),
                        ),
                        variadic: true,
                        default: None,
                        by_ref: true,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            101,
                            37,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            101,
                                            50,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                101,
                                53,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            101,
                                            55,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    101,
                                    59,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        101,
                                                        60,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    101,
                                    62,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                102,
                1,
            ),
            end: (
                102,
                64,
            ),
            name: SimpleIdentifier {
                span: (
                    102,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    102,
                    13,
                ),
                end: (
                    102,
                    34,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            102,
                            14,
                        ),
                        end: (
                            102,
                            33,
                        ),
                        name: SimpleVariable {
                            span: (
                                102,
                                31,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Intersection(
                                [
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                102,
                                                14,
                                            ),
                                            value: "Foo",
                                        },
                                    ),
                                    Union(
                                        [
                                            Identifier(
                                                SimpleIdentifier {
                                                    span: (
                                                        102,
                                                        19,
                                                    ),
                                                    value: "Bar",
                                                },
                                            ),
                                            Identifier(
                                                SimpleIdentifier {
                                                    span: (
                                                        102,
                                                        23,
                                                    ),
                                                    value: "Baz",
                                                },
                                            ),
                                        ],
                                    ),
                                ],
                            ),
                        ),
                        variadic: true,
                        default: None,
                        by_ref: false,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            102,
                            36,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            102,
                                            49,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                102,
                                52,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            102,
                                            54,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    102,
                                    58,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        102,
                                                        59,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    102,
                                    61,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                103,
                1,
            ),
            end: (
                103,
                62,
            ),
            name: SimpleIdentifier {
                span: (
                    103,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    103,
                    13,
                ),
                end: (
                    103,
                    32,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            103,
                            14,
                        ),
                        end: (
                            103,
                            31,
                        ),
                        name: SimpleVariable {
                            span: (
                                103,
                                29,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Intersection(
                                [
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                103,
                                                14,
                                            ),
                                            value: "Foo",
                                        },
                                    ),
                                    Union(
                                        [
                                            Identifier(
                                                SimpleIdentifier {
                                                    span: (
                                                        103,
                                                        19,
                                                    ),
                                                    value: "Bar",
                                                },
                                            ),
                                            Identifier(
                                                SimpleIdentifier {
                                                    span: (
                                                        103,
                                                        23,
                                                    ),
                                                    value: "Baz",
                                                },
                                            ),
                                        ],
                                    ),
                                ],
                            ),
                        ),
                        variadic: false,
                        default: None,
                        by_ref: true,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            103,
                            34,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            103,
                                            47,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                103,
                                50,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            103,
                                            52,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    103,
                                    56,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        103,
                                                        57,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    103,
                                    59,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
    Function(
        Function {
            start: (
                104,
                1,
            ),
            end: (
                104,
                61,
            ),
            name: SimpleIdentifier {
                span: (
                    104,
                    10,
                ),
                value: "foo",
            },
            attributes: [],
            parameters: FunctionParameterList {
                start: (
                    104,
                    13,
                ),
                end: (
                    104,
                    31,
                ),
                members: [
                    FunctionParameter {
                        start: (
                            104,
                            14,
                        ),
                        end: (
                            104,
                            30,
                        ),
                        name: SimpleVariable {
                            span: (
                                104,
                                28,
                            ),
                            name: "s",
                        },
                        attributes: [],
                        type: Some(
                            Intersection(
                                [
                                    Identifier(
                                        SimpleIdentifier {
                                            span: (
                                                104,
                                                14,
                                            ),
                                            value: "Foo",
                                        },
                                    ),
                                    Union(
                                        [
                                            Identifier(
                                                SimpleIdentifier {
                                                    span: (
                                                        104,
                                                        19,
                                                    ),
                                                    value: "Bar",
                                                },
                                            ),
                                            Identifier(
                                                SimpleIdentifier {
                                                    span: (
                                                        104,
                                                        23,
                                                    ),
                                                    value: "Baz",
                                                },
                                            ),
                                        ],
                                    ),
                                ],
                            ),
                        ),
                        variadic: false,
                        default: None,
                        by_ref: false,
                    },
                ],
            },
            return_type: Some(
                Identifier(
                    SimpleIdentifier {
                        span: (
                            104,
                            33,
                        ),
                        value: "Bar",
                    },
                ),
            ),
            by_ref: false,
            body: [
                Return {
                    value: Some(
                        StaticMethodCall {
                            target: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            104,
                                            46,
                                        ),
                                        value: "Bar",
                                    },
                                ),
                            ),
                            span: (
                                104,
                                49,
                            ),
                            method: Identifier(
                                SimpleIdentifier(
                                    SimpleIdentifier {
                                        span: (
                                            104,
                                            51,
                                        ),
                                        value: "from",
                                    },
                                ),
                            ),
                            arguments: ArgumentList {
                                start: (
                                    104,
                                    55,
                                ),
                                arguments: [
                                    Positional {
                                        ellipsis: None,
                                        value: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: (
                                                        104,
                                                        56,
                                                    ),
                                                    name: "s",
                                                },
                                            ),
                                        ),
                                    },
                                ],
                                end: (
                                    104,
                                    58,
                                ),
                            },
                        },
                    ),
                },
            ],
        },
    ),
]
