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