openharmony/third_party_rust_syn
1
0
Fork 0
mirror of https://gitee.com/openharmony/third_party_rust_syn synced 2024-11-23 07:50:04 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update generated code

Browse Source
This commit is contained in:
David Tolnay 2019-07-28 17:21:10 -07:00
parent 7eab8a8e35
commit bf752ef807
No known key found for this signature in database
GPG Key ID: F9BA143B95FF6D82
5 changed files with 216 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/gen/fold.rs
View File

@ -2347,6 +2347,7 @@ pub fn fold_pat<V: Fold + ?Sized>(_visitor: &mut V, _i: Pat) -> Pat {
#[cfg(feature = "full")]
pub fn fold_pat_box<V: Fold + ?Sized>(_visitor: &mut V, _i: PatBox) -> PatBox {
PatBox {
attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
box_token: Token![box](tokens_helper(_visitor, &_i.box_token.span)),
pat: Box::new(_visitor.fold_pat(*_i.pat)),
}
@ -2354,6 +2355,7 @@ pub fn fold_pat_box<V: Fold + ?Sized>(_visitor: &mut V, _i: PatBox) -> PatBox {
#[cfg(feature = "full")]
pub fn fold_pat_ident<V: Fold + ?Sized>(_visitor: &mut V, _i: PatIdent) -> PatIdent {
PatIdent {
attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
by_ref: (_i.by_ref).map(|it| Token![ref](tokens_helper(_visitor, &it.span))),
mutability: (_i.mutability).map(|it| Token![mut](tokens_helper(_visitor, &it.span))),
ident: _visitor.fold_ident(_i.ident),
@ -2368,18 +2370,21 @@ pub fn fold_pat_ident<V: Fold + ?Sized>(_visitor: &mut V, _i: PatIdent) -> PatId
#[cfg(feature = "full")]
pub fn fold_pat_lit<V: Fold + ?Sized>(_visitor: &mut V, _i: PatLit) -> PatLit {
PatLit {
attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
expr: Box::new(_visitor.fold_expr(*_i.expr)),
}
}
#[cfg(feature = "full")]
pub fn fold_pat_macro<V: Fold + ?Sized>(_visitor: &mut V, _i: PatMacro) -> PatMacro {
PatMacro {
attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
mac: _visitor.fold_macro(_i.mac),
}
}
#[cfg(feature = "full")]
pub fn fold_pat_path<V: Fold + ?Sized>(_visitor: &mut V, _i: PatPath) -> PatPath {
PatPath {
attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
qself: (_i.qself).map(|it| _visitor.fold_qself(it)),
path: _visitor.fold_path(_i.path),
}
@ -2387,6 +2392,7 @@ pub fn fold_pat_path<V: Fold + ?Sized>(_visitor: &mut V, _i: PatPath) -> PatPath
#[cfg(feature = "full")]
pub fn fold_pat_range<V: Fold + ?Sized>(_visitor: &mut V, _i: PatRange) -> PatRange {
PatRange {
attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
lo: Box::new(_visitor.fold_expr(*_i.lo)),
limits: _visitor.fold_range_limits(_i.limits),
hi: Box::new(_visitor.fold_expr(*_i.hi)),
@ -2395,6 +2401,7 @@ pub fn fold_pat_range<V: Fold + ?Sized>(_visitor: &mut V, _i: PatRange) -> PatRa
#[cfg(feature = "full")]
pub fn fold_pat_ref<V: Fold + ?Sized>(_visitor: &mut V, _i: PatRef) -> PatRef {
PatRef {
attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
and_token: Token ! [ & ](tokens_helper(_visitor, &_i.and_token.spans)),
mutability: (_i.mutability).map(|it| Token![mut](tokens_helper(_visitor, &it.span))),
pat: Box::new(_visitor.fold_pat(*_i.pat)),
@ -2403,6 +2410,7 @@ pub fn fold_pat_ref<V: Fold + ?Sized>(_visitor: &mut V, _i: PatRef) -> PatRef {
#[cfg(feature = "full")]
pub fn fold_pat_slice<V: Fold + ?Sized>(_visitor: &mut V, _i: PatSlice) -> PatSlice {
PatSlice {
attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)),
front: FoldHelper::lift(_i.front, |it| _visitor.fold_pat(it)),
middle: (_i.middle).map(|it| Box::new(_visitor.fold_pat(*it))),
@ -2414,6 +2422,7 @@ pub fn fold_pat_slice<V: Fold + ?Sized>(_visitor: &mut V, _i: PatSlice) -> PatSl
#[cfg(feature = "full")]
pub fn fold_pat_struct<V: Fold + ?Sized>(_visitor: &mut V, _i: PatStruct) -> PatStruct {
PatStruct {
attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
path: _visitor.fold_path(_i.path),
brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)),
fields: FoldHelper::lift(_i.fields, |it| _visitor.fold_field_pat(it)),
@ -2423,6 +2432,7 @@ pub fn fold_pat_struct<V: Fold + ?Sized>(_visitor: &mut V, _i: PatStruct) -> Pat
#[cfg(feature = "full")]
pub fn fold_pat_tuple<V: Fold + ?Sized>(_visitor: &mut V, _i: PatTuple) -> PatTuple {
PatTuple {
attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)),
front: FoldHelper::lift(_i.front, |it| _visitor.fold_pat(it)),
dot2_token: (_i.dot2_token).map(|it| Token![..](tokens_helper(_visitor, &it.spans))),
@ -2436,6 +2446,7 @@ pub fn fold_pat_tuple_struct<V: Fold + ?Sized>(
_i: PatTupleStruct,
) -> PatTupleStruct {
PatTupleStruct {
attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
path: _visitor.fold_path(_i.path),
pat: _visitor.fold_pat_tuple(_i.pat),
}
@ -2447,6 +2458,7 @@ pub fn fold_pat_verbatim<V: Fold + ?Sized>(_visitor: &mut V, _i: PatVerbatim) ->
#[cfg(feature = "full")]
pub fn fold_pat_wild<V: Fold + ?Sized>(_visitor: &mut V, _i: PatWild) -> PatWild {
PatWild {
attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)),
underscore_token: Token![_](tokens_helper(_visitor, &_i.underscore_token.spans)),
}
}

36
src/gen/visit.rs
View File

@ -2686,11 +2686,17 @@ pub fn visit_pat<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Pat)
}
#[cfg(feature = "full")]
pub fn visit_pat_box<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatBox) {
for it in &_i.attrs {
_visitor.visit_attribute(it)
}
tokens_helper(_visitor, &_i.box_token.span);
_visitor.visit_pat(&*_i.pat);
}
#[cfg(feature = "full")]
pub fn visit_pat_ident<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatIdent) {
for it in &_i.attrs {
_visitor.visit_attribute(it)
}
if let Some(ref it) = _i.by_ref {
tokens_helper(_visitor, &it.span)
};
@ -2705,14 +2711,23 @@ pub fn visit_pat_ident<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'as
}
#[cfg(feature = "full")]
pub fn visit_pat_lit<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatLit) {
for it in &_i.attrs {
_visitor.visit_attribute(it)
}
_visitor.visit_expr(&*_i.expr);
}
#[cfg(feature = "full")]
pub fn visit_pat_macro<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatMacro) {
for it in &_i.attrs {
_visitor.visit_attribute(it)
}
_visitor.visit_macro(&_i.mac);
}
#[cfg(feature = "full")]
pub fn visit_pat_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatPath) {
for it in &_i.attrs {
_visitor.visit_attribute(it)
}
if let Some(ref it) = _i.qself {
_visitor.visit_qself(it)
};
@ -2720,12 +2735,18 @@ pub fn visit_pat_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast
}
#[cfg(feature = "full")]
pub fn visit_pat_range<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatRange) {
for it in &_i.attrs {
_visitor.visit_attribute(it)
}
_visitor.visit_expr(&*_i.lo);
_visitor.visit_range_limits(&_i.limits);
_visitor.visit_expr(&*_i.hi);
}
#[cfg(feature = "full")]
pub fn visit_pat_ref<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatRef) {
for it in &_i.attrs {
_visitor.visit_attribute(it)
}
tokens_helper(_visitor, &_i.and_token.spans);
if let Some(ref it) = _i.mutability {
tokens_helper(_visitor, &it.span)
@ -2734,6 +2755,9 @@ pub fn visit_pat_ref<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast
}
#[cfg(feature = "full")]
pub fn visit_pat_slice<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatSlice) {
for it in &_i.attrs {
_visitor.visit_attribute(it)
}
tokens_helper(_visitor, &_i.bracket_token.span);
for el in Punctuated::pairs(&_i.front) {
let it = el.value();
@ -2755,6 +2779,9 @@ pub fn visit_pat_slice<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'as
}
#[cfg(feature = "full")]
pub fn visit_pat_struct<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatStruct) {
for it in &_i.attrs {
_visitor.visit_attribute(it)
}
_visitor.visit_path(&_i.path);
tokens_helper(_visitor, &_i.brace_token.span);
for el in Punctuated::pairs(&_i.fields) {
@ -2767,6 +2794,9 @@ pub fn visit_pat_struct<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'a
}
#[cfg(feature = "full")]
pub fn visit_pat_tuple<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatTuple) {
for it in &_i.attrs {
_visitor.visit_attribute(it)
}
tokens_helper(_visitor, &_i.paren_token.span);
for el in Punctuated::pairs(&_i.front) {
let it = el.value();
@ -2788,6 +2818,9 @@ pub fn visit_pat_tuple_struct<'ast, V: Visit<'ast> + ?Sized>(
_visitor: &mut V,
_i: &'ast PatTupleStruct,
) {
for it in &_i.attrs {
_visitor.visit_attribute(it)
}
_visitor.visit_path(&_i.path);
_visitor.visit_pat_tuple(&_i.pat);
}
@ -2797,6 +2830,9 @@ pub fn visit_pat_verbatim<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &
}
#[cfg(feature = "full")]
pub fn visit_pat_wild<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatWild) {
for it in &_i.attrs {
_visitor.visit_attribute(it)
}
tokens_helper(_visitor, &_i.underscore_token.spans);
}
#[cfg(any(feature = "derive", feature = "full"))]

36
src/gen/visit_mut.rs
View File

@ -2629,11 +2629,17 @@ pub fn visit_pat_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Pat) {
}
#[cfg(feature = "full")]
pub fn visit_pat_box_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatBox) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.box_token.span);
_visitor.visit_pat_mut(&mut *_i.pat);
}
#[cfg(feature = "full")]
pub fn visit_pat_ident_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatIdent) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
if let Some(ref mut it) = _i.by_ref {
tokens_helper(_visitor, &mut it.span)
};
@ -2648,14 +2654,23 @@ pub fn visit_pat_ident_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatI
}
#[cfg(feature = "full")]
pub fn visit_pat_lit_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatLit) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_expr_mut(&mut *_i.expr);
}
#[cfg(feature = "full")]
pub fn visit_pat_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatMacro) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_macro_mut(&mut _i.mac);
}
#[cfg(feature = "full")]
pub fn visit_pat_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatPath) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
if let Some(ref mut it) = _i.qself {
_visitor.visit_qself_mut(it)
};
@ -2663,12 +2678,18 @@ pub fn visit_pat_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatPa
}
#[cfg(feature = "full")]
pub fn visit_pat_range_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatRange) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_expr_mut(&mut *_i.lo);
_visitor.visit_range_limits_mut(&mut _i.limits);
_visitor.visit_expr_mut(&mut *_i.hi);
}
#[cfg(feature = "full")]
pub fn visit_pat_ref_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatRef) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.and_token.spans);
if let Some(ref mut it) = _i.mutability {
tokens_helper(_visitor, &mut it.span)
@ -2677,6 +2698,9 @@ pub fn visit_pat_ref_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatRef
}
#[cfg(feature = "full")]
pub fn visit_pat_slice_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatSlice) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.bracket_token.span);
for mut el in Punctuated::pairs_mut(&mut _i.front) {
let it = el.value_mut();
@ -2698,6 +2722,9 @@ pub fn visit_pat_slice_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatS
}
#[cfg(feature = "full")]
pub fn visit_pat_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatStruct) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_path_mut(&mut _i.path);
tokens_helper(_visitor, &mut _i.brace_token.span);
for mut el in Punctuated::pairs_mut(&mut _i.fields) {
@ -2710,6 +2737,9 @@ pub fn visit_pat_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Pat
}
#[cfg(feature = "full")]
pub fn visit_pat_tuple_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatTuple) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.paren_token.span);
for mut el in Punctuated::pairs_mut(&mut _i.front) {
let it = el.value_mut();
@ -2728,6 +2758,9 @@ pub fn visit_pat_tuple_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatT
}
#[cfg(feature = "full")]
pub fn visit_pat_tuple_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatTupleStruct) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_path_mut(&mut _i.path);
_visitor.visit_pat_tuple_mut(&mut _i.pat);
}
@ -2737,6 +2770,9 @@ pub fn visit_pat_verbatim_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut P
}
#[cfg(feature = "full")]
pub fn visit_pat_wild_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatWild) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.underscore_token.spans);
}
#[cfg(any(feature = "derive", feature = "full"))]

