File {
    shebang: None,
    attrs: [],
    items: [
        Use(
            ItemUse {
                attrs: [],
                vis: Inherited,
                use_token: Use,
                leading_colon: None,
                tree: Path(
                    UsePath {
                        ident: Ident(
                            std,
                        ),
                        colon2_token: Colon2,
                        tree: Path(
                            UsePath {
                                ident: Ident(
                                    sync,
                                ),
                                colon2_token: Colon2,
                                tree: Group(
                                    UseGroup {
                                        brace_token: Brace,
                                        items: [
                                            Name(
                                                UseName {
                                                    ident: Ident(
                                                        Arc,
                                                    ),
                                                },
                                            ),
                                            Comma,
                                            Name(
                                                UseName {
                                                    ident: Ident(
                                                        Mutex,
                                                    ),
                                                },
                                            ),
                                        ],
                                    },
                                ),
                            },
                        ),
                    },
                ),
                semi_token: Semi,
            },
        ),
        Struct(
            ItemStruct {
                attrs: [
                    Attribute {
                        pound_token: Pound,
                        style: Outer,
                        bracket_token: Bracket,
                        path: Path {
                            leading_colon: None,
                            segments: [
                                PathSegment {
                                    ident: Ident(
                                        doc,
                                    ),
                                    arguments: None,
                                },
                            ],
                        },
                        tokens: TokenStream [
                            Punct {
                                op: '=',
                                spacing: Alone,
                            },
                            Literal {
                                lit: "\r",
                            },
                        ],
                    },
                    Attribute {
                        pound_token: Pound,
                        style: Outer,
                        bracket_token: Bracket,
                        path: Path {
                            leading_colon: None,
                            segments: [
                                PathSegment {
                                    ident: Ident(
                                        doc,
                                    ),
                                    arguments: None,
                                },
                            ],
                        },
                        tokens: TokenStream [
                            Punct {
                                op: '=',
                                spacing: Alone,
                            },
                            Literal {
                                lit: " 测试用结构体A\r",
                            },
                        ],
                    },
                    Attribute {
                        pound_token: Pound,
                        style: Outer,
                        bracket_token: Bracket,
                        path: Path {
                            leading_colon: None,
                            segments: [
                                PathSegment {
                                    ident: Ident(
                                        doc,
                                    ),
                                    arguments: None,
                                },
                            ],
                        },
                        tokens: TokenStream [
                            Punct {
                                op: '=',
                                spacing: Alone,
                            },
                            Literal {
                                lit: "\r",
                            },
                        ],
                    },
                    Attribute {
                        pound_token: Pound,
                        style: Outer,
                        bracket_token: Bracket,
                        path: Path {
                            leading_colon: None,
                            segments: [
                                PathSegment {
                                    ident: Ident(
                                        pi_js_export,
                                    ),
                                    arguments: None,
                                },
                            ],
                        },
                        tokens: TokenStream [
                            Group {
                                delimiter: Parenthesis,
                                stream: TokenStream [
                                    Ident {
                                        sym: T,
                                    },
                                    Punct {
                                        op: '=',
                                        spacing: Alone,
                                    },
                                    Ident {
                                        sym: type,
                                    },
                                    Group {
                                        delimiter: Parenthesis,
                                        stream: TokenStream [
                                            Ident {
                                                sym: u8,
                                            },
                                        ],
                                    },
                                ],
                            },
                        ],
                    },
                ],
                vis: Public(
                    VisPublic {
                        pub_token: Pub,
                    },
                ),
                struct_token: Struct,
                ident: Ident(
                    A,
                ),
                generics: Generics {
                    lt_token: Some(
                        Lt,
                    ),
                    params: [
                        Lifetime(
                            LifetimeDef {
                                attrs: [],
                                lifetime: Lifetime {
                                    apostrophe: Span,
                                    ident: Ident(
                                        a,
                                    ),
                                },
                                colon_token: None,
                                bounds: [],
                            },
                        ),
                        Comma,
                        Type(
                            TypeParam {
                                attrs: [],
                                ident: Ident(
                                    T,
                                ),
                                colon_token: None,
                                bounds: [],
                                eq_token: None,
                                default: None,
                            },
                        ),
                    ],
                    gt_token: Some(
                        Gt,
                    ),
                    where_clause: None,
                },
                fields: Unnamed(
                    FieldsUnnamed {
                        paren_token: Paren,
                        unnamed: [
                            Field {
                                attrs: [],
                                vis: Inherited,
                                ident: None,
                                colon_token: None,
                                ty: Path(
                                    TypePath {
                                        qself: None,
                                        path: Path {
                                            leading_colon: None,
                                            segments: [
                                                PathSegment {
                                                    ident: Ident(
                                                        bool,
                                                    ),
                                                    arguments: None,
                                                },
                                            ],
                                        },
                                    },
                                ),
                            },
                            Comma,
                            Field {
                                attrs: [],
                                vis: Inherited,
                                ident: None,
                                colon_token: None,
                                ty: Path(
                                    TypePath {
                                        qself: None,
                                        path: Path {
                                            leading_colon: None,
                                            segments: [
                                                PathSegment {
                                                    ident: Ident(
                                                        usize,
                                                    ),
                                                    arguments: None,
                                                },
                                            ],
                                        },
                                    },
                                ),
                            },
                            Comma,
                            Field {
                                attrs: [],
                                vis: Inherited,
                                ident: None,
                                colon_token: None,
                                ty: Path(
                                    TypePath {
                                        qself: None,
                                        path: Path {
                                            leading_colon: None,
                                            segments: [
                                                PathSegment {
                                                    ident: Ident(
                                                        String,
                                                    ),
                                                    arguments: None,
                                                },
                                            ],
                                        },
                                    },
                                ),
                            },
                            Comma,
                            Field {
                                attrs: [],
                                vis: Inherited,
                                ident: None,
                                colon_token: None,
                                ty: Path(
                                    TypePath {
                                        qself: None,
                                        path: Path {
                                            leading_colon: None,
                                            segments: [
                                                PathSegment {
                                                    ident: Ident(
                                                        Arc,
                                                    ),
                                                    arguments: AngleBracketed(
                                                        AngleBracketedGenericArguments {
                                                            colon2_token: None,
                                                            lt_token: Lt,
                                                            args: [
                                                                Type(
                                                                    Path(
                                                                        TypePath {
                                                                            qself: None,
                                                                            path: Path {
                                                                                leading_colon: None,
                                                                                segments: [
                                                                                    PathSegment {
                                                                                        ident: Ident(
                                                                                            Mutex,
                                                                                        ),
                                                                                        arguments: AngleBracketed(
                                                                                            AngleBracketedGenericArguments {
                                                                                                colon2_token: None,
                                                                                                lt_token: Lt,
                                                                                                args: [
                                                                                                    Type(
                                                                                                        Path(
                                                                                                            TypePath {
                                                                                                                qself: None,
                                                                                                                path: Path {
                                                                                                                    leading_colon: None,
                                                                                                                    segments: [
                                                                                                                        PathSegment {
                                                                                                                            ident: Ident(
                                                                                                                                usize,
                                                                                                                            ),
                                                                                                                            arguments: None,
                                                                                                                        },
                                                                                                                    ],
                                                                                                                },
                                                                                                            },
                                                                                                        ),
                                                                                                    ),
                                                                                                ],
                                                                                                gt_token: Gt,
                                                                                            },
                                                                                        ),
                                                                                    },
                                                                                ],
                                                                            },
                                                                        },
                                                                    ),
                                                                ),
                                                            ],
                                                            gt_token: Gt,
                                                        },
                                                    ),
                                                },
                                            ],
                                        },
                                    },
                                ),
                            },
                            Comma,
                            Field {
                                attrs: [],
                                vis: Inherited,
                                ident: None,
                                colon_token: None,
                                ty: Path(
                                    TypePath {
                                        qself: None,
                                        path: Path {
                                            leading_colon: None,
                                            segments: [
                                                PathSegment {
                                                    ident: Ident(
                                                        Vec,
                                                    ),
                                                    arguments: AngleBracketed(
                                                        AngleBracketedGenericArguments {
                                                            colon2_token: None,
                                                            lt_token: Lt,
                                                            args: [
                                                                Type(
                                                                    Path(
                                                                        TypePath {
                                                                            qself: None,
                                                                            path: Path {
                                                                                leading_colon: None,
                                                                                segments: [
                                                                                    PathSegment {
                                                                                        ident: Ident(
                                                                                            T,
                                                                                        ),
                                                                                        arguments: None,
                                                                                    },
                                                                                ],
                                                                            },
                                                                        },
                                                                    ),
                                                                ),
                                                            ],
                                                            gt_token: Gt,
                                                        },
                                                    ),
                                                },
                                            ],
                                        },
                                    },
                                ),
                            },
                        ],
                    },
                ),
                semi_token: Some(
                    Semi,
                ),
            },
        ),
    ],
}