1use crate::algorithm::Printer;
2use crate::fixup::FixupContext;
3use crate::iter::IterDelimited;
4use crate::mac;
5use crate::path::PathKind;
6use crate::INDENT;
7use proc_macro2::TokenStream;
8use syn::{
9 Fields, FnArg, ForeignItem, ForeignItemFn, ForeignItemMacro, ForeignItemStatic,
10 ForeignItemType, ImplItem, ImplItemConst, ImplItemFn, ImplItemMacro, ImplItemType, Item,
11 ItemConst, ItemEnum, ItemExternCrate, ItemFn, ItemForeignMod, ItemImpl, ItemMacro, ItemMod,
12 ItemStatic, ItemStruct, ItemTrait, ItemTraitAlias, ItemType, ItemUnion, ItemUse, Receiver,
13 Signature, StaticMutability, TraitItem, TraitItemConst, TraitItemFn, TraitItemMacro,
14 TraitItemType, Type, UseGlob, UseGroup, UseName, UsePath, UseRename, UseTree, Variadic,
15};
16
17impl Printer {
18 pub fn item(&mut self, item: &Item) {
19 match item {
20 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
21 Item::Const(item) => self.item_const(item),
22 Item::Enum(item) => self.item_enum(item),
23 Item::ExternCrate(item) => self.item_extern_crate(item),
24 Item::Fn(item) => self.item_fn(item),
25 Item::ForeignMod(item) => self.item_foreign_mod(item),
26 Item::Impl(item) => self.item_impl(item),
27 Item::Macro(item) => self.item_macro(item),
28 Item::Mod(item) => self.item_mod(item),
29 Item::Static(item) => self.item_static(item),
30 Item::Struct(item) => self.item_struct(item),
31 Item::Trait(item) => self.item_trait(item),
32 Item::TraitAlias(item) => self.item_trait_alias(item),
33 Item::Type(item) => self.item_type(item),
34 Item::Union(item) => self.item_union(item),
35 Item::Use(item) => self.item_use(item),
36 Item::Verbatim(item) => self.item_verbatim(item),
37 _ => unimplemented!("unknown Item"),
38 }
39 }
40
41 fn item_const(&mut self, item: &ItemConst) {
42 self.outer_attrs(&item.attrs);
43 self.cbox(0);
44 self.visibility(&item.vis);
45 self.word("const ");
46 self.ident(&item.ident);
47 self.generics(&item.generics);
48 self.word(": ");
49 self.ty(&item.ty);
50 self.word(" = ");
51 self.neverbreak();
52 self.expr(&item.expr, FixupContext::NONE);
53 self.word(";");
54 self.end();
55 self.hardbreak();
56 }
57
58 fn item_enum(&mut self, item: &ItemEnum) {
59 self.outer_attrs(&item.attrs);
60 self.cbox(INDENT);
61 self.visibility(&item.vis);
62 self.word("enum ");
63 self.ident(&item.ident);
64 self.generics(&item.generics);
65 self.where_clause_for_body(&item.generics.where_clause);
66 self.word("{");
67 self.hardbreak_if_nonempty();
68 for variant in &item.variants {
69 self.variant(variant);
70 self.word(",");
71 self.hardbreak();
72 }
73 self.offset(-INDENT);
74 self.end();
75 self.word("}");
76 self.hardbreak();
77 }
78
79 fn item_extern_crate(&mut self, item: &ItemExternCrate) {
80 self.outer_attrs(&item.attrs);
81 self.visibility(&item.vis);
82 self.word("extern crate ");
83 self.ident(&item.ident);
84 if let Some((_as_token, rename)) = &item.rename {
85 self.word(" as ");
86 self.ident(rename);
87 }
88 self.word(";");
89 self.hardbreak();
90 }
91
92 fn item_fn(&mut self, item: &ItemFn) {
93 self.outer_attrs(&item.attrs);
94 self.cbox(INDENT);
95 self.visibility(&item.vis);
96 self.signature(
97 &item.sig,
98 #[cfg(feature = "verbatim")]
99 &verbatim::Safety::Disallowed,
100 );
101 self.where_clause_for_body(&item.sig.generics.where_clause);
102 self.word("{");
103 self.hardbreak_if_nonempty();
104 self.inner_attrs(&item.attrs);
105 for stmt in item.block.stmts.iter().delimited() {
106 self.stmt(&stmt, stmt.is_last);
107 }
108 self.offset(-INDENT);
109 self.end();
110 self.word("}");
111 self.hardbreak();
112 }
113
114 fn item_foreign_mod(&mut self, item: &ItemForeignMod) {
115 self.outer_attrs(&item.attrs);
116 self.cbox(INDENT);
117 if item.unsafety.is_some() {
118 self.word("unsafe ");
119 }
120 self.abi(&item.abi);
121 self.word("{");
122 self.hardbreak_if_nonempty();
123 self.inner_attrs(&item.attrs);
124 for foreign_item in &item.items {
125 self.foreign_item(foreign_item);
126 }
127 self.offset(-INDENT);
128 self.end();
129 self.word("}");
130 self.hardbreak();
131 }
132
133 fn item_impl(&mut self, item: &ItemImpl) {
134 self.outer_attrs(&item.attrs);
135 self.cbox(INDENT);
136 self.ibox(-INDENT);
137 self.cbox(INDENT);
138 if item.defaultness.is_some() {
139 self.word("default ");
140 }
141 if item.unsafety.is_some() {
142 self.word("unsafe ");
143 }
144 self.word("impl");
145 self.generics(&item.generics);
146 self.end();
147 self.nbsp();
148 if let Some((negative_polarity, path, _for_token)) = &item.trait_ {
149 if negative_polarity.is_some() {
150 self.word("!");
151 }
152 self.path(path, PathKind::Type);
153 self.space();
154 self.word("for ");
155 }
156 self.ty(&item.self_ty);
157 self.end();
158 self.where_clause_for_body(&item.generics.where_clause);
159 self.word("{");
160 self.hardbreak_if_nonempty();
161 self.inner_attrs(&item.attrs);
162 for impl_item in &item.items {
163 self.impl_item(impl_item);
164 }
165 self.offset(-INDENT);
166 self.end();
167 self.word("}");
168 self.hardbreak();
169 }
170
171 fn item_macro(&mut self, item: &ItemMacro) {
172 self.outer_attrs(&item.attrs);
173 let semicolon = mac::requires_semi(&item.mac.delimiter);
174 self.mac(&item.mac, item.ident.as_ref(), semicolon);
175 self.hardbreak();
176 }
177
178 fn item_mod(&mut self, item: &ItemMod) {
179 self.outer_attrs(&item.attrs);
180 self.cbox(INDENT);
181 self.visibility(&item.vis);
182 if item.unsafety.is_some() {
183 self.word("unsafe ");
184 }
185 self.word("mod ");
186 self.ident(&item.ident);
187 if let Some((_brace, items)) = &item.content {
188 self.word(" {");
189 self.hardbreak_if_nonempty();
190 self.inner_attrs(&item.attrs);
191 for item in items {
192 self.item(item);
193 }
194 self.offset(-INDENT);
195 self.end();
196 self.word("}");
197 } else {
198 self.word(";");
199 self.end();
200 }
201 self.hardbreak();
202 }
203
204 fn item_static(&mut self, item: &ItemStatic) {
205 self.outer_attrs(&item.attrs);
206 self.cbox(0);
207 self.visibility(&item.vis);
208 self.word("static ");
209 self.static_mutability(&item.mutability);
210 self.ident(&item.ident);
211 self.word(": ");
212 self.ty(&item.ty);
213 self.word(" = ");
214 self.neverbreak();
215 self.expr(&item.expr, FixupContext::NONE);
216 self.word(";");
217 self.end();
218 self.hardbreak();
219 }
220
221 fn item_struct(&mut self, item: &ItemStruct) {
222 self.outer_attrs(&item.attrs);
223 self.cbox(INDENT);
224 self.visibility(&item.vis);
225 self.word("struct ");
226 self.ident(&item.ident);
227 self.generics(&item.generics);
228 match &item.fields {
229 Fields::Named(fields) => {
230 self.where_clause_for_body(&item.generics.where_clause);
231 self.word("{");
232 self.hardbreak_if_nonempty();
233 for field in &fields.named {
234 self.field(field);
235 self.word(",");
236 self.hardbreak();
237 }
238 self.offset(-INDENT);
239 self.end();
240 self.word("}");
241 }
242 Fields::Unnamed(fields) => {
243 self.fields_unnamed(fields);
244 self.where_clause_semi(&item.generics.where_clause);
245 self.end();
246 }
247 Fields::Unit => {
248 self.where_clause_semi(&item.generics.where_clause);
249 self.end();
250 }
251 }
252 self.hardbreak();
253 }
254
255 fn item_trait(&mut self, item: &ItemTrait) {
256 self.outer_attrs(&item.attrs);
257 self.cbox(INDENT);
258 self.visibility(&item.vis);
259 if item.unsafety.is_some() {
260 self.word("unsafe ");
261 }
262 if item.auto_token.is_some() {
263 self.word("auto ");
264 }
265 self.word("trait ");
266 self.ident(&item.ident);
267 self.generics(&item.generics);
268 for supertrait in item.supertraits.iter().delimited() {
269 if supertrait.is_first {
270 self.word(": ");
271 } else {
272 self.word(" + ");
273 }
274 self.type_param_bound(&supertrait);
275 }
276 self.where_clause_for_body(&item.generics.where_clause);
277 self.word("{");
278 self.hardbreak_if_nonempty();
279 self.inner_attrs(&item.attrs);
280 for trait_item in &item.items {
281 self.trait_item(trait_item);
282 }
283 self.offset(-INDENT);
284 self.end();
285 self.word("}");
286 self.hardbreak();
287 }
288
289 fn item_trait_alias(&mut self, item: &ItemTraitAlias) {
290 self.outer_attrs(&item.attrs);
291 self.cbox(INDENT);
292 self.visibility(&item.vis);
293 self.word("trait ");
294 self.ident(&item.ident);
295 self.generics(&item.generics);
296 self.word(" = ");
297 self.neverbreak();
298 for bound in item.bounds.iter().delimited() {
299 if !bound.is_first {
300 self.space();
301 self.word("+ ");
302 }
303 self.type_param_bound(&bound);
304 }
305 self.where_clause_semi(&item.generics.where_clause);
306 self.end();
307 self.hardbreak();
308 }
309
310 fn item_type(&mut self, item: &ItemType) {
311 self.outer_attrs(&item.attrs);
312 self.cbox(INDENT);
313 self.visibility(&item.vis);
314 self.word("type ");
315 self.ident(&item.ident);
316 self.generics(&item.generics);
317 self.where_clause_oneline(&item.generics.where_clause);
318 self.word("= ");
319 self.neverbreak();
320 self.ibox(-INDENT);
321 self.ty(&item.ty);
322 self.end();
323 self.word(";");
324 self.end();
325 self.hardbreak();
326 }
327
328 fn item_union(&mut self, item: &ItemUnion) {
329 self.outer_attrs(&item.attrs);
330 self.cbox(INDENT);
331 self.visibility(&item.vis);
332 self.word("union ");
333 self.ident(&item.ident);
334 self.generics(&item.generics);
335 self.where_clause_for_body(&item.generics.where_clause);
336 self.word("{");
337 self.hardbreak_if_nonempty();
338 for field in &item.fields.named {
339 self.field(field);
340 self.word(",");
341 self.hardbreak();
342 }
343 self.offset(-INDENT);
344 self.end();
345 self.word("}");
346 self.hardbreak();
347 }
348
349 fn item_use(&mut self, item: &ItemUse) {
350 self.outer_attrs(&item.attrs);
351 self.visibility(&item.vis);
352 self.word("use ");
353 if item.leading_colon.is_some() {
354 self.word("::");
355 }
356 self.use_tree(&item.tree);
357 self.word(";");
358 self.hardbreak();
359 }
360
361 #[cfg(not(feature = "verbatim"))]
362 fn item_verbatim(&mut self, item: &TokenStream) {
363 if !item.is_empty() {
364 unimplemented!("Item::Verbatim `{}`", item);
365 }
366 self.hardbreak();
367 }
368
369 #[cfg(feature = "verbatim")]
370 fn item_verbatim(&mut self, tokens: &TokenStream) {
371 use syn::parse::{Parse, ParseStream, Result};
372 use syn::punctuated::Punctuated;
373 use syn::{
374 braced, parenthesized, token, Attribute, Generics, Ident, Lifetime, Token, Visibility,
375 };
376 use verbatim::{
377 FlexibleItemConst, FlexibleItemFn, FlexibleItemStatic, FlexibleItemType,
378 WhereClauseLocation,
379 };
380
381 enum ItemVerbatim {
382 Empty,
383 Ellipsis,
384 ConstFlexible(FlexibleItemConst),
385 FnFlexible(FlexibleItemFn),
386 ImplFlexible(ImplFlexible),
387 Macro2(Macro2),
388 StaticFlexible(FlexibleItemStatic),
389 TypeFlexible(FlexibleItemType),
390 UseBrace(UseBrace),
391 }
392
393 struct ImplFlexible {
394 attrs: Vec<Attribute>,
395 vis: Visibility,
396 defaultness: bool,
397 unsafety: bool,
398 generics: Generics,
399 constness: ImplConstness,
400 negative_impl: bool,
401 trait_: Option<Type>,
402 self_ty: Type,
403 items: Vec<ImplItem>,
404 }
405
406 enum ImplConstness {
407 None,
408 MaybeConst,
409 Const,
410 }
411
412 struct Macro2 {
413 attrs: Vec<Attribute>,
414 vis: Visibility,
415 ident: Ident,
416 args: Option<TokenStream>,
417 body: TokenStream,
418 }
419
420 struct UseBrace {
421 attrs: Vec<Attribute>,
422 vis: Visibility,
423 trees: Punctuated<RootUseTree, Token![,]>,
424 }
425
426 struct RootUseTree {
427 leading_colon: Option<Token![::]>,
428 inner: UseTree,
429 }
430
431 impl Parse for ImplConstness {
432 fn parse(input: ParseStream) -> Result<Self> {
433 if input.parse::<Option<Token![?]>>()?.is_some() {
434 input.parse::<Token![const]>()?;
435 Ok(ImplConstness::MaybeConst)
436 } else if input.parse::<Option<Token![const]>>()?.is_some() {
437 Ok(ImplConstness::Const)
438 } else {
439 Ok(ImplConstness::None)
440 }
441 }
442 }
443
444 impl Parse for RootUseTree {
445 fn parse(input: ParseStream) -> Result<Self> {
446 Ok(RootUseTree {
447 leading_colon: input.parse()?,
448 inner: input.parse()?,
449 })
450 }
451 }
452
453 impl Parse for ItemVerbatim {
454 fn parse(input: ParseStream) -> Result<Self> {
455 if input.is_empty() {
456 return Ok(ItemVerbatim::Empty);
457 } else if input.peek(Token![...]) {
458 input.parse::<Token![...]>()?;
459 return Ok(ItemVerbatim::Ellipsis);
460 }
461
462 let mut attrs = input.call(Attribute::parse_outer)?;
463 let vis: Visibility = input.parse()?;
464
465 let lookahead = input.lookahead1();
466 if lookahead.peek(Token![const]) && (input.peek2(Ident) || input.peek2(Token![_])) {
467 let defaultness = false;
468 let flexible_item = FlexibleItemConst::parse(attrs, vis, defaultness, input)?;
469 Ok(ItemVerbatim::ConstFlexible(flexible_item))
470 } else if input.peek(Token![const])
471 || lookahead.peek(Token![async])
472 || lookahead.peek(Token![unsafe]) && !input.peek2(Token![impl])
473 || lookahead.peek(Token![extern])
474 || lookahead.peek(Token![fn])
475 {
476 let defaultness = false;
477 let flexible_item = FlexibleItemFn::parse(attrs, vis, defaultness, input)?;
478 Ok(ItemVerbatim::FnFlexible(flexible_item))
479 } else if lookahead.peek(Token![default])
480 || input.peek(Token![unsafe])
481 || lookahead.peek(Token![impl])
482 {
483 let defaultness = input.parse::<Option<Token![default]>>()?.is_some();
484 let unsafety = input.parse::<Option<Token![unsafe]>>()?.is_some();
485 input.parse::<Token![impl]>()?;
486 let has_generics = input.peek(Token![<])
487 && (input.peek2(Token![>])
488 || input.peek2(Token![#])
489 || (input.peek2(Ident) || input.peek2(Lifetime))
490 && (input.peek3(Token![:])
491 || input.peek3(Token![,])
492 || input.peek3(Token![>])
493 || input.peek3(Token![=]))
494 || input.peek2(Token![const]));
495 let mut generics: Generics = if has_generics {
496 input.parse()?
497 } else {
498 Generics::default()
499 };
500 let constness: ImplConstness = input.parse()?;
501 let negative_impl =
502 !input.peek2(token::Brace) && input.parse::<Option<Token![!]>>()?.is_some();
503 let first_ty: Type = input.parse()?;
504 let (trait_, self_ty) = if input.parse::<Option<Token![for]>>()?.is_some() {
505 (Some(first_ty), input.parse()?)
506 } else {
507 (None, first_ty)
508 };
509 generics.where_clause = input.parse()?;
510 let content;
511 braced!(content in input);
512 let inner_attrs = content.call(Attribute::parse_inner)?;
513 attrs.extend(inner_attrs);
514 let mut items = Vec::new();
515 while !content.is_empty() {
516 items.push(content.parse()?);
517 }
518 Ok(ItemVerbatim::ImplFlexible(ImplFlexible {
519 attrs,
520 vis,
521 defaultness,
522 unsafety,
523 generics,
524 constness,
525 negative_impl,
526 trait_,
527 self_ty,
528 items,
529 }))
530 } else if lookahead.peek(Token![macro]) {
531 input.parse::<Token![macro]>()?;
532 let ident: Ident = input.parse()?;
533 let args = if input.peek(token::Paren) {
534 let paren_content;
535 parenthesized!(paren_content in input);
536 Some(paren_content.parse::<TokenStream>()?)
537 } else {
538 None
539 };
540 let brace_content;
541 braced!(brace_content in input);
542 let body: TokenStream = brace_content.parse()?;
543 Ok(ItemVerbatim::Macro2(Macro2 {
544 attrs,
545 vis,
546 ident,
547 args,
548 body,
549 }))
550 } else if lookahead.peek(Token![static]) {
551 let flexible_item = FlexibleItemStatic::parse(attrs, vis, input)?;
552 Ok(ItemVerbatim::StaticFlexible(flexible_item))
553 } else if lookahead.peek(Token![type]) {
554 let defaultness = false;
555 let flexible_item = FlexibleItemType::parse(
556 attrs,
557 vis,
558 defaultness,
559 input,
560 WhereClauseLocation::BeforeEq,
561 )?;
562 Ok(ItemVerbatim::TypeFlexible(flexible_item))
563 } else if lookahead.peek(Token![use]) {
564 input.parse::<Token![use]>()?;
565 let content;
566 braced!(content in input);
567 let trees = content.parse_terminated(RootUseTree::parse, Token![,])?;
568 input.parse::<Token![;]>()?;
569 Ok(ItemVerbatim::UseBrace(UseBrace { attrs, vis, trees }))
570 } else {
571 Err(lookahead.error())
572 }
573 }
574 }
575
576 let item: ItemVerbatim = match syn::parse2(tokens.clone()) {
577 Ok(item) => item,
578 Err(_) => unimplemented!("Item::Verbatim `{}`", tokens),
579 };
580
581 match item {
582 ItemVerbatim::Empty => {
583 self.hardbreak();
584 }
585 ItemVerbatim::Ellipsis => {
586 self.word("...");
587 self.hardbreak();
588 }
589 ItemVerbatim::ConstFlexible(item) => {
590 self.flexible_item_const(&item);
591 }
592 ItemVerbatim::FnFlexible(item) => {
593 self.flexible_item_fn(&item);
594 }
595 ItemVerbatim::ImplFlexible(item) => {
596 self.outer_attrs(&item.attrs);
597 self.cbox(INDENT);
598 self.ibox(-INDENT);
599 self.cbox(INDENT);
600 self.visibility(&item.vis);
601 if item.defaultness {
602 self.word("default ");
603 }
604 if item.unsafety {
605 self.word("unsafe ");
606 }
607 self.word("impl");
608 self.generics(&item.generics);
609 self.end();
610 self.nbsp();
611 match item.constness {
612 ImplConstness::None => {}
613 ImplConstness::MaybeConst => self.word("?const "),
614 ImplConstness::Const => self.word("const "),
615 }
616 if item.negative_impl {
617 self.word("!");
618 }
619 if let Some(trait_) = &item.trait_ {
620 self.ty(trait_);
621 self.space();
622 self.word("for ");
623 }
624 self.ty(&item.self_ty);
625 self.end();
626 self.where_clause_for_body(&item.generics.where_clause);
627 self.word("{");
628 self.hardbreak_if_nonempty();
629 self.inner_attrs(&item.attrs);
630 for impl_item in &item.items {
631 self.impl_item(impl_item);
632 }
633 self.offset(-INDENT);
634 self.end();
635 self.word("}");
636 self.hardbreak();
637 }
638 ItemVerbatim::Macro2(item) => {
639 self.outer_attrs(&item.attrs);
640 self.visibility(&item.vis);
641 self.word("macro ");
642 self.ident(&item.ident);
643 if let Some(args) = &item.args {
644 self.word("(");
645 self.cbox(INDENT);
646 self.zerobreak();
647 self.ibox(0);
648 self.macro_rules_tokens(args.clone(), true);
649 self.end();
650 self.zerobreak();
651 self.offset(-INDENT);
652 self.end();
653 self.word(")");
654 }
655 self.word(" {");
656 if !item.body.is_empty() {
657 self.neverbreak();
658 self.cbox(INDENT);
659 self.hardbreak();
660 self.ibox(0);
661 self.macro_rules_tokens(item.body.clone(), false);
662 self.end();
663 self.hardbreak();
664 self.offset(-INDENT);
665 self.end();
666 }
667 self.word("}");
668 self.hardbreak();
669 }
670 ItemVerbatim::StaticFlexible(item) => {
671 self.flexible_item_static(&item);
672 }
673 ItemVerbatim::TypeFlexible(item) => {
674 self.flexible_item_type(&item);
675 }
676 ItemVerbatim::UseBrace(item) => {
677 self.outer_attrs(&item.attrs);
678 self.visibility(&item.vis);
679 self.word("use ");
680 if item.trees.len() == 1 {
681 self.word("::");
682 self.use_tree(&item.trees[0].inner);
683 } else {
684 self.cbox(INDENT);
685 self.word("{");
686 self.zerobreak();
687 self.ibox(0);
688 for use_tree in item.trees.iter().delimited() {
689 if use_tree.leading_colon.is_some() {
690 self.word("::");
691 }
692 self.use_tree(&use_tree.inner);
693 if !use_tree.is_last {
694 self.word(",");
695 let mut use_tree = &use_tree.inner;
696 while let UseTree::Path(use_path) = use_tree {
697 use_tree = &use_path.tree;
698 }
699 if let UseTree::Group(_) = use_tree {
700 self.hardbreak();
701 } else {
702 self.space();
703 }
704 }
705 }
706 self.end();
707 self.trailing_comma(true);
708 self.offset(-INDENT);
709 self.word("}");
710 self.end();
711 }
712 self.word(";");
713 self.hardbreak();
714 }
715 }
716 }
717
718 fn use_tree(&mut self, use_tree: &UseTree) {
719 match use_tree {
720 UseTree::Path(use_path) => self.use_path(use_path),
721 UseTree::Name(use_name) => self.use_name(use_name),
722 UseTree::Rename(use_rename) => self.use_rename(use_rename),
723 UseTree::Glob(use_glob) => self.use_glob(use_glob),
724 UseTree::Group(use_group) => self.use_group(use_group),
725 }
726 }
727
728 fn use_path(&mut self, use_path: &UsePath) {
729 self.ident(&use_path.ident);
730 self.word("::");
731 self.use_tree(&use_path.tree);
732 }
733
734 fn use_name(&mut self, use_name: &UseName) {
735 self.ident(&use_name.ident);
736 }
737
738 fn use_rename(&mut self, use_rename: &UseRename) {
739 self.ident(&use_rename.ident);
740 self.word(" as ");
741 self.ident(&use_rename.rename);
742 }
743
744 fn use_glob(&mut self, use_glob: &UseGlob) {
745 let _ = use_glob;
746 self.word("*");
747 }
748
749 fn use_group(&mut self, use_group: &UseGroup) {
750 if use_group.items.is_empty() {
751 self.word("{}");
752 } else if use_group.items.len() == 1
753 && match &use_group.items[0] {
754 UseTree::Rename(use_rename) => use_rename.ident != "self",
755 _ => true,
756 }
757 {
758 self.use_tree(&use_group.items[0]);
759 } else {
760 self.cbox(INDENT);
761 self.word("{");
762 self.zerobreak();
763 self.ibox(0);
764 for use_tree in use_group.items.iter().delimited() {
765 self.use_tree(&use_tree);
766 if !use_tree.is_last {
767 self.word(",");
768 let mut use_tree = *use_tree;
769 while let UseTree::Path(use_path) = use_tree {
770 use_tree = &use_path.tree;
771 }
772 if let UseTree::Group(_) = use_tree {
773 self.hardbreak();
774 } else {
775 self.space();
776 }
777 }
778 }
779 self.end();
780 self.trailing_comma(true);
781 self.offset(-INDENT);
782 self.word("}");
783 self.end();
784 }
785 }
786
787 fn foreign_item(&mut self, foreign_item: &ForeignItem) {
788 match foreign_item {
789 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
790 ForeignItem::Fn(item) => self.foreign_item_fn(item),
791 ForeignItem::Static(item) => self.foreign_item_static(item),
792 ForeignItem::Type(item) => self.foreign_item_type(item),
793 ForeignItem::Macro(item) => self.foreign_item_macro(item),
794 ForeignItem::Verbatim(item) => self.foreign_item_verbatim(item),
795 _ => unimplemented!("unknown ForeignItem"),
796 }
797 }
798
799 fn foreign_item_fn(&mut self, foreign_item: &ForeignItemFn) {
800 self.outer_attrs(&foreign_item.attrs);
801 self.cbox(INDENT);
802 self.visibility(&foreign_item.vis);
803 self.signature(
804 &foreign_item.sig,
805 #[cfg(feature = "verbatim")]
806 &verbatim::Safety::Disallowed,
807 );
808 self.where_clause_semi(&foreign_item.sig.generics.where_clause);
809 self.end();
810 self.hardbreak();
811 }
812
813 fn foreign_item_static(&mut self, foreign_item: &ForeignItemStatic) {
814 self.outer_attrs(&foreign_item.attrs);
815 self.cbox(0);
816 self.visibility(&foreign_item.vis);
817 self.word("static ");
818 self.static_mutability(&foreign_item.mutability);
819 self.ident(&foreign_item.ident);
820 self.word(": ");
821 self.ty(&foreign_item.ty);
822 self.word(";");
823 self.end();
824 self.hardbreak();
825 }
826
827 fn foreign_item_type(&mut self, foreign_item: &ForeignItemType) {
828 self.outer_attrs(&foreign_item.attrs);
829 self.cbox(0);
830 self.visibility(&foreign_item.vis);
831 self.word("type ");
832 self.ident(&foreign_item.ident);
833 self.generics(&foreign_item.generics);
834 self.word(";");
835 self.end();
836 self.hardbreak();
837 }
838
839 fn foreign_item_macro(&mut self, foreign_item: &ForeignItemMacro) {
840 self.outer_attrs(&foreign_item.attrs);
841 let semicolon = mac::requires_semi(&foreign_item.mac.delimiter);
842 self.mac(&foreign_item.mac, None, semicolon);
843 self.hardbreak();
844 }
845
846 #[cfg(not(feature = "verbatim"))]
847 fn foreign_item_verbatim(&mut self, foreign_item: &TokenStream) {
848 if !foreign_item.is_empty() {
849 unimplemented!("ForeignItem::Verbatim `{}`", foreign_item);
850 }
851 self.hardbreak();
852 }
853
854 #[cfg(feature = "verbatim")]
855 fn foreign_item_verbatim(&mut self, tokens: &TokenStream) {
856 use syn::parse::{Parse, ParseStream, Result};
857 use syn::{Abi, Attribute, Token, Visibility};
858 use verbatim::{
859 kw, FlexibleItemFn, FlexibleItemStatic, FlexibleItemType, WhereClauseLocation,
860 };
861
862 enum ForeignItemVerbatim {
863 Empty,
864 Ellipsis,
865 FnFlexible(FlexibleItemFn),
866 StaticFlexible(FlexibleItemStatic),
867 TypeFlexible(FlexibleItemType),
868 }
869
870 fn peek_signature(input: ParseStream) -> bool {
871 let fork = input.fork();
872 fork.parse::<Option<Token![const]>>().is_ok()
873 && fork.parse::<Option<Token![async]>>().is_ok()
874 && ((fork.peek(kw::safe) && fork.parse::<kw::safe>().is_ok())
875 || fork.parse::<Option<Token![unsafe]>>().is_ok())
876 && fork.parse::<Option<Abi>>().is_ok()
877 && fork.peek(Token![fn])
878 }
879
880 impl Parse for ForeignItemVerbatim {
881 fn parse(input: ParseStream) -> Result<Self> {
882 if input.is_empty() {
883 return Ok(ForeignItemVerbatim::Empty);
884 } else if input.peek(Token![...]) {
885 input.parse::<Token![...]>()?;
886 return Ok(ForeignItemVerbatim::Ellipsis);
887 }
888
889 let attrs = input.call(Attribute::parse_outer)?;
890 let vis: Visibility = input.parse()?;
891 let defaultness = false;
892
893 let lookahead = input.lookahead1();
894 if lookahead.peek(Token![fn]) || peek_signature(input) {
895 let flexible_item = FlexibleItemFn::parse(attrs, vis, defaultness, input)?;
896 Ok(ForeignItemVerbatim::FnFlexible(flexible_item))
897 } else if lookahead.peek(Token![static])
898 || ((input.peek(Token![unsafe]) || input.peek(kw::safe))
899 && input.peek2(Token![static]))
900 {
901 let flexible_item = FlexibleItemStatic::parse(attrs, vis, input)?;
902 Ok(ForeignItemVerbatim::StaticFlexible(flexible_item))
903 } else if lookahead.peek(Token![type]) {
904 let flexible_item = FlexibleItemType::parse(
905 attrs,
906 vis,
907 defaultness,
908 input,
909 WhereClauseLocation::Both,
910 )?;
911 Ok(ForeignItemVerbatim::TypeFlexible(flexible_item))
912 } else {
913 Err(lookahead.error())
914 }
915 }
916 }
917
918 let foreign_item: ForeignItemVerbatim = match syn::parse2(tokens.clone()) {
919 Ok(foreign_item) => foreign_item,
920 Err(_) => unimplemented!("ForeignItem::Verbatim `{}`", tokens),
921 };
922
923 match foreign_item {
924 ForeignItemVerbatim::Empty => {
925 self.hardbreak();
926 }
927 ForeignItemVerbatim::Ellipsis => {
928 self.word("...");
929 self.hardbreak();
930 }
931 ForeignItemVerbatim::FnFlexible(foreign_item) => {
932 self.flexible_item_fn(&foreign_item);
933 }
934 ForeignItemVerbatim::StaticFlexible(foreign_item) => {
935 self.flexible_item_static(&foreign_item);
936 }
937 ForeignItemVerbatim::TypeFlexible(foreign_item) => {
938 self.flexible_item_type(&foreign_item);
939 }
940 }
941 }
942
943 fn trait_item(&mut self, trait_item: &TraitItem) {
944 match trait_item {
945 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
946 TraitItem::Const(item) => self.trait_item_const(item),
947 TraitItem::Fn(item) => self.trait_item_fn(item),
948 TraitItem::Type(item) => self.trait_item_type(item),
949 TraitItem::Macro(item) => self.trait_item_macro(item),
950 TraitItem::Verbatim(item) => self.trait_item_verbatim(item),
951 _ => unimplemented!("unknown TraitItem"),
952 }
953 }
954
955 fn trait_item_const(&mut self, trait_item: &TraitItemConst) {
956 self.outer_attrs(&trait_item.attrs);
957 self.cbox(0);
958 self.word("const ");
959 self.ident(&trait_item.ident);
960 self.generics(&trait_item.generics);
961 self.word(": ");
962 self.ty(&trait_item.ty);
963 if let Some((_eq_token, default)) = &trait_item.default {
964 self.word(" = ");
965 self.neverbreak();
966 self.expr(default, FixupContext::NONE);
967 }
968 self.word(";");
969 self.end();
970 self.hardbreak();
971 }
972
973 fn trait_item_fn(&mut self, trait_item: &TraitItemFn) {
974 self.outer_attrs(&trait_item.attrs);
975 self.cbox(INDENT);
976 self.signature(
977 &trait_item.sig,
978 #[cfg(feature = "verbatim")]
979 &verbatim::Safety::Disallowed,
980 );
981 if let Some(block) = &trait_item.default {
982 self.where_clause_for_body(&trait_item.sig.generics.where_clause);
983 self.word("{");
984 self.hardbreak_if_nonempty();
985 self.inner_attrs(&trait_item.attrs);
986 for stmt in block.stmts.iter().delimited() {
987 self.stmt(&stmt, stmt.is_last);
988 }
989 self.offset(-INDENT);
990 self.end();
991 self.word("}");
992 } else {
993 self.where_clause_semi(&trait_item.sig.generics.where_clause);
994 self.end();
995 }
996 self.hardbreak();
997 }
998
999 fn trait_item_type(&mut self, trait_item: &TraitItemType) {
1000 self.outer_attrs(&trait_item.attrs);
1001 self.cbox(INDENT);
1002 self.word("type ");
1003 self.ident(&trait_item.ident);
1004 self.generics(&trait_item.generics);
1005 for bound in trait_item.bounds.iter().delimited() {
1006 if bound.is_first {
1007 self.word(": ");
1008 } else {
1009 self.space();
1010 self.word("+ ");
1011 }
1012 self.type_param_bound(&bound);
1013 }
1014 if let Some((_eq_token, default)) = &trait_item.default {
1015 self.word(" = ");
1016 self.neverbreak();
1017 self.ibox(-INDENT);
1018 self.ty(default);
1019 self.end();
1020 }
1021 self.where_clause_oneline_semi(&trait_item.generics.where_clause);
1022 self.end();
1023 self.hardbreak();
1024 }
1025
1026 fn trait_item_macro(&mut self, trait_item: &TraitItemMacro) {
1027 self.outer_attrs(&trait_item.attrs);
1028 let semicolon = mac::requires_semi(&trait_item.mac.delimiter);
1029 self.mac(&trait_item.mac, None, semicolon);
1030 self.hardbreak();
1031 }
1032
1033 #[cfg(not(feature = "verbatim"))]
1034 fn trait_item_verbatim(&mut self, trait_item: &TokenStream) {
1035 if !trait_item.is_empty() {
1036 unimplemented!("TraitItem::Verbatim `{}`", trait_item);
1037 }
1038 self.hardbreak();
1039 }
1040
1041 #[cfg(feature = "verbatim")]
1042 fn trait_item_verbatim(&mut self, tokens: &TokenStream) {
1043 use syn::parse::{Parse, ParseStream, Result};
1044 use syn::{Attribute, Ident, Token, Visibility};
1045 use verbatim::{FlexibleItemConst, FlexibleItemType, WhereClauseLocation};
1046
1047 enum TraitItemVerbatim {
1048 Empty,
1049 Ellipsis,
1050 ConstFlexible(FlexibleItemConst),
1051 TypeFlexible(FlexibleItemType),
1052 PubOrDefault(PubOrDefaultTraitItem),
1053 }
1054
1055 struct PubOrDefaultTraitItem {
1056 attrs: Vec<Attribute>,
1057 vis: Visibility,
1058 defaultness: bool,
1059 trait_item: TraitItem,
1060 }
1061
1062 impl Parse for TraitItemVerbatim {
1063 fn parse(input: ParseStream) -> Result<Self> {
1064 if input.is_empty() {
1065 return Ok(TraitItemVerbatim::Empty);
1066 } else if input.peek(Token![...]) {
1067 input.parse::<Token![...]>()?;
1068 return Ok(TraitItemVerbatim::Ellipsis);
1069 }
1070
1071 let attrs = input.call(Attribute::parse_outer)?;
1072 let vis: Visibility = input.parse()?;
1073 let defaultness = input.parse::<Option<Token![default]>>()?.is_some();
1074
1075 let lookahead = input.lookahead1();
1076 if lookahead.peek(Token![const]) && (input.peek2(Ident) || input.peek2(Token![_])) {
1077 let flexible_item = FlexibleItemConst::parse(attrs, vis, defaultness, input)?;
1078 Ok(TraitItemVerbatim::ConstFlexible(flexible_item))
1079 } else if lookahead.peek(Token![type]) {
1080 let flexible_item = FlexibleItemType::parse(
1081 attrs,
1082 vis,
1083 defaultness,
1084 input,
1085 WhereClauseLocation::AfterEq,
1086 )?;
1087 Ok(TraitItemVerbatim::TypeFlexible(flexible_item))
1088 } else if (input.peek(Token![const])
1089 || lookahead.peek(Token![async])
1090 || lookahead.peek(Token![unsafe])
1091 || lookahead.peek(Token![extern])
1092 || lookahead.peek(Token![fn]))
1093 && (!matches!(vis, Visibility::Inherited) || defaultness)
1094 {
1095 Ok(TraitItemVerbatim::PubOrDefault(PubOrDefaultTraitItem {
1096 attrs,
1097 vis,
1098 defaultness,
1099 trait_item: input.parse()?,
1100 }))
1101 } else {
1102 Err(lookahead.error())
1103 }
1104 }
1105 }
1106
1107 let impl_item: TraitItemVerbatim = match syn::parse2(tokens.clone()) {
1108 Ok(impl_item) => impl_item,
1109 Err(_) => unimplemented!("TraitItem::Verbatim `{}`", tokens),
1110 };
1111
1112 match impl_item {
1113 TraitItemVerbatim::Empty => {
1114 self.hardbreak();
1115 }
1116 TraitItemVerbatim::Ellipsis => {
1117 self.word("...");
1118 self.hardbreak();
1119 }
1120 TraitItemVerbatim::ConstFlexible(trait_item) => {
1121 self.flexible_item_const(&trait_item);
1122 }
1123 TraitItemVerbatim::TypeFlexible(trait_item) => {
1124 self.flexible_item_type(&trait_item);
1125 }
1126 TraitItemVerbatim::PubOrDefault(trait_item) => {
1127 self.outer_attrs(&trait_item.attrs);
1128 self.visibility(&trait_item.vis);
1129 if trait_item.defaultness {
1130 self.word("default ");
1131 }
1132 self.trait_item(&trait_item.trait_item);
1133 }
1134 }
1135 }
1136
1137 fn impl_item(&mut self, impl_item: &ImplItem) {
1138 match impl_item {
1139 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
1140 ImplItem::Const(item) => self.impl_item_const(item),
1141 ImplItem::Fn(item) => self.impl_item_fn(item),
1142 ImplItem::Type(item) => self.impl_item_type(item),
1143 ImplItem::Macro(item) => self.impl_item_macro(item),
1144 ImplItem::Verbatim(item) => self.impl_item_verbatim(item),
1145 _ => unimplemented!("unknown ImplItem"),
1146 }
1147 }
1148
1149 fn impl_item_const(&mut self, impl_item: &ImplItemConst) {
1150 self.outer_attrs(&impl_item.attrs);
1151 self.cbox(0);
1152 self.visibility(&impl_item.vis);
1153 if impl_item.defaultness.is_some() {
1154 self.word("default ");
1155 }
1156 self.word("const ");
1157 self.ident(&impl_item.ident);
1158 self.generics(&impl_item.generics);
1159 self.word(": ");
1160 self.ty(&impl_item.ty);
1161 self.word(" = ");
1162 self.neverbreak();
1163 self.expr(&impl_item.expr, FixupContext::NONE);
1164 self.word(";");
1165 self.end();
1166 self.hardbreak();
1167 }
1168
1169 fn impl_item_fn(&mut self, impl_item: &ImplItemFn) {
1170 self.outer_attrs(&impl_item.attrs);
1171 self.cbox(INDENT);
1172 self.visibility(&impl_item.vis);
1173 if impl_item.defaultness.is_some() {
1174 self.word("default ");
1175 }
1176 self.signature(
1177 &impl_item.sig,
1178 #[cfg(feature = "verbatim")]
1179 &verbatim::Safety::Disallowed,
1180 );
1181 self.where_clause_for_body(&impl_item.sig.generics.where_clause);
1182 self.word("{");
1183 self.hardbreak_if_nonempty();
1184 self.inner_attrs(&impl_item.attrs);
1185 for stmt in impl_item.block.stmts.iter().delimited() {
1186 self.stmt(&stmt, stmt.is_last);
1187 }
1188 self.offset(-INDENT);
1189 self.end();
1190 self.word("}");
1191 self.hardbreak();
1192 }
1193
1194 fn impl_item_type(&mut self, impl_item: &ImplItemType) {
1195 self.outer_attrs(&impl_item.attrs);
1196 self.cbox(INDENT);
1197 self.visibility(&impl_item.vis);
1198 if impl_item.defaultness.is_some() {
1199 self.word("default ");
1200 }
1201 self.word("type ");
1202 self.ident(&impl_item.ident);
1203 self.generics(&impl_item.generics);
1204 self.word(" = ");
1205 self.neverbreak();
1206 self.ibox(-INDENT);
1207 self.ty(&impl_item.ty);
1208 self.end();
1209 self.where_clause_oneline_semi(&impl_item.generics.where_clause);
1210 self.end();
1211 self.hardbreak();
1212 }
1213
1214 fn impl_item_macro(&mut self, impl_item: &ImplItemMacro) {
1215 self.outer_attrs(&impl_item.attrs);
1216 let semicolon = mac::requires_semi(&impl_item.mac.delimiter);
1217 self.mac(&impl_item.mac, None, semicolon);
1218 self.hardbreak();
1219 }
1220
1221 #[cfg(not(feature = "verbatim"))]
1222 fn impl_item_verbatim(&mut self, impl_item: &TokenStream) {
1223 if !impl_item.is_empty() {
1224 unimplemented!("ImplItem::Verbatim `{}`", impl_item);
1225 }
1226 self.hardbreak();
1227 }
1228
1229 #[cfg(feature = "verbatim")]
1230 fn impl_item_verbatim(&mut self, tokens: &TokenStream) {
1231 use syn::parse::{Parse, ParseStream, Result};
1232 use syn::{Attribute, Ident, Token, Visibility};
1233 use verbatim::{FlexibleItemConst, FlexibleItemFn, FlexibleItemType, WhereClauseLocation};
1234
1235 enum ImplItemVerbatim {
1236 Empty,
1237 Ellipsis,
1238 ConstFlexible(FlexibleItemConst),
1239 FnFlexible(FlexibleItemFn),
1240 TypeFlexible(FlexibleItemType),
1241 }
1242
1243 impl Parse for ImplItemVerbatim {
1244 fn parse(input: ParseStream) -> Result<Self> {
1245 if input.is_empty() {
1246 return Ok(ImplItemVerbatim::Empty);
1247 } else if input.peek(Token![...]) {
1248 input.parse::<Token![...]>()?;
1249 return Ok(ImplItemVerbatim::Ellipsis);
1250 }
1251
1252 let attrs = input.call(Attribute::parse_outer)?;
1253 let vis: Visibility = input.parse()?;
1254 let defaultness = input.parse::<Option<Token![default]>>()?.is_some();
1255
1256 let lookahead = input.lookahead1();
1257 if lookahead.peek(Token![const]) && (input.peek2(Ident) || input.peek2(Token![_])) {
1258 let flexible_item = FlexibleItemConst::parse(attrs, vis, defaultness, input)?;
1259 Ok(ImplItemVerbatim::ConstFlexible(flexible_item))
1260 } else if input.peek(Token![const])
1261 || lookahead.peek(Token![async])
1262 || lookahead.peek(Token![unsafe])
1263 || lookahead.peek(Token![extern])
1264 || lookahead.peek(Token![fn])
1265 {
1266 let flexible_item = FlexibleItemFn::parse(attrs, vis, defaultness, input)?;
1267 Ok(ImplItemVerbatim::FnFlexible(flexible_item))
1268 } else if lookahead.peek(Token![type]) {
1269 let flexible_item = FlexibleItemType::parse(
1270 attrs,
1271 vis,
1272 defaultness,
1273 input,
1274 WhereClauseLocation::AfterEq,
1275 )?;
1276 Ok(ImplItemVerbatim::TypeFlexible(flexible_item))
1277 } else {
1278 Err(lookahead.error())
1279 }
1280 }
1281 }
1282
1283 let impl_item: ImplItemVerbatim = match syn::parse2(tokens.clone()) {
1284 Ok(impl_item) => impl_item,
1285 Err(_) => unimplemented!("ImplItem::Verbatim `{}`", tokens),
1286 };
1287
1288 match impl_item {
1289 ImplItemVerbatim::Empty => {
1290 self.hardbreak();
1291 }
1292 ImplItemVerbatim::Ellipsis => {
1293 self.word("...");
1294 self.hardbreak();
1295 }
1296 ImplItemVerbatim::ConstFlexible(impl_item) => {
1297 self.flexible_item_const(&impl_item);
1298 }
1299 ImplItemVerbatim::FnFlexible(impl_item) => {
1300 self.flexible_item_fn(&impl_item);
1301 }
1302 ImplItemVerbatim::TypeFlexible(impl_item) => {
1303 self.flexible_item_type(&impl_item);
1304 }
1305 }
1306 }
1307
1308 fn signature(
1309 &mut self,
1310 signature: &Signature,
1311 #[cfg(feature = "verbatim")] safety: &verbatim::Safety,
1312 ) {
1313 if signature.constness.is_some() {
1314 self.word("const ");
1315 }
1316 if signature.asyncness.is_some() {
1317 self.word("async ");
1318 }
1319 #[cfg(feature = "verbatim")]
1320 {
1321 if let verbatim::Safety::Disallowed = safety {
1322 if signature.unsafety.is_some() {
1323 self.word("unsafe ");
1324 }
1325 } else {
1326 self.safety(safety);
1327 }
1328 }
1329 #[cfg(not(feature = "verbatim"))]
1330 {
1331 if signature.unsafety.is_some() {
1332 self.word("unsafe ");
1333 }
1334 }
1335 if let Some(abi) = &signature.abi {
1336 self.abi(abi);
1337 }
1338 self.word("fn ");
1339 self.ident(&signature.ident);
1340 self.generics(&signature.generics);
1341 self.word("(");
1342 self.neverbreak();
1343 self.cbox(0);
1344 self.zerobreak();
1345 for input in signature.inputs.iter().delimited() {
1346 self.fn_arg(&input);
1347 let is_last = input.is_last && signature.variadic.is_none();
1348 self.trailing_comma(is_last);
1349 }
1350 if let Some(variadic) = &signature.variadic {
1351 self.variadic(variadic);
1352 self.zerobreak();
1353 }
1354 self.offset(-INDENT);
1355 self.end();
1356 self.word(")");
1357 self.cbox(-INDENT);
1358 self.return_type(&signature.output);
1359 self.end();
1360 }
1361
1362 fn fn_arg(&mut self, fn_arg: &FnArg) {
1363 match fn_arg {
1364 FnArg::Receiver(receiver) => self.receiver(receiver),
1365 FnArg::Typed(pat_type) => self.pat_type(pat_type),
1366 }
1367 }
1368
1369 fn receiver(&mut self, receiver: &Receiver) {
1370 self.outer_attrs(&receiver.attrs);
1371 if let Some((_ampersand, lifetime)) = &receiver.reference {
1372 self.word("&");
1373 if let Some(lifetime) = lifetime {
1374 self.lifetime(lifetime);
1375 self.nbsp();
1376 }
1377 }
1378 if receiver.mutability.is_some() {
1379 self.word("mut ");
1380 }
1381 self.word("self");
1382 if receiver.colon_token.is_some() {
1383 self.word(": ");
1384 self.ty(&receiver.ty);
1385 } else {
1386 let consistent = match (&receiver.reference, &receiver.mutability, &*receiver.ty) {
1387 (Some(_), mutability, Type::Reference(ty)) => {
1388 mutability.is_some() == ty.mutability.is_some()
1389 && match &*ty.elem {
1390 Type::Path(ty) => ty.qself.is_none() && ty.path.is_ident("Self"),
1391 _ => false,
1392 }
1393 }
1394 (None, _, Type::Path(ty)) => ty.qself.is_none() && ty.path.is_ident("Self"),
1395 _ => false,
1396 };
1397 if !consistent {
1398 self.word(": ");
1399 self.ty(&receiver.ty);
1400 }
1401 }
1402 }
1403
1404 fn variadic(&mut self, variadic: &Variadic) {
1405 self.outer_attrs(&variadic.attrs);
1406 if let Some((pat, _colon)) = &variadic.pat {
1407 self.pat(pat);
1408 self.word(": ");
1409 }
1410 self.word("...");
1411 }
1412
1413 fn static_mutability(&mut self, mutability: &StaticMutability) {
1414 match mutability {
1415 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
1416 StaticMutability::Mut(_) => self.word("mut "),
1417 StaticMutability::None => {}
1418 _ => unimplemented!("unknown StaticMutability"),
1419 }
1420 }
1421}
1422
1423#[cfg(feature = "verbatim")]
1424mod verbatim {
1425 use crate::algorithm::Printer;
1426 use crate::fixup::FixupContext;
1427 use crate::iter::IterDelimited;
1428 use crate::INDENT;
1429 use syn::ext::IdentExt;
1430 use syn::parse::{Parse, ParseStream, Result};
1431 use syn::{
1432 braced, token, Attribute, Block, Expr, Generics, Ident, Signature, StaticMutability, Stmt,
1433 Token, Type, TypeParamBound, Visibility, WhereClause,
1434 };
1435
1436 pub mod kw {
1437 syn::custom_keyword!(safe);
1438 }
1439
1440 pub struct FlexibleItemConst {
1441 pub attrs: Vec<Attribute>,
1442 pub vis: Visibility,
1443 pub defaultness: bool,
1444 pub ident: Ident,
1445 pub generics: Generics,
1446 pub ty: Type,
1447 pub value: Option<Expr>,
1448 }
1449
1450 pub struct FlexibleItemFn {
1451 pub attrs: Vec<Attribute>,
1452 pub vis: Visibility,
1453 pub defaultness: bool,
1454 pub safety: Safety,
1455 pub sig: Signature,
1456 pub body: Option<Vec<Stmt>>,
1457 }
1458
1459 pub struct FlexibleItemStatic {
1460 pub attrs: Vec<Attribute>,
1461 pub vis: Visibility,
1462 pub safety: Safety,
1463 pub mutability: StaticMutability,
1464 pub ident: Ident,
1465 pub ty: Option<Type>,
1466 pub expr: Option<Expr>,
1467 }
1468
1469 pub struct FlexibleItemType {
1470 pub attrs: Vec<Attribute>,
1471 pub vis: Visibility,
1472 pub defaultness: bool,
1473 pub ident: Ident,
1474 pub generics: Generics,
1475 pub bounds: Vec<TypeParamBound>,
1476 pub definition: Option<Type>,
1477 pub where_clause_after_eq: Option<WhereClause>,
1478 }
1479
1480 pub enum Safety {
1481 Unsafe,
1482 Safe,
1483 Default,
1484 Disallowed,
1485 }
1486
1487 pub enum WhereClauseLocation {
1488 // type Ty<T> where T: 'static = T;
1489 BeforeEq,
1490 // type Ty<T> = T where T: 'static;
1491 AfterEq,
1492 // TODO: goes away once the migration period on rust-lang/rust#89122 is over
1493 Both,
1494 }
1495
1496 impl FlexibleItemConst {
1497 pub fn parse(
1498 attrs: Vec<Attribute>,
1499 vis: Visibility,
1500 defaultness: bool,
1501 input: ParseStream,
1502 ) -> Result<Self> {
1503 input.parse::<Token![const]>()?;
1504 let ident = input.call(Ident::parse_any)?;
1505 let mut generics: Generics = input.parse()?;
1506 input.parse::<Token![:]>()?;
1507 let ty: Type = input.parse()?;
1508 let value = if input.parse::<Option<Token![=]>>()?.is_some() {
1509 let expr: Expr = input.parse()?;
1510 Some(expr)
1511 } else {
1512 None
1513 };
1514 generics.where_clause = input.parse()?;
1515 input.parse::<Token![;]>()?;
1516
1517 Ok(FlexibleItemConst {
1518 attrs,
1519 vis,
1520 defaultness,
1521 ident,
1522 generics,
1523 ty,
1524 value,
1525 })
1526 }
1527 }
1528
1529 impl FlexibleItemFn {
1530 pub fn parse(
1531 mut attrs: Vec<Attribute>,
1532 vis: Visibility,
1533 defaultness: bool,
1534 input: ParseStream,
1535 ) -> Result<Self> {
1536 let constness: Option<Token![const]> = input.parse()?;
1537 let asyncness: Option<Token![async]> = input.parse()?;
1538 let safety: Safety = input.parse()?;
1539
1540 let lookahead = input.lookahead1();
1541 let sig: Signature = if lookahead.peek(Token![extern]) || lookahead.peek(Token![fn]) {
1542 input.parse()?
1543 } else {
1544 return Err(lookahead.error());
1545 };
1546
1547 let lookahead = input.lookahead1();
1548 let body = if lookahead.peek(Token![;]) {
1549 input.parse::<Token![;]>()?;
1550 None
1551 } else if lookahead.peek(token::Brace) {
1552 let content;
1553 braced!(content in input);
1554 attrs.extend(content.call(Attribute::parse_inner)?);
1555 Some(content.call(Block::parse_within)?)
1556 } else {
1557 return Err(lookahead.error());
1558 };
1559
1560 Ok(FlexibleItemFn {
1561 attrs,
1562 vis,
1563 defaultness,
1564 safety,
1565 sig: Signature {
1566 constness,
1567 asyncness,
1568 unsafety: None,
1569 ..sig
1570 },
1571 body,
1572 })
1573 }
1574 }
1575
1576 impl FlexibleItemStatic {
1577 pub fn parse(attrs: Vec<Attribute>, vis: Visibility, input: ParseStream) -> Result<Self> {
1578 let safety: Safety = input.parse()?;
1579 input.parse::<Token![static]>()?;
1580 let mutability: StaticMutability = input.parse()?;
1581 let ident = input.parse()?;
1582
1583 let lookahead = input.lookahead1();
1584 let has_type = lookahead.peek(Token![:]);
1585 let has_expr = lookahead.peek(Token![=]);
1586 if !has_type && !has_expr {
1587 return Err(lookahead.error());
1588 }
1589
1590 let ty: Option<Type> = if has_type {
1591 input.parse::<Token![:]>()?;
1592 input.parse().map(Some)?
1593 } else {
1594 None
1595 };
1596
1597 let expr: Option<Expr> = if input.parse::<Option<Token![=]>>()?.is_some() {
1598 input.parse().map(Some)?
1599 } else {
1600 None
1601 };
1602
1603 input.parse::<Token![;]>()?;
1604
1605 Ok(FlexibleItemStatic {
1606 attrs,
1607 vis,
1608 safety,
1609 mutability,
1610 ident,
1611 ty,
1612 expr,
1613 })
1614 }
1615 }
1616
1617 impl FlexibleItemType {
1618 pub fn parse(
1619 attrs: Vec<Attribute>,
1620 vis: Visibility,
1621 defaultness: bool,
1622 input: ParseStream,
1623 where_clause_location: WhereClauseLocation,
1624 ) -> Result<Self> {
1625 input.parse::<Token![type]>()?;
1626 let ident: Ident = input.parse()?;
1627 let mut generics: Generics = input.parse()?;
1628
1629 let mut bounds = Vec::new();
1630 if input.parse::<Option<Token![:]>>()?.is_some() {
1631 loop {
1632 if input.peek(Token![where]) || input.peek(Token![=]) || input.peek(Token![;]) {
1633 break;
1634 }
1635 bounds.push(input.parse::<TypeParamBound>()?);
1636 if input.peek(Token![where]) || input.peek(Token![=]) || input.peek(Token![;]) {
1637 break;
1638 }
1639 input.parse::<Token![+]>()?;
1640 }
1641 }
1642
1643 match where_clause_location {
1644 WhereClauseLocation::BeforeEq | WhereClauseLocation::Both => {
1645 generics.where_clause = input.parse()?;
1646 }
1647 WhereClauseLocation::AfterEq => {}
1648 }
1649
1650 let definition = if input.parse::<Option<Token![=]>>()?.is_some() {
1651 Some(input.parse()?)
1652 } else {
1653 None
1654 };
1655
1656 let where_clause_after_eq = match where_clause_location {
1657 WhereClauseLocation::AfterEq | WhereClauseLocation::Both
1658 if generics.where_clause.is_none() =>
1659 {
1660 input.parse()?
1661 }
1662 _ => None,
1663 };
1664
1665 input.parse::<Token![;]>()?;
1666
1667 Ok(FlexibleItemType {
1668 attrs,
1669 vis,
1670 defaultness,
1671 ident,
1672 generics,
1673 bounds,
1674 definition,
1675 where_clause_after_eq,
1676 })
1677 }
1678 }
1679
1680 impl Parse for Safety {
1681 fn parse(input: ParseStream) -> Result<Self> {
1682 if input.peek(Token![unsafe]) {
1683 input.parse::<Token![unsafe]>()?;
1684 Ok(Safety::Unsafe)
1685 } else if input.peek(kw::safe) {
1686 input.parse::<kw::safe>()?;
1687 Ok(Safety::Safe)
1688 } else {
1689 Ok(Safety::Default)
1690 }
1691 }
1692 }
1693
1694 impl Printer {
1695 pub fn flexible_item_const(&mut self, item: &FlexibleItemConst) {
1696 self.outer_attrs(&item.attrs);
1697 self.cbox(INDENT);
1698 self.visibility(&item.vis);
1699 if item.defaultness {
1700 self.word("default ");
1701 }
1702 self.word("const ");
1703 self.ident(&item.ident);
1704 self.generics(&item.generics);
1705 self.word(": ");
1706 self.cbox(-INDENT);
1707 self.ty(&item.ty);
1708 self.end();
1709 if let Some(value) = &item.value {
1710 self.word(" = ");
1711 self.neverbreak();
1712 self.ibox(-INDENT);
1713 self.expr(value, FixupContext::NONE);
1714 self.end();
1715 }
1716 self.where_clause_oneline_semi(&item.generics.where_clause);
1717 self.end();
1718 self.hardbreak();
1719 }
1720
1721 pub fn flexible_item_fn(&mut self, item: &FlexibleItemFn) {
1722 self.outer_attrs(&item.attrs);
1723 self.cbox(INDENT);
1724 self.visibility(&item.vis);
1725 if item.defaultness {
1726 self.word("default ");
1727 }
1728 self.signature(&item.sig, &item.safety);
1729 if let Some(body) = &item.body {
1730 self.where_clause_for_body(&item.sig.generics.where_clause);
1731 self.word("{");
1732 self.hardbreak_if_nonempty();
1733 self.inner_attrs(&item.attrs);
1734 for stmt in body.iter().delimited() {
1735 self.stmt(&stmt, stmt.is_last);
1736 }
1737 self.offset(-INDENT);
1738 self.end();
1739 self.word("}");
1740 } else {
1741 self.where_clause_semi(&item.sig.generics.where_clause);
1742 self.end();
1743 }
1744 self.hardbreak();
1745 }
1746
1747 pub fn flexible_item_static(&mut self, item: &FlexibleItemStatic) {
1748 self.outer_attrs(&item.attrs);
1749 self.cbox(0);
1750 self.visibility(&item.vis);
1751 self.safety(&item.safety);
1752 self.word("static ");
1753 self.static_mutability(&item.mutability);
1754 self.ident(&item.ident);
1755 if let Some(ty) = &item.ty {
1756 self.word(": ");
1757 self.ty(ty);
1758 }
1759 if let Some(expr) = &item.expr {
1760 self.word(" = ");
1761 self.neverbreak();
1762 self.expr(expr, FixupContext::NONE);
1763 }
1764 self.word(";");
1765 self.end();
1766 self.hardbreak();
1767 }
1768
1769 pub fn flexible_item_type(&mut self, item: &FlexibleItemType) {
1770 self.outer_attrs(&item.attrs);
1771 self.cbox(INDENT);
1772 self.visibility(&item.vis);
1773 if item.defaultness {
1774 self.word("default ");
1775 }
1776 self.word("type ");
1777 self.ident(&item.ident);
1778 self.generics(&item.generics);
1779 for bound in item.bounds.iter().delimited() {
1780 if bound.is_first {
1781 self.word(": ");
1782 } else {
1783 self.space();
1784 self.word("+ ");
1785 }
1786 self.type_param_bound(&bound);
1787 }
1788 if let Some(definition) = &item.definition {
1789 self.where_clause_oneline(&item.generics.where_clause);
1790 self.word("= ");
1791 self.neverbreak();
1792 self.ibox(-INDENT);
1793 self.ty(definition);
1794 self.end();
1795 self.where_clause_oneline_semi(&item.where_clause_after_eq);
1796 } else {
1797 self.where_clause_oneline_semi(&item.generics.where_clause);
1798 }
1799 self.end();
1800 self.hardbreak();
1801 }
1802
1803 pub fn safety(&mut self, safety: &Safety) {
1804 match safety {
1805 Safety::Unsafe => self.word("unsafe "),
1806 Safety::Safe => self.word("safe "),
1807 Safety::Default => {}
1808 Safety::Disallowed => unreachable!(),
1809 }
1810 }
1811 }
1812}
1813

Provided by KDAB

Privacy Policy