60
syn.json
View File

@ -4163,6 +4163,11 @@
]
},
"fields": {
"attrs": {
"vec": {
"syn": "Attribute"
}
},
"box_token": {
"token": "Box"
},
@ -4181,6 +4186,11 @@
]
},
"fields": {
"attrs": {
"vec": {
"syn": "Attribute"
}
},
"by_ref": {
"option": {
"token": "Ref"
@ -4218,6 +4228,11 @@
]
},
"fields": {
"attrs": {
"vec": {
"syn": "Attribute"
}
},
"expr": {
"box": {
"syn": "Expr"
@ -4233,6 +4248,11 @@
]
},
"fields": {
"attrs": {
"vec": {
"syn": "Attribute"
}
},
"mac": {
"syn": "Macro"
}
@ -4246,6 +4266,11 @@
]
},
"fields": {
"attrs": {
"vec": {
"syn": "Attribute"
}
},
"qself": {
"option": {
"syn": "QSelf"
@ -4264,6 +4289,11 @@
]
},
"fields": {
"attrs": {
"vec": {
"syn": "Attribute"
}
},
"lo": {
"box": {
"syn": "Expr"
@ -4287,6 +4317,11 @@
]
},
"fields": {
"attrs": {
"vec": {
"syn": "Attribute"
}
},
"and_token": {
"token": "And"
},
@ -4310,6 +4345,11 @@
]
},
"fields": {
"attrs": {
"vec": {
"syn": "Attribute"
}
},
"bracket_token": {
"group": "Bracket"
},
@ -4356,6 +4396,11 @@
]
},
"fields": {
"attrs": {
"vec": {
"syn": "Attribute"
}
},
"path": {
"syn": "Path"
},
@ -4385,6 +4430,11 @@
]
},
"fields": {
"attrs": {
"vec": {
"syn": "Attribute"
}
},
"paren_token": {
"group": "Paren"
},
@ -4424,6 +4474,11 @@
]
},
"fields": {
"attrs": {
"vec": {
"syn": "Attribute"
}
},
"path": {
"syn": "Path"
},
@ -4453,6 +4508,11 @@
]
},
"fields": {
"attrs": {
"vec": {
"syn": "Attribute"
}
},
"underscore_token": {
"token": "Underscore"
}

72
tests/debug/gen.rs
View File

@ -4151,11 +4151,17 @@ impl Debug for Lite<syn::Pat> {
match _val {
syn::Pat::Box(_val) => {
let mut formatter = formatter.debug_struct("Pat::Box");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
formatter.field("pat", Lite(&_val.pat));
formatter.finish()
}
syn::Pat::Ident(_val) => {
let mut formatter = formatter.debug_struct("Pat::Ident");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
if let Some(val) = &_val.by_ref {
#[derive(RefCast)]
#[repr(transparent)]
@ -4201,16 +4207,25 @@ impl Debug for Lite<syn::Pat> {
}
syn::Pat::Lit(_val) => {
let mut formatter = formatter.debug_struct("Pat::Lit");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
formatter.field("expr", Lite(&_val.expr));
formatter.finish()
}
syn::Pat::Macro(_val) => {
let mut formatter = formatter.debug_struct("Pat::Macro");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
formatter.field("mac", Lite(&_val.mac));
formatter.finish()
}
syn::Pat::Path(_val) => {
let mut formatter = formatter.debug_struct("Pat::Path");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
if let Some(val) = &_val.qself {
#[derive(RefCast)]
#[repr(transparent)]
@ -4232,6 +4247,9 @@ impl Debug for Lite<syn::Pat> {
}
syn::Pat::Range(_val) => {
let mut formatter = formatter.debug_struct("Pat::Range");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
formatter.field("lo", Lite(&_val.lo));
formatter.field("limits", Lite(&_val.limits));
formatter.field("hi", Lite(&_val.hi));
@ -4239,6 +4257,9 @@ impl Debug for Lite<syn::Pat> {
}
syn::Pat::Ref(_val) => {
let mut formatter = formatter.debug_struct("Pat::Ref");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
if let Some(val) = &_val.mutability {
#[derive(RefCast)]
#[repr(transparent)]
@ -4256,6 +4277,9 @@ impl Debug for Lite<syn::Pat> {
}
syn::Pat::Slice(_val) => {
let mut formatter = formatter.debug_struct("Pat::Slice");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
if !_val.front.is_empty() {
formatter.field("front", Lite(&_val.front));
}
@ -4306,6 +4330,9 @@ impl Debug for Lite<syn::Pat> {
}
syn::Pat::Struct(_val) => {
let mut formatter = formatter.debug_struct("Pat::Struct");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
formatter.field("path", Lite(&_val.path));
if !_val.fields.is_empty() {
formatter.field("fields", Lite(&_val.fields));
@ -4326,6 +4353,9 @@ impl Debug for Lite<syn::Pat> {
}
syn::Pat::Tuple(_val) => {
let mut formatter = formatter.debug_struct("Pat::Tuple");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
if !_val.front.is_empty() {
formatter.field("front", Lite(&_val.front));
}
@ -4360,6 +4390,9 @@ impl Debug for Lite<syn::Pat> {
}
syn::Pat::TupleStruct(_val) => {
let mut formatter = formatter.debug_struct("Pat::TupleStruct");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
formatter.field("path", Lite(&_val.path));
formatter.field("pat", Lite(&_val.pat));
formatter.finish()
@ -4371,6 +4404,9 @@ impl Debug for Lite<syn::Pat> {
}
syn::Pat::Wild(_val) => {
let mut formatter = formatter.debug_struct("Pat::Wild");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
formatter.finish()
}
}
@ -4380,6 +4416,9 @@ impl Debug for Lite<syn::PatBox> {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
let _val = &self.value;
let mut formatter = formatter.debug_struct("PatBox");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
formatter.field("pat", Lite(&_val.pat));
formatter.finish()
}
@ -4388,6 +4427,9 @@ impl Debug for Lite<syn::PatIdent> {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
let _val = &self.value;
let mut formatter = formatter.debug_struct("PatIdent");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
if let Some(val) = &_val.by_ref {
#[derive(RefCast)]
#[repr(transparent)]
@ -4436,6 +4478,9 @@ impl Debug for Lite<syn::PatLit> {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
let _val = &self.value;
let mut formatter = formatter.debug_struct("PatLit");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
formatter.field("expr", Lite(&_val.expr));
formatter.finish()
}
@ -4444,6 +4489,9 @@ impl Debug for Lite<syn::PatMacro> {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
let _val = &self.value;
let mut formatter = formatter.debug_struct("PatMacro");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
formatter.field("mac", Lite(&_val.mac));
formatter.finish()
}
@ -4452,6 +4500,9 @@ impl Debug for Lite<syn::PatPath> {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
let _val = &self.value;
let mut formatter = formatter.debug_struct("PatPath");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
if let Some(val) = &_val.qself {
#[derive(RefCast)]
#[repr(transparent)]
@ -4476,6 +4527,9 @@ impl Debug for Lite<syn::PatRange> {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
let _val = &self.value;
let mut formatter = formatter.debug_struct("PatRange");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
formatter.field("lo", Lite(&_val.lo));
formatter.field("limits", Lite(&_val.limits));
formatter.field("hi", Lite(&_val.hi));
@ -4486,6 +4540,9 @@ impl Debug for Lite<syn::PatRef> {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
let _val = &self.value;
let mut formatter = formatter.debug_struct("PatRef");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
if let Some(val) = &_val.mutability {
#[derive(RefCast)]
#[repr(transparent)]
@ -4506,6 +4563,9 @@ impl Debug for Lite<syn::PatSlice> {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
let _val = &self.value;
let mut formatter = formatter.debug_struct("PatSlice");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
if !_val.front.is_empty() {
formatter.field("front", Lite(&_val.front));
}
@ -4559,6 +4619,9 @@ impl Debug for Lite<syn::PatStruct> {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
let _val = &self.value;
let mut formatter = formatter.debug_struct("PatStruct");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
formatter.field("path", Lite(&_val.path));
if !_val.fields.is_empty() {
formatter.field("fields", Lite(&_val.fields));
@ -4582,6 +4645,9 @@ impl Debug for Lite<syn::PatTuple> {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
let _val = &self.value;
let mut formatter = formatter.debug_struct("PatTuple");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
if !_val.front.is_empty() {
formatter.field("front", Lite(&_val.front));
}
@ -4619,6 +4685,9 @@ impl Debug for Lite<syn::PatTupleStruct> {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
let _val = &self.value;
let mut formatter = formatter.debug_struct("PatTupleStruct");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
formatter.field("path", Lite(&_val.path));
formatter.field("pat", Lite(&_val.pat));
formatter.finish()
@ -4636,6 +4705,9 @@ impl Debug for Lite<syn::PatWild> {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
let _val = &self.value;
let mut formatter = formatter.debug_struct("PatWild");
if !_val.attrs.is_empty() {
formatter.field("attrs", Lite(&_val.attrs));
}
formatter.finish()
}
